Line data Source code
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 <com/sun/star/uno/Sequence.hxx>
21 : #include <com/sun/star/lang/XSingleServiceFactory.hpp>
22 : #include <com/sun/star/embed/XStorage.hpp>
23 : #include <com/sun/star/embed/ElementModes.hpp>
24 : #include <com/sun/star/beans/XPropertySet.hpp>
25 :
26 : #include <rtl/digest.h>
27 : #include <osl/file.hxx>
28 : #include <sot/stg.hxx>
29 : #include <sot/storinfo.hxx>
30 : #include <sot/storage.hxx>
31 : #include <sot/formats.hxx>
32 : #include <sot/exchange.hxx>
33 : #include <unotools/ucbstreamhelper.hxx>
34 : #include <tools/fsys.hxx>
35 : #include <tools/cachestr.hxx>
36 : #include <tools/debug.hxx>
37 : #include <tools/urlobj.hxx>
38 : #include <unotools/localfilehelper.hxx>
39 : #include <unotools/ucbhelper.hxx>
40 : #include <comphelper/processfactory.hxx>
41 :
42 : using namespace ::com::sun::star;
43 :
44 : /************** class SotStorageStream ***********************************/
45 0 : class SotStorageStreamFactory : public SotFactory
46 : {
47 : public:
48 : TYPEINFO();
49 0 : SotStorageStreamFactory( const SvGlobalName & rName,
50 : const String & rClassName,
51 : CreateInstanceType pCreateFuncP )
52 0 : : SotFactory( rName, rClassName, pCreateFuncP )
53 0 : {}
54 : };
55 0 : TYPEINIT1(SotStorageStreamFactory,SotFactory);
56 :
57 :
58 0 : SO2_IMPL_BASIC_CLASS1_DLL(SotStorageStream,SotStorageStreamFactory,SotObject,
59 : SvGlobalName( 0xd7deb420, 0xf902, 0x11d0,
60 : 0xaa, 0xa1, 0x0, 0xa0, 0x24, 0x9d, 0x55, 0x90 ) )
61 :
62 : /************************************************************************
63 : |* SotStorageStream::SotStorageStream()
64 : |*
65 : |* Beschreibung
66 : *************************************************************************/
67 0 : SvLockBytesRef MakeLockBytes_Impl( const String & rName, StreamMode nMode )
68 : {
69 0 : SvLockBytesRef xLB;
70 0 : if( rName.Len() )
71 : {
72 0 : SvStream * pFileStm = new SvFileStream( rName, nMode );
73 0 : xLB = new SvLockBytes( pFileStm, sal_True );
74 : }
75 : else
76 : {
77 0 : SvStream * pCacheStm = new SvCacheStream();
78 0 : xLB = new SvLockBytes( pCacheStm, sal_True );
79 : }
80 0 : return xLB;
81 : }
82 :
83 0 : SotStorageStream::SotStorageStream( const String & rName, StreamMode nMode,
84 : StorageMode
85 : #ifdef DBG_UTIL
86 : nStorageMode
87 : #endif
88 : )
89 : : SvStream( MakeLockBytes_Impl( rName, nMode ) )
90 0 : , pOwnStm( NULL )
91 : {
92 0 : if( nMode & STREAM_WRITE )
93 0 : bIsWritable = sal_True;
94 : else
95 0 : bIsWritable = sal_False;
96 :
97 : DBG_ASSERT( !nStorageMode,"StorageModes ignored" );
98 0 : }
99 :
100 402 : SotStorageStream::SotStorageStream( BaseStorageStream * pStm )
101 : {
102 402 : if( pStm )
103 : {
104 402 : if( STREAM_WRITE & pStm->GetMode() )
105 137 : bIsWritable = sal_True;
106 : else
107 265 : bIsWritable = sal_False;
108 :
109 402 : pOwnStm = pStm;
110 402 : SetError( pStm->GetError() );
111 402 : pStm->ResetError();
112 : }
113 : else
114 : {
115 0 : pOwnStm = NULL;
116 0 : bIsWritable = sal_True;
117 0 : SetError( SVSTREAM_INVALID_PARAMETER );
118 : }
119 402 : }
120 :
121 0 : SotStorageStream::SotStorageStream()
122 0 : : pOwnStm( NULL )
123 : {
124 : // ??? wenn Init virtuell ist, entsprechen setzen
125 0 : bIsWritable = sal_True;
126 0 : }
127 :
128 : /************************************************************************
129 : |* SotStorageStream::~SotStorageStream()
130 : |*
131 : |* Beschreibung
132 : *************************************************************************/
133 2010 : SotStorageStream::~SotStorageStream()
134 : {
135 402 : Flush(); //SetBufferSize(0);
136 402 : delete pOwnStm;
137 1608 : }
138 :
139 : /*************************************************************************
140 : |* SotStorageStream::ResetError()
141 : |*
142 : |* Beschreibung
143 : *************************************************************************/
144 0 : void SotStorageStream::ResetError()
145 : {
146 0 : SvStream::ResetError();
147 0 : if( pOwnStm )
148 0 : pOwnStm->ResetError();
149 0 : }
150 :
151 : /*************************************************************************
152 : |* SotStorageStream::GetData()
153 : |*
154 : |* Beschreibung
155 : *************************************************************************/
156 951391 : sal_uLong SotStorageStream::GetData( void* pData, sal_uLong nSize )
157 : {
158 951391 : sal_uLong nRet = 0;
159 :
160 951391 : if( pOwnStm )
161 : {
162 951391 : nRet = pOwnStm->Read( pData, nSize );
163 951391 : SetError( pOwnStm->GetError() );
164 : }
165 : else
166 0 : nRet = SvStream::GetData( (sal_Char *)pData, nSize );
167 951391 : return nRet;
168 : }
169 :
170 : /*************************************************************************
171 : |* SotStorageStream::PutData()
172 : |*
173 : |* Beschreibung
174 : *************************************************************************/
175 0 : sal_uLong SotStorageStream::PutData( const void* pData, sal_uLong nSize )
176 : {
177 0 : sal_uLong nRet = 0;
178 :
179 0 : if( pOwnStm )
180 : {
181 0 : nRet = pOwnStm->Write( pData, nSize );
182 0 : SetError( pOwnStm->GetError() );
183 : }
184 : else
185 0 : nRet = SvStream::PutData( (sal_Char *)pData, nSize );
186 0 : return nRet;
187 : }
188 :
189 : /*************************************************************************
190 : |* SotStorageStream::SeekPos()
191 : |*
192 : |* Beschreibung
193 : *************************************************************************/
194 748156 : sal_uLong SotStorageStream::SeekPos( sal_uLong nPos )
195 : {
196 748156 : sal_uLong nRet = 0;
197 :
198 748156 : if( pOwnStm )
199 : {
200 748156 : nRet = pOwnStm->Seek( nPos );
201 748156 : SetError( pOwnStm->GetError() );
202 : }
203 : else
204 0 : nRet = SvStream::SeekPos( nPos );
205 748156 : return nRet;
206 : }
207 :
208 : /*************************************************************************
209 : |* SotStorageStream::Flush()
210 : |*
211 : |* Beschreibung
212 : *************************************************************************/
213 137 : void SotStorageStream::FlushData()
214 : {
215 137 : if( pOwnStm )
216 : {
217 137 : pOwnStm->Flush();
218 137 : SetError( pOwnStm->GetError() );
219 : }
220 : else
221 0 : SvStream::FlushData();
222 137 : }
223 :
224 : /*************************************************************************
225 : |* SotStorageStream::SetSize()
226 : |*
227 : |* Beschreibung
228 : *************************************************************************/
229 0 : void SotStorageStream::SetSize( sal_uLong nNewSize )
230 : {
231 0 : sal_uLong nPos = Tell();
232 0 : if( pOwnStm )
233 : {
234 0 : pOwnStm->SetSize( nNewSize );
235 0 : SetError( pOwnStm->GetError() );
236 : }
237 : else
238 0 : SvStream::SetSize( nNewSize );
239 :
240 0 : if( nNewSize < nPos )
241 : // ans Ende setzen
242 0 : Seek( nNewSize );
243 :
244 : //return GetError() == SVSTREAM_OK;
245 0 : }
246 :
247 : /*************************************************************************
248 : |*
249 : |* SotStorageStream::GetSize()
250 : |*
251 : |* Beschreibung
252 : |*
253 : *************************************************************************/
254 61 : sal_uInt32 SotStorageStream::GetSize() const
255 : {
256 61 : sal_uLong nPos = Tell();
257 61 : ((SotStorageStream *)this)->Seek( STREAM_SEEK_TO_END );
258 61 : sal_uLong nSize = Tell();
259 61 : ((SotStorageStream *)this)->Seek( nPos );
260 61 : return nSize;
261 : }
262 :
263 6502 : sal_Size SotStorageStream::remainingSize()
264 : {
265 6502 : if (pOwnStm)
266 6502 : return pOwnStm->GetSize() - Tell();
267 0 : return SvStream::remainingSize();
268 : }
269 :
270 : /*************************************************************************
271 : |* SotStorageStream::CopyTo()
272 : |*
273 : |* Beschreibung
274 : *************************************************************************/
275 0 : sal_Bool SotStorageStream::CopyTo( SotStorageStream * pDestStm )
276 : {
277 0 : Flush(); // alle Daten schreiben
278 0 : pDestStm->ClearBuffer();
279 0 : if( !pOwnStm || !pDestStm->pOwnStm )
280 : { // Wenn Ole2 oder nicht nur eigene StorageStreams
281 :
282 0 : sal_uLong nPos = Tell(); // Position merken
283 0 : Seek( 0L );
284 0 : pDestStm->SetSize( 0 ); // Ziel-Stream leeren
285 :
286 0 : void * pMem = new sal_uInt8[ 8192 ];
287 : sal_uLong nRead;
288 0 : while( 0 != (nRead = Read( pMem, 8192 )) )
289 : {
290 0 : if( nRead != pDestStm->Write( pMem, nRead ) )
291 : {
292 0 : SetError( SVSTREAM_GENERALERROR );
293 0 : break;
294 : }
295 : }
296 0 : delete [] static_cast<sal_uInt8*>(pMem);
297 : // Position setzen
298 0 : pDestStm->Seek( nPos );
299 0 : Seek( nPos );
300 : }
301 : else
302 : {
303 : /*
304 : // Kopieren
305 : nErr = pObjI->CopyTo( pDestStm->pObjI, uSize, NULL, &uWrite );
306 : if( SUCCEEDED( nErr ) )
307 : {
308 : // Ziel-Streamzeiger steht hinter den Daten
309 : // SvSeek abgleichen
310 : pDestStm->Seek( uWrite.LowPart );
311 : }
312 : else if( GetScode( nErr ) == E_NOTIMPL )
313 : { // Eines Tages werden alle MS... ?!#
314 : */
315 0 : pOwnStm->CopyTo( pDestStm->pOwnStm );
316 0 : SetError( pOwnStm->GetError() );
317 : }
318 0 : return GetError() == SVSTREAM_OK;
319 : }
320 :
321 : /*************************************************************************
322 : |* SotStorageStream::Commit()
323 : |* SotStorageStream::Revert()
324 : |*
325 : |* Beschreibung
326 : *************************************************************************/
327 0 : sal_Bool SotStorageStream::Commit()
328 : {
329 0 : if( pOwnStm )
330 : {
331 0 : pOwnStm->Flush();
332 0 : if( pOwnStm->GetError() == SVSTREAM_OK )
333 0 : pOwnStm->Commit();
334 0 : SetError( pOwnStm->GetError() );
335 : }
336 0 : return GetError() == SVSTREAM_OK;
337 : }
338 :
339 0 : sal_Bool SotStorageStream::Revert()
340 : {
341 0 : if( !pOwnStm )
342 : {
343 0 : pOwnStm->Revert();
344 0 : SetError( pOwnStm->GetError() );
345 : }
346 0 : return GetError() == SVSTREAM_OK;
347 : }
348 :
349 0 : sal_Bool SotStorageStream::SetProperty( const String& rName, const ::com::sun::star::uno::Any& rValue )
350 : {
351 0 : UCBStorageStream* pStg = PTR_CAST( UCBStorageStream, pOwnStm );
352 0 : if ( pStg )
353 : {
354 0 : return pStg->SetProperty( rName, rValue );
355 : }
356 : else
357 : {
358 : OSL_FAIL("Not implemented!");
359 0 : return sal_False;
360 : }
361 : }
362 :
363 : /************** class SotStorage ******************************************
364 : *************************************************************************/
365 0 : class SotStorageFactory : public SotFactory
366 : {
367 : public:
368 : TYPEINFO();
369 0 : SotStorageFactory( const SvGlobalName & rName,
370 : const String & rClassName,
371 : CreateInstanceType pCreateFuncP )
372 0 : : SotFactory( rName, rClassName, pCreateFuncP )
373 0 : {}
374 : };
375 0 : TYPEINIT1(SotStorageFactory,SotFactory);
376 :
377 :
378 0 : SO2_IMPL_BASIC_CLASS1_DLL(SotStorage,SotStorageFactory,SotObject,
379 : SvGlobalName( 0x980ce7e0, 0xf905, 0x11d0,
380 : 0xaa, 0xa1, 0x0, 0xa0, 0x24, 0x9d, 0x55, 0x90 ) )
381 :
382 : /************************************************************************
383 : |*
384 : |* SotStorage::SotStorage()
385 : |*
386 : |* Beschreibung Es muss ein I... Objekt an SvObject uebergeben
387 : |* werden, da es sonst selbst ein IUnknown anlegt und
388 : |* festlegt, dass alle weiteren I... Objekte mit
389 : |* delete zerstoert werden (Owner() == sal_True).
390 : |* Es werden aber nur IStorage Objekte benutzt und nicht
391 : |* selbst implementiert, deshalb wird so getan, als ob
392 : |* das IStorage Objekt von aussen kam und es wird mit
393 : |* Release() freigegeben.
394 : |* Die CreateStorage Methoden werden benoetigt, um
395 : |* ein IStorage Objekt vor dem Aufruf von SvObject
396 : |* zu erzeugen (Own, !Own automatik).
397 : |* Hat CreateStorage ein Objekt erzeugt, dann wurde
398 : |* der RefCounter schon um 1 erhoet.
399 : |* Die Uebergabe erfolgt in pStorageCTor. Die Variable
400 : |* ist NULL, wenn es nicht geklappt hat.
401 : |*
402 : *************************************************************************/
403 : #define INIT_SotStorage() \
404 : : m_pOwnStg( NULL ) \
405 : , m_pStorStm( NULL ) \
406 : , m_nError( SVSTREAM_OK ) \
407 : , m_bIsRoot( sal_False ) \
408 : , m_bDelStm( sal_False ) \
409 : , m_nVersion( SOFFICE_FILEFORMAT_CURRENT )
410 :
411 0 : SotStorage::SotStorage()
412 0 : INIT_SotStorage()
413 : {
414 : // ??? What's this ???
415 0 : }
416 :
417 : #define ERASEMASK ( STREAM_TRUNC | STREAM_WRITE | STREAM_SHARE_DENYALL )
418 : #include <com/sun/star/uno/Reference.h>
419 : #include <com/sun/star/ucb/XCommandEnvironment.hpp>
420 : #include <ucbhelper/content.hxx>
421 :
422 243 : SotStorage::SotStorage( const String & rName, StreamMode nMode, StorageMode nStorageMode )
423 243 : INIT_SotStorage()
424 : {
425 243 : m_aName = rName; // Namen merken
426 243 : CreateStorage( sal_True, nMode, nStorageMode );
427 243 : if ( IsOLEStorage() )
428 0 : m_nVersion = SOFFICE_FILEFORMAT_50;
429 243 : }
430 :
431 243 : void SotStorage::CreateStorage( sal_Bool bForceUCBStorage, StreamMode nMode, StorageMode nStorageMode )
432 : {
433 : DBG_ASSERT( !m_pStorStm && !m_pOwnStg, "Use only in ctor!" );
434 243 : if( m_aName.Len() )
435 : {
436 : // named storage
437 0 : if( ( ( nMode & ERASEMASK ) == ERASEMASK ) )
438 0 : ::utl::UCBContentHelper::Kill( m_aName );
439 :
440 0 : INetURLObject aObj( m_aName );
441 0 : if ( aObj.GetProtocol() == INET_PROT_NOT_VALID )
442 : {
443 0 : rtl::OUString aURL;
444 0 : ::utl::LocalFileHelper::ConvertPhysicalNameToURL( m_aName, aURL );
445 0 : aObj.SetURL( aURL );
446 0 : m_aName = aObj.GetMainURL( INetURLObject::NO_DECODE );
447 : }
448 :
449 : // a new unpacked storage should be created
450 0 : if ( nStorageMode == STORAGE_CREATE_UNPACKED )
451 : {
452 : // don't open stream readwrite, content provider may not support this !
453 0 : String aURL = UCBStorage::CreateLinkFile( m_aName );
454 0 : if ( aURL.Len() )
455 : {
456 0 : ::ucbhelper::Content aContent( aURL, ::com::sun::star::uno::Reference < ::com::sun::star::ucb::XCommandEnvironment >(), comphelper::getProcessComponentContext() );
457 0 : m_pOwnStg = new UCBStorage( aContent, aURL, nMode, sal_False );
458 : }
459 : else
460 : {
461 0 : m_pOwnStg = new Storage( m_aName, nMode, (nStorageMode & STORAGE_TRANSACTED) ? sal_False : sal_True );
462 0 : SetError( ERRCODE_IO_NOTSUPPORTED );
463 0 : }
464 : }
465 : else
466 : {
467 : // check the stream
468 0 : m_pStorStm = ::utl::UcbStreamHelper::CreateStream( m_aName, nMode );
469 0 : if ( m_pStorStm && m_pStorStm->GetError() )
470 0 : DELETEZ( m_pStorStm );
471 :
472 0 : if ( m_pStorStm )
473 : {
474 : // try as UCBStorage, next try as OLEStorage
475 0 : sal_Bool bIsUCBStorage = UCBStorage::IsStorageFile( m_pStorStm );
476 0 : if ( !bIsUCBStorage && bForceUCBStorage )
477 : // if UCBStorage has priority, it should not be used only if it is really an OLEStorage
478 0 : bIsUCBStorage = !Storage::IsStorageFile( m_pStorStm );
479 :
480 0 : if ( bIsUCBStorage )
481 : {
482 0 : if ( UCBStorage::GetLinkedFile( *m_pStorStm ).Len() )
483 : {
484 : // detect special unpacked storages
485 0 : m_pOwnStg = new UCBStorage( *m_pStorStm, (nStorageMode & STORAGE_TRANSACTED) ? sal_False : sal_True );
486 0 : m_bDelStm = sal_True;
487 : }
488 : else
489 : {
490 : // detect special disk spanned storages
491 0 : if ( UCBStorage::IsDiskSpannedFile( m_pStorStm ) )
492 0 : nMode |= STORAGE_DISKSPANNED_MODE;
493 :
494 : // UCBStorage always works directly on the UCB content, so discard the stream first
495 0 : DELETEZ( m_pStorStm );
496 0 : m_pOwnStg = new UCBStorage( m_aName, nMode, (nStorageMode & STORAGE_TRANSACTED) ? sal_False : sal_True );
497 : }
498 : }
499 : else
500 : {
501 : // OLEStorage can be opened with a stream
502 0 : m_pOwnStg = new Storage( *m_pStorStm, (nStorageMode & STORAGE_TRANSACTED) ? sal_False : sal_True );
503 0 : m_bDelStm = sal_True;
504 : }
505 : }
506 0 : else if ( bForceUCBStorage )
507 : {
508 0 : m_pOwnStg = new UCBStorage( m_aName, nMode, (nStorageMode & STORAGE_TRANSACTED) ? sal_False : sal_True );
509 0 : SetError( ERRCODE_IO_NOTSUPPORTED );
510 : }
511 : else
512 : {
513 0 : m_pOwnStg = new Storage( m_aName, nMode, (nStorageMode & STORAGE_TRANSACTED) ? sal_False : sal_True );
514 0 : SetError( ERRCODE_IO_NOTSUPPORTED );
515 : }
516 0 : }
517 : }
518 : else
519 : {
520 : // temporary storage
521 243 : if ( bForceUCBStorage )
522 243 : m_pOwnStg = new UCBStorage( m_aName, nMode, (nStorageMode & STORAGE_TRANSACTED) ? sal_False : sal_True );
523 : else
524 0 : m_pOwnStg = new Storage( m_aName, nMode, (nStorageMode & STORAGE_TRANSACTED) ? sal_False : sal_True );
525 243 : m_aName = m_pOwnStg->GetName();
526 : }
527 :
528 243 : SetError( m_pOwnStg->GetError() );
529 :
530 243 : SignAsRoot( m_pOwnStg->IsRoot() );
531 243 : }
532 :
533 0 : SotStorage::SotStorage( sal_Bool bUCBStorage, const String & rName, StreamMode nMode, StorageMode nStorageMode )
534 0 : INIT_SotStorage()
535 : {
536 0 : m_aName = rName;
537 0 : CreateStorage( bUCBStorage, nMode, nStorageMode );
538 0 : if ( IsOLEStorage() )
539 0 : m_nVersion = SOFFICE_FILEFORMAT_50;
540 0 : }
541 :
542 22 : SotStorage::SotStorage( BaseStorage * pStor )
543 22 : INIT_SotStorage()
544 : {
545 22 : if ( pStor )
546 : {
547 22 : m_aName = pStor->GetName(); // Namen merken
548 22 : SignAsRoot( pStor->IsRoot() );
549 22 : SetError( pStor->GetError() );
550 : }
551 :
552 22 : m_pOwnStg = pStor;
553 22 : sal_uLong nErr = m_pOwnStg ? m_pOwnStg->GetError() : SVSTREAM_CANNOT_MAKE;
554 22 : SetError( nErr );
555 22 : if ( IsOLEStorage() )
556 22 : m_nVersion = SOFFICE_FILEFORMAT_50;
557 22 : }
558 :
559 0 : SotStorage::SotStorage( sal_Bool bUCBStorage, SvStream & rStm )
560 0 : INIT_SotStorage()
561 : {
562 0 : SetError( rStm.GetError() );
563 :
564 : // try as UCBStorage, next try as OLEStorage
565 0 : if ( UCBStorage::IsStorageFile( &rStm ) || bUCBStorage )
566 0 : m_pOwnStg = new UCBStorage( rStm, sal_False );
567 : else
568 0 : m_pOwnStg = new Storage( rStm, sal_False );
569 :
570 0 : SetError( m_pOwnStg->GetError() );
571 :
572 0 : if ( IsOLEStorage() )
573 0 : m_nVersion = SOFFICE_FILEFORMAT_50;
574 :
575 0 : SignAsRoot( m_pOwnStg->IsRoot() );
576 0 : }
577 :
578 37 : SotStorage::SotStorage( SvStream & rStm )
579 37 : INIT_SotStorage()
580 : {
581 37 : SetError( rStm.GetError() );
582 :
583 : // try as UCBStorage, next try as OLEStorage
584 37 : if ( UCBStorage::IsStorageFile( &rStm ) )
585 0 : m_pOwnStg = new UCBStorage( rStm, sal_False );
586 : else
587 37 : m_pOwnStg = new Storage( rStm, sal_False );
588 :
589 37 : SetError( m_pOwnStg->GetError() );
590 :
591 37 : if ( IsOLEStorage() )
592 37 : m_nVersion = SOFFICE_FILEFORMAT_50;
593 :
594 37 : SignAsRoot( m_pOwnStg->IsRoot() );
595 37 : }
596 :
597 38 : SotStorage::SotStorage( SvStream * pStm, sal_Bool bDelete )
598 38 : INIT_SotStorage()
599 : {
600 38 : SetError( pStm->GetError() );
601 :
602 : // try as UCBStorage, next try as OLEStorage
603 38 : if ( UCBStorage::IsStorageFile( pStm ) )
604 0 : m_pOwnStg = new UCBStorage( *pStm, sal_False );
605 : else
606 38 : m_pOwnStg = new Storage( *pStm, sal_False );
607 :
608 38 : SetError( m_pOwnStg->GetError() );
609 :
610 38 : m_pStorStm = pStm;
611 38 : m_bDelStm = bDelete;
612 38 : if ( IsOLEStorage() )
613 38 : m_nVersion = SOFFICE_FILEFORMAT_50;
614 :
615 38 : SignAsRoot( m_pOwnStg->IsRoot() );
616 38 : }
617 :
618 : /*************************************************************************
619 : |* SotStorage::~SotStorage()
620 : |*
621 : |* Beschreibung
622 : *************************************************************************/
623 1700 : SotStorage::~SotStorage()
624 : {
625 340 : delete m_pOwnStg;
626 340 : if( m_bDelStm )
627 3 : delete m_pStorStm;
628 1360 : }
629 :
630 : /*************************************************************************
631 : |* SotStorage::CreateMemoryStream()
632 : |*
633 : |* Beschreibung
634 : *************************************************************************/
635 0 : SvMemoryStream * SotStorage::CreateMemoryStream()
636 : {
637 0 : SvMemoryStream * pStm = NULL;
638 0 : pStm = new SvMemoryStream( 0x8000, 0x8000 );
639 0 : SotStorageRef aStg = new SotStorage( *pStm );
640 0 : if( CopyTo( aStg ) )
641 0 : aStg->Commit();
642 : else
643 : {
644 0 : aStg.Clear(); // Storage vorher freigeben
645 0 : delete pStm;
646 0 : pStm = NULL;
647 : }
648 0 : return pStm;
649 : }
650 :
651 : /*************************************************************************
652 : |* SotStorage::GetStorage()
653 : |*
654 : |* Beschreibung
655 : *************************************************************************/
656 1 : sal_Bool SotStorage::IsStorageFile( const String & rFileName )
657 : {
658 1 : String aName( rFileName );
659 1 : INetURLObject aObj( aName );
660 1 : if ( aObj.GetProtocol() == INET_PROT_NOT_VALID )
661 : {
662 0 : rtl::OUString aURL;
663 0 : ::utl::LocalFileHelper::ConvertPhysicalNameToURL( aName, aURL );
664 0 : aObj.SetURL( aURL );
665 0 : aName = aObj.GetMainURL( INetURLObject::NO_DECODE );
666 : }
667 :
668 1 : SvStream * pStm = ::utl::UcbStreamHelper::CreateStream( aName, STREAM_STD_READ );
669 1 : sal_Bool bRet = SotStorage::IsStorageFile( pStm );
670 1 : delete pStm;
671 1 : return bRet;
672 : }
673 :
674 369 : sal_Bool SotStorage::IsStorageFile( SvStream* pStream )
675 : {
676 : /** code for new storages must come first! **/
677 369 : if ( pStream )
678 : {
679 369 : long nPos = pStream->Tell();
680 369 : sal_Bool bRet = UCBStorage::IsStorageFile( pStream );
681 369 : if ( !bRet )
682 352 : bRet = Storage::IsStorageFile( pStream );
683 369 : pStream->Seek( nPos );
684 369 : return bRet;
685 : }
686 : else
687 0 : return sal_False;
688 : }
689 : /*************************************************************************
690 : |* SotStorage::GetStorage()
691 : |*
692 : |* Beschreibung
693 : *************************************************************************/
694 243 : const String & SotStorage::GetName() const
695 : {
696 243 : if( !m_aName.Len() )
697 : {
698 : DBG_ASSERT( Owner(), "must be owner" );
699 0 : if( m_pOwnStg )
700 0 : ((SotStorage *)this)->m_aName = m_pOwnStg->GetName();
701 : }
702 243 : return m_aName;
703 : }
704 :
705 6 : const rtl::OString& SotStorage::GetKey() const
706 : {
707 6 : return m_aKey;
708 : }
709 :
710 : /*************************************************************************
711 : |* SotStorage::ResetError()
712 : |*
713 : |* Beschreibung
714 : *************************************************************************/
715 0 : void SotStorage::ResetError()
716 : {
717 0 : m_nError = SVSTREAM_OK;
718 0 : if( m_pOwnStg )
719 0 : m_pOwnStg->ResetError();
720 0 : }
721 :
722 : /*************************************************************************
723 : |* SotStorage::SetClass()
724 : |* SotStorage::SetConvertClass()
725 : |*
726 : |* Beschreibung
727 : *************************************************************************/
728 0 : void SotStorage::SetClass( const SvGlobalName & rName,
729 : sal_uLong nOriginalClipFormat,
730 : const String & rUserTypeName )
731 : {
732 : DBG_ASSERT( Owner(), "must be owner" );
733 0 : if( m_pOwnStg )
734 0 : m_pOwnStg->SetClass( rName, nOriginalClipFormat, rUserTypeName );
735 : else
736 0 : SetError( SVSTREAM_GENERALERROR );
737 0 : }
738 :
739 0 : void SotStorage::SetConvertClass( const SvGlobalName & rName,
740 : sal_uLong nOriginalClipFormat,
741 : const String & rUserTypeName )
742 : {
743 : DBG_ASSERT( Owner(), "must be owner" );
744 0 : if( m_pOwnStg )
745 0 : m_pOwnStg->SetConvertClass( rName, nOriginalClipFormat, rUserTypeName );
746 : else
747 0 : SetError( SVSTREAM_GENERALERROR );
748 0 : }
749 :
750 : /*************************************************************************
751 : |* SotStorage::GetClassName()
752 : |* SotStorage::GetFormat()
753 : |* SotStorage::GetUserName()
754 : |* SotStorage::ShouldConvert()
755 : |*
756 : |* Beschreibung
757 : *************************************************************************/
758 6 : SvGlobalName SotStorage::GetClassName()
759 : {
760 6 : SvGlobalName aGN;
761 : DBG_ASSERT( Owner(), "must be owner" );
762 6 : if( m_pOwnStg )
763 6 : aGN = m_pOwnStg->GetClassName();
764 : else
765 0 : SetError( SVSTREAM_GENERALERROR );
766 6 : return aGN;
767 : }
768 :
769 8 : sal_uLong SotStorage::GetFormat()
770 : {
771 8 : sal_uLong nFormat = 0;
772 : DBG_ASSERT( Owner(), "must be owner" );
773 8 : if( m_pOwnStg )
774 8 : nFormat = m_pOwnStg->GetFormat();
775 : else
776 0 : SetError( SVSTREAM_GENERALERROR );
777 8 : return nFormat;
778 : }
779 :
780 0 : String SotStorage::GetUserName()
781 : {
782 0 : String aName;
783 : DBG_ASSERT( Owner(), "must be owner" );
784 0 : if( m_pOwnStg )
785 0 : aName = m_pOwnStg->GetUserName();
786 : else
787 0 : SetError( SVSTREAM_GENERALERROR );
788 0 : return aName;
789 : }
790 :
791 0 : sal_Bool SotStorage::ShouldConvert()
792 : {
793 : DBG_ASSERT( Owner(), "must be owner" );
794 0 : if( m_pOwnStg )
795 0 : return m_pOwnStg->ShouldConvert();
796 : else
797 0 : SetError( SVSTREAM_GENERALERROR );
798 0 : return sal_False;
799 : }
800 :
801 : /*************************************************************************
802 : |* SotStorage::FillInfoList()
803 : |*
804 : |* Beschreibung
805 : *************************************************************************/
806 14 : void SotStorage::FillInfoList( SvStorageInfoList * pFillList ) const
807 : {
808 : DBG_ASSERT( Owner(), "must be owner" );
809 14 : if( m_pOwnStg )
810 14 : m_pOwnStg->FillInfoList( pFillList );
811 14 : }
812 :
813 : /*************************************************************************
814 : |* SotStorage::CopyTo()
815 : |*
816 : |* Beschreibung
817 : *************************************************************************/
818 3 : sal_Bool SotStorage::CopyTo( SotStorage * pDestStg )
819 : {
820 : DBG_ASSERT( Owner(), "must be owner" );
821 : DBG_ASSERT( pDestStg->Owner(), "must be owner" );
822 3 : if( m_pOwnStg && pDestStg->m_pOwnStg )
823 : {
824 3 : m_pOwnStg->CopyTo( pDestStg->m_pOwnStg );
825 3 : SetError( m_pOwnStg->GetError() );
826 3 : pDestStg->m_aKey = m_aKey;
827 3 : pDestStg->m_nVersion = m_nVersion;
828 : }
829 : else
830 0 : SetError( SVSTREAM_GENERALERROR );
831 3 : return SVSTREAM_OK == GetError();
832 : }
833 :
834 : /*************************************************************************
835 : |* SotStorage::Commit()
836 : |*
837 : |* Beschreibung
838 : *************************************************************************/
839 3 : sal_Bool SotStorage::Commit()
840 : {
841 : DBG_ASSERT( Owner(), "must be owner" );
842 3 : if( m_pOwnStg )
843 : {
844 3 : if( !m_pOwnStg->Commit() )
845 0 : SetError( m_pOwnStg->GetError() );
846 : }
847 : else
848 0 : SetError( SVSTREAM_GENERALERROR );
849 3 : return SVSTREAM_OK == GetError();
850 : }
851 :
852 : /*************************************************************************
853 : |* SotStorage::Revert()
854 : |*
855 : |* Beschreibung
856 : *************************************************************************/
857 0 : sal_Bool SotStorage::Revert()
858 : {
859 : DBG_ASSERT( Owner(), "must be owner" );
860 0 : if( m_pOwnStg )
861 : {
862 0 : if( !m_pOwnStg->Revert() )
863 0 : SetError( m_pOwnStg->GetError() );
864 : }
865 : else
866 0 : SetError( SVSTREAM_GENERALERROR );
867 0 : return SVSTREAM_OK == GetError();
868 : }
869 :
870 402 : SotStorageStream * SotStorage::OpenSotStream( const String & rEleName,
871 : StreamMode nMode,
872 : StorageMode nStorageMode )
873 : {
874 : DBG_ASSERT( !nStorageMode, "StorageModes ignored" );
875 402 : SotStorageStream * pStm = NULL;
876 : DBG_ASSERT( Owner(), "must be owner" );
877 402 : if( m_pOwnStg )
878 : {
879 : // volle Ole-Patches einschalten
880 : // egal was kommt, nur exclusiv gestattet
881 402 : nMode |= STREAM_SHARE_DENYALL;
882 402 : ErrCode nE = m_pOwnStg->GetError();
883 : BaseStorageStream * p = m_pOwnStg->OpenStream( rEleName, nMode,
884 402 : (nStorageMode & STORAGE_TRANSACTED) ? sal_False : sal_True );
885 402 : pStm = new SotStorageStream( p );
886 :
887 402 : if( !nE )
888 402 : m_pOwnStg->ResetError(); // kein Fehler setzen
889 402 : if( nMode & STREAM_TRUNC )
890 0 : pStm->SetSize( 0 );
891 : }
892 : else
893 0 : SetError( SVSTREAM_GENERALERROR );
894 402 : return pStm;
895 : }
896 :
897 : /*************************************************************************
898 : |* SotStorage::OpenStorage()
899 : |*
900 : |* Beschreibung
901 : *************************************************************************/
902 19 : SotStorage * SotStorage::OpenSotStorage( const String & rEleName,
903 : StreamMode nMode,
904 : StorageMode nStorageMode )
905 : {
906 19 : SotStorage * pStor = NULL;
907 : DBG_ASSERT( Owner(), "must be owner" );
908 19 : if( m_pOwnStg )
909 : {
910 19 : nMode |= STREAM_SHARE_DENYALL;
911 19 : ErrCode nE = m_pOwnStg->GetError();
912 : BaseStorage * p = m_pOwnStg->OpenStorage( rEleName, nMode,
913 19 : (nStorageMode & STORAGE_TRANSACTED) ? sal_False : sal_True );
914 19 : if( p )
915 : {
916 19 : pStor = new SotStorage( p );
917 19 : if( !nE )
918 19 : m_pOwnStg->ResetError(); // kein Fehler setzen
919 :
920 19 : return pStor;
921 : }
922 : }
923 :
924 0 : SetError( SVSTREAM_GENERALERROR );
925 :
926 0 : return NULL;
927 : }
928 :
929 : /*************************************************************************
930 : |* SotStorage::IsStream()
931 : |* SotStorage::IsStorage()
932 : |* SotStorage::IsContained()
933 : |*
934 : |* Beschreibung
935 : *************************************************************************/
936 0 : sal_Bool SotStorage::IsStorage( const String & rEleName ) const
937 : {
938 : DBG_ASSERT( Owner(), "must be owner" );
939 : // ein bisschen schneller
940 0 : if( m_pOwnStg )
941 0 : return m_pOwnStg->IsStorage( rEleName );
942 0 : return sal_False;
943 : }
944 :
945 519 : sal_Bool SotStorage::IsStream( const String & rEleName ) const
946 : {
947 : DBG_ASSERT( Owner(), "must be owner" );
948 : // ein bisschen schneller
949 519 : if( m_pOwnStg )
950 519 : return m_pOwnStg->IsStream( rEleName );
951 0 : return sal_False;
952 : }
953 :
954 100 : sal_Bool SotStorage::IsContained( const String & rEleName ) const
955 : {
956 : DBG_ASSERT( Owner(), "must be owner" );
957 : // ein bisschen schneller
958 100 : if( m_pOwnStg )
959 100 : return m_pOwnStg->IsContained( rEleName );
960 0 : return sal_False;
961 : }
962 :
963 : /*************************************************************************
964 : |* SotStorage::Remove()
965 : |*
966 : |* Beschreibung
967 : *************************************************************************/
968 0 : sal_Bool SotStorage::Remove( const String & rEleName )
969 : {
970 : DBG_ASSERT( Owner(), "must be owner" );
971 0 : if( m_pOwnStg )
972 : {
973 0 : m_pOwnStg->Remove( rEleName );
974 0 : SetError( m_pOwnStg->GetError() );
975 : }
976 : else
977 0 : SetError( SVSTREAM_GENERALERROR );
978 0 : return SVSTREAM_OK == GetError();
979 : }
980 :
981 : /*************************************************************************
982 : |* SotStorage::Rename()
983 : |*
984 : |* Beschreibung
985 : *************************************************************************/
986 0 : sal_Bool SotStorage::Rename( const String & rEleName, const String & rNewName )
987 : {
988 : DBG_ASSERT( Owner(), "must be owner" );
989 0 : if( m_pOwnStg )
990 : {
991 0 : m_pOwnStg->Rename( rEleName, rNewName );
992 0 : SetError( m_pOwnStg->GetError() );
993 : }
994 : else
995 0 : SetError( SVSTREAM_GENERALERROR );
996 0 : return SVSTREAM_OK == GetError();
997 : }
998 :
999 : /*************************************************************************
1000 : |* SotStorage::CopyTo()
1001 : |*
1002 : |* Beschreibung
1003 : *************************************************************************/
1004 0 : sal_Bool SotStorage::CopyTo( const String & rEleName,
1005 : SotStorage * pNewSt, const String & rNewName )
1006 : {
1007 : DBG_ASSERT( Owner(), "must be owner" );
1008 : DBG_ASSERT( pNewSt->Owner(), "must be owner" );
1009 0 : if( m_pOwnStg )
1010 : {
1011 0 : m_pOwnStg->CopyTo( rEleName, pNewSt->m_pOwnStg, rNewName );
1012 0 : SetError( m_pOwnStg->GetError() );
1013 0 : SetError( pNewSt->GetError() );
1014 : }
1015 : else
1016 0 : SetError( SVSTREAM_GENERALERROR );
1017 0 : return SVSTREAM_OK == GetError();
1018 : }
1019 :
1020 : /*************************************************************************
1021 : |* SotStorage::MoveTo()
1022 : |*
1023 : |* Beschreibung
1024 : *************************************************************************/
1025 0 : sal_Bool SotStorage::MoveTo( const String & rEleName,
1026 : SotStorage * pNewSt, const String & rNewName )
1027 : {
1028 : DBG_ASSERT( Owner(), "must be owner" );
1029 : DBG_ASSERT( pNewSt->Owner(), "must be owner" );
1030 0 : if( m_pOwnStg )
1031 : {
1032 0 : m_pOwnStg->MoveTo( rEleName, pNewSt->m_pOwnStg, rNewName );
1033 0 : SetError( m_pOwnStg->GetError() );
1034 0 : SetError( pNewSt->GetError() );
1035 : }
1036 : else
1037 0 : SetError( SVSTREAM_GENERALERROR );
1038 0 : return SVSTREAM_OK == GetError();
1039 : }
1040 :
1041 4 : sal_Bool SotStorage::Validate()
1042 : {
1043 : DBG_ASSERT( m_bIsRoot, "Validate nur an Rootstorage" );
1044 4 : if( m_pOwnStg )
1045 4 : return m_pOwnStg->ValidateFAT();
1046 : else
1047 0 : return sal_True;
1048 : }
1049 :
1050 340 : sal_Bool SotStorage::IsOLEStorage() const
1051 : {
1052 340 : UCBStorage* pStg = PTR_CAST( UCBStorage, m_pOwnStg );
1053 340 : return !pStg;
1054 : }
1055 :
1056 0 : sal_Bool SotStorage::IsOLEStorage( const String & rFileName )
1057 : {
1058 0 : return Storage::IsStorageFile( rFileName );
1059 : }
1060 :
1061 58 : sal_Bool SotStorage::IsOLEStorage( SvStream* pStream )
1062 : {
1063 58 : return Storage::IsStorageFile( pStream );
1064 : }
1065 :
1066 3 : SotStorage* SotStorage::OpenOLEStorage( const com::sun::star::uno::Reference < com::sun::star::embed::XStorage >& xStorage,
1067 : const String& rEleName, StreamMode nMode )
1068 : {
1069 3 : sal_Int32 nEleMode = embed::ElementModes::SEEKABLEREAD;
1070 3 : if ( nMode & STREAM_WRITE )
1071 3 : nEleMode |= embed::ElementModes::WRITE;
1072 3 : if ( nMode & STREAM_TRUNC )
1073 0 : nEleMode |= embed::ElementModes::TRUNCATE;
1074 3 : if ( nMode & STREAM_NOCREATE )
1075 0 : nEleMode |= embed::ElementModes::NOCREATE;
1076 :
1077 3 : SvStream* pStream = NULL;
1078 : try
1079 : {
1080 3 : uno::Reference < io::XStream > xStream = xStorage->openStreamElement( rEleName, nEleMode );
1081 :
1082 : // TODO/LATER: should it be done this way?
1083 3 : if ( nMode & STREAM_WRITE )
1084 : {
1085 3 : uno::Reference < beans::XPropertySet > xStreamProps( xStream, uno::UNO_QUERY_THROW );
1086 3 : xStreamProps->setPropertyValue(
1087 : ::rtl::OUString( "MediaType" ),
1088 3 : uno::makeAny( ::rtl::OUString( "application/vnd.sun.star.oleobject" ) ) );
1089 : }
1090 :
1091 3 : pStream = utl::UcbStreamHelper::CreateStream( xStream );
1092 : }
1093 0 : catch ( uno::Exception& )
1094 : {
1095 : //TODO/LATER: ErrorHandling
1096 0 : pStream = new SvMemoryStream;
1097 0 : pStream->SetError( ERRCODE_IO_GENERAL );
1098 : }
1099 :
1100 3 : return new SotStorage( pStream, sal_True );
1101 : }
1102 :
1103 1052 : sal_Int32 SotStorage::GetFormatID( const com::sun::star::uno::Reference < com::sun::star::embed::XStorage >& xStorage )
1104 : {
1105 1052 : uno::Reference< beans::XPropertySet > xProps( xStorage, uno::UNO_QUERY );
1106 1052 : if ( !xProps.is() )
1107 0 : return 0;
1108 :
1109 1052 : ::rtl::OUString aMediaType;
1110 1052 : xProps->getPropertyValue( ::rtl::OUString("MediaType") ) >>= aMediaType;
1111 1052 : if ( !aMediaType.isEmpty() )
1112 : {
1113 1052 : ::com::sun::star::datatransfer::DataFlavor aDataFlavor;
1114 1052 : aDataFlavor.MimeType = aMediaType;
1115 1052 : return SotExchange::GetFormat( aDataFlavor );
1116 : }
1117 :
1118 0 : return 0;
1119 : }
1120 :
1121 1052 : sal_Int32 SotStorage::GetVersion( const com::sun::star::uno::Reference < com::sun::star::embed::XStorage >& xStorage )
1122 : {
1123 1052 : sal_Int32 nSotFormatID = SotStorage::GetFormatID( xStorage );
1124 1052 : switch( nSotFormatID )
1125 : {
1126 : case SOT_FORMATSTR_ID_STARWRITER_8:
1127 : case SOT_FORMATSTR_ID_STARWRITER_8_TEMPLATE:
1128 : case SOT_FORMATSTR_ID_STARWRITERWEB_8:
1129 : case SOT_FORMATSTR_ID_STARWRITERGLOB_8:
1130 : case SOT_FORMATSTR_ID_STARDRAW_8:
1131 : case SOT_FORMATSTR_ID_STARDRAW_8_TEMPLATE:
1132 : case SOT_FORMATSTR_ID_STARIMPRESS_8:
1133 : case SOT_FORMATSTR_ID_STARIMPRESS_8_TEMPLATE:
1134 : case SOT_FORMATSTR_ID_STARCALC_8:
1135 : case SOT_FORMATSTR_ID_STARCALC_8_TEMPLATE:
1136 : case SOT_FORMATSTR_ID_STARCHART_8:
1137 : case SOT_FORMATSTR_ID_STARCHART_8_TEMPLATE:
1138 : case SOT_FORMATSTR_ID_STARMATH_8:
1139 : case SOT_FORMATSTR_ID_STARMATH_8_TEMPLATE:
1140 1051 : return SOFFICE_FILEFORMAT_8;
1141 : case SOT_FORMATSTR_ID_STARWRITER_60:
1142 : case SOT_FORMATSTR_ID_STARWRITERWEB_60:
1143 : case SOT_FORMATSTR_ID_STARWRITERGLOB_60:
1144 : case SOT_FORMATSTR_ID_STARDRAW_60:
1145 : case SOT_FORMATSTR_ID_STARIMPRESS_60:
1146 : case SOT_FORMATSTR_ID_STARCALC_60:
1147 : case SOT_FORMATSTR_ID_STARCHART_60:
1148 : case SOT_FORMATSTR_ID_STARMATH_60:
1149 1 : return SOFFICE_FILEFORMAT_60;
1150 : }
1151 :
1152 0 : return 0;
1153 : }
1154 :
1155 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
