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/debug.hxx>
35 : #include <tools/urlobj.hxx>
36 : #include <unotools/localfilehelper.hxx>
37 : #include <unotools/ucbhelper.hxx>
38 : #include <comphelper/processfactory.hxx>
39 : #include <boost/scoped_array.hpp>
40 : #include <boost/scoped_ptr.hpp>
41 :
42 : using namespace ::com::sun::star;
43 :
44 : /************** class SotStorageStream ***********************************/
45 0 : class SotStorageStreamFactory : public SotFactory
46 : {
47 : public:
48 : TYPEINFO_OVERRIDE();
49 0 : SotStorageStreamFactory( const SvGlobalName & rName,
50 : const OUString & 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 0 : SvLockBytesRef MakeLockBytes_Impl( const OUString & rName, StreamMode nMode )
63 : {
64 0 : SvLockBytesRef xLB;
65 0 : if( !rName.isEmpty() )
66 : {
67 0 : SvStream * pFileStm = new SvFileStream( rName, nMode );
68 0 : xLB = new SvLockBytes( pFileStm, true );
69 : }
70 : else
71 : {
72 0 : SvStream * pCacheStm = new SvMemoryStream();
73 0 : xLB = new SvLockBytes( pCacheStm, true );
74 : }
75 0 : return xLB;
76 : }
77 :
78 0 : SotStorageStream::SotStorageStream( const OUString & rName, StreamMode nMode )
79 : : SvStream( MakeLockBytes_Impl( rName, nMode ) )
80 0 : , pOwnStm( NULL )
81 : {
82 0 : if( nMode & StreamMode::WRITE )
83 0 : bIsWritable = true;
84 : else
85 0 : bIsWritable = false;
86 0 : }
87 :
88 1574 : SotStorageStream::SotStorageStream( BaseStorageStream * pStm )
89 : {
90 1574 : if( pStm )
91 : {
92 1574 : if( StreamMode::WRITE & pStm->GetMode() )
93 478 : bIsWritable = true;
94 : else
95 1096 : bIsWritable = false;
96 :
97 1574 : pOwnStm = pStm;
98 1574 : SetError( pStm->GetError() );
99 1574 : pStm->ResetError();
100 : }
101 : else
102 : {
103 0 : pOwnStm = NULL;
104 0 : bIsWritable = true;
105 0 : SetError( SVSTREAM_INVALID_PARAMETER );
106 : }
107 1574 : }
108 :
109 0 : SotStorageStream::SotStorageStream()
110 0 : : pOwnStm( NULL )
111 : {
112 : // ??? wenn Init virtuell ist, entsprechen setzen
113 0 : bIsWritable = true;
114 0 : }
115 :
116 6296 : SotStorageStream::~SotStorageStream()
117 : {
118 1574 : Flush(); //SetBufferSize(0);
119 1574 : delete pOwnStm;
120 4722 : }
121 :
122 0 : void SotStorageStream::ResetError()
123 : {
124 0 : SvStream::ResetError();
125 0 : if( pOwnStm )
126 0 : pOwnStm->ResetError();
127 0 : }
128 :
129 1578407 : sal_uLong SotStorageStream::GetData( void* pData, sal_uLong nSize )
130 : {
131 1578407 : sal_uLong nRet = 0;
132 :
133 1578407 : if( pOwnStm )
134 : {
135 1578407 : nRet = pOwnStm->Read( pData, nSize );
136 1578407 : SetError( pOwnStm->GetError() );
137 : }
138 : else
139 0 : nRet = SvStream::GetData( pData, nSize );
140 :
141 1578407 : return nRet;
142 : }
143 :
144 22489 : sal_uLong SotStorageStream::PutData( const void* pData, sal_uLong nSize )
145 : {
146 22489 : sal_uLong nRet = 0;
147 :
148 22489 : if( pOwnStm )
149 : {
150 22489 : nRet = pOwnStm->Write( pData, nSize );
151 22489 : SetError( pOwnStm->GetError() );
152 : }
153 : else
154 0 : nRet = SvStream::PutData( pData, nSize );
155 22489 : return nRet;
156 : }
157 :
158 1271748 : sal_uInt64 SotStorageStream::SeekPos(sal_uInt64 nPos)
159 : {
160 1271748 : sal_uLong nRet = 0;
161 :
162 1271748 : if( pOwnStm )
163 : {
164 1271748 : nRet = pOwnStm->Seek( nPos );
165 1271748 : SetError( pOwnStm->GetError() );
166 : }
167 : else
168 0 : nRet = SvStream::SeekPos( nPos );
169 :
170 1271748 : return nRet;
171 : }
172 :
173 568 : void SotStorageStream::FlushData()
174 : {
175 568 : if( pOwnStm )
176 : {
177 568 : pOwnStm->Flush();
178 568 : SetError( pOwnStm->GetError() );
179 : }
180 : else
181 0 : SvStream::FlushData();
182 568 : }
183 :
184 123 : void SotStorageStream::SetSize(sal_uInt64 const nNewSize)
185 : {
186 123 : sal_uInt64 const nPos = Tell();
187 123 : if( pOwnStm )
188 : {
189 123 : pOwnStm->SetSize( nNewSize );
190 123 : SetError( pOwnStm->GetError() );
191 : }
192 : else
193 0 : SvStream::SetSize( nNewSize );
194 :
195 123 : if( nNewSize < nPos )
196 : // ans Ende setzen
197 0 : Seek( nNewSize );
198 123 : }
199 :
200 69 : sal_uInt32 SotStorageStream::GetSize() const
201 : {
202 69 : sal_uLong nPos = Tell();
203 69 : const_cast<SotStorageStream *>(this)->Seek( STREAM_SEEK_TO_END );
204 69 : sal_uLong nSize = Tell();
205 69 : const_cast<SotStorageStream *>(this)->Seek( nPos );
206 69 : return nSize;
207 : }
208 :
209 13297 : sal_uInt64 SotStorageStream::remainingSize()
210 : {
211 13297 : if (pOwnStm)
212 13297 : return pOwnStm->GetSize() - Tell();
213 :
214 0 : return SvStream::remainingSize();
215 : }
216 :
217 0 : bool SotStorageStream::CopyTo( SotStorageStream * pDestStm )
218 : {
219 0 : Flush(); // alle Daten schreiben
220 0 : pDestStm->ClearBuffer();
221 0 : if( !pOwnStm || !pDestStm->pOwnStm )
222 : {
223 : // Wenn Ole2 oder nicht nur eigene StorageStreams
224 0 : sal_uLong nPos = Tell(); // Position merken
225 0 : Seek( 0L );
226 0 : pDestStm->SetSize( 0 ); // Ziel-Stream leeren
227 :
228 0 : boost::scoped_array<sal_uInt8> pMem(new sal_uInt8[ 8192 ]);
229 : sal_uLong nRead;
230 0 : while( 0 != (nRead = Read( pMem.get(), 8192 )) )
231 : {
232 0 : if( nRead != pDestStm->Write( pMem.get(), nRead ) )
233 : {
234 0 : SetError( SVSTREAM_GENERALERROR );
235 0 : break;
236 : }
237 : }
238 0 : pMem.reset();
239 : // Position setzen
240 0 : pDestStm->Seek( nPos );
241 0 : Seek( nPos );
242 : }
243 : else
244 : {
245 0 : pOwnStm->CopyTo( pDestStm->pOwnStm );
246 0 : SetError( pOwnStm->GetError() );
247 : }
248 0 : return GetError() == SVSTREAM_OK;
249 : }
250 :
251 19 : bool SotStorageStream::Commit()
252 : {
253 19 : if( pOwnStm )
254 : {
255 19 : pOwnStm->Flush();
256 19 : if( pOwnStm->GetError() == SVSTREAM_OK )
257 19 : pOwnStm->Commit();
258 19 : SetError( pOwnStm->GetError() );
259 : }
260 19 : return GetError() == SVSTREAM_OK;
261 : }
262 :
263 0 : bool SotStorageStream::SetProperty( const OUString& rName, const ::com::sun::star::uno::Any& rValue )
264 : {
265 0 : UCBStorageStream* pStg = PTR_CAST( UCBStorageStream, pOwnStm );
266 0 : if ( pStg )
267 : {
268 0 : return pStg->SetProperty( rName, rValue );
269 : }
270 : else
271 : {
272 : OSL_FAIL("Not implemented!");
273 0 : return false;
274 : }
275 : }
276 :
277 : /************** class SotStorage ******************************************
278 : *************************************************************************/
279 0 : class SotStorageFactory : public SotFactory
280 : {
281 : public:
282 : TYPEINFO_OVERRIDE();
283 0 : SotStorageFactory( const SvGlobalName & rName,
284 : const OUString & rClassName,
285 : CreateInstanceType pCreateFuncP )
286 0 : : SotFactory( rName, rClassName, pCreateFuncP )
287 0 : {}
288 : };
289 0 : TYPEINIT1(SotStorageFactory,SotFactory);
290 :
291 :
292 0 : SO2_IMPL_BASIC_CLASS1_DLL(SotStorage,SotStorageFactory,SotObject,
293 : SvGlobalName( 0x980ce7e0, 0xf905, 0x11d0,
294 : 0xaa, 0xa1, 0x0, 0xa0, 0x24, 0x9d, 0x55, 0x90 ) )
295 :
296 : /************************************************************************
297 : |*
298 : |* SotStorage::SotStorage()
299 : |*
300 : |* Beschreibung Es muss ein I... Objekt an SvObject uebergeben
301 : |* werden, da es sonst selbst ein IUnknown anlegt und
302 : |* festlegt, dass alle weiteren I... Objekte mit
303 : |* delete zerstoert werden (Owner() == true).
304 : |* Es werden aber nur IStorage Objekte benutzt und nicht
305 : |* selbst implementiert, deshalb wird so getan, als ob
306 : |* das IStorage Objekt von aussen kam und es wird mit
307 : |* Release() freigegeben.
308 : |* Die CreateStorage Methoden werden benoetigt, um
309 : |* ein IStorage Objekt vor dem Aufruf von SvObject
310 : |* zu erzeugen (Own, !Own automatik).
311 : |* Hat CreateStorage ein Objekt erzeugt, dann wurde
312 : |* der RefCounter schon um 1 erhoet.
313 : |* Die Uebergabe erfolgt in pStorageCTor. Die Variable
314 : |* ist NULL, wenn es nicht geklappt hat.
315 : |*
316 : *************************************************************************/
317 : #define INIT_SotStorage() \
318 : : m_pOwnStg( NULL ) \
319 : , m_pStorStm( NULL ) \
320 : , m_nError( SVSTREAM_OK ) \
321 : , m_bIsRoot( false ) \
322 : , m_bDelStm( false ) \
323 : , m_nVersion( SOFFICE_FILEFORMAT_CURRENT )
324 :
325 0 : SotStorage::SotStorage()
326 0 : INIT_SotStorage()
327 : {
328 : // ??? What's this ???
329 0 : }
330 :
331 : #define ERASEMASK ( StreamMode::TRUNC | StreamMode::WRITE | StreamMode::SHARE_DENYALL )
332 : #include <com/sun/star/uno/Reference.h>
333 : #include <com/sun/star/ucb/XCommandEnvironment.hpp>
334 : #include <ucbhelper/content.hxx>
335 :
336 2006 : SotStorage::SotStorage( const OUString & rName, StreamMode nMode, bool transacted )
337 2006 : INIT_SotStorage()
338 : {
339 2006 : m_aName = rName; // Namen merken
340 2006 : CreateStorage( true, nMode, transacted );
341 2006 : if ( IsOLEStorage() )
342 0 : m_nVersion = SOFFICE_FILEFORMAT_50;
343 2006 : }
344 :
345 2028 : void SotStorage::CreateStorage( bool bForceUCBStorage, StreamMode nMode, bool transacted )
346 : {
347 : DBG_ASSERT( !m_pStorStm && !m_pOwnStg, "Use only in ctor!" );
348 2028 : if( !m_aName.isEmpty() )
349 : {
350 : // named storage
351 22 : if( ( ( nMode & ERASEMASK ) == ERASEMASK ) )
352 0 : ::utl::UCBContentHelper::Kill( m_aName );
353 :
354 22 : INetURLObject aObj( m_aName );
355 22 : if ( aObj.GetProtocol() == INetProtocol::NotValid )
356 : {
357 0 : OUString aURL;
358 0 : ::utl::LocalFileHelper::ConvertPhysicalNameToURL( m_aName, aURL );
359 0 : aObj.SetURL( aURL );
360 0 : m_aName = aObj.GetMainURL( INetURLObject::NO_DECODE );
361 : }
362 :
363 : // check the stream
364 22 : m_pStorStm = ::utl::UcbStreamHelper::CreateStream( m_aName, nMode );
365 22 : if ( m_pStorStm && m_pStorStm->GetError() )
366 0 : DELETEZ( m_pStorStm );
367 :
368 22 : if ( m_pStorStm )
369 : {
370 : // try as UCBStorage, next try as OLEStorage
371 22 : bool bIsUCBStorage = UCBStorage::IsStorageFile( m_pStorStm );
372 22 : if ( !bIsUCBStorage && bForceUCBStorage )
373 : // if UCBStorage has priority, it should not be used only if it is really an OLEStorage
374 0 : bIsUCBStorage = !Storage::IsStorageFile( m_pStorStm );
375 :
376 22 : if ( bIsUCBStorage )
377 : {
378 0 : if ( !(UCBStorage::GetLinkedFile( *m_pStorStm ).isEmpty()) )
379 : {
380 : // detect special unpacked storages
381 0 : m_pOwnStg = new UCBStorage( *m_pStorStm, !transacted );
382 0 : m_bDelStm = true;
383 : }
384 : else
385 : {
386 : // UCBStorage always works directly on the UCB content, so discard the stream first
387 0 : DELETEZ( m_pStorStm );
388 0 : m_pOwnStg = new UCBStorage( m_aName, nMode, !transacted );
389 : }
390 : }
391 : else
392 : {
393 : // OLEStorage can be opened with a stream
394 22 : m_pOwnStg = new Storage( *m_pStorStm, !transacted );
395 22 : m_bDelStm = true;
396 : }
397 : }
398 0 : else if ( bForceUCBStorage )
399 : {
400 0 : m_pOwnStg = new UCBStorage( m_aName, nMode, !transacted );
401 0 : SetError( ERRCODE_IO_NOTSUPPORTED );
402 : }
403 : else
404 : {
405 0 : m_pOwnStg = new Storage( m_aName, nMode, !transacted );
406 0 : SetError( ERRCODE_IO_NOTSUPPORTED );
407 22 : }
408 : }
409 : else
410 : {
411 : // temporary storage
412 2006 : if ( bForceUCBStorage )
413 2006 : m_pOwnStg = new UCBStorage( m_aName, nMode, !transacted );
414 : else
415 0 : m_pOwnStg = new Storage( m_aName, nMode, !transacted );
416 2006 : m_aName = m_pOwnStg->GetName();
417 : }
418 :
419 2028 : SetError( m_pOwnStg->GetError() );
420 :
421 2028 : SignAsRoot( m_pOwnStg->IsRoot() );
422 2028 : }
423 :
424 22 : SotStorage::SotStorage( bool bUCBStorage, const OUString & rName, StreamMode nMode )
425 22 : INIT_SotStorage()
426 : {
427 22 : m_aName = rName;
428 22 : CreateStorage( bUCBStorage, nMode, false );
429 22 : if ( IsOLEStorage() )
430 22 : m_nVersion = SOFFICE_FILEFORMAT_50;
431 22 : }
432 :
433 143 : SotStorage::SotStorage( BaseStorage * pStor )
434 143 : INIT_SotStorage()
435 : {
436 143 : if ( pStor )
437 : {
438 143 : m_aName = pStor->GetName(); // Namen merken
439 143 : SignAsRoot( pStor->IsRoot() );
440 143 : SetError( pStor->GetError() );
441 : }
442 :
443 143 : m_pOwnStg = pStor;
444 143 : sal_uLong nErr = m_pOwnStg ? m_pOwnStg->GetError() : SVSTREAM_CANNOT_MAKE;
445 143 : SetError( nErr );
446 143 : if ( IsOLEStorage() )
447 143 : m_nVersion = SOFFICE_FILEFORMAT_50;
448 143 : }
449 :
450 12 : SotStorage::SotStorage( bool bUCBStorage, SvStream & rStm )
451 12 : INIT_SotStorage()
452 : {
453 12 : SetError( rStm.GetError() );
454 :
455 : // try as UCBStorage, next try as OLEStorage
456 12 : if ( UCBStorage::IsStorageFile( &rStm ) || bUCBStorage )
457 0 : m_pOwnStg = new UCBStorage( rStm, false );
458 : else
459 12 : m_pOwnStg = new Storage( rStm, false );
460 :
461 12 : SetError( m_pOwnStg->GetError() );
462 :
463 12 : if ( IsOLEStorage() )
464 12 : m_nVersion = SOFFICE_FILEFORMAT_50;
465 :
466 12 : SignAsRoot( m_pOwnStg->IsRoot() );
467 12 : }
468 :
469 164 : SotStorage::SotStorage( SvStream & rStm )
470 164 : INIT_SotStorage()
471 : {
472 164 : SetError( rStm.GetError() );
473 :
474 : // try as UCBStorage, next try as OLEStorage
475 164 : if ( UCBStorage::IsStorageFile( &rStm ) )
476 0 : m_pOwnStg = new UCBStorage( rStm, false );
477 : else
478 164 : m_pOwnStg = new Storage( rStm, false );
479 :
480 164 : SetError( m_pOwnStg->GetError() );
481 :
482 164 : if ( IsOLEStorage() )
483 164 : m_nVersion = SOFFICE_FILEFORMAT_50;
484 :
485 164 : SignAsRoot( m_pOwnStg->IsRoot() );
486 164 : }
487 :
488 1702 : SotStorage::SotStorage( SvStream * pStm, bool bDelete )
489 1702 : INIT_SotStorage()
490 : {
491 1702 : SetError( pStm->GetError() );
492 :
493 : // try as UCBStorage, next try as OLEStorage
494 1702 : if ( UCBStorage::IsStorageFile( pStm ) )
495 30 : m_pOwnStg = new UCBStorage( *pStm, false );
496 : else
497 1672 : m_pOwnStg = new Storage( *pStm, false );
498 :
499 1702 : SetError( m_pOwnStg->GetError() );
500 :
501 1702 : m_pStorStm = pStm;
502 1702 : m_bDelStm = bDelete;
503 1702 : if ( IsOLEStorage() )
504 1672 : m_nVersion = SOFFICE_FILEFORMAT_50;
505 :
506 1702 : SignAsRoot( m_pOwnStg->IsRoot() );
507 1702 : }
508 :
509 16196 : SotStorage::~SotStorage()
510 : {
511 4049 : delete m_pOwnStg;
512 4049 : if( m_bDelStm )
513 81 : delete m_pStorStm;
514 12147 : }
515 :
516 0 : SvMemoryStream * SotStorage::CreateMemoryStream()
517 : {
518 0 : SvMemoryStream * pStm = NULL;
519 0 : pStm = new SvMemoryStream( 0x8000, 0x8000 );
520 0 : tools::SvRef<SotStorage> aStg = new SotStorage( *pStm );
521 0 : if( CopyTo( aStg ) )
522 : {
523 0 : aStg->Commit();
524 : }
525 : else
526 : {
527 0 : aStg.Clear(); // Storage vorher freigeben
528 0 : delete pStm;
529 0 : pStm = NULL;
530 : }
531 0 : return pStm;
532 : }
533 :
534 56 : bool SotStorage::IsStorageFile( const OUString & rFileName )
535 : {
536 56 : OUString aName( rFileName );
537 112 : INetURLObject aObj( aName );
538 56 : if ( aObj.GetProtocol() == INetProtocol::NotValid )
539 : {
540 0 : OUString aURL;
541 0 : ::utl::LocalFileHelper::ConvertPhysicalNameToURL( aName, aURL );
542 0 : aObj.SetURL( aURL );
543 0 : aName = aObj.GetMainURL( INetURLObject::NO_DECODE );
544 : }
545 :
546 112 : boost::scoped_ptr<SvStream> pStm(::utl::UcbStreamHelper::CreateStream( aName, STREAM_STD_READ ));
547 56 : bool bRet = SotStorage::IsStorageFile( pStm.get() );
548 112 : return bRet;
549 : }
550 :
551 586 : bool SotStorage::IsStorageFile( SvStream* pStream )
552 : {
553 : /** code for new storages must come first! **/
554 586 : if ( pStream )
555 : {
556 586 : long nPos = pStream->Tell();
557 586 : bool bRet = UCBStorage::IsStorageFile( pStream );
558 586 : if ( !bRet )
559 556 : bRet = Storage::IsStorageFile( pStream );
560 586 : pStream->Seek( nPos );
561 586 : return bRet;
562 : }
563 : else
564 0 : return false;
565 : }
566 :
567 2006 : const OUString & SotStorage::GetName() const
568 : {
569 2006 : if( m_aName.isEmpty() )
570 : {
571 : DBG_ASSERT( Owner(), "must be owner" );
572 0 : if( m_pOwnStg )
573 0 : const_cast<SotStorage *>(this)->m_aName = m_pOwnStg->GetName();
574 : }
575 2006 : return m_aName;
576 : }
577 :
578 53 : void SotStorage::SetClass( const SvGlobalName & rName,
579 : SotClipboardFormatId nOriginalClipFormat,
580 : const OUString & rUserTypeName )
581 : {
582 : DBG_ASSERT( Owner(), "must be owner" );
583 53 : if( m_pOwnStg )
584 53 : m_pOwnStg->SetClass( rName, nOriginalClipFormat, rUserTypeName );
585 : else
586 0 : SetError( SVSTREAM_GENERALERROR );
587 53 : }
588 :
589 24 : SvGlobalName SotStorage::GetClassName()
590 : {
591 24 : SvGlobalName aGN;
592 : DBG_ASSERT( Owner(), "must be owner" );
593 24 : if( m_pOwnStg )
594 24 : aGN = m_pOwnStg->GetClassName();
595 : else
596 0 : SetError( SVSTREAM_GENERALERROR );
597 24 : return aGN;
598 : }
599 :
600 0 : SotClipboardFormatId SotStorage::GetFormat()
601 : {
602 0 : SotClipboardFormatId nFormat = SotClipboardFormatId::NONE;
603 : DBG_ASSERT( Owner(), "must be owner" );
604 0 : if( m_pOwnStg )
605 0 : nFormat = m_pOwnStg->GetFormat();
606 : else
607 0 : SetError( SVSTREAM_GENERALERROR );
608 0 : return nFormat;
609 : }
610 :
611 0 : OUString SotStorage::GetUserName()
612 : {
613 0 : OUString aName;
614 : DBG_ASSERT( Owner(), "must be owner" );
615 0 : if( m_pOwnStg )
616 0 : aName = m_pOwnStg->GetUserName();
617 : else
618 0 : SetError( SVSTREAM_GENERALERROR );
619 0 : return aName;
620 : }
621 :
622 94 : void SotStorage::FillInfoList( SvStorageInfoList * pFillList ) const
623 : {
624 : DBG_ASSERT( Owner(), "must be owner" );
625 94 : if( m_pOwnStg )
626 94 : m_pOwnStg->FillInfoList( pFillList );
627 94 : }
628 :
629 19 : bool SotStorage::CopyTo( SotStorage * pDestStg )
630 : {
631 : DBG_ASSERT( Owner(), "must be owner" );
632 : DBG_ASSERT( pDestStg->Owner(), "must be owner" );
633 19 : if( m_pOwnStg && pDestStg->m_pOwnStg )
634 : {
635 19 : m_pOwnStg->CopyTo( pDestStg->m_pOwnStg );
636 19 : SetError( m_pOwnStg->GetError() );
637 19 : pDestStg->m_aKey = m_aKey;
638 19 : pDestStg->m_nVersion = m_nVersion;
639 : }
640 : else
641 0 : SetError( SVSTREAM_GENERALERROR );
642 :
643 19 : return SVSTREAM_OK == GetError();
644 : }
645 :
646 70 : bool SotStorage::Commit()
647 : {
648 : DBG_ASSERT( Owner(), "must be owner" );
649 70 : if( m_pOwnStg )
650 : {
651 70 : if( !m_pOwnStg->Commit() )
652 0 : SetError( m_pOwnStg->GetError() );
653 : }
654 : else
655 0 : SetError( SVSTREAM_GENERALERROR );
656 :
657 70 : return SVSTREAM_OK == GetError();
658 : }
659 :
660 1574 : SotStorageStream * SotStorage::OpenSotStream( const OUString & rEleName,
661 : StreamMode nMode )
662 : {
663 1574 : SotStorageStream * pStm = NULL;
664 : DBG_ASSERT( Owner(), "must be owner" );
665 1574 : if( m_pOwnStg )
666 : {
667 : // volle Ole-Patches einschalten
668 : // egal was kommt, nur exclusiv gestattet
669 1574 : nMode |= StreamMode::SHARE_DENYALL;
670 1574 : ErrCode nE = m_pOwnStg->GetError();
671 1574 : BaseStorageStream * p = m_pOwnStg->OpenStream( rEleName, nMode, true );
672 1574 : pStm = new SotStorageStream( p );
673 :
674 1574 : if( !nE )
675 1574 : m_pOwnStg->ResetError(); // kein Fehler setzen
676 1574 : if( nMode & StreamMode::TRUNC )
677 123 : pStm->SetSize( 0 );
678 : }
679 : else
680 0 : SetError( SVSTREAM_GENERALERROR );
681 :
682 1574 : return pStm;
683 : }
684 :
685 139 : SotStorage * SotStorage::OpenSotStorage( const OUString & rEleName,
686 : StreamMode nMode,
687 : bool transacted )
688 : {
689 : DBG_ASSERT( Owner(), "must be owner" );
690 139 : if( m_pOwnStg )
691 : {
692 139 : nMode |= StreamMode::SHARE_DENYALL;
693 139 : ErrCode nE = m_pOwnStg->GetError();
694 139 : BaseStorage * p = m_pOwnStg->OpenStorage(rEleName, nMode, !transacted);
695 139 : if( p )
696 : {
697 139 : SotStorage * pStor = new SotStorage( p );
698 139 : if( !nE )
699 139 : m_pOwnStg->ResetError(); // kein Fehler setzen
700 :
701 139 : return pStor;
702 : }
703 : }
704 :
705 0 : SetError( SVSTREAM_GENERALERROR );
706 :
707 0 : return NULL;
708 : }
709 :
710 0 : bool SotStorage::IsStorage( const OUString & rEleName ) const
711 : {
712 : DBG_ASSERT( Owner(), "must be owner" );
713 : // ein bisschen schneller
714 0 : if( m_pOwnStg )
715 0 : return m_pOwnStg->IsStorage( rEleName );
716 :
717 0 : return false;
718 : }
719 :
720 4246 : bool SotStorage::IsStream( const OUString & rEleName ) const
721 : {
722 : DBG_ASSERT( Owner(), "must be owner" );
723 : // ein bisschen schneller
724 4246 : if( m_pOwnStg )
725 4246 : return m_pOwnStg->IsStream( rEleName );
726 :
727 0 : return false;
728 : }
729 :
730 664 : bool SotStorage::IsContained( const OUString & rEleName ) const
731 : {
732 : DBG_ASSERT( Owner(), "must be owner" );
733 : // ein bisschen schneller
734 664 : if( m_pOwnStg )
735 664 : return m_pOwnStg->IsContained( rEleName );
736 :
737 0 : return false;
738 : }
739 :
740 28 : bool SotStorage::Remove( const OUString & rEleName )
741 : {
742 : DBG_ASSERT( Owner(), "must be owner" );
743 28 : if( m_pOwnStg )
744 : {
745 28 : m_pOwnStg->Remove( rEleName );
746 28 : SetError( m_pOwnStg->GetError() );
747 : }
748 : else
749 0 : SetError( SVSTREAM_GENERALERROR );
750 :
751 28 : return SVSTREAM_OK == GetError();
752 : }
753 :
754 0 : bool SotStorage::CopyTo( const OUString & rEleName,
755 : SotStorage * pNewSt, const OUString & rNewName )
756 : {
757 : DBG_ASSERT( Owner(), "must be owner" );
758 : DBG_ASSERT( pNewSt->Owner(), "must be owner" );
759 0 : if( m_pOwnStg )
760 : {
761 0 : m_pOwnStg->CopyTo( rEleName, pNewSt->m_pOwnStg, rNewName );
762 0 : SetError( m_pOwnStg->GetError() );
763 0 : SetError( pNewSt->GetError() );
764 : }
765 : else
766 0 : SetError( SVSTREAM_GENERALERROR );
767 :
768 0 : return SVSTREAM_OK == GetError();
769 : }
770 :
771 5 : bool SotStorage::Validate()
772 : {
773 : DBG_ASSERT( m_bIsRoot, "Validate nur an Rootstorage" );
774 5 : if( m_pOwnStg )
775 5 : return m_pOwnStg->ValidateFAT();
776 : else
777 0 : return true;
778 : }
779 :
780 4049 : bool SotStorage::IsOLEStorage() const
781 : {
782 4049 : UCBStorage* pStg = PTR_CAST( UCBStorage, m_pOwnStg );
783 4049 : return !pStg;
784 : }
785 :
786 32 : bool SotStorage::IsOLEStorage( const OUString & rFileName )
787 : {
788 32 : return Storage::IsStorageFile( rFileName );
789 : }
790 :
791 5761 : bool SotStorage::IsOLEStorage( SvStream* pStream )
792 : {
793 5761 : return Storage::IsStorageFile( pStream );
794 : }
795 :
796 27 : SotStorage* SotStorage::OpenOLEStorage( const com::sun::star::uno::Reference < com::sun::star::embed::XStorage >& xStorage,
797 : const OUString& rEleName, StreamMode nMode )
798 : {
799 27 : sal_Int32 nEleMode = embed::ElementModes::SEEKABLEREAD;
800 27 : if ( nMode & StreamMode::WRITE )
801 27 : nEleMode |= embed::ElementModes::WRITE;
802 27 : if ( nMode & StreamMode::TRUNC )
803 0 : nEleMode |= embed::ElementModes::TRUNCATE;
804 27 : if ( nMode & StreamMode::NOCREATE )
805 20 : nEleMode |= embed::ElementModes::NOCREATE;
806 :
807 27 : SvStream* pStream = NULL;
808 : try
809 : {
810 27 : uno::Reference < io::XStream > xStream = xStorage->openStreamElement( rEleName, nEleMode );
811 :
812 : // TODO/LATER: should it be done this way?
813 6 : if ( nMode & StreamMode::WRITE )
814 : {
815 6 : uno::Reference < beans::XPropertySet > xStreamProps( xStream, uno::UNO_QUERY_THROW );
816 6 : xStreamProps->setPropertyValue(
817 : OUString( "MediaType" ),
818 6 : uno::makeAny( OUString( "application/vnd.sun.star.oleobject" ) ) );
819 : }
820 :
821 6 : pStream = utl::UcbStreamHelper::CreateStream( xStream );
822 : }
823 21 : catch ( uno::Exception& )
824 : {
825 : //TODO/LATER: ErrorHandling
826 21 : pStream = new SvMemoryStream;
827 21 : pStream->SetError( ERRCODE_IO_GENERAL );
828 : }
829 :
830 27 : return new SotStorage( pStream, true );
831 : }
832 :
833 2530 : SotClipboardFormatId SotStorage::GetFormatID( const com::sun::star::uno::Reference < com::sun::star::embed::XStorage >& xStorage )
834 : {
835 2530 : uno::Reference< beans::XPropertySet > xProps( xStorage, uno::UNO_QUERY );
836 2530 : if ( !xProps.is() )
837 0 : return SotClipboardFormatId::NONE;
838 :
839 5060 : OUString aMediaType;
840 2530 : xProps->getPropertyValue("MediaType") >>= aMediaType;
841 2530 : if ( !aMediaType.isEmpty() )
842 : {
843 2528 : ::com::sun::star::datatransfer::DataFlavor aDataFlavor;
844 2528 : aDataFlavor.MimeType = aMediaType;
845 2528 : return SotExchange::GetFormat( aDataFlavor );
846 : }
847 :
848 2532 : return SotClipboardFormatId::NONE;
849 : }
850 :
851 2522 : sal_Int32 SotStorage::GetVersion( const com::sun::star::uno::Reference < com::sun::star::embed::XStorage >& xStorage )
852 : {
853 2522 : SotClipboardFormatId nSotFormatID = SotStorage::GetFormatID( xStorage );
854 2522 : switch( nSotFormatID )
855 : {
856 : case SotClipboardFormatId::STARWRITER_8:
857 : case SotClipboardFormatId::STARWRITER_8_TEMPLATE:
858 : case SotClipboardFormatId::STARWRITERWEB_8:
859 : case SotClipboardFormatId::STARWRITERGLOB_8:
860 : case SotClipboardFormatId::STARWRITERGLOB_8_TEMPLATE:
861 : case SotClipboardFormatId::STARDRAW_8:
862 : case SotClipboardFormatId::STARDRAW_8_TEMPLATE:
863 : case SotClipboardFormatId::STARIMPRESS_8:
864 : case SotClipboardFormatId::STARIMPRESS_8_TEMPLATE:
865 : case SotClipboardFormatId::STARCALC_8:
866 : case SotClipboardFormatId::STARCALC_8_TEMPLATE:
867 : case SotClipboardFormatId::STARCHART_8:
868 : case SotClipboardFormatId::STARCHART_8_TEMPLATE:
869 : case SotClipboardFormatId::STARMATH_8:
870 : case SotClipboardFormatId::STARMATH_8_TEMPLATE:
871 2501 : return SOFFICE_FILEFORMAT_8;
872 : case SotClipboardFormatId::STARWRITER_60:
873 : case SotClipboardFormatId::STARWRITERWEB_60:
874 : case SotClipboardFormatId::STARWRITERGLOB_60:
875 : case SotClipboardFormatId::STARDRAW_60:
876 : case SotClipboardFormatId::STARIMPRESS_60:
877 : case SotClipboardFormatId::STARCALC_60:
878 : case SotClipboardFormatId::STARCHART_60:
879 : case SotClipboardFormatId::STARMATH_60:
880 13 : return SOFFICE_FILEFORMAT_60;
881 8 : default: break;
882 : }
883 :
884 8 : return 0;
885 : }
886 :
887 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
