?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
bump product version to 4.1.6.2
[LibreOffice.git] / sd / source / filter / ppt / propread.cxx
blob38e2d7a87e3fe692a4a0af8664bed98a0fc5dbdc
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20 #include <propread.hxx>
21 #include "rtl/tencinfo.h"
22 #include "rtl/textenc.h"
23
24 PropEntry::PropEntry( sal_uInt32 nId, const sal_uInt8* pBuf, sal_uInt32 nBufSize, sal_uInt16 nTextEnc ) :
25 mnId ( nId ),
26 mnSize ( nBufSize ),
27 mnTextEnc ( nTextEnc ),
28 mpBuf ( new sal_uInt8[ nBufSize ] )
29 {
30 memcpy( (void*)mpBuf, (void*)pBuf, nBufSize );
31 };
32
33 PropEntry::PropEntry( const PropEntry& rProp ) :
34 mnId ( rProp.mnId ),
35 mnSize ( rProp.mnSize ),
36 mnTextEnc ( rProp.mnTextEnc ),
37 mpBuf ( new sal_uInt8[ mnSize ] )
38 {
39 memcpy( (void*)mpBuf, (void*)rProp.mpBuf, mnSize );
40 };
41
42 PropEntry& PropEntry::operator=(const PropEntry& rPropEntry)
43 {
44 if ( this != &rPropEntry )
45 {
46 delete[] mpBuf;
47 mnId = rPropEntry.mnId;
48 mnSize = rPropEntry.mnSize;
49 mnTextEnc = rPropEntry.mnTextEnc;
50 mpBuf = new sal_uInt8[ mnSize ];
51 memcpy( (void*)mpBuf, (void*)rPropEntry.mpBuf, mnSize );
52 }
53 return *this;
54 }
55
56 // -----------------------------------------------------------------------
57
58 void PropItem::Clear()
59 {
60 Seek( STREAM_SEEK_TO_BEGIN );
61 delete[] (sal_uInt8*)SwitchBuffer();
62 }
63
64 // -----------------------------------------------------------------------
65
66 static xub_StrLen lcl_getMaxSafeStrLen(sal_uInt32 nSize)
67 {
68 nSize -= 1; //Drop NULL terminator
69
70 //If it won't fit in a string, clip it to the max size that does
71 if (nSize > STRING_MAXLEN)
72 nSize = STRING_MAXLEN;
73
74 return static_cast< xub_StrLen >( nSize );
75 }
76
77 sal_Bool PropItem::Read( OUString& rString, sal_uInt32 nStringType, sal_Bool bAlign )
78 {
79 sal_uInt32 i, nItemSize, nType, nItemPos;
80 sal_Bool bRetValue = sal_False;
81
82 nItemPos = Tell();
83
84 if ( nStringType == VT_EMPTY )
85 *this >> nType;
86 else
87 nType = nStringType & VT_TYPEMASK;
88
89 *this >> nItemSize;
90
91 switch( nType )
92 {
93 case VT_LPSTR :
94 {
95 if ( nItemSize )
96 {
97 try
98 {
99 sal_Char* pString = new sal_Char[ nItemSize ];
100 if ( mnTextEnc == RTL_TEXTENCODING_UCS2 )
101 {
102 nItemSize >>= 1;
103 if ( nItemSize > 1 )
104 {
105 sal_Unicode* pWString = (sal_Unicode*)pString;
106 for ( i = 0; i < nItemSize; i++ )
107 *this >> pWString[ i ];
108 rString = OUString(pWString, lcl_getMaxSafeStrLen(nItemSize));
109 }
110 else
111 rString = OUString();
112 bRetValue = sal_True;
113 }
114 else
115 {
116 SvMemoryStream::Read( pString, nItemSize );
117 if ( pString[ nItemSize - 1 ] == 0 )
118 {
119 if ( nItemSize > 1 )
120 rString = OUString(pString, rtl_str_getLength(pString), mnTextEnc);
121 else
122 rString = OUString();
123 bRetValue = sal_True;
124 }
125 }
126 delete[] pString;
127 }
128 catch( const std::bad_alloc& )
129 {
130 OSL_FAIL( "sd PropItem::Read bad alloc" );
131 }
132 }
133 if ( bAlign )
134 SeekRel( ( 4 - ( nItemSize & 3 ) ) & 3 ); // dword align
135 }
136 break;
137
138 case VT_LPWSTR :
139 {
140 if ( nItemSize )
141 {
142 try
143 {
144 sal_Unicode* pString = new sal_Unicode[ nItemSize ];
145 for ( i = 0; i < nItemSize; i++ )
146 *this >> pString[ i ];
147 if ( pString[ i - 1 ] == 0 )
148 {
149 if ( (sal_uInt16)nItemSize > 1 )
150 rString = OUString(pString, lcl_getMaxSafeStrLen(nItemSize));
151 else
152 rString = OUString();
153 bRetValue = sal_True;
154 }
155 delete[] pString;
156 }
157 catch( const std::bad_alloc& )
158 {
159 OSL_FAIL( "sd PropItem::Read bad alloc" );
160 }
161 }
162 if ( bAlign && ( nItemSize & 1 ) )
163 SeekRel( 2 ); // dword align
164 }
165 break;
166 }
167 if ( !bRetValue )
168 Seek( nItemPos );
169 return bRetValue;
170 }
171
172 // -----------------------------------------------------------------------
173
174 PropItem& PropItem::operator=( PropItem& rPropItem )
175 {
176 if ( this != &rPropItem )
177 {
178 Seek( STREAM_SEEK_TO_BEGIN );
179 delete[] (sal_uInt8*)SwitchBuffer();
180
181 mnTextEnc = rPropItem.mnTextEnc;
182 sal_uInt32 nItemPos = rPropItem.Tell();
183 rPropItem.Seek( STREAM_SEEK_TO_END );
184 SvMemoryStream::Write( rPropItem.GetData(), rPropItem.Tell() );
185 rPropItem.Seek( nItemPos );
186 }
187 return *this;
188 }
189
190 // -----------------------------------------------------------------------
191
192 Section::Section( const Section& rSection )
193 : mnTextEnc(rSection.mnTextEnc),
194 maEntries(rSection.maEntries.clone())
195 {
196 for ( int i = 0; i < 16; i++ )
197 aFMTID[ i ] = rSection.aFMTID[ i ];
198 }
199
200 // -----------------------------------------------------------------------
201
202 Section::Section( const sal_uInt8* pFMTID )
203 {
204 mnTextEnc = RTL_TEXTENCODING_MS_1252;
205 for ( int i = 0; i < 16; i++ )
206 aFMTID[ i ] = pFMTID[ i ];
207 }
208
209 // -----------------------------------------------------------------------
210
211 sal_Bool Section::GetProperty( sal_uInt32 nId, PropItem& rPropItem )
212 {
213 if ( nId )
214 {
215 boost::ptr_vector<PropEntry>::const_iterator iter;
216 for (iter = maEntries.begin(); iter != maEntries.end(); ++iter)
217 {
218 if (iter->mnId == nId)
219 break;
220 }
221
222 if (iter != maEntries.end())
223 {
224 rPropItem.Clear();
225 rPropItem.SetTextEncoding( mnTextEnc );
226 rPropItem.Write( iter->mpBuf,iter->mnSize );
227 rPropItem.Seek( STREAM_SEEK_TO_BEGIN );
228 return sal_True;
229 }
230 }
231 return sal_False;
232 }
233
234 // -----------------------------------------------------------------------
235
236 void Section::AddProperty( sal_uInt32 nId, const sal_uInt8* pBuf, sal_uInt32 nBufSize )
237 {
238 // just a simple id check
239
240 if ( !nId )
241 return;
242 if ( nId == 0xffffffff )
243 nId = 0;
244
245 // do not allow same PropId's, sort
246 boost::ptr_vector<PropEntry>::iterator iter;
247 for ( iter = maEntries.begin(); iter != maEntries.end(); ++iter )
248 {
249 if ( iter->mnId == nId )
250 maEntries.replace( iter, new PropEntry( nId, pBuf, nBufSize, mnTextEnc ));
251 else if ( iter->mnId > nId )
252 maEntries.insert( iter, new PropEntry( nId, pBuf, nBufSize, mnTextEnc ));
253 else
254 continue;
255 return;
256 }
257
258 maEntries.push_back( new PropEntry( nId, pBuf, nBufSize, mnTextEnc ) );
259 }
260
261 // -----------------------------------------------------------------------
262
263 sal_Bool Section::GetDictionary( Dictionary& rDict )
264 {
265 sal_Bool bRetValue = sal_False;
266
267 boost::ptr_vector<PropEntry>::iterator iter;
268 for (iter = maEntries.begin(); iter != maEntries.end(); ++iter)
269 {
270 if ( iter->mnId == 0 )
271 break;
272 }
273
274 if ( iter != maEntries.end() )
275 {
276 sal_uInt32 nDictCount, nId, nSize, nPos;
277 SvMemoryStream aStream( (sal_Int8*)iter->mpBuf, iter->mnSize, STREAM_READ );
278 aStream.Seek( STREAM_SEEK_TO_BEGIN );
279 aStream >> nDictCount;
280 for ( sal_uInt32 i = 0; i < nDictCount; i++ )
281 {
282 aStream >> nId >> nSize;
283 if ( nSize )
284 {
285 String aString;
286 nPos = aStream.Tell();
287 try
288 {
289 sal_Char* pString = new sal_Char[ nSize ];
290 aStream.Read( pString, nSize );
291 if ( mnTextEnc == RTL_TEXTENCODING_UCS2 )
292 {
293 nSize >>= 1;
294 aStream.Seek( nPos );
295 sal_Unicode* pWString = (sal_Unicode*)pString;
296 for ( i = 0; i < nSize; i++ )
297 aStream >> pWString[ i ];
298 aString = OUString(pWString, lcl_getMaxSafeStrLen(nSize));
299 }
300 else
301 aString = OUString(pString, lcl_getMaxSafeStrLen(nSize), mnTextEnc);
302 delete[] pString;
303 }
304 catch( const std::bad_alloc& )
305 {
306 OSL_FAIL( "sd Section::GetDictionary bad alloc" );
307 }
308 if ( !aString.Len() )
309 break;
310 rDict.insert( std::make_pair(aString,nId) );
311 }
312 bRetValue = sal_True;
313 }
314 }
315 return bRetValue;
316 }
317
318 // -----------------------------------------------------------------------
319
320 void Section::Read( SvStorageStream *pStrm )
321 {
322 sal_uInt32 i, nSecOfs, nSecSize, nPropCount, nPropId, nPropOfs, nPropType, nPropSize, nCurrent, nVectorCount, nTemp, nStrmSize;
323 nSecOfs = pStrm->Tell();
324
325 pStrm->Seek( STREAM_SEEK_TO_END );
326 nStrmSize = pStrm->Tell();
327 pStrm->Seek( nSecOfs );
328
329 mnTextEnc = RTL_TEXTENCODING_MS_1252;
330 *pStrm >> nSecSize >> nPropCount;
331 while( nPropCount-- && ( pStrm->GetError() == ERRCODE_NONE ) )
332 {
333 *pStrm >> nPropId >> nPropOfs;
334 nCurrent = pStrm->Tell();
335 pStrm->Seek( nPropOfs + nSecOfs );
336 if ( nPropId ) // do not read dictionary
337 {
338
339 *pStrm >> nPropType;
340
341 nPropSize = 4;
342
343 if ( nPropType & VT_VECTOR )
344 {
345 *pStrm >> nVectorCount;
346 nPropType &=~VT_VECTOR;
347 nPropSize += 4;
348 }
349 else
350 nVectorCount = 1;
351
352
353 sal_Bool bVariant = ( nPropType == VT_VARIANT );
354
355 for ( i = 0; nPropSize && ( i < nVectorCount ); i++ )
356 {
357 if ( bVariant )
358 {
359 *pStrm >> nPropType;
360 nPropSize += 4;
361 }
362 switch( nPropType )
363 {
364 case VT_UI1 :
365 nPropSize++;
366 break;
367
368 case VT_I2 :
369 case VT_UI2 :
370 case VT_BOOL :
371 nPropSize += 2;
372 break;
373
374 case VT_I4 :
375 case VT_R4 :
376 case VT_UI4 :
377 case VT_ERROR :
378 nPropSize += 4;
379 break;
380
381 case VT_I8 :
382 case VT_R8 :
383 case VT_CY :
384 case VT_UI8 :
385 case VT_DATE :
386 case VT_FILETIME :
387 nPropSize += 8;
388 break;
389
390 case VT_BSTR :
391 *pStrm >> nTemp;
392 nPropSize += ( nTemp + 4 );
393 break;
394
395 case VT_LPSTR :
396 *pStrm >> nTemp;
397 nPropSize += ( nTemp + 4 );
398 break;
399
400 case VT_LPWSTR :
401 {
402 *pStrm >> nTemp;
403 // looks like these are aligned to 4 bytes
404 sal_uInt32 nLength = nPropOfs + nSecOfs + nPropSize + ( nTemp << 1 ) + 4;
405 nPropSize += ( nTemp << 1 ) + 4 + (nLength % 4);
406 }
407 break;
408
409 case VT_BLOB_OBJECT :
410 case VT_BLOB :
411 case VT_CF :
412 *pStrm >> nTemp;
413 nPropSize += ( nTemp + 4 );
414 break;
415
416 case VT_CLSID :
417 case VT_STREAM :
418 case VT_STORAGE :
419 case VT_STREAMED_OBJECT :
420 case VT_STORED_OBJECT :
421 case VT_VARIANT :
422 case VT_VECTOR :
423 default :
424 nPropSize = 0;
425 }
426 if ( nPropSize )
427 {
428 if ( ( nVectorCount - i ) > 1 )
429 pStrm->Seek( nPropOfs + nSecOfs + nPropSize );
430 }
431 else
432 break;
433 }
434 if ( nPropSize )
435 {
436 if ( nPropSize > nStrmSize )
437 {
438 nPropCount = 0;
439 break;
440 }
441 pStrm->Seek( nPropOfs + nSecOfs );
442 // make sure we don't overflow the section size
443 if( nPropSize > nSecSize - nSecOfs )
444 nPropSize = nSecSize - nSecOfs;
445 sal_uInt8* pBuf = new sal_uInt8[ nPropSize ];
446 pStrm->Read( pBuf, nPropSize );
447 AddProperty( nPropId, pBuf, nPropSize );
448 delete[] pBuf;
449 }
450 if ( nPropId == 1 )
451 {
452 PropItem aPropItem;
453 if ( GetProperty( 1, aPropItem ) )
454 {
455 sal_uInt16 nCodePage;
456 aPropItem >> nPropType;
457 if ( nPropType == VT_I2 )
458 {
459 aPropItem >> nCodePage;
460
461 if ( nCodePage == 1200 )
462 {
463 mnTextEnc = RTL_TEXTENCODING_UCS2;
464 }
465 else
466 {
467 mnTextEnc = rtl_getTextEncodingFromWindowsCodePage( nCodePage );
468 if ( mnTextEnc == RTL_TEXTENCODING_DONTKNOW )
469 mnTextEnc = RTL_TEXTENCODING_MS_1252;
470 }
471 }
472 else
473 {
474 mnTextEnc = RTL_TEXTENCODING_MS_1252;
475 }
476 }
477 }
478 }
479 else
480 {
481 sal_uInt32 nDictCount, nSize;
482 *pStrm >> nDictCount;
483 for ( i = 0; i < nDictCount; i++ )
484 {
485 *pStrm >> nSize >> nSize;
486 pStrm->SeekRel( nSize );
487 }
488 nSize = pStrm->Tell();
489 pStrm->Seek( nPropOfs + nSecOfs );
490 nSize -= pStrm->Tell();
491 if ( nSize > nStrmSize )
492 {
493 nPropCount = 0;
494 break;
495 }
496 sal_uInt8* pBuf = new sal_uInt8[ nSize ];
497 pStrm->Read( pBuf, nSize );
498 AddProperty( 0xffffffff, pBuf, nSize );
499 delete[] pBuf;
500 }
501 pStrm->Seek( nCurrent );
502 }
503 pStrm->Seek( nSecOfs + nSecSize );
504 }
505
506 // -----------------------------------------------------------------------
507
508 Section& Section::operator=( const Section& rSection )
509 {
510 if ( this != &rSection )
511 {
512 memcpy( (void*)aFMTID, (void*)rSection.aFMTID, 16 );
513
514 maEntries = rSection.maEntries.clone();
515 }
516 return *this;
517 }
518
519 // -----------------------------------------------------------------------
520
521 PropRead::PropRead( SvStorage& rStorage, const String& rName ) :
522 mbStatus ( sal_False ),
523 mnByteOrder ( 0xfffe ),
524 mnFormat ( 0 ),
525 mnVersionLo ( 4 ),
526 mnVersionHi ( 2 )
527 {
528 if ( rStorage.IsStream( rName ) )
529 {
530 mpSvStream = rStorage.OpenSotStream( rName, STREAM_STD_READ );
531 if ( mpSvStream )
532 {
533 mpSvStream->SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
534 memset( mApplicationCLSID, 0, 16 );
535 mbStatus = sal_True;
536 }
537 }
538 }
539
540 // -----------------------------------------------------------------------
541
542 void PropRead::AddSection( Section& rSection )
543 {
544 maSections.push_back( new Section( rSection ) );
545 }
546
547 // -----------------------------------------------------------------------
548
549 const Section* PropRead::GetSection( const sal_uInt8* pFMTID )
550 {
551 boost::ptr_vector<Section>::iterator it;
552 for ( it = maSections.begin(); it != maSections.end(); ++it)
553 {
554 if ( memcmp( it->GetFMTID(), pFMTID, 16 ) == 0 )
555 return &(*it);
556 }
557 return NULL;
558 }
559
560 // -----------------------------------------------------------------------
561
562 void PropRead::Read()
563 {
564 maSections.clear();
565
566 if ( mbStatus )
567 {
568 sal_uInt32 nSections;
569 sal_uInt32 nSectionOfs;
570 sal_uInt32 nCurrent;
571 *mpSvStream >> mnByteOrder >> mnFormat >> mnVersionLo >> mnVersionHi;
572 if ( mnByteOrder == 0xfffe )
573 {
574 sal_uInt8* pSectCLSID = new sal_uInt8[ 16 ];
575 mpSvStream->Read( mApplicationCLSID, 16 );
576 *mpSvStream >> nSections;
577 if ( nSections > 2 ) // sj: PowerPoint documents are containing max 2 sections
578 {
579 mbStatus = sal_False;
580 }
581 else for ( sal_uInt32 i = 0; i < nSections; i++ )
582 {
583 mpSvStream->Read( pSectCLSID, 16 );
584 *mpSvStream >> nSectionOfs;
585 nCurrent = mpSvStream->Tell();
586 mpSvStream->Seek( nSectionOfs );
587 Section aSection( pSectCLSID );
588 aSection.Read( mpSvStream );
589 AddSection( aSection );
590 mpSvStream->Seek( nCurrent );
591 }
592 delete[] pSectCLSID;
593 }
594 }
595 }
596
597 // -----------------------------------------------------------------------
598
599 PropRead& PropRead::operator=( const PropRead& rPropRead )
600 {
601 if ( this != &rPropRead )
602 {
603 mbStatus = rPropRead.mbStatus;
604 mpSvStream = rPropRead.mpSvStream;
605
606 mnByteOrder = rPropRead.mnByteOrder;
607 mnFormat = rPropRead.mnFormat;
608 mnVersionLo = rPropRead.mnVersionLo;
609 mnVersionHi = rPropRead.mnVersionHi;
610 memcpy( mApplicationCLSID, rPropRead.mApplicationCLSID, 16 );
611
612 maSections = rPropRead.maSections.clone();
613 }
614 return *this;
615 }
616
617 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE