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_filter.hxx"
26 #include <osl/endian.h>
27 #include <vcl/svapp.hxx>
28 #include <unotools/tempfile.hxx>
29 #include <math.h>
30 #include <editeng/eeitem.hxx>
31 #include <sot/storage.hxx>
32 #include <sot/storinfo.hxx>
33 #include <sot/stg.hxx>
34 #include <com/sun/star/embed/Aspects.hpp>
35 #include <com/sun/star/office/XAnnotation.hpp>
36 #include <com/sun/star/office/XAnnotationAccess.hpp>
37 #include <com/sun/star/text/XText.hpp>
38 #include <com/sun/star/geometry/RealPoint2D.hpp>
39 #include <com/sun/star/util/DateTime.hpp>
40 #include <com/sun/star/drawing/BitmapMode.hpp>
41 #include <unotools/streamwrap.hxx>
42 #include <filter/msfilter/svdfppt.hxx>
43 #include <svx/xpoly.hxx>
44 #include <svx/svdtrans.hxx>
45 #include <svx/svdmodel.hxx>
46 #include <svx/svdpage.hxx>
47 #include <svx/svdobj.hxx>
48 #include <svx/svdogrp.hxx>
49 #include <svx/svdorect.hxx>
50 #include <svx/svdopage.hxx>
51 #include <svx/svdograf.hxx>
52 #include <svx/svdopath.hxx>
53 #include <svx/svdocirc.hxx>
54 #include <svx/svdocapt.hxx>
55 #include <svx/svdotable.hxx>
56 #include <editeng/outlobj.hxx>
57 #include <svx/svdattr.hxx>
58 #include "svx/xattr.hxx"
59 #include "svx/svditext.hxx"
60 #include <svx/svdetc.hxx>
61 #include <editeng/bulitem.hxx>
62 #include <svx/polysc3d.hxx>
63 #include <svx/extrud3d.hxx>
64 #include <svx/svdoashp.hxx>
65 #include <editeng/tstpitem.hxx>
66 #include <editeng/unoprnms.hxx>
67 #include <editeng/editids.hrc>
68
69 #if defined(JOEENV) && defined(JOEDEBUG)
70 #include "impinccv.h" // etwas Testkram
71 #endif
72
73 #if defined(DBG_EXTRACTOLEOBJECTS) || defined(DBG_EXTRACTFONTMETRICS)
74 #include <tools/urlobj.hxx>
75 #include <unotools/localfilehelper.hxx>
76 #endif
77
78 #define ITEMVALUE(ItemSet,Id,Cast) ((const Cast&)(ItemSet).Get(Id)).GetValue()
79 #include <editeng/adjitem.hxx>
80 #include <editeng/escpitem.hxx>
81 #include <editeng/colritem.hxx>
82 #include <editeng/fhgtitem.hxx>
83 #include <editeng/wghtitem.hxx>
84 #include <editeng/postitem.hxx>
85 #include <editeng/udlnitem.hxx>
86 #include <editeng/crsditem.hxx>
87 #include <editeng/shdditem.hxx>
88 #include <editeng/charreliefitem.hxx>
89 #include <editeng/fontitem.hxx>
90 #include <svx/svdoutl.hxx>
91 #include <editeng/editeng.hxx>
92 #include <editeng/lspcitem.hxx>
93 #include <editeng/ulspitem.hxx>
94 #include <editeng/lrspitem.hxx>
95 #include <vcl/metric.hxx>
96 #include <vcl/bmpacc.hxx>
97 #include <svx/svditer.hxx>
98 #include <svx/svdoedge.hxx>
99 #include <svx/sxekitm.hxx>
100 #include <editeng/flditem.hxx>
101 #include <svtools/sychconv.hxx>
102 #include <tools/zcodec.hxx>
103 #include <filter/msfilter/svxmsbas.hxx>
104 #include <sfx2/objsh.hxx>
105 #include <editeng/brshitem.hxx>
106 #include <editeng/langitem.hxx>
107 #include <svx/svdoole2.hxx>
108 #include <svx/unoapi.hxx>
109 #include <toolkit/unohlp.hxx>
110 #include <com/sun/star/container/XIndexContainer.hpp>
111 #include <com/sun/star/drawing/XShapes.hpp>
112 #include <com/sun/star/drawing/XControlShape.hpp>
113 #include <com/sun/star/form/XFormComponent.hpp>
114 #include <com/sun/star/beans/XPropertySet.hpp>
115 #include <com/sun/star/drawing/XDrawPagesSupplier.hpp>
116 #include <com/sun/star/drawing/XMasterPagesSupplier.hpp>
117 #include <com/sun/star/drawing/XDrawPageSupplier.hpp>
118 #include <com/sun/star/awt/Size.hpp>
119 #include <com/sun/star/awt/Point.hpp>
120 #include <com/sun/star/drawing/FillStyle.hpp>
121 #include <com/sun/star/drawing/TextVerticalAdjust.hpp>
122 #include <editeng/writingmodeitem.hxx>
123 #include <vcl/print.hxx>
124 #include <editeng/svxfont.hxx>
125 #include <editeng/frmdiritem.hxx>
126 #include <svx/sdtfchim.hxx>
127 #include <unotools/ucbstreamhelper.hxx>
128 #include <editeng/scripttypeitem.hxx>
129 #include "com/sun/star/awt/Gradient.hpp"
130 #include <com/sun/star/table/XMergeableCellRange.hpp>
131 #include <com/sun/star/table/BorderLine.hpp>
132 #include <vcl/virdev.hxx>
133 #include <algorithm>
134 #include <set>
135
136 ////////////////////////////////////////////////////////////////////////////////////////////////////
137
138 // PPT ColorScheme Slots
139 #define PPT_COLSCHEME (0x08000000)
140 #define PPT_COLSCHEME_HINTERGRUND (0x08000000)
141 #define PPT_COLSCHEME_TEXT_UND_ZEILEN (0x08000001)
142 #define PPT_COLSCHEME_SCHATTEN (0x08000002)
143 #define PPT_COLSCHEME_TITELTEXT (0x08000003)
144 #define PPT_COLSCHEME_FUELLBEREICHE (0x08000004)
145 #define PPT_COLSCHEME_AKZENT (0x08000005)
146 #define PPT_COLSCHEME_A_UND_HYPERLINK (0x08000006)
147 #define PPT_COLSCHEME_A_H_GESICHERT (0x08000007)
148
149 ////////////////////////////////////////////////////////////////////////////////////////////////////
150
151 #define ANSI_CHARSET 0
152 #define DEFAULT_CHARSET 1
153 #define SYMBOL_CHARSET 2
154 #define SHIFTJIS_CHARSET 128
155 #define HANGEUL_CHARSET 129
156 #define CHINESEBIG5_CHARSET 136
157 #define OEM_CHARSET 255
158
159 ////////////////////////////////////////////////////////////////////////////////////////////////////
160
161 /* Font Families */
162 #define FF_DONTCARE 0x00
163 #define FF_ROMAN 0x10
164 #define FF_SWISS 0x20
165 #define FF_MODERN 0x30
166 #define FF_SCRIPT 0x40
167 #define FF_DECORATIVE 0x50
168
169 ////////////////////////////////////////////////////////////////////////////////////////////////////
170
171 #define DEFAULT_PITCH 0x00
172 #define FIXED_PITCH 0x01
173 #define VARIABLE_PITCH 0x02
174
175 using namespace ::com::sun::star ;
176 using namespace uno ;
177 using namespace beans ;
178 using namespace drawing ;
179 using namespace container ;
180 using namespace table ;
181
182 ////////////////////////////////////////////////////////////////////////////////////////////////////
183
PowerPointImportParam(SvStream & rDocStrm,sal_uInt32 nFlags,MSFilterTracer * pT)184 PowerPointImportParam::PowerPointImportParam( SvStream& rDocStrm, sal_uInt32 nFlags, MSFilterTracer* pT ) :
185 rDocStream ( rDocStrm ),
186 nImportFlags ( nFlags ),
187 pTracer ( pT )
188 {
189 }
190
191 ////////////////////////////////////////////////////////////////////////////////////////////////////
192
operator >>(SvStream & rIn,PptCurrentUserAtom & rAtom)193 SvStream& operator>>( SvStream& rIn, PptCurrentUserAtom& rAtom )
194 {
195 DffRecordHeader aHd;
196 rIn >> aHd;
197 if ( aHd.nRecType == PPT_PST_CurrentUserAtom )
198 {
199 sal_uInt32 nLen;
200 sal_uInt16 nUserNameLen, nPad;
201 rIn >> nLen
202 >> rAtom.nMagic
203 >> rAtom.nCurrentUserEdit
204 >> nUserNameLen
205 >> rAtom.nDocFileVersion
206 >> rAtom.nMajorVersion
207 >> rAtom.nMinorVersion
208 >> nPad;
209 SvxMSDffManager::MSDFFReadZString( rIn, rAtom.aCurrentUser, nUserNameLen, sal_True );
210 }
211 aHd.SeekToEndOfRecord( rIn );
212 return rIn;
213 }
214
Clear()215 void PptSlidePersistAtom::Clear()
216 {
217 nReserved = nPsrReference = nFlags = nNumberTexts = nSlideId = 0;
218 }
219
operator >>(SvStream & rIn,PptSlidePersistAtom & rAtom)220 SvStream& operator>>( SvStream& rIn, PptSlidePersistAtom& rAtom )
221 {
222 DffRecordHeader aHd;
223 rIn >> aHd
224 >> rAtom.nPsrReference
225 >> rAtom.nFlags
226 >> rAtom.nNumberTexts
227 >> rAtom.nSlideId;
228 // >> rAtom.nReserved;
229 aHd.SeekToEndOfRecord( rIn );
230 return rIn;
231 }
232
233 SV_IMPL_PTRARR(_PptSlidePersistList,PptSlidePersistEntry*);
234
FindPage(sal_uInt32 nId) const235 sal_uInt16 PptSlidePersistList::FindPage(sal_uInt32 nId) const
236 {
237 for ( sal_uInt16 i=0; i < Count(); i++ )
238 {
239 if (operator[](i)->GetSlideId()==nId) return i;
240 }
241 return PPTSLIDEPERSIST_ENTRY_NOTFOUND;
242 }
243
244 ////////////////////////////////////////////////////////////////////////////////////////////////////
245
operator >>(SvStream & rIn,PptInteractiveInfoAtom & rAtom)246 SvStream& operator>>( SvStream& rIn, PptInteractiveInfoAtom& rAtom )
247 {
248 rIn >> rAtom.nSoundRef
249 >> rAtom.nExHyperlinkId
250 >> rAtom.nAction
251 >> rAtom.nOleVerb
252 >> rAtom.nJump
253 >> rAtom.nFlags
254 >> rAtom.nHyperlinkType
255 >> rAtom.nUnknown1
256 >> rAtom.nUnknown2
257 >> rAtom.nUnknown3;
258 return rIn;
259 }
260
operator >>(SvStream & rIn,PptExOleObjAtom & rAtom)261 SvStream& operator>>( SvStream& rIn, PptExOleObjAtom& rAtom )
262 {
263 rIn >> rAtom.nAspect
264 >> rAtom.nDummy1
265 >> rAtom.nId
266 >> rAtom.nDummy2
267 >> rAtom.nPersistPtr
268 >> rAtom.nDummy4;
269 return rIn;
270 }
271
GetPageSize(const Size & rSiz) const272 Size PptDocumentAtom::GetPageSize(const Size& rSiz) const
273 {
274 return rSiz;
275 /*
276 Size aRet;
277 switch ( eSlidesPageFormat )
278 {
279 // Wenn man in Powerpoint als Seitenformat "Bildschirmgroesse"
280 // einstellt, dann zeigt dieser Dialog zwar 24x18cm an, die
281 // angezeigte Seite ist aber anders. Das sieht man, wenn man
282 // ein Rechteck seitenfuellend aufzieht und sich dessen Groesse
283 // ansieht. Die importierten Abmessungen sind auf jeden Fall
284 // die, die auch im Ppt-File stehen. Ich denke, das es sich
285 // hier eher um ein Bug in PowerPoint handelt, das im
286 // Seitenformat-Dialog bei "Bildschirmgroesse" falsche Masse
287 // angezeigt werden (vielleicht ja auch bildschirmabhaengig?).
288 // case PPTPF_SCREEN : aRet.Width()=4082; aRet.Height()=5443; break;
289 case PPTPF_USLETTER: aRet.Width()=4896; aRet.Height()=6336; break;
290 case PPTPF_A4 : aRet.Width()=4762; aRet.Height()=6735; break;
291 // case PPTPF_35MMDIA : aRet.Width()=4082; aRet.Height()=6123; break;
292 // case PPTPF_OVERHEAD: aRet.Width()=4082; aRet.Height()=5443; break;
293 }
294 if ( aRet.Width() )
295 {
296 if ( rSiz.Width() > rSiz.Height() )
297 { // Querformat
298 long nMerk = aRet.Width();
299 aRet.Width() = aRet.Height();
300 aRet.Height() = nMerk;
301 }
302 }
303 else // CustomFormat oder Unbekannt oder Screen,Dia,Overhead
304 aRet = rSiz;
305 return aRet;
306 */
307 }
308
operator >>(SvStream & rIn,PptDocumentAtom & rAtom)309 SvStream& operator>>(SvStream& rIn, PptDocumentAtom& rAtom)
310 {
311 // Tatsaechliches Format:
312 // 00 aSlidePageSizeXY 8
313 // 08 aNotesPageSizeXY 8
314 // 16 aZoomRatio (OLE) 8
315 // 24 nNotesMasterPersist 4
316 // 28 nHandoutMasterPersist 4
317 // 32 n1stPageNumber 2
318 // 34 ePageFormat 2
319 // 36 bEmbeddedTrueType 1
320 // 37 bOmitTitlePlace 1
321 // 38 bRightToLeft 1
322 // 39 bShowComments 1
323
324 DffRecordHeader aHd;
325 sal_Int32 nSlideX,nSlideY, nNoticeX, nNoticeY, nDummy;
326 sal_uInt16 nSlidePageFormat;
327 sal_Int8 nEmbeddedTrueType, nTitlePlaceHoldersOmitted, nRightToLeft, nShowComments;
328
329 rIn >> aHd
330 >> nSlideX >> nSlideY
331 >> nNoticeX >> nNoticeY
332 >> nDummy >> nDummy // ZoomRation ueberspringen
333 >> rAtom.nNotesMasterPersist
334 >> rAtom.nHandoutMasterPersist
335 >> rAtom.n1stPageNumber
336 >> nSlidePageFormat
337 >> nEmbeddedTrueType
338 >> nTitlePlaceHoldersOmitted
339 >> nRightToLeft
340 >> nShowComments;
341 rAtom.aSlidesPageSize.Width() = nSlideX;
342 rAtom.aSlidesPageSize.Height() = nSlideY;
343 rAtom.aNotesPageSize.Width() = nNoticeX;
344 rAtom.aNotesPageSize.Height() = nNoticeY;
345 rAtom.eSlidesPageFormat = (PptPageFormat)nSlidePageFormat;
346 rAtom.bEmbeddedTrueType = nEmbeddedTrueType;
347 rAtom.bTitlePlaceholdersOmitted = nTitlePlaceHoldersOmitted;
348 rAtom.bRightToLeft = nRightToLeft;
349 rAtom.bShowComments = nShowComments;
350 aHd.SeekToEndOfRecord( rIn );
351 return rIn;
352 }
353
354 ////////////////////////////////////////////////////////////////////////////////////////////////////
355
Clear()356 void PptSlideLayoutAtom::Clear()
357 {
358 eLayout = 0;
359 for ( sal_uInt16 i = 0; i < 8; i++ )
360 {
361 aPlaceholderId[ i ] = 0;
362 aPlacementId[ i ] = 0;
363 }
364 }
365
operator >>(SvStream & rIn,PptSlideLayoutAtom & rAtom)366 SvStream& operator>>( SvStream& rIn, PptSlideLayoutAtom& rAtom )
367 {
368 rIn >> rAtom.eLayout;
369 rIn.Read( rAtom.aPlaceholderId, 8 );
370 return rIn;
371 }
372
373 ////////////////////////////////////////////////////////////////////////////////////////////////////
374
operator >>(SvStream & rIn,PptSlideAtom & rAtom)375 SvStream& operator>>( SvStream& rIn, PptSlideAtom& rAtom )
376 {
377 DffRecordHeader aHd;
378 rIn >> aHd
379 >> rAtom.aLayout
380 >> rAtom.nMasterId
381 >> rAtom.nNotesId
382 >> rAtom.nFlags;
383 aHd.SeekToEndOfRecord( rIn );
384 return rIn;
385 }
386
Clear()387 void PptSlideAtom::Clear()
388 {
389 nMasterId = nNotesId = 0;
390 nFlags = 0;
391 }
392
393 ////////////////////////////////////////////////////////////////////////////////////////////////////
394
operator >>(SvStream & rIn,PptNotesAtom & rAtom)395 SvStream& operator>>( SvStream& rIn, PptNotesAtom& rAtom )
396 {
397 DffRecordHeader aHd;
398 rIn >> aHd
399 >> rAtom.nSlideId
400 >> rAtom.nFlags;
401 aHd.SeekToEndOfRecord( rIn );
402 return rIn;
403 }
404
Clear()405 void PptNotesAtom::Clear()
406 {
407 nSlideId = 0;
408 nFlags = 0;
409 }
410
411 ////////////////////////////////////////////////////////////////////////////////////////////////////
412
Clear()413 void PptColorSchemeAtom::Clear()
414 {
415 memset(&aData[0], 0, 32);
416 }
417
GetColor(sal_uInt16 nNum) const418 Color PptColorSchemeAtom::GetColor( sal_uInt16 nNum ) const
419 {
420 Color aRetval;
421 if ( nNum < 8 )
422 {
423 nNum <<= 2;
424 aRetval.SetRed( aData[ nNum++ ] );
425 aRetval.SetGreen( aData[ nNum++ ] );
426 aRetval.SetBlue( aData[ nNum++ ] );
427 }
428 return aRetval;
429 }
430
operator >>(SvStream & rIn,PptColorSchemeAtom & rAtom)431 SvStream& operator>>( SvStream& rIn, PptColorSchemeAtom& rAtom )
432 {
433 DffRecordHeader aHd;
434 rIn >> aHd;
435 rIn.Read( rAtom.aData, 32 );
436 aHd.SeekToEndOfRecord( rIn );
437 return rIn;
438 }
439
440 ////////////////////////////////////////////////////////////////////////////////////////////////////
441
operator >>(SvStream & rIn,PptFontEntityAtom & rAtom)442 SvStream& operator>>( SvStream& rIn, PptFontEntityAtom& rAtom )
443 {
444 DffRecordHeader aHd;
445 rIn >> aHd;
446 sal_Unicode nTemp, cData[ 32 ];
447 rIn.Read( cData, 64 );
448
449 sal_uInt8 lfCharset, lfPitchAndFamily;
450
451 rIn >> lfCharset
452 >> rAtom.lfClipPrecision
453 >> rAtom.lfQuality
454 >> lfPitchAndFamily;
455
456 switch( lfCharset )
457 {
458 case SYMBOL_CHARSET :
459 rAtom.eCharSet = RTL_TEXTENCODING_SYMBOL;
460 break;
461 case ANSI_CHARSET :
462 rAtom.eCharSet = RTL_TEXTENCODING_MS_1252;
463 break;
464
465 // case DEFAULT_CHARSET :
466 // case SHIFTJIS_CHARSET :
467 // case HANGEUL_CHARSET :
468 // case CHINESEBIG5_CHARSET :
469 // case OEM_CHARSET :
470 default :
471 rAtom.eCharSet = gsl_getSystemTextEncoding();
472 }
473 switch ( lfPitchAndFamily & 0xf0 )
474 {
475 case FF_ROMAN:
476 rAtom.eFamily = FAMILY_ROMAN;
477 break;
478
479 case FF_SWISS:
480 rAtom.eFamily = FAMILY_SWISS;
481 break;
482
483 case FF_MODERN:
484 rAtom.eFamily = FAMILY_MODERN;
485 break;
486
487 case FF_SCRIPT:
488 rAtom.eFamily = FAMILY_SCRIPT;
489 break;
490
491 case FF_DECORATIVE:
492 rAtom.eFamily = FAMILY_DECORATIVE;
493 break;
494
495 default:
496 rAtom.eFamily = FAMILY_DONTKNOW;
497 break;
498 }
499
500 switch ( lfPitchAndFamily & 0x0f )
501 {
502 case FIXED_PITCH:
503 rAtom.ePitch = PITCH_FIXED;
504 break;
505
506 case DEFAULT_PITCH:
507 case VARIABLE_PITCH:
508 default:
509 rAtom.ePitch = PITCH_VARIABLE;
510 break;
511 }
512 sal_uInt16 i;
513 for ( i = 0; i < 32; i++ )
514 {
515 nTemp = cData[ i ];
516 if ( !nTemp )
517 break;
518 #ifdef OSL_BIGENDIAN
519 cData[ i ] = ( nTemp >> 8 ) | ( nTemp << 8 );
520 #endif
521 }
522 rAtom.aName = String( cData, i );
523 OutputDevice* pDev = (OutputDevice*)Application::GetDefaultDevice();
524 rAtom.bAvailable = pDev->IsFontAvailable( rAtom.aName );
525 aHd.SeekToEndOfRecord( rIn );
526 return rIn;
527 }
528
529 SV_DECL_PTRARR_DEL( PptFontEntityAtomList, PptFontEntityAtom*, 16, 16 )
530 SV_IMPL_PTRARR( PptFontEntityAtomList, PptFontEntityAtom* );
531
532 class PptFontCollection: public PptFontEntityAtomList {
533 };
534
535 ////////////////////////////////////////////////////////////////////////////////////////////////////
536
operator >>(SvStream & rIn,PptUserEditAtom & rAtom)537 SvStream& operator>>( SvStream& rIn, PptUserEditAtom& rAtom )
538 {
539 rIn >> rAtom.aHd
540 >> rAtom.nLastSlideID
541 >> rAtom.nVersion
542 >> rAtom.nOffsetLastEdit
543 >> rAtom.nOffsetPersistDirectory
544 >> rAtom.nDocumentRef
545 >> rAtom.nMaxPersistWritten
546 >> rAtom.eLastViewType;
547 rAtom.aHd.SeekToEndOfRecord(rIn);
548 return rIn;
549 }
550
551 ////////////////////////////////////////////////////////////////////////////////////////////////////
552
Clear()553 void PptOEPlaceholderAtom::Clear()
554 {
555 nPlacementId = 0;
556 nPlaceholderSize = nPlaceholderId = 0;
557 }
558
operator >>(SvStream & rIn,PptOEPlaceholderAtom & rAtom)559 SvStream& operator>>( SvStream& rIn, PptOEPlaceholderAtom& rAtom )
560 {
561 rIn >> rAtom.nPlacementId
562 >> rAtom.nPlaceholderId
563 >> rAtom.nPlaceholderSize;
564 return rIn;
565 }
566
567 ////////////////////////////////////////////////////////////////////////////////////////////////////
568
PptSlidePersistEntry()569 PptSlidePersistEntry::PptSlidePersistEntry() :
570 pStyleSheet ( NULL ),
571 pHeaderFooterEntry ( NULL ),
572 pSolverContainer ( NULL ),
573 nSlidePersistStartOffset( 0 ),
574 nSlidePersistEndOffset ( 0 ),
575 nBackgroundOffset ( 0 ),
576 nDrawingDgId ( 0xffffffff ),
577 pPresentationObjects ( NULL ),
578 pBObj ( NULL ),
579 bBObjIsTemporary ( sal_True ),
580 ePageKind ( PPT_MASTERPAGE ),
581 bNotesMaster ( sal_False ),
582 bHandoutMaster ( sal_False ),
583 bStarDrawFiller ( sal_False )
584 {
585 HeaderFooterOfs[ 0 ] = HeaderFooterOfs[ 1 ] = HeaderFooterOfs[ 2 ] = HeaderFooterOfs[ 3 ] = 0;
586 }
587
588
~PptSlidePersistEntry()589 PptSlidePersistEntry::~PptSlidePersistEntry()
590 {
591 delete pStyleSheet;
592 delete pHeaderFooterEntry;
593 delete pSolverContainer;
594 delete[] pPresentationObjects;
595 };
596
597 ////////////////////////////////////////////////////////////////////////////////////////////////////
598 ////////////////////////////////////////////////////////////////////////////////////////////////////
599 ////////////////////////////////////////////////////////////////////////////////////////////////////
600
SdrEscherImport(PowerPointImportParam & rParam,const String & rBaseURL)601 SdrEscherImport::SdrEscherImport( PowerPointImportParam& rParam, const String& rBaseURL ) :
602 SvxMSDffManager ( rParam.rDocStream, rBaseURL, rParam.pTracer ),
603 pFonts ( NULL ),
604 nStreamLen ( 0 ),
605 nTextStylesIndex ( 0xffff ),
606 eCharSetSystem ( gsl_getSystemTextEncoding() ),
607 bWingdingsChecked ( sal_False ),
608 bWingdingsAvailable ( sal_False ),
609 bMonotypeSortsChecked ( sal_False ),
610 bMonotypeSortsAvailable ( sal_False ),
611 bTimesNewRomanChecked ( sal_False ),
612 bTimesNewRomanAvailable ( sal_False ),
613 rImportParam ( rParam )
614 {
615 }
616
~SdrEscherImport()617 SdrEscherImport::~SdrEscherImport()
618 {
619 void* pPtr;
620 for ( pPtr = aOleObjectList.First(); pPtr; pPtr = aOleObjectList.Next() )
621 delete (PPTOleEntry*)pPtr;
622 delete pFonts;
623 }
624
GetSlideLayoutAtom() const625 const PptSlideLayoutAtom* SdrEscherImport::GetSlideLayoutAtom() const
626 {
627 return NULL;
628 }
629
ReadString(String & rStr) const630 sal_Bool SdrEscherImport::ReadString( String& rStr ) const
631 {
632 sal_Bool bRet = sal_False;
633 DffRecordHeader aStrHd;
634 rStCtrl >> aStrHd;
635 if (aStrHd.nRecType == PPT_PST_TextBytesAtom
636 || aStrHd.nRecType == PPT_PST_TextCharsAtom
637 || aStrHd.nRecType == PPT_PST_CString)
638 {
639 sal_Bool bUniCode =
640 (aStrHd.nRecType == PPT_PST_TextCharsAtom
641 || aStrHd.nRecType == PPT_PST_CString);
642 bRet=sal_True;
643 sal_uLong nBytes = aStrHd.nRecLen;
644 MSDFFReadZString( rStCtrl, rStr, nBytes, bUniCode );
645 aStrHd.SeekToEndOfRecord( rStCtrl );
646 }
647 else
648 aStrHd.SeekToBegOfRecord( rStCtrl );
649 return bRet;
650 }
651
GetColorFromPalette(sal_uInt16,Color &) const652 FASTBOOL SdrEscherImport::GetColorFromPalette(sal_uInt16 /*nNum*/, Color& /*rColor*/) const
653 {
654 return sal_False;
655 }
656
SeekToShape(SvStream &,void *,sal_uInt32) const657 sal_Bool SdrEscherImport::SeekToShape( SvStream& /*rSt*/, void* /*pClientData*/, sal_uInt32 /*nId*/) const
658 {
659 return sal_False;
660 }
661
GetFontEnityAtom(sal_uInt32 nNum) const662 PptFontEntityAtom* SdrEscherImport::GetFontEnityAtom( sal_uInt32 nNum ) const
663 {
664 PptFontEntityAtom* pRetValue = NULL;
665 if ( pFonts && ( nNum < pFonts->Count() ) )
666 pRetValue = (*pFonts)[ (sal_uInt16)nNum ];
667 return pRetValue;
668 }
669
GetCharSet(sal_uInt32 nNum) const670 CharSet SdrEscherImport::GetCharSet( sal_uInt32 nNum ) const
671 {
672 CharSet eRetValue( eCharSetSystem );
673 if ( pFonts && ( nNum < pFonts->Count() ) )
674 eRetValue = (*pFonts)[ (sal_uInt16)nNum ]->eCharSet;
675 return eRetValue;
676 }
677
IsFontAvailable(sal_uInt32 nNum) const678 sal_Bool SdrEscherImport::IsFontAvailable( sal_uInt32 nNum ) const
679 {
680 sal_Bool bRetValue = sal_False;
681 if ( pFonts && ( nNum < pFonts->Count() ) )
682 bRetValue = (*pFonts)[ (sal_uInt16)nNum ]->bAvailable;
683 return bRetValue;
684 }
685
ReadObjText(PPTTextObj *,SdrObject * pObj,SdPage *) const686 SdrObject* SdrEscherImport::ReadObjText( PPTTextObj* /*pTextObj*/, SdrObject* pObj, SdPage* /*pPage*/) const
687 {
688 return pObj;
689 }
690
ProcessClientAnchor2(SvStream & rSt,DffRecordHeader & rHd,void *,DffObjData & rObj)691 void SdrEscherImport::ProcessClientAnchor2( SvStream& rSt, DffRecordHeader& rHd, void* /*pData*/, DffObjData& rObj )
692 {
693 sal_Int32 l, t, r, b;
694 if ( rHd.nRecLen == 16 )
695 {
696 rSt >> l >> t >> r >> b;
697 }
698 else
699 {
700 sal_Int16 ls, ts, rs, bs;
701 rSt >> ts >> ls >> rs >> bs; // etwas seltsame Koordinatenreihenfolge ...
702 l = ls, t = ts, r = rs, b = bs;
703 }
704 Scale( l );
705 Scale( t );
706 Scale( r );
707 Scale( b );
708 rObj.aChildAnchor = Rectangle( l, t, r, b );
709 rObj.bChildAnchor = sal_True;
710 return;
711 };
712
RecolorGraphic(SvStream & rSt,sal_uInt32 nRecLen,Graphic & rGraphic)713 void SdrEscherImport::RecolorGraphic( SvStream& rSt, sal_uInt32 nRecLen, Graphic& rGraphic )
714 {
715 if ( rGraphic.GetType() == GRAPHIC_GDIMETAFILE )
716 {
717 sal_uInt16 nX, nGlobalColorsCount, nFillColorsCount;
718
719 rSt >> nX
720 >> nGlobalColorsCount
721 >> nFillColorsCount
722 >> nX
723 >> nX
724 >> nX;
725
726 if ( ( nGlobalColorsCount <= 64 ) && ( nFillColorsCount <= 64 ) )
727 {
728 if ( (sal_uInt32)( ( nGlobalColorsCount + nFillColorsCount ) * 44 + 12 ) == nRecLen )
729 {
730 sal_uInt32 OriginalGlobalColors[ 64 ];
731 sal_uInt32 NewGlobalColors[ 64 ];
732 sal_uInt32 OriginalFillColors[ 64 ];
733 sal_uInt32 NewFillColors[ 64 ];
734
735 sal_uInt32 i, j, nGlobalColorsChanged, nFillColorsChanged;
736 nGlobalColorsChanged = nFillColorsChanged = 0;
737
738 sal_uInt32* pCurrentOriginal = OriginalGlobalColors;
739 sal_uInt32* pCurrentNew = NewGlobalColors;
740 sal_uInt32* pCount = &nGlobalColorsChanged;
741 i = nGlobalColorsCount;
742
743 for ( j = 0; j < 2; j++ )
744 {
745 for ( ; i > 0; i-- )
746 {
747 sal_uInt32 nIndex, nPos = rSt.Tell();
748 sal_uInt8 nDummy, nRed, nGreen, nBlue;
749 sal_uInt16 nChanged;
750 rSt >> nChanged;
751 if ( nChanged & 1 )
752 {
753 sal_uInt32 nColor = 0;
754 rSt >> nDummy
755 >> nRed
756 >> nDummy
757 >> nGreen
758 >> nDummy
759 >> nBlue
760 >> nIndex;
761
762 if ( nIndex < 8 )
763 {
764 Color aColor = MSO_CLR_ToColor( nIndex << 24 );
765 nRed = aColor.GetRed();
766 nGreen = aColor.GetGreen();
767 nBlue = aColor.GetBlue();
768 }
769 nColor = nRed | ( nGreen << 8 ) | ( nBlue << 16 );
770 *pCurrentNew++ = nColor;
771 rSt >> nDummy
772 >> nRed
773 >> nDummy
774 >> nGreen
775 >> nDummy
776 >> nBlue;
777 nColor = nRed | ( nGreen << 8 ) | ( nBlue << 16 );
778 *pCurrentOriginal++ = nColor;
779 (*pCount)++;
780 }
781 rSt.Seek( nPos + 44 );
782 }
783 pCurrentOriginal = OriginalFillColors;
784 pCurrentNew = NewFillColors;
785 pCount = &nFillColorsChanged;
786 i = nFillColorsCount;
787 }
788 if ( nGlobalColorsChanged || nFillColorsChanged )
789 {
790 Color* pSearchColors = new Color[ nGlobalColorsChanged ];
791 Color* pReplaceColors = new Color[ nGlobalColorsChanged ];
792
793 for ( j = 0; j < nGlobalColorsChanged; j++ )
794 {
795 sal_uInt32 nSearch = OriginalGlobalColors[ j ];
796 sal_uInt32 nReplace = NewGlobalColors[ j ];
797
798 pSearchColors[ j ].SetRed( (sal_uInt8)nSearch );
799 pSearchColors[ j ].SetGreen( (sal_uInt8)( nSearch >> 8 ) );
800 pSearchColors[ j ].SetBlue( (sal_uInt8)( nSearch >> 16 ) );
801
802 pReplaceColors[ j ].SetRed( (sal_uInt8)nReplace );
803 pReplaceColors[ j ].SetGreen( (sal_uInt8)( nReplace >> 8 ) );
804 pReplaceColors[ j ].SetBlue( (sal_uInt8)( nReplace >> 16 ) );
805 }
806 GDIMetaFile aGdiMetaFile( rGraphic.GetGDIMetaFile() );
807 aGdiMetaFile.ReplaceColors( pSearchColors, pReplaceColors,
808 nGlobalColorsChanged, NULL );
809 rGraphic = aGdiMetaFile;
810
811 delete[] pSearchColors;
812 delete[] pReplaceColors;
813 }
814 }
815 }
816 }
817 }
818
819 /* ProcessObject is called from ImplSdPPTImport::ProcessObj to hanlde all application specific things,
820 such as the import of text, animation effects, header footer and placeholder.
821
822 The parameter pOriginalObj is the object as it was imported by our general escher import, it must either
823 be deleted or it can be returned to be inserted into the sdr page.
824 */
ProcessObj(SvStream & rSt,DffObjData & rObjData,void * pData,Rectangle & rTextRect,SdrObject * pOriginalObj)825 SdrObject* SdrEscherImport::ProcessObj( SvStream& rSt, DffObjData& rObjData, void* pData, Rectangle& rTextRect, SdrObject* pOriginalObj )
826 {
827 if ( pOriginalObj && pOriginalObj->ISA( SdrObjCustomShape ) )
828 pOriginalObj->SetMergedItem( SdrTextFixedCellHeightItem( sal_True ) );
829
830 // we are initializing our return value with the object that was imported by our escher import
831 SdrObject* pRet = pOriginalObj;
832
833 ProcessData& rData = *((ProcessData*)pData);
834 PptSlidePersistEntry& rPersistEntry = rData.rPersistEntry;
835
836 if ( ! ( rObjData.nSpFlags & SP_FGROUP ) ) // sj: #114758# ...
837 {
838 PptOEPlaceholderAtom aPlaceholderAtom;
839 sal_Int16 nHeaderFooterInstance = -1;
840
841 if ( maShapeRecords.SeekToContent( rSt, DFF_msofbtClientData, SEEK_FROM_CURRENT_AND_RESTART ) )
842 {
843 DffRecordHeader aClientDataHd;
844 while ( ( rSt.GetError() == 0 ) && ( rSt.Tell() < maShapeRecords.Current()->GetRecEndFilePos() ) )
845 {
846 rSt >> aClientDataHd;
847 switch ( aClientDataHd.nRecType )
848 {
849 // importing header/footer object from master page
850 case PPT_PST_OEPlaceholderAtom :
851 {
852 rSt >> aPlaceholderAtom;
853 if ( nHeaderFooterInstance == -1 )
854 {
855 switch ( aPlaceholderAtom.nPlaceholderId )
856 {
857 case PPT_PLACEHOLDER_MASTERSLIDENUMBER : nHeaderFooterInstance++;
858 case PPT_PLACEHOLDER_MASTERFOOTER : nHeaderFooterInstance++;
859 case PPT_PLACEHOLDER_MASTERHEADER : nHeaderFooterInstance++;
860 case PPT_PLACEHOLDER_MASTERDATE : nHeaderFooterInstance++; break;
861 }
862 if ( ! ( nHeaderFooterInstance & 0xfffc ) ) // is this a valid instance ( 0->3 )
863 rPersistEntry.HeaderFooterOfs[ nHeaderFooterInstance ] = rObjData.rSpHd.GetRecBegFilePos();
864 }
865 }
866 break;
867
868 case PPT_PST_RecolorInfoAtom :
869 {
870 if ( pRet && ( pRet->ISA( SdrGrafObj ) && ((SdrGrafObj*)pRet)->HasGDIMetaFile() ) )
871 {
872 Graphic aGraphic( ((SdrGrafObj*)pRet)->GetGraphic() );
873 RecolorGraphic( rSt, aClientDataHd.nRecLen, aGraphic );
874 ((SdrGrafObj*)pRet)->SetGraphic( aGraphic );
875 }
876 }
877 break;
878 }
879 aClientDataHd.SeekToEndOfRecord( rSt );
880 }
881 }
882 if ( ( aPlaceholderAtom.nPlaceholderId == PPT_PLACEHOLDER_NOTESSLIDEIMAGE ) && ( rPersistEntry.bNotesMaster == sal_False ) )
883 {
884 sal_uInt16 nPageNum = pSdrModel->GetPageCount();
885 if ( nPageNum > 0 )
886 nPageNum--;
887
888 // replacing the object which we will return with a SdrPageObj
889 SdrObject::Free( pRet );
890 pRet = new SdrPageObj( rObjData.aBoundRect, pSdrModel->GetPage( nPageNum - 1 ) );
891 }
892 else
893 {
894 // try to load some ppt text
895 PPTTextObj aTextObj( rSt, (SdrPowerPointImport&)*this, rPersistEntry, &rObjData );
896 if ( ( aTextObj.Count() || aTextObj.GetOEPlaceHolderAtom() ) )
897 {
898 sal_Bool bVerticalText = sal_False;
899 // and if the text object is not empty, it must be applied to pRet, the object we
900 // initially got from our escher import
901 sal_Int32 nTextRotationAngle = 0;
902 if ( IsProperty( DFF_Prop_txflTextFlow ) )
903 {
904 MSO_TextFlow eTextFlow = (MSO_TextFlow)( GetPropertyValue( DFF_Prop_txflTextFlow ) & 0xFFFF );
905 switch( eTextFlow )
906 {
907 case mso_txflBtoT : // Bottom to Top non-@, unten -> oben
908 nTextRotationAngle += 9000;
909 break;
910 case mso_txflTtoBA : /* #68110# */ // Top to Bottom @-font, oben -> unten
911 case mso_txflTtoBN : // Top to Bottom non-@, oben -> unten
912 case mso_txflVertN : // Vertical, non-@, oben -> unten
913 bVerticalText = !bVerticalText; // nTextRotationAngle += 27000;
914 break;
915 // case mso_txflHorzN : // Horizontal non-@, normal
916 // case mso_txflHorzA : // Horizontal @-font, normal
917 default: break;
918 }
919 }
920 sal_Int32 nFontDirection = GetPropertyValue( DFF_Prop_cdirFont, mso_cdir0 );
921 nTextRotationAngle -= nFontDirection * 9000;
922 if ( ( nFontDirection == 1 ) || ( nFontDirection == 3 ) ) // #104546#
923 {
924 bVerticalText = !bVerticalText;
925 /*
926 sal_Int32 nHalfWidth = ( rTextRect.GetWidth() + 1 ) >> 1;
927 sal_Int32 nHalfHeight = ( rTextRect.GetHeight() + 1 ) >> 1;
928 Point aTopLeft( rTextRect.Left() + nHalfWidth - nHalfHeight,
929 rTextRect.Top() + nHalfHeight - nHalfWidth );
930 Size aNewSize( rTextRect.GetHeight(), rTextRect.GetWidth() );
931 Rectangle aNewRect( aTopLeft, aNewSize );
932 rTextRect = aNewRect;
933 */
934 }
935 aTextObj.SetVertical( bVerticalText );
936 if ( pRet )
937 {
938 sal_Bool bDeleteSource = aTextObj.GetOEPlaceHolderAtom() != 0;
939 if ( bDeleteSource && ( pRet->ISA( SdrGrafObj ) == sal_False ) // we are not allowed to get
940 && ( pRet->ISA( SdrObjGroup ) == sal_False ) // grouped placeholder objects
941 && ( pRet->ISA( SdrOle2Obj ) == sal_False ) )
942 SdrObject::Free( pRet );
943 }
944 sal_uInt32 nTextFlags = aTextObj.GetTextFlags();
945 sal_Int32 nTextLeft = GetPropertyValue( DFF_Prop_dxTextLeft, 25 * 3600 ); // 0.25 cm (emu)
946 sal_Int32 nTextRight = GetPropertyValue( DFF_Prop_dxTextRight, 25 * 3600 ); // 0.25 cm (emu)
947 sal_Int32 nTextTop = GetPropertyValue( DFF_Prop_dyTextTop, 13 * 3600 ); // 0.13 cm (emu)
948 sal_Int32 nTextBottom = GetPropertyValue( DFF_Prop_dyTextBottom, 13 * 3600 );
949 ScaleEmu( nTextLeft );
950 ScaleEmu( nTextRight );
951 ScaleEmu( nTextTop );
952 ScaleEmu( nTextBottom );
953
954 sal_Int32 nMinFrameWidth = 0;
955 sal_Int32 nMinFrameHeight = 0;
956 sal_Bool bAutoGrowWidth, bAutoGrowHeight;
957
958 SdrTextVertAdjust eTVA;
959 SdrTextHorzAdjust eTHA;
960
961 nTextFlags &= PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_LEFT | PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_RIGHT
962 | PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_CENTER | PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_BLOCK;
963
964 if ( bVerticalText )
965 {
966 eTVA = SDRTEXTVERTADJUST_BLOCK;
967 eTHA = SDRTEXTHORZADJUST_CENTER;
968
969 // Textverankerung lesen
970 MSO_Anchor eTextAnchor = (MSO_Anchor)GetPropertyValue( DFF_Prop_anchorText, mso_anchorTop );
971
972 switch( eTextAnchor )
973 {
974 case mso_anchorTop:
975 case mso_anchorTopCentered:
976 case mso_anchorTopBaseline:
977 case mso_anchorTopCenteredBaseline:
978 eTHA = SDRTEXTHORZADJUST_RIGHT;
979 break;
980
981 case mso_anchorMiddle :
982 case mso_anchorMiddleCentered:
983 eTHA = SDRTEXTHORZADJUST_CENTER;
984 break;
985
986 case mso_anchorBottom:
987 case mso_anchorBottomCentered:
988 case mso_anchorBottomBaseline:
989 case mso_anchorBottomCenteredBaseline:
990 eTHA = SDRTEXTHORZADJUST_LEFT;
991 break;
992 }
993 // if there is a 100% use of following attributes, the textbox can been aligned also in vertical direction
994 switch ( eTextAnchor )
995 {
996 case mso_anchorTopCentered :
997 case mso_anchorMiddleCentered :
998 case mso_anchorBottomCentered :
999 case mso_anchorTopCenteredBaseline:
1000 case mso_anchorBottomCenteredBaseline:
1001 {
1002 // check if it is sensible to use the centered alignment
1003 sal_uInt32 nMask = PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_LEFT | PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_RIGHT;
1004 if ( ( nTextFlags & nMask ) != nMask ) // if the textobject has left and also right aligned pararagraphs
1005 eTVA = SDRTEXTVERTADJUST_CENTER; // the text has to be displayed using the full width;
1006 }
1007 break;
1008
1009 default :
1010 {
1011 if ( nTextFlags == PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_LEFT )
1012 eTVA = SDRTEXTVERTADJUST_TOP;
1013 else if ( nTextFlags == PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_RIGHT )
1014 eTVA = SDRTEXTVERTADJUST_BOTTOM;
1015 }
1016 break;
1017 }
1018 nMinFrameWidth = rTextRect.GetWidth() - ( nTextLeft + nTextRight );
1019 }
1020 else
1021 {
1022 eTVA = SDRTEXTVERTADJUST_CENTER;
1023 eTHA = SDRTEXTHORZADJUST_BLOCK;
1024
1025 // Textverankerung lesen
1026 MSO_Anchor eTextAnchor = (MSO_Anchor)GetPropertyValue( DFF_Prop_anchorText, mso_anchorTop );
1027
1028 switch( eTextAnchor )
1029 {
1030 case mso_anchorTop:
1031 case mso_anchorTopCentered:
1032 case mso_anchorTopBaseline:
1033 case mso_anchorTopCenteredBaseline:
1034 eTVA = SDRTEXTVERTADJUST_TOP;
1035 break;
1036
1037 case mso_anchorMiddle :
1038 case mso_anchorMiddleCentered:
1039 eTVA = SDRTEXTVERTADJUST_CENTER;
1040 break;
1041
1042 case mso_anchorBottom:
1043 case mso_anchorBottomCentered:
1044 case mso_anchorBottomBaseline:
1045 case mso_anchorBottomCenteredBaseline:
1046 eTVA = SDRTEXTVERTADJUST_BOTTOM;
1047 break;
1048 }
1049 // if there is a 100% usage of following attributes, the textbox can be aligned also in horizontal direction
1050 switch ( eTextAnchor )
1051 {
1052 case mso_anchorTopCentered :
1053 case mso_anchorMiddleCentered :
1054 case mso_anchorBottomCentered :
1055 case mso_anchorTopCenteredBaseline:
1056 case mso_anchorBottomCenteredBaseline:
1057 {
1058 // check if it is sensible to use the centered alignment
1059 sal_uInt32 nMask = PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_LEFT | PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_RIGHT;
1060 if ( ( nTextFlags & nMask ) != nMask ) // if the textobject has left and also right aligned pararagraphs
1061 eTHA = SDRTEXTHORZADJUST_CENTER; // the text has to be displayed using the full width;
1062 }
1063 break;
1064
1065 default :
1066 {
1067 if ( nTextFlags == PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_LEFT )
1068 eTHA = SDRTEXTHORZADJUST_LEFT;
1069 else if ( nTextFlags == PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_RIGHT )
1070 eTHA = SDRTEXTHORZADJUST_RIGHT;
1071 }
1072 break;
1073 }
1074 nMinFrameHeight = rTextRect.GetHeight() - ( nTextTop + nTextBottom );
1075 }
1076
1077 SdrObjKind eTextKind = OBJ_RECT;
1078 if ( ( aPlaceholderAtom.nPlaceholderId == PPT_PLACEHOLDER_NOTESSLIDEIMAGE )
1079 || ( aPlaceholderAtom.nPlaceholderId == PPT_PLACEHOLDER_MASTERNOTESSLIDEIMAGE ) )
1080 {
1081 aTextObj.SetInstance( 2 );
1082 eTextKind = OBJ_TITLETEXT;
1083 }
1084 else if ( ( aPlaceholderAtom.nPlaceholderId == PPT_PLACEHOLDER_MASTERNOTESBODYIMAGE )
1085 || ( aPlaceholderAtom.nPlaceholderId == PPT_PLACEHOLDER_NOTESBODY ) )
1086 {
1087 aTextObj.SetInstance( 2 );
1088 eTextKind = OBJ_TEXT;
1089 }
1090
1091 sal_uInt32 nDestinationInstance = aTextObj.GetInstance();
1092 if ( rPersistEntry.ePageKind == PPT_MASTERPAGE )
1093 {
1094 if ( !rPersistEntry.pPresentationObjects )
1095 {
1096 rPersistEntry.pPresentationObjects = new sal_uInt32[ PPT_STYLESHEETENTRYS ];
1097 memset( rPersistEntry.pPresentationObjects, 0, PPT_STYLESHEETENTRYS * 4 );
1098 }
1099 if ( !rPersistEntry.pPresentationObjects[ nDestinationInstance ] )
1100 rPersistEntry.pPresentationObjects[ nDestinationInstance ] = rObjData.rSpHd.GetRecBegFilePos();
1101 }
1102 switch ( nDestinationInstance )
1103 {
1104 case TSS_TYPE_PAGETITLE :
1105 case TSS_TYPE_TITLE :
1106 {
1107 if ( GetSlideLayoutAtom()->eLayout == PPT_LAYOUT_TITLEMASTERSLIDE )
1108 nDestinationInstance = TSS_TYPE_TITLE;
1109 else
1110 nDestinationInstance = TSS_TYPE_PAGETITLE;
1111 }
1112 break;
1113 case TSS_TYPE_BODY :
1114 // case TSS_TYPE_SUBTITLE :
1115 case TSS_TYPE_HALFBODY :
1116 case TSS_TYPE_QUARTERBODY :
1117 nDestinationInstance = TSS_TYPE_BODY;
1118 break;
1119 }
1120 aTextObj.SetDestinationInstance( (sal_uInt16)nDestinationInstance );
1121
1122 switch ( aTextObj.GetInstance() )
1123 {
1124 case TSS_TYPE_PAGETITLE :
1125 case TSS_TYPE_TITLE : eTextKind = OBJ_TITLETEXT; break;
1126 case TSS_TYPE_SUBTITLE : eTextKind = OBJ_TEXT; break;
1127 case TSS_TYPE_BODY :
1128 case TSS_TYPE_HALFBODY :
1129 case TSS_TYPE_QUARTERBODY : eTextKind = OBJ_OUTLINETEXT; break;
1130 }
1131 if ( aTextObj.GetDestinationInstance() != TSS_TYPE_TEXT_IN_SHAPE )
1132 {
1133 if ( !aTextObj.GetOEPlaceHolderAtom() || !aTextObj.GetOEPlaceHolderAtom()->nPlaceholderId )
1134 {
1135 aTextObj.SetDestinationInstance( TSS_TYPE_TEXT_IN_SHAPE );
1136 eTextKind = OBJ_RECT;
1137 }
1138 }
1139 SdrObject* pTObj = NULL;
1140 sal_Bool bWordWrap = (MSO_WrapMode)GetPropertyValue( DFF_Prop_WrapText, mso_wrapSquare ) != mso_wrapNone;
1141 sal_Bool bFitShapeToText = ( GetPropertyValue( DFF_Prop_FitTextToShape ) & 2 ) != 0;
1142
1143 if ( pRet && pRet->ISA( SdrObjCustomShape ) && ( eTextKind == OBJ_RECT ) )
1144 {
1145 bAutoGrowHeight = bFitShapeToText;
1146 if ( bWordWrap )
1147 bAutoGrowWidth = sal_False;
1148 else
1149 bAutoGrowWidth = sal_True;
1150 pTObj = pRet;
1151 pRet = NULL;
1152 }
1153 else
1154 {
1155 if ( pRet && pRet->ISA( SdrObjCustomShape ) )
1156 {
1157 SdrObject::Free( pRet );
1158 pRet = NULL;
1159 }
1160 pTObj = new SdrRectObj( eTextKind != OBJ_RECT ? eTextKind : OBJ_TEXT );
1161 pTObj->SetModel( pSdrModel );
1162 SfxItemSet aSet( pSdrModel->GetItemPool() );
1163 if ( !pRet )
1164 ((SdrEscherImport*)this)->ApplyAttributes( rSt, aSet, rObjData );
1165 pTObj->SetMergedItemSet( aSet );
1166 if ( pRet )
1167 {
1168 pTObj->SetMergedItem( XLineStyleItem( XLINE_NONE ) );
1169 pTObj->SetMergedItem( XFillStyleItem( XFILL_NONE ) );
1170 }
1171 if ( bVerticalText )
1172 {
1173 bAutoGrowWidth = bFitShapeToText;
1174 bAutoGrowHeight = sal_False;
1175 }
1176 else
1177 {
1178 bAutoGrowWidth = sal_False;
1179
1180 // #119885# re-activationg bFitShapeToText here, could not find deeper explanations
1181 // for it (it was from 2005). Keeping the old commeht here for reference
1182 // old comment: // bFitShapeToText; can't be used, because we cut the text if it is too height,
1183 bAutoGrowHeight = bFitShapeToText;
1184 }
1185 }
1186 pTObj->SetMergedItem( SvxFrameDirectionItem( bVerticalText ? FRMDIR_VERT_TOP_RIGHT : FRMDIR_HORI_LEFT_TOP, EE_PARA_WRITINGDIR ) );
1187
1188 if ( !pTObj->ISA( SdrObjCustomShape ) )
1189 {
1190 pTObj->SetMergedItem( SdrTextAutoGrowWidthItem( bAutoGrowWidth ) );
1191 pTObj->SetMergedItem( SdrTextAutoGrowHeightItem( bAutoGrowHeight ) );
1192 }
1193 else
1194 {
1195 pTObj->SetMergedItem( SdrTextWordWrapItem( bWordWrap ) );
1196 pTObj->SetMergedItem( SdrTextAutoGrowHeightItem( bFitShapeToText ) );
1197 }
1198
1199 pTObj->SetMergedItem( SdrTextVertAdjustItem( eTVA ) );
1200 pTObj->SetMergedItem( SdrTextHorzAdjustItem( eTHA ) );
1201
1202 if ( nMinFrameHeight < 0 )
1203 nMinFrameHeight = 0;
1204 if ( !pTObj->ISA( SdrObjCustomShape ) )
1205 pTObj->SetMergedItem( SdrTextMinFrameHeightItem( nMinFrameHeight ) );
1206
1207 if ( nMinFrameWidth < 0 )
1208 nMinFrameWidth = 0;
1209 if ( !pTObj->ISA( SdrObjCustomShape ) )
1210 pTObj->SetMergedItem( SdrTextMinFrameWidthItem( nMinFrameWidth ) );
1211
1212 // Abstaende an den Raendern der Textbox setzen
1213 pTObj->SetMergedItem( SdrTextLeftDistItem( nTextLeft ) );
1214 pTObj->SetMergedItem( SdrTextRightDistItem( nTextRight ) );
1215 pTObj->SetMergedItem( SdrTextUpperDistItem( nTextTop ) );
1216 pTObj->SetMergedItem( SdrTextLowerDistItem( nTextBottom ) );
1217 pTObj->SetMergedItem( SdrTextFixedCellHeightItem( sal_True ) );
1218
1219 if ( !pTObj->ISA( SdrObjCustomShape ) )
1220 pTObj->SetSnapRect( rTextRect );
1221 pTObj = ReadObjText( &aTextObj, pTObj, rData.pPage );
1222 if ( pTObj )
1223 {
1224 /* check if our new snaprect makes trouble,
1225 because we do not display the ADJUST_BLOCK
1226 properly if the textsize is bigger than the
1227 snaprect of the object. Then we will use
1228 ADJUST_CENTER instead of ADJUST_BLOCK.
1229 */
1230 if ( !pTObj->ISA( SdrObjCustomShape ) && !bFitShapeToText && !bWordWrap )
1231 {
1232 SdrTextObj* pText = PTR_CAST( SdrTextObj, pTObj );
1233 if ( pText )
1234 {
1235 if ( bVerticalText )
1236 {
1237 if ( eTVA == SDRTEXTVERTADJUST_BLOCK )
1238 {
1239 Size aTextSize( pText->GetTextSize() );
1240 aTextSize.Width() += nTextLeft + nTextRight;
1241 aTextSize.Height() += nTextTop + nTextBottom;
1242 if ( rTextRect.GetHeight() < aTextSize.Height() )
1243 pTObj->SetMergedItem( SdrTextVertAdjustItem( SDRTEXTVERTADJUST_CENTER ) );
1244 }
1245 }
1246 else
1247 {
1248 if ( eTHA == SDRTEXTHORZADJUST_BLOCK )
1249 {
1250 Size aTextSize( pText->GetTextSize() );
1251 aTextSize.Width() += nTextLeft + nTextRight;
1252 aTextSize.Height() += nTextTop + nTextBottom;
1253 if ( rTextRect.GetWidth() < aTextSize.Width() )
1254 pTObj->SetMergedItem( SdrTextHorzAdjustItem( SDRTEXTHORZADJUST_CENTER ) );
1255 }
1256 }
1257 }
1258 }
1259 // rotate text with shape ?
1260 sal_Int32 nAngle = ( rObjData.nSpFlags & SP_FFLIPV ) ? -mnFix16Angle : mnFix16Angle; // #72116# vertical flip -> rotate by using the other way
1261 nAngle += nTextRotationAngle;
1262
1263 if ( pTObj->ISA( SdrObjCustomShape ) )
1264 {
1265 /*
1266 if ( nTextRotationAngle )
1267 {
1268 double fTextRotateAngle = (double)nTextRotationAngle / 100.0;
1269 SdrCustomShapeGeometryItem aGeometryItem( (SdrCustomShapeGeometryItem&)((SdrObjCustomShape*)pTObj)->GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ) );
1270 const rtl::OUString sTextRotateAngle( RTL_CONSTASCII_USTRINGPARAM ( "TextRotateAngle" ) );
1271 PropertyValue aPropValue;
1272 aPropValue.Name = sTextRotateAngle;
1273 aPropValue.Value <<= fTextRotateAngle;
1274 aGeometryItem.SetPropertyValue( aPropValue );
1275 ((SdrObjCustomShape*)pTObj)->SetMergedItem( aGeometryItem );
1276 }
1277 */
1278 }
1279 else
1280 {
1281 if ( rObjData.nSpFlags & SP_FFLIPV )
1282 {
1283 double a = 18000 * nPi180;
1284 pTObj->Rotate( rTextRect.Center(), 18000, sin( a ), cos( a ) );
1285 }
1286 if ( rObjData.nSpFlags & SP_FFLIPH )
1287 nAngle = 36000 - nAngle;
1288 if ( nAngle )
1289 {
1290 double a = nAngle * nPi180;
1291 pTObj->NbcRotate( rObjData.aBoundRect.Center(), nAngle, sin( a ), cos( a ) );
1292 }
1293 }
1294 if ( pRet )
1295 {
1296 SdrObject* pGroup = new SdrObjGroup;
1297 pGroup->GetSubList()->NbcInsertObject( pRet );
1298 pGroup->GetSubList()->NbcInsertObject( pTObj );
1299 pRet = pGroup;
1300 }
1301 else
1302 pRet = pTObj;
1303 }
1304 }
1305 }
1306 }
1307 else
1308 {
1309 if ( maShapeRecords.SeekToContent( rSt, DFF_msofbtUDefProp, SEEK_FROM_CURRENT_AND_RESTART ) )
1310 {
1311 maShapeRecords.Current()->SeekToBegOfRecord( rSt );
1312 DffPropertyReader aSecPropSet( *this );
1313 aSecPropSet.ReadPropSet( rSt, (ProcessData*)pData );
1314 sal_Int32 nTableProperties = aSecPropSet.GetPropertyValue( DFF_Prop_tableProperties, 0 );
1315 if ( nTableProperties & 3 )
1316 {
1317 if ( aSecPropSet.SeekToContent( DFF_Prop_tableRowProperties, rSt ) )
1318 {
1319 sal_Int16 i, nRowCount = 0;
1320 rSt >> nRowCount >> i >> i;
1321 if ( nRowCount )
1322 {
1323 sal_uInt32* pTableArry = new sal_uInt32[ nRowCount + 2 ];
1324 pTableArry[ 0 ] = nTableProperties;
1325 pTableArry[ 1 ] = nRowCount;
1326 for ( i = 0; i < nRowCount; i++ )
1327 rSt >> pTableArry[ i + 2 ];
1328 rData.pTableRowProperties = pTableArry;
1329 }
1330 }
1331 }
1332 }
1333 }
1334 if ( pRet ) // sj: #i38501#, and and taking care of connections to group objects
1335 {
1336 if ( rObjData.nSpFlags & SP_FBACKGROUND )
1337 {
1338 pRet->NbcSetSnapRect( Rectangle( Point(), ((SdrPage*)rData.pPage)->GetSize() ) ); // Groesse setzen
1339 }
1340 if ( rPersistEntry.pSolverContainer )
1341 {
1342 for ( SvxMSDffConnectorRule* pPtr = (SvxMSDffConnectorRule*)rPersistEntry.pSolverContainer->aCList.First();
1343 pPtr; pPtr = (SvxMSDffConnectorRule*)rPersistEntry.pSolverContainer->aCList.Next() )
1344 {
1345 if ( rObjData.nShapeId == pPtr->nShapeC )
1346 pPtr->pCObj = pRet;
1347 else
1348 {
1349 SdrObject* pConnectObj = pRet;
1350 if ( pOriginalObj && pRet->ISA( SdrObjGroup ) )
1351 { /* check if the original object from the escherimport is part of the group object,
1352 if this is the case, we will use the original object to connect to */
1353 SdrObjListIter aIter( *pRet, IM_DEEPWITHGROUPS );
1354 while( aIter.IsMore() )
1355 {
1356 SdrObject* pPartObj = aIter.Next();
1357 if ( pPartObj == pOriginalObj )
1358 {
1359 pConnectObj = pPartObj;
1360 break;
1361 }
1362 }
1363 }
1364 if ( rObjData.nShapeId == pPtr->nShapeA )
1365 {
1366 pPtr->pAObj = pConnectObj;
1367 pPtr->nSpFlagsA = rObjData.nSpFlags;
1368 }
1369 if ( rObjData.nShapeId == pPtr->nShapeB )
1370 {
1371 pPtr->pBObj = pConnectObj;
1372 pPtr->nSpFlagsB = rObjData.nSpFlags;
1373 }
1374 }
1375 }
1376 }
1377 if ( rPersistEntry.ePageKind == PPT_MASTERPAGE )
1378 { // maybe the escher clusterlist is not correct, but we have to got the right page by using the
1379 // spMaster property, so we are patching the table
1380 if ( rPersistEntry.nDrawingDgId != 0xffffffff )
1381 {
1382 sal_uInt32 nSec = ( rObjData.nShapeId >> 10 ) - 1;
1383 if ( mpFidcls && ( nSec < mnIdClusters ) )
1384 mpFidcls[ nSec ].dgid = rPersistEntry.nDrawingDgId; // insert the correct drawing id;
1385 }
1386 }
1387 if ( GetPropertyValue( DFF_Prop_fNoFillHitTest ) & 0x10 )
1388 {
1389 if ( (MSO_FillType)GetPropertyValue( DFF_Prop_fillType, mso_fillSolid ) == mso_fillBackground )
1390 {
1391 if ( !rData.pBackgroundColoredObjects )
1392 rData.pBackgroundColoredObjects = new List;
1393 rData.pBackgroundColoredObjects->Insert( pRet, LIST_APPEND );
1394 }
1395 }
1396 }
1397 return pRet;
1398 }
1399
1400 ////////////////////////////////////////////////////////////////////////////////////////////////////
1401
CheckWingdings() const1402 void SdrEscherImport::CheckWingdings() const
1403 {
1404 OutputDevice* pDev = (OutputDevice*)Application::GetDefaultDevice();
1405 ((SdrEscherImport*)this)->bWingdingsAvailable = pDev->IsFontAvailable( String( RTL_CONSTASCII_USTRINGPARAM( "WINGDINGS" ) ) );
1406 ((SdrEscherImport*)this)->bWingdingsChecked = sal_True;
1407 }
1408
CheckMonotypeSorts() const1409 void SdrEscherImport::CheckMonotypeSorts() const
1410 {
1411 OutputDevice* pDev = (OutputDevice*)Application::GetDefaultDevice();
1412 ((SdrEscherImport*)this)->bMonotypeSortsAvailable = pDev->IsFontAvailable( String( RTL_CONSTASCII_USTRINGPARAM( "MONOTYPE SORTS" ) ) );
1413 ((SdrEscherImport*)this)->bMonotypeSortsChecked = sal_True;
1414 }
1415
CheckTimesNewRoman() const1416 void SdrEscherImport::CheckTimesNewRoman() const
1417 {
1418 OutputDevice* pDev = (OutputDevice*)Application::GetDefaultDevice();
1419 ((SdrEscherImport*)this)->bTimesNewRomanAvailable = pDev->IsFontAvailable( String( RTL_CONSTASCII_USTRINGPARAM( "TIMES NEW ROMAN" ) ) );
1420 ((SdrEscherImport*)this)->bTimesNewRomanChecked = sal_True;
1421 }
1422
1423 ////////////////////////////////////////////////////////////////////////////////////////////////////
1424 ////////////////////////////////////////////////////////////////////////////////////////////////////
1425 ////////////////////////////////////////////////////////////////////////////////////////////////////
1426
SdrPowerPointImport(PowerPointImportParam & rParam,const String & rBaseURL)1427 SdrPowerPointImport::SdrPowerPointImport( PowerPointImportParam& rParam, const String& rBaseURL ) :
1428 SdrEscherImport ( rParam, rBaseURL ),
1429 bOk ( rStCtrl.GetErrorCode() == SVSTREAM_OK ),
1430 pPersistPtr ( NULL ),
1431 nPersistPtrAnz ( 0 ),
1432 pDefaultSheet ( NULL ),
1433 pMasterPages ( NULL ),
1434 pSlidePages ( NULL ),
1435 pNotePages ( NULL ),
1436 nAktPageNum ( 0 ),
1437 nDocStreamPos ( 0 ),
1438 nPageColorsNum ( 0xFFFF ),
1439 ePageColorsKind ( PPT_MASTERPAGE ),
1440 eAktPageKind ( PPT_MASTERPAGE )
1441 {
1442 DffRecordHeader* pHd;
1443 if ( bOk )
1444 {
1445 rStCtrl.Seek( STREAM_SEEK_TO_END );
1446 nStreamLen = rStCtrl.Tell();
1447
1448 // try to allocate the UserEditAtom via CurrentUserAtom
1449 sal_uInt32 nCurrentUserEdit = rParam.aCurrentUserAtom.nCurrentUserEdit;
1450 if ( nCurrentUserEdit )
1451 {
1452 rStCtrl.Seek( nCurrentUserEdit );
1453 rStCtrl >> aUserEditAtom;
1454 }
1455 if ( !aUserEditAtom.nOffsetPersistDirectory )
1456 { // if there is no UserEditAtom try to search the last one
1457
1458 rStCtrl.Seek( 0 );
1459 DffRecordManager aPptRecManager; // contains all first level container and atoms
1460 aPptRecManager.Consume( rStCtrl, sal_False, nStreamLen );
1461 for ( pHd = aPptRecManager.Last(); pHd; pHd = aPptRecManager.Prev() )
1462 {
1463 if ( pHd->nRecType == PPT_PST_UserEditAtom )
1464 {
1465 pHd->SeekToBegOfRecord( rStCtrl );
1466 rStCtrl >> aUserEditAtom;
1467 break;
1468 }
1469 }
1470 if ( !pHd )
1471 bOk = sal_False;
1472 }
1473 }
1474 if ( rStCtrl.GetError() != 0 )
1475 bOk = sal_False;
1476
1477 if ( bOk )
1478 {
1479 nPersistPtrAnz = aUserEditAtom.nMaxPersistWritten + 1;
1480 if ( ( nPersistPtrAnz >> 2 ) > nStreamLen ) // sj: at least nPersistPtrAnz is not allowed to be greater than filesize
1481 bOk = sal_False; // (it should not be greater than the PPT_PST_PersistPtrIncrementalBlock, but
1482 // we are reading this block later, so we do not have access yet)
1483
1484 if ( bOk && ( nPersistPtrAnz < ( SAL_MAX_UINT32 / sizeof( sal_uInt32 ) ) ) )
1485 pPersistPtr = new (std::nothrow) sal_uInt32[ nPersistPtrAnz ];
1486 if ( !pPersistPtr )
1487 bOk = sal_False;
1488 if ( bOk )
1489 {
1490 memset( pPersistPtr, 0x00, nPersistPtrAnz * 4 );
1491
1492 // SJ: new search mechanism from bottom to top (Issue 21122)
1493 PptUserEditAtom aCurrentEditAtom( aUserEditAtom );
1494 sal_uInt32 nCurrentEditAtomStrmPos = aCurrentEditAtom.aHd.GetRecEndFilePos();
1495 while( nCurrentEditAtomStrmPos )
1496 {
1497 sal_uInt32 nPersistIncPos = aCurrentEditAtom.nOffsetPersistDirectory;
1498 if ( nPersistIncPos )
1499 {
1500 rStCtrl.Seek( nPersistIncPos );
1501 DffRecordHeader aPersistHd;
1502 rStCtrl >> aPersistHd;
1503 if ( aPersistHd.nRecType == PPT_PST_PersistPtrIncrementalBlock )
1504 {
1505 sal_uLong nPibLen = aPersistHd.GetRecEndFilePos();
1506 while ( bOk && ( rStCtrl.GetError() == 0 ) && ( rStCtrl.Tell() < nPibLen ) )
1507 {
1508 sal_uInt32 nOfs, nAnz;
1509 rStCtrl >> nOfs;
1510 nAnz = nOfs;
1511 nOfs &= 0x000FFFFF;
1512 nAnz >>= 20;
1513 while ( bOk && ( rStCtrl.GetError() == 0 ) && ( nAnz > 0 ) && ( nOfs <= nPersistPtrAnz ) )
1514 {
1515 sal_uInt32 nPt;
1516 rStCtrl >> nPt;
1517 if ( !pPersistPtr[ nOfs ] )
1518 {
1519 pPersistPtr[ nOfs ] = nPt;
1520 if ( pPersistPtr[ nOfs ] > nStreamLen )
1521 {
1522 bOk = sal_False;
1523 DBG_ERROR("SdrPowerPointImport::Ctor(): Ungueltiger Eintrag im Persist-Directory!");
1524 }
1525 }
1526 nAnz--;
1527 nOfs++;
1528 }
1529 if ( bOk && nAnz > 0 )
1530 {
1531 DBG_ERROR("SdrPowerPointImport::Ctor(): Nicht alle Persist-Directory Entraege gelesen!");
1532 bOk = sal_False;
1533 }
1534 }
1535 }
1536 }
1537 nCurrentEditAtomStrmPos = aCurrentEditAtom.nOffsetLastEdit < nCurrentEditAtomStrmPos ? aCurrentEditAtom.nOffsetLastEdit : 0;
1538 if ( nCurrentEditAtomStrmPos )
1539 {
1540 rStCtrl.Seek( nCurrentEditAtomStrmPos );
1541 rStCtrl >> aCurrentEditAtom;
1542 }
1543 }
1544 }
1545 }
1546 if ( rStCtrl.GetError() != 0 )
1547 bOk = sal_False;
1548 if ( bOk )
1549 { // Document PersistEntry checken
1550 nDocStreamPos = aUserEditAtom.nDocumentRef;
1551 if ( nDocStreamPos > nPersistPtrAnz )
1552 {
1553 DBG_ERROR("SdrPowerPointImport::Ctor(): aUserEditAtom.nDocumentRef ungueltig!");
1554 bOk = sal_False;
1555 }
1556 }
1557 if ( bOk )
1558 { // Document FilePos checken
1559 nDocStreamPos = pPersistPtr[ nDocStreamPos ];
1560 if ( nDocStreamPos >= nStreamLen )
1561 {
1562 DBG_ERROR("SdrPowerPointImport::Ctor(): nDocStreamPos >= nStreamLen!");
1563 bOk = sal_False;
1564 }
1565 }
1566 if ( bOk )
1567 {
1568 rStCtrl.Seek( nDocStreamPos );
1569 aDocRecManager.Consume( rStCtrl );
1570
1571 DffRecordHeader aDocHd;
1572 rStCtrl >> aDocHd;
1573 // DocumentAtom lesen
1574 DffRecordHeader aDocAtomHd;
1575 rStCtrl >> aDocAtomHd;
1576 if ( aDocHd.nRecType == PPT_PST_Document && aDocAtomHd.nRecType == PPT_PST_DocumentAtom )
1577 {
1578 aDocAtomHd.SeekToBegOfRecord( rStCtrl );
1579 rStCtrl >> aDocAtom;
1580 }
1581 else
1582 bOk = sal_False;
1583
1584 if ( bOk )
1585 {
1586 if ( !pFonts )
1587 ReadFontCollection();
1588
1589 // reading TxPF, TxSI
1590 PPTTextCharacterStyleAtomInterpreter aTxCFStyle; // SJ: ToDo, this atom needs to be interpreted, it contains character default styles for standard objects (instance4)
1591 PPTTextParagraphStyleAtomInterpreter aTxPFStyle;
1592 PPTTextSpecInfoAtomInterpreter aTxSIStyle; // styles (default language setting ... )
1593
1594 DffRecordHeader* pEnvHd = aDocRecManager.GetRecordHeader( PPT_PST_Environment );
1595 if ( pEnvHd )
1596 {
1597 pEnvHd->SeekToContent( rStCtrl );
1598 DffRecordHeader aTxPFStyleRecHd;
1599 if ( SeekToRec( rStCtrl, PPT_PST_TxPFStyleAtom, pEnvHd->GetRecEndFilePos(), &aTxPFStyleRecHd ) )
1600 aTxPFStyle.Read( rStCtrl, aTxPFStyleRecHd );
1601
1602 pEnvHd->SeekToContent( rStCtrl );
1603 DffRecordHeader aTxSIStyleRecHd;
1604 if ( SeekToRec( rStCtrl, PPT_PST_TxSIStyleAtom, pEnvHd->GetRecEndFilePos(), &aTxSIStyleRecHd ) )
1605 {
1606 aTxSIStyle.Read( rStCtrl, aTxSIStyleRecHd, PPT_PST_TxSIStyleAtom );
1607 #ifdef DBG_UTIL
1608 if ( !aTxSIStyle.bValid )
1609 {
1610 if (!(rImportParam.nImportFlags & PPT_IMPORTFLAGS_NO_TEXT_ASSERT ))
1611 {
1612 DBG_ERROR( "SdrTextSpecInfoAtomInterpreter::Ctor(): parsing error, this document needs to be analysed (SJ)" );
1613 }
1614 }
1615 #endif
1616 }
1617 }
1618
1619 // todo:: PPT_PST_TxPFStyleAtom
1620
1621 // SlidePersists Lesen
1622 pMasterPages=new PptSlidePersistList;
1623 pSlidePages =new PptSlidePersistList;
1624 pNotePages =new PptSlidePersistList;
1625
1626 // now always creating the handout page, it will be the first in our masterpage list
1627 PptSlidePersistEntry* pE = new PptSlidePersistEntry;
1628 pE->aPersistAtom.nPsrReference = aDocAtom.nHandoutMasterPersist;
1629 pE->bHandoutMaster = sal_True;
1630 if ( !aDocAtom.nHandoutMasterPersist )
1631 pE->bStarDrawFiller = sal_True; // this is a dummy master page
1632 pMasterPages->C40_INSERT( PptSlidePersistEntry, pE, 0 );
1633
1634 sal_uInt16 nPageListNum = 0;
1635 DffRecordHeader* pSlideListWithTextHd = aDocRecManager.GetRecordHeader( PPT_PST_SlideListWithText );
1636 PptSlidePersistEntry* pPreviousPersist = NULL;
1637 while ( pSlideListWithTextHd && ( nPageListNum < 3 ) )
1638 {
1639 pSlideListWithTextHd->SeekToContent( rStCtrl );
1640 PptSlidePersistList* pPageList = GetPageList( PptPageKind( nPageListNum ) );
1641 sal_uInt32 nSlideListWithTextHdEndOffset = pSlideListWithTextHd->GetRecEndFilePos();
1642 while ( SeekToRec( rStCtrl, PPT_PST_SlidePersistAtom, nSlideListWithTextHdEndOffset ) )
1643 {
1644 if ( pPreviousPersist )
1645 pPreviousPersist->nSlidePersistEndOffset = rStCtrl.Tell();
1646 PptSlidePersistEntry* pE2 = new PptSlidePersistEntry;
1647 rStCtrl >> pE2->aPersistAtom;
1648 pE2->nSlidePersistStartOffset = rStCtrl.Tell();
1649 pE2->ePageKind = PptPageKind( nPageListNum );
1650 pPageList->C40_INSERT( PptSlidePersistEntry, pE2, pPageList->Count() );
1651 pPreviousPersist = pE2;
1652 }
1653 if ( pPreviousPersist )
1654 pPreviousPersist->nSlidePersistEndOffset = nSlideListWithTextHdEndOffset;
1655 pSlideListWithTextHd = aDocRecManager.GetRecordHeader( PPT_PST_SlideListWithText, SEEK_FROM_CURRENT );
1656 nPageListNum++;
1657 }
1658
1659 // we will ensure that there is at least one master page
1660 if ( pMasterPages->Count() == 1 ) // -> there is only a handout page available
1661 {
1662 PptSlidePersistEntry* pE2 = new PptSlidePersistEntry;
1663 pE2->bStarDrawFiller = sal_True; // this is a dummy master page
1664 pMasterPages->C40_INSERT( PptSlidePersistEntry, pE2, 1 );
1665 }
1666
1667 // now we will insert at least one notes master for each master page
1668 sal_uInt16 nMasterPage;
1669 sal_uInt16 nMasterPages = pMasterPages->Count() - 1;
1670 for ( nMasterPage = 0; nMasterPage < nMasterPages; nMasterPage++ )
1671 {
1672 PptSlidePersistEntry* pE2 = new PptSlidePersistEntry;
1673 pE2->bNotesMaster = sal_True;
1674 pE2->bStarDrawFiller = sal_True; // this is a dummy master page
1675 if ( !nMasterPage && aDocAtom.nNotesMasterPersist )
1676 { // special treatment for the first notes master
1677 pE2->aPersistAtom.nPsrReference = aDocAtom.nNotesMasterPersist;
1678 pE2->bStarDrawFiller = sal_False; // this is a dummy master page
1679 }
1680 pMasterPages->C40_INSERT( PptSlidePersistEntry, pE2, ( nMasterPage + 1 ) << 1 );
1681 }
1682
1683 // Zu jeder Page noch das SlideAtom bzw. NotesAtom lesen, soweit vorhanden
1684 nPageListNum = 0;
1685 for ( nPageListNum = 0; nPageListNum < 3; nPageListNum++ )
1686 {
1687 PptSlidePersistList* pPageList = GetPageList( PptPageKind( nPageListNum ) );
1688 for ( sal_uInt16 nPageNum = 0; nPageNum < pPageList->Count(); nPageNum++ )
1689 {
1690 PptSlidePersistEntry* pE2 = (*pPageList)[ nPageNum ];
1691 sal_uLong nPersist = pE2->aPersistAtom.nPsrReference;
1692 if ( ( nPersist > 0 ) && ( nPersist < nPersistPtrAnz ) )
1693 {
1694 sal_uLong nFPos = pPersistPtr[ nPersist ];
1695 if ( nFPos < nStreamLen )
1696 {
1697 rStCtrl.Seek( nFPos );
1698 DffRecordHeader aSlideHd;
1699 rStCtrl >> aSlideHd;
1700 if ( SeekToRec( rStCtrl, PPT_PST_SlideAtom, aSlideHd.GetRecEndFilePos() ) )
1701 rStCtrl >> pE2->aSlideAtom;
1702 else if ( SeekToRec( rStCtrl, PPT_PST_NotesAtom, aSlideHd.GetRecEndFilePos() ) )
1703 rStCtrl >> pE2->aNotesAtom;
1704 aSlideHd.SeekToContent( rStCtrl );
1705
1706 DffRecordHeader aPPTDrawingHd;
1707 if ( SeekToRec( rStCtrl, PPT_PST_PPDrawing, aSlideHd.GetRecEndFilePos(), &aPPTDrawingHd ) )
1708 {
1709 DffRecordHeader aPPTDgContainer;
1710 if ( SeekToRec( rStCtrl, DFF_msofbtDgContainer, aPPTDrawingHd.GetRecEndFilePos(), &aPPTDgContainer ) )
1711 {
1712 if ( SeekToRec( rStCtrl, DFF_msofbtDg, aPPTDrawingHd.GetRecEndFilePos() ) )
1713 {
1714 DffRecordHeader aDgRecordHeader;
1715 rStCtrl >> aDgRecordHeader;
1716 pE2->nDrawingDgId = aDgRecordHeader.nRecInstance;
1717 aDgRecordHeader.SeekToEndOfRecord( rStCtrl );
1718 }
1719 if ( SeekToRec( rStCtrl, DFF_msofbtSolverContainer, aPPTDgContainer.GetRecEndFilePos() ) )
1720 {
1721 pE2->pSolverContainer = new SvxMSDffSolverContainer;
1722 rStCtrl >> *( pE2->pSolverContainer );
1723 }
1724 aPPTDgContainer.SeekToBegOfRecord( rStCtrl );
1725 SetDgContainer( rStCtrl ); // set this, so that the escherimport is knowing of our drawings
1726 }
1727 }
1728 // office xp is supporting more than one stylesheet
1729 if ( ( pE2->ePageKind == PPT_MASTERPAGE ) && ( pE2->aSlideAtom.nMasterId == 0 ) && ( pE2->bNotesMaster == 0 ) )
1730 {
1731 PPTTextSpecInfo aTxSI( 0 );
1732 if ( aTxSIStyle.bValid && aTxSIStyle.aList.Count() )
1733 aTxSI = *( ( (PPTTextSpecInfo*)aTxSIStyle.aList.GetObject( 0 ) ) );
1734
1735 pE2->pStyleSheet = new PPTStyleSheet( aSlideHd, rStCtrl, *this, aTxCFStyle, aTxPFStyle, aTxSI );
1736 pDefaultSheet = pE2->pStyleSheet;
1737 }
1738 if ( SeekToRec( rStCtrl, PPT_PST_ColorSchemeAtom, aSlideHd.GetRecEndFilePos() ) )
1739 rStCtrl >> pE2->aColorScheme;
1740 else
1741 {
1742 DBG_ERROR( "SdrPowerPointImport::Ctor(): could not get SlideColorScheme! (SJ)" );
1743 }
1744 }
1745 else
1746 {
1747 DBG_ERROR("SdrPowerPointImport::Ctor(): Persist-Eintrag fehlerhaft! (SJ)");
1748 }
1749 }
1750 }
1751 }
1752 DffRecordHeader* pHeadersFootersHd = aDocRecManager.GetRecordHeader( PPT_PST_HeadersFooters, SEEK_FROM_BEGINNING );
1753 if ( pHeadersFootersHd )
1754 {
1755 HeaderFooterEntry aNormalMaster, aNotesMaster;
1756 for ( ; pHeadersFootersHd; pHeadersFootersHd = aDocRecManager.GetRecordHeader( PPT_PST_HeadersFooters, SEEK_FROM_CURRENT ) )
1757 {
1758 if ( pHeadersFootersHd->nRecInstance == 3 ) // normal master
1759 ImportHeaderFooterContainer( *pHeadersFootersHd, aNormalMaster );
1760 else if ( pHeadersFootersHd->nRecInstance == 4 ) // notes master
1761 ImportHeaderFooterContainer( *pHeadersFootersHd, aNotesMaster );
1762 }
1763 for ( sal_uInt16 i = 0; i < pMasterPages->Count(); i++ )
1764 {
1765 if ( (*pMasterPages)[ i ]->bNotesMaster )
1766 (*pMasterPages)[ i ]->pHeaderFooterEntry = new HeaderFooterEntry( aNotesMaster );
1767 else
1768 (*pMasterPages)[ i ]->pHeaderFooterEntry = new HeaderFooterEntry( aNormalMaster );
1769 }
1770 }
1771 }
1772 }
1773 if ( ( rStCtrl.GetError() != 0 ) || ( pDefaultSheet == NULL ) )
1774 bOk = sal_False;
1775 pPPTStyleSheet = pDefaultSheet;
1776 rStCtrl.Seek( 0 );
1777 }
1778
~SdrPowerPointImport()1779 SdrPowerPointImport::~SdrPowerPointImport()
1780 {
1781 for ( void* pPtr = aHyperList.First(); pPtr; pPtr = aHyperList.Next() )
1782 delete (SdHyperlinkEntry*)pPtr;
1783 delete pMasterPages;
1784 delete pSlidePages;
1785 delete pNotePages;
1786 delete[] pPersistPtr;
1787 }
1788
InsertControl(const com::sun::star::uno::Reference<com::sun::star::form::XFormComponent> & rFComp,const com::sun::star::awt::Size & rSize,com::sun::star::uno::Reference<com::sun::star::drawing::XShape> * pShape,sal_Bool)1789 sal_Bool PPTConvertOCXControls::InsertControl(
1790 const com::sun::star::uno::Reference<
1791 com::sun::star::form::XFormComponent > &rFComp,
1792 const com::sun::star::awt::Size& rSize,
1793 com::sun::star::uno::Reference<
1794 com::sun::star::drawing::XShape > *pShape,
1795 sal_Bool /*bFloatingCtrl*/)
1796 {
1797 sal_Bool bRetValue = sal_False;
1798 try
1799 {
1800 ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XShape > xShape;
1801
1802 const ::com::sun::star::uno::Reference< ::com::sun::star::container::XIndexContainer > & rFormComps =
1803 GetFormComps();
1804
1805 ::com::sun::star::uno::Any aTmp( &rFComp, ::getCppuType((const ::com::sun::star::uno::Reference<
1806 com::sun::star::form::XFormComponent >*)0) );
1807
1808 rFormComps->insertByIndex( rFormComps->getCount(), aTmp );
1809
1810 const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory > & rServiceFactory =
1811 GetServiceFactory();
1812 if( rServiceFactory.is() )
1813 {
1814 ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > xCreate = rServiceFactory
1815 ->createInstance(String( RTL_CONSTASCII_STRINGPARAM( "com.sun.star.drawing.ControlShape" ) ) );
1816 if( xCreate.is() )
1817 {
1818 xShape = ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XShape >(xCreate, ::com::sun::star::uno::UNO_QUERY);
1819 if ( xShape.is() )
1820 {
1821 xShape->setSize(rSize);
1822 // GetShapes()->add( xShape );
1823 // Das Control-Model am Control-Shape setzen
1824 ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XControlShape > xControlShape( xShape,
1825 ::com::sun::star::uno::UNO_QUERY );
1826 ::com::sun::star::uno::Reference< ::com::sun::star::awt::XControlModel > xControlModel( rFComp,
1827 ::com::sun::star::uno::UNO_QUERY );
1828 if ( xControlShape.is() && xControlModel.is() )
1829 {
1830 xControlShape->setControl( xControlModel );
1831 if (pShape)
1832 *pShape = xShape;
1833 bRetValue = sal_True;
1834 }
1835 }
1836 }
1837 }
1838 }
1839 catch( ... )
1840 {
1841 bRetValue = sal_False;
1842 }
1843 return bRetValue;
1844 };
1845
GetDrawPage()1846 const ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XDrawPage >& PPTConvertOCXControls::GetDrawPage()
1847 {
1848 if( !xDrawPage.is() && pDocSh )
1849 {
1850 ::com::sun::star::uno::Reference< ::com::sun::star::frame::XModel > xModel( pDocSh->GetModel() );
1851 ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XDrawPages > xDrawPages;
1852 switch( ePageKind )
1853 {
1854 case PPT_SLIDEPAGE :
1855 case PPT_NOTEPAGE :
1856 {
1857 ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XDrawPagesSupplier >
1858 xDrawPagesSupplier( xModel, ::com::sun::star::uno::UNO_QUERY);
1859 if ( xDrawPagesSupplier.is() )
1860 xDrawPages = xDrawPagesSupplier->getDrawPages();
1861 }
1862 break;
1863
1864 case PPT_MASTERPAGE :
1865 {
1866 ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XMasterPagesSupplier >
1867 xMasterPagesSupplier( xModel, ::com::sun::star::uno::UNO_QUERY);
1868 if ( xMasterPagesSupplier.is() )
1869 xDrawPages = xMasterPagesSupplier->getMasterPages();
1870 }
1871 break;
1872 }
1873 if ( xDrawPages.is() && xDrawPages->getCount() )
1874 {
1875 xDrawPages->getCount();
1876 ::com::sun::star::uno::Any aAny( xDrawPages->getByIndex( xDrawPages->getCount() - 1 ) );
1877 aAny >>= xDrawPage;
1878 }
1879 }
1880 return xDrawPage;
1881 }
1882
SdrPowerPointOLEDecompress(SvStream & rOutput,SvStream & rInput,sal_uInt32 nInputSize)1883 sal_Bool SdrPowerPointOLEDecompress( SvStream& rOutput, SvStream& rInput, sal_uInt32 nInputSize )
1884 {
1885 sal_uInt32 nOldPos = rInput.Tell();
1886 char* pBuf = new char[ nInputSize ];
1887 rInput.Read( pBuf, nInputSize );
1888 ZCodec aZCodec( 0x8000, 0x8000 );
1889 aZCodec.BeginCompression();
1890 SvMemoryStream aSource( pBuf, nInputSize, STREAM_READ );
1891 aZCodec.Decompress( aSource, rOutput );
1892 const sal_Bool bSuccess(0L != aZCodec.EndCompression());
1893 delete[] pBuf;
1894 rInput.Seek( nOldPos );
1895 return bSuccess;
1896 }
1897
1898 // --> OD 2004-12-14 #i32596# - add new parameter <_nCalledByGroup>
ImportOLE(long nOLEId,const Graphic & rGraf,const Rectangle & rBoundRect,const Rectangle & rVisArea,const int,sal_Int64) const1899 SdrObject* SdrPowerPointImport::ImportOLE( long nOLEId,
1900 const Graphic& rGraf,
1901 const Rectangle& rBoundRect,
1902 const Rectangle& rVisArea,
1903 const int /*_nCalledByGroup*/,
1904 sal_Int64 /*nAspect*/ ) const
1905 // <--
1906 {
1907 SdrObject* pRet = NULL;
1908
1909 sal_uInt32 nOldPos = rStCtrl.Tell();
1910
1911 Graphic aGraphic( rGraf );
1912
1913 if ( ((SdrPowerPointImport*)this)->maShapeRecords.SeekToContent( rStCtrl, DFF_msofbtClientData, SEEK_FROM_CURRENT_AND_RESTART ) )
1914 {
1915 DffRecordHeader aPlaceHd;
1916 while ( ( rStCtrl.GetError() == 0 )
1917 && ( rStCtrl.Tell() < ((SdrPowerPointImport*)this)->maShapeRecords.Current()->GetRecEndFilePos() ) )
1918 {
1919 rStCtrl >> aPlaceHd;
1920 if ( aPlaceHd.nRecType == PPT_PST_RecolorInfoAtom )
1921 {
1922 ((SdrPowerPointImport*)this)->RecolorGraphic( rStCtrl, aPlaceHd.nRecLen, aGraphic );
1923 break;
1924 }
1925 else
1926 aPlaceHd.SeekToEndOfRecord( rStCtrl );
1927 }
1928 }
1929
1930 PPTOleEntry* pOe;
1931 for ( pOe = (PPTOleEntry*)((SdrPowerPointImport*)this)->aOleObjectList.First(); pOe;
1932 pOe = (PPTOleEntry*)((SdrPowerPointImport*)this)->aOleObjectList.Next() )
1933 {
1934 if ( pOe->nId != (sal_uInt32)nOLEId )
1935 continue;
1936
1937 rStCtrl.Seek( pOe->nRecHdOfs );
1938
1939 DffRecordHeader aHd;
1940 rStCtrl >> aHd;
1941
1942 sal_uInt32 nLen = aHd.nRecLen - 4;
1943 if ( (sal_Int32)nLen > 0 )
1944 {
1945 sal_Bool bSuccess = sal_False;
1946
1947 rStCtrl.SeekRel( 4 );
1948
1949 ::utl::TempFile aTmpFile;
1950 aTmpFile.EnableKillingFile( sal_True );
1951
1952 if ( aTmpFile.IsValid() )
1953 {
1954 SvStream* pDest = ::utl::UcbStreamHelper::CreateStream( aTmpFile.GetURL(), STREAM_TRUNC | STREAM_WRITE );
1955 if ( pDest )
1956 bSuccess = SdrPowerPointOLEDecompress( *pDest, rStCtrl, nLen );
1957 delete pDest;
1958 }
1959 if ( bSuccess )
1960 {
1961 SvStream* pDest = ::utl::UcbStreamHelper::CreateStream( aTmpFile.GetURL(), STREAM_READ );
1962 Storage* pObjStor = pDest ? new Storage( *pDest, sal_True ) : NULL;
1963 if ( pObjStor )
1964 {
1965 SotStorageRef xObjStor( new SotStorage( pObjStor ) );
1966 if ( xObjStor.Is() && !xObjStor->GetError() )
1967 {
1968 if ( xObjStor->GetClassName() == SvGlobalName() )
1969 {
1970 ClsId aId( pObjStor->GetClassId() );
1971 xObjStor->SetClass( SvGlobalName( aId.n1, aId.n2, aId.n3, aId.n4, aId.n5, aId.n6, aId.n7, aId.n8, aId.n9, aId.n10, aId.n11 ),
1972 pObjStor->GetFormat(), pObjStor->GetUserName() );
1973 }
1974 SotStorageStreamRef xSrcTst = xObjStor->OpenSotStream( String( RTL_CONSTASCII_USTRINGPARAM( "\1Ole" ) ) );
1975 if ( xSrcTst.Is() )
1976 {
1977 sal_uInt8 aTestA[ 10 ];
1978 sal_Bool bGetItAsOle = ( sizeof( aTestA ) == xSrcTst->Read( aTestA, sizeof( aTestA ) ) );
1979 if ( !bGetItAsOle )
1980 { // maybe there is a contentsstream in here
1981 xSrcTst = xObjStor->OpenSotStream( String( RTL_CONSTASCII_USTRINGPARAM( "Contents" ) ), STREAM_READWRITE | STREAM_NOCREATE );
1982 bGetItAsOle = ( xSrcTst.Is() && sizeof( aTestA ) == xSrcTst->Read( aTestA, sizeof( aTestA ) ) );
1983 }
1984 if ( bGetItAsOle )
1985 {
1986 ::rtl::OUString aNm;
1987 // if ( nSvxMSDffOLEConvFlags )
1988 {
1989 uno::Reference < embed::XStorage > xDestStorage( pOe->pShell->GetStorage() );
1990 uno::Reference < embed::XEmbeddedObject > xObj =
1991 CheckForConvertToSOObj( nSvxMSDffOLEConvFlags, *xObjStor, xDestStorage, rGraf, rVisArea );
1992 if( xObj.is() )
1993 {
1994 pOe->pShell->getEmbeddedObjectContainer().InsertEmbeddedObject( xObj, aNm );
1995
1996 svt::EmbeddedObjectRef aObj( xObj, pOe->nAspect );
1997
1998 // TODO/LATER: need MediaType for Graphic
1999 aObj.SetGraphic( rGraf, ::rtl::OUString() );
2000 pRet = new SdrOle2Obj( aObj, aNm, rBoundRect, sal_False );
2001 }
2002 }
2003 if ( !pRet && ( pOe->nType == PPT_PST_ExControl ) )
2004 {
2005 PPTConvertOCXControls aPPTConvertOCXControls( pOe->pShell, eAktPageKind );
2006 ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XShape > xShape;
2007 if ( aPPTConvertOCXControls.ReadOCXStream( xObjStor, &xShape, sal_False ) )
2008 pRet = GetSdrObjectFromXShape( xShape );
2009 }
2010 if ( !pRet )
2011 {
2012 aNm = pOe->pShell->getEmbeddedObjectContainer().CreateUniqueObjectName();
2013 ErrCode aErrCode = 0;
2014
2015 // object is not an own object
2016 SotStorageRef xTarget = SotStorage::OpenOLEStorage( pOe->pShell->GetStorage(), aNm, STREAM_READWRITE );
2017 if ( xObjStor.Is() && xTarget.Is() )
2018 {
2019 xObjStor->CopyTo( xTarget );
2020 if( !xTarget->GetError() )
2021 xTarget->Commit();
2022 if( xTarget->GetError() )
2023 aErrCode = xTarget->GetError();
2024 }
2025 xTarget.Clear();
2026
2027 uno::Reference < embed::XEmbeddedObject > xObj =
2028 pOe->pShell->getEmbeddedObjectContainer().GetEmbeddedObject( aNm );
2029 if ( xObj.is() )
2030 {
2031 if ( pOe->nAspect != embed::Aspects::MSOLE_ICON )
2032 {
2033 //TODO/LATER: keep on hacking?!
2034 // modifiziert wollen wir nicht werden
2035 //xInplaceObj->EnableSetModified( sal_False );
2036 if ( rVisArea.IsEmpty() )
2037 {
2038 MapUnit aMapUnit = VCLUnoHelper::UnoEmbed2VCLMapUnit( xObj->getMapUnit( pOe->nAspect ) );
2039 Size aSize( OutputDevice::LogicToLogic( aGraphic.GetPrefSize(),
2040 aGraphic.GetPrefMapMode(), MapMode( aMapUnit ) ) );
2041
2042 awt::Size aSz;
2043 aSz.Width = aSize.Width();
2044 aSz.Height = aSize.Height();
2045 xObj->setVisualAreaSize( pOe->nAspect, aSz );
2046 }
2047 else
2048 {
2049 awt::Size aSize( rVisArea.GetSize().Width(), rVisArea.GetSize().Height() );
2050 xObj->setVisualAreaSize( pOe->nAspect, aSize );
2051 }
2052 //xInplaceObj->EnableSetModified( sal_True );
2053 }
2054
2055 svt::EmbeddedObjectRef aObj( xObj, pOe->nAspect );
2056
2057 // TODO/LATER: need MediaType for Graphic
2058 aObj.SetGraphic( aGraphic, ::rtl::OUString() );
2059
2060 pRet = new SdrOle2Obj( aObj, aNm, rBoundRect, sal_False );
2061 }
2062 }
2063 }
2064 }
2065 }
2066 }
2067 delete pDest;
2068 }
2069 }
2070 }
2071 rStCtrl.Seek( nOldPos );
2072
2073 return pRet;
2074 }
2075
ImportExOleObjStg(sal_uInt32 nPersistPtr,sal_uInt32 & nOleId) const2076 SvMemoryStream* SdrPowerPointImport::ImportExOleObjStg( sal_uInt32 nPersistPtr, sal_uInt32& nOleId ) const
2077 {
2078 SvMemoryStream* pRet = NULL;
2079 if ( nPersistPtr && ( nPersistPtr < nPersistPtrAnz ) )
2080 {
2081 sal_uInt32 nOldPos, nOfs = pPersistPtr[ nPersistPtr ];
2082 nOldPos = rStCtrl.Tell();
2083 rStCtrl.Seek( nOfs );
2084 DffRecordHeader aHd;
2085 rStCtrl >> aHd;
2086 if ( aHd.nRecType == DFF_PST_ExOleObjStg )
2087 {
2088 sal_uInt32 nLen = aHd.nRecLen - 4;
2089 if ( (sal_Int32)nLen > 0 )
2090 {
2091 rStCtrl >> nOleId;
2092 pRet = new SvMemoryStream;
2093 ZCodec aZCodec( 0x8000, 0x8000 );
2094 aZCodec.BeginCompression();
2095 aZCodec.Decompress( rStCtrl, *pRet );
2096 if ( !aZCodec.EndCompression() )
2097 delete pRet, pRet = NULL;
2098 }
2099 }
2100 rStCtrl.Seek( nOldPos );
2101 }
2102 return pRet;
2103 }
2104
SeekOle(SfxObjectShell * pShell,sal_uInt32 nFilterOptions)2105 void SdrPowerPointImport::SeekOle( SfxObjectShell* pShell, sal_uInt32 nFilterOptions )
2106 {
2107 if ( pShell )
2108 {
2109 DffRecordHeader* pHd;
2110
2111 sal_uInt32 nOldPos = rStCtrl.Tell();
2112 if ( nFilterOptions & 1 )
2113 {
2114 pHd = aDocRecManager.GetRecordHeader( PPT_PST_List, SEEK_FROM_BEGINNING );
2115 if ( pHd )
2116 {
2117 // we try to locate the basic atom
2118 pHd->SeekToContent( rStCtrl );
2119 if ( SeekToRec( rStCtrl, PPT_PST_VBAInfo, pHd->GetRecEndFilePos(), pHd ) )
2120 {
2121 if ( SeekToRec( rStCtrl, PPT_PST_VBAInfoAtom, pHd->GetRecEndFilePos(), pHd ) )
2122 {
2123 sal_uInt32 nPersistPtr, nIDoNotKnow1, nIDoNotKnow2;
2124 rStCtrl >> nPersistPtr
2125 >> nIDoNotKnow1
2126 >> nIDoNotKnow2;
2127
2128 sal_uInt32 nOleId;
2129 SvMemoryStream* pBas = ImportExOleObjStg( nPersistPtr, nOleId );
2130 if ( pBas )
2131 {
2132 SotStorageRef xSource( new SotStorage( pBas, sal_True ) );
2133 SotStorageRef xDest( new SotStorage( new SvMemoryStream(), sal_True ) );
2134 if ( xSource.Is() && xDest.Is() )
2135 {
2136 // is this a visual basic storage ?
2137 SotStorageRef xSubStorage = xSource->OpenSotStorage( String( RTL_CONSTASCII_USTRINGPARAM( "VBA" ) ),
2138 STREAM_READWRITE | STREAM_NOCREATE | STREAM_SHARE_DENYALL );
2139 if( xSubStorage.Is() && ( SVSTREAM_OK == xSubStorage->GetError() ) )
2140 {
2141 SotStorageRef xMacros = xDest->OpenSotStorage( String( RTL_CONSTASCII_USTRINGPARAM( "MACROS" ) ) );
2142 if ( xMacros.Is() )
2143 {
2144 SvStorageInfoList aList;
2145 xSource->FillInfoList( &aList );
2146 sal_uInt32 i;
2147
2148 sal_Bool bCopied = sal_True;
2149 for ( i = 0; i < aList.Count(); i++ ) // copy all entrys
2150 {
2151 const SvStorageInfo& rInfo = aList[ i ];
2152 if ( !xSource->CopyTo( rInfo.GetName(), xMacros, rInfo.GetName() ) )
2153 bCopied = sal_False;
2154 }
2155 if ( i && bCopied )
2156 {
2157 SvxImportMSVBasic aMSVBas( *pShell, *xDest, sal_True, sal_False );
2158 //int nSuccess = aMSVBas.Import( String( RTL_CONSTASCII_USTRINGPARAM( "MACROS" ) ),
2159 // String( RTL_CONSTASCII_USTRINGPARAM( "VBA" ) ), TRUE, FALSE );
2160
2161 uno::Reference < embed::XStorage > xDoc( pShell->GetStorage() );
2162 if ( xDoc.is() )
2163 {
2164 SotStorageRef xVBA = SotStorage::OpenOLEStorage( xDoc, String( RTL_CONSTASCII_USTRINGPARAM( "_MS_VBA_Macros" ) ) );
2165 if ( xVBA.Is() && ( xVBA->GetError() == SVSTREAM_OK ) )
2166 {
2167 SotStorageRef xSubVBA = xVBA->OpenSotStorage( String( RTL_CONSTASCII_USTRINGPARAM( "_MS_VBA_Overhead" ) ) );
2168 if ( xSubVBA.Is() && ( xSubVBA->GetError() == SVSTREAM_OK ) )
2169 {
2170 SotStorageStreamRef xOriginal = xSubVBA->OpenSotStream( String( RTL_CONSTASCII_USTRINGPARAM( "_MS_VBA_Overhead2" ) ) );
2171 if ( xOriginal.Is() && ( xOriginal->GetError() == SVSTREAM_OK ) )
2172 {
2173 if ( nPersistPtr && ( nPersistPtr < nPersistPtrAnz ) )
2174 {
2175 rStCtrl.Seek( pPersistPtr[ nPersistPtr ] );
2176 rStCtrl >> *pHd;
2177
2178 *xOriginal << nIDoNotKnow1
2179 << nIDoNotKnow2;
2180
2181 sal_uInt32 nSource, nToCopy, nBufSize;
2182 nSource = rStCtrl.Tell();
2183 nToCopy = pHd->nRecLen;
2184 sal_uInt8* pBuf = new sal_uInt8[ 0x40000 ]; // 256KB Buffer
2185 if ( pBuf )
2186 {
2187 while ( nToCopy )
2188 {
2189 nBufSize = ( nToCopy >= 0x40000 ) ? 0x40000 : nToCopy;
2190 rStCtrl.Read( pBuf, nBufSize );
2191 xOriginal->Write( pBuf, nBufSize );
2192 nToCopy -= nBufSize;
2193 }
2194 delete[] pBuf;
2195 }
2196 }
2197 }
2198 }
2199 }
2200 }
2201 }
2202 }
2203 }
2204 }
2205 }
2206 }
2207 }
2208 }
2209 }
2210 pHd = aDocRecManager.GetRecordHeader( PPT_PST_ExObjList, SEEK_FROM_BEGINNING );
2211 if ( pHd )
2212 {
2213 DffRecordManager* pExObjListManager = NULL;
2214 DffRecordHeader* pExEmbed = NULL;
2215
2216 pHd->SeekToBegOfRecord( rStCtrl );
2217 pExObjListManager = new DffRecordManager( rStCtrl );
2218 sal_uInt16 i, nRecType(PPT_PST_ExEmbed);
2219
2220 for ( i = 0; i < 2; i++ )
2221 {
2222 switch ( i )
2223 {
2224 case 0 : nRecType = PPT_PST_ExEmbed; break;
2225 case 1 : nRecType = PPT_PST_ExControl; break;
2226 }
2227 for ( pExEmbed = pExObjListManager->GetRecordHeader( nRecType, SEEK_FROM_BEGINNING );
2228 pExEmbed; pExEmbed = pExObjListManager->GetRecordHeader( nRecType, SEEK_FROM_CURRENT ) )
2229 {
2230 pExEmbed->SeekToContent( rStCtrl );
2231
2232 DffRecordHeader aExOleAtHd;
2233 if ( SeekToRec( rStCtrl, PPT_PST_ExOleObjAtom, pExEmbed->GetRecEndFilePos(), &aExOleAtHd ) )
2234 {
2235 PptExOleObjAtom aAt;
2236 rStCtrl >> aAt;
2237
2238 if ( aAt.nPersistPtr && ( aAt.nPersistPtr < nPersistPtrAnz ) )
2239 {
2240 sal_uInt32 nId;
2241 rStCtrl.Seek( pPersistPtr[ aAt.nPersistPtr ] );
2242 DffRecordHeader aHd;
2243 rStCtrl >> aHd;
2244 if ( aHd.nRecType == DFF_PST_ExOleObjStg )
2245 {
2246 rStCtrl >> nId;
2247 aOleObjectList.Insert(
2248 new PPTOleEntry( aAt.nId, aHd.nFilePos, pShell, nRecType, aAt.nAspect ) );
2249 }
2250 }
2251 }
2252 }
2253 }
2254 delete pExObjListManager;
2255 }
2256 rStCtrl.Seek( nOldPos );
2257 }
2258 }
2259
ReadFontCollection()2260 sal_Bool SdrPowerPointImport::ReadFontCollection()
2261 {
2262 sal_Bool bRet = sal_False;
2263 DffRecordHeader* pEnvHd = aDocRecManager.GetRecordHeader( PPT_PST_Environment );
2264 if ( pEnvHd )
2265 {
2266 sal_uLong nFPosMerk = rStCtrl.Tell(); // FilePos merken fuer spaetere Restauration
2267 pEnvHd->SeekToContent( rStCtrl );
2268 DffRecordHeader aListHd;
2269 if ( SeekToRec( rStCtrl, PPT_PST_FontCollection, pEnvHd->GetRecEndFilePos(), &aListHd ) )
2270 {
2271 sal_uInt16 nCount2 = 0;
2272 VirtualDevice* pVDev = NULL;
2273 while ( SeekToRec( rStCtrl, PPT_PST_FontEntityAtom, aListHd.GetRecEndFilePos() ) )
2274 {
2275 bRet = sal_True;
2276 if ( !pFonts )
2277 pFonts = new PptFontCollection;
2278 PptFontEntityAtom* pFont = new PptFontEntityAtom;
2279 rStCtrl >> *pFont;
2280
2281 Font aFont;
2282 aFont.SetCharSet( pFont->eCharSet );
2283 aFont.SetName( pFont->aName );
2284 aFont.SetFamily( pFont->eFamily );
2285 aFont.SetPitch( pFont->ePitch );
2286 aFont.SetHeight( 100 );
2287
2288 if ( mbTracing && !pFont->bAvailable )
2289 mpTracer->Trace( rtl::OUString::createFromAscii( "sd1000" ), pFont->aName );
2290
2291 #ifdef DBG_EXTRACTFONTMETRICS
2292
2293 SvxFont aTmpFont( aFont );
2294
2295 if ( !pVDev )
2296 pVDev = new VirtualDevice;
2297 aTmpFont.SetPhysFont( pVDev );
2298 FontMetric aMetric( pVDev->GetFontMetric() );
2299 sal_uInt16 nTxtHeight = (sal_uInt16)aMetric.GetAscent() + (sal_uInt16)aMetric.GetDescent();
2300
2301 String aFileURLStr;
2302 if( ::utl::LocalFileHelper::ConvertPhysicalNameToURL( Application::GetAppFileName(), aFileURLStr ) )
2303 {
2304 INetURLObject aURL( aFileURLStr );
2305 aURL.SetName( String( RTL_CONSTASCII_STRINGPARAM( "dbgfontmetrics.txt" ) ) );
2306
2307 SvStream* pDbgOut = ::utl::UcbStreamHelper::CreateStream( aURL.GetMainURL( INetURLObject::NO_DECODE ), STREAM_WRITE );
2308 if( pDbgOut )
2309 {
2310 pDbgOut->Seek( STREAM_SEEK_TO_END );
2311
2312 Printer* pPrinter = NULL;
2313 if ( pSdrModel->GetRefDevice() && pSdrModel->GetRefDevice()->GetOutDevType() == OUTDEV_PRINTER )
2314 pPrinter = (Printer*)pSdrModel->GetRefDevice();
2315 if ( pPrinter )
2316 {
2317 Font aOldFont( pPrinter->GetFont() );
2318 aFont.SetKerning( sal_True );
2319 pPrinter->SetFont( aFont );
2320 aMetric = pPrinter->GetFontMetric();
2321 pPrinter->SetFont( aOldFont );
2322 }
2323
2324 if ( ( pPrinter == NULL ) || ( aMetric.GetIntLeading() == 0 ) )
2325 {
2326 VirtualDevice aVirDev( 1 );
2327 aVirDev.SetFont( aFont );
2328 aMetric = aVirDev.GetFontMetric();
2329 }
2330 ByteString aFontName( aFont.GetName(), RTL_TEXTENCODING_UTF8 );
2331 ByteString aHeight( ByteString::CreateFromInt32( aMetric.GetLineHeight() ) );
2332 ByteString aAscent( ByteString::CreateFromInt32( aMetric.GetAscent() ) );
2333 ByteString aDescent( ByteString::CreateFromInt32( aMetric.GetDescent() ) );
2334 ByteString aLeading( ByteString::CreateFromInt32( aMetric.GetIntLeading() ) );
2335 ByteString aPhysHeight( ByteString::CreateFromInt32( nTxtHeight ) );
2336
2337 *pDbgOut << (sal_uInt8)0xa
2338 << "FontName : " << aFontName.GetBuffer() << (sal_uInt8)0xa
2339 << " Height: " << aHeight.GetBuffer() << (sal_uInt8)0xa
2340 << " Ascent: " << aAscent.GetBuffer() << (sal_uInt8)0xa
2341 << " Descent:" << aDescent.GetBuffer() << (sal_uInt8)0xa
2342 << " Leading:" << aLeading.GetBuffer() << (sal_uInt8)0xa
2343 << "PhysHeight :" << aPhysHeight.GetBuffer()<< (sal_uInt8)0xa;
2344 }
2345 delete pDbgOut;
2346 }
2347 #endif
2348 // following block is necessary, because our old PowerPoint export did not set the
2349 // correct charset
2350 if ( pFont->aName.EqualsIgnoreCaseAscii( "Wingdings" ) ||
2351 pFont->aName.EqualsIgnoreCaseAscii( "Wingdings 2" ) ||
2352 pFont->aName.EqualsIgnoreCaseAscii( "Wingdings 3" ) ||
2353 pFont->aName.EqualsIgnoreCaseAscii( "Monotype Sorts" ) ||
2354 pFont->aName.EqualsIgnoreCaseAscii( "Monotype Sorts 2" ) ||
2355 pFont->aName.EqualsIgnoreCaseAscii( "Webdings" ) ||
2356 pFont->aName.EqualsIgnoreCaseAscii( "StarBats" ) ||
2357 pFont->aName.EqualsIgnoreCaseAscii( "StarMath" ) ||
2358 pFont->aName.EqualsIgnoreCaseAscii( "ZapfDingbats" ) )
2359 {
2360 pFont->eCharSet = RTL_TEXTENCODING_SYMBOL;
2361 };
2362 pFonts->C40_INSERT( PptFontEntityAtom, pFont, nCount2++ );
2363 }
2364 delete pVDev;
2365 }
2366 rStCtrl.Seek( nFPosMerk ); // FilePos restaurieren
2367 }
2368 return bRet;
2369 }
2370
GetPageList(PptPageKind ePageKind) const2371 PptSlidePersistList* SdrPowerPointImport::GetPageList(PptPageKind ePageKind) const
2372 {
2373 if ( ePageKind == PPT_MASTERPAGE )
2374 return pMasterPages;
2375 if ( ePageKind == PPT_SLIDEPAGE )
2376 return pSlidePages;
2377 if ( ePageKind == PPT_NOTEPAGE )
2378 return pNotePages;
2379 return NULL;
2380 }
2381
GetDrawOutliner(SdrTextObj * pSdrText) const2382 SdrOutliner* SdrPowerPointImport::GetDrawOutliner( SdrTextObj* pSdrText ) const
2383 {
2384 if ( !pSdrText )
2385 return NULL;
2386 else
2387 return &pSdrText->ImpGetDrawOutliner();
2388 }
2389
2390
ReadObjText(PPTTextObj * pTextObj,SdrObject * pSdrObj,SdPage * pPage) const2391 SdrObject* SdrPowerPointImport::ReadObjText( PPTTextObj* pTextObj, SdrObject* pSdrObj, SdPage* pPage ) const
2392 {
2393 SdrTextObj* pText = PTR_CAST( SdrTextObj, pSdrObj );
2394 if ( pText )
2395 {
2396 if ( !ApplyTextObj( pTextObj, pText, pPage, NULL, NULL ) )
2397 pSdrObj = NULL;
2398 }
2399 return pSdrObj;
2400 }
2401
2402
ApplyTextObj(PPTTextObj * pTextObj,SdrTextObj * pSdrText,SdPage *,SfxStyleSheet * pSheet,SfxStyleSheet ** ppStyleSheetAry) const2403 SdrObject* SdrPowerPointImport::ApplyTextObj( PPTTextObj* pTextObj, SdrTextObj* pSdrText, SdPage* /*pPage*/,
2404 SfxStyleSheet* pSheet, SfxStyleSheet** ppStyleSheetAry ) const
2405 {
2406 SdrTextObj* pText = pSdrText;
2407 if ( pTextObj->Count() )
2408 {
2409 sal_uInt32 nDestinationInstance = pTextObj->GetDestinationInstance() ;
2410 SdrOutliner& rOutliner = pText->ImpGetDrawOutliner();
2411 if ( ( pText->GetObjInventor() == SdrInventor ) && ( pText->GetObjIdentifier() == OBJ_TITLETEXT ) ) // Outliner-Style fuer Titel-Textobjekt?!? (->von DL)
2412 rOutliner.Init( OUTLINERMODE_TITLEOBJECT ); // Outliner reset
2413
2414 sal_Bool bOldUpdateMode = rOutliner.GetUpdateMode();
2415 rOutliner.SetUpdateMode( sal_False );
2416 if ( pSheet )
2417 {
2418 if ( rOutliner.GetStyleSheet( 0 ) != pSheet )
2419 rOutliner.SetStyleSheet( 0, pSheet );
2420 }
2421 rOutliner.SetVertical( pTextObj->GetVertical() );
2422 const PPTParagraphObj* pPreviousParagraph = NULL;
2423 for ( PPTParagraphObj* pPara = pTextObj->First(); pPara; pPara = pTextObj->Next() )
2424 {
2425 sal_uInt32 nTextSize = pPara->GetTextSize();
2426 if ( ! ( nTextSize & 0xffff0000 ) )
2427 {
2428 PPTPortionObj* pPortion;
2429 sal_Unicode* pParaText = new sal_Unicode[ nTextSize ];
2430 sal_uInt32 nCurrentIndex = 0;
2431 for ( pPortion = pPara->First(); pPortion; pPortion = pPara->Next() )
2432 {
2433 if ( pPortion->mpFieldItem )
2434 pParaText[ nCurrentIndex++ ] = ' ';
2435 else
2436 {
2437 sal_uInt32 nCharacters = pPortion->Count();
2438 const sal_Unicode* pSource = pPortion->maString.GetBuffer();
2439 sal_Unicode* pDest = pParaText + nCurrentIndex;
2440
2441 sal_uInt32 nFont;
2442 pPortion->GetAttrib( PPT_CharAttr_Font, nFont, pTextObj->GetInstance() );
2443 PptFontEntityAtom* pFontEnityAtom = GetFontEnityAtom( nFont );
2444 if ( pFontEnityAtom && ( pFontEnityAtom->eCharSet == RTL_TEXTENCODING_SYMBOL ) )
2445 {
2446 sal_uInt32 i;
2447 sal_Unicode nUnicode;
2448 for ( i = 0; i < nCharacters; i++ )
2449 {
2450 nUnicode = pSource[ i ];
2451 if ( ! ( nUnicode & 0xff00 ) )
2452 nUnicode |= 0xf000;
2453 pDest[ i ] = nUnicode;
2454 }
2455 }
2456 else
2457 memcpy( pDest, pSource, nCharacters << 1 );
2458 nCurrentIndex += nCharacters;
2459 }
2460 }
2461 sal_uInt16 nParaIndex = (sal_uInt16)pTextObj->GetCurrentIndex();
2462 SfxStyleSheet* pS = ( ppStyleSheetAry ) ? ppStyleSheetAry[ pPara->pParaSet->mnDepth ] : pSheet;
2463
2464 ESelection aSelection( nParaIndex, 0, nParaIndex, 0 );
2465 rOutliner.Insert( String(), nParaIndex, pPara->pParaSet->mnDepth );
2466 rOutliner.QuickInsertText( String( pParaText, (sal_uInt16)nCurrentIndex ), aSelection );
2467 rOutliner.SetParaAttribs( nParaIndex, rOutliner.GetEmptyItemSet() );
2468 if ( pS )
2469 rOutliner.SetStyleSheet( nParaIndex, pS );
2470
2471 for ( pPortion = pPara->First(); pPortion; pPortion = pPara->Next() )
2472 {
2473 SfxItemSet aPortionAttribs( rOutliner.GetEmptyItemSet() );
2474 SvxFieldItem* pFieldItem = pPortion->GetTextField();
2475 if ( pFieldItem )
2476 {
2477 rOutliner.QuickInsertField( *pFieldItem, ESelection( nParaIndex, aSelection.nEndPos, nParaIndex, aSelection.nEndPos + 1 ) );
2478 aSelection.nEndPos++;
2479 delete pFieldItem;
2480 }
2481 else
2482 {
2483 const sal_Unicode *pF, *pPtr = pPortion->maString.GetBuffer();
2484 const sal_Unicode *pMax = pPtr + pPortion->maString.Len();
2485 sal_Int32 nLen;
2486 for ( pF = pPtr; pPtr < pMax; pPtr++ )
2487 {
2488 if ( *pPtr == 0xb )
2489 {
2490 nLen = pPtr - pF;
2491 if ( nLen )
2492 aSelection.nEndPos =
2493 sal::static_int_cast< sal_uInt16 >(
2494 aSelection.nEndPos + nLen );
2495 pF = pPtr + 1;
2496 rOutliner.QuickInsertLineBreak( ESelection( nParaIndex, aSelection.nEndPos, nParaIndex, aSelection.nEndPos + 1 ) );
2497 aSelection.nEndPos++;
2498 }
2499 }
2500 nLen = pPtr - pF;
2501 if ( nLen )
2502 aSelection.nEndPos = sal::static_int_cast< sal_uInt16 >(
2503 aSelection.nEndPos + nLen );
2504 }
2505 pPortion->ApplyTo( aPortionAttribs, (SdrPowerPointImport&)*this, nDestinationInstance, pTextObj );
2506 rOutliner.QuickSetAttribs( aPortionAttribs, aSelection );
2507 aSelection.nStartPos = aSelection.nEndPos;
2508 }
2509 boost::optional< sal_Int16 > oStartNumbering;
2510 SfxItemSet aParagraphAttribs( rOutliner.GetEmptyItemSet() );
2511 pPara->ApplyTo( aParagraphAttribs, oStartNumbering, (SdrPowerPointImport&)*this, nDestinationInstance, pPreviousParagraph );
2512
2513 sal_uInt32 nIsBullet2 = 0; //, nInstance = nDestinationInstance != 0xffffffff ? nDestinationInstance : pTextObj->GetInstance();
2514 pPara->GetAttrib( PPT_ParaAttr_BulletOn, nIsBullet2, nDestinationInstance );
2515 if ( !nIsBullet2 )
2516 aParagraphAttribs.Put( SfxBoolItem( EE_PARA_BULLETSTATE, sal_False ) );
2517
2518
2519 pPreviousParagraph = pPara;
2520 if ( !aSelection.nStartPos ) // in PPT empty paragraphs never gets a bullet
2521 {
2522 aParagraphAttribs.Put( SfxBoolItem( EE_PARA_BULLETSTATE, sal_False ) );
2523 // rOutliner.SetDepth( rOutliner.GetParagraph( nParaIndex ), -1 );
2524 }
2525 aSelection.nStartPos = 0;
2526 rOutliner.QuickSetAttribs( aParagraphAttribs, aSelection );
2527 delete[] pParaText;
2528 }
2529 }
2530 OutlinerParaObject* pNewText = rOutliner.CreateParaObject();
2531 rOutliner.Clear();
2532 rOutliner.SetUpdateMode( bOldUpdateMode );
2533 pText->SetOutlinerParaObject( pNewText );
2534 }
2535 return pText;
2536 }
2537
SeekToDocument(DffRecordHeader * pRecHd) const2538 sal_Bool SdrPowerPointImport::SeekToDocument( DffRecordHeader* pRecHd ) const
2539 {
2540 sal_Bool bRet;
2541 sal_uLong nFPosMerk = rStCtrl.Tell(); // FilePos merken fuer ggf. spaetere Restauration
2542 rStCtrl.Seek( nDocStreamPos );
2543 DffRecordHeader aDocHd;
2544 rStCtrl >> aDocHd;
2545 bRet = aDocHd.nRecType == PPT_PST_Document;
2546 if ( bRet )
2547 {
2548 if ( pRecHd )
2549 *pRecHd = aDocHd;
2550 else
2551 aDocHd.SeekToBegOfRecord( rStCtrl );
2552 }
2553 if ( !bRet )
2554 rStCtrl.Seek( nFPosMerk ); // FilePos restaurieren
2555 return bRet;
2556 }
2557
SeekToContentOfProgTag(sal_Int32 nVersion,SvStream & rSt,const DffRecordHeader & rSourceHd,DffRecordHeader & rContentHd)2558 sal_Bool SdrPowerPointImport::SeekToContentOfProgTag( sal_Int32 nVersion, SvStream& rSt,
2559 const DffRecordHeader& rSourceHd, DffRecordHeader& rContentHd )
2560 {
2561 sal_Bool bRetValue = sal_False;
2562 sal_uInt32 nOldPos = rSt.Tell();
2563
2564 DffRecordHeader aProgTagsHd, aProgTagBinaryDataHd;
2565 rSourceHd.SeekToContent( rSt );
2566 sal_Bool bFound = rSourceHd.nRecType == PPT_PST_ProgTags;
2567 if ( !bFound )
2568 bFound = SeekToRec( rSt, PPT_PST_ProgTags, rSourceHd.GetRecEndFilePos(), &aProgTagsHd );
2569 if ( bFound )
2570 {
2571 while( SeekToRec( rSt, PPT_PST_ProgBinaryTag, aProgTagsHd.GetRecEndFilePos(), &aProgTagBinaryDataHd ) )
2572 {
2573 rSt >> rContentHd;
2574 if ( rContentHd.nRecType == PPT_PST_CString )
2575 {
2576 sal_uInt16 n = 6;
2577 sal_uInt32 i = rContentHd.nRecLen >> 1;
2578 if ( i > n )
2579 {
2580 String aPre, aSuf;
2581 sal_Unicode *pTmp = aPre.AllocBuffer( n );
2582 while ( n-- )
2583 rSt >> *pTmp++;
2584 n = (sal_uInt16)( i - 6 );
2585 pTmp = aSuf.AllocBuffer( n );
2586 while ( n-- )
2587 rSt >> *pTmp++;
2588 sal_Int32 nV = aSuf.ToInt32();
2589 if ( ( nV == nVersion ) && ( aPre == String( RTL_CONSTASCII_USTRINGPARAM( "___PPT" ) ) ) )
2590 {
2591 rContentHd.SeekToEndOfRecord( rSt );
2592 rSt >> rContentHd;
2593 if ( rContentHd.nRecType == PPT_PST_BinaryTagData )
2594 {
2595 bRetValue = sal_True;
2596 break;
2597 }
2598 }
2599 }
2600 }
2601 aProgTagBinaryDataHd.SeekToEndOfRecord( rSt );
2602 }
2603 }
2604 if ( !bRetValue )
2605 rSt.Seek( nOldPos );
2606 return bRetValue;
2607 }
2608
GetAktPageId()2609 sal_uInt32 SdrPowerPointImport::GetAktPageId()
2610 {
2611 PptSlidePersistList* pList = GetPageList( eAktPageKind );
2612 if ( pList && nAktPageNum < pList->Count() )
2613 return (*pList)[ (sal_uInt16)nAktPageNum ]->aPersistAtom.nSlideId;
2614 return 0;
2615 }
2616
SeekToAktPage(DffRecordHeader * pRecHd) const2617 sal_Bool SdrPowerPointImport::SeekToAktPage( DffRecordHeader* pRecHd ) const
2618 {
2619 sal_Bool bRet = sal_False;
2620 PptSlidePersistList* pList = GetPageList( eAktPageKind );
2621 if ( pList && ( nAktPageNum < pList->Count() ) )
2622 {
2623 sal_uLong nPersist = (*pList)[ (sal_uInt16)nAktPageNum ]->aPersistAtom.nPsrReference;
2624 if ( nPersist > 0 && nPersist < nPersistPtrAnz )
2625 {
2626 sal_uLong nFPos = 0;
2627 nFPos = pPersistPtr[ nPersist ];
2628 if ( nFPos < nStreamLen )
2629 {
2630 rStCtrl.Seek( nFPos );
2631 if ( pRecHd )
2632 rStCtrl >> *pRecHd;
2633 bRet = sal_True;
2634 }
2635 }
2636 }
2637 return bRet;
2638 }
2639
GetPageCount(PptPageKind ePageKind) const2640 sal_uInt16 SdrPowerPointImport::GetPageCount( PptPageKind ePageKind ) const
2641 {
2642 PptSlidePersistList* pList = GetPageList( ePageKind );
2643 if ( pList )
2644 return pList->Count();
2645 return 0;
2646 }
2647
SetPageNum(sal_uInt16 nPageNum,PptPageKind eKind)2648 void SdrPowerPointImport::SetPageNum( sal_uInt16 nPageNum, PptPageKind eKind )
2649 {
2650 eAktPageKind = eKind;
2651 nAktPageNum = nPageNum;
2652
2653 pPPTStyleSheet = NULL;
2654
2655 sal_Bool bHasMasterPage = sal_True;
2656 sal_uInt16 nMasterIndex = 0;
2657
2658 if ( eKind == PPT_MASTERPAGE )
2659 nMasterIndex = nPageNum;
2660 else
2661 {
2662 if ( HasMasterPage( nPageNum, eKind ) )
2663 nMasterIndex = GetMasterPageIndex( nPageNum, eKind );
2664 else
2665 bHasMasterPage = sal_False;
2666 }
2667 if ( bHasMasterPage )
2668 {
2669 PptSlidePersistList* pPageList = GetPageList( PPT_MASTERPAGE );
2670 if ( pPageList && nMasterIndex < pPageList->Count() )
2671 {
2672 PptSlidePersistEntry* pMasterPersist = (*pPageList)[ nMasterIndex ];
2673 if ( ( pMasterPersist->pStyleSheet == NULL ) && pMasterPersist->aSlideAtom.nMasterId )
2674 {
2675 nMasterIndex = pMasterPages->FindPage( pMasterPersist->aSlideAtom.nMasterId );
2676 if ( nMasterIndex != PPTSLIDEPERSIST_ENTRY_NOTFOUND )
2677 pMasterPersist = (*pPageList)[ nMasterIndex ];
2678 }
2679 pPPTStyleSheet = pMasterPersist->pStyleSheet;
2680 }
2681 }
2682 if ( !pPPTStyleSheet )
2683 pPPTStyleSheet = pDefaultSheet;
2684 }
2685
GetPageSize() const2686 Size SdrPowerPointImport::GetPageSize() const
2687 {
2688 Size aRet( IsNoteOrHandout( nAktPageNum, eAktPageKind ) ? aDocAtom.GetNotesPageSize() : aDocAtom.GetSlidesPageSize() );
2689 Scale( aRet );
2690 // PPT arbeitet nur mit Einheiten zu 576DPI. Um Ungenauigkeiten zu
2691 // vermeiden runde ich die letzte Nachkommastelle metrisch weg.
2692 if ( nMapMul > 2 * nMapDiv )
2693 {
2694 MapUnit eMap = pSdrModel->GetScaleUnit();
2695 bool bInch = IsInch( eMap );
2696 long nInchMul = 1, nInchDiv = 1;
2697 if ( bInch )
2698 { // Size temporaer (zum runden) in nach metric konvertieren
2699 Fraction aFact(GetMapFactor(eMap,MAP_100TH_MM).X());
2700 nInchMul = aFact.GetNumerator();
2701 nInchDiv = aFact.GetDenominator();
2702 aRet.Width() = BigMulDiv( aRet.Width(), nInchMul, nInchDiv );
2703 aRet.Height() = BigMulDiv( aRet.Height(), nInchMul, nInchDiv );
2704 }
2705 aRet.Width() += 5; aRet.Width() /= 10; aRet.Width()*=10;
2706 aRet.Height() += 5; aRet.Height() /= 10; aRet.Height()*=10;
2707 if ( bInch )
2708 {
2709 aRet.Width() = BigMulDiv( aRet.Width(), nInchDiv, nInchMul );
2710 aRet.Height() = BigMulDiv( aRet.Height(), nInchDiv, nInchMul );
2711 }
2712 }
2713 return aRet;
2714 }
2715
GetColorFromPalette(sal_uInt16 nNum,Color & rColor) const2716 FASTBOOL SdrPowerPointImport::GetColorFromPalette( sal_uInt16 nNum, Color& rColor ) const
2717 {
2718 if ( nPageColorsNum != nAktPageNum || ePageColorsKind != eAktPageKind )
2719 {
2720 sal_uInt16 nSlideFlags = 0;
2721 PptSlidePersistList* pPageList = GetPageList( eAktPageKind );
2722 if ( pPageList && ( nAktPageNum < pPageList->Count() ) )
2723 {
2724 PptSlidePersistEntry* pE = (*pPageList)[ nAktPageNum ];
2725 if ( pE )
2726 nSlideFlags = pE->aSlideAtom.nFlags;
2727 if ( ! ( nSlideFlags & 2 ) )
2728 ((SdrPowerPointImport*)this)->aPageColors = pE->aColorScheme;
2729 }
2730 if ( nSlideFlags & 2 ) // follow master colorscheme ?
2731 {
2732 PptSlidePersistList* pPageList2 = GetPageList( PPT_MASTERPAGE );
2733 if ( pPageList2 )
2734 {
2735 PptSlidePersistEntry* pMasterPersist = NULL;
2736 if ( eAktPageKind == PPT_MASTERPAGE )
2737 pMasterPersist = (*pPageList2)[ nAktPageNum ];
2738 else
2739 {
2740 if ( HasMasterPage( nAktPageNum, eAktPageKind ) )
2741 {
2742 sal_uInt16 nMasterNum = GetMasterPageIndex( nAktPageNum, eAktPageKind );
2743 if ( nMasterNum < pPageList2->Count() )
2744 pMasterPersist = (*pPageList2)[ nMasterNum ];
2745 }
2746 }
2747 if ( pMasterPersist )
2748 {
2749 while( ( pMasterPersist && pMasterPersist->aSlideAtom.nFlags & 2 ) // it is possible that a masterpage
2750 && pMasterPersist->aSlideAtom.nMasterId ) // itself is following a master colorscheme
2751 {
2752 sal_uInt16 nNextMaster = pMasterPages->FindPage( pMasterPersist->aSlideAtom.nMasterId );
2753 if ( nNextMaster == PPTSLIDEPERSIST_ENTRY_NOTFOUND )
2754 break;
2755 else
2756 pMasterPersist = (*pPageList2)[ nNextMaster ];
2757 }
2758 ((SdrPowerPointImport*)this)->aPageColors = pMasterPersist->aColorScheme;
2759 }
2760 }
2761 }
2762 // momentanes Farbschema eintragen
2763 ((SdrPowerPointImport*)this)->nPageColorsNum = nAktPageNum;
2764 ((SdrPowerPointImport*)this)->ePageColorsKind = eAktPageKind;
2765 }
2766 rColor = aPageColors.GetColor( nNum );
2767 return sal_True;
2768 }
2769
SeekToShape(SvStream & rSt,void * pClientData,sal_uInt32 nId) const2770 sal_Bool SdrPowerPointImport::SeekToShape( SvStream& rSt, void* pClientData, sal_uInt32 nId ) const
2771 {
2772 sal_Bool bRet = SvxMSDffManager::SeekToShape( rSt, pClientData, nId );
2773 if ( !bRet )
2774 {
2775 ProcessData& rData = *( (ProcessData*)pClientData );
2776 PptSlidePersistEntry& rPersistEntry = rData.rPersistEntry;
2777 if ( rPersistEntry.ePageKind == PPT_SLIDEPAGE )
2778 {
2779 if ( HasMasterPage( nAktPageNum, eAktPageKind ) )
2780 {
2781 sal_uInt16 nMasterNum = GetMasterPageIndex( nAktPageNum, eAktPageKind );
2782 PptSlidePersistList* pPageList = GetPageList( PPT_MASTERPAGE );
2783 if ( pPageList && ( nMasterNum < pPageList->Count() ) )
2784 {
2785 PptSlidePersistEntry* pPersist = (*pPageList)[ nMasterNum ]; // get the masterpage's persistentry
2786 if ( pPersist && pPersist->pPresentationObjects )
2787 {
2788 sal_uInt32 nCurrent(0L);
2789 DffRecordList* pCList = maShapeRecords.pCList; // we got a backup of the current position
2790 if ( pCList )
2791 nCurrent = pCList->nCurrent;
2792 if ( ((SdrEscherImport*)this )->maShapeRecords.SeekToContent( rSt, DFF_msofbtClientData, SEEK_FROM_CURRENT_AND_RESTART ) )
2793 {
2794 sal_uInt32 nStreamPos = rSt.Tell();
2795 PPTTextObj aTextObj( rSt, (SdrPowerPointImport&)*this, rPersistEntry, NULL );
2796 if ( aTextObj.Count() || aTextObj.GetOEPlaceHolderAtom() )
2797 {
2798 sal_uInt32 nShapePos = 0;
2799 switch ( aTextObj.GetInstance() )
2800 {
2801 case TSS_TYPE_TITLE :
2802 nShapePos = pPersist->pPresentationObjects[ TSS_TYPE_PAGETITLE ];
2803 break;
2804 case TSS_TYPE_PAGETITLE :
2805 nShapePos = pPersist->pPresentationObjects[ TSS_TYPE_PAGETITLE ];
2806 break;
2807 case TSS_TYPE_SUBTITLE :
2808 case TSS_TYPE_HALFBODY :
2809 case TSS_TYPE_QUARTERBODY :
2810 case TSS_TYPE_BODY :
2811 nShapePos = pPersist->pPresentationObjects[ TSS_TYPE_BODY ];
2812 break;
2813 // case TSS_TYPE_NOTES :
2814 // case TSS_TYPE_UNUSED :
2815 // case TSS_TYPE_TEXT_IN_SHAPE :
2816 }
2817 if ( nShapePos )
2818 {
2819 rSt.Seek( nShapePos );
2820 bRet = sal_True;
2821 }
2822 }
2823 if ( !bRet )
2824 rSt.Seek( nStreamPos );
2825 }
2826 if ( pCList ) // restoring
2827 pCList->nCurrent = nCurrent;
2828 ((SdrEscherImport*)this )->maShapeRecords.pCList = pCList;
2829 }
2830 }
2831 }
2832 }
2833 }
2834 return bRet;
2835 }
2836
MakeBlancPage(sal_Bool bMaster) const2837 SdrPage* SdrPowerPointImport::MakeBlancPage( sal_Bool bMaster ) const
2838 {
2839 SdrPage* pRet = pSdrModel->AllocPage( bMaster );
2840 pRet->SetSize( GetPageSize() );
2841
2842 /*
2843 SJ (21.08.00) : since bug #77576# i decided not to set a border size.
2844
2845 Size aPageSize( aDocAtom.GetSlidesPageSize() ); // PageSize in 576DPI-Units
2846 long nHMarg = aPageSize.Width() - aDocAtom.aSlidesPageSize.Width();
2847 long nVMarg = aPageSize.Height() - aDocAtom.aSlidesPageSize.Height();
2848 if ( nHMarg > 0 )
2849 {
2850 Scale( nHMarg );
2851 pRet->SetLftBorder( nHMarg / 2 );
2852 pRet->SetRgtBorder( nHMarg - nHMarg / 2 );
2853 }
2854 if ( nVMarg > 0 )
2855 {
2856 Scale( nVMarg );
2857 pRet->SetUppBorder( nVMarg / 2 );
2858 pRet->SetLwrBorder( nVMarg - nVMarg / 2 );
2859 }
2860 */
2861 return pRet;
2862 }
2863
ImportComment10(SvxMSDffManager & rMan,SvStream & rStCtrl,SdrPage * pPage,DffRecordHeader & rComment10Hd)2864 void ImportComment10( SvxMSDffManager& rMan, SvStream& rStCtrl, SdrPage* pPage, DffRecordHeader& rComment10Hd )
2865 {
2866 rtl::OUString sAuthor;
2867 rtl::OUString sText;
2868 rtl::OUString sInitials;
2869
2870 sal_Int32 nIndex = 0;
2871 util::DateTime aDateTime;
2872 sal_Int32 nPosX = 0;
2873 sal_Int32 nPosY = 0;
2874
2875 while ( ( rStCtrl.GetError() == 0 ) && ( rStCtrl.Tell() < rComment10Hd.GetRecEndFilePos() ) )
2876 {
2877 DffRecordHeader aCommentHd;
2878 rStCtrl >> aCommentHd;
2879 switch( aCommentHd.nRecType )
2880 {
2881 case PPT_PST_CString :
2882 {
2883 String aString;
2884 SvxMSDffManager::MSDFFReadZString( rStCtrl, aString, aCommentHd.nRecLen, sal_True );
2885 switch ( aCommentHd.nRecInstance )
2886 {
2887 case 0 : sAuthor = aString; break;
2888 case 1 : sText = aString; break;
2889 case 2 : sInitials = aString; break;
2890 }
2891 }
2892 break;
2893
2894 case PPT_PST_CommentAtom10 :
2895 {
2896 rStCtrl >> nIndex
2897 >> aDateTime.Year
2898 >> aDateTime.Month
2899 >> aDateTime.Day // DayOfWeek
2900 >> aDateTime.Day
2901 >> aDateTime.Hours
2902 >> aDateTime.Minutes
2903 >> aDateTime.Seconds
2904 >> aDateTime.HundredthSeconds
2905 >> nPosX
2906 >> nPosY;
2907
2908 aDateTime.HundredthSeconds /= 10;
2909 }
2910 break;
2911 }
2912 aCommentHd.SeekToEndOfRecord( rStCtrl );
2913 }
2914 Point aPosition( nPosX, nPosY );
2915 rMan.Scale( aPosition );
2916
2917 try
2918 {
2919 uno::Reference< office::XAnnotationAccess > xAnnotationAccess( pPage->getUnoPage(), UNO_QUERY_THROW );
2920 uno::Reference< office::XAnnotation > xAnnotation( xAnnotationAccess->createAndInsertAnnotation() );
2921 xAnnotation->setPosition( geometry::RealPoint2D( aPosition.X() / 100.0, aPosition.Y() / 100.0 ) );
2922 xAnnotation->setAuthor( sAuthor );
2923 xAnnotation->setDateTime( aDateTime );
2924 uno::Reference< text::XText > xText( xAnnotation->getTextRange() );
2925 xText->setString( sText );
2926 }
2927 catch( uno::Exception& )
2928 {
2929
2930 }
2931 }
2932
2933
2934 // be sure not to import masterpages with this method
2935 // be sure not to import masterpages with this method
ImportPage(SdrPage * pRet,const PptSlidePersistEntry * pMasterPersist)2936 void SdrPowerPointImport::ImportPage( SdrPage* pRet, const PptSlidePersistEntry* pMasterPersist )
2937 {
2938 sal_uInt32 nMerk = rStCtrl.Tell();
2939 PptSlidePersistList* pList = GetPageList( eAktPageKind );
2940 if ( ( !pList ) || ( pList->Count() <= nAktPageNum ) )
2941 return;
2942 PptSlidePersistEntry& rSlidePersist = *(*pList)[ nAktPageNum ];
2943 if ( rSlidePersist.bStarDrawFiller )
2944 return;
2945
2946 DffRecordHeader aPageHd;
2947 if ( SeekToAktPage( &aPageHd ) )
2948 {
2949 if ( mbTracing )
2950 mpTracer->AddAttribute( eAktPageKind == PPT_SLIDEPAGE
2951 ? rtl::OUString::createFromAscii( "Page" )
2952 : rtl::OUString::createFromAscii( "NotesPage" ),
2953 rtl::OUString::valueOf( (sal_Int32)nAktPageNum + 1 ) );
2954
2955 rSlidePersist.pHeaderFooterEntry = new HeaderFooterEntry( pMasterPersist );
2956 ProcessData aProcessData( rSlidePersist, (SdPage*)pRet );
2957 sal_Size nLastPosition;
2958 while ( ( rStCtrl.GetError() == 0 ) && ( rStCtrl.Tell() < aPageHd.GetRecEndFilePos() ) )
2959 {
2960 nLastPosition = rStCtrl.Tell();
2961 DffRecordHeader aHd;
2962 rStCtrl >> aHd;
2963 switch ( aHd.nRecType )
2964 {
2965 case PPT_PST_HeadersFooters :
2966 {
2967 ImportHeaderFooterContainer( aHd, *rSlidePersist.pHeaderFooterEntry );
2968 }
2969 break;
2970
2971 case PPT_PST_ProgTags :
2972 {
2973 DffRecordHeader aContentDataHd;
2974 if ( SeekToContentOfProgTag( 10, rStCtrl, aHd, aContentDataHd ) )
2975 {
2976 DffRecordHeader aComment10Hd;
2977 while( ( rStCtrl.GetError() == 0 ) && SeekToRec( rStCtrl, PPT_PST_Comment10, aContentDataHd.GetRecEndFilePos(), &aComment10Hd ) )
2978 {
2979 ImportComment10( *this, rStCtrl, pRet, aComment10Hd );
2980 aComment10Hd.SeekToEndOfRecord( rStCtrl );
2981 }
2982 }
2983 }
2984 break;
2985
2986 case PPT_PST_PPDrawing :
2987 {
2988 DffRecordHeader aPPDrawHd;
2989 if ( SeekToRec( rStCtrl, DFF_msofbtDgContainer, aHd.GetRecEndFilePos(), &aPPDrawHd ) )
2990 {
2991 sal_uInt32 nPPDrawOfs = rStCtrl.Tell();
2992
2993 // importing the background object before importing the page
2994 while ( ( rStCtrl.GetError() == 0 ) && ( rStCtrl.Tell() < aPPDrawHd.GetRecEndFilePos() ) )
2995 {
2996 DffRecordHeader aEscherObjListHd;
2997 rStCtrl >> aEscherObjListHd;
2998 switch ( aEscherObjListHd.nRecType )
2999 {
3000 case DFF_msofbtSpContainer :
3001 {
3002 Rectangle aPageSize( Point(), pRet->GetSize() );
3003 if ( rSlidePersist.aSlideAtom.nFlags & 4 ) // follow master background ?
3004 {
3005 if ( HasMasterPage( nAktPageNum, eAktPageKind ) )
3006 {
3007 sal_uInt16 nMasterNum = GetMasterPageIndex( nAktPageNum, eAktPageKind );
3008 PptSlidePersistList* pPageList = GetPageList( PPT_MASTERPAGE );
3009 PptSlidePersistEntry* pE = (*pPageList)[ nMasterNum ];
3010 while( ( pE->aSlideAtom.nFlags & 4 ) && pE->aSlideAtom.nMasterId )
3011 {
3012 sal_uInt16 nNextMaster = pMasterPages->FindPage( pE->aSlideAtom.nMasterId );
3013 if ( nNextMaster == PPTSLIDEPERSIST_ENTRY_NOTFOUND )
3014 break;
3015 else
3016 pE = (*pPageList)[ nNextMaster ];
3017 }
3018 if ( pE->nBackgroundOffset )
3019 {
3020 // do not follow master colorscheme ?
3021 sal_Bool bTemporary = ( rSlidePersist.aSlideAtom.nFlags & 2 ) != 0;
3022 sal_uInt32 nPos = rStCtrl.Tell();
3023 rStCtrl.Seek( pE->nBackgroundOffset );
3024 rSlidePersist.pBObj = ImportObj( rStCtrl, (void*)&aProcessData, aPageSize, aPageSize );
3025 rSlidePersist.bBObjIsTemporary = bTemporary;
3026 rStCtrl.Seek( nPos );
3027 }
3028 }
3029 }
3030 else
3031 {
3032 DffRecordHeader aShapeHd;
3033 rStCtrl >> aShapeHd;
3034 if ( aShapeHd.nRecType == DFF_msofbtSp )
3035 {
3036 sal_uInt32 nSpFlags;
3037 rStCtrl >> nSpFlags >> nSpFlags;
3038 if ( nSpFlags & SP_FBACKGROUND )
3039 {
3040 aEscherObjListHd.SeekToBegOfRecord( rStCtrl );
3041 rSlidePersist.pBObj = ImportObj( rStCtrl, (void*)&aProcessData, aPageSize, aPageSize );
3042 rSlidePersist.bBObjIsTemporary = sal_False;
3043 }
3044 }
3045 }
3046 }
3047 break;
3048 }
3049 if ( aEscherObjListHd.nRecType == DFF_msofbtSpContainer )
3050 break;
3051 aEscherObjListHd.SeekToEndOfRecord( rStCtrl );
3052 }
3053
3054 // now importing page
3055 rStCtrl.Seek( nPPDrawOfs );
3056 while ( ( rStCtrl.GetError() == 0 ) && ( rStCtrl.Tell() < aPPDrawHd.GetRecEndFilePos() ) )
3057 {
3058 DffRecordHeader aEscherObjListHd;
3059 rStCtrl >> aEscherObjListHd;
3060 switch ( aEscherObjListHd.nRecType )
3061 {
3062 case DFF_msofbtSpgrContainer :
3063 {
3064 DffRecordHeader aShapeHd;
3065 if ( SeekToRec( rStCtrl, DFF_msofbtSpContainer, aEscherObjListHd.GetRecEndFilePos(), &aShapeHd ) )
3066 {
3067 sal_Size nShapeLastPosition;
3068 aShapeHd.SeekToEndOfRecord( rStCtrl );
3069 while ( ( rStCtrl.GetError() == 0 ) && ( rStCtrl.Tell() < aEscherObjListHd.GetRecEndFilePos() ) )
3070 {
3071 nShapeLastPosition = rStCtrl.Tell();
3072 rStCtrl >> aShapeHd;
3073 if ( ( aShapeHd.nRecType == DFF_msofbtSpContainer ) || ( aShapeHd.nRecType == DFF_msofbtSpgrContainer ) )
3074 {
3075 Rectangle aEmpty;
3076 aShapeHd.SeekToBegOfRecord( rStCtrl );
3077 sal_Int32 nShapeId;
3078 aProcessData.pTableRowProperties = NULL;
3079 SdrObject* pObj = ImportObj( rStCtrl, (void*)&aProcessData, aEmpty, aEmpty, 0, &nShapeId );
3080 if ( pObj )
3081 {
3082 if ( aProcessData.pTableRowProperties )
3083 pObj = CreateTable( pObj, aProcessData.pTableRowProperties, aProcessData.rPersistEntry.pSolverContainer );
3084
3085 pRet->NbcInsertObject( pObj );
3086
3087 if( nShapeId )
3088 insertShapeId( nShapeId, pObj );
3089 }
3090 }
3091 aShapeHd.SeekToEndOfRecord( rStCtrl );
3092 if (rStCtrl.Tell() == nShapeLastPosition) {
3093 // We are inside an endless loop
3094 break;
3095 }
3096 }
3097 }
3098 }
3099 break;
3100 }
3101 if ( aEscherObjListHd.nRecType == DFF_msofbtSpgrContainer )
3102 break;
3103 aEscherObjListHd.SeekToEndOfRecord( rStCtrl );
3104 }
3105
3106 /* There are a lot of Shapes who are dependent to
3107 the current background color */
3108 if ( rSlidePersist.ePageKind == PPT_SLIDEPAGE )
3109 {
3110 List* pList2 = aProcessData.pBackgroundColoredObjects;
3111 if ( pList2 )
3112 {
3113 if ( rSlidePersist.pBObj )
3114 {
3115 void* pPtr;
3116 const SfxPoolItem* pPoolItem = NULL;
3117 const SfxItemSet& rObjectItemSet = rSlidePersist.pBObj->GetMergedItemSet();
3118
3119 //SfxItemState eState = rObjectItemSet.GetItemState( XATTR_FILLCOLOR, sal_False, &pPoolItem );
3120 if ( pPoolItem )
3121 {
3122 SfxItemSet aNewSet(*rObjectItemSet.GetPool());
3123 aNewSet.Put(*pPoolItem);
3124 aNewSet.Put(XFillStyleItem( XFILL_SOLID ));
3125
3126 for ( pPtr = pList2->First(); pPtr; pPtr = pList2->Next() )
3127 {
3128 ((SdrObject*)pPtr)->SetMergedItemSet(aNewSet);
3129 }
3130 }
3131 }
3132 }
3133 }
3134 if ( rSlidePersist.pBObj )
3135 {
3136 // #i99386# transfer the attributes from the temporary BackgroundObject
3137 // to the Page and delete it. Maybe rSlidePersist.bBObjIsTemporary is
3138 // obsolete here, too.
3139 pRet->getSdrPageProperties().ClearItem();
3140 pRet->getSdrPageProperties().PutItemSet(rSlidePersist.pBObj->GetMergedItemSet());
3141 SdrObject::Free( rSlidePersist.pBObj );
3142 }
3143 }
3144 }
3145 break;
3146 }
3147 aHd.SeekToEndOfRecord( rStCtrl );
3148 if (rStCtrl.Tell() == nLastPosition) {
3149 // We are inside an endless loop
3150 break;
3151 }
3152 }
3153 if ( rSlidePersist.pSolverContainer )
3154 SolveSolver( *rSlidePersist.pSolverContainer );
3155 if ( mbTracing )
3156 mpTracer->RemoveAttribute( eAktPageKind == PPT_SLIDEPAGE
3157 ? rtl::OUString::createFromAscii( "Page" )
3158 : rtl::OUString::createFromAscii( "NotesPage" ) );
3159 }
3160 rStCtrl.Seek( nMerk );
3161 }
3162
GetSlideLayoutAtom() const3163 const PptSlideLayoutAtom* SdrPowerPointImport::GetSlideLayoutAtom() const
3164 {
3165 PptSlidePersistList* pPageList = GetPageList( eAktPageKind );
3166 if ( pPageList && nAktPageNum < pPageList->Count() )
3167 {
3168 PptSlidePersistEntry* pE = (*pPageList)[ nAktPageNum ];
3169 if ( pE )
3170 return &pE->aSlideAtom.aLayout;
3171 }
3172 return NULL;
3173 }
3174
IsNoteOrHandout(sal_uInt16 nPageNum,PptPageKind) const3175 sal_Bool SdrPowerPointImport::IsNoteOrHandout( sal_uInt16 nPageNum, PptPageKind /*ePageKind*/) const
3176 {
3177 sal_Bool bNote = eAktPageKind == PPT_NOTEPAGE;
3178 if ( eAktPageKind == PPT_MASTERPAGE )
3179 bNote = ( nPageNum & 1 ) == 0;
3180 return bNote;
3181 }
3182
GetMasterPageId(sal_uInt16 nPageNum,PptPageKind ePageKind) const3183 sal_uInt32 SdrPowerPointImport::GetMasterPageId( sal_uInt16 nPageNum, PptPageKind ePageKind ) const
3184 {
3185 PptSlidePersistList* pPageList = GetPageList( ePageKind );
3186 if ( pPageList && nPageNum < pPageList->Count() )
3187 return (*pPageList)[ nPageNum ]->aSlideAtom.nMasterId;
3188 return 0;
3189 }
3190
GetNotesPageId(sal_uInt16 nPageNum) const3191 sal_uInt32 SdrPowerPointImport::GetNotesPageId( sal_uInt16 nPageNum ) const
3192 {
3193 PptSlidePersistList* pPageList=GetPageList( PPT_SLIDEPAGE );
3194 if ( pPageList && nPageNum < pPageList->Count() )
3195 return (*pPageList)[ nPageNum ]->aSlideAtom.nNotesId;
3196 return 0;
3197 }
3198
HasMasterPage(sal_uInt16 nPageNum,PptPageKind ePageKind) const3199 sal_Bool SdrPowerPointImport::HasMasterPage( sal_uInt16 nPageNum, PptPageKind ePageKind ) const
3200 {
3201 if ( ePageKind == PPT_NOTEPAGE )
3202 return aDocAtom.nNotesMasterPersist != 0;
3203 if ( ePageKind == PPT_MASTERPAGE )
3204 return sal_False;
3205 return GetMasterPageId( nPageNum, ePageKind ) != 0;
3206 }
3207
GetMasterPageIndex(sal_uInt16 nPageNum,PptPageKind ePageKind) const3208 sal_uInt16 SdrPowerPointImport::GetMasterPageIndex( sal_uInt16 nPageNum, PptPageKind ePageKind ) const
3209 {
3210 sal_uInt16 nIdx = 0;
3211 if ( ePageKind == PPT_NOTEPAGE )
3212 return 2;
3213 sal_uInt32 nId = GetMasterPageId( nPageNum, ePageKind );
3214 if ( nId && pMasterPages )
3215 {
3216 nIdx = pMasterPages->FindPage( nId );
3217 if ( nIdx == PPTSLIDEPERSIST_ENTRY_NOTFOUND )
3218 nIdx = 0;
3219 }
3220 return nIdx;
3221 }
3222
ImportPageBackgroundObject(const SdrPage & rPage,sal_uInt32 & nBgFileOffset,sal_Bool bForce)3223 SdrObject* SdrPowerPointImport::ImportPageBackgroundObject( const SdrPage& rPage, sal_uInt32& nBgFileOffset, sal_Bool bForce )
3224 {
3225 SdrObject* pRet = NULL;
3226 sal_Bool bCreateObj = bForce;
3227 SfxItemSet* pSet = NULL;
3228 sal_uLong nFPosMerk = rStCtrl.Tell(); // FilePos merken fuer spaetere Restauration
3229 DffRecordHeader aPageHd;
3230 if ( SeekToAktPage( &aPageHd ) )
3231 { // und nun die Hintergrundattribute der Page suchen
3232 sal_uLong nPageRecEnd = aPageHd.GetRecEndFilePos();
3233 DffRecordHeader aPPDrawHd;
3234 if ( SeekToRec( rStCtrl, PPT_PST_PPDrawing, nPageRecEnd, &aPPDrawHd ) )
3235 {
3236 sal_uLong nPPDrawEnd = aPPDrawHd.GetRecEndFilePos();
3237 DffRecordHeader aEscherF002Hd;
3238 if ( SeekToRec( rStCtrl, DFF_msofbtDgContainer, nPPDrawEnd, &aEscherF002Hd ) )
3239 {
3240 sal_uLong nEscherF002End = aEscherF002Hd.GetRecEndFilePos();
3241 DffRecordHeader aEscherObjectHd;
3242 if ( SeekToRec( rStCtrl, DFF_msofbtSpContainer, nEscherF002End, &aEscherObjectHd ) )
3243 {
3244 nBgFileOffset = aEscherObjectHd.GetRecBegFilePos();
3245 //sal_uLong nEscherObjectEnd = aEscherObjectHd.GetRecEndFilePos();
3246 //DffRecordHeader aEscherPropertiesHd;
3247 if ( SeekToRec( rStCtrl, DFF_msofbtOPT,nEscherF002End ) )
3248 {
3249 rStCtrl >> (DffPropertyReader&)*this;
3250 mnFix16Angle = Fix16ToAngle( GetPropertyValue( DFF_Prop_Rotation, 0 ) );
3251 sal_uInt32 nColor = GetPropertyValue( DFF_Prop_fillColor, 0xffffff );
3252 pSet = new SfxItemSet( pSdrModel->GetItemPool() );
3253 DffObjData aObjData( aEscherObjectHd, Rectangle( 0, 0, 28000, 21000 ), 0 );
3254 ApplyAttributes( rStCtrl, *pSet, aObjData );
3255 Color aColor( MSO_CLR_ToColor( nColor ) );
3256 pSet->Put( XFillColorItem( String(), aColor ) );
3257 }
3258 }
3259 }
3260 }
3261 }
3262 rStCtrl.Seek( nFPosMerk ); // FilePos restaurieren
3263 if ( bCreateObj )
3264 {
3265 if ( !pSet )
3266 {
3267 pSet = new SfxItemSet( pSdrModel->GetItemPool() );
3268 pSet->Put( XFillStyleItem( XFILL_NONE ) );
3269 }
3270 pSet->Put( XLineStyleItem( XLINE_NONE ) );
3271 Rectangle aRect( rPage.GetLftBorder(), rPage.GetUppBorder(), rPage.GetWdt()-rPage.GetRgtBorder(), rPage.GetHgt()-rPage.GetLwrBorder() );
3272 pRet = new SdrRectObj( aRect );
3273 pRet->SetModel( pSdrModel );
3274
3275 pRet->SetMergedItemSet(*pSet);
3276
3277 pRet->SetMarkProtect( sal_True );
3278 pRet->SetMoveProtect( sal_True );
3279 pRet->SetResizeProtect( sal_True );
3280 }
3281 delete pSet;
3282 return pRet;
3283 }
3284
3285 ////////////////////////////////////////////////////////////////////////////////////////////////////
3286
HeaderFooterEntry(const PptSlidePersistEntry * pMPE)3287 HeaderFooterEntry::HeaderFooterEntry( const PptSlidePersistEntry* pMPE ) :
3288 pMasterPersist ( pMPE ),
3289 nAtom ( 0 )
3290 {
3291 if ( pMPE )
3292 {
3293 HeaderFooterEntry* pMHFE = pMPE->pHeaderFooterEntry;
3294 if ( pMHFE )
3295 {
3296 nAtom = pMPE->pHeaderFooterEntry->nAtom;
3297 pPlaceholder[ 0 ] = pMHFE->pPlaceholder[ 0 ];
3298 pPlaceholder[ 1 ] = pMHFE->pPlaceholder[ 1 ];
3299 pPlaceholder[ 2 ] = pMHFE->pPlaceholder[ 2 ];
3300 pPlaceholder[ 3 ] = pMHFE->pPlaceholder[ 3 ];
3301 }
3302 }
3303 }
3304
~HeaderFooterEntry()3305 HeaderFooterEntry::~HeaderFooterEntry()
3306 {
3307 }
3308
GetMaskForInstance(sal_uInt32 nInstance)3309 sal_uInt32 HeaderFooterEntry::GetMaskForInstance( sal_uInt32 nInstance )
3310 {
3311 sal_uInt32 nRet = 0;
3312 switch ( nInstance )
3313 {
3314 case 0 : nRet = 0x07ffff; break;
3315 case 1 : nRet = 0x100000; break;
3316 case 2 : nRet = 0x200000; break;
3317 case 3 : nRet = 0x080000; break;
3318 }
3319 return nRet;
3320 }
3321
IsToDisplay(sal_uInt32 nInstance)3322 sal_uInt32 HeaderFooterEntry::IsToDisplay( sal_uInt32 nInstance )
3323 {
3324 sal_uInt32 nMask = 0;
3325 switch ( nInstance )
3326 {
3327 case 0 : nMask = 0x010000; break;
3328 case 1 : nMask = 0x100000; break;
3329 case 2 : nMask = 0x200000; break;
3330 case 3 : nMask = 0x080000; break;
3331 }
3332 return ( nAtom & nMask );
3333 }
3334
3335 // The following method checks if the slide is using a different colorscheme than
3336 // its master, if this is the fact, then the HeaderFooter must probably be
3337 // imported as real sdrobject. In this case, the return value is the offset to the
3338 // master header footer object, so it can be re-loaded with a different color set
NeedToImportInstance(const sal_uInt32 nInstance,const PptSlidePersistEntry & rSlidePersist)3339 sal_uInt32 HeaderFooterEntry::NeedToImportInstance( const sal_uInt32 nInstance, const PptSlidePersistEntry& rSlidePersist )
3340 {
3341 sal_uInt32 nRet = 0;
3342 if ( pMasterPersist )
3343 {
3344 if ( !( rSlidePersist.aSlideAtom.nFlags & 2 ) )
3345 { // not following the master persist, so we have to check if the colors are changed
3346 if ( memcmp( &rSlidePersist.aColorScheme, &pMasterPersist->aColorScheme, 32 ) )
3347 {
3348 nRet = pMasterPersist->HeaderFooterOfs[ nInstance ];
3349 }
3350 }
3351 }
3352 return nRet;
3353 }
3354
ImportHeaderFooterContainer(DffRecordHeader & rHd,HeaderFooterEntry & rE)3355 void SdrEscherImport::ImportHeaderFooterContainer( DffRecordHeader& rHd, HeaderFooterEntry& rE )
3356 {
3357 rHd.SeekToContent( rStCtrl );
3358 while ( ( rStCtrl.GetError() == 0 ) && ( rStCtrl.Tell() < rHd.GetRecEndFilePos() ) )
3359 {
3360 DffRecordHeader aHd;
3361 rStCtrl >> aHd;
3362 switch ( aHd.nRecType )
3363 {
3364 case PPT_PST_HeadersFootersAtom :
3365 rStCtrl >> rE.nAtom;
3366 break;
3367
3368 case PPT_PST_CString :
3369 {
3370 if ( aHd.nRecInstance < 4 )
3371 MSDFFReadZString( rStCtrl, rE.pPlaceholder[ aHd.nRecInstance ], aHd.nRecLen, sal_True );
3372 }
3373 break;
3374 }
3375 aHd.SeekToEndOfRecord( rStCtrl );
3376 }
3377 }
3378
3379 //static sal_Unicode PPTExportMapper( sal_Unicode nUni, sal_Bool& bNeedsStarBats )
3380 //{
3381 // bNeedsStarBats = sal_False;
3382 //
3383 // sal_Unicode cLo, cReplace;
3384 // cLo = cReplace = 0;
3385 // switch ( nUni )
3386 // {
3387 // case 132 : cLo = 175; break;
3388 // case 147 : cLo = 174; break;
3389 // // Currency
3390 // case 0x00A2: cReplace = 224; break;
3391 // case 0x00A4: cReplace = 225; break;
3392 // case 0x00A5: cReplace = 226; break;
3393 // case 0x20A1: cReplace = 228; break;
3394 // case 0x20A2: cReplace = 229; break;
3395 // case 0x20A3: cReplace = 230; break;
3396 // case 0x20A4: cReplace = 231; break;
3397 // case 0x20A7: cReplace = 227; break;
3398 // case 0x20A8: cReplace = 234; break;
3399 // case 0x20A9: cReplace = 232; break;
3400 // case 0x20AB: cReplace = 233; break;
3401 // case 0x20AC: cReplace = 128; break;
3402 // // Punctuation and other
3403 // case 0x201A: cReplace = 130; break; // SINGLE LOW-9 QUOTATION MARK
3404 // case 0x0192: cReplace = 131; break; // LATIN SMALL LETTER F WITH HOOK
3405 // case 0x201E: // DOUBLE LOW-9 QUOTATION MARK
3406 // case 0x301F: // LOW DOUBLE PRIME QUOTATION MARK
3407 // cReplace = 132; break;
3408 // case 0x2026: cReplace = 133; break; // HORIZONTAL ELLIPSES
3409 // case 0x2020: cReplace = 134; break; // DAGGER
3410 // case 0x2021: cReplace = 135; break; // DOUBLE DAGGER
3411 // case 0x02C6: cReplace = 136; break; // MODIFIER LETTER CIRCUMFLEX ACCENT
3412 // case 0x2030: cReplace = 137; break; // PER MILLE SIGN
3413 // case 0x0160: cReplace = 138; break; // LATIN CAPITAL LETTER S WITH CARON
3414 // case 0x2039: cReplace = 139; break; // SINGLE LEFT-POINTING ANGLE QUOTATION MARK
3415 // case 0x0152: cReplace = 140; break; // LATIN CAPITAL LIGATURE OE
3416 // case 0x017D: cReplace = 142; break; // LATIN CAPITAL LETTER Z WITH CARON
3417 // case 0x2018: // LEFT SINGLE QUOTATION MARK
3418 // case 0x02BB: // MODIFIER LETTER TURNED COMMA
3419 // cReplace = 145; break;
3420 // case 0x2019: // RIGHT SINGLE QUOTATION MARK
3421 // case 0x02BC: // MODIFIER LETTER APOSTROPHE
3422 // cReplace = 146; break;
3423 // case 0x201C: // LEFT DOUBLE QUOTATION MARK
3424 // case 0x301D: // REVERSED DOUBLE PRIME QUOTATION MARK
3425 // cReplace = 147; break;
3426 // case 0x201D: // RIGHT DOUBLE QUOTATION MARK
3427 // case 0x301E: // REVERSED DOUBLE PRIME QUOTATION MARK
3428 // cReplace = 148; break;
3429 // case 0x2022: cReplace = 149; break; // BULLET
3430 // case 0x2013: cReplace = 150; break; // EN DASH
3431 // case 0x2014: cReplace = 151; break; // EM DASH
3432 // case 0x02DC: cReplace = 152; break; // SMALL TILDE
3433 // case 0x2122: cReplace = 153; break; // TRADE MARK SIGN
3434 // case 0x0161: cReplace = 154; break; // LATIN SMALL LETTER S WITH CARON
3435 // case 0x203A: cReplace = 155; break; // SINGLE RIGHT-POINTING ANGLE QUOTATION MARK
3436 // case 0x0153: cReplace = 156; break; // LATIN SMALL LIGATURE OE
3437 // case 0x017E: cReplace = 158; break; // LATIN SMALL LETTER Z WITH CARON
3438 // case 0x0178: cReplace = 159; break; // LATIN CAPITAL LETTER Y WITH DIAERESIS
3439 // case 0x00B6: cReplace = 222; break; // PILCROW SIGN / PARAGRAPH SIGN
3440 // }
3441 // if ( cReplace )
3442 // {
3443 // bNeedsStarBats = sal_True;
3444 // return cReplace;
3445 // }
3446 // else
3447 // return cLo;
3448 //}
3449
3450 // no longer needed
PPTSubstitute(sal_uInt16,sal_Unicode,sal_uInt32 &,Font &,char) const3451 sal_Unicode SdrPowerPointImport::PPTSubstitute( sal_uInt16 /*nFont*/, sal_Unicode /*nChar*/,
3452 sal_uInt32& /*nMappedFontId*/, Font& /*rFont*/, char /*nDefault*/) const
3453 {
3454 return 0;
3455 }
3456
3457 ////////////////////////////////////////////////////////////////////////////////////////////////////
3458
PPTBuGraEntry(Graphic & rGraphic,sal_uInt32 nInst)3459 PPTBuGraEntry::PPTBuGraEntry( Graphic& rGraphic, sal_uInt32 nInst ) :
3460 nInstance ( nInst ),
3461 aBuGra ( rGraphic ) {}
3462
PPTExtParaLevel()3463 PPTExtParaLevel::PPTExtParaLevel()
3464 : mnExtParagraphMask( 0 )
3465 , mnBuBlip( 0xffff )
3466 , mnHasAnm( 0 )
3467 , mnAnmScheme( 0 )
3468 , mpfPP10Ext( 0 )
3469 , mnExtCharacterMask( 0 )
3470 , mcfPP10Ext( 0 )
3471 , mbSet( sal_False )
3472 {}
3473
operator >>(SvStream & rIn,PPTExtParaLevel & rLevel)3474 SvStream& operator>>( SvStream& rIn, PPTExtParaLevel& rLevel )
3475 {
3476 rLevel.mbSet = sal_True;
3477 rIn >> rLevel.mnExtParagraphMask;
3478 if ( rLevel.mnExtParagraphMask & 0x00800000 )
3479 rIn >> rLevel.mnBuBlip;
3480 if ( rLevel.mnExtParagraphMask & 0x02000000 )
3481 rIn >> rLevel.mnHasAnm;
3482 if ( rLevel.mnExtParagraphMask & 0x01000000 )
3483 rIn >> rLevel.mnAnmScheme;
3484 if ( rLevel.mnExtParagraphMask & 0x04000000 )
3485 rIn >> rLevel.mpfPP10Ext;
3486 rIn >> rLevel.mnExtCharacterMask;
3487 if ( rLevel.mnExtCharacterMask & 0x100000 )
3488 rIn >> rLevel.mcfPP10Ext;
3489 return rIn;
3490 }
3491
GetGraphic(sal_uInt32 nInstance,Graphic & rGraph) const3492 sal_Bool PPTExtParaProv::GetGraphic( sal_uInt32 nInstance, Graphic& rGraph ) const
3493 {
3494 sal_Bool bRetValue = sal_False;
3495 PPTBuGraEntry* pPtr = NULL;
3496 if ( nInstance < aBuGraList.Count() )
3497 {
3498 pPtr = (PPTBuGraEntry*)aBuGraList.GetObject( nInstance );
3499 if ( pPtr->nInstance == nInstance )
3500 bRetValue = sal_True;
3501 }
3502 if ( !bRetValue )
3503 {
3504 sal_uInt32 i;
3505 for ( i = 0; i < aBuGraList.Count(); i++ )
3506 {
3507 pPtr = (PPTBuGraEntry*)aBuGraList.GetObject( i );
3508 if ( pPtr->nInstance == nInstance )
3509 {
3510 bRetValue = sal_True;
3511 break;
3512 }
3513 }
3514 }
3515 if ( bRetValue )
3516 rGraph = pPtr->aBuGra;
3517 return bRetValue;
3518 }
3519
PPTExtParaProv(SdrPowerPointImport & rMan,SvStream & rSt,const DffRecordHeader * pHd)3520 PPTExtParaProv::PPTExtParaProv( SdrPowerPointImport& rMan, SvStream& rSt, const DffRecordHeader* pHd ) :
3521 bStyles ( sal_False ),
3522 bGraphics ( sal_False )
3523 {
3524 sal_uInt32 nOldPos = rSt.Tell();
3525
3526 // here we have to get the graphical bullets...
3527
3528 DffRecordHeader aHd;
3529 DffRecordHeader aContentDataHd;
3530
3531 const DffRecordHeader* pListHd = rMan.aDocRecManager.GetRecordHeader( PPT_PST_List, SEEK_FROM_BEGINNING );
3532 while( pListHd )
3533 {
3534 pListHd->SeekToContent( rSt );
3535 if ( !rMan.SeekToContentOfProgTag( 9, rSt, *pListHd, aContentDataHd ) )
3536 break;
3537 while ( ( rSt.GetError() == 0 ) && ( rSt.Tell() < aContentDataHd.GetRecEndFilePos() ) )
3538 {
3539 rSt >> aHd;
3540 switch ( aHd.nRecType )
3541 {
3542 case PPT_PST_ExtendedBuGraContainer :
3543 {
3544 while ( ( rSt.GetError() == 0 ) && ( rSt.Tell() < aHd.GetRecEndFilePos() ) )
3545 {
3546 sal_uInt16 nType;
3547 DffRecordHeader aBuGraAtomHd;
3548 rSt >> aBuGraAtomHd;
3549 if ( aBuGraAtomHd.nRecType == PPT_PST_ExtendedBuGraAtom )
3550 {
3551 rSt >> nType;
3552 Graphic aGraphic;
3553 if ( rMan.GetBLIPDirect( rSt, aGraphic, NULL ) )
3554 {
3555 sal_uInt32 nInstance = aBuGraAtomHd.nRecInstance;
3556 PPTBuGraEntry* pBuGra = new PPTBuGraEntry( aGraphic, nInstance );
3557 sal_uInt32 n = 0;
3558 sal_uInt32 nBuGraCount = aBuGraList.Count();
3559 if ( nBuGraCount )
3560 {
3561 if ( ( (PPTBuGraEntry*)aBuGraList.GetObject( nBuGraCount - 1 ) )->nInstance < nInstance )
3562 n = nBuGraCount;
3563 else
3564 { // maybe the instances are not sorted, we sort it
3565 for ( n = 0; n < nBuGraCount; n++ )
3566 { // sorting fields ( hi >> lo )
3567 if ( ( (PPTBuGraEntry*)aBuGraList.GetObject( n ) )->nInstance < nInstance )
3568 break;
3569 }
3570 }
3571 }
3572 aBuGraList.Insert( pBuGra, (sal_uInt32)n );
3573 }
3574 #ifdef DBG_UTIL
3575 else DBG_ERROR( "PPTExParaProv::PPTExParaProv - bullet graphic is not valid (SJ)" );
3576 #endif
3577 }
3578 #ifdef DBG_UTIL
3579 else DBG_ERROR( "PPTExParaProv::PPTExParaProv - unknown atom interpreting the PPT_PST_ExtendedBuGraContainer (SJ)" );
3580 #endif
3581 aBuGraAtomHd.SeekToEndOfRecord( rSt );
3582 }
3583 if ( aBuGraList.Count() )
3584 bGraphics = sal_True;
3585 }
3586 break;
3587
3588 case PPT_PST_ExtendedPresRuleContainer :
3589 aExtendedPresRules.Consume( rSt, sal_False, aHd.GetRecEndFilePos() );
3590 break;
3591 #ifdef DBG_UTIL
3592 default :
3593 DBG_ERROR( "PPTExParaProv::PPTExParaProv - unknown atom reading ppt2000 num rules (SJ)" );
3594 case PPT_PST_MasterText : // first seen in: ms-tt02.ppt
3595 case PPT_PST_SrKinsoku :
3596 case PPT_PST_NewlyAddedAtom4016 :
3597 case PPT_PST_NewlyAddedAtomByPPT2000_6010 :
3598 case PPT_PST_NewlyAddedAtomByPPT2000_6011 :
3599 case PPT_PST_NewlyAddedAtomByXP1037 :
3600 case PPT_PST_NewlyAddedAtomByXP12004 :
3601 case PPT_PST_NewlyAddedAtomByXP14001 :
3602 break;
3603 #endif
3604 }
3605 aHd.SeekToEndOfRecord( rSt );
3606 }
3607 break;
3608 }
3609
3610 while( pHd )
3611 { // get the extended paragraph styles on mainmaster ( graphical bullets, num ruling ... )
3612 if ( !rMan.SeekToContentOfProgTag( 9, rSt, *pHd, aContentDataHd ) )
3613 break;
3614 while ( ( rSt.GetError() == 0 ) && ( rSt.Tell() < aContentDataHd.GetRecEndFilePos() ) )
3615 {
3616 rSt >> aHd;
3617 switch ( aHd.nRecType )
3618 {
3619 case PPT_PST_ExtendedParagraphMasterAtom :
3620 {
3621 if ( aHd.nRecInstance < PPT_STYLESHEETENTRYS )
3622 {
3623 sal_uInt16 nDepth, i = 0;
3624 rSt >> nDepth;
3625 if ( i <= 5 )
3626 {
3627
3628 while ( ( rSt.GetError() == 0 ) && ( rSt.Tell() < aHd.GetRecEndFilePos() ) && ( i < nDepth ) )
3629 {
3630 bStyles = sal_True;
3631 rSt >> aExtParaSheet[ aHd.nRecInstance ].aExtParaLevel[ i++ ];
3632 }
3633 #ifdef DBG_UTIL
3634 if ( rSt.Tell() != aHd.GetRecEndFilePos() )
3635 DBG_ERROR( "PPTExParaProv::PPTExParaProv - error reading PPT_PST_ExtendedParagraphMasterAtom (SJ)" );
3636 #endif
3637 }
3638 #ifdef DBG_UTIL
3639 else DBG_ERROR( "PPTExParaProv::PPTExParaProv - depth is greater than 5 (SJ)" );
3640 #endif
3641 }
3642 #ifdef DBG_UTIL
3643 else DBG_ERROR( "PPTExParaProv::PPTExParaProv - instance out of range (SJ)" );
3644 #endif
3645 }
3646 break;
3647 default :
3648 DBG_ERROR( "PPTExParaProv::PPTExParaProv - unknown atom, assuming PPT_PST_ExtendedParagraphMasterAtom (SJ)" );
3649 case PPT_PST_NewlyAddedAtomByXP11008 :
3650 case PPT_PST_NewlyAddedAtomByXP11010 :
3651 case PPT_PST_NewlyAddedAtomByXP12010 :
3652 case PPT_PST_NewlyAddedAtomByXP12011 :
3653 case 0xf144 :
3654 break;
3655 }
3656 aHd.SeekToEndOfRecord( rSt );
3657 }
3658 break;
3659 }
3660 rSt.Seek( nOldPos );
3661 }
3662
~PPTExtParaProv()3663 PPTExtParaProv::~PPTExtParaProv()
3664 {
3665 void* pPtr;
3666 for ( pPtr = aBuGraList.First(); pPtr; pPtr = aBuGraList.Next() )
3667 delete (PPTBuGraEntry*)pPtr;
3668 }
3669
3670 ////////////////////////////////////////////////////////////////////////////////////////////////////
3671
PPTNumberFormatCreator(PPTExtParaProv * pParaProv)3672 PPTNumberFormatCreator::PPTNumberFormatCreator( PPTExtParaProv* pParaProv ) :
3673 pExtParaProv ( pParaProv )
3674 {
3675 }
3676
~PPTNumberFormatCreator()3677 PPTNumberFormatCreator::~PPTNumberFormatCreator()
3678 {
3679 delete pExtParaProv;
3680 }
3681
ImplGetExtNumberFormat(SdrPowerPointImport & rManager,SvxNumberFormat & rNumberFormat,sal_uInt32 nLevel,sal_uInt32 nInstance,sal_uInt32 nDestinationInstance,boost::optional<sal_Int16> & rStartNumbering,sal_uInt32 nFontHeight,PPTParagraphObj * pPara)3682 sal_Bool PPTNumberFormatCreator::ImplGetExtNumberFormat( SdrPowerPointImport& rManager,
3683 SvxNumberFormat& rNumberFormat, sal_uInt32 nLevel, sal_uInt32 nInstance, sal_uInt32 nDestinationInstance,
3684 boost::optional< sal_Int16 >& rStartNumbering, sal_uInt32 nFontHeight, PPTParagraphObj* pPara )
3685 {
3686 sal_Bool bHardAttribute = ( nDestinationInstance == 0xffffffff );
3687
3688 sal_uInt32 nBuFlags = 0;
3689 sal_uInt16 nHasAnm = 0;
3690 sal_uInt32 nAnmScheme = 0x10003;
3691 sal_uInt16 nBuBlip = 0xffff;
3692
3693 const PPTExtParaProv* pParaProv = pExtParaProv;
3694 if ( !pExtParaProv )
3695 pParaProv = ( pPara ) ? pPara->mrStyleSheet.pExtParaProv
3696 : rManager.pPPTStyleSheet->pExtParaProv;
3697 if ( pPara )
3698 {
3699 nBuFlags = pPara->pParaSet->mnExtParagraphMask;
3700 if ( nBuFlags )
3701 {
3702 if ( nBuFlags & 0x00800000 )
3703 nBuBlip = pPara->pParaSet->mnBuBlip;
3704 if ( nBuFlags & 0x01000000 )
3705 nAnmScheme = pPara->pParaSet->mnAnmScheme;
3706 if ( nBuFlags & 0x02000000 )
3707 nHasAnm = pPara->pParaSet->mnHasAnm;
3708 bHardAttribute = sal_True;
3709 }
3710 }
3711
3712 if ( ( nBuFlags & 0x03800000 ) != 0x03800000 ) // merge style sheet
3713 { // we have to read the master attributes
3714 if ( pParaProv && ( nLevel < 5 ) )
3715 {
3716 if ( pParaProv->bStyles )
3717 {
3718 const PPTExtParaLevel& rLev = pParaProv->aExtParaSheet[ nInstance ].aExtParaLevel[ nLevel ];
3719 if ( rLev.mbSet )
3720 {
3721 sal_uInt32 nMaBuFlags = rLev.mnExtParagraphMask;
3722
3723 if ( (!( nBuFlags & 0x00800000)) && ( nMaBuFlags & 0x00800000 ) )
3724 {
3725 if (!( nBuFlags & 0x02000000)) // if there is a BuStart without BuInstance,
3726 nBuBlip = rLev.mnBuBlip; // then there is no graphical Bullet possible
3727 }
3728 if ( (!( nBuFlags & 0x01000000)) && ( nMaBuFlags & 0x01000000 ) )
3729 nAnmScheme = rLev.mnAnmScheme;
3730 if ( (!( nBuFlags & 0x02000000)) && ( nMaBuFlags & 0x02000000 ) )
3731 nHasAnm = rLev.mnHasAnm;
3732 nBuFlags |= nMaBuFlags;
3733 }
3734 }
3735 }
3736 }
3737 if ( nBuBlip != 0xffff ) // set graphical bullet
3738 {
3739 Graphic aGraphic;
3740 if ( pParaProv->GetGraphic( nBuBlip, aGraphic ) )
3741 {
3742 SvxBrushItem aBrush( aGraphic, GPOS_MM, SID_ATTR_BRUSH );
3743 rNumberFormat.SetGraphicBrush( &aBrush );
3744 sal_uInt32 nHeight = (sal_uInt32)( (double)nFontHeight * 0.2540 * nBulletHeight + 0.5 );
3745 Size aPrefSize( aGraphic.GetPrefSize() );
3746 sal_uInt32 nWidth = ( nHeight * aPrefSize.Width() ) / aPrefSize.Height();
3747 rNumberFormat.SetGraphicSize( Size( nWidth, nHeight ) );
3748 rNumberFormat.SetNumberingType ( SVX_NUM_BITMAP );
3749 }
3750 }
3751 else if ( nHasAnm )
3752 {
3753 switch( static_cast< sal_uInt16 >( nAnmScheme ) )
3754 {
3755 default :
3756 case 0 :
3757 {
3758 rNumberFormat.SetNumberingType( SVX_NUM_CHARS_LOWER_LETTER );
3759 rNumberFormat.SetSuffix( String( RTL_CONSTASCII_USTRINGPARAM( "." ) ) );
3760 }
3761 break;
3762 case 1 :
3763 {
3764 rNumberFormat.SetNumberingType( SVX_NUM_CHARS_UPPER_LETTER );
3765 rNumberFormat.SetSuffix( String( RTL_CONSTASCII_USTRINGPARAM( "." ) ) );
3766 }
3767 break;
3768 case 2 :
3769 {
3770 rNumberFormat.SetNumberingType( SVX_NUM_ARABIC );
3771 rNumberFormat.SetSuffix( String( RTL_CONSTASCII_USTRINGPARAM( ")" ) ) );
3772 }
3773 break;
3774 case 3 :
3775 {
3776 rNumberFormat.SetNumberingType( SVX_NUM_ARABIC );
3777 rNumberFormat.SetSuffix( String( RTL_CONSTASCII_USTRINGPARAM( "." ) ) );
3778 }
3779 break;
3780 case 4 :
3781 {
3782 rNumberFormat.SetNumberingType( SVX_NUM_ROMAN_LOWER );
3783 rNumberFormat.SetSuffix( String( RTL_CONSTASCII_USTRINGPARAM( ")" ) ) );
3784 rNumberFormat.SetPrefix( String( RTL_CONSTASCII_USTRINGPARAM( "(" ) ) );
3785 }
3786 break;
3787 case 5 :
3788 {
3789 rNumberFormat.SetNumberingType( SVX_NUM_ROMAN_LOWER );
3790 rNumberFormat.SetSuffix( String( RTL_CONSTASCII_USTRINGPARAM( ")" ) ) );
3791 }
3792 break;
3793 case 6 :
3794 {
3795 rNumberFormat.SetNumberingType( SVX_NUM_ROMAN_LOWER );
3796 rNumberFormat.SetSuffix( String( RTL_CONSTASCII_USTRINGPARAM( "." ) ) );
3797 }
3798 break;
3799 case 7 :
3800 {
3801 rNumberFormat.SetNumberingType( SVX_NUM_ROMAN_UPPER );
3802 rNumberFormat.SetSuffix( String( RTL_CONSTASCII_USTRINGPARAM( "." ) ) );
3803 }
3804 break;
3805 case 8 :
3806 {
3807 rNumberFormat.SetNumberingType( SVX_NUM_CHARS_LOWER_LETTER );
3808 rNumberFormat.SetSuffix( String( RTL_CONSTASCII_USTRINGPARAM( ")" ) ) );
3809 rNumberFormat.SetPrefix( String( RTL_CONSTASCII_USTRINGPARAM( "(" ) ) );
3810 }
3811 break;
3812 case 9 :
3813 {
3814 rNumberFormat.SetNumberingType( SVX_NUM_CHARS_LOWER_LETTER );
3815 rNumberFormat.SetSuffix( String( RTL_CONSTASCII_USTRINGPARAM( ")" ) ) );
3816 }
3817 break;
3818 case 10 :
3819 {
3820 rNumberFormat.SetNumberingType( SVX_NUM_CHARS_UPPER_LETTER );
3821 rNumberFormat.SetSuffix( String( RTL_CONSTASCII_USTRINGPARAM( ")" ) ) );
3822 rNumberFormat.SetPrefix( String( RTL_CONSTASCII_USTRINGPARAM( "(" ) ) );
3823 }
3824 break;
3825 case 11 :
3826 {
3827 rNumberFormat.SetNumberingType( SVX_NUM_CHARS_UPPER_LETTER );
3828 rNumberFormat.SetSuffix( String( RTL_CONSTASCII_USTRINGPARAM( ")" ) ) );
3829 }
3830 break;
3831 case 12 :
3832 {
3833 rNumberFormat.SetNumberingType( SVX_NUM_ARABIC );
3834 rNumberFormat.SetSuffix( String( RTL_CONSTASCII_USTRINGPARAM( ")" ) ) );
3835 rNumberFormat.SetPrefix( String( RTL_CONSTASCII_USTRINGPARAM( "(" ) ) );
3836 }
3837 break;
3838 case 13 :
3839 {
3840 rNumberFormat.SetNumberingType( SVX_NUM_ARABIC );
3841 }
3842 break;
3843 case 14 :
3844 {
3845 rNumberFormat.SetNumberingType( SVX_NUM_ROMAN_UPPER );
3846 rNumberFormat.SetSuffix( String( RTL_CONSTASCII_USTRINGPARAM( ")" ) ) );
3847 rNumberFormat.SetPrefix( String( RTL_CONSTASCII_USTRINGPARAM( "(" ) ) );
3848 }
3849 break;
3850 case 15 :
3851 {
3852 rNumberFormat.SetNumberingType( SVX_NUM_ROMAN_UPPER );
3853 rNumberFormat.SetSuffix( String( RTL_CONSTASCII_USTRINGPARAM( ")" ) ) );
3854 }
3855 break;
3856 case 16: // Simplified Chinese.
3857 {
3858 rNumberFormat.SetNumberingType( SVX_NUM_NUMBER_UPPER_ZH );
3859 }
3860 break;
3861 case 17: // Simplified Chinese with single-byte period.
3862 {
3863 rNumberFormat.SetNumberingType( SVX_NUM_NUMBER_UPPER_ZH );
3864 rNumberFormat.SetSuffix( String( RTL_CONSTASCII_USTRINGPARAM( "." ) ) );
3865 }
3866 break;
3867 case 18: // Double byte circle numbers.
3868 case 19: // Wingdings white circle numbers.
3869 case 20: // Wingdings black circle numbers.
3870 {
3871 rNumberFormat.SetNumberingType( SVX_NUM_CIRCLE_NUMBER );
3872 }
3873 break;
3874 case 21: // Traditional Chinese.
3875 {
3876 rNumberFormat.SetNumberingType( SVX_NUM_NUMBER_UPPER_ZH_TW );
3877 }
3878 break;
3879 case 22: // Traditional Chinese with single-byte period.
3880 {
3881 rNumberFormat.SetNumberingType( SVX_NUM_NUMBER_UPPER_ZH_TW );
3882 rNumberFormat.SetSuffix( String( RTL_CONSTASCII_USTRINGPARAM( "." ) ) );
3883 }
3884 break;
3885 case 26: // Japanese/Korean.
3886 {
3887 rNumberFormat.SetNumberingType( SVX_NUM_NUMBER_LOWER_ZH );
3888 }
3889 break;
3890 case 27: // Japanese/Korean with single-byte period.
3891 {
3892 rNumberFormat.SetNumberingType( SVX_NUM_NUMBER_LOWER_ZH );
3893 rNumberFormat.SetSuffix( String( RTL_CONSTASCII_USTRINGPARAM( "." ) ) );
3894 }
3895 break;
3896 case 28: // Double-byte Arabic numbers.
3897 {
3898 rNumberFormat.SetNumberingType( SVX_NUM_FULL_WIDTH_ARABIC );
3899 }
3900 break;
3901 case 29: // Double-byte Arabic numbers with double-byte period.
3902 {
3903 rNumberFormat.SetNumberingType( SVX_NUM_FULL_WIDTH_ARABIC );
3904 rNumberFormat.SetSuffix( String( sal_Unicode(0xff0e) ) );
3905 }
3906 break;
3907 case 38: // Japanese with double-byte period.
3908 {
3909 rNumberFormat.SetNumberingType( SVX_NUM_NUMBER_LOWER_ZH ); // No such type. Instead with Lower Chinese Number
3910 rNumberFormat.SetSuffix( String( sal_Unicode(0xff0e) ) );
3911 }
3912 break;
3913 }
3914 rStartNumbering = boost::optional< sal_Int16 >( nAnmScheme >> 16 );
3915 sal_Int16 nBuStart = *rStartNumbering;
3916 //The Seventh bit of nBuFlags that specifies whether fBulletHasAutoNumber exists,
3917 //and fBulletHasAutoNumber that specifies whether this paragraph has an automatic numbering scheme.
3918 if ( ( nBuFlags & 0x02000000 ) && ( nBuStart != 1 ))
3919 {
3920 rNumberFormat.SetStart( static_cast<sal_uInt16>(nBuStart) );
3921 }
3922 }
3923 return bHardAttribute;
3924 }
3925
GetNumberFormat(SdrPowerPointImport & rManager,SvxNumberFormat & rNumberFormat,sal_uInt32 nLevel,const PPTParaLevel & rParaLevel,const PPTCharLevel & rCharLevel,sal_uInt32 nInstance)3926 void PPTNumberFormatCreator::GetNumberFormat( SdrPowerPointImport& rManager, SvxNumberFormat& rNumberFormat, sal_uInt32 nLevel, const PPTParaLevel& rParaLevel, const PPTCharLevel& rCharLevel, sal_uInt32 nInstance )
3927 {
3928 nIsBullet = ( rParaLevel.mnBuFlags & ( 1 << PPT_ParaAttr_BulletOn ) ) != 0 ? 1 : 0;
3929 nBulletChar = rParaLevel.mnBulletChar;
3930
3931 sal_Bool bBuHardFont;
3932 bBuHardFont = ( rParaLevel.mnBuFlags & ( 1 << PPT_ParaAttr_BuHardFont ) ) != 0;
3933 if ( bBuHardFont )
3934 nBulletFont = rParaLevel.mnBulletFont;
3935 else
3936 nBulletFont = rCharLevel.mnFont;
3937 nBulletHeight = rParaLevel.mnBulletHeight;
3938 nBulletColor = rParaLevel.mnBulletColor;
3939 nTextOfs = rParaLevel.mnTextOfs;
3940 nBulletOfs = rParaLevel.mnBulletOfs;
3941
3942 boost::optional< sal_Int16 > oStartNumbering;
3943 ImplGetExtNumberFormat( rManager, rNumberFormat, nLevel, nInstance, 0xffffffff, oStartNumbering, rCharLevel.mnFontHeight, NULL );
3944 if ( ( rNumberFormat.GetNumberingType() != SVX_NUM_BITMAP ) && ( nBulletHeight > 0x7fff ) )
3945 nBulletHeight = rCharLevel.mnFontHeight ? ((-((sal_Int16)nBulletHeight)) * 100 ) / rCharLevel.mnFontHeight : 100;
3946 ImplGetNumberFormat( rManager, rNumberFormat, nLevel );
3947 switch ( rNumberFormat.GetNumberingType() )
3948 {
3949 case SVX_NUM_CHARS_UPPER_LETTER :
3950 case SVX_NUM_CHARS_LOWER_LETTER :
3951 case SVX_NUM_ROMAN_UPPER :
3952 case SVX_NUM_ROMAN_LOWER :
3953 case SVX_NUM_ARABIC :
3954 case SVX_NUM_CHARS_UPPER_LETTER_N :
3955 case SVX_NUM_CHARS_LOWER_LETTER_N :
3956 {
3957 sal_uInt32 nFont = rCharLevel.mnFont;
3958 PptFontEntityAtom* pFontEnityAtom = rManager.GetFontEnityAtom( nFont );
3959 if ( pFontEnityAtom )
3960 {
3961 Font aFont;
3962 aFont.SetCharSet( pFontEnityAtom->eCharSet );
3963 aFont.SetName( pFontEnityAtom->aName );
3964 aFont.SetFamily( pFontEnityAtom->eFamily );
3965 aFont.SetPitch( pFontEnityAtom->ePitch );
3966 rNumberFormat.SetBulletFont( &aFont );
3967 }
3968 }
3969 break;
3970 }
3971 }
3972
GetNumberFormat(SdrPowerPointImport & rManager,SvxNumberFormat & rNumberFormat,PPTParagraphObj * pParaObj,sal_uInt32 nDestinationInstance,boost::optional<sal_Int16> & rStartNumbering)3973 sal_Bool PPTNumberFormatCreator::GetNumberFormat( SdrPowerPointImport& rManager, SvxNumberFormat& rNumberFormat, PPTParagraphObj* pParaObj,
3974 sal_uInt32 nDestinationInstance, boost::optional< sal_Int16 >& rStartNumbering )
3975 {
3976 sal_uInt32 nHardCount = 0;
3977 nHardCount += pParaObj->GetAttrib( PPT_ParaAttr_BulletOn, nIsBullet, nDestinationInstance );
3978 nHardCount += pParaObj->GetAttrib( PPT_ParaAttr_BulletChar, nBulletChar, nDestinationInstance );
3979 nHardCount += pParaObj->GetAttrib( PPT_ParaAttr_BulletFont, nBulletFont, nDestinationInstance );
3980 nHardCount += pParaObj->GetAttrib( PPT_ParaAttr_BulletHeight, nBulletHeight, nDestinationInstance );
3981 nHardCount += pParaObj->GetAttrib( PPT_ParaAttr_BulletColor, nBulletColor, nDestinationInstance );
3982 nHardCount += pParaObj->GetAttrib( PPT_ParaAttr_TextOfs, nTextOfs, nDestinationInstance );
3983 nHardCount += pParaObj->GetAttrib( PPT_ParaAttr_BulletOfs, nBulletOfs, nDestinationInstance );
3984
3985 if ( nIsBullet )
3986 rNumberFormat.SetNumberingType( SVX_NUM_CHAR_SPECIAL );
3987
3988 sal_uInt32 nFontHeight = 24;
3989 PPTPortionObj* pPtr = pParaObj->First();
3990 if ( pPtr )
3991 pPtr->GetAttrib( PPT_CharAttr_FontHeight, nFontHeight, nDestinationInstance );
3992 if ( nIsBullet )
3993 nHardCount += ImplGetExtNumberFormat( rManager, rNumberFormat, pParaObj->pParaSet->mnDepth,
3994 pParaObj->mnInstance, nDestinationInstance, rStartNumbering, nFontHeight, pParaObj );
3995
3996 if ( rNumberFormat.GetNumberingType() != SVX_NUM_BITMAP )
3997 pParaObj->UpdateBulletRelSize( nBulletHeight );
3998 if ( nHardCount )
3999 ImplGetNumberFormat( rManager, rNumberFormat, pParaObj->pParaSet->mnDepth );
4000
4001 if ( nHardCount )
4002 {
4003 switch ( rNumberFormat.GetNumberingType() )
4004 {
4005 case SVX_NUM_CHARS_UPPER_LETTER :
4006 case SVX_NUM_CHARS_LOWER_LETTER :
4007 case SVX_NUM_ROMAN_UPPER :
4008 case SVX_NUM_ROMAN_LOWER :
4009 case SVX_NUM_ARABIC :
4010 case SVX_NUM_CHARS_UPPER_LETTER_N :
4011 case SVX_NUM_CHARS_LOWER_LETTER_N :
4012 {
4013 if ( pPtr )
4014 {
4015 sal_uInt32 nFont;
4016 pPtr->GetAttrib( PPT_CharAttr_Font, nFont, nDestinationInstance );
4017 PptFontEntityAtom* pFontEnityAtom = rManager.GetFontEnityAtom( nFont );
4018 if ( pFontEnityAtom )
4019 {
4020 Font aFont;
4021 aFont.SetCharSet( pFontEnityAtom->eCharSet );
4022 aFont.SetName( pFontEnityAtom->aName );
4023 aFont.SetFamily( pFontEnityAtom->eFamily );
4024 aFont.SetPitch( pFontEnityAtom->ePitch );
4025 rNumberFormat.SetBulletFont( &aFont );
4026 }
4027 }
4028 }
4029 break;
4030 }
4031 }
4032 return ( nHardCount ) ? sal_True : sal_False;
4033 }
4034
ImplGetNumberFormat(SdrPowerPointImport & rManager,SvxNumberFormat & rNumberFormat,sal_uInt32)4035 void PPTNumberFormatCreator::ImplGetNumberFormat( SdrPowerPointImport& rManager, SvxNumberFormat& rNumberFormat, sal_uInt32 /*nLevel*/)
4036 {
4037 Font aFont;
4038 PptFontEntityAtom* pAtom = rManager.GetFontEnityAtom( nBulletFont );
4039 if ( pAtom )
4040 {
4041 CharSet eCharSet( pAtom->eCharSet );
4042 aFont.SetName( pAtom->aName );
4043 aFont.SetCharSet( eCharSet );
4044 aFont.SetFamily( pAtom->eFamily );
4045 aFont.SetPitch( pAtom->ePitch );
4046 }
4047 Color aCol( rManager.MSO_TEXT_CLR_ToColor( nBulletColor ) );
4048 aFont.SetColor( aCol );
4049
4050 sal_uInt16 nBuChar = (sal_uInt16)nBulletChar;
4051 if ( aFont.GetCharSet() == RTL_TEXTENCODING_SYMBOL )
4052 {
4053 nBuChar &= 0x00ff;
4054 nBuChar |= 0xf000;
4055 }
4056 rNumberFormat.SetBulletFont( &aFont );
4057 rNumberFormat.SetBulletChar( nBuChar );
4058 rNumberFormat.SetBulletRelSize( (sal_uInt16)nBulletHeight );
4059 rNumberFormat.SetBulletColor( aCol );
4060 sal_uInt16 nAbsLSpace = (sal_uInt16)( ( (sal_uInt32)nTextOfs * 2540 ) / 576 );
4061 sal_uInt16 nFirstLineOffset = nAbsLSpace - (sal_uInt16)( ( (sal_uInt32)nBulletOfs * 2540 ) / 576 );
4062 rNumberFormat.SetAbsLSpace( nAbsLSpace );
4063 rNumberFormat.SetFirstLineOffset( -nFirstLineOffset );
4064 }
4065
4066 ////////////////////////////////////////////////////////////////////////////////////////////////////
4067
PPTCharSheet(sal_uInt32 nInstance)4068 PPTCharSheet::PPTCharSheet( sal_uInt32 nInstance )
4069 {
4070 sal_uInt32 nColor = PPT_COLSCHEME_TEXT_UND_ZEILEN;
4071 sal_uInt16 nFontHeight(0);
4072 switch ( nInstance )
4073 {
4074 case TSS_TYPE_PAGETITLE :
4075 case TSS_TYPE_TITLE :
4076 {
4077 nColor = PPT_COLSCHEME_TITELTEXT;
4078 nFontHeight = 44;
4079 }
4080 break;
4081 case TSS_TYPE_BODY :
4082 case TSS_TYPE_SUBTITLE :
4083 case TSS_TYPE_HALFBODY :
4084 case TSS_TYPE_QUARTERBODY :
4085 nFontHeight = 32;
4086 break;
4087 case TSS_TYPE_NOTES :
4088 nFontHeight = 12;
4089 break;
4090 case TSS_TYPE_UNUSED :
4091 case TSS_TYPE_TEXT_IN_SHAPE :
4092 nFontHeight = 24;
4093 break;
4094 }
4095 for ( sal_uInt32 nDepth = 0; nDepth < 5; nDepth++ )
4096 {
4097 maCharLevel[ nDepth ].mnFlags = 0;
4098 maCharLevel[ nDepth ].mnFont = 0;
4099 maCharLevel[ nDepth ].mnAsianOrComplexFont = 0xffff;
4100 maCharLevel[ nDepth ].mnFontHeight = nFontHeight;
4101 maCharLevel[ nDepth ].mnFontColor = nColor;
4102 maCharLevel[ nDepth ].mnFontColorInStyleSheet = Color( (sal_uInt8)nColor, (sal_uInt8)( nColor >> 8 ), (sal_uInt8)( nColor >> 16 ) );
4103 maCharLevel[ nDepth ].mnEscapement = 0;
4104 }
4105 }
4106
PPTCharSheet(const PPTCharSheet & rAttr)4107 PPTCharSheet::PPTCharSheet( const PPTCharSheet& rAttr )
4108 {
4109 *this = rAttr;
4110 }
4111
Read(SvStream & rIn,sal_Bool,sal_uInt32 nLevel,sal_Bool)4112 void PPTCharSheet::Read( SvStream& rIn, sal_Bool /*bMasterStyle*/, sal_uInt32 nLevel, sal_Bool /*bFirst*/)
4113 {
4114 // Zeichenattribute
4115 sal_uInt32 nCMask;
4116 sal_uInt16 nVal16;
4117 rIn >> nCMask;
4118
4119 if ( nCMask & 0x0000FFFF )
4120 {
4121 sal_uInt16 nBitAttr;
4122 maCharLevel[ nLevel ].mnFlags &= ~( (sal_uInt16)nCMask );
4123 rIn >> nBitAttr; // Bit-Attribute (Fett, Unterstrichen, ...)
4124 maCharLevel[ nLevel ].mnFlags |= nBitAttr;
4125 }
4126 if ( nCMask & ( 1 << PPT_CharAttr_Font ) ) // 0x00010000
4127 rIn >> maCharLevel[ nLevel ].mnFont;
4128 if ( nCMask & ( 1 << PPT_CharAttr_AsianOrComplexFont ) ) // 0x00200000
4129 rIn >> maCharLevel[ nLevel ].mnAsianOrComplexFont;
4130 if ( nCMask & ( 1 << PPT_CharAttr_ANSITypeface ) ) // 0x00400000
4131 rIn >> nVal16;
4132 if ( nCMask & ( 1 << PPT_CharAttr_Symbol ) ) // 0x00800000
4133 rIn >> nVal16;
4134 if ( nCMask & ( 1 << PPT_CharAttr_FontHeight ) ) // 0x00020000
4135 rIn >> maCharLevel[ nLevel ].mnFontHeight;
4136 if ( nCMask & ( 1 << PPT_CharAttr_FontColor ) ) // 0x00040000
4137 {
4138 rIn >> maCharLevel[ nLevel ].mnFontColor;
4139 if( ! (maCharLevel[ nLevel ].mnFontColor & 0xff000000 ) )
4140 maCharLevel[ nLevel ].mnFontColor = PPT_COLSCHEME_HINTERGRUND;
4141 }
4142 if ( nCMask & ( 1 << PPT_CharAttr_Escapement ) ) // 0x00080000
4143 rIn >> maCharLevel[ nLevel ].mnEscapement;
4144 if ( nCMask & 0x00100000 ) // 0x00100000
4145 rIn >> nVal16;
4146
4147 nCMask >>= 24;
4148 while( nCMask )
4149 {
4150 if ( nCMask & 1 )
4151 {
4152 DBG_ERROR( "PPTCharSheet::Read - unknown attribute, send me this document (SJ)" );
4153 rIn >> nVal16;
4154 }
4155 nCMask >>= 1;
4156 }
4157 }
4158
PPTParaSheet(sal_uInt32 nInstance)4159 PPTParaSheet::PPTParaSheet( sal_uInt32 nInstance )
4160 {
4161 sal_uInt16 nBuFlags = 0;
4162 sal_uInt32 nBulletColor = 0x8000000;
4163 sal_uInt16 nUpperDist = 0;
4164
4165 switch ( nInstance )
4166 {
4167 case TSS_TYPE_PAGETITLE :
4168 case TSS_TYPE_TITLE :
4169 nBulletColor = PPT_COLSCHEME_TITELTEXT;
4170 break;
4171 case TSS_TYPE_BODY :
4172 case TSS_TYPE_SUBTITLE :
4173 case TSS_TYPE_HALFBODY :
4174 case TSS_TYPE_QUARTERBODY :
4175 {
4176 nBuFlags = 1;
4177 nUpperDist = 0x14;
4178 }
4179 break;
4180 case TSS_TYPE_NOTES :
4181 nUpperDist = 0x1e;
4182 break;
4183 /*
4184 default :
4185 case TSS_TYPE_UNUSED :
4186 case TSS_TYPE_TEXT_IN_SHAPE :
4187 break;
4188 */
4189 }
4190 for ( sal_uInt32 i = 0; i < 5; i++ )
4191 {
4192 maParaLevel[ i ].mnBuFlags = nBuFlags;
4193 maParaLevel[ i ].mnBulletChar = 0x2022;
4194 maParaLevel[ i ].mnBulletFont = 0;
4195 maParaLevel[ i ].mnBulletHeight = 100;
4196 maParaLevel[ i ].mnBulletColor = nBulletColor;
4197 maParaLevel[ i ].mnAdjust = 0;
4198 maParaLevel[ i ].mnLineFeed = 100;
4199 maParaLevel[ i ].mnLowerDist = 0;
4200 maParaLevel[ i ].mnUpperDist = nUpperDist;
4201 maParaLevel[ i ].mnTextOfs = 0;
4202 maParaLevel[ i ].mnBulletOfs = 0;
4203 maParaLevel[ i ].mnDefaultTab = 0x240;
4204 maParaLevel[ i ].mnAsianLineBreak = 0;
4205 maParaLevel[ i ].mnBiDi = 0;
4206 }
4207 }
4208
PPTParaSheet(const PPTParaSheet & rSheet)4209 PPTParaSheet::PPTParaSheet( const PPTParaSheet& rSheet )
4210 {
4211 *this = rSheet;
4212 }
4213
Read(SdrPowerPointImport & rManager,SvStream & rIn,sal_Bool,sal_uInt32 nLevel,sal_Bool bFirst)4214 void PPTParaSheet::Read( SdrPowerPointImport&
4215 #ifdef DBG_UTIL
4216 rManager
4217 #endif
4218 , SvStream& rIn, sal_Bool /*bMasterStyle*/,
4219 sal_uInt32 nLevel, sal_Bool bFirst )
4220 {
4221 // Absatzattribute
4222 sal_uInt16 nVal16, i, nMask16;
4223 sal_uInt32 nVal32, nPMask;
4224 rIn >> nPMask;
4225
4226 nMask16 = (sal_uInt16)nPMask & 0xf;
4227 if ( nMask16 )
4228 {
4229 rIn >> nVal16;
4230 maParaLevel[ nLevel ].mnBuFlags &=~ nMask16;
4231 nVal16 &= nMask16;
4232 maParaLevel[ nLevel ].mnBuFlags |= nVal16;
4233 }
4234 if ( nPMask & 0x0080 )
4235 rIn >> maParaLevel[ nLevel ].mnBulletChar;
4236 if ( nPMask & 0x0010 )
4237 rIn >> maParaLevel[ nLevel ].mnBulletFont;
4238 if ( nPMask & 0x0040 )
4239 {
4240 rIn >> nVal16;
4241 maParaLevel[ nLevel ].mnBulletHeight = nVal16;
4242 }
4243 if ( nPMask & 0x0020 )
4244 {
4245 rIn >> nVal32;
4246 maParaLevel[ nLevel ].mnBulletColor = nVal32;
4247 }
4248 if ( bFirst )
4249 {
4250 if ( nPMask & 0xF00 )
4251 { // AbsJust!
4252 rIn >> nVal16;
4253 maParaLevel[ nLevel ].mnAdjust = nVal16 & 3;
4254 }
4255 if ( nPMask & 0x1000 )
4256 rIn >> maParaLevel[ nLevel ].mnLineFeed;
4257 if ( nPMask & 0x2000 )
4258 rIn >> maParaLevel[ nLevel ].mnUpperDist;
4259 if ( nPMask & 0x4000 )
4260 rIn >> maParaLevel[ nLevel ].mnLowerDist;
4261 if ( nPMask & 0x8000 )
4262 rIn >> maParaLevel[ nLevel ].mnTextOfs;
4263 if ( nPMask & 0x10000 )
4264 rIn >> maParaLevel[ nLevel ].mnBulletOfs;
4265 if ( nPMask & 0x20000 )
4266 rIn >> maParaLevel[ nLevel ].mnDefaultTab;
4267 if ( nPMask & 0x200000 )
4268 {
4269 // number of tabulators
4270 rIn >> nVal16;
4271 for ( i = 0; i < nVal16; i++ )
4272 rIn >> nVal32; // reading the tabulators
4273 }
4274 if ( nPMask & 0x40000 )
4275 rIn >> nVal16;
4276 if ( nPMask & 0x80000 )
4277 rIn >> maParaLevel[ nLevel ].mnAsianLineBreak;
4278 if ( nPMask & 0x100000 )
4279 rIn >> maParaLevel[ nLevel ].mnBiDi;
4280 }
4281 else
4282 {
4283 if ( nPMask & 0x800 )
4284 {
4285 rIn >> nVal16;
4286 maParaLevel[ nLevel ].mnAdjust = nVal16 & 3;
4287 }
4288 if ( nPMask & 0x1000 )
4289 rIn >> maParaLevel[ nLevel ].mnLineFeed;
4290 if ( nPMask & 0x2000 )
4291 rIn >> maParaLevel[ nLevel ].mnUpperDist;
4292 if ( nPMask & 0x4000 )
4293 rIn >> maParaLevel[ nLevel ].mnLowerDist;
4294 if ( nPMask & 0x8000 )
4295 rIn >> nVal16;
4296 if ( nPMask & 0x100 )
4297 rIn >> maParaLevel[ nLevel ].mnTextOfs;
4298 if ( nPMask & 0x200 )
4299 rIn >> nVal16;
4300 if ( nPMask & 0x400 )
4301 rIn >> maParaLevel[ nLevel ].mnBulletOfs;
4302 if ( nPMask & 0x10000 )
4303 rIn >> nVal16;
4304 if ( nPMask & 0xe0000 )
4305 {
4306 sal_uInt16 nFlagsToModifyMask = (sal_uInt16)( ( nPMask >> 17 ) & 7 );
4307 rIn >> nVal16;
4308 // bits that are not involved to zero
4309 nVal16 &= nFlagsToModifyMask;
4310 // bits that are to change to zero
4311 maParaLevel[ nLevel ].mnAsianLineBreak &=~nFlagsToModifyMask;
4312 // now set the corresponding bits
4313 maParaLevel[ nLevel ].mnAsianLineBreak |= nVal16;
4314 }
4315 if ( nPMask & 0x100000 )
4316 {
4317 // number of tabulators
4318 rIn >> nVal16;
4319 for ( i = 0; i < nVal16; i++ )
4320 rIn >> nVal32; // reading the tabulators
4321 }
4322 if ( nPMask & 0x200000 )
4323 rIn >> maParaLevel[ nLevel ].mnBiDi; // #88602#
4324 }
4325
4326 nPMask >>= 22;
4327 while( nPMask )
4328 {
4329 if ( nPMask & 1 )
4330 {
4331 #ifdef DBG_UTIL
4332 if (!(rManager.rImportParam.nImportFlags & PPT_IMPORTFLAGS_NO_TEXT_ASSERT))
4333 {
4334 DBG_ERROR( "PPTParaSheet::Read - unknown attribute, send me this document (SJ)" );
4335 }
4336 #endif
4337 rIn >> nVal16;
4338 }
4339 nPMask >>= 1;
4340 }
4341 }
4342
UpdateBulletRelSize(sal_uInt32 nLevel,sal_uInt16 nFontHeight)4343 void PPTParaSheet::UpdateBulletRelSize( sal_uInt32 nLevel, sal_uInt16 nFontHeight )
4344 {
4345 if ( maParaLevel[ nLevel ].mnBulletHeight > 0x7fff ) // a negative value is the absolute bullet height
4346 {
4347 sal_Int16 nBulletRelSize = ( sal_Int16 )maParaLevel[ nLevel ].mnBulletHeight;
4348 nBulletRelSize = nFontHeight ? ((-nBulletRelSize) * 100 ) / nFontHeight : 100;
4349 if ( nBulletRelSize < 0 ) //bullet size over flow
4350 nBulletRelSize = 100;
4351 maParaLevel[ nLevel ].mnBulletHeight = nBulletRelSize;
4352 }
4353 }
4354
PPTStyleSheet(const DffRecordHeader & rSlideHd,SvStream & rIn,SdrPowerPointImport & rManager,const PPTTextCharacterStyleAtomInterpreter &,const PPTTextParagraphStyleAtomInterpreter & rTxPFStyle,const PPTTextSpecInfo & rTextSpecInfo)4355 PPTStyleSheet::PPTStyleSheet( const DffRecordHeader& rSlideHd, SvStream& rIn, SdrPowerPointImport& rManager,
4356 const PPTTextCharacterStyleAtomInterpreter& /*rTxCFStyle*/, const PPTTextParagraphStyleAtomInterpreter& rTxPFStyle,
4357 const PPTTextSpecInfo& rTextSpecInfo ) :
4358
4359 PPTNumberFormatCreator ( new PPTExtParaProv( rManager, rIn, &rSlideHd ) ),
4360 maTxSI ( rTextSpecInfo )
4361 {
4362 sal_uInt32 i;
4363 sal_uInt32 nOldFilePos = rIn.Tell();
4364
4365 // default stylesheets
4366 mpCharSheet[ TSS_TYPE_PAGETITLE ] = new PPTCharSheet( TSS_TYPE_PAGETITLE );
4367 mpCharSheet[ TSS_TYPE_BODY ] = new PPTCharSheet( TSS_TYPE_BODY );
4368 mpCharSheet[ TSS_TYPE_NOTES ] = new PPTCharSheet( TSS_TYPE_NOTES );
4369 mpCharSheet[ TSS_TYPE_UNUSED ] = new PPTCharSheet( TSS_TYPE_UNUSED ); // this entry is not used by ppt
4370 mpCharSheet[ TSS_TYPE_TEXT_IN_SHAPE ] = new PPTCharSheet( TSS_TYPE_TEXT_IN_SHAPE );
4371 mpParaSheet[ TSS_TYPE_PAGETITLE ] = new PPTParaSheet( TSS_TYPE_PAGETITLE );
4372 mpParaSheet[ TSS_TYPE_BODY ] = new PPTParaSheet( TSS_TYPE_BODY );
4373 mpParaSheet[ TSS_TYPE_NOTES ] = new PPTParaSheet( TSS_TYPE_NOTES );
4374 mpParaSheet[ TSS_TYPE_UNUSED ] = new PPTParaSheet( TSS_TYPE_UNUSED );
4375 mpParaSheet[ TSS_TYPE_TEXT_IN_SHAPE ] = new PPTParaSheet( TSS_TYPE_TEXT_IN_SHAPE );
4376 mpCharSheet[ TSS_TYPE_QUARTERBODY ] = mpCharSheet[ TSS_TYPE_HALFBODY ] = mpCharSheet[ TSS_TYPE_TITLE ] = mpCharSheet[ TSS_TYPE_SUBTITLE ] = NULL;
4377 mpParaSheet[ TSS_TYPE_QUARTERBODY ] = mpParaSheet[ TSS_TYPE_HALFBODY ] = mpParaSheet[ TSS_TYPE_TITLE ] = mpParaSheet[ TSS_TYPE_SUBTITLE ] = NULL;
4378
4379 /* SJ: try to locate the txMasterStyleAtom in the Environment
4380
4381 it seems that the environment TextStyle is having a higher priority
4382 than the TextStyle that can be found within the master page
4383 */
4384 sal_Bool bFoundTxMasterStyleAtom04 = sal_False;
4385 DffRecordHeader* pEnvHeader = rManager.aDocRecManager.GetRecordHeader( PPT_PST_Environment );
4386 if ( pEnvHeader )
4387 {
4388 pEnvHeader->SeekToContent( rIn );
4389 DffRecordHeader aTxMasterStyleHd;
4390 while ( rIn.Tell() < pEnvHeader->GetRecEndFilePos() )
4391 {
4392 rIn >> aTxMasterStyleHd;
4393 if ( aTxMasterStyleHd.nRecType == PPT_PST_TxMasterStyleAtom )
4394 {
4395 sal_uInt16 nLevelAnz;
4396 rIn >> nLevelAnz;
4397
4398 if (nLevelAnz > 5)
4399 {
4400 throw std::range_error("Bad input file, Too many stylesheet levels");
4401 }
4402
4403 sal_uInt16 nLev = 0;
4404 sal_Bool bFirst = sal_True;
4405 bFoundTxMasterStyleAtom04 = sal_True;
4406 while ( rIn.GetError() == 0 && rIn.Tell() < aTxMasterStyleHd.GetRecEndFilePos() && nLev < nLevelAnz )
4407 {
4408 if ( nLev )
4409 {
4410 mpParaSheet[ TSS_TYPE_TEXT_IN_SHAPE ]->maParaLevel[ nLev ] = mpParaSheet[ TSS_TYPE_TEXT_IN_SHAPE ]->maParaLevel[ nLev - 1 ];
4411 mpCharSheet[ TSS_TYPE_TEXT_IN_SHAPE ]->maCharLevel[ nLev ] = mpCharSheet[ TSS_TYPE_TEXT_IN_SHAPE ]->maCharLevel[ nLev - 1 ];
4412 }
4413 mpParaSheet[ TSS_TYPE_TEXT_IN_SHAPE ]->Read( rManager, rIn, sal_True, nLev, bFirst );
4414 if ( !nLev )
4415 {
4416 // set paragraph defaults for instance 4 (TSS_TYPE_TEXT_IN_SHAPE)
4417 if ( rTxPFStyle.bValid )
4418 {
4419 PPTParaLevel& rParaLevel = mpParaSheet[ TSS_TYPE_TEXT_IN_SHAPE ]->maParaLevel[ 0 ];
4420 rParaLevel.mnAsianLineBreak = 0;
4421 if ( rTxPFStyle.bForbiddenRules )
4422 rParaLevel.mnAsianLineBreak |= 1;
4423 if ( !rTxPFStyle.bLatinTextWrap )
4424 rParaLevel.mnAsianLineBreak |= 2;
4425 if ( rTxPFStyle.bHangingPunctuation )
4426 rParaLevel.mnAsianLineBreak |= 4;
4427 }
4428 }
4429 mpCharSheet[ TSS_TYPE_TEXT_IN_SHAPE ]->Read( rIn, sal_True, nLev, bFirst );
4430 mpParaSheet[ TSS_TYPE_TEXT_IN_SHAPE ]->UpdateBulletRelSize( nLev, mpCharSheet[ TSS_TYPE_TEXT_IN_SHAPE ]->maCharLevel[ nLev ].mnFontHeight );
4431 bFirst = sal_False;
4432 nLev++;
4433 }
4434 break;
4435 }
4436 else
4437 aTxMasterStyleHd.SeekToEndOfRecord( rIn );
4438 }
4439 }
4440
4441 rSlideHd.SeekToContent( rIn );
4442 DffRecordHeader aTxMasterStyleHd;
4443 while ( rIn.Tell() < rSlideHd.GetRecEndFilePos() )
4444 {
4445 rIn >> aTxMasterStyleHd;
4446 if ( aTxMasterStyleHd.nRecType == PPT_PST_TxMasterStyleAtom )
4447 break;
4448 else
4449 aTxMasterStyleHd.SeekToEndOfRecord( rIn );
4450 }
4451 while ( ( aTxMasterStyleHd.nRecType == PPT_PST_TxMasterStyleAtom ) && ( rIn.Tell() < rSlideHd.GetRecEndFilePos() ) ) //TODO: aTxMasterStyleHd may be used without having been properly initialized
4452 {
4453 sal_uInt32 nInstance = aTxMasterStyleHd.nRecInstance;
4454 if ( ( nInstance < PPT_STYLESHEETENTRYS ) &&
4455 ( ( nInstance != TSS_TYPE_TEXT_IN_SHAPE ) || ( bFoundTxMasterStyleAtom04 == sal_False ) ) )
4456 {
4457 if ( nInstance > 4 )
4458 {
4459 delete mpCharSheet[ nInstance ]; // be sure to delete the old one if this instance comes twice
4460 delete mpParaSheet[ nInstance ];
4461
4462 switch ( nInstance )
4463 {
4464 case TSS_TYPE_SUBTITLE :
4465 {
4466 mpCharSheet[ TSS_TYPE_SUBTITLE ] = new PPTCharSheet( *( mpCharSheet[ TSS_TYPE_BODY ] ) );
4467 mpParaSheet[ TSS_TYPE_SUBTITLE ] = new PPTParaSheet( *( mpParaSheet[ TSS_TYPE_BODY ] ) );
4468 }
4469 break;
4470 case TSS_TYPE_TITLE :
4471 {
4472 mpCharSheet[ TSS_TYPE_TITLE ] = new PPTCharSheet( *( mpCharSheet[ TSS_TYPE_PAGETITLE ] ) );
4473 mpParaSheet[ TSS_TYPE_TITLE ] = new PPTParaSheet( *( mpParaSheet[ TSS_TYPE_PAGETITLE ] ) );
4474 }
4475 break;
4476 case TSS_TYPE_HALFBODY :
4477 {
4478 mpCharSheet[ TSS_TYPE_HALFBODY ] = new PPTCharSheet( *( mpCharSheet[ TSS_TYPE_BODY ] ) );
4479 mpParaSheet[ TSS_TYPE_HALFBODY ] = new PPTParaSheet( *( mpParaSheet[ TSS_TYPE_BODY ] ) );
4480 }
4481 break;
4482
4483 case TSS_TYPE_QUARTERBODY :
4484 {
4485 mpCharSheet[ TSS_TYPE_QUARTERBODY ] = new PPTCharSheet( *( mpCharSheet[ TSS_TYPE_BODY ] ) );
4486 mpParaSheet[ TSS_TYPE_QUARTERBODY ] = new PPTParaSheet( *( mpParaSheet[ TSS_TYPE_BODY ] ) );
4487 }
4488 break;
4489 }
4490 }
4491 sal_uInt16 nLevelAnz;
4492 rIn >> nLevelAnz;
4493 if ( nLevelAnz > 5 )
4494 {
4495 DBG_ERROR( "PPTStyleSheet::Ppt-TextStylesheet hat mehr als 5 Ebenen! (SJ)" );
4496 nLevelAnz = 5;
4497 }
4498 sal_uInt16 nLev = 0;
4499 sal_Bool bFirst = sal_True;
4500
4501 while ( rIn.GetError() == 0 && rIn.Tell() < aTxMasterStyleHd.GetRecEndFilePos() && nLev < nLevelAnz )
4502 {
4503 if ( nLev && ( nInstance < 5 ) )
4504 {
4505 mpParaSheet[ nInstance ]->maParaLevel[ nLev ] = mpParaSheet[ nInstance ]->maParaLevel[ nLev - 1 ];
4506 mpCharSheet[ nInstance ]->maCharLevel[ nLev ] = mpCharSheet[ nInstance ]->maCharLevel[ nLev - 1 ];
4507 }
4508
4509 // Ausnahme: Vorlage 5, 6 (MasterTitle Titel und SubTitel)
4510 if ( nInstance >= TSS_TYPE_SUBTITLE )
4511 {
4512 bFirst = sal_False;
4513
4514 sal_uInt16 nDontKnow;
4515 rIn >> nDontKnow;
4516 }
4517 mpParaSheet[ nInstance ]->Read( rManager, rIn, sal_True, nLev, bFirst );
4518 mpCharSheet[ nInstance ]->Read( rIn, sal_True, nLev, bFirst );
4519 mpParaSheet[ nInstance ]->UpdateBulletRelSize( nLev, mpCharSheet[ nInstance ]->maCharLevel[ nLev ].mnFontHeight );
4520 bFirst = sal_False;
4521 nLev++;
4522 }
4523 #ifdef DBG_UTIL
4524 if (!(rManager.rImportParam.nImportFlags & PPT_IMPORTFLAGS_NO_TEXT_ASSERT))
4525 {
4526 if ( rIn.GetError() == 0 )
4527 {
4528 ByteString aMsg;
4529 if ( rIn.Tell() > aTxMasterStyleHd.GetRecEndFilePos() )
4530 {
4531 aMsg += "\n ";
4532 aMsg += "reading too many bytes:";
4533 aMsg += ByteString::CreateFromInt32( rIn.Tell() - aTxMasterStyleHd.GetRecEndFilePos() );
4534 }
4535 if ( rIn.Tell() < aTxMasterStyleHd.GetRecEndFilePos() )
4536 {
4537 aMsg += "\n ";
4538 aMsg += "reading too less bytes:";
4539 aMsg += ByteString::CreateFromInt32( aTxMasterStyleHd.GetRecEndFilePos() - rIn.Tell() );
4540 }
4541 if ( aMsg.Len() != 0 )
4542 {
4543 aMsg.Insert( "]:", 0 );
4544 aMsg.Insert( "PptStyleSheet::operator>>[", 0 );
4545 DBG_ERROR(aMsg.GetBuffer());
4546 }
4547 }
4548 if ( rIn.Tell() != aTxMasterStyleHd.GetRecEndFilePos() )
4549 DBG_ASSERT(0, "SJ: Falsche Anzahl von Bytes gelesen beim Import der PPT-Formatvorlagen");
4550 }
4551 #endif
4552 }
4553 aTxMasterStyleHd.SeekToEndOfRecord( rIn );
4554 rIn >> aTxMasterStyleHd;
4555 }
4556 if ( !mpCharSheet[ TSS_TYPE_SUBTITLE ] )
4557 {
4558 mpCharSheet[ TSS_TYPE_SUBTITLE ] = new PPTCharSheet( *( mpCharSheet[ TSS_TYPE_BODY ] ) );
4559 mpParaSheet[ TSS_TYPE_SUBTITLE ] = new PPTParaSheet( *( mpParaSheet[ TSS_TYPE_BODY ] ) );
4560 }
4561 if ( !mpCharSheet[ TSS_TYPE_TITLE ] )
4562 {
4563 mpCharSheet[ TSS_TYPE_TITLE ] = new PPTCharSheet( *( mpCharSheet[ TSS_TYPE_PAGETITLE ] ) );
4564 mpParaSheet[ TSS_TYPE_TITLE ] = new PPTParaSheet( *( mpParaSheet[ TSS_TYPE_PAGETITLE ] ) );
4565 }
4566 if ( !mpCharSheet[ TSS_TYPE_HALFBODY ] )
4567 {
4568 mpCharSheet[ TSS_TYPE_HALFBODY ] = new PPTCharSheet( *( mpCharSheet[ TSS_TYPE_BODY ] ) );
4569 mpParaSheet[ TSS_TYPE_HALFBODY ] = new PPTParaSheet( *( mpParaSheet[ TSS_TYPE_BODY ] ) );
4570 }
4571 if ( !mpCharSheet[ TSS_TYPE_QUARTERBODY ] )
4572 {
4573 mpCharSheet[ TSS_TYPE_QUARTERBODY ] = new PPTCharSheet( *( mpCharSheet[ TSS_TYPE_BODY ] ) );
4574 mpParaSheet[ TSS_TYPE_QUARTERBODY ] = new PPTParaSheet( *( mpParaSheet[ TSS_TYPE_BODY ] ) );
4575 }
4576 if ( !bFoundTxMasterStyleAtom04 )
4577 { // try to locate the txMasterStyleAtom in the Environment
4578 DffRecordHeader* pEnvHeader2 = rManager.aDocRecManager.GetRecordHeader( PPT_PST_Environment );
4579 if ( pEnvHeader2 )
4580 {
4581 pEnvHeader2->SeekToContent( rIn );
4582 DffRecordHeader aTxMasterStyleHd2;
4583 while ( rIn.Tell() < pEnvHeader2->GetRecEndFilePos() )
4584 {
4585 rIn >> aTxMasterStyleHd2;
4586 if ( aTxMasterStyleHd2.nRecType == PPT_PST_TxMasterStyleAtom )
4587 {
4588 sal_uInt16 nLevelAnz;
4589 rIn >> nLevelAnz;
4590
4591 sal_uInt16 nLev = 0;
4592 sal_Bool bFirst = sal_True;
4593 while ( rIn.GetError() == 0 && rIn.Tell() < aTxMasterStyleHd2.GetRecEndFilePos() && nLev < nLevelAnz )
4594 {
4595 if ( nLev )
4596 {
4597 mpParaSheet[ TSS_TYPE_TEXT_IN_SHAPE ]->maParaLevel[ nLev ] = mpParaSheet[ TSS_TYPE_TEXT_IN_SHAPE ]->maParaLevel[ nLev - 1 ];
4598 mpCharSheet[ TSS_TYPE_TEXT_IN_SHAPE ]->maCharLevel[ nLev ] = mpCharSheet[ TSS_TYPE_TEXT_IN_SHAPE ]->maCharLevel[ nLev - 1 ];
4599 }
4600 mpParaSheet[ TSS_TYPE_TEXT_IN_SHAPE ]->Read( rManager, rIn, sal_True, nLev, bFirst );
4601 if ( !nLev )
4602 {
4603 // set paragraph defaults for instance 4 (TSS_TYPE_TEXT_IN_SHAPE)
4604 if ( rTxPFStyle.bValid )
4605 {
4606 PPTParaLevel& rParaLevel = mpParaSheet[ TSS_TYPE_TEXT_IN_SHAPE ]->maParaLevel[ 0 ];
4607 rParaLevel.mnAsianLineBreak = 0;
4608 if ( rTxPFStyle.bForbiddenRules )
4609 rParaLevel.mnAsianLineBreak |= 1;
4610 if ( !rTxPFStyle.bLatinTextWrap )
4611 rParaLevel.mnAsianLineBreak |= 2;
4612 if ( rTxPFStyle.bHangingPunctuation )
4613 rParaLevel.mnAsianLineBreak |= 4;
4614 }
4615 }
4616 mpCharSheet[ TSS_TYPE_TEXT_IN_SHAPE ]->Read( rIn, sal_True, nLev, bFirst );
4617 mpParaSheet[ TSS_TYPE_TEXT_IN_SHAPE ]->UpdateBulletRelSize( nLev, mpCharSheet[ TSS_TYPE_TEXT_IN_SHAPE ]->maCharLevel[ nLev ].mnFontHeight );
4618 bFirst = sal_False;
4619 nLev++;
4620 }
4621 break;
4622 }
4623 else
4624 aTxMasterStyleHd2.SeekToEndOfRecord( rIn );
4625 }
4626 }
4627 }
4628 rIn.Seek( nOldFilePos );
4629
4630 // will will create the default numbulletitem for each instance
4631 for ( i = 0; i < PPT_STYLESHEETENTRYS; i++ )
4632 {
4633 sal_uInt16 nLevels, nDepth = 0;
4634 SvxNumRuleType eNumRuleType;
4635
4636 switch ( i )
4637 {
4638 case TSS_TYPE_PAGETITLE :
4639 case TSS_TYPE_TITLE :
4640 nLevels = 1;
4641 eNumRuleType = SVX_RULETYPE_NUMBERING;
4642 break;
4643 case TSS_TYPE_SUBTITLE :
4644 nLevels = 10;
4645 eNumRuleType = SVX_RULETYPE_NUMBERING;
4646 break;
4647 case TSS_TYPE_BODY :
4648 case TSS_TYPE_HALFBODY :
4649 case TSS_TYPE_QUARTERBODY :
4650 nLevels = 10;
4651 eNumRuleType = SVX_RULETYPE_PRESENTATION_NUMBERING;
4652 break;
4653 default :
4654 case TSS_TYPE_NOTES :
4655 case TSS_TYPE_UNUSED :
4656 case TSS_TYPE_TEXT_IN_SHAPE :
4657 nLevels = 10;
4658 eNumRuleType = SVX_RULETYPE_NUMBERING;
4659 break;
4660 }
4661 SvxNumRule aRule( NUM_BULLET_REL_SIZE | NUM_BULLET_COLOR |
4662 NUM_CHAR_TEXT_DISTANCE | NUM_SYMBOL_ALIGNMENT,
4663 nLevels, sal_False, eNumRuleType );
4664 for ( sal_uInt16 nCount = 0; nDepth < nLevels; nCount++ )
4665 {
4666 const PPTParaLevel& rParaLevel = mpParaSheet[ i ]->maParaLevel[ nCount ];
4667 const PPTCharLevel& rCharLevel = mpCharSheet[ i ]->maCharLevel[ nCount ];
4668 SvxNumberFormat aNumberFormat( SVX_NUM_CHAR_SPECIAL );
4669 aNumberFormat.SetBulletChar( ' ' );
4670 GetNumberFormat( rManager, aNumberFormat, nCount, rParaLevel, rCharLevel, i );
4671 aRule.SetLevel( nDepth++, aNumberFormat );
4672 if ( nCount >= 4 )
4673 {
4674 for ( ;nDepth < nLevels; nDepth++ )
4675 aRule.SetLevel( nDepth, aNumberFormat );
4676 if ( eNumRuleType == SVX_RULETYPE_PRESENTATION_NUMBERING )
4677 aRule.SetLevel( 0, aNumberFormat );
4678 }
4679 }
4680 mpNumBulletItem[ i ] = new SvxNumBulletItem( aRule, EE_PARA_NUMBULLET );
4681 }
4682 }
4683
~PPTStyleSheet()4684 PPTStyleSheet::~PPTStyleSheet()
4685 {
4686 for ( sal_uInt32 i = 0; i < PPT_STYLESHEETENTRYS; i++ )
4687 {
4688 delete mpCharSheet[ i ];
4689 delete mpParaSheet[ i ];
4690 delete mpNumBulletItem[ i ];
4691 }
4692 }
4693
4694 ////////////////////////////////////////////////////////////////////////////////////////////////////
4695
PPTParaPropSet()4696 PPTParaPropSet::PPTParaPropSet() :
4697 pParaSet( new ImplPPTParaPropSet )
4698 {
4699 pParaSet->mnHasAnm = 1;
4700 }
4701
PPTParaPropSet(PPTParaPropSet & rParaPropSet)4702 PPTParaPropSet::PPTParaPropSet( PPTParaPropSet& rParaPropSet )
4703 {
4704 pParaSet = rParaPropSet.pParaSet;
4705 pParaSet->mnRefCount++;
4706
4707 mnOriginalTextPos = rParaPropSet.mnOriginalTextPos;
4708 }
4709
~PPTParaPropSet()4710 PPTParaPropSet::~PPTParaPropSet()
4711 {
4712 if ( ! ( --pParaSet->mnRefCount ) )
4713 delete pParaSet;
4714 }
4715
operator =(PPTParaPropSet & rParaPropSet)4716 PPTParaPropSet& PPTParaPropSet::operator=( PPTParaPropSet& rParaPropSet )
4717 {
4718 if ( this != &rParaPropSet )
4719 {
4720 if ( ! ( --pParaSet->mnRefCount ) )
4721 delete pParaSet;
4722 pParaSet = rParaPropSet.pParaSet;
4723 pParaSet->mnRefCount++;
4724
4725 mnOriginalTextPos = rParaPropSet.mnOriginalTextPos;
4726 }
4727 return *this;
4728 }
4729
PPTCharPropSet(sal_uInt32 nParagraph)4730 PPTCharPropSet::PPTCharPropSet( sal_uInt32 nParagraph ) :
4731 mnParagraph ( nParagraph ),
4732 mpFieldItem ( NULL ),
4733 pCharSet ( new ImplPPTCharPropSet )
4734 {
4735 mnHylinkOrigColor = 0;
4736 mbIsHyperlink = sal_False;
4737 mbHardHylinkOrigColor = sal_False;
4738 mnLanguage[ 0 ] = mnLanguage[ 1 ] = mnLanguage[ 2 ] = 0;
4739 }
4740
PPTCharPropSet(PPTCharPropSet & rCharPropSet)4741 PPTCharPropSet::PPTCharPropSet( PPTCharPropSet& rCharPropSet )
4742 {
4743 mnHylinkOrigColor = rCharPropSet.mnHylinkOrigColor;
4744 mbIsHyperlink = rCharPropSet.mbIsHyperlink;
4745 mbHardHylinkOrigColor = rCharPropSet.mbHardHylinkOrigColor;
4746 pCharSet = rCharPropSet.pCharSet;
4747 pCharSet->mnRefCount++;
4748
4749 mnParagraph = rCharPropSet.mnParagraph;
4750 mnOriginalTextPos = rCharPropSet.mnOriginalTextPos;
4751 maString = rCharPropSet.maString;
4752 mpFieldItem = ( rCharPropSet.mpFieldItem ) ? new SvxFieldItem( *rCharPropSet.mpFieldItem ) : NULL;
4753 mnLanguage[ 0 ] = rCharPropSet.mnLanguage[ 0 ];
4754 mnLanguage[ 1 ] = rCharPropSet.mnLanguage[ 1 ];
4755 mnLanguage[ 2 ] = rCharPropSet.mnLanguage[ 2 ];
4756 }
4757
PPTCharPropSet(PPTCharPropSet & rCharPropSet,sal_uInt32 nParagraph)4758 PPTCharPropSet::PPTCharPropSet( PPTCharPropSet& rCharPropSet, sal_uInt32 nParagraph )
4759 {
4760 pCharSet = rCharPropSet.pCharSet;
4761 pCharSet->mnRefCount++;
4762
4763 mnHylinkOrigColor = rCharPropSet.mnHylinkOrigColor;
4764 mbIsHyperlink = rCharPropSet.mbIsHyperlink;
4765 mbHardHylinkOrigColor = rCharPropSet.mbHardHylinkOrigColor;
4766
4767 mnParagraph = nParagraph;
4768 mnOriginalTextPos = rCharPropSet.mnOriginalTextPos;
4769 maString = rCharPropSet.maString;
4770 mpFieldItem = ( rCharPropSet.mpFieldItem ) ? new SvxFieldItem( *rCharPropSet.mpFieldItem ) : NULL;
4771 mnLanguage[ 0 ] = mnLanguage[ 1 ] = mnLanguage[ 2 ] = 0;
4772 }
4773
~PPTCharPropSet()4774 PPTCharPropSet::~PPTCharPropSet()
4775 {
4776 if ( ! ( --pCharSet->mnRefCount ) )
4777 delete pCharSet;
4778 delete mpFieldItem;
4779 }
4780
operator =(PPTCharPropSet & rCharPropSet)4781 PPTCharPropSet& PPTCharPropSet::operator=( PPTCharPropSet& rCharPropSet )
4782 {
4783 if ( this != &rCharPropSet )
4784 {
4785 if ( ! ( --pCharSet->mnRefCount ) )
4786 delete pCharSet;
4787 pCharSet = rCharPropSet.pCharSet;
4788 pCharSet->mnRefCount++;
4789
4790 mnOriginalTextPos = rCharPropSet.mnOriginalTextPos;
4791 mnParagraph = rCharPropSet.mnParagraph;
4792 maString = rCharPropSet.maString;
4793 mpFieldItem = ( rCharPropSet.mpFieldItem ) ? new SvxFieldItem( *rCharPropSet.mpFieldItem ) : NULL;
4794 }
4795 return *this;
4796 }
4797
ImplMakeUnique()4798 void PPTCharPropSet::ImplMakeUnique()
4799 {
4800 if ( pCharSet->mnRefCount > 1 )
4801 {
4802 ImplPPTCharPropSet& rOld = *pCharSet;
4803 rOld.mnRefCount--;
4804 pCharSet = new ImplPPTCharPropSet( rOld );
4805 pCharSet->mnRefCount = 1;
4806 }
4807 }
4808
SetFont(sal_uInt16 nFont)4809 void PPTCharPropSet::SetFont( sal_uInt16 nFont )
4810 {
4811 sal_uInt32 nMask = 1 << PPT_CharAttr_Font;
4812 sal_uInt32 bDoNotMake = pCharSet->mnAttrSet & nMask;
4813
4814 if ( bDoNotMake )
4815 bDoNotMake = nFont == pCharSet->mnFont;
4816
4817 if ( !bDoNotMake )
4818 {
4819 ImplMakeUnique();
4820 pCharSet->mnFont = nFont;
4821 pCharSet->mnAttrSet |= nMask;
4822 }
4823 }
4824
SetColor(sal_uInt32 nColor)4825 void PPTCharPropSet::SetColor( sal_uInt32 nColor )
4826 {
4827 ImplMakeUnique();
4828 pCharSet->mnColor = nColor;
4829 pCharSet->mnAttrSet |= 1 << PPT_CharAttr_FontColor;
4830 }
4831
4832 ////////////////////////////////////////////////////////////////////////////////////////////////////
4833
PPTRuler()4834 PPTRuler::PPTRuler() :
4835 nRefCount ( 1 ),
4836 nFlags ( 0 ),
4837 pTab ( NULL ),
4838 nTabCount ( 0 )
4839 {
4840 }
4841
~PPTRuler()4842 PPTRuler::~PPTRuler()
4843 {
4844 delete[] pTab;
4845 };
4846
4847
PPTTextRulerInterpreter()4848 PPTTextRulerInterpreter::PPTTextRulerInterpreter() :
4849 mpImplRuler ( new PPTRuler() )
4850 {
4851 }
4852
PPTTextRulerInterpreter(PPTTextRulerInterpreter & rRuler)4853 PPTTextRulerInterpreter::PPTTextRulerInterpreter( PPTTextRulerInterpreter& rRuler )
4854 {
4855 mpImplRuler = rRuler.mpImplRuler;
4856 mpImplRuler->nRefCount++;
4857 }
4858
PPTTextRulerInterpreter(sal_uInt32 nFileOfs,SdrPowerPointImport & rMan,DffRecordHeader & rHeader,SvStream & rIn)4859 PPTTextRulerInterpreter::PPTTextRulerInterpreter( sal_uInt32 nFileOfs, SdrPowerPointImport& rMan, DffRecordHeader& rHeader, SvStream& rIn ) :
4860 mpImplRuler ( new PPTRuler() )
4861 {
4862 if ( nFileOfs != 0xffffffff )
4863 {
4864 sal_uInt32 nOldPos = rIn.Tell();
4865 DffRecordHeader rHd;
4866 if ( nFileOfs )
4867 {
4868 rIn.Seek( nFileOfs );
4869 rIn >> rHd;
4870 }
4871 else
4872 {
4873 rHeader.SeekToContent( rIn );
4874 if ( rMan.SeekToRec( rIn, PPT_PST_TextRulerAtom, rHeader.GetRecEndFilePos(), &rHd ) )
4875 nFileOfs++;
4876 }
4877 if ( nFileOfs )
4878 {
4879 sal_Int16 nTCount;
4880 sal_Int32 i;
4881 rIn >> mpImplRuler->nFlags;
4882 if ( mpImplRuler->nFlags & 1 )
4883 rIn >> mpImplRuler->nDefaultTab;
4884 if ( mpImplRuler->nFlags & 4 )
4885 {
4886 rIn >> nTCount;
4887 if ( nTCount )
4888 {
4889 mpImplRuler->nTabCount = (sal_uInt16)nTCount;
4890 mpImplRuler->pTab = new PPTTabEntry[ mpImplRuler->nTabCount ];
4891 for ( i = 0; i < nTCount; i++ )
4892 {
4893 rIn >> mpImplRuler->pTab[ i ].nOffset
4894 >> mpImplRuler->pTab[ i ].nStyle;
4895 }
4896 }
4897 }
4898 for ( i = 0; i < 5; i++ )
4899 {
4900 if ( mpImplRuler->nFlags & ( 8 << i ) )
4901 rIn >> mpImplRuler->nTextOfs[ i ];
4902 if ( mpImplRuler->nFlags & ( 256 << i ) )
4903 rIn >> mpImplRuler->nBulletOfs[ i ];
4904 }
4905 }
4906 rIn.Seek( nOldPos );
4907 }
4908 }
4909
GetDefaultTab(sal_uInt32,sal_uInt16 & nValue) const4910 sal_Bool PPTTextRulerInterpreter::GetDefaultTab( sal_uInt32 /*nLevel*/, sal_uInt16& nValue ) const
4911 {
4912 if ( ! ( mpImplRuler->nFlags & 1 ) )
4913 return sal_False;
4914 nValue = mpImplRuler->nDefaultTab;
4915 return sal_True;
4916 }
4917
GetTextOfs(sal_uInt32 nLevel,sal_uInt16 & nValue) const4918 sal_Bool PPTTextRulerInterpreter::GetTextOfs( sal_uInt32 nLevel, sal_uInt16& nValue ) const
4919 {
4920 if ( ! ( ( nLevel < 5 ) && ( mpImplRuler->nFlags & ( 8 << nLevel ) ) ) )
4921 return sal_False;
4922 nValue = mpImplRuler->nTextOfs[ nLevel ];
4923 return sal_True;
4924 }
4925
GetBulletOfs(sal_uInt32 nLevel,sal_uInt16 & nValue) const4926 sal_Bool PPTTextRulerInterpreter::GetBulletOfs( sal_uInt32 nLevel, sal_uInt16& nValue ) const
4927 {
4928 if ( ! ( ( nLevel < 5 ) && ( mpImplRuler->nFlags & ( 256 << nLevel ) ) ) )
4929 return sal_False;
4930 nValue = mpImplRuler->nBulletOfs[ nLevel ];
4931 return sal_True;
4932 }
4933
operator =(PPTTextRulerInterpreter & rRuler)4934 PPTTextRulerInterpreter& PPTTextRulerInterpreter::operator=( PPTTextRulerInterpreter& rRuler )
4935 {
4936 if ( this != &rRuler )
4937 {
4938 if ( ! ( --mpImplRuler->nRefCount ) )
4939 delete mpImplRuler;
4940 mpImplRuler = rRuler.mpImplRuler;
4941 mpImplRuler->nRefCount++;
4942 }
4943 return *this;
4944 }
4945
~PPTTextRulerInterpreter()4946 PPTTextRulerInterpreter::~PPTTextRulerInterpreter()
4947 {
4948 if ( ! ( --mpImplRuler->nRefCount ) )
4949 delete mpImplRuler;
4950 }
4951
4952 ////////////////////////////////////////////////////////////////////////////////////////////////////
4953
PPTTextCharacterStyleAtomInterpreter()4954 PPTTextCharacterStyleAtomInterpreter::PPTTextCharacterStyleAtomInterpreter() :
4955 nFlags1 ( 0 ),
4956 nFlags2 ( 0 ),
4957 nFlags3 ( 0 )
4958 {
4959 }
4960
Read(SvStream & rIn,const DffRecordHeader & rRecHd)4961 sal_Bool PPTTextCharacterStyleAtomInterpreter::Read( SvStream& rIn, const DffRecordHeader& rRecHd )
4962 {
4963 rRecHd.SeekToContent( rIn );
4964
4965 rIn >> nFlags1
4966 >> nFlags2
4967 >> nFlags3
4968 >> n1
4969 >> nFontHeight
4970 >> nFontColor;
4971
4972 return sal_True;
4973 }
4974
~PPTTextCharacterStyleAtomInterpreter()4975 PPTTextCharacterStyleAtomInterpreter::~PPTTextCharacterStyleAtomInterpreter()
4976 {
4977 }
4978
4979 ////////////////////////////////////////////////////////////////////////////////////////////////////
PPTTextParagraphStyleAtomInterpreter()4980 PPTTextParagraphStyleAtomInterpreter::PPTTextParagraphStyleAtomInterpreter() :
4981 bValid ( sal_False ),
4982 bForbiddenRules ( sal_False ),
4983 bHangingPunctuation ( sal_False ),
4984 bLatinTextWrap ( sal_False )
4985 {
4986 }
4987
Read(SvStream & rIn,const DffRecordHeader & rRecHd)4988 sal_Bool PPTTextParagraphStyleAtomInterpreter::Read( SvStream& rIn, const DffRecordHeader& rRecHd )
4989 {
4990 bValid = sal_False;
4991 rRecHd.SeekToContent( rIn );
4992 sal_uInt32 nDummy32, nFlags, nRecEndPos = rRecHd.GetRecEndFilePos();
4993 sal_uInt16 nDummy16;
4994
4995 rIn >> nDummy16
4996 >> nFlags;
4997
4998 if ( nFlags & 0xf && ( rIn.Tell() < nRecEndPos ) )
4999 rIn >> nDummy16; // BuFlags
5000 if ( nFlags & 0x80 && ( rIn.Tell() < nRecEndPos ) )
5001 rIn >> nDummy16; // BuChar
5002 if ( nFlags & 0x10 && ( rIn.Tell() < nRecEndPos ) )
5003 rIn >> nDummy16; // nBuFont;
5004 if ( nFlags & 0x40 && ( rIn.Tell() < nRecEndPos ) )
5005 rIn >> nDummy16; // nBuHeight;
5006 if ( nFlags & 0x0020 && ( rIn.Tell() < nRecEndPos ) )
5007 rIn >> nDummy32; // nBuColor;
5008 if ( nFlags & 0x800 && ( rIn.Tell() < nRecEndPos ) )
5009 rIn >> nDummy16; // AbsJust!
5010 if ( nFlags & 0x400 && ( rIn.Tell() < nRecEndPos ) )
5011 rIn >> nDummy16;
5012 if ( nFlags & 0x200 && ( rIn.Tell() < nRecEndPos ) )
5013 rIn >> nDummy16;
5014 if ( nFlags & 0x100 && ( rIn.Tell() < nRecEndPos ) )
5015 rIn >> nDummy16;
5016 if ( nFlags & 0x1000 && ( rIn.Tell() < nRecEndPos ) )
5017 rIn >> nDummy16; // LineFeed
5018 if ( nFlags & 0x2000 && ( rIn.Tell() < nRecEndPos ) )
5019 rIn >> nDummy16; // nUpperDist
5020 if ( nFlags & 0x4000 && ( rIn.Tell() < nRecEndPos ) )
5021 rIn >> nDummy16; // nLowerDist
5022 if ( nFlags & 0x8000 && ( rIn.Tell() < nRecEndPos ) )
5023 rIn >> nDummy16;
5024 if ( nFlags & 0x10000 && ( rIn.Tell() < nRecEndPos ) )
5025 rIn >> nDummy16;
5026 if ( nFlags & 0xe0000 && ( rIn.Tell() < nRecEndPos ) )
5027 {
5028 rIn >> nDummy16;
5029 if ( nFlags & 0x20000 )
5030 bForbiddenRules = ( nDummy16 & 1 ) == 1;
5031 if ( nFlags & 0x40000 )
5032 bLatinTextWrap = ( nDummy16 & 2 ) == 0;
5033 if ( nFlags & 0x80000 )
5034 bHangingPunctuation = ( nDummy16 & 4 ) == 4;
5035 }
5036 nFlags &=~ 0xfffff;
5037 sal_uInt32 nMask = 0x100000;
5038 while ( nFlags && nMask && ( rIn.Tell() < nRecEndPos ) )
5039 {
5040 if ( nFlags & nMask )
5041 {
5042 rIn >> nDummy16;
5043 nFlags ^= nMask;
5044 }
5045 nMask <<= 1;
5046 }
5047 bValid = rIn.Tell() == nRecEndPos;
5048 return bValid;
5049 }
5050
~PPTTextParagraphStyleAtomInterpreter()5051 PPTTextParagraphStyleAtomInterpreter::~PPTTextParagraphStyleAtomInterpreter()
5052 {
5053
5054 }
5055
5056 ////////////////////////////////////////////////////////////////////////////////////////////////////
5057
PPTTextSpecInfo(sal_uInt32 _nCharIdx)5058 PPTTextSpecInfo::PPTTextSpecInfo( sal_uInt32 _nCharIdx ) :
5059 nCharIdx ( _nCharIdx ),
5060 nDontKnow ( 1 )
5061 {
5062 nLanguage[ 0 ] = 0x400;
5063 nLanguage[ 1 ] = 0;
5064 nLanguage[ 2 ] = 0;
5065 }
5066
~PPTTextSpecInfo()5067 PPTTextSpecInfo::~PPTTextSpecInfo()
5068 {
5069 }
5070
PPTTextSpecInfoAtomInterpreter()5071 PPTTextSpecInfoAtomInterpreter::PPTTextSpecInfoAtomInterpreter() :
5072 bValid ( sal_False )
5073 {
5074 }
5075
Read(SvStream & rIn,const DffRecordHeader & rRecHd,sal_uInt16 nRecordType,const PPTTextSpecInfo * pTextSpecDefault)5076 sal_Bool PPTTextSpecInfoAtomInterpreter::Read( SvStream& rIn, const DffRecordHeader& rRecHd,
5077 sal_uInt16 nRecordType, const PPTTextSpecInfo* pTextSpecDefault )
5078 {
5079 bValid = sal_False;
5080 sal_uInt32 nCharIdx = 0;
5081 rRecHd.SeekToContent( rIn );
5082
5083 while ( rIn.Tell() < rRecHd.GetRecEndFilePos() )
5084 {
5085 sal_uInt32 nCharCount,
5086 nFlags, i;
5087
5088 if ( nRecordType == PPT_PST_TextSpecInfoAtom )
5089 {
5090 rIn >> nCharCount;
5091 nCharIdx += nCharCount;
5092 }
5093 rIn >> nFlags;
5094
5095 PPTTextSpecInfo* pEntry = new PPTTextSpecInfo( nCharIdx );
5096 if ( pTextSpecDefault )
5097 {
5098 pEntry->nDontKnow = pTextSpecDefault->nDontKnow;
5099 pEntry->nLanguage[ 0 ] = pTextSpecDefault->nLanguage[ 0 ];
5100 pEntry->nLanguage[ 1 ] = pTextSpecDefault->nLanguage[ 1 ];
5101 pEntry->nLanguage[ 2 ] = pTextSpecDefault->nLanguage[ 2 ];
5102 }
5103 for ( i = 1; nFlags && i ; i <<= 1 )
5104 {
5105 sal_uInt16 nLang = 0;
5106 switch( nFlags & i )
5107 {
5108 case 0 : break;
5109 case 1 : rIn >> pEntry->nDontKnow; break;
5110 case 2 : rIn >> nLang; break;
5111 case 4 : rIn >> nLang; break;
5112 default :
5113 {
5114 rIn.SeekRel( 2 );
5115 }
5116 }
5117 if ( nLang )
5118 {
5119 // bug119985 2012.06.14
5120 if (i == 2)
5121 {
5122 pEntry->nLanguage[ 0 ] = pEntry->nLanguage[ 1 ] = pEntry->nLanguage[ 2 ] = nLang;
5123 }
5124 }
5125 nFlags &= ~i;
5126 }
5127 aList.Insert( pEntry, LIST_APPEND );
5128 }
5129 bValid = rIn.Tell() == rRecHd.GetRecEndFilePos();
5130 return bValid;
5131 }
5132
~PPTTextSpecInfoAtomInterpreter()5133 PPTTextSpecInfoAtomInterpreter::~PPTTextSpecInfoAtomInterpreter()
5134 {
5135 void *pPtr;
5136 for ( pPtr = aList.First(); pPtr; pPtr = aList.Next() )
5137 delete (PPTTextSpecInfo*)pPtr;
5138 }
5139
5140 ////////////////////////////////////////////////////////////////////////////////////////////////////
5141
Read(SvStream & rIn)5142 void StyleTextProp9::Read( SvStream& rIn )
5143 {
5144 rIn >> mnExtParagraphMask;
5145 if ( mnExtParagraphMask & 0x800000 )
5146 rIn >> mnBuBlip;
5147 if ( mnExtParagraphMask & 0x2000000 )
5148 rIn >> mnHasAnm;
5149 if ( mnExtParagraphMask & 0x1000000 )
5150 rIn >> mnAnmScheme;
5151 if ( mnExtParagraphMask & 0x4000000 )
5152 rIn >> mpfPP10Ext;
5153 rIn >> mnExtCharacterMask;
5154 if ( mnExtCharacterMask & 0x100000 )
5155 rIn >> mncfPP10Ext;
5156 rIn >> mnSpecialInfoMask;
5157 if ( mnSpecialInfoMask & 0x20 )
5158 rIn >> mnPP10Ext;
5159 if ( mnSpecialInfoMask & 0x40 )
5160 rIn >> mfBidi;
5161 }
5162
PPTStyleTextPropReader(SvStream & rIn,SdrPowerPointImport & rMan,const DffRecordHeader & rTextHeader,PPTTextRulerInterpreter & rRuler,const DffRecordHeader & rExtParaHd,sal_uInt32 nInstance)5163 PPTStyleTextPropReader::PPTStyleTextPropReader( SvStream& rIn, SdrPowerPointImport& rMan, const DffRecordHeader& rTextHeader,
5164 PPTTextRulerInterpreter& rRuler, const DffRecordHeader& rExtParaHd, sal_uInt32 nInstance )
5165 {
5166 Init(rIn, rMan, rTextHeader, rRuler, rExtParaHd, nInstance);
5167 }
5168
ReadParaProps(SvStream & rIn,SdrPowerPointImport & rMan,const DffRecordHeader & rTextHeader,const String & aString,PPTTextRulerInterpreter & rRuler,sal_uInt32 & nCharCount,sal_Bool & bTextPropAtom)5169 void PPTStyleTextPropReader::ReadParaProps( SvStream& rIn, SdrPowerPointImport& rMan, const DffRecordHeader& rTextHeader,
5170 const String& aString, PPTTextRulerInterpreter& rRuler,
5171 sal_uInt32& nCharCount, sal_Bool& bTextPropAtom )
5172 {
5173 sal_uInt32 nMask = 0; //TODO: nMask initialized here to suppress warning for now, see corresponding TODO below
5174 sal_uInt32 nCharAnzRead = 0;
5175 sal_uInt16 nDummy16;
5176
5177 sal_uInt16 nStringLen = aString.Len();
5178
5179 DffRecordHeader aTextHd2;
5180 rTextHeader.SeekToContent( rIn );
5181 if ( rMan.SeekToRec( rIn, PPT_PST_StyleTextPropAtom, rTextHeader.GetRecEndFilePos(), &aTextHd2 ) )
5182 bTextPropAtom = sal_True;
5183 while ( nCharAnzRead <= nStringLen )
5184 {
5185 PPTParaPropSet aParaPropSet;
5186 ImplPPTParaPropSet& aSet = *aParaPropSet.pParaSet;
5187 if ( bTextPropAtom )
5188 {
5189 rIn >> nCharCount
5190 >> aParaPropSet.pParaSet->mnDepth; // Einruecktiefe
5191
5192 aParaPropSet.pParaSet->mnDepth = // taking care of about using not more than 9 outliner levels
5193 std::min(sal_uInt16(8),
5194 aParaPropSet.pParaSet->mnDepth);
5195
5196 nCharCount--;
5197
5198 rIn >> nMask;
5199 aSet.mnAttrSet = nMask & 0x207df7;
5200 sal_uInt16 nBulFlg = 0;
5201 if ( nMask & 0xF )
5202 rIn >> nBulFlg; // Bullet-HardAttr-Flags
5203 aSet.mpArry[ PPT_ParaAttr_BulletOn ] = ( nBulFlg & 1 ) ? 1 : 0;
5204 aSet.mpArry[ PPT_ParaAttr_BuHardFont ] = ( nBulFlg & 2 ) ? 1 : 0;
5205 aSet.mpArry[ PPT_ParaAttr_BuHardColor ] = ( nBulFlg & 4 ) ? 1 : 0;
5206
5207 if ( nMask & 0x0080 ) // buChar
5208 rIn >> aSet.mpArry[ PPT_ParaAttr_BulletChar ];
5209 if ( nMask & 0x0010 ) // buTypeface
5210 rIn >> aSet.mpArry[ PPT_ParaAttr_BulletFont ];
5211 if ( nMask & 0x0040 ) // buSize
5212 {
5213 rIn >> aSet.mpArry[ PPT_ParaAttr_BulletHeight ];
5214 if ( ! ( ( nMask & ( 1 << PPT_ParaAttr_BuHardHeight ) )
5215 && ( nBulFlg & ( 1 << PPT_ParaAttr_BuHardHeight ) ) ) )
5216 aSet.mnAttrSet ^= 0x40;
5217 }
5218 if ( nMask & 0x0020 ) // buColor
5219 {
5220 sal_uInt32 nVal32, nHiByte;
5221 rIn >> nVal32;
5222 nHiByte = nVal32 >> 24;
5223 if ( nHiByte <= 8 )
5224 nVal32 = nHiByte | PPT_COLSCHEME;
5225 aSet.mnBulletColor = nVal32;
5226 }
5227 if ( nMask & 0x0800 ) // pfAlignment
5228 {
5229 rIn >> nDummy16;
5230 aSet.mpArry[ PPT_ParaAttr_Adjust ] = nDummy16 & 3;
5231 }
5232 if ( nMask & 0x1000 ) // pfLineSpacing
5233 rIn >> aSet.mpArry[ PPT_ParaAttr_LineFeed ];
5234 if ( nMask & 0x2000 ) // pfSpaceBefore
5235 rIn >> aSet.mpArry[ PPT_ParaAttr_UpperDist ];
5236 if ( nMask & 0x4000 ) // pfSpaceAfter
5237 rIn >> aSet.mpArry[ PPT_ParaAttr_LowerDist ];
5238 if ( nMask & 0x100 ) // pfLeftMargin
5239 {
5240 rIn >> aSet.mpArry[ PPT_ParaAttr_TextOfs ];
5241 aSet.mnAttrSet |= 1 << PPT_ParaAttr_TextOfs;
5242 }
5243 if ( nMask & 0x400 ) // pfIndent
5244 {
5245 rIn >> aSet.mpArry[ PPT_ParaAttr_BulletOfs ];
5246 aSet.mnAttrSet |= 1 << PPT_ParaAttr_BulletOfs;
5247 }
5248 if ( nMask & 0x8000 ) // pfDefaultTabSize
5249 rIn >> nDummy16;
5250 if ( nMask & 0x100000 ) // pfTabStops
5251 {
5252 sal_uInt16 i, nDistance, nAlignment, nNumberOfTabStops = 0;
5253 rIn >> nNumberOfTabStops;
5254 for ( i = 0; i < nNumberOfTabStops; i++ )
5255 {
5256 rIn >> nDistance
5257 >> nAlignment;
5258 }
5259 }
5260 if ( nMask & 0x10000 ) // pfBaseLine
5261 rIn >> nDummy16;
5262 if ( nMask & 0xe0000 ) // pfCharWrap, pfWordWrap, pfOverflow
5263 {
5264 rIn >> nDummy16;
5265 if ( nMask & 0x20000 )
5266 aSet.mpArry[ PPT_ParaAttr_AsianLB_1 ] = nDummy16 & 1;
5267 if ( nMask & 0x40000 )
5268 aSet.mpArry[ PPT_ParaAttr_AsianLB_2 ] = ( nDummy16 >> 1 ) & 1;
5269 if ( nMask & 0x80000 )
5270 aSet.mpArry[ PPT_ParaAttr_AsianLB_3 ] = ( nDummy16 >> 2 ) & 1;
5271 aSet.mnAttrSet |= ( ( nMask >> 17 ) & 7 ) << PPT_ParaAttr_AsianLB_1;
5272 }
5273 if ( nMask & 0x200000 ) // pfTextDirection
5274 rIn >> aSet.mpArry[ PPT_ParaAttr_BiDi ];
5275 }
5276 else
5277 nCharCount = nStringLen;
5278
5279 //if the textofs attr has been read at above, need not to reset.
5280 if ( ( !( aSet.mnAttrSet & 1 << PPT_ParaAttr_TextOfs ) ) && rRuler.GetTextOfs( aParaPropSet.pParaSet->mnDepth, aSet.mpArry[ PPT_ParaAttr_TextOfs ] ) )
5281 aSet.mnAttrSet |= 1 << PPT_ParaAttr_TextOfs;
5282 if ( ( !( aSet.mnAttrSet & 1 << PPT_ParaAttr_BulletOfs ) ) && rRuler.GetBulletOfs( aParaPropSet.pParaSet->mnDepth, aSet.mpArry[ PPT_ParaAttr_BulletOfs ] ) )
5283 aSet.mnAttrSet |= 1 << PPT_ParaAttr_BulletOfs;
5284 if ( rRuler.GetDefaultTab( aParaPropSet.pParaSet->mnDepth, aSet.mpArry[ PPT_ParaAttr_DefaultTab ] ) )
5285 aSet.mnAttrSet |= 1 << PPT_ParaAttr_DefaultTab;
5286
5287 if ( ( nCharCount > nStringLen ) || ( nStringLen < nCharAnzRead + nCharCount ) )
5288 {
5289 bTextPropAtom = sal_False;
5290 nCharCount = nStringLen - nCharAnzRead;
5291 // please fix the right hand side of
5292 // PPTParaPropSet& PPTParaPropSet::operator=(PPTParaPropSet&),
5293 // it should be a const reference
5294 PPTParaPropSet aTmpPPTParaPropSet;
5295 aParaPropSet = aTmpPPTParaPropSet;
5296 DBG_ERROR( "SJ:PPTStyleTextPropReader::could not get this PPT_PST_StyleTextPropAtom by reading the paragraph attributes" );
5297 }
5298 PPTParaPropSet* pPara = new PPTParaPropSet( aParaPropSet );
5299 pPara->mnOriginalTextPos = nCharAnzRead;
5300 aParaPropList.Insert( pPara, LIST_APPEND );
5301 if ( nCharCount )
5302 {
5303 sal_uInt32 nCount;
5304 const sal_Unicode* pDat = aString.GetBuffer() + nCharAnzRead;
5305 for ( nCount = 0; nCount < nCharCount; nCount++ )
5306 {
5307 if ( pDat[ nCount ] == 0xd )
5308 {
5309 pPara = new PPTParaPropSet( aParaPropSet );
5310 pPara->mnOriginalTextPos = nCharAnzRead + nCount + 1;
5311 aParaPropList.Insert( pPara, LIST_APPEND );
5312 }
5313 }
5314 }
5315 nCharAnzRead += nCharCount + 1;
5316 }
5317 }
5318
ReadCharProps(SvStream & rIn,PPTCharPropSet & aCharPropSet,const String & aString,sal_uInt32 & nCharCount,sal_uInt32 nCharAnzRead,sal_Bool & bTextPropAtom,sal_uInt32 nExtParaPos,const std::vector<StyleTextProp9> & aStyleTextProp9,sal_uInt32 & nExtParaFlags,sal_uInt16 & nBuBlip,sal_uInt16 & nHasAnm,sal_uInt32 & nAnmScheme)5319 void PPTStyleTextPropReader::ReadCharProps( SvStream& rIn, PPTCharPropSet& aCharPropSet, const String& aString,
5320 sal_uInt32& nCharCount, sal_uInt32 nCharAnzRead,
5321 sal_Bool& bTextPropAtom, sal_uInt32 nExtParaPos,
5322 const std::vector< StyleTextProp9 >& aStyleTextProp9,
5323 sal_uInt32& nExtParaFlags, sal_uInt16& nBuBlip,
5324 sal_uInt16& nHasAnm, sal_uInt32& nAnmScheme )
5325 {
5326 sal_uInt32 nMask = 0; //TODO: nMask initialized here to suppress warning for now, see corresponding TODO below
5327 sal_uInt16 nDummy16;
5328 sal_Int32 nCharsToRead;
5329 sal_uInt32 nExtParaNibble = 0;
5330
5331 sal_uInt16 nStringLen = aString.Len();
5332
5333 rIn >> nDummy16;
5334 nCharCount = nDummy16;
5335 rIn >> nDummy16;
5336 nCharsToRead = nStringLen - ( nCharAnzRead + nCharCount );
5337 if ( nCharsToRead < 0 )
5338 {
5339 nCharCount = nStringLen - nCharAnzRead;
5340 if ( nCharsToRead < -1 )
5341 {
5342 bTextPropAtom = sal_False;
5343 DBG_ERROR( "SJ:PPTStyleTextPropReader::could not get this PPT_PST_StyleTextPropAtom by reading the character attributes" );
5344 }
5345 }
5346 ImplPPTCharPropSet& aSet = *aCharPropSet.pCharSet;
5347
5348 // character attributes
5349 rIn >> nMask;
5350 if ( (sal_uInt16)nMask )
5351 {
5352 aSet.mnAttrSet |= (sal_uInt16)nMask;
5353 rIn >> aSet.mnFlags;
5354 }
5355 if ( nMask & 0x10000 ) // cfTypeface
5356 {
5357 rIn >> aSet.mnFont;
5358 aSet.mnAttrSet |= 1 << PPT_CharAttr_Font;
5359 }
5360 if ( nMask & 0x200000 ) // cfFEOldTypeface
5361 {
5362 rIn >> aSet.mnAsianOrComplexFont;
5363 aSet.mnAttrSet |= 1 << PPT_CharAttr_AsianOrComplexFont;
5364 }
5365 if ( nMask & 0x400000 ) // cfANSITypeface
5366 {
5367 rIn >> aSet.mnANSITypeface;
5368 aSet.mnAttrSet |= 1 << PPT_CharAttr_ANSITypeface;
5369 }
5370 if ( nMask & 0x800000 ) // cfSymbolTypeface
5371 {
5372 rIn >> aSet.mnSymbolFont;
5373 aSet.mnAttrSet |= 1 << PPT_CharAttr_Symbol;
5374 }
5375 if ( nMask & 0x20000 ) // cfSize
5376 {
5377 rIn >> aSet.mnFontHeight;
5378 aSet.mnAttrSet |= 1 << PPT_CharAttr_FontHeight;
5379 }
5380 if ( nMask & 0x40000 ) // cfColor
5381 {
5382 sal_uInt32 nVal;
5383 rIn >> nVal;
5384 if ( !( nVal & 0xff000000 ) )
5385 nVal = PPT_COLSCHEME_HINTERGRUND;
5386 aSet.mnColor = nVal;
5387 aSet.mnAttrSet |= 1 << PPT_CharAttr_FontColor;
5388 }
5389 if ( nMask & 0x80000 ) // cfPosition
5390 {
5391 rIn >> aSet.mnEscapement;
5392 aSet.mnAttrSet |= 1 << PPT_CharAttr_Escapement;
5393 }
5394 if ( nExtParaPos )
5395 {
5396 sal_uInt32 nExtBuInd = nMask & 0x3c00;
5397 if ( nExtBuInd )
5398 nExtBuInd = ( aSet.mnFlags & 0x3c00 ) >> 10;
5399 if ( nExtBuInd < aStyleTextProp9.size() )
5400 {
5401 if ( nExtParaNibble && ( ( nExtBuInd + nExtParaNibble ) < aStyleTextProp9.size() ) )
5402 nExtBuInd += nExtParaNibble;
5403
5404 nExtParaFlags = aStyleTextProp9[ nExtBuInd ].mnExtParagraphMask;
5405 nBuBlip = aStyleTextProp9[ nExtBuInd ].mnBuBlip;
5406 nHasAnm = aStyleTextProp9[ nExtBuInd ].mnHasAnm;
5407 nAnmScheme = aStyleTextProp9[ nExtBuInd ].mnAnmScheme;
5408 }
5409 if ( ( nExtBuInd & 0xf ) == 0xf )
5410 nExtParaNibble += 16;
5411 }
5412 }
5413
Init(SvStream & rIn,SdrPowerPointImport & rMan,const DffRecordHeader & rTextHeader,PPTTextRulerInterpreter & rRuler,const DffRecordHeader & rExtParaHd,sal_uInt32 nInstance)5414 void PPTStyleTextPropReader::Init( SvStream& rIn, SdrPowerPointImport& rMan, const DffRecordHeader& rTextHeader,
5415 PPTTextRulerInterpreter& rRuler, const DffRecordHeader& rExtParaHd, sal_uInt32 nInstance )
5416 {
5417 sal_uInt32 nMerk = rIn.Tell();
5418 sal_uInt32 nExtParaPos = ( rExtParaHd.nRecType == PPT_PST_ExtendedParagraphAtom ) ? rExtParaHd.nFilePos + 8 : 0;
5419
5420 std::vector< StyleTextProp9 > aStyleTextProp9;
5421 if ( rExtParaHd.nRecType == PPT_PST_ExtendedParagraphAtom )
5422 {
5423 rIn.Seek( rExtParaHd.nFilePos + 8 );
5424 while( ( rIn.GetError() == 0 ) && ( rIn.Tell() < rExtParaHd.GetRecEndFilePos() ) )
5425 {
5426 aStyleTextProp9.resize( aStyleTextProp9.size() + 1 );
5427 aStyleTextProp9.back().Read( rIn );
5428 }
5429 rIn.Seek( nMerk );
5430 }
5431
5432 String aString;
5433 DffRecordHeader aTextHd;
5434 rIn >> aTextHd;
5435 sal_uInt32 nMaxLen = aTextHd.nRecLen;
5436 if ( nMaxLen >= 0xFFFF )
5437 nMaxLen = 0xFFFE;
5438
5439 if( aTextHd.nRecType == PPT_PST_TextCharsAtom )
5440 {
5441 sal_uInt32 i;
5442 sal_Unicode nChar,*pBuf = new sal_Unicode[ ( nMaxLen >> 1 ) + 1 ];
5443 rIn.Read( pBuf, nMaxLen );
5444 nMaxLen >>= 1;
5445 pBuf[ nMaxLen ] = 0;
5446 sal_Unicode* pPtr = pBuf;
5447 #ifdef OSL_BIGENDIAN
5448 sal_Unicode nTemp;
5449 for ( i = 0; i < nMaxLen; i++ )
5450 {
5451 nTemp = *pPtr;
5452 *pPtr++ = ( nTemp << 8 ) | ( nTemp >> 8 );
5453 }
5454 pPtr = pBuf;
5455 #endif
5456
5457 for ( i = 0; i < nMaxLen; pPtr++, i++ )
5458 {
5459 nChar = *pPtr;
5460 if ( !nChar )
5461 break;
5462 if ( ( nChar & 0xff00 ) == 0xf000 ) // in this special case we got a symbol
5463 aSpecMarkerList.Insert( (void*)( i | PPT_SPEC_SYMBOL ), LIST_APPEND );
5464 else if ( nChar == 0xd )
5465 {
5466 if ( nInstance == TSS_TYPE_PAGETITLE )
5467 *pPtr = 0xb;
5468 else
5469 aSpecMarkerList.Insert( (void*)( i | PPT_SPEC_NEWLINE ), LIST_APPEND );
5470 }
5471 }
5472 if ( i )
5473 aString = String( pBuf, (sal_uInt16)i );
5474 delete[] pBuf;
5475 }
5476 else if( aTextHd.nRecType == PPT_PST_TextBytesAtom )
5477 {
5478 sal_Char *pBuf = new sal_Char[ nMaxLen + 1 ];
5479 pBuf[ nMaxLen ] = 0;
5480 rIn.Read( pBuf, nMaxLen );
5481 sal_Char* pPtr = pBuf;
5482 for (;;)
5483 {
5484 sal_Char cLo = *pPtr;
5485 if ( cLo == 0 )
5486 break;
5487 if ( cLo == 0xd )
5488 {
5489 if ( nInstance == TSS_TYPE_PAGETITLE )
5490 *pPtr = 0xb;
5491 else
5492 aSpecMarkerList.Insert( (void*)( (pPtr - pBuf) | PPT_SPEC_NEWLINE ), LIST_APPEND );
5493 }
5494 pPtr++;
5495 }
5496 xub_StrLen nLen = sal::static_int_cast< xub_StrLen >( pPtr - pBuf );
5497 if ( nLen )
5498 aString = String( pBuf, nLen, RTL_TEXTENCODING_MS_1252 );
5499 delete[] pBuf;
5500 }
5501 else
5502 {
5503 // no chars, but potentially char/para props?
5504 sal_uInt32 nCharCount;
5505 sal_Bool bTextPropAtom = sal_False;
5506 ReadParaProps( rIn, rMan, rTextHeader, aString, rRuler, nCharCount, bTextPropAtom );
5507
5508 if ( bTextPropAtom )
5509 {
5510 // yeah, StyleTextProp is there, read it all & push to
5511 // aParaPropList
5512 PPTCharPropSet aCharPropSet(0);
5513 aCharPropSet.mnOriginalTextPos = 0;
5514
5515 sal_uInt32 nCharAnzRead = 0;
5516 sal_uInt32 nExtParaFlags = 0, nAnmScheme = 0;
5517 sal_uInt16 nBuBlip = 0xffff, nHasAnm = 0;
5518 ReadCharProps( rIn, aCharPropSet, aString, nCharCount, nCharAnzRead,
5519 bTextPropAtom, nExtParaPos, aStyleTextProp9, nExtParaFlags,
5520 nBuBlip, nHasAnm, nAnmScheme );
5521
5522 aCharPropList.Insert(
5523 new PPTCharPropSet( aCharPropSet, 0 ), LIST_APPEND );
5524 }
5525 }
5526
5527 if ( aString.Len() )
5528 {
5529 sal_uInt32 nCharCount;
5530 sal_Bool bTextPropAtom = sal_False;
5531
5532 ReadParaProps( rIn, rMan, rTextHeader, aString, rRuler, nCharCount, bTextPropAtom );
5533
5534 sal_Bool bEmptyParaPossible = sal_True;
5535 sal_uInt32 nCharAnzRead = 0;
5536 sal_uInt32 nCurrentPara = 0;
5537 sal_uInt32 nCurrentSpecMarker = (sal_uInt32)(sal_uIntPtr)aSpecMarkerList.First();
5538 sal_uInt16 nStringLen = aString.Len();
5539
5540 while ( nCharAnzRead < nStringLen )
5541 {
5542 sal_uInt32 nExtParaFlags = 0, nLatestParaUpdate = 0xffffffff, nAnmScheme = 0;
5543 sal_uInt16 nBuBlip = 0xffff, nHasAnm = 0;
5544
5545 PPTCharPropSet aCharPropSet( nCurrentPara );
5546 if ( bTextPropAtom )
5547 ReadCharProps( rIn, aCharPropSet, aString, nCharCount, nCharAnzRead,
5548 bTextPropAtom, nExtParaPos, aStyleTextProp9, nExtParaFlags,
5549 nBuBlip, nHasAnm, nAnmScheme );
5550 else
5551 nCharCount = nStringLen;
5552
5553 sal_uInt32 nLen;
5554 while( nCharCount )
5555 {
5556 if ( nExtParaPos && ( nLatestParaUpdate != nCurrentPara ) && ( nCurrentPara < aParaPropList.Count() ) )
5557 {
5558 PPTParaPropSet* pPropSet = (PPTParaPropSet*)aParaPropList.GetObject( nCurrentPara );
5559 pPropSet->pParaSet->mnExtParagraphMask = nExtParaFlags;
5560 if ( nExtParaFlags & 0x800000 )
5561 pPropSet->pParaSet->mnBuBlip = nBuBlip;
5562 if ( nExtParaFlags & 0x01000000 )
5563 pPropSet->pParaSet->mnAnmScheme = nAnmScheme;
5564 if ( nExtParaFlags & 0x02000000 )
5565 pPropSet->pParaSet->mnHasAnm = nHasAnm;
5566 nLatestParaUpdate = nCurrentPara;
5567 }
5568 aCharPropSet.mnOriginalTextPos = nCharAnzRead;
5569 if ( nCurrentSpecMarker && ( ( nCurrentSpecMarker & 0xffff ) < ( nCharAnzRead + nCharCount ) ) )
5570 {
5571 if ( nCurrentSpecMarker & PPT_SPEC_NEWLINE )
5572 {
5573 nLen = ( nCurrentSpecMarker & 0xffff ) - nCharAnzRead;
5574 if ( nLen )
5575 aCharPropSet.maString = String( aString, (sal_uInt16)nCharAnzRead, (sal_uInt16)nLen );
5576 else if ( bEmptyParaPossible )
5577 aCharPropSet.maString = String();
5578 if ( nLen || bEmptyParaPossible )
5579 aCharPropList.Insert( new PPTCharPropSet( aCharPropSet, nCurrentPara ), LIST_APPEND );
5580 nCurrentPara++;
5581 nLen++;
5582 nCharAnzRead += nLen;
5583 nCharCount -= nLen;
5584 bEmptyParaPossible = sal_True;
5585 }
5586 else if ( nCurrentSpecMarker & PPT_SPEC_SYMBOL )
5587 {
5588 if ( ( nCurrentSpecMarker & 0xffff ) != nCharAnzRead )
5589 {
5590 nLen = ( nCurrentSpecMarker & 0xffff ) - nCharAnzRead;
5591 aCharPropSet.maString = String( aString, (sal_uInt16)nCharAnzRead, (sal_uInt16)nLen );
5592 aCharPropList.Insert( new PPTCharPropSet( aCharPropSet, nCurrentPara ), LIST_APPEND );
5593 nCharCount -= nLen;
5594 nCharAnzRead += nLen;
5595 }
5596 PPTCharPropSet* pCPropSet = new PPTCharPropSet( aCharPropSet, nCurrentPara );
5597 pCPropSet->maString = aString.GetChar( (sal_uInt16)nCharAnzRead );
5598 if ( aCharPropSet.pCharSet->mnAttrSet & ( 1 << PPT_CharAttr_Symbol ) )
5599 pCPropSet->SetFont( aCharPropSet.pCharSet->mnSymbolFont );
5600 aCharPropList.Insert( pCPropSet, LIST_APPEND );
5601 nCharCount--;
5602 nCharAnzRead++;
5603 bEmptyParaPossible = sal_False;
5604 }
5605 nCurrentSpecMarker = (sal_uInt32)(sal_uIntPtr)aSpecMarkerList.Next();
5606 }
5607 else
5608 {
5609 aCharPropSet.maString = String( aString, (sal_uInt16)nCharAnzRead, (sal_uInt16)nCharCount );
5610 aCharPropList.Insert( new PPTCharPropSet( aCharPropSet, nCurrentPara ), LIST_APPEND );
5611 nCharAnzRead += nCharCount;
5612 bEmptyParaPossible = sal_False;
5613 break;
5614 }
5615 }
5616 }
5617 if ( aCharPropList.Count() && ( ((PPTCharPropSet*)aCharPropList.Last())->mnParagraph != nCurrentPara ) )
5618 {
5619 PPTCharPropSet* pCharPropSet = new PPTCharPropSet( *(PPTCharPropSet*)aCharPropList.Last(), nCurrentPara );
5620 pCharPropSet->maString = String();
5621 pCharPropSet->mnOriginalTextPos = nStringLen - 1;
5622 aCharPropList.Insert( pCharPropSet, LIST_APPEND );
5623 }
5624 }
5625 rIn.Seek( nMerk );
5626 }
5627
~PPTStyleTextPropReader()5628 PPTStyleTextPropReader::~PPTStyleTextPropReader()
5629 {
5630 void* pTmp;
5631 for ( pTmp = aParaPropList.First(); pTmp; pTmp = aParaPropList.Next() )
5632 delete (PPTParaPropSet*)pTmp;
5633 for ( pTmp = aCharPropList.First(); pTmp; pTmp = aCharPropList.Next() )
5634 delete (PPTCharPropSet*)pTmp;
5635 }
5636
5637 ////////////////////////////////////////////////////////////////////////////////////////////////////
5638
5639 struct FieldEntry
5640 {
5641 sal_uInt32 nFieldType;
5642 sal_uInt32 nFieldStartPos;
5643 sal_uInt32 nFieldEndPos;
5644 String aFieldUrl;
5645
FieldEntryFieldEntry5646 FieldEntry( sal_uInt32 nType, sal_uInt32 nStart, sal_uInt32 nEnd )
5647 {
5648 nFieldType = nType;
5649 nFieldStartPos = nStart;
5650 nFieldEndPos = nEnd;
5651 }
FieldEntryFieldEntry5652 FieldEntry( FieldEntry& rFieldEntry )
5653 {
5654 nFieldType = rFieldEntry.nFieldType;
5655 nFieldStartPos = rFieldEntry.nFieldStartPos;
5656 nFieldEndPos = rFieldEntry.nFieldEndPos;
5657 aFieldUrl = rFieldEntry.aFieldUrl;
5658 }
5659 };
5660
5661
PPTPortionObj(const PPTStyleSheet & rStyleSheet,sal_uInt32 nInstance,sal_uInt32 nDepth)5662 PPTPortionObj::PPTPortionObj( const PPTStyleSheet& rStyleSheet, sal_uInt32 nInstance, sal_uInt32 nDepth ) :
5663 PPTCharPropSet ( 0 ),
5664 mrStyleSheet ( rStyleSheet ),
5665 mnInstance ( nInstance ),
5666 mnDepth ( ( nDepth > 4 ) ? 4 : nDepth )
5667 {
5668 }
5669
PPTPortionObj(PPTCharPropSet & rCharPropSet,const PPTStyleSheet & rStyleSheet,sal_uInt32 nInstance,sal_uInt32 nDepth)5670 PPTPortionObj::PPTPortionObj( PPTCharPropSet& rCharPropSet, const PPTStyleSheet& rStyleSheet, sal_uInt32 nInstance, sal_uInt32 nDepth ) :
5671 PPTCharPropSet ( rCharPropSet ),
5672 mrStyleSheet ( rStyleSheet ),
5673 mnInstance ( nInstance ),
5674 mnDepth ( nDepth )
5675 {
5676 }
5677
PPTPortionObj(PPTPortionObj & rPortionObj)5678 PPTPortionObj::PPTPortionObj( PPTPortionObj& rPortionObj ) :
5679 PPTCharPropSet ( rPortionObj ),
5680 mrStyleSheet ( rPortionObj.mrStyleSheet ),
5681 mnInstance ( rPortionObj.mnInstance ),
5682 mnDepth ( rPortionObj.mnDepth )
5683 {
5684 }
5685
~PPTPortionObj()5686 PPTPortionObj::~PPTPortionObj()
5687 {
5688 }
5689
HasTabulator()5690 sal_Bool PPTPortionObj::HasTabulator()
5691 {
5692 sal_Bool bRetValue = sal_False;
5693 sal_Int32 nCount;
5694 const sal_Unicode* pPtr = maString.GetBuffer();
5695 for ( nCount = 0; nCount < maString.Len(); nCount++ )
5696 {
5697 if ( pPtr[ nCount ] == 0x9 )
5698 {
5699 bRetValue = sal_True;
5700 break;
5701 }
5702
5703 }
5704 return bRetValue;
5705 }
5706
GetAttrib(sal_uInt32 nAttr,sal_uInt32 & nRetValue,sal_uInt32 nDestinationInstance)5707 sal_Bool PPTPortionObj::GetAttrib( sal_uInt32 nAttr, sal_uInt32& nRetValue, sal_uInt32 nDestinationInstance )
5708 {
5709 sal_uInt32 nMask = 1 << nAttr;
5710 nRetValue = 0;
5711
5712 sal_uInt32 bIsHardAttribute = ( ( pCharSet->mnAttrSet & nMask ) != 0 ) ? 1 : 0;
5713
5714 if ( bIsHardAttribute )
5715 {
5716 switch ( nAttr )
5717 {
5718 case PPT_CharAttr_Bold :
5719 case PPT_CharAttr_Italic :
5720 case PPT_CharAttr_Underline :
5721 case PPT_CharAttr_Shadow :
5722 case PPT_CharAttr_Strikeout :
5723 case PPT_CharAttr_Embossed :
5724 nRetValue = ( pCharSet->mnFlags & nMask ) ? 1 : 0;
5725 break;
5726 case PPT_CharAttr_Font :
5727 nRetValue = pCharSet->mnFont;
5728 break;
5729 case PPT_CharAttr_AsianOrComplexFont :
5730 nRetValue = pCharSet->mnAsianOrComplexFont;
5731 break;
5732 case PPT_CharAttr_FontHeight :
5733 nRetValue = pCharSet->mnFontHeight;
5734 break;
5735 case PPT_CharAttr_FontColor :
5736 nRetValue = pCharSet->mnColor;
5737 break;
5738 case PPT_CharAttr_Escapement :
5739 nRetValue = pCharSet->mnEscapement;
5740 break;
5741 default :
5742 DBG_ERROR( "SJ:PPTPortionObj::GetAttrib ( hard attribute does not exist )" );
5743 }
5744 }
5745 else
5746 {
5747 const PPTCharLevel& rCharLevel = mrStyleSheet.mpCharSheet[ mnInstance ]->maCharLevel[ mnDepth ];
5748 PPTCharLevel* pCharLevel = NULL;
5749 if ( ( nDestinationInstance == 0xffffffff )
5750 || ( mnDepth && ( ( mnInstance == TSS_TYPE_SUBTITLE ) || ( mnInstance == TSS_TYPE_TEXT_IN_SHAPE ) ) ) )
5751 bIsHardAttribute = 1;
5752 else if ( nDestinationInstance != mnInstance )
5753 pCharLevel = &mrStyleSheet.mpCharSheet[ nDestinationInstance ]->maCharLevel[ mnDepth ];
5754 switch( nAttr )
5755 {
5756 case PPT_CharAttr_Bold :
5757 case PPT_CharAttr_Italic :
5758 case PPT_CharAttr_Underline :
5759 case PPT_CharAttr_Shadow :
5760 case PPT_CharAttr_Strikeout :
5761 case PPT_CharAttr_Embossed :
5762 {
5763 nRetValue = ( rCharLevel.mnFlags & nMask ) ? 1 : 0;
5764 if ( pCharLevel )
5765 {
5766 sal_uInt32 nTmp = ( pCharLevel->mnFlags & nMask ) ? 1 : 0;
5767 if ( nRetValue != nTmp )
5768 bIsHardAttribute = 1;
5769 }
5770 }
5771 break;
5772 case PPT_CharAttr_Font :
5773 {
5774 nRetValue = rCharLevel.mnFont;
5775 if ( pCharLevel && ( nRetValue != pCharLevel->mnFont ) )
5776 bIsHardAttribute = 1;
5777 }
5778 break;
5779 case PPT_CharAttr_AsianOrComplexFont :
5780 {
5781 nRetValue = rCharLevel.mnAsianOrComplexFont;
5782 if ( pCharLevel && ( nRetValue != pCharLevel->mnAsianOrComplexFont ) )
5783 bIsHardAttribute = 1;
5784 }
5785 break;
5786 case PPT_CharAttr_FontHeight :
5787 {
5788 nRetValue = rCharLevel.mnFontHeight;
5789 if ( pCharLevel && ( nRetValue != pCharLevel->mnFontHeight ) )
5790 bIsHardAttribute = 1;
5791 }
5792 break;
5793 case PPT_CharAttr_FontColor :
5794 {
5795 nRetValue = rCharLevel.mnFontColor;
5796 if ( pCharLevel && ( nRetValue != pCharLevel->mnFontColor ) )
5797 bIsHardAttribute = 1;
5798 }
5799 break;
5800 case PPT_CharAttr_Escapement :
5801 {
5802 nRetValue = rCharLevel.mnEscapement;
5803 if ( pCharLevel && ( nRetValue != pCharLevel->mnEscapement ) )
5804 bIsHardAttribute = 1;
5805 }
5806 break;
5807 default :
5808 DBG_ERROR( "SJ:PPTPortionObj::GetAttrib ( attribute does not exist )" );
5809 }
5810 }
5811 return (sal_Bool)bIsHardAttribute;
5812 }
5813
ApplyTo(SfxItemSet & rSet,SdrPowerPointImport & rManager,sal_uInt32 nDestinationInstance)5814 void PPTPortionObj::ApplyTo( SfxItemSet& rSet, SdrPowerPointImport& rManager, sal_uInt32 nDestinationInstance )
5815 {
5816 ApplyTo( rSet, rManager, nDestinationInstance, NULL );
5817 }
5818
ApplyTo(SfxItemSet & rSet,SdrPowerPointImport & rManager,sal_uInt32 nDestinationInstance,const PPTTextObj * pTextObj)5819 void PPTPortionObj::ApplyTo( SfxItemSet& rSet, SdrPowerPointImport& rManager, sal_uInt32 nDestinationInstance, const PPTTextObj* pTextObj )
5820 {
5821 sal_uInt32 nVal;
5822 if ( GetAttrib( PPT_CharAttr_Bold, nVal, nDestinationInstance ) )
5823 {
5824 rSet.Put( SvxWeightItem( nVal != 0 ? WEIGHT_BOLD : WEIGHT_NORMAL, EE_CHAR_WEIGHT ) );
5825 rSet.Put( SvxWeightItem( nVal != 0 ? WEIGHT_BOLD : WEIGHT_NORMAL, EE_CHAR_WEIGHT_CJK ) );
5826 rSet.Put( SvxWeightItem( nVal != 0 ? WEIGHT_BOLD : WEIGHT_NORMAL, EE_CHAR_WEIGHT_CTL ) );
5827 }
5828 if ( GetAttrib( PPT_CharAttr_Italic, nVal, nDestinationInstance ) )
5829 {
5830 rSet.Put( SvxPostureItem( nVal != 0 ? ITALIC_NORMAL : ITALIC_NONE, EE_CHAR_ITALIC ) );
5831 rSet.Put( SvxPostureItem( nVal != 0 ? ITALIC_NORMAL : ITALIC_NONE, EE_CHAR_ITALIC_CJK ) );
5832 rSet.Put( SvxPostureItem( nVal != 0 ? ITALIC_NORMAL : ITALIC_NONE, EE_CHAR_ITALIC_CTL ) );
5833 }
5834 if ( GetAttrib( PPT_CharAttr_Underline, nVal, nDestinationInstance ) )
5835 rSet.Put( SvxUnderlineItem( nVal != 0 ? UNDERLINE_SINGLE : UNDERLINE_NONE, EE_CHAR_UNDERLINE ) );
5836
5837 if ( GetAttrib( PPT_CharAttr_Shadow, nVal, nDestinationInstance ) )
5838 rSet.Put( SvxShadowedItem( nVal != 0, EE_CHAR_SHADOW ) );
5839
5840 if ( GetAttrib( PPT_CharAttr_Strikeout, nVal, nDestinationInstance ) )
5841 rSet.Put( SvxCrossedOutItem( nVal != 0 ? STRIKEOUT_SINGLE : STRIKEOUT_NONE, EE_CHAR_STRIKEOUT ) );
5842
5843 sal_uInt32 nAsianFontId = 0xffff;
5844 if ( GetAttrib( PPT_CharAttr_AsianOrComplexFont, nAsianFontId, nDestinationInstance ) )
5845 {
5846 if ( nAsianFontId != 0xffff )
5847 {
5848 PptFontEntityAtom* pFontEnityAtom = rManager.GetFontEnityAtom( nAsianFontId );
5849 if ( pFontEnityAtom )
5850 {
5851 rSet.Put( SvxFontItem( pFontEnityAtom->eFamily, pFontEnityAtom->aName,
5852 String(), pFontEnityAtom->ePitch, pFontEnityAtom->eCharSet, EE_CHAR_FONTINFO_CJK ) );
5853 rSet.Put( SvxFontItem( pFontEnityAtom->eFamily, pFontEnityAtom->aName,
5854 String(), pFontEnityAtom->ePitch, pFontEnityAtom->eCharSet, EE_CHAR_FONTINFO_CTL ) );
5855 }
5856 }
5857 }
5858 if ( GetAttrib( PPT_CharAttr_Font, nVal, nDestinationInstance ) )
5859 {
5860 PptFontEntityAtom* pFontEnityAtom = rManager.GetFontEnityAtom( nVal );
5861 if ( pFontEnityAtom )
5862 {
5863 rSet.Put( SvxFontItem( pFontEnityAtom->eFamily, pFontEnityAtom->aName, String(), pFontEnityAtom->ePitch, pFontEnityAtom->eCharSet, EE_CHAR_FONTINFO ) );
5864
5865 // #119475# bullet font info for CJK and CTL
5866 if ( RTL_TEXTENCODING_SYMBOL == pFontEnityAtom->eCharSet )
5867 {
5868 rSet.Put( SvxFontItem( pFontEnityAtom->eFamily, pFontEnityAtom->aName, String(), pFontEnityAtom->ePitch, pFontEnityAtom->eCharSet, EE_CHAR_FONTINFO_CJK ) );
5869 rSet.Put( SvxFontItem( pFontEnityAtom->eFamily, pFontEnityAtom->aName, String(), pFontEnityAtom->ePitch, pFontEnityAtom->eCharSet, EE_CHAR_FONTINFO_CTL ) );
5870 }
5871 }
5872 }
5873 if ( GetAttrib( PPT_CharAttr_FontHeight, nVal, nDestinationInstance ) ) // Schriftgrad in Point
5874 {
5875 sal_uInt32 nHeight = rManager.ScalePoint( nVal );
5876 rSet.Put( SvxFontHeightItem( nHeight, 100, EE_CHAR_FONTHEIGHT ) );
5877 rSet.Put( SvxFontHeightItem( nHeight, 100, EE_CHAR_FONTHEIGHT_CJK ) );
5878 rSet.Put( SvxFontHeightItem( nHeight, 100, EE_CHAR_FONTHEIGHT_CTL ) );
5879 }
5880
5881 if ( GetAttrib( PPT_CharAttr_Embossed, nVal, nDestinationInstance ) )
5882 rSet.Put( SvxCharReliefItem( nVal != 0 ? RELIEF_EMBOSSED : RELIEF_NONE, EE_CHAR_RELIEF ) );
5883 if ( nVal ) /* if Embossed is set, the font color depends to the fillstyle/color of the object,
5884 if the object has no fillstyle, the font color depends to fillstyle of the background */
5885 {
5886 Color aDefColor( COL_BLACK );
5887 MSO_FillType eFillType = mso_fillSolid;
5888 if ( rManager.GetPropertyValue( DFF_Prop_fNoFillHitTest ) & 0x10 )
5889 eFillType = (MSO_FillType)rManager.GetPropertyValue( DFF_Prop_fillType, mso_fillSolid );
5890 else
5891 eFillType = mso_fillBackground;
5892 switch( eFillType )
5893 {
5894 case mso_fillShade :
5895 case mso_fillShadeCenter :
5896 case mso_fillShadeShape :
5897 case mso_fillShadeScale :
5898 case mso_fillShadeTitle :
5899 case mso_fillSolid :
5900 aDefColor = rManager.MSO_CLR_ToColor( rManager.GetPropertyValue( DFF_Prop_fillColor ) );
5901 break;
5902 case mso_fillPattern :
5903 aDefColor = rManager.MSO_CLR_ToColor( rManager.GetPropertyValue( DFF_Prop_fillBackColor ) );
5904 break;
5905 case mso_fillTexture :
5906 {
5907 Graphic aGraf;
5908 if ( rManager.GetBLIP( rManager.GetPropertyValue( DFF_Prop_fillBlip ), aGraf, NULL ) )
5909 {
5910 Bitmap aBmp( aGraf.GetBitmap() );
5911 Size aSize( aBmp.GetSizePixel() );
5912 if ( aSize.Width() && aSize.Height() )
5913 {
5914 if ( aSize.Width () > 64 )
5915 aSize.Width () = 64;
5916 if ( aSize.Height() > 64 )
5917 aSize.Height() = 64;
5918
5919 sal_uLong nRt = 0, nGn = 0, nBl = 0;
5920 BitmapReadAccess* pAcc = aBmp.AcquireReadAccess();
5921 if( pAcc )
5922 {
5923 const long nWidth = aSize.Width();
5924 const long nHeight = aSize.Height();
5925
5926 if( pAcc->HasPalette() )
5927 {
5928 for( long nY = 0L; nY < nHeight; nY++ )
5929 {
5930 for( long nX = 0L; nX < nWidth; nX++ )
5931 {
5932 const BitmapColor& rCol = pAcc->GetPaletteColor( pAcc->GetPixelIndex( nY, nX ) );
5933 nRt+=rCol.GetRed(); nGn+=rCol.GetGreen(); nBl+=rCol.GetBlue();
5934 }
5935 }
5936 }
5937 else
5938 {
5939 for( long nY = 0L; nY < nHeight; nY++ )
5940 {
5941 for( long nX = 0L; nX < nWidth; nX++ )
5942 {
5943 const BitmapColor aCol( pAcc->GetPixel( nY, nX ) );
5944 nRt+=aCol.GetRed(); nGn+=aCol.GetGreen(); nBl+=aCol.GetBlue();
5945 }
5946 }
5947 }
5948 aBmp.ReleaseAccess( pAcc );
5949 sal_uInt32 nC = ( aSize.Width() * aSize.Height() );
5950 nRt /= nC;
5951 nGn /= nC;
5952 nBl /= nC;
5953 aDefColor = Color(sal_uInt8( nRt ), sal_uInt8( nGn ),sal_uInt8( nBl ) );
5954 }
5955 }
5956 }
5957 }
5958 break;
5959 case mso_fillBackground :
5960 {
5961 if ( pTextObj ) // the textobject is needed
5962 {
5963 const SfxItemSet* pItemSet = pTextObj->GetBackground();
5964 if ( pItemSet )
5965 {
5966 const SfxPoolItem* pFillStyleItem = NULL;
5967 pItemSet->GetItemState( XATTR_FILLSTYLE, sal_False, &pFillStyleItem );
5968 if ( pFillStyleItem )
5969 {
5970 XFillStyle eFillStyle = ((XFillStyleItem*)pFillStyleItem)->GetValue();
5971 switch( eFillStyle )
5972 {
5973 case XFILL_SOLID :
5974 {
5975 const SfxPoolItem* pFillColorItem = NULL;
5976 pItemSet->GetItemState( XATTR_FILLCOLOR, sal_False, &pFillColorItem );
5977 if ( pFillColorItem )
5978 aDefColor = ((XColorItem*)pFillColorItem)->GetColorValue();
5979 }
5980 break;
5981 case XFILL_GRADIENT :
5982 {
5983 const SfxPoolItem* pGradientItem = NULL;
5984 pItemSet->GetItemState( XATTR_FILLGRADIENT, sal_False, &pGradientItem );
5985 if ( pGradientItem )
5986 aDefColor = ((XFillGradientItem*)pGradientItem)->GetGradientValue().GetStartColor();
5987 }
5988 break;
5989 case XFILL_HATCH :
5990 case XFILL_BITMAP :
5991 aDefColor = Color( COL_WHITE );
5992 break;
5993 default: break;
5994 }
5995 }
5996 }
5997 }
5998 }
5999 break;
6000 // case mso_fillPicture :
6001 default: break;
6002 }
6003 rSet.Put( SvxColorItem( aDefColor, EE_CHAR_COLOR ) );
6004 }
6005 else
6006 {
6007 if ( GetAttrib( PPT_CharAttr_FontColor, nVal, nDestinationInstance ) ) // Textfarbe (4Byte-Arg)
6008 {
6009 Color aCol( rManager.MSO_TEXT_CLR_ToColor( nVal ) );
6010 rSet.Put( SvxColorItem( aCol, EE_CHAR_COLOR ) );
6011 if ( nDestinationInstance == 0xffffffff )
6012 mrStyleSheet.mpCharSheet[ mnInstance ]->maCharLevel[ mnDepth ].mnFontColorInStyleSheet = aCol;
6013 }
6014 else if ( nVal & 0x0f000000 ) // this is not a hard attribute, but maybe the page has a different colerscheme,
6015 { // so that in this case we must use a hard color attribute
6016 Color aCol( rManager.MSO_TEXT_CLR_ToColor( nVal ) );
6017 Color& aColorInSheet = mrStyleSheet.mpCharSheet[ mnInstance ]->maCharLevel[ mnDepth ].mnFontColorInStyleSheet;
6018 if ( aColorInSheet != aCol )
6019 rSet.Put( SvxColorItem( aCol, EE_CHAR_COLOR ) );
6020 }
6021 }
6022
6023 if ( GetAttrib( PPT_CharAttr_Escapement, nVal, nDestinationInstance ) ) // Hoch/Tiefstellung in %
6024 {
6025 sal_uInt16 nEsc = 0;
6026 sal_uInt8 nProp = 100;
6027
6028 if ( nVal )
6029 {
6030 nEsc = (sal_Int16)nVal;
6031 nProp = DFLT_ESC_PROP;
6032 }
6033 SvxEscapementItem aItem( nEsc, nProp, EE_CHAR_ESCAPEMENT );
6034 rSet.Put( aItem );
6035 }
6036 if ( mnLanguage[ 0 ] )
6037 rSet.Put( SvxLanguageItem( mnLanguage[ 0 ], EE_CHAR_LANGUAGE ) );
6038 if ( mnLanguage[ 1 ] )
6039 rSet.Put( SvxLanguageItem( mnLanguage[ 1 ], EE_CHAR_LANGUAGE_CJK ) );
6040 if ( mnLanguage[ 2 ] )
6041 rSet.Put( SvxLanguageItem( mnLanguage[ 2 ], EE_CHAR_LANGUAGE_CTL ) );
6042 }
6043
GetTextField()6044 SvxFieldItem* PPTPortionObj::GetTextField()
6045 {
6046 if ( mpFieldItem )
6047 return new SvxFieldItem( *mpFieldItem );
6048 return NULL;
6049 }
6050
6051 // -----------------------------------------------------------------------
6052
PPTParagraphObj(const PPTStyleSheet & rStyleSheet,sal_uInt32 nInstance,sal_uInt16 nDepth)6053 PPTParagraphObj::PPTParagraphObj( const PPTStyleSheet& rStyleSheet, sal_uInt32 nInstance, sal_uInt16 nDepth ) :
6054 PPTNumberFormatCreator ( NULL ),
6055 mrStyleSheet ( rStyleSheet ),
6056 mnInstance ( nInstance ),
6057 mbTab ( sal_True ), // style sheets always have to get the right tabulator setting
6058 mnPortionCount ( 0 ),
6059 mpPortionList ( NULL )
6060 {
6061 if ( nDepth > 4 )
6062 nDepth = 4;
6063 pParaSet->mnDepth = nDepth;
6064 }
6065
PPTParagraphObj(PPTStyleTextPropReader & rPropReader,const PPTStyleSheet & rStyleSheet,sal_uInt32 nInstance,PPTTextRulerInterpreter & rRuler)6066 PPTParagraphObj::PPTParagraphObj( PPTStyleTextPropReader& rPropReader, const PPTStyleSheet& rStyleSheet,
6067 sal_uInt32 nInstance, PPTTextRulerInterpreter& rRuler ) :
6068 PPTParaPropSet ( *( (PPTParaPropSet*)rPropReader.aParaPropList.GetCurObject() ) ),
6069 PPTNumberFormatCreator ( NULL ),
6070 PPTTextRulerInterpreter ( rRuler ),
6071 mrStyleSheet ( rStyleSheet ),
6072 mnInstance ( nInstance ),
6073 mbTab ( sal_False ),
6074 mnCurrentObject ( 0 ),
6075 mnPortionCount ( 0 ),
6076 mpPortionList ( NULL )
6077 {
6078 sal_uInt32 nCurPos = rPropReader.aCharPropList.GetCurPos();
6079 PPTCharPropSet* pCharPropSet = (PPTCharPropSet*)rPropReader.aCharPropList.GetCurObject();
6080 if ( pCharPropSet )
6081 {
6082 sal_uInt32 nCurrentParagraph = pCharPropSet->mnParagraph;
6083 for ( ; pCharPropSet && ( pCharPropSet->mnParagraph == nCurrentParagraph ); pCharPropSet = (PPTCharPropSet*)rPropReader.aCharPropList.Next() )
6084 mnPortionCount++; // counting number of portions that are part of this paragraph
6085 pCharPropSet = (PPTCharPropSet*)rPropReader.aCharPropList.Seek( nCurPos );
6086
6087 mpPortionList = new PPTPortionObj*[ mnPortionCount ];
6088 for ( sal_uInt32 i = 0; i < mnPortionCount; i++ )
6089 {
6090 if ( pCharPropSet )
6091 {
6092 PPTPortionObj* pPPTPortion = new PPTPortionObj( *pCharPropSet, rStyleSheet, nInstance, pParaSet->mnDepth );
6093 mpPortionList[ i ] = pPPTPortion;
6094 if ( !mbTab )
6095 mbTab = mpPortionList[ i ]->HasTabulator();
6096 }
6097 else
6098 {
6099 DBG_ERROR( "SJ:PPTParagraphObj::It seems that there are missing some textportions" );
6100 mpPortionList[ i ] = NULL;
6101 }
6102 pCharPropSet = (PPTCharPropSet*)rPropReader.aCharPropList.Next();
6103 }
6104 }
6105 }
6106
~PPTParagraphObj()6107 PPTParagraphObj::~PPTParagraphObj()
6108 {
6109 ImplClear();
6110 }
6111
AppendPortion(PPTPortionObj & rPPTPortion)6112 void PPTParagraphObj::AppendPortion( PPTPortionObj& rPPTPortion )
6113 {
6114 sal_uInt32 i;
6115 PPTPortionObj** mpOldPortionList = mpPortionList;
6116 mpPortionList = new PPTPortionObj*[ ++mnPortionCount ];
6117 for ( i = 0; i < mnPortionCount - 1; i++ )
6118 mpPortionList[ i ] = mpOldPortionList[ i ];
6119 delete[] mpOldPortionList;
6120 mpPortionList[ mnPortionCount - 1 ] = new PPTPortionObj( rPPTPortion );
6121 if ( !mbTab )
6122 mbTab = mpPortionList[ mnPortionCount - 1 ]->HasTabulator();
6123 }
6124
UpdateBulletRelSize(sal_uInt32 & nBulletRelSize) const6125 void PPTParagraphObj::UpdateBulletRelSize( sal_uInt32& nBulletRelSize ) const
6126 {
6127 if ( nBulletRelSize > 0x7fff ) // a negative value is the absolute bullet height
6128 {
6129 sal_uInt16 nFontHeight = 0;
6130 if ( mpPortionList )
6131 {
6132 PPTPortionObj* pPortion = mpPortionList[ 0 ];
6133 if ( pPortion && ( pPortion->pCharSet->mnAttrSet & ( 1 << PPT_CharAttr_FontHeight ) ) )
6134 nFontHeight = pPortion->pCharSet->mnFontHeight;
6135 }
6136 // if we do not have a hard attributed fontheight, the fontheight is taken from the style
6137 if ( !nFontHeight )
6138 nFontHeight = mrStyleSheet.mpCharSheet[ mnInstance ]->maCharLevel[ pParaSet->mnDepth ].mnFontHeight;
6139 nBulletRelSize = nFontHeight ? ((-((sal_Int16)nBulletRelSize)) * 100 ) / nFontHeight : 100;
6140 }
6141 }
6142
GetAttrib(sal_uInt32 nAttr,sal_uInt32 & nRetValue,sal_uInt32 nDestinationInstance)6143 sal_Bool PPTParagraphObj::GetAttrib( sal_uInt32 nAttr, sal_uInt32& nRetValue, sal_uInt32 nDestinationInstance )
6144 {
6145 sal_uInt32 nMask = 1 << nAttr;
6146 nRetValue = 0;
6147
6148 if ( nAttr > 21 )
6149 {
6150 DBG_ERROR( "SJ:PPTParagraphObj::GetAttrib - attribute does not exist" );
6151 return sal_False;
6152 }
6153
6154 sal_uInt32 bIsHardAttribute = ( ( pParaSet->mnAttrSet & nMask ) != 0 ) ? 1 : 0;
6155
6156 if ( bIsHardAttribute )
6157 {
6158 if ( nAttr == PPT_ParaAttr_BulletColor )
6159 {
6160 sal_Bool bHardBulletColor;
6161 if ( pParaSet->mnAttrSet & ( 1 << PPT_ParaAttr_BuHardColor ) )
6162 bHardBulletColor = pParaSet->mpArry[ PPT_ParaAttr_BuHardColor ] != 0;
6163 else
6164 bHardBulletColor = ( mrStyleSheet.mpParaSheet[ mnInstance ]->maParaLevel[ pParaSet->mnDepth ].mnBuFlags
6165 & ( 1 << PPT_ParaAttr_BuHardColor ) ) != 0;
6166 if ( bHardBulletColor )
6167 nRetValue = pParaSet->mnBulletColor;
6168 else
6169 {
6170 nRetValue = PPT_COLSCHEME_TEXT_UND_ZEILEN;
6171 if ( ( nDestinationInstance != 0xffffffff ) && mnPortionCount )
6172 {
6173 PPTPortionObj* pPortion = mpPortionList[ 0 ];
6174 if ( pPortion )
6175 {
6176 if ( pPortion->pCharSet->mnAttrSet & ( 1 << PPT_CharAttr_FontColor ) )
6177 nRetValue = pPortion->pCharSet->mnColor;
6178 else
6179 nRetValue = mrStyleSheet.mpCharSheet[ nDestinationInstance ]->maCharLevel[ pParaSet->mnDepth ].mnFontColor;
6180 }
6181 }
6182 }
6183 }
6184 else if ( nAttr == PPT_ParaAttr_BulletFont )
6185 {
6186 sal_Bool bHardBuFont;
6187 if ( pParaSet->mnAttrSet & ( 1 << PPT_ParaAttr_BuHardFont ) )
6188 bHardBuFont = pParaSet->mpArry[ PPT_ParaAttr_BuHardFont ] != 0;
6189 else
6190 bHardBuFont = ( mrStyleSheet.mpParaSheet[ mnInstance ]->maParaLevel[ pParaSet->mnDepth ].mnBuFlags
6191 & ( 1 << PPT_ParaAttr_BuHardFont ) ) != 0;
6192 if ( bHardBuFont )
6193 nRetValue = pParaSet->mpArry[ PPT_ParaAttr_BulletFont ];
6194 else
6195 {
6196 // it is the font used which assigned to the first character of the following text
6197 nRetValue = 0;
6198 if ( ( nDestinationInstance != 0xffffffff ) && mnPortionCount )
6199 {
6200 PPTPortionObj* pPortion = mpPortionList[ 0 ];
6201 if ( pPortion )
6202 {
6203 if ( pPortion->pCharSet->mnAttrSet & ( 1 << PPT_CharAttr_Font ) )
6204 nRetValue = pPortion->pCharSet->mnFont;
6205 else
6206 nRetValue = mrStyleSheet.mpCharSheet[ nDestinationInstance ]->maCharLevel[ pParaSet->mnDepth ].mnFont;
6207 }
6208 }
6209 }
6210 }
6211 else
6212 nRetValue = pParaSet->mpArry[ nAttr ];
6213 }
6214 else
6215 {
6216 const PPTParaLevel& rParaLevel = mrStyleSheet.mpParaSheet[ mnInstance ]->maParaLevel[ pParaSet->mnDepth ];
6217
6218 PPTParaLevel* pParaLevel = NULL;
6219 if ( ( nDestinationInstance == 0xffffffff )
6220 || ( pParaSet->mnDepth && ( ( mnInstance == TSS_TYPE_SUBTITLE ) || ( mnInstance == TSS_TYPE_TEXT_IN_SHAPE ) ) ) )
6221 bIsHardAttribute = 1;
6222 else if ( nDestinationInstance != mnInstance )
6223 pParaLevel = &mrStyleSheet.mpParaSheet[ nDestinationInstance ]->maParaLevel[ pParaSet->mnDepth ];
6224 switch ( nAttr )
6225 {
6226 case PPT_ParaAttr_BulletOn :
6227 {
6228 nRetValue = rParaLevel.mnBuFlags & ( 1 << PPT_ParaAttr_BulletOn );
6229 if ( pParaLevel )
6230 {
6231 if ( nRetValue != ( (sal_uInt32)pParaLevel->mnBuFlags & ( 1 << PPT_ParaAttr_BulletOn ) ) )
6232 bIsHardAttribute = 1;
6233 }
6234 }
6235 break;
6236 case PPT_ParaAttr_BuHardFont :
6237 case PPT_ParaAttr_BuHardColor :
6238 case PPT_ParaAttr_BuHardHeight :
6239 DBG_ERROR( "SJ:PPTParagraphObj::GetAttrib - this attribute does not make sense" );
6240 break;
6241 case PPT_ParaAttr_BulletChar :
6242 {
6243 nRetValue = rParaLevel.mnBulletChar;
6244 if ( pParaLevel && ( nRetValue != pParaLevel->mnBulletChar ) )
6245 bIsHardAttribute = 1;
6246 }
6247 break;
6248 case PPT_ParaAttr_BulletFont :
6249 {
6250 sal_Bool bHardBuFont;
6251 if ( pParaSet->mnAttrSet & ( 1 << PPT_ParaAttr_BuHardFont ) )
6252 bHardBuFont = pParaSet->mpArry[ PPT_ParaAttr_BuHardFont ] != 0;
6253 else
6254 bHardBuFont = ( rParaLevel.mnBuFlags & ( 1 << PPT_ParaAttr_BuHardFont ) ) != 0;
6255 if ( bHardBuFont )
6256 {
6257 nRetValue = rParaLevel.mnBulletFont;
6258 if ( pParaLevel && ( nRetValue != pParaLevel->mnBulletFont ) )
6259 bIsHardAttribute = 1;
6260 }
6261 else
6262 {
6263 if ( mnPortionCount )
6264 {
6265 PPTPortionObj* pPortion = mpPortionList[ 0 ];
6266 if ( pPortion )
6267 bIsHardAttribute = pPortion->GetAttrib( PPT_CharAttr_Font, nRetValue, nDestinationInstance );
6268 }
6269 else
6270 {
6271 nRetValue = mrStyleSheet.mpCharSheet[ mnInstance ]->maCharLevel[ pParaSet->mnDepth ].mnFont;
6272 bIsHardAttribute = 1;
6273 }
6274 }
6275 }
6276 break;
6277 case PPT_ParaAttr_BulletHeight :
6278 {
6279 nRetValue = rParaLevel.mnBulletHeight;
6280 if ( pParaLevel && ( nRetValue != pParaLevel->mnBulletHeight ) )
6281 bIsHardAttribute = 1;
6282 }
6283 break;
6284 case PPT_ParaAttr_BulletColor :
6285 {
6286 sal_Bool bHardBulletColor;
6287 if ( pParaSet->mnAttrSet & ( 1 << PPT_ParaAttr_BuHardColor ) )
6288 bHardBulletColor = pParaSet->mpArry[ PPT_ParaAttr_BuHardColor ] != 0;
6289 else
6290 bHardBulletColor = ( rParaLevel.mnBuFlags & ( 1 << PPT_ParaAttr_BuHardColor ) ) != 0;
6291 if ( bHardBulletColor )
6292 {
6293 nRetValue = rParaLevel.mnBulletColor;
6294 if ( pParaLevel && ( nRetValue != pParaLevel->mnBulletColor ) )
6295 bIsHardAttribute = 1;
6296 }
6297 else
6298 {
6299 if ( mnPortionCount )
6300 {
6301 PPTPortionObj* pPortion = mpPortionList[ 0 ];
6302 if ( pPortion )
6303 {
6304 if (pPortion->mbIsHyperlink )
6305 {
6306 if( pPortion->mbHardHylinkOrigColor )
6307 nRetValue = pPortion->mnHylinkOrigColor;
6308 else
6309 nRetValue = mrStyleSheet.mpCharSheet[ mnInstance ]->maCharLevel[ pParaSet->mnDepth ].mnFontColor;
6310 bIsHardAttribute = sal_True;
6311 }
6312 else
6313 {
6314 bIsHardAttribute = pPortion->GetAttrib( PPT_CharAttr_FontColor, nRetValue, nDestinationInstance );
6315 }
6316 }
6317 }
6318 else
6319 {
6320 nRetValue = mrStyleSheet.mpCharSheet[ mnInstance ]->maCharLevel[ pParaSet->mnDepth ].mnFontColor;
6321 bIsHardAttribute = 1;
6322 }
6323 }
6324 }
6325 break;
6326 case PPT_ParaAttr_Adjust :
6327 {
6328 nRetValue = rParaLevel.mnAdjust;
6329 if ( pParaLevel && ( nRetValue != pParaLevel->mnAdjust ) )
6330 bIsHardAttribute = 1;
6331 }
6332 break;
6333 case PPT_ParaAttr_LineFeed :
6334 {
6335 nRetValue = rParaLevel.mnLineFeed;
6336 if ( pParaLevel && ( nRetValue != pParaLevel->mnLineFeed ) )
6337 bIsHardAttribute = 1;
6338 }
6339 break;
6340 case PPT_ParaAttr_UpperDist :
6341 {
6342 nRetValue = rParaLevel.mnUpperDist;
6343 if ( pParaLevel && ( nRetValue != pParaLevel->mnUpperDist ) )
6344 bIsHardAttribute = 1;
6345 }
6346 break;
6347 case PPT_ParaAttr_LowerDist :
6348 {
6349 nRetValue = rParaLevel.mnLowerDist;
6350 if ( pParaLevel && ( nRetValue != pParaLevel->mnLowerDist ) )
6351 bIsHardAttribute = 1;
6352 }
6353 break;
6354 case PPT_ParaAttr_TextOfs :
6355 {
6356 nRetValue = rParaLevel.mnTextOfs;
6357 if ( pParaLevel && ( nRetValue != pParaLevel->mnTextOfs ) )
6358 bIsHardAttribute = 1;
6359 }
6360 break;
6361 case PPT_ParaAttr_BulletOfs :
6362 {
6363 nRetValue = rParaLevel.mnBulletOfs;
6364 if ( pParaLevel && ( nRetValue != pParaLevel->mnBulletOfs ) )
6365 bIsHardAttribute = 1;
6366 }
6367 break;
6368 case PPT_ParaAttr_DefaultTab :
6369 {
6370 nRetValue = rParaLevel.mnDefaultTab;
6371 if ( pParaLevel && ( nRetValue != pParaLevel->mnBulletOfs ) )
6372 bIsHardAttribute = 1;
6373 }
6374 break;
6375 case PPT_ParaAttr_AsianLB_1 :
6376 {
6377 nRetValue = rParaLevel.mnAsianLineBreak & 1;
6378 if ( pParaLevel && ( nRetValue != ( (sal_uInt32)pParaLevel->mnAsianLineBreak & 1 ) ) )
6379 bIsHardAttribute = 1;
6380 }
6381 break;
6382 case PPT_ParaAttr_AsianLB_2 :
6383 {
6384 nRetValue = ( rParaLevel.mnAsianLineBreak >> 1 ) & 1;
6385 if ( pParaLevel && ( nRetValue != ( ( (sal_uInt32)pParaLevel->mnAsianLineBreak >> 1 ) & 1 ) ) )
6386 bIsHardAttribute = 1;
6387 }
6388 break;
6389 case PPT_ParaAttr_AsianLB_3 :
6390 {
6391 nRetValue = ( rParaLevel.mnAsianLineBreak >> 2 ) & 1;
6392 if ( pParaLevel && ( nRetValue != ( ( (sal_uInt32)pParaLevel->mnAsianLineBreak >> 2 ) & 1 ) ) )
6393 bIsHardAttribute = 1;
6394 }
6395 break;
6396 case PPT_ParaAttr_BiDi :
6397 {
6398 nRetValue = rParaLevel.mnBiDi;
6399 if ( pParaLevel && ( nRetValue != pParaLevel->mnBiDi ) )
6400 bIsHardAttribute = 1;
6401 }
6402 break;
6403 }
6404 }
6405 return (sal_Bool)bIsHardAttribute;
6406 }
6407
ApplyTo(SfxItemSet & rSet,boost::optional<sal_Int16> & rStartNumbering,SdrPowerPointImport & rManager,sal_uInt32 nDestinationInstance,const PPTParagraphObj *)6408 void PPTParagraphObj::ApplyTo( SfxItemSet& rSet, boost::optional< sal_Int16 >& rStartNumbering, SdrPowerPointImport& rManager, sal_uInt32 nDestinationInstance, const PPTParagraphObj* /*pPrev*/)
6409 {
6410 sal_Int16 nVal2;
6411 sal_uInt32 nVal, nUpperDist, nLowerDist;
6412 sal_uInt32 nInstance = nDestinationInstance != 0xffffffff ? nDestinationInstance : mnInstance;
6413
6414 if ( ( nDestinationInstance != 0xffffffff ) || ( pParaSet->mnDepth <= 1 ) )
6415 {
6416 SvxNumBulletItem* pNumBulletItem = mrStyleSheet.mpNumBulletItem[ nInstance ];
6417 if ( pNumBulletItem )
6418 {
6419 SvxNumberFormat aNumberFormat( SVX_NUM_NUMBER_NONE );
6420 if ( GetNumberFormat( rManager, aNumberFormat, this, nDestinationInstance, rStartNumbering ) )
6421 {
6422 if ( aNumberFormat.GetNumberingType() == SVX_NUM_NUMBER_NONE )
6423 {
6424 aNumberFormat.SetLSpace( 0 );
6425 aNumberFormat.SetAbsLSpace( 0 );
6426 aNumberFormat.SetFirstLineOffset( 0 );
6427 aNumberFormat.SetCharTextDistance( 0 );
6428 aNumberFormat.SetFirstLineIndent( 0 );
6429 aNumberFormat.SetIndentAt( 0 );
6430 }
6431 SvxNumBulletItem aNewNumBulletItem( *pNumBulletItem );
6432 SvxNumRule* pRule = aNewNumBulletItem.GetNumRule();
6433 if ( pRule )
6434 {
6435 pRule->SetLevel( pParaSet->mnDepth, aNumberFormat );
6436 sal_uInt16 i, n;
6437 for ( i = 0; i < pRule->GetLevelCount(); i++ )
6438 {
6439 if ( i != pParaSet->mnDepth )
6440 {
6441 n = i > 4 ? 4 : i;
6442
6443 SvxNumberFormat aNumberFormat2( pRule->GetLevel( i ) );
6444 const PPTParaLevel& rParaLevel = mrStyleSheet.mpParaSheet[ nInstance ]->maParaLevel[ n ];
6445 const PPTCharLevel& rCharLevel = mrStyleSheet.mpCharSheet[ nInstance ]->maCharLevel[ n ];
6446 sal_uInt32 nColor;
6447 if ( rParaLevel.mnBuFlags & ( 1 << PPT_ParaAttr_BuHardColor ) )
6448 nColor = rParaLevel.mnBulletColor;
6449 else
6450 nColor = rCharLevel.mnFontColor;
6451 aNumberFormat2.SetBulletColor( rManager.MSO_TEXT_CLR_ToColor( nColor ) );
6452 pRule->SetLevel( i, aNumberFormat2 );
6453 }
6454 }
6455 rSet.Put( aNewNumBulletItem );
6456 }
6457 }
6458 }
6459 }
6460
6461 sal_uInt32 nIsBullet2, _nTextOfs, _nBulletOfs, nHardAttribute = 0;
6462 GetAttrib( PPT_ParaAttr_BulletOn, nIsBullet2, nDestinationInstance );
6463 nHardAttribute += GetAttrib( PPT_ParaAttr_TextOfs, _nTextOfs, nDestinationInstance );
6464 nHardAttribute += GetAttrib( PPT_ParaAttr_BulletOfs, _nBulletOfs, nDestinationInstance );
6465 if ( !nIsBullet2 )
6466 {
6467 SvxLRSpaceItem aLRSpaceItem( EE_PARA_LRSPACE );
6468 sal_uInt16 nAbsLSpace = (sal_uInt16)( ( (sal_uInt32)_nTextOfs * 2540 ) / 576 );
6469 sal_uInt16 nFirstLineOffset = nAbsLSpace - (sal_uInt16)( ( (sal_uInt32)_nBulletOfs * 2540 ) / 576 );
6470 aLRSpaceItem.SetLeft( nAbsLSpace );
6471 aLRSpaceItem.SetTxtFirstLineOfstValue( -nFirstLineOffset );
6472 rSet.Put( aLRSpaceItem );
6473 }
6474 else
6475 {
6476 SvxLRSpaceItem aLRSpaceItem( EE_PARA_LRSPACE );
6477 aLRSpaceItem.SetLeft( 0 );
6478 aLRSpaceItem.SetTxtFirstLineOfstValue( 0 );
6479 rSet.Put( aLRSpaceItem );
6480 }
6481 if ( GetAttrib( PPT_ParaAttr_Adjust, nVal, nDestinationInstance ) )
6482 {
6483 if ( nVal <= 3 )
6484 { // Absatzausrichtung
6485 static SvxAdjust __READONLY_DATA aAdj[ 4 ] = { SVX_ADJUST_LEFT, SVX_ADJUST_CENTER, SVX_ADJUST_RIGHT, SVX_ADJUST_BLOCK };
6486 rSet.Put( SvxAdjustItem( aAdj[ nVal ], EE_PARA_JUST ) );
6487 }
6488 }
6489
6490 if ( GetAttrib( PPT_ParaAttr_AsianLB_1, nVal, nDestinationInstance ) )
6491 rSet.Put( SfxBoolItem( EE_PARA_FORBIDDENRULES, nVal != 0 ) );
6492 if ( GetAttrib( PPT_ParaAttr_AsianLB_3, nVal, nDestinationInstance ) )
6493 rSet.Put( SfxBoolItem( EE_PARA_HANGINGPUNCTUATION, nVal != 0 ) );
6494
6495 if ( GetAttrib( PPT_ParaAttr_BiDi, nVal, nDestinationInstance ) )
6496 rSet.Put( SvxFrameDirectionItem( nVal == 1 ? FRMDIR_HORI_RIGHT_TOP : FRMDIR_HORI_LEFT_TOP, EE_PARA_WRITINGDIR ) );
6497
6498 // LineSpacing
6499 PPTPortionObj* pPortion = First();
6500 sal_Bool bIsHardAttribute = GetAttrib( PPT_ParaAttr_LineFeed, nVal, nDestinationInstance );
6501 nVal2 = (sal_Int16)nVal;
6502 sal_uInt32 nFont = sal_uInt32();
6503 if ( pPortion && pPortion->GetAttrib( PPT_CharAttr_Font, nFont, nDestinationInstance ) )
6504 bIsHardAttribute = sal_True;
6505
6506 if ( bIsHardAttribute )
6507 {
6508 if ( pPortion && ( nVal2 > 200 ) )
6509 {
6510 sal_uInt32 nFontHeight;
6511 pPortion->GetAttrib( PPT_CharAttr_FontHeight, nFontHeight, nDestinationInstance );
6512 nVal2 = -(sal_Int16)( ( nFontHeight * nVal * 8 ) / 100 );
6513 }
6514 rSet.Put( SdrTextFixedCellHeightItem( sal_True ), SDRATTR_TEXT_USEFIXEDCELLHEIGHT );
6515 SvxLineSpacingItem aItem( 200, EE_PARA_SBL );
6516 if ( nVal2 <= 0 )
6517 {
6518 aItem.SetLineHeight( (sal_uInt16)( rManager.ScalePoint( -nVal2 ) / 8 ) );
6519 aItem.GetLineSpaceRule() = SVX_LINE_SPACE_FIX;
6520 }
6521 else
6522 {
6523 sal_uInt8 nPropLineSpace = (sal_uInt8)nVal2;
6524 aItem.SetPropLineSpace( nPropLineSpace );
6525 aItem.GetLineSpaceRule() = SVX_LINE_SPACE_AUTO;
6526 }
6527 rSet.Put( aItem );
6528 }
6529
6530 // Paragraph Spacing
6531 sal_uInt32 nFontHeight = 0;
6532 bIsHardAttribute = ( (sal_uInt32)GetAttrib( PPT_ParaAttr_UpperDist, nUpperDist, nDestinationInstance ) +
6533 (sal_uInt32)GetAttrib( PPT_ParaAttr_LowerDist, nLowerDist, nDestinationInstance ) ) != 0;
6534 if ( ( nUpperDist > 0 ) || ( nLowerDist > 0 ) )
6535 {
6536 if ( mnPortionCount )
6537 {
6538 mpPortionList[ mnPortionCount - 1 ]->GetAttrib( PPT_CharAttr_FontHeight, nFontHeight, nDestinationInstance );
6539 if ( ((sal_Int16)nUpperDist) > 0 )
6540 nUpperDist = - (sal_Int16)( ( nFontHeight * nUpperDist * 100 ) / 1000 );
6541 if ( ((sal_Int16)nLowerDist) > 0 )
6542 nLowerDist = - (sal_Int16)( ( nFontHeight * nLowerDist * 100 ) / 1000 );
6543 }
6544 bIsHardAttribute = sal_True;
6545 }
6546 if ( bIsHardAttribute )
6547 {
6548 SvxULSpaceItem aULSpaceItem( EE_PARA_ULSPACE );
6549 nVal2 = (sal_Int16)nUpperDist;
6550 if ( nVal2 <= 0 )
6551 aULSpaceItem.SetUpper( (sal_uInt16)(((sal_uInt32) - nVal2 * 2540 ) / ( 72 * 8 ) ) );
6552 else
6553 {
6554 aULSpaceItem.SetUpperValue( 0 );
6555 aULSpaceItem.SetPropUpper( (sal_uInt16)nUpperDist == 100 ? 101 : (sal_uInt16)nUpperDist );
6556 }
6557 nVal2 = (sal_Int16)nLowerDist;
6558 if ( nVal2 <= 0 )
6559 aULSpaceItem.SetLower( (sal_uInt16)(((sal_uInt32) - nVal2 * 2540 ) / ( 72 * 8 ) ) );
6560 else
6561 {
6562 aULSpaceItem.SetLowerValue( 0 );
6563 aULSpaceItem.SetPropLower( (sal_uInt16)nLowerDist == 100 ? 101 : (sal_uInt16)nLowerDist );
6564 }
6565 rSet.Put( aULSpaceItem );
6566 }
6567
6568 if ( mbTab ) // makes it sense to apply tabsettings
6569 {
6570 sal_uInt32 i, nDefaultTab, nTab, nTextOfs2 = 0;
6571 sal_uInt32 nLatestManTab = 0;
6572 GetAttrib( PPT_ParaAttr_TextOfs, nTextOfs2, nDestinationInstance );
6573 GetAttrib( PPT_ParaAttr_BulletOfs, nTab, nDestinationInstance );
6574 GetAttrib( PPT_ParaAttr_BulletOn, i, nDestinationInstance );
6575 GetAttrib( PPT_ParaAttr_DefaultTab, nDefaultTab, nDestinationInstance );
6576 SvxTabStopItem aTabItem( 0, 0, SVX_TAB_ADJUST_DEFAULT, EE_PARA_TABS );
6577 if ( GetTabCount() )
6578 {
6579 //paragraph offset = MIN(first_line_offset, hanging_offset)
6580 sal_uInt32 nParaOffset = Min( nTextOfs2, nTab );
6581 for ( i = 0; i < GetTabCount(); i++ )
6582 {
6583 SvxTabAdjust eTabAdjust;
6584 nTab = GetTabOffsetByIndex( (sal_uInt16)i );
6585 switch( GetTabStyleByIndex( (sal_uInt16)i ) )
6586 {
6587 case 1 : eTabAdjust = SVX_TAB_ADJUST_CENTER; break;
6588 case 2 : eTabAdjust = SVX_TAB_ADJUST_RIGHT; break;
6589 case 3 : eTabAdjust = SVX_TAB_ADJUST_DECIMAL; break;
6590 default : eTabAdjust = SVX_TAB_ADJUST_LEFT;
6591 }
6592 if ( nTab > nParaOffset )//If tab stop greater than paragraph offset
6593 aTabItem.Insert( SvxTabStop( ( ( (long( nTab - nTextOfs2 )) * 2540 ) / 576 ), eTabAdjust ) );
6594 }
6595 nLatestManTab = nTab;
6596 }
6597 if ( nIsBullet2 == 0 )
6598 aTabItem.Insert( SvxTabStop( (sal_uInt16)0 ) );
6599 if ( nDefaultTab )
6600 {
6601 nTab = ( nTextOfs2 > nLatestManTab ) ? nTextOfs2 : nLatestManTab;
6602 nTab /= nDefaultTab;
6603 nTab = nDefaultTab * ( 1 + nTab );
6604 for ( i = 0; ( i < 20 ) && ( nTab < 0x1b00 ); i++ )
6605 {
6606 aTabItem.Insert( SvxTabStop( (sal_uInt16)( ( ( nTab - nTextOfs2 ) * 2540 ) / 576 ) ) );
6607 nTab += nDefaultTab;
6608 }
6609 }
6610 rSet.Put( aTabItem );
6611 }
6612 }
6613
GetTextSize()6614 sal_uInt32 PPTParagraphObj::GetTextSize()
6615 {
6616 sal_uInt32 nCount, nRetValue = 0;
6617 for ( sal_uInt32 i = 0; i < mnPortionCount; i++ )
6618 {
6619 PPTPortionObj* pPortionObj = mpPortionList[ i ];
6620 nCount = pPortionObj->Count();
6621 if ( ( !nCount ) && pPortionObj->mpFieldItem )
6622 nCount++;
6623 nRetValue += nCount;
6624 }
6625 return nRetValue;
6626 }
6627
First()6628 PPTPortionObj* PPTParagraphObj::First()
6629 {
6630 mnCurrentObject = 0;
6631 if ( !mnPortionCount )
6632 return NULL;
6633 return mpPortionList[ 0 ];
6634 }
6635
Next()6636 PPTPortionObj* PPTParagraphObj::Next()
6637 {
6638 sal_uInt32 i = mnCurrentObject + 1;
6639 if ( i >= mnPortionCount )
6640 return NULL;
6641 mnCurrentObject++;
6642 return mpPortionList[ i ];
6643 }
6644
ImplClear()6645 void PPTParagraphObj::ImplClear()
6646 {
6647 for ( void* pPtr = First(); pPtr; pPtr = Next() )
6648 delete (PPTPortionObj*)pPtr;
6649 delete[] mpPortionList;
6650 }
6651
~PPTFieldEntry()6652 PPTFieldEntry::~PPTFieldEntry()
6653 {
6654 delete pField1;
6655 delete pField2;
6656 delete pString;
6657 };
6658
GetDateTime(const sal_uInt32 nVal,SvxDateFormat & eDateFormat,SvxTimeFormat & eTimeFormat)6659 void PPTFieldEntry::GetDateTime( const sal_uInt32 nVal, SvxDateFormat& eDateFormat, SvxTimeFormat& eTimeFormat )
6660 {
6661 eDateFormat = SVXDATEFORMAT_APPDEFAULT;
6662 eTimeFormat = SVXTIMEFORMAT_APPDEFAULT;
6663 // ID auswerten
6664 switch( nVal )
6665 {
6666 case 0:
6667 case 6:
6668 eDateFormat = SVXDATEFORMAT_A;
6669 break;
6670 case 1:
6671 eDateFormat = SVXDATEFORMAT_F;
6672 break;
6673 case 2:
6674 case 3:
6675 eDateFormat = SVXDATEFORMAT_D;
6676 break;
6677 case 4:
6678 case 5:
6679 eDateFormat = SVXDATEFORMAT_C;
6680 break;
6681 case 7:
6682 eDateFormat = SVXDATEFORMAT_A;
6683 case 9:
6684 eTimeFormat = SVXTIMEFORMAT_24_HM;
6685 break;
6686 case 8:
6687 eDateFormat = SVXDATEFORMAT_A;
6688 case 11:
6689 eTimeFormat = SVXTIMEFORMAT_12_HM;
6690 break;
6691 case 10:
6692 eTimeFormat = SVXTIMEFORMAT_24_HMS;
6693 break;
6694 case 12:
6695 eTimeFormat = SVXTIMEFORMAT_12_HMS;
6696 break;
6697 }
6698 }
6699
SetDateTime(sal_uInt32 nVal)6700 void PPTFieldEntry::SetDateTime( sal_uInt32 nVal )
6701 {
6702 SvxDateFormat eDateFormat;
6703 SvxTimeFormat eTimeFormat;
6704 GetDateTime( nVal, eDateFormat, eTimeFormat );
6705 if ( eDateFormat != SVXDATEFORMAT_APPDEFAULT )
6706 pField1 = new SvxFieldItem( SvxDateField( Date(), SVXDATETYPE_VAR, eDateFormat ), EE_FEATURE_FIELD );
6707 if ( eTimeFormat != SVXTIMEFORMAT_APPDEFAULT )
6708 {
6709 SvxFieldItem* pFieldItem = new SvxFieldItem( SvxExtTimeField( Time(), SVXTIMETYPE_VAR, eTimeFormat ), EE_FEATURE_FIELD );
6710 if ( pField1 )
6711 pField2 = pFieldItem;
6712 else
6713 pField1 = pFieldItem;
6714 }
6715 }
6716
6717 // -----------------------------------------------------------------------
6718
PPTTextObj(SvStream & rIn,SdrPowerPointImport & rSdrPowerPointImport,PptSlidePersistEntry & rPersistEntry,DffObjData * pObjData)6719 PPTTextObj::PPTTextObj( SvStream& rIn, SdrPowerPointImport& rSdrPowerPointImport, PptSlidePersistEntry& rPersistEntry, DffObjData* pObjData ) :
6720 mpImplTextObj ( new ImplPPTTextObj( rPersistEntry ) )
6721 {
6722 mpImplTextObj->mnRefCount = 1;
6723 mpImplTextObj->mnShapeId = 0;
6724 mpImplTextObj->mnShapeMaster = 0;
6725 mpImplTextObj->mpPlaceHolderAtom = NULL;
6726 mpImplTextObj->mnDestinationInstance = mpImplTextObj->mnInstance = 4;
6727 mpImplTextObj->mnCurrentObject = 0;
6728 mpImplTextObj->mnParagraphCount = 0;
6729 mpImplTextObj->mpParagraphList = NULL;
6730 mpImplTextObj->mnTextFlags = 0;
6731 mpImplTextObj->meShapeType = ( pObjData && pObjData->bShapeType ) ? pObjData->eShapeType : mso_sptMin;
6732
6733 DffRecordHeader aExtParaHd;
6734 aExtParaHd.nRecType = 0; // set empty
6735
6736 sal_uInt32 bStatus = sal_True;
6737
6738 DffRecordHeader aShapeContainerHd;
6739 rIn >> aShapeContainerHd;
6740
6741 if ( ( pObjData == NULL ) || ( pObjData->bShapeType ) )
6742 {
6743 PPTExtParaProv* pExtParaProv = rSdrPowerPointImport.pPPTStyleSheet->pExtParaProv;
6744 if ( pObjData )
6745 {
6746 mpImplTextObj->mnShapeId = pObjData->nShapeId;
6747 if ( pObjData->nSpFlags & SP_FHAVEMASTER )
6748 mpImplTextObj->mnShapeMaster = rSdrPowerPointImport.GetPropertyValue( DFF_Prop_hspMaster, 0 );
6749 }
6750 ////////////////
6751 // ClientData //
6752 ////////////////
6753 if ( rSdrPowerPointImport.maShapeRecords.SeekToContent( rIn, DFF_msofbtClientData, SEEK_FROM_CURRENT_AND_RESTART ) )
6754 {
6755 sal_uInt32 nOldPos = rIn.Tell();
6756 DffRecordHeader& aClientDataContainerHd = *rSdrPowerPointImport.maShapeRecords.Current();
6757 DffRecordHeader aPlaceHolderAtomHd;
6758 if ( rSdrPowerPointImport.SeekToRec( rIn, PPT_PST_OEPlaceholderAtom, aClientDataContainerHd.GetRecEndFilePos(), &aPlaceHolderAtomHd ) )
6759 {
6760 mpImplTextObj->mpPlaceHolderAtom = new PptOEPlaceholderAtom;
6761 rIn >> *( mpImplTextObj->mpPlaceHolderAtom );
6762 }
6763 rIn.Seek( nOldPos );
6764 DffRecordHeader aProgTagHd;
6765 if ( rSdrPowerPointImport.SeekToContentOfProgTag( 9, rIn, aClientDataContainerHd, aProgTagHd ) )
6766 {
6767 rIn >> aExtParaHd;
6768 }
6769 }
6770
6771 ///////////////////
6772 // ClientTextBox //
6773 ///////////////////
6774 if ( rSdrPowerPointImport.maShapeRecords.SeekToContent( rIn, DFF_msofbtClientTextbox, SEEK_FROM_CURRENT_AND_RESTART ) )
6775 {
6776 DffRecordHeader aClientTextBoxHd( *rSdrPowerPointImport.maShapeRecords.Current() );
6777 sal_uInt32 nTextRulerAtomOfs = 0; // case of zero -> this atom may be found in aClientDataContainerHd;
6778 // case of -1 -> ther is no atom of this kind
6779 // else -> this is the fileofs where we can get it
6780
6781 //////////////////////////////////////
6782 // checkout if this is a referenced //
6783 // textobj, if so the we will patch //
6784 // the ClientTextBoxHd for a //
6785 // equivalent one //
6786 //////////////////////////////////////
6787 DffRecordHeader aTextHd;
6788 if ( rSdrPowerPointImport.SeekToRec( rIn, PPT_PST_OutlineTextRefAtom, aClientTextBoxHd.GetRecEndFilePos(), &aTextHd ) )
6789 {
6790 sal_uInt32 nRefNum;
6791 rIn >> nRefNum;
6792
6793 if ( rSdrPowerPointImport.SeekToRec( rIn, PPT_PST_TextRulerAtom, aClientTextBoxHd.GetRecEndFilePos() ) )
6794 nTextRulerAtomOfs = rIn.Tell();
6795 else
6796 nTextRulerAtomOfs = 0xffffffff;
6797
6798 sal_uInt32 nInstance = 0;
6799 switch( rSdrPowerPointImport.eAktPageKind )
6800 {
6801 case PPT_NOTEPAGE :
6802 nInstance++;
6803 case PPT_MASTERPAGE :
6804 nInstance++;
6805 case PPT_SLIDEPAGE :
6806 break;
6807 default :
6808 bStatus = sal_False;
6809 }
6810 if ( bStatus )
6811 {
6812 sal_uInt32 nSlideId = rSdrPowerPointImport.GetAktPageId();
6813 if ( !nSlideId )
6814 bStatus = sal_False;
6815 else
6816 {
6817 if ( !aExtParaHd.nRecType )
6818 {
6819 sal_uInt32 nOldPos = rIn.Tell();
6820 // try to locate the referenced ExtendedParaHd
6821 DffRecordHeader* pHd = pExtParaProv->
6822 aExtendedPresRules.GetRecordHeader( PPT_PST_ExtendedParagraphHeaderAtom,
6823 SEEK_FROM_CURRENT_AND_RESTART );
6824 DffRecordHeader aPresRuleHd;
6825 DffRecordHeader* pFirst = pHd;
6826
6827 sal_uInt32 nTmpSlideId, nTmpRef;
6828 while ( pHd )
6829 {
6830 pHd->SeekToContent( rIn );
6831 rIn >> nTmpSlideId
6832 >> nTmpRef; // this seems to be the instance
6833
6834 if ( ( nTmpSlideId == nSlideId ) && ( pHd->nRecInstance == nRefNum ) )
6835 {
6836 pHd->SeekToEndOfRecord( rIn );
6837 rIn >> aPresRuleHd;
6838 if ( aPresRuleHd.nRecType == PPT_PST_ExtendedParagraphAtom )
6839 {
6840 aExtParaHd = aPresRuleHd;
6841 break;
6842 }
6843 }
6844 pHd = pExtParaProv->
6845 aExtendedPresRules.GetRecordHeader( PPT_PST_ExtendedParagraphHeaderAtom,
6846 SEEK_FROM_CURRENT_AND_RESTART );
6847 if ( pHd == pFirst )
6848 break;
6849 }
6850 rIn.Seek( nOldPos );
6851 }
6852 // now pHd points to the right SlideListWithText Container
6853 PptSlidePersistList* pPageList = rSdrPowerPointImport.GetPageList( rSdrPowerPointImport.eAktPageKind );
6854 PptSlidePersistEntry* pE = NULL;
6855 if ( pPageList && ( rSdrPowerPointImport.nAktPageNum < pPageList->Count() ) )
6856 pE = (*pPageList)[ rSdrPowerPointImport.nAktPageNum ];
6857 if ( (!pE) || (!pE->nSlidePersistStartOffset) || ( pE->aPersistAtom.nSlideId != nSlideId ) )
6858 bStatus = sal_False;
6859 else
6860 {
6861 rIn.Seek( pE->nSlidePersistStartOffset );
6862 // now we got the right page and are searching for the right
6863 // TextHeaderAtom
6864 while ( rIn.Tell() < pE->nSlidePersistEndOffset )
6865 {
6866 rIn >> aClientTextBoxHd;
6867 if ( aClientTextBoxHd.nRecType == PPT_PST_TextHeaderAtom )
6868 {
6869 if ( aClientTextBoxHd.nRecInstance == nRefNum )
6870 {
6871 aClientTextBoxHd.SeekToEndOfRecord( rIn );
6872 break;
6873 }
6874 }
6875 aClientTextBoxHd.SeekToEndOfRecord( rIn );
6876 }
6877 if ( rIn.Tell() > pE->nSlidePersistEndOffset )
6878 bStatus = sal_False;
6879 else
6880 { // patching the RecordHeader
6881 aClientTextBoxHd.nFilePos -= DFF_COMMON_RECORD_HEADER_SIZE;
6882 aClientTextBoxHd.nRecLen += DFF_COMMON_RECORD_HEADER_SIZE;
6883 aClientTextBoxHd.nRecType = DFF_msofbtClientTextbox;
6884 aClientTextBoxHd.nRecVer = DFF_PSFLAG_CONTAINER;
6885
6886 // we have to calculate the correct record len
6887 DffRecordHeader aTmpHd;
6888 while ( rIn.Tell() < pE->nSlidePersistEndOffset )
6889 {
6890 rIn >> aTmpHd;
6891 if ( ( aTmpHd.nRecType == PPT_PST_SlidePersistAtom ) || ( aTmpHd.nRecType == PPT_PST_TextHeaderAtom ) )
6892 break;
6893 aTmpHd.SeekToEndOfRecord( rIn );
6894 aClientTextBoxHd.nRecLen += aTmpHd.nRecLen + DFF_COMMON_RECORD_HEADER_SIZE;
6895 }
6896 aClientTextBoxHd.SeekToContent( rIn );
6897 }
6898 }
6899 }
6900 }
6901 }
6902
6903 if ( bStatus )
6904 {
6905 if ( rSdrPowerPointImport.SeekToRec( rIn, PPT_PST_TextHeaderAtom, aClientTextBoxHd.GetRecEndFilePos(), &aTextHd ) )
6906 {
6907 // TextHeaderAtom is always the first Atom
6908 sal_uInt16 nInstance;
6909 rIn >> nInstance; // this number tells us the TxMasterStyleAtom Instance
6910 if ( nInstance > 8 )
6911 nInstance = 4;
6912 aTextHd.SeekToEndOfRecord( rIn );
6913 mpImplTextObj->mnInstance = nInstance;
6914
6915 sal_uInt32 nFilePos = rIn.Tell();
6916 if ( rSdrPowerPointImport.SeekToRec2( PPT_PST_TextBytesAtom,
6917 PPT_PST_TextCharsAtom,
6918 aClientTextBoxHd.GetRecEndFilePos() )
6919 || rSdrPowerPointImport.SeekToRec( rIn,
6920 PPT_PST_StyleTextPropAtom,
6921 aClientTextBoxHd.GetRecEndFilePos() ) )
6922 {
6923 PPTTextRulerInterpreter aTextRulerInterpreter( nTextRulerAtomOfs, rSdrPowerPointImport,
6924 aClientTextBoxHd, rIn );
6925
6926 PPTStyleTextPropReader aStyleTextPropReader( rIn, rSdrPowerPointImport, aClientTextBoxHd,
6927 aTextRulerInterpreter, aExtParaHd, nInstance );
6928 sal_uInt32 nParagraphs = mpImplTextObj->mnParagraphCount = aStyleTextPropReader.aParaPropList.Count();
6929 if ( nParagraphs )
6930 {
6931 // the language settings will be merged into the list of PPTCharPropSet
6932 DffRecordHeader aTextSpecInfoHd;
6933 PPTTextSpecInfoAtomInterpreter aTextSpecInfoAtomInterpreter;
6934 if ( rSdrPowerPointImport.SeekToRec( rIn, PPT_PST_TextSpecInfoAtom,
6935 aClientTextBoxHd.GetRecEndFilePos(), &aTextSpecInfoHd ) )
6936 {
6937 if ( aTextSpecInfoAtomInterpreter.Read( rIn, aTextSpecInfoHd, PPT_PST_TextSpecInfoAtom,
6938 &(rSdrPowerPointImport.pPPTStyleSheet->maTxSI) ) )
6939 {
6940 sal_uInt32 nI = 0;
6941 PPTTextSpecInfo* pSpecInfo;
6942 for ( pSpecInfo = (PPTTextSpecInfo*)aTextSpecInfoAtomInterpreter.aList.First();
6943 pSpecInfo; pSpecInfo =(PPTTextSpecInfo*)aTextSpecInfoAtomInterpreter.aList.Next() )
6944 {
6945 sal_uInt32 nCharIdx = pSpecInfo->nCharIdx;
6946
6947 // portions and text have to been splitted in some cases
6948 for ( ; nI < aStyleTextPropReader.aCharPropList.Count(); )
6949 {
6950 PPTCharPropSet* pSet = (PPTCharPropSet*)aStyleTextPropReader.aCharPropList.GetObject( nI );
6951 if ( pSet->mnOriginalTextPos < nCharIdx )
6952 {
6953 pSet->mnLanguage[ 0 ] = pSpecInfo->nLanguage[ 0 ];
6954 pSet->mnLanguage[ 1 ] = pSpecInfo->nLanguage[ 1 ];
6955 pSet->mnLanguage[ 2 ] = pSpecInfo->nLanguage[ 2 ];
6956 // test if the current portion needs to be splitted
6957 if ( pSet->maString.Len() > 1 )
6958 {
6959 sal_Int32 nIndexOfNextPortion = pSet->maString.Len() + pSet->mnOriginalTextPos;
6960 sal_Int32 nNewLen = nIndexOfNextPortion - nCharIdx;
6961 sal_Int32 nOldLen = pSet->maString.Len() - nNewLen;
6962
6963 if ( ( nNewLen > 0 ) && ( nOldLen > 0 ) )
6964 {
6965 String aString( pSet->maString );
6966 PPTCharPropSet* pNew = new PPTCharPropSet( *pSet );
6967 pSet->maString = String( aString, 0, (sal_uInt16)nOldLen );
6968 pNew->maString = String( aString, (sal_uInt16)nOldLen, (sal_uInt16)nNewLen );
6969 pNew->mnOriginalTextPos += nOldLen;
6970 aStyleTextPropReader.aCharPropList.Insert( pNew, nI + 1 );
6971 }
6972 }
6973 }
6974 else
6975 break;
6976 nI++;
6977 }
6978 }
6979 }
6980 #ifdef DBG_UTIL
6981 else
6982 {
6983 if (!(rSdrPowerPointImport.rImportParam.nImportFlags & PPT_IMPORTFLAGS_NO_TEXT_ASSERT))
6984 {
6985 DBG_ERROR( "SdrTextSpecInfoAtomInterpreter::Ctor(): parsing error, this document needs to be analysed (SJ)" );
6986 }
6987 }
6988 #endif
6989 }
6990 //
6991 // now will search for possible textextensions such as date/time fields
6992 // or ParaTabStops and append them on this textobj
6993 //
6994 rIn.Seek( nFilePos );
6995 List* pFieldList = NULL;
6996 while ( rIn.Tell() < aClientTextBoxHd.GetRecEndFilePos() )
6997 {
6998 rIn >> aTextHd;
6999 sal_uInt16 nVal = 0;
7000 PPTFieldEntry* pEntry = NULL;
7001 switch ( aTextHd.nRecType )
7002 {
7003 case PPT_PST_DateTimeMCAtom :
7004 {
7005 pEntry = new PPTFieldEntry;
7006 rIn >> pEntry->nPos
7007 >> nVal
7008 >> nVal;
7009 pEntry->SetDateTime( nVal & 0xff );
7010 }
7011 break;
7012
7013 case PPT_PST_FooterMCAtom :
7014 {
7015 pEntry = new PPTFieldEntry;
7016 rIn >> pEntry->nPos;
7017 pEntry->pField1 = new SvxFieldItem( SvxFooterField(), EE_FEATURE_FIELD );
7018 }
7019 break;
7020
7021 case PPT_PST_HeaderMCAtom :
7022 {
7023 pEntry = new PPTFieldEntry;
7024 rIn >> pEntry->nPos;
7025 pEntry->pField1 = new SvxFieldItem( SvxHeaderField(), EE_FEATURE_FIELD );
7026 }
7027 break;
7028
7029 case PPT_PST_GenericDateMCAtom :
7030 {
7031 pEntry = new PPTFieldEntry;
7032 rIn >> pEntry->nPos;
7033 pEntry->pField1 = new SvxFieldItem( SvxDateTimeField(), EE_FEATURE_FIELD );
7034 if ( rPersistEntry.pHeaderFooterEntry ) // sj: #i34111# on master pages it is possible
7035 { // that there is no HeaderFooterEntry available
7036 if ( rPersistEntry.pHeaderFooterEntry->nAtom & 0x20000 ) // auto date time
7037 pEntry->SetDateTime( rPersistEntry.pHeaderFooterEntry->nAtom & 0xff );
7038 else
7039 pEntry->pString = new String( rPersistEntry.pHeaderFooterEntry->pPlaceholder[ nVal ] );
7040 }
7041 }
7042 break;
7043
7044 case PPT_PST_SlideNumberMCAtom :
7045 case PPT_PST_RTFDateTimeMCAtom :
7046 {
7047 pEntry = new PPTFieldEntry;
7048 if ( aTextHd.nRecLen >= 4 )
7049 {
7050 rIn >> pEntry->nPos
7051 >> nVal;
7052
7053 // ID auswerten
7054 //SvxFieldItem* pFieldItem = NULL;
7055 switch( aTextHd.nRecType )
7056 {
7057 case PPT_PST_SlideNumberMCAtom:
7058 pEntry->pField1 = new SvxFieldItem( SvxPageField(), EE_FEATURE_FIELD );
7059 break;
7060
7061 case PPT_PST_RTFDateTimeMCAtom:
7062 {
7063 // Rude workaround for one specal case reported
7064 // by a customer. (#i75203#)
7065
7066 // Don't even attempt to handle the general use
7067 // case for PPT_PST_RTFDateTimeMCAtom (a generic
7068 // MS style date/time format string). Just handle
7069 // the special case where the format string
7070 // contains only one or several possibly empty
7071 // quoted strings. I.e. something that doesn't
7072 // expand to any date or time at all, but to a
7073 // fixed string. How on earth somebody manages to
7074 // produce such things in PPT slides I have no
7075 // idea.
7076 if (nVal == 0)
7077 {
7078 sal_Unicode n;
7079 xub_StrLen nLen;
7080 String aStr;
7081 bool inquote = sal_False;
7082 for (nLen = 0, n = 0; nLen < 64; nLen++)
7083 {
7084 rIn >> n;
7085
7086 // Collect quoted characters into aStr
7087 if ( n == '\'')
7088 inquote = !inquote;
7089 else if (!n)
7090 {
7091 // End of format string
7092 pEntry->pString = new String( aStr );
7093 break;
7094 }
7095 else if (!inquote)
7096 {
7097 // Non-quoted character, i.e. a real
7098 // format specifier. We don't handle
7099 // those. Sorry.
7100 break;
7101 }
7102 else
7103 {
7104 aStr += n;
7105 }
7106 }
7107 }
7108 if ( pEntry->pString == NULL )
7109 {
7110 // Handle as previously
7111 pEntry->pField1 = new SvxFieldItem( SvxDateField( Date(), SVXDATETYPE_FIX ), EE_FEATURE_FIELD );
7112 }
7113 }
7114 }
7115 }
7116 }
7117 break;
7118
7119 case PPT_PST_InteractiveInfo :
7120 {
7121 DffRecordHeader aHdInteractiveInfoAtom;
7122 if ( rSdrPowerPointImport.SeekToRec( rIn, PPT_PST_InteractiveInfoAtom, aTextHd.GetRecEndFilePos(), &aHdInteractiveInfoAtom ) )
7123 {
7124 PptInteractiveInfoAtom aInteractiveInfoAtom;
7125 rIn >> aInteractiveInfoAtom;
7126 for ( SdHyperlinkEntry* pHyperlink = (SdHyperlinkEntry*)rSdrPowerPointImport.aHyperList.First();
7127 pHyperlink; pHyperlink = (SdHyperlinkEntry*)rSdrPowerPointImport.aHyperList.Next() )
7128 {
7129 if ( pHyperlink->nIndex == aInteractiveInfoAtom.nExHyperlinkId )
7130 {
7131 aTextHd.SeekToEndOfRecord( rIn );
7132 rIn >> aTextHd;
7133 if ( aTextHd.nRecType != PPT_PST_TxInteractiveInfoAtom )
7134 {
7135 aTextHd.SeekToBegOfRecord( rIn );
7136 continue;
7137 }
7138 else
7139 {
7140 sal_uInt32 nStartPos, nEndPos;
7141 rIn >> nStartPos
7142 >> nEndPos;
7143 if ( nEndPos )
7144 {
7145 pEntry = new PPTFieldEntry;
7146 pEntry->nPos = (sal_uInt16)nStartPos;
7147 pEntry->nTextRangeEnd = (sal_uInt16)nEndPos;
7148 String aTarget( pHyperlink->aTarget );
7149 if ( pHyperlink->aConvSubString.Len() )
7150 {
7151 aTarget.Append( (sal_Unicode)'#' );
7152 aTarget.Append( pHyperlink->aConvSubString );
7153 }
7154 pEntry->pField1 = new SvxFieldItem( SvxURLField( aTarget, String(), SVXURLFORMAT_REPR ), EE_FEATURE_FIELD );
7155 }
7156 }
7157 break;
7158 }
7159 }
7160 }
7161 }
7162 break;
7163 }
7164 aTextHd.SeekToEndOfRecord( rIn );
7165 if ( pEntry )
7166 {
7167 if ( !pFieldList )
7168 pFieldList = new List;
7169 sal_uInt32 n;
7170 for ( n = 0; n < pFieldList->Count(); n++ )
7171 { // sorting fields ( hi >> lo )
7172 if ( ( (PPTFieldEntry*)pFieldList->GetObject( n ) )->nPos < pEntry->nPos )
7173 break;
7174 }
7175 pFieldList->Insert( pEntry, (sal_uInt32)n );
7176 }
7177 }
7178 if ( pFieldList )
7179 {
7180 PPTFieldEntry* pFE = (PPTFieldEntry*)pFieldList->First();
7181 List& aCharPropList = aStyleTextPropReader.aCharPropList;
7182
7183 sal_Int32 i = nParagraphs - 1;
7184 sal_Int32 n = aCharPropList.Count() - 1;
7185
7186 // at this point we just have a list of textportions(aCharPropList)
7187 // the next while loop tries to resolve the list of fields(pFieldList)
7188 while( pFE && ( n >= 0 ) && ( i >= 0 ) )
7189 {
7190 PPTCharPropSet* pSet = (PPTCharPropSet*)aCharPropList.GetObject( n );
7191 String aString( pSet->maString );
7192 sal_uInt32 nCount = aString.Len();
7193 sal_uInt32 nPos = pSet->mnOriginalTextPos + nCount;
7194 while ( pFE && nCount-- )
7195 {
7196 nPos--;
7197 while ( pFE && ( pFE->nPos > nPos ) )
7198 pFE = (PPTFieldEntry*)pFieldList->Next();
7199 if ( !pFE )
7200 break;
7201
7202 if ( pFE->nPos == nPos )
7203 {
7204 if ( aString.GetChar( (sal_uInt16)nCount ) == 0x2a )
7205 {
7206 sal_uInt32 nBehind = aString.Len() - ( nCount + 1 );
7207 pSet->maString = String();
7208 if ( nBehind )
7209 {
7210 PPTCharPropSet* pNewCPS = new PPTCharPropSet( *pSet );
7211 pNewCPS->maString = String( aString, (sal_uInt16)nCount + 1, (sal_uInt16)nBehind );
7212 aCharPropList.Insert( pNewCPS, n + 1 );
7213 }
7214 if ( pFE->pField2 )
7215 {
7216 PPTCharPropSet* pNewCPS = new PPTCharPropSet( *pSet );
7217 pNewCPS->mpFieldItem = pFE->pField2, pFE->pField2 = NULL;
7218 aCharPropList.Insert( pNewCPS, n + 1 );
7219
7220 pNewCPS = new PPTCharPropSet( *pSet );
7221 pNewCPS->maString = String( String( RTL_CONSTASCII_USTRINGPARAM( " " ) ) );
7222 aCharPropList.Insert( pNewCPS, n + 1 );
7223 }
7224 if ( nCount )
7225 {
7226 PPTCharPropSet* pNewCPS = new PPTCharPropSet( *pSet );
7227 pNewCPS->maString = String( aString, (sal_uInt16)0, (sal_uInt16)nCount );
7228 aCharPropList.Insert( pNewCPS, n++ );
7229 }
7230 if ( pFE->pField1 )
7231 {
7232 pSet->mpFieldItem = pFE->pField1, pFE->pField1 = NULL;
7233 }
7234 else if ( pFE->pString )
7235 pSet->maString = *pFE->pString;
7236 }
7237 else
7238 {
7239 if ( pFE->nTextRangeEnd ) // text range hyperlink
7240 {
7241 sal_uInt32 nHyperLen = pFE->nTextRangeEnd - nPos;
7242 if ( nHyperLen )
7243 {
7244 PPTCharPropSet* pBefCPS = NULL;
7245 if ( nCount )
7246 {
7247 pBefCPS = new PPTCharPropSet( *pSet );
7248 pSet->maString = String( pSet->maString, (sal_uInt16)nCount, (sal_uInt16)( pSet->maString.Len() - nCount ) );
7249 }
7250 sal_uInt32 nIdx = n;
7251 sal_Int32 nHyperLenLeft = nHyperLen;
7252
7253 while ( ( aCharPropList.Count() > nIdx ) && nHyperLenLeft )
7254 {
7255 // the textrange hyperlink can take more than 1 paragraph
7256 // the solution here is to clone the hyperlink...
7257
7258 PPTCharPropSet* pCurrent = (PPTCharPropSet*)aCharPropList.GetObject( nIdx );
7259 sal_Int32 nNextStringLen = pCurrent->maString.Len();
7260
7261 DBG_ASSERT( pFE->pField1, "missing field!" );
7262 if (!pFE->pField1)
7263 break;
7264
7265 const SvxURLField* pField = (const SvxURLField*)pFE->pField1->GetField();
7266
7267 pCurrent->mbIsHyperlink=sal_True;
7268 pCurrent->mnHylinkOrigColor=pCurrent->pCharSet->mnColor;
7269 pCurrent->mbHardHylinkOrigColor= ( ( pCurrent->pCharSet->mnAttrSet >>PPT_CharAttr_FontColor ) & 1)>0;
7270
7271 if ( pCurrent->mpFieldItem )
7272 {
7273 pCurrent->SetColor( PPT_COLSCHEME_A_UND_HYPERLINK );
7274 if ( pCurrent->mpFieldItem->GetField()->ISA( SvxURLField ) )
7275 break;
7276 nHyperLenLeft--;
7277 }
7278 else if ( nNextStringLen )
7279 {
7280 if ( nNextStringLen <= nHyperLenLeft )
7281 {
7282 pCurrent->mpFieldItem = new SvxFieldItem( SvxURLField( pField->GetURL(), pCurrent->maString, SVXURLFORMAT_REPR ), EE_FEATURE_FIELD );
7283 nHyperLenLeft -= nNextStringLen;
7284
7285 if ( nHyperLenLeft )
7286 {
7287 // if the next portion is in a higher paragraph,
7288 // the textrange is to decrease (because of the LineBreak character)
7289 if ( aCharPropList.Count() > ( nIdx + 1 ) )
7290 {
7291 PPTCharPropSet* pNext = (PPTCharPropSet*)aCharPropList.GetObject( nIdx + 1 );
7292 if ( pNext->mnParagraph > pCurrent->mnParagraph )
7293 nHyperLenLeft--;
7294 }
7295 }
7296 }
7297 else
7298 {
7299 PPTCharPropSet* pNewCPS = new PPTCharPropSet( *pCurrent );
7300 pNewCPS->maString = String( pCurrent->maString, (sal_uInt16)nHyperLenLeft, (sal_uInt16)( nNextStringLen - nHyperLenLeft ) );
7301 aCharPropList.Insert( pNewCPS, nIdx + 1 );
7302 String aRepresentation( pCurrent->maString, 0, (sal_uInt16)nHyperLenLeft );
7303 pCurrent->mpFieldItem = new SvxFieldItem( SvxURLField( pField->GetURL(), aRepresentation, SVXURLFORMAT_REPR ), EE_FEATURE_FIELD );
7304 nHyperLenLeft = 0;
7305 }
7306 pCurrent->maString = String();
7307 pCurrent->SetColor( PPT_COLSCHEME_A_UND_HYPERLINK );
7308 }
7309 nIdx++;
7310 }
7311 delete pFE->pField1, pFE->pField1 = NULL;
7312
7313 if ( pBefCPS )
7314 {
7315 pBefCPS->maString = String( aString, (sal_uInt16)0, (sal_uInt16)nCount );
7316 aCharPropList.Insert( pBefCPS, n++ );
7317
7318 }
7319 }
7320 }
7321 }
7322 break;
7323 }
7324 }
7325 n--;
7326 }
7327 for ( void* pPtr = pFieldList->First(); pPtr; pPtr = pFieldList->Next() )
7328 delete (PPTFieldEntry*)pPtr;
7329 delete pFieldList;
7330 }
7331 mpImplTextObj->mpParagraphList = new PPTParagraphObj*[ nParagraphs ];
7332 aStyleTextPropReader.aCharPropList.First();
7333 sal_uInt32 nCount = 0;
7334 for ( void* pPtr = aStyleTextPropReader.aParaPropList.First();
7335 pPtr;
7336 pPtr = aStyleTextPropReader.aParaPropList.Next() )
7337 {
7338 PPTParagraphObj* pPara = new PPTParagraphObj( aStyleTextPropReader, *rSdrPowerPointImport.pPPTStyleSheet, nInstance, aTextRulerInterpreter );
7339 mpImplTextObj->mpParagraphList[ nCount++ ] = pPara;
7340
7341 sal_uInt32 nParaAdjust, nFlags = 0;
7342 pPara->GetAttrib( PPT_ParaAttr_Adjust, nParaAdjust, GetInstance() );
7343
7344 switch ( nParaAdjust )
7345 {
7346 case 0 : nFlags = PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_LEFT; break;
7347 case 1 : nFlags = PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_CENTER; break;
7348 case 2 : nFlags = PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_RIGHT; break;
7349 case 3 : nFlags = PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_BLOCK; break;
7350 }
7351 mpImplTextObj->mnTextFlags |= nFlags;
7352 }
7353 }
7354 }
7355 }
7356 }
7357 }
7358 }
7359 }
7360
PPTTextObj(PPTTextObj & rTextObj)7361 PPTTextObj::PPTTextObj( PPTTextObj& rTextObj )
7362 {
7363 mpImplTextObj = rTextObj.mpImplTextObj;
7364 mpImplTextObj->mnRefCount++;
7365 }
7366
~PPTTextObj()7367 PPTTextObj::~PPTTextObj()
7368 {
7369 ImplClear();
7370 }
7371
First()7372 PPTParagraphObj* PPTTextObj::First()
7373 {
7374 mpImplTextObj->mnCurrentObject = 0;
7375 if ( !mpImplTextObj->mnParagraphCount )
7376 return NULL;
7377 return mpImplTextObj->mpParagraphList[ 0 ];
7378 }
7379
Next()7380 PPTParagraphObj* PPTTextObj::Next()
7381 {
7382 sal_uInt32 i = mpImplTextObj->mnCurrentObject + 1;
7383 if ( i >= mpImplTextObj->mnParagraphCount )
7384 return NULL;
7385 mpImplTextObj->mnCurrentObject++;
7386 return mpImplTextObj->mpParagraphList[ i ];
7387 }
7388
GetBackground() const7389 const SfxItemSet* PPTTextObj::GetBackground() const
7390 {
7391 if ( mpImplTextObj->mrPersistEntry.pBObj )
7392 return &mpImplTextObj->mrPersistEntry.pBObj->GetMergedItemSet();
7393 else
7394 return NULL;
7395 }
7396
ImplClear()7397 void PPTTextObj::ImplClear()
7398 {
7399 if ( ! ( --mpImplTextObj->mnRefCount ) )
7400 {
7401 for ( PPTParagraphObj* pPtr = First(); pPtr; pPtr = Next() )
7402 delete pPtr;
7403 delete[] mpImplTextObj->mpParagraphList;
7404 delete mpImplTextObj->mpPlaceHolderAtom;
7405 delete mpImplTextObj;
7406 }
7407 }
7408
operator =(PPTTextObj & rTextObj)7409 PPTTextObj& PPTTextObj::operator=( PPTTextObj& rTextObj )
7410 {
7411 if ( this != &rTextObj )
7412 {
7413 ImplClear();
7414 mpImplTextObj = rTextObj.mpImplTextObj;
7415 mpImplTextObj->mnRefCount++;
7416 }
7417 return *this;
7418 }
7419
IsLine(const SdrObject * pObj)7420 sal_Bool IsLine( const SdrObject* pObj )
7421 {
7422 return pObj->ISA( SdrPathObj ) && ((SdrPathObj*)pObj)->IsLine() && (((SdrPathObj*)pObj)->GetPointCount() == 2 );
7423 }
7424
GetCellPosition(const SdrObject * pObj,const std::set<sal_Int32> & rRows,const std::set<sal_Int32> & rColumns,sal_Int32 & nTableIndex,sal_Int32 & nRow,sal_Int32 & nRowCount,sal_Int32 & nColumn,sal_Int32 & nColumnCount)7425 sal_Bool GetCellPosition( const SdrObject* pObj, const std::set< sal_Int32 >& rRows, const std::set< sal_Int32 >& rColumns,
7426 sal_Int32& nTableIndex, sal_Int32& nRow, sal_Int32& nRowCount, sal_Int32& nColumn, sal_Int32& nColumnCount )
7427 {
7428 Rectangle aSnapRect( pObj->GetSnapRect() );
7429 sal_Bool bCellObject = ( aSnapRect.GetWidth() > 1 ) && ( aSnapRect.GetHeight() > 1 );
7430 if ( bCellObject )
7431 {
7432 std::set< sal_Int32 >::const_iterator aRowIter( rRows.find( aSnapRect.Top() ) );
7433 std::set< sal_Int32 >::const_iterator aColumnIter( rColumns.find( aSnapRect.Left() ) );
7434 if ( ( aRowIter == rRows.end() ) || ( aColumnIter == rColumns.end() ) )
7435 bCellObject = sal_False;
7436 else
7437 {
7438 nRowCount = 1;
7439 nRow = std::distance( rRows.begin(), aRowIter );
7440 while( ++aRowIter != rRows.end() )
7441 {
7442 if ( *aRowIter >= aSnapRect.Bottom() )
7443 break;
7444 nRowCount++;
7445 }
7446 nColumnCount = 1;
7447 nColumn = std::distance( rColumns.begin(), aColumnIter );
7448 while( ++aColumnIter != rColumns.end() )
7449 {
7450 if ( *aColumnIter >= aSnapRect.Right() )
7451 break;
7452 nColumnCount++;
7453 }
7454 nTableIndex = nRow * rColumns.size() + nColumn;
7455 }
7456 }
7457 return bCellObject;
7458 }
7459
7460 #define LinePositionLeft 0x01000000
7461 #define LinePositionTop 0x02000000
7462 #define LinePositionRight 0x04000000
7463 #define LinePositionBottom 0x08000000
7464 #define LinePositionTLBR 0x10000000
7465 #define LinePositionBLTR 0x20000000
7466
7467
GetRowPositions(const Rectangle & rSnapRect,const std::set<sal_Int32> & rRows,const std::set<sal_Int32> & rColumns,std::vector<sal_Int32> & rPositions,sal_Int32 nColumn,sal_Int32 nFlags)7468 void GetRowPositions( const Rectangle& rSnapRect, const std::set< sal_Int32 >& rRows,
7469 const std::set< sal_Int32 >& rColumns, std::vector< sal_Int32 >& rPositions, sal_Int32 nColumn, sal_Int32 nFlags )
7470 {
7471 std::set< sal_Int32 >::const_iterator aRow( rRows.find( rSnapRect.Top() ) );
7472 if ( aRow != rRows.end() )
7473 {
7474 sal_Int32 nRow = std::distance( rRows.begin(), aRow );
7475 while( ( aRow != rRows.end() ) && ((*aRow) < rSnapRect.Bottom() ) )
7476 {
7477 if ( nFlags & LinePositionLeft )
7478 rPositions.push_back( ( ( nRow * rColumns.size() ) + nColumn ) | LinePositionLeft );
7479 if ( nFlags & LinePositionRight )
7480 rPositions.push_back( ( ( nRow * rColumns.size() ) + ( nColumn - 1 ) ) | LinePositionRight );
7481
7482 nRow++;
7483 aRow++;
7484 }
7485 }
7486 }
7487
7488
GetColumnPositions(const Rectangle & rSnapRect,const std::set<sal_Int32> &,const std::set<sal_Int32> & rColumns,std::vector<sal_Int32> & rPositions,sal_Int32 nRow,sal_Int32 nFlags)7489 void GetColumnPositions( const Rectangle& rSnapRect, const std::set< sal_Int32 >& /* rRows */,
7490 const std::set< sal_Int32 >& rColumns, std::vector< sal_Int32 >& rPositions, sal_Int32 nRow, sal_Int32 nFlags )
7491 {
7492 std::set< sal_Int32 >::const_iterator aColumn( rColumns.find( rSnapRect.Left() ) );
7493 if ( aColumn != rColumns.end() )
7494 {
7495 sal_Int32 nColumn = std::distance( rColumns.begin(), aColumn );
7496 while( ( aColumn != rColumns.end() ) && ((*aColumn) < rSnapRect.Right() ) )
7497 {
7498 if ( nFlags & LinePositionTop )
7499 rPositions.push_back( ( ( nRow * rColumns.size() ) + nColumn ) | LinePositionTop );
7500 if ( nFlags & LinePositionBottom )
7501 rPositions.push_back( ( ( ( nRow - 1 ) * rColumns.size() ) + nColumn ) | LinePositionBottom );
7502
7503 nColumn++;
7504 aColumn++;
7505 }
7506 }
7507 }
7508
GetLinePositions(const SdrObject * pObj,const std::set<sal_Int32> & rRows,const std::set<sal_Int32> & rColumns,std::vector<sal_Int32> & rPositions,const Rectangle & rGroupSnap)7509 void GetLinePositions( const SdrObject* pObj, const std::set< sal_Int32 >& rRows, const std::set< sal_Int32 >& rColumns,
7510 std::vector< sal_Int32 >& rPositions, const Rectangle& rGroupSnap )
7511 {
7512 Rectangle aSnapRect( pObj->GetSnapRect() );
7513 if ( aSnapRect.Left() == aSnapRect.Right() )
7514 {
7515 std::set< sal_Int32 >::const_iterator aColumn( rColumns.find( aSnapRect.Left() ) );
7516 if ( ( aColumn != rColumns.end() ) || ( aSnapRect.Left() == rGroupSnap.Right() ) )
7517 {
7518 sal_Int32 nColumn, nFlags;
7519 if ( aColumn != rColumns.end() )
7520 {
7521 nColumn = std::distance( rColumns.begin(), aColumn );
7522 nFlags = LinePositionLeft;
7523 if ( aColumn != rColumns.begin() )
7524 nFlags |= LinePositionRight;
7525 }
7526 else
7527 {
7528 nColumn = rColumns.size();
7529 nFlags = LinePositionRight;
7530 }
7531 GetRowPositions( aSnapRect, rRows, rColumns, rPositions, nColumn, nFlags );
7532 }
7533 }
7534 else if ( aSnapRect.Top() == aSnapRect.Bottom() )
7535 {
7536 std::set< sal_Int32 >::const_iterator aRow( rRows.find( aSnapRect.Top() ) );
7537 if ( ( aRow != rRows.end() ) || ( aSnapRect.Top() == rGroupSnap.Bottom() ) )
7538 {
7539 sal_Int32 nRow, nFlags;
7540 if ( aRow != rRows.end() )
7541 {
7542 nRow = std::distance( rRows.begin(), aRow );
7543 nFlags = LinePositionTop;
7544 if ( aRow != rRows.begin() )
7545 nFlags |= LinePositionBottom;
7546 }
7547 else
7548 {
7549 nRow = rRows.size();
7550 nFlags = LinePositionBottom;
7551 }
7552 GetColumnPositions( aSnapRect, rRows, rColumns, rPositions, nRow, nFlags );
7553 }
7554 }
7555 else
7556 {
7557 sal_uInt32 nPosition = 0;
7558 Point aPt1( ((SdrPathObj*)pObj)->GetPoint( 0 ) );
7559 Point aPt2( ((SdrPathObj*)pObj)->GetPoint( 1 ) );
7560 if ( aPt1.X() < aPt2.X() )
7561 nPosition |= aPt1.Y() < aPt2.Y() ? LinePositionTLBR : LinePositionBLTR;
7562 else
7563 nPosition |= aPt1.Y() < aPt2.Y() ? LinePositionBLTR : LinePositionTLBR;
7564
7565 std::set< sal_Int32 >::const_iterator aRow( rRows.find( aPt1.Y() < aPt2.Y() ? aPt1.Y() : aPt2.Y() ) );
7566 std::set< sal_Int32 >::const_iterator aColumn( rColumns.find( aPt1.X() < aPt2.X() ? aPt1.X() : aPt2.X() ) );
7567 if ( ( aRow != rRows.end() ) && ( aColumn != rColumns.end() ) )
7568 {
7569 nPosition |= ( std::distance( rRows.begin(), aRow ) * rColumns.size() ) + std::distance( rColumns.begin(), aColumn );
7570 rPositions.push_back( nPosition );
7571 }
7572 }
7573 }
7574
CreateTableRows(Reference<XTableRows> xTableRows,const std::set<sal_Int32> & rRows,sal_Int32 nTableBottom)7575 void CreateTableRows( Reference< XTableRows > xTableRows, const std::set< sal_Int32 >& rRows, sal_Int32 nTableBottom )
7576 {
7577 if ( rRows.size() > 1 )
7578 xTableRows->insertByIndex( 0, rRows.size() - 1 );
7579
7580 std::set< sal_Int32 >::const_iterator aIter( rRows.begin() );
7581 sal_Int32 nLastPosition( *aIter );
7582 Reference< XIndexAccess > xIndexAccess( xTableRows, UNO_QUERY_THROW );
7583 for ( sal_Int32 n = 0; n < xIndexAccess->getCount(); n++ )
7584 {
7585 sal_Int32 nHeight;
7586 if ( ++aIter != rRows.end() )
7587 {
7588 nHeight = *aIter - nLastPosition;
7589 nLastPosition = *aIter;
7590 }
7591 else
7592 nHeight = nTableBottom - nLastPosition;
7593
7594 static const rtl::OUString sWidth( RTL_CONSTASCII_USTRINGPARAM ( "Height" ) );
7595 Reference< XPropertySet > xPropSet( xIndexAccess->getByIndex( n ), UNO_QUERY_THROW );
7596 xPropSet->setPropertyValue( sWidth, Any( nHeight ) );
7597 }
7598 }
7599
CreateTableColumns(Reference<XTableColumns> xTableColumns,const std::set<sal_Int32> & rColumns,sal_Int32 nTableRight)7600 void CreateTableColumns( Reference< XTableColumns > xTableColumns, const std::set< sal_Int32 >& rColumns, sal_Int32 nTableRight )
7601 {
7602 if ( rColumns.size() > 1 )
7603 xTableColumns->insertByIndex( 0, rColumns.size() - 1 );
7604
7605 std::set< sal_Int32 >::const_iterator aIter( rColumns.begin() );
7606 sal_Int32 nLastPosition( *aIter );
7607 Reference< XIndexAccess > xIndexAccess( xTableColumns, UNO_QUERY_THROW );
7608 for ( sal_Int32 n = 0; n < xIndexAccess->getCount(); n++ )
7609 {
7610 sal_Int32 nWidth;
7611 if ( ++aIter != rColumns.end() )
7612 {
7613 nWidth = *aIter - nLastPosition;
7614 nLastPosition = *aIter;
7615 }
7616 else
7617 nWidth = nTableRight - nLastPosition;
7618
7619 static const rtl::OUString sWidth( RTL_CONSTASCII_USTRINGPARAM ( "Width" ) );
7620 Reference< XPropertySet > xPropSet( xIndexAccess->getByIndex( n ), UNO_QUERY_THROW );
7621 xPropSet->setPropertyValue( sWidth, Any( nWidth ) );
7622 }
7623 }
7624
MergeCells(const Reference<XTable> & xTable,sal_Int32 nCol,sal_Int32 nRow,sal_Int32 nColSpan,sal_Int32 nRowSpan)7625 void MergeCells( const Reference< XTable >& xTable, sal_Int32 nCol, sal_Int32 nRow, sal_Int32 nColSpan, sal_Int32 nRowSpan )
7626 {
7627 DBG_ASSERT( (nColSpan > 1) || (nRowSpan > 1), "nonsense parameter!!" );
7628 DBG_ASSERT( (nCol >= 0) && (nCol < xTable->getColumnCount()) && (nRow >= 0) && (nRow < xTable->getRowCount()), "die celle gibts nicht!!" );
7629 DBG_ASSERT( (nColSpan >= 1) && ((nCol + nColSpan - 1) < xTable->getColumnCount()), "nColSpan murks!" );
7630 DBG_ASSERT( (nRowSpan >= 1) && ((nRow + nRowSpan - 1) < xTable->getRowCount()), "nRowSpan murks!" );
7631
7632 if( xTable.is() ) try
7633 {
7634 Reference< XMergeableCellRange > xRange( xTable->createCursorByRange( xTable->getCellRangeByPosition( nCol, nRow,nCol + nColSpan - 1, nRow + nRowSpan - 1 ) ), UNO_QUERY_THROW );
7635 if( xRange->isMergeable() )
7636 xRange->merge();
7637 }
7638 catch( Exception& )
7639 {
7640 DBG_ASSERT( false, "exception caught!" );
7641 }
7642 }
7643
ApplyCellAttributes(const SdrObject * pObj,Reference<XCell> & xCell)7644 void ApplyCellAttributes( const SdrObject* pObj, Reference< XCell >& xCell )
7645 {
7646 try
7647 {
7648 Reference< XPropertySet > xPropSet( xCell, UNO_QUERY_THROW );
7649
7650 const sal_Int32 nLeftDist(((const SdrTextLeftDistItem&)pObj->GetMergedItem(SDRATTR_TEXT_LEFTDIST)).GetValue());
7651 const sal_Int32 nRightDist(((const SdrTextRightDistItem&)pObj->GetMergedItem(SDRATTR_TEXT_RIGHTDIST)).GetValue());
7652 const sal_Int32 nUpperDist(((const SdrTextUpperDistItem&)pObj->GetMergedItem(SDRATTR_TEXT_UPPERDIST)).GetValue());
7653 const sal_Int32 nLowerDist(((const SdrTextLowerDistItem&)pObj->GetMergedItem(SDRATTR_TEXT_LOWERDIST)).GetValue());
7654 static const rtl::OUString sTopBorder( RTL_CONSTASCII_USTRINGPARAM( "TextUpperDistance" ) );
7655 static const rtl::OUString sBottomBorder( RTL_CONSTASCII_USTRINGPARAM( "TextLowerDistance" ) );
7656 static const rtl::OUString sLeftBorder( RTL_CONSTASCII_USTRINGPARAM( "TextLeftDistance" ) );
7657 static const rtl::OUString sRightBorder( RTL_CONSTASCII_USTRINGPARAM( "TextRightDistance" ) );
7658 xPropSet->setPropertyValue( sTopBorder, Any( nUpperDist ) );
7659 xPropSet->setPropertyValue( sRightBorder, Any( nRightDist ) );
7660 xPropSet->setPropertyValue( sLeftBorder, Any( nLeftDist ) );
7661 xPropSet->setPropertyValue( sBottomBorder, Any( nLowerDist ) );
7662
7663 static const rtl::OUString sTextVerticalAdjust( RTL_CONSTASCII_USTRINGPARAM( "TextVerticalAdjust" ) );
7664 const SdrTextVertAdjust eTextVertAdjust(((const SdrTextVertAdjustItem&)pObj->GetMergedItem(SDRATTR_TEXT_VERTADJUST)).GetValue());
7665 drawing::TextVerticalAdjust eVA( drawing::TextVerticalAdjust_TOP );
7666 if ( eTextVertAdjust == SDRTEXTVERTADJUST_CENTER )
7667 eVA = drawing::TextVerticalAdjust_CENTER;
7668 else if ( eTextVertAdjust == SDRTEXTVERTADJUST_BOTTOM )
7669 eVA = drawing::TextVerticalAdjust_BOTTOM;
7670 xPropSet->setPropertyValue( sTextVerticalAdjust, Any( eVA ) );
7671
7672 //set textHorizontalAdjust and TextWritingMode attr
7673 const sal_Int32 eHA(((const SdrTextLeftDistItem&)pObj->GetMergedItem(SDRATTR_TEXT_HORZADJUST)).GetValue());
7674 const SvxFrameDirection eDirection = (const SvxFrameDirection)((( const SvxFrameDirectionItem&)pObj->GetMergedItem(EE_PARA_WRITINGDIR)).GetValue());
7675 static const rtl::OUString sHorizontalAdjust( RTL_CONSTASCII_USTRINGPARAM( "TextHorizontalAdjust" ) );
7676 static const rtl::OUString sWritingMode( RTL_CONSTASCII_USTRINGPARAM("TextWritingMode") );
7677 xPropSet->setPropertyValue( sHorizontalAdjust , Any( eHA ) );
7678 if ( eDirection == FRMDIR_VERT_TOP_RIGHT )
7679 {//vertical writing
7680 xPropSet->setPropertyValue( sWritingMode , Any( ::com::sun::star::text::WritingMode_TB_RL ) );
7681 }
7682 SfxItemSet aSet( pObj->GetMergedItemSet() );
7683 XFillStyle eFillStyle(((XFillStyleItem&)pObj->GetMergedItem( XATTR_FILLSTYLE )).GetValue());
7684 ::com::sun::star::drawing::FillStyle eFS( com::sun::star::drawing::FillStyle_NONE );
7685 switch( eFillStyle )
7686 {
7687 case XFILL_SOLID :
7688 {
7689 static const rtl::OUString sFillColor( String( RTL_CONSTASCII_USTRINGPARAM( "FillColor" ) ) );
7690 eFS = com::sun::star::drawing::FillStyle_SOLID;
7691 Color aFillColor( ((XFillColorItem&)pObj->GetMergedItem( XATTR_FILLCOLOR )).GetColorValue() );
7692 sal_Int32 nFillColor( aFillColor.GetColor() );
7693 xPropSet->setPropertyValue( sFillColor, Any( nFillColor ) );
7694 }
7695 break;
7696 case XFILL_GRADIENT :
7697 {
7698 eFS = com::sun::star::drawing::FillStyle_GRADIENT;
7699 XGradient aXGradient(((const XFillGradientItem&)pObj->GetMergedItem(XATTR_FILLGRADIENT)).GetGradientValue());
7700
7701 com::sun::star::awt::Gradient aGradient;
7702 aGradient.Style = (awt::GradientStyle) aXGradient.GetGradientStyle();
7703 aGradient.StartColor = (sal_Int32)aXGradient.GetStartColor().GetColor();
7704 aGradient.EndColor = (sal_Int32)aXGradient.GetEndColor().GetColor();
7705 aGradient.Angle = (short)aXGradient.GetAngle();
7706 aGradient.Border = aXGradient.GetBorder();
7707 aGradient.XOffset = aXGradient.GetXOffset();
7708 aGradient.YOffset = aXGradient.GetYOffset();
7709 aGradient.StartIntensity = aXGradient.GetStartIntens();
7710 aGradient.EndIntensity = aXGradient.GetEndIntens();
7711 aGradient.StepCount = aXGradient.GetSteps();
7712
7713 static const rtl::OUString sFillGradient( String( RTL_CONSTASCII_USTRINGPARAM( "FillGradient" ) ) );
7714 xPropSet->setPropertyValue( sFillGradient, Any( aGradient ) );
7715 }
7716 break;
7717 case XFILL_HATCH :
7718 eFS = com::sun::star::drawing::FillStyle_HATCH;
7719 break;
7720 case XFILL_BITMAP :
7721 {
7722 eFS = com::sun::star::drawing::FillStyle_BITMAP;
7723
7724 const XFillBitmapItem aXFillBitmapItem((const XFillBitmapItem&)pObj->GetMergedItem( XATTR_FILLBITMAP ));
7725 rtl::OUString aURL( RTL_CONSTASCII_USTRINGPARAM(UNO_NAME_GRAPHOBJ_URLPREFIX));
7726 aURL += rtl::OUString::createFromAscii(aXFillBitmapItem.GetGraphicObject().GetUniqueID().GetBuffer());
7727
7728 static const rtl::OUString sFillBitmapURL( String( RTL_CONSTASCII_USTRINGPARAM( "FillBitmapURL" ) ) );
7729 xPropSet->setPropertyValue( sFillBitmapURL, Any( aURL ) );
7730
7731 static const rtl::OUString sFillBitmapMode( String( RTL_CONSTASCII_USTRINGPARAM( "FillBitmapMode" ) ) );
7732 const XFillBmpStretchItem aStretchItem(( const XFillBmpStretchItem&)pObj->GetMergedItem( XATTR_FILLBMP_STRETCH ));
7733 const XFillBmpTileItem aTileItem(( const XFillBmpTileItem&)pObj->GetMergedItem( XATTR_FILLBMP_TILE ));
7734 if( aTileItem.GetValue() )
7735 xPropSet->setPropertyValue( sFillBitmapMode, Any( com::sun::star::drawing::BitmapMode_REPEAT ) );
7736 else if( aStretchItem.GetValue() )
7737 xPropSet->setPropertyValue( sFillBitmapMode, Any( com::sun::star::drawing::BitmapMode_STRETCH ) );
7738 else
7739 xPropSet->setPropertyValue( sFillBitmapMode, Any( com::sun::star::drawing::BitmapMode_NO_REPEAT ) );
7740 }
7741 break;
7742 case XFILL_NONE :
7743 eFS = com::sun::star::drawing::FillStyle_NONE;
7744 break;
7745
7746 }
7747 static const rtl::OUString sFillStyle( String( RTL_CONSTASCII_USTRINGPARAM( "FillStyle" ) ) );
7748 xPropSet->setPropertyValue( sFillStyle, Any( eFS ) );
7749 if ( eFillStyle != XFILL_NONE )
7750 {
7751 sal_Int16 nFillTransparence( ( (const XFillTransparenceItem&)pObj->GetMergedItem( XATTR_FILLTRANSPARENCE ) ).GetValue() );
7752 static const rtl::OUString sFillTransparence( String( RTL_CONSTASCII_USTRINGPARAM( "FillTransparence" ) ) );
7753 xPropSet->setPropertyValue( sFillTransparence, Any( nFillTransparence ) );
7754 }
7755 }
7756 catch( Exception& )
7757 {
7758 }
7759 }
7760
ApplyCellLineAttributes(const SdrObject * pLine,Reference<XTable> & xTable,const std::vector<sal_Int32> vPositions,sal_Int32 nColumns)7761 void ApplyCellLineAttributes( const SdrObject* pLine, Reference< XTable >& xTable, const std::vector< sal_Int32 > vPositions, sal_Int32 nColumns )
7762 {
7763 try
7764 {
7765 SfxItemSet aSet( pLine->GetMergedItemSet() );
7766 XLineStyle eLineStyle(((XLineStyleItem&)pLine->GetMergedItem( XATTR_LINESTYLE )).GetValue());
7767 com::sun::star::table::BorderLine aBorderLine;
7768 switch( eLineStyle )
7769 {
7770 case XLINE_DASH :
7771 case XLINE_SOLID :
7772 {
7773 Color aLineColor( ((XLineColorItem&)pLine->GetMergedItem( XATTR_LINECOLOR )).GetColorValue() );
7774 aBorderLine.Color = aLineColor.GetColor();
7775 // Avoid width = 0, the min value should be 1.
7776 aBorderLine.OuterLineWidth = std::max( static_cast< sal_Int16 >( 1 ), static_cast< sal_Int16 >( ((const XLineWidthItem&)(pLine->GetMergedItem(XATTR_LINEWIDTH))).GetValue() / 4) );
7777 aBorderLine.InnerLineWidth = std::max( static_cast< sal_Int16 >( 1 ), static_cast< sal_Int16 >( ((const XLineWidthItem&)(pLine->GetMergedItem(XATTR_LINEWIDTH))).GetValue() / 4) );
7778 aBorderLine.LineDistance = 0;
7779 }
7780 break;
7781 case XLINE_NONE :
7782 {
7783 aBorderLine.OuterLineWidth = 0;
7784 aBorderLine.InnerLineWidth = 0;
7785 aBorderLine.LineDistance = 0;
7786 }
7787 break;
7788 }
7789 Reference< XCellRange > xCellRange( xTable, UNO_QUERY_THROW );
7790 std::vector< sal_Int32 >::const_iterator aIter( vPositions.begin() );
7791 while( aIter != vPositions.end() )
7792 {
7793 static const rtl::OUString sTopBorder( String( RTL_CONSTASCII_USTRINGPARAM( "TopBorder" ) ) );
7794 static const rtl::OUString sBottomBorder( String( RTL_CONSTASCII_USTRINGPARAM( "BottomBorder" ) ) );
7795 static const rtl::OUString sLeftBorder( String( RTL_CONSTASCII_USTRINGPARAM( "LeftBorder" ) ) );
7796 static const rtl::OUString sRightBorder( String( RTL_CONSTASCII_USTRINGPARAM( "RightBorder" ) ) );
7797 static const rtl::OUString sDiagonalTLBR( RTL_CONSTASCII_USTRINGPARAM ( "DiagonalTLBR" ) );
7798 static const rtl::OUString sDiagonalBLTR( RTL_CONSTASCII_USTRINGPARAM ( "DiagonalBLTR" ) );
7799
7800 sal_Int32 nPosition = *aIter & 0xffffff;
7801 sal_Int32 nFlags = *aIter &~0xffffff;
7802 sal_Int32 nRow = nPosition / nColumns;
7803 sal_Int32 nColumn = nPosition - ( nRow * nColumns );
7804 Reference< XCell > xCell( xCellRange->getCellByPosition( nColumn, nRow ) );
7805 Reference< XPropertySet > xPropSet( xCell, UNO_QUERY_THROW );
7806
7807 if ( nFlags & LinePositionLeft )
7808 xPropSet->setPropertyValue( sLeftBorder, Any( aBorderLine ) );
7809 if ( nFlags & LinePositionTop )
7810 xPropSet->setPropertyValue( sTopBorder, Any( aBorderLine ) );
7811 if ( nFlags & LinePositionRight )
7812 xPropSet->setPropertyValue( sRightBorder, Any( aBorderLine ) );
7813 if ( nFlags & LinePositionBottom )
7814 xPropSet->setPropertyValue( sBottomBorder, Any( aBorderLine ) );
7815 if ( nFlags & LinePositionTLBR )
7816 xPropSet->setPropertyValue( sDiagonalTLBR, Any( sal_True ) );
7817 if ( nFlags & LinePositionBLTR )
7818 xPropSet->setPropertyValue( sDiagonalBLTR, Any( sal_True ) );
7819 aIter++;
7820 }
7821 }
7822 catch( Exception& )
7823 {
7824 }
7825 }
7826
CreateTable(SdrObject * pGroup,sal_uInt32 * pTableArry,SvxMSDffSolverContainer * pSolverContainer)7827 SdrObject* SdrPowerPointImport::CreateTable( SdrObject* pGroup, sal_uInt32* pTableArry, SvxMSDffSolverContainer* pSolverContainer )
7828 {
7829 SdrObject* pRet = pGroup;
7830 sal_uInt32 nRows = pTableArry[ 1 ];
7831 if ( nRows && pGroup->ISA( SdrObjGroup ) )
7832 {
7833 SdrObjList* pSubList(((SdrObjGroup*)pGroup)->GetSubList());
7834 if ( pSubList )
7835 {
7836 std::set< sal_Int32 > aRows;
7837 std::set< sal_Int32 > aColumns;
7838
7839 SdrObjListIter aGroupIter( *pSubList, IM_DEEPNOGROUPS, sal_False );
7840 while( aGroupIter.IsMore() )
7841 {
7842 const SdrObject* pObj( aGroupIter.Next() );
7843 if ( !IsLine( pObj ) )
7844 {
7845 Rectangle aSnapRect( pObj->GetSnapRect() );
7846 aRows.insert( aSnapRect.Top() );
7847 aColumns.insert( aSnapRect.Left() );
7848 }
7849 }
7850 ::sdr::table::SdrTableObj* pTable = new ::sdr::table::SdrTableObj( pSdrModel );
7851 pTable->uno_lock();
7852 Reference< XTable > xTable( pTable->getTable() );
7853 try
7854 {
7855 Reference< XColumnRowRange > xColumnRowRange( xTable, UNO_QUERY_THROW );
7856
7857 CreateTableRows( xColumnRowRange->getRows(), aRows, pGroup->GetSnapRect().Bottom() );
7858 CreateTableColumns( xColumnRowRange->getColumns(), aColumns, pGroup->GetSnapRect().Right() );
7859
7860 sal_Int32 nCellCount = aRows.size() * aColumns.size();
7861 sal_Int32 *pMergedCellIndexTable = new sal_Int32[ nCellCount ];
7862 for ( sal_Int32 i = 0; i < nCellCount; i++ )
7863 pMergedCellIndexTable[ i ] = i;
7864
7865 aGroupIter.Reset();
7866 while( aGroupIter.IsMore() )
7867 {
7868 SdrObject* pObj( aGroupIter.Next() );
7869 if ( !IsLine( pObj ) )
7870 {
7871 Rectangle aSnapRect( pObj->GetSnapRect() );
7872 sal_Int32 nTableIndex = 0;
7873 sal_Int32 nRow = 0;
7874 sal_Int32 nRowCount = 0;
7875 sal_Int32 nColumn = 0;
7876 sal_Int32 nColumnCount = 0;
7877 if ( GetCellPosition( pObj, aRows, aColumns, nTableIndex, nRow, nRowCount, nColumn, nColumnCount ) )
7878 {
7879 Reference< XCellRange > xCellRange( xTable, UNO_QUERY_THROW );
7880 Reference< XCell > xCell( xCellRange->getCellByPosition( nColumn, nRow ) );
7881
7882 ApplyCellAttributes( pObj, xCell );
7883
7884 if ( ( nRowCount > 1 ) || ( nColumnCount > 1 ) ) // cell merging
7885 {
7886 MergeCells( xTable, nColumn, nRow, nColumnCount, nRowCount );
7887 for ( sal_Int32 nRowIter = 0; nRowIter < nRowCount; nRowIter++ )
7888 {
7889 for ( sal_Int32 nColumnIter = 0; nColumnIter < nColumnCount; nColumnIter++ )
7890 { // now set the correct index for the merged cell
7891 pMergedCellIndexTable[ ( ( nRow + nRowIter ) * aColumns.size() ) + nColumn + nColumnIter ] = nTableIndex;
7892 }
7893 }
7894 }
7895
7896 // applying text
7897 OutlinerParaObject* pParaObject = pObj->GetOutlinerParaObject();
7898 if ( pParaObject )
7899 {
7900 SdrText* pSdrText = pTable->getText( nTableIndex );
7901 if ( pSdrText )
7902 pSdrText->SetOutlinerParaObject(new OutlinerParaObject(*pParaObject) );
7903 }
7904 }
7905 }
7906 }
7907 aGroupIter.Reset();
7908 while( aGroupIter.IsMore() )
7909 {
7910 SdrObject* pObj( aGroupIter.Next() );
7911 if ( IsLine( pObj ) )
7912 {
7913 std::vector< sal_Int32 > vPositions; // containing cell indexes + cell position
7914 GetLinePositions( pObj, aRows, aColumns, vPositions, pGroup->GetSnapRect() );
7915
7916 // correcting merged cell position
7917 std::vector< sal_Int32 >::iterator aIter( vPositions.begin() );
7918 while( aIter != vPositions.end() )
7919 {
7920 sal_Int32 nOldPosition = *aIter & 0xffff;
7921 sal_Int32 nOldFlags = *aIter & 0xffff0000;
7922 sal_Int32 nNewPosition = pMergedCellIndexTable[ nOldPosition ] | nOldFlags;
7923 *aIter++ = nNewPosition;
7924 }
7925 ApplyCellLineAttributes( pObj, xTable, vPositions, aColumns.size() );
7926 }
7927 }
7928 delete[] pMergedCellIndexTable;
7929
7930 // we are replacing the whole group object by a single table object, so
7931 // possibly connections to the group object have to be removed.
7932 if ( pSolverContainer )
7933 {
7934 for ( SvxMSDffConnectorRule* pPtr = (SvxMSDffConnectorRule*)pSolverContainer->aCList.First();
7935 pPtr; pPtr = (SvxMSDffConnectorRule*)pSolverContainer->aCList.Next() )
7936 {
7937 SdrObjListIter aIter( *pGroup, IM_DEEPWITHGROUPS );
7938 while( aIter.IsMore() )
7939 {
7940 SdrObject* pPartObj = aIter.Next();
7941 if ( pPtr->pAObj == pPartObj )
7942 pPtr->pAObj = NULL;
7943 if ( pPtr->pBObj == pPartObj )
7944 pPtr->pBObj = NULL;
7945 }
7946 //In MS, the one_row_one_col table is made up of five shape,the connector is connected to some part of a table.
7947 //but in AOO, the connector is connected to the whole group table,so the connector obj is a group table when export by AOO.
7948 //should process this situation when import.
7949 if ( pPtr->pAObj == pGroup )
7950 pPtr->pAObj = pTable;
7951 if ( pPtr->pBObj == pGroup )
7952 pPtr->pBObj = pTable;
7953 }
7954 }
7955 pTable->uno_unlock();
7956 pTable->SetSnapRect( pGroup->GetSnapRect() );
7957 pRet = pTable;
7958
7959 //Remove Objects from shape map
7960 SdrObjListIter aIter( *pGroup, IM_DEEPWITHGROUPS );
7961 while( aIter.IsMore() )
7962 {
7963 SdrObject* pPartObj = aIter.Next();
7964 removeShapeId( pPartObj );
7965 }
7966
7967 SdrObject::Free( pGroup );
7968 }
7969 catch( Exception& )
7970 {
7971 pTable->uno_unlock();
7972 SdrObject* pObj = pTable;
7973 SdrObject::Free( pObj );
7974 }
7975 }
7976 }
7977 return pRet;
7978 }
7979
7980
7981 ////////////////////////////////////////////////////////////////////////////////////////////////////
IsVerticalText() const7982 sal_Bool SdrPowerPointImport::IsVerticalText() const
7983 {
7984 sal_Bool bVerticalText = sal_False;
7985 if ( IsProperty( DFF_Prop_txflTextFlow ) )
7986 {
7987 MSO_TextFlow eTextFlow = (MSO_TextFlow)( GetPropertyValue( DFF_Prop_txflTextFlow ) & 0xFFFF );
7988 switch( eTextFlow )
7989 {
7990 case mso_txflTtoBA : // Top to Bottom @-font, above -> below
7991 case mso_txflTtoBN : // Top to Bottom non-@, above -> below
7992 case mso_txflVertN : // Vertical, non-@, above -> below
7993 bVerticalText = !bVerticalText;
7994 break;
7995 default: break;
7996 }
7997 }
7998
7999 return bVerticalText;
8000 }
8001
ApplyTextAnchorAttributes(PPTTextObj & rTextObj,SfxItemSet & rSet) const8002 void SdrPowerPointImport::ApplyTextAnchorAttributes( PPTTextObj& rTextObj, SfxItemSet& rSet ) const
8003 {
8004 SdrTextVertAdjust eTVA;
8005 SdrTextHorzAdjust eTHA;
8006
8007 sal_uInt32 nTextFlags = rTextObj.GetTextFlags();
8008
8009 nTextFlags &= PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_LEFT | PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_RIGHT
8010 | PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_CENTER | PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_BLOCK;
8011
8012 if ( IsVerticalText() )
8013 {
8014 eTVA = SDRTEXTVERTADJUST_BLOCK;
8015 eTHA = SDRTEXTHORZADJUST_CENTER;
8016
8017 // Textverankerung lesen
8018 MSO_Anchor eTextAnchor = (MSO_Anchor)GetPropertyValue( DFF_Prop_anchorText, mso_anchorTop );
8019
8020 switch( eTextAnchor )
8021 {
8022 case mso_anchorTop:
8023 case mso_anchorTopCentered:
8024 eTHA = SDRTEXTHORZADJUST_RIGHT;
8025 break;
8026
8027 case mso_anchorMiddle :
8028 case mso_anchorMiddleCentered:
8029 eTHA = SDRTEXTHORZADJUST_CENTER;
8030 break;
8031
8032 case mso_anchorBottom:
8033 case mso_anchorBottomCentered:
8034 eTHA = SDRTEXTHORZADJUST_LEFT;
8035 break;
8036
8037 default:
8038 break;
8039 }
8040 // if there is a 100% use of following attributes, the textbox can been aligned also in vertical direction
8041 switch ( eTextAnchor )
8042 {
8043 case mso_anchorTopCentered :
8044 case mso_anchorMiddleCentered :
8045 case mso_anchorBottomCentered :
8046 {
8047 // check if it is sensible to use the centered alignment
8048 sal_uInt32 nMask = PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_LEFT | PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_RIGHT;
8049 if ( ( nTextFlags & nMask ) != nMask ) // if the textobject has left or also right aligned pararagraphs
8050 eTVA = SDRTEXTVERTADJUST_CENTER; // the text has to be displayed using the full width;
8051 }
8052 break;
8053
8054 default :
8055 {
8056 if ( nTextFlags == PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_LEFT )
8057 eTVA = SDRTEXTVERTADJUST_TOP;
8058 else if ( nTextFlags == PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_RIGHT )
8059 eTVA = SDRTEXTVERTADJUST_BOTTOM;
8060 }
8061 break;
8062 }
8063 }
8064 else
8065 {
8066 eTVA = SDRTEXTVERTADJUST_CENTER;
8067 eTHA = SDRTEXTHORZADJUST_BLOCK;
8068
8069 // Textverankerung lesen
8070 MSO_Anchor eTextAnchor = (MSO_Anchor)GetPropertyValue( DFF_Prop_anchorText, mso_anchorTop );
8071
8072 switch( eTextAnchor )
8073 {
8074 case mso_anchorTop:
8075 case mso_anchorTopCentered:
8076 eTVA = SDRTEXTVERTADJUST_TOP;
8077 break;
8078
8079 case mso_anchorMiddle :
8080 case mso_anchorMiddleCentered:
8081 eTVA = SDRTEXTVERTADJUST_CENTER;
8082 break;
8083
8084 case mso_anchorBottom:
8085 case mso_anchorBottomCentered:
8086 eTVA = SDRTEXTVERTADJUST_BOTTOM;
8087 break;
8088
8089 default:
8090 break;
8091 }
8092 // if there is a 100% usage of following attributes, the textbox can be aligned also in horizontal direction
8093 switch ( eTextAnchor )
8094 {
8095 case mso_anchorTopCentered :
8096 case mso_anchorMiddleCentered :
8097 case mso_anchorBottomCentered :
8098 {
8099 // check if it is sensible to use the centered alignment
8100 sal_uInt32 nMask = PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_LEFT | PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_RIGHT;
8101 if ( ( nTextFlags & nMask ) != nMask ) // if the textobject has left or also right aligned pararagraphs
8102 eTHA = SDRTEXTHORZADJUST_CENTER; // the text has to be displayed using the full width;
8103 }
8104 break;
8105
8106 default :
8107 {
8108 if ( nTextFlags == PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_LEFT )
8109 eTHA = SDRTEXTHORZADJUST_LEFT;
8110 else if ( nTextFlags == PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_RIGHT )
8111 eTHA = SDRTEXTHORZADJUST_RIGHT;
8112 }
8113 break;
8114 }
8115 }
8116 rSet.Put( SdrTextVertAdjustItem( eTVA ) );
8117 rSet.Put( SdrTextHorzAdjustItem( eTHA ) );
8118 }
8119