?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
LanguageTool: don't crash if REST protocol isn't set
[LibreOffice.git] / sc / source / filter / excel / xestream.cxx
blob315b905560f3680cd5f2c6c92bb73eb288f13bc7
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 <stdio.h>
21 #include <string.h>
22 #include <utility>
23
24 #include <filter/msfilter/util.hxx>
25 #include <o3tl/safeint.hxx>
26 #include <rtl/ustring.hxx>
27 #include <rtl/ustrbuf.hxx>
28 #include <rtl/random.h>
29 #include <sax/fshelper.hxx>
30 #include <unotools/streamwrap.hxx>
31 #include <sot/storage.hxx>
32 #include <tools/urlobj.hxx>
33 #include <vcl/svapp.hxx>
34 #include <vcl/settings.hxx>
35 #include <officecfg/Office/Calc.hxx>
36
37 #include <docuno.hxx>
38 #include <xestream.hxx>
39 #include <xladdress.hxx>
40 #include <xlstring.hxx>
41 #include <xltools.hxx>
42 #include <xeroot.hxx>
43 #include <xcl97rec.hxx>
44 #include <rangelst.hxx>
45 #include <compiler.hxx>
46 #include <formulacell.hxx>
47 #include <tokenarray.hxx>
48 #include <tokenstringcontext.hxx>
49 #include <refreshtimerprotector.hxx>
50 #include <globstr.hrc>
51 #include <scresid.hxx>
52 #include <root.hxx>
53 #include <sfx2/app.hxx>
54
55 #include <docsh.hxx>
56 #include <viewdata.hxx>
57 #include <excdoc.hxx>
58
59 #include <oox/token/tokens.hxx>
60 #include <oox/token/relationship.hxx>
61 #include <oox/export/utils.hxx>
62 #include <formula/grammar.hxx>
63 #include <oox/ole/vbaexport.hxx>
64 #include <excelvbaproject.hxx>
65
66 #include <com/sun/star/task/XStatusIndicator.hpp>
67 #include <memory>
68 #include <comphelper/storagehelper.hxx>
69
70 #include <externalrefmgr.hxx>
71
72 #define DEBUG_XL_ENCRYPTION 0
73
74 using ::com::sun::star::uno::XInterface;
75 using ::std::vector;
76
77 using namespace com::sun::star;
78 using namespace ::com::sun::star::beans;
79 using namespace ::com::sun::star::io;
80 using namespace ::com::sun::star::lang;
81 using namespace ::com::sun::star::sheet;
82 using namespace ::com::sun::star::uno;
83 using namespace ::formula;
84 using namespace ::oox;
85
86 XclExpStream::XclExpStream( SvStream& rOutStrm, const XclExpRoot& rRoot, sal_uInt16 nMaxRecSize ) :
87 mrStrm( rOutStrm ),
88 mrRoot( rRoot ),
89 mbUseEncrypter( false ),
90 mnMaxRecSize( nMaxRecSize ),
91 mnCurrMaxSize( 0 ),
92 mnMaxSliceSize( 0 ),
93 mnHeaderSize( 0 ),
94 mnCurrSize( 0 ),
95 mnSliceSize( 0 ),
96 mnPredictSize( 0 ),
97 mnLastSizePos( 0 ),
98 mbInRec( false )
99 {
100 if( mnMaxRecSize == 0 )
101 mnMaxRecSize = (mrRoot.GetBiff() <= EXC_BIFF5) ? EXC_MAXRECSIZE_BIFF5 : EXC_MAXRECSIZE_BIFF8;
102 mnMaxContSize = mnMaxRecSize;
103 }
104
105 XclExpStream::~XclExpStream()
106 {
107 mrStrm.Flush();
108 }
109
110 void XclExpStream::StartRecord( sal_uInt16 nRecId, std::size_t nRecSize )
111 {
112 OSL_ENSURE( !mbInRec, "XclExpStream::StartRecord - another record still open" );
113 DisableEncryption();
114 mnMaxContSize = mnCurrMaxSize = mnMaxRecSize;
115 mnPredictSize = nRecSize;
116 mbInRec = true;
117 InitRecord( nRecId );
118 SetSliceSize( 0 );
119 EnableEncryption();
120 }
121
122 void XclExpStream::EndRecord()
123 {
124 OSL_ENSURE( mbInRec, "XclExpStream::EndRecord - no record open" );
125 DisableEncryption();
126 UpdateRecSize();
127 mrStrm.Seek( STREAM_SEEK_TO_END );
128 mbInRec = false;
129 }
130
131 void XclExpStream::SetSliceSize( sal_uInt16 nSize )
132 {
133 mnMaxSliceSize = nSize;
134 mnSliceSize = 0;
135 }
136
137 XclExpStream& XclExpStream::operator<<( sal_Int8 nValue )
138 {
139 PrepareWrite( 1 );
140 if (mbUseEncrypter && HasValidEncrypter())
141 mxEncrypter->Encrypt(mrStrm, nValue);
142 else
143 mrStrm.WriteSChar( nValue );
144 return *this;
145 }
146
147 XclExpStream& XclExpStream::operator<<( sal_uInt8 nValue )
148 {
149 PrepareWrite( 1 );
150 if (mbUseEncrypter && HasValidEncrypter())
151 mxEncrypter->Encrypt(mrStrm, nValue);
152 else
153 mrStrm.WriteUChar( nValue );
154 return *this;
155 }
156
157 XclExpStream& XclExpStream::operator<<( sal_Int16 nValue )
158 {
159 PrepareWrite( 2 );
160 if (mbUseEncrypter && HasValidEncrypter())
161 mxEncrypter->Encrypt(mrStrm, nValue);
162 else
163 mrStrm.WriteInt16( nValue );
164 return *this;
165 }
166
167 XclExpStream& XclExpStream::operator<<( sal_uInt16 nValue )
168 {
169 PrepareWrite( 2 );
170 if (mbUseEncrypter && HasValidEncrypter())
171 mxEncrypter->Encrypt(mrStrm, nValue);
172 else
173 mrStrm.WriteUInt16( nValue );
174 return *this;
175 }
176
177 XclExpStream& XclExpStream::operator<<( sal_Int32 nValue )
178 {
179 PrepareWrite( 4 );
180 if (mbUseEncrypter && HasValidEncrypter())
181 mxEncrypter->Encrypt(mrStrm, nValue);
182 else
183 mrStrm.WriteInt32( nValue );
184 return *this;
185 }
186
187 XclExpStream& XclExpStream::operator<<( sal_uInt32 nValue )
188 {
189 PrepareWrite( 4 );
190 if (mbUseEncrypter && HasValidEncrypter())
191 mxEncrypter->Encrypt(mrStrm, nValue);
192 else
193 mrStrm.WriteUInt32( nValue );
194 return *this;
195 }
196
197 XclExpStream& XclExpStream::operator<<( float fValue )
198 {
199 PrepareWrite( 4 );
200 if (mbUseEncrypter && HasValidEncrypter())
201 mxEncrypter->Encrypt(mrStrm, fValue);
202 else
203 mrStrm.WriteFloat( fValue );
204 return *this;
205 }
206
207 XclExpStream& XclExpStream::operator<<( double fValue )
208 {
209 PrepareWrite( 8 );
210 if (mbUseEncrypter && HasValidEncrypter())
211 mxEncrypter->Encrypt(mrStrm, fValue);
212 else
213 mrStrm.WriteDouble( fValue );
214 return *this;
215 }
216
217 std::size_t XclExpStream::Write( const void* pData, std::size_t nBytes )
218 {
219 std::size_t nRet = 0;
220 if( pData && (nBytes > 0) )
221 {
222 if( mbInRec )
223 {
224 const sal_uInt8* pBuffer = static_cast< const sal_uInt8* >( pData );
225 std::size_t nBytesLeft = nBytes;
226 bool bValid = true;
227
228 while( bValid && (nBytesLeft > 0) )
229 {
230 std::size_t nWriteLen = ::std::min< std::size_t >( PrepareWrite(), nBytesLeft );
231 std::size_t nWriteRet = nWriteLen;
232 if (mbUseEncrypter && HasValidEncrypter())
233 {
234 OSL_ENSURE(nWriteLen > 0, "XclExpStream::Write: write length is 0!");
235 vector<sal_uInt8> aBytes(nWriteLen);
236 memcpy(aBytes.data(), pBuffer, nWriteLen);
237 mxEncrypter->EncryptBytes(mrStrm, aBytes);
238 // TODO: How do I check if all the bytes have been successfully written ?
239 }
240 else
241 {
242 nWriteRet = mrStrm.WriteBytes(pBuffer, nWriteLen);
243 bValid = (nWriteLen == nWriteRet);
244 OSL_ENSURE( bValid, "XclExpStream::Write - stream write error" );
245 }
246 pBuffer += nWriteRet;
247 nRet += nWriteRet;
248 nBytesLeft -= nWriteRet;
249 UpdateSizeVars( nWriteRet );
250 }
251 }
252 else
253 nRet = mrStrm.WriteBytes(pData, nBytes);
254 }
255 return nRet;
256 }
257
258 void XclExpStream::WriteZeroBytes( std::size_t nBytes )
259 {
260 if( mbInRec )
261 {
262 std::size_t nBytesLeft = nBytes;
263 while( nBytesLeft > 0 )
264 {
265 std::size_t nWriteLen = ::std::min< std::size_t >( PrepareWrite(), nBytesLeft );
266 WriteRawZeroBytes( nWriteLen );
267 nBytesLeft -= nWriteLen;
268 UpdateSizeVars( nWriteLen );
269 }
270 }
271 else
272 WriteRawZeroBytes( nBytes );
273 }
274
275 void XclExpStream::WriteZeroBytesToRecord( std::size_t nBytes )
276 {
277 if (!mbInRec)
278 // not in record.
279 return;
280
281 for (std::size_t i = 0; i < nBytes; ++i)
282 *this << sal_uInt8(0)/*nZero*/;
283 }
284
285 void XclExpStream::CopyFromStream(SvStream& rInStrm, sal_uInt64 const nBytes)
286 {
287 sal_uInt64 const nRemaining(rInStrm.remainingSize());
288 sal_uInt64 nBytesLeft = ::std::min(nBytes, nRemaining);
289 if( nBytesLeft <= 0 )
290 return;
291
292 const std::size_t nMaxBuffer = 4096;
293 std::unique_ptr<sal_uInt8[]> pBuffer(
294 new sal_uInt8[ ::std::min<std::size_t>(nBytesLeft, nMaxBuffer) ]);
295 bool bValid = true;
296
297 while( bValid && (nBytesLeft > 0) )
298 {
299 std::size_t nWriteLen = ::std::min<std::size_t>(nBytesLeft, nMaxBuffer);
300 rInStrm.ReadBytes(pBuffer.get(), nWriteLen);
301 std::size_t nWriteRet = Write( pBuffer.get(), nWriteLen );
302 bValid = (nWriteLen == nWriteRet);
303 nBytesLeft -= nWriteRet;
304 }
305 }
306
307 void XclExpStream::WriteUnicodeBuffer( const ScfUInt16Vec& rBuffer, sal_uInt8 nFlags )
308 {
309 SetSliceSize( 0 );
310 nFlags &= EXC_STRF_16BIT; // repeat only 16bit flag
311 sal_uInt16 nCharLen = nFlags ? 2 : 1;
312
313 for( const auto& rItem : rBuffer )
314 {
315 if( mbInRec && (mnCurrSize + nCharLen > mnCurrMaxSize) )
316 {
317 StartContinue();
318 operator<<( nFlags );
319 }
320 if( nCharLen == 2 )
321 operator<<( rItem );
322 else
323 operator<<( static_cast< sal_uInt8 >( rItem ) );
324 }
325 }
326
327 // Xcl has an obscure sense of whether starting a new record or not,
328 // and crashes if it encounters the string header at the very end of a record.
329 // Thus we add 1 to give some room, seems like they do it that way but with another count (10?)
330 void XclExpStream::WriteByteString( const OString& rString )
331 {
332 SetSliceSize( 0 );
333 std::size_t nLen = ::std::min< std::size_t >( rString.getLength(), 0x00FF );
334 nLen = ::std::min< std::size_t >( nLen, 0xFF );
335
336 sal_uInt16 nLeft = PrepareWrite();
337 if( mbInRec && (nLeft <= 1) )
338 StartContinue();
339
340 operator<<( static_cast< sal_uInt8 >( nLen ) );
341 Write( rString.getStr(), nLen );
342 }
343
344 void XclExpStream::WriteCharBuffer( const ScfUInt8Vec& rBuffer )
345 {
346 SetSliceSize( 0 );
347 Write( rBuffer.data(), rBuffer.size() );
348 }
349
350 void XclExpStream::SetEncrypter( XclExpEncrypterRef const & xEncrypter )
351 {
352 mxEncrypter = xEncrypter;
353 }
354
355 bool XclExpStream::HasValidEncrypter() const
356 {
357 return mxEncrypter && mxEncrypter->IsValid();
358 }
359
360 void XclExpStream::EnableEncryption( bool bEnable )
361 {
362 mbUseEncrypter = bEnable && HasValidEncrypter();
363 }
364
365 void XclExpStream::DisableEncryption()
366 {
367 EnableEncryption(false);
368 }
369
370 void XclExpStream::SetSvStreamPos(sal_uInt64 const nPos)
371 {
372 OSL_ENSURE( !mbInRec, "XclExpStream::SetSvStreamPos - not allowed inside of a record" );
373 mbInRec ? 0 : mrStrm.Seek( nPos );
374 }
375
376 // private --------------------------------------------------------------------
377
378 void XclExpStream::InitRecord( sal_uInt16 nRecId )
379 {
380 mrStrm.Seek( STREAM_SEEK_TO_END );
381 mrStrm.WriteUInt16( nRecId );
382
383 mnLastSizePos = mrStrm.Tell();
384 mnHeaderSize = static_cast< sal_uInt16 >( ::std::min< std::size_t >( mnPredictSize, mnCurrMaxSize ) );
385 mrStrm.WriteUInt16( mnHeaderSize );
386 mnCurrSize = mnSliceSize = 0;
387 }
388
389 void XclExpStream::UpdateRecSize()
390 {
391 if( mnCurrSize != mnHeaderSize )
392 {
393 mrStrm.Seek( mnLastSizePos );
394 mrStrm.WriteUInt16( mnCurrSize );
395 }
396 }
397
398 void XclExpStream::UpdateSizeVars( std::size_t nSize )
399 {
400 OSL_ENSURE( mnCurrSize + nSize <= mnCurrMaxSize, "XclExpStream::UpdateSizeVars - record overwritten" );
401 mnCurrSize = mnCurrSize + static_cast< sal_uInt16 >( nSize );
402
403 if( mnMaxSliceSize > 0 )
404 {
405 OSL_ENSURE( mnSliceSize + nSize <= mnMaxSliceSize, "XclExpStream::UpdateSizeVars - slice overwritten" );
406 mnSliceSize = mnSliceSize + static_cast< sal_uInt16 >( nSize );
407 if( mnSliceSize >= mnMaxSliceSize )
408 mnSliceSize = 0;
409 }
410 }
411
412 void XclExpStream::StartContinue()
413 {
414 UpdateRecSize();
415 mnCurrMaxSize = mnMaxContSize;
416 mnPredictSize -= mnCurrSize;
417 InitRecord( EXC_ID_CONT );
418 }
419
420 void XclExpStream::PrepareWrite( sal_uInt16 nSize )
421 {
422 if( mbInRec )
423 {
424 if( (mnCurrSize + nSize > mnCurrMaxSize) ||
425 ((mnMaxSliceSize > 0) && (mnSliceSize == 0) && (mnCurrSize + mnMaxSliceSize > mnCurrMaxSize)) )
426 StartContinue();
427 UpdateSizeVars( nSize );
428 }
429 }
430
431 sal_uInt16 XclExpStream::PrepareWrite()
432 {
433 sal_uInt16 nRet = 0;
434 if( mbInRec )
435 {
436 if( (mnCurrSize >= mnCurrMaxSize) ||
437 ((mnMaxSliceSize > 0) && (mnSliceSize == 0) && (mnCurrSize + mnMaxSliceSize > mnCurrMaxSize)) )
438 StartContinue();
439 UpdateSizeVars( 0 );
440
441 nRet = (mnMaxSliceSize > 0) ? (mnMaxSliceSize - mnSliceSize) : (mnCurrMaxSize - mnCurrSize);
442 }
443 return nRet;
444 }
445
446 void XclExpStream::WriteRawZeroBytes( std::size_t nBytes )
447 {
448 const sal_uInt32 nData = 0;
449 std::size_t nBytesLeft = nBytes;
450 while( nBytesLeft >= sizeof( nData ) )
451 {
452 mrStrm.WriteUInt32( nData );
453 nBytesLeft -= sizeof( nData );
454 }
455 if( nBytesLeft )
456 mrStrm.WriteBytes(&nData, nBytesLeft);
457 }
458
459 XclExpBiff8Encrypter::XclExpBiff8Encrypter( const XclExpRoot& rRoot ) :
460 mnOldPos(STREAM_SEEK_TO_END),
461 mbValid(false)
462 {
463 Sequence< NamedValue > aEncryptionData = rRoot.GetEncryptionData();
464 if( !aEncryptionData.hasElements() )
465 // Empty password. Get the default biff8 password.
466 aEncryptionData = XclExpRoot::GenerateDefaultEncryptionData();
467 Init( aEncryptionData );
468 }
469
470 XclExpBiff8Encrypter::~XclExpBiff8Encrypter()
471 {
472 }
473
474 void XclExpBiff8Encrypter::GetSaltDigest( sal_uInt8 pnSaltDigest[16] ) const
475 {
476 if ( sizeof( mpnSaltDigest ) == 16 )
477 memcpy( pnSaltDigest, mpnSaltDigest, 16 );
478 }
479
480 void XclExpBiff8Encrypter::GetSalt( sal_uInt8 pnSalt[16] ) const
481 {
482 if ( sizeof( mpnSalt ) == 16 )
483 memcpy( pnSalt, mpnSalt, 16 );
484 }
485
486 void XclExpBiff8Encrypter::GetDocId( sal_uInt8 pnDocId[16] ) const
487 {
488 if ( sizeof( mpnDocId ) == 16 )
489 memcpy( pnDocId, mpnDocId, 16 );
490 }
491
492 void XclExpBiff8Encrypter::Encrypt( SvStream& rStrm, sal_uInt8 nData )
493 {
494 vector<sal_uInt8> aByte { nData };
495 EncryptBytes(rStrm, aByte);
496 }
497
498 void XclExpBiff8Encrypter::Encrypt( SvStream& rStrm, sal_uInt16 nData )
499 {
500 ::std::vector<sal_uInt8> pnBytes
501 {
502 o3tl::narrowing<sal_uInt8>(nData & 0xFF),
503 o3tl::narrowing<sal_uInt8>((nData >> 8) & 0xFF)
504 };
505 EncryptBytes(rStrm, pnBytes);
506 }
507
508 void XclExpBiff8Encrypter::Encrypt( SvStream& rStrm, sal_uInt32 nData )
509 {
510 ::std::vector<sal_uInt8> pnBytes
511 {
512 o3tl::narrowing<sal_uInt8>(nData & 0xFF),
513 o3tl::narrowing<sal_uInt8>((nData >> 8) & 0xFF),
514 o3tl::narrowing<sal_uInt8>((nData >> 16) & 0xFF),
515 o3tl::narrowing<sal_uInt8>((nData >> 24) & 0xFF)
516 };
517 EncryptBytes(rStrm, pnBytes);
518 }
519
520 void XclExpBiff8Encrypter::Encrypt( SvStream& rStrm, float fValue )
521 {
522 ::std::vector<sal_uInt8> pnBytes(4);
523 memcpy(pnBytes.data(), &fValue, 4);
524 EncryptBytes(rStrm, pnBytes);
525 }
526
527 void XclExpBiff8Encrypter::Encrypt( SvStream& rStrm, double fValue )
528 {
529 ::std::vector<sal_uInt8> pnBytes(8);
530 memcpy(pnBytes.data(), &fValue, 8);
531 EncryptBytes(rStrm, pnBytes);
532 }
533
534 void XclExpBiff8Encrypter::Encrypt( SvStream& rStrm, sal_Int8 nData )
535 {
536 Encrypt(rStrm, static_cast<sal_uInt8>(nData));
537 }
538
539 void XclExpBiff8Encrypter::Encrypt( SvStream& rStrm, sal_Int16 nData )
540 {
541 Encrypt(rStrm, static_cast<sal_uInt16>(nData));
542 }
543
544 void XclExpBiff8Encrypter::Encrypt( SvStream& rStrm, sal_Int32 nData )
545 {
546 Encrypt(rStrm, static_cast<sal_uInt32>(nData));
547 }
548
549 void XclExpBiff8Encrypter::Init( const Sequence< NamedValue >& rEncryptionData )
550 {
551 mbValid = false;
552
553 if( !maCodec.InitCodec( rEncryptionData ) )
554 return;
555
556 maCodec.GetDocId( mpnDocId );
557
558 // generate the salt here
559 rtlRandomPool aRandomPool = rtl_random_createPool ();
560 rtl_random_getBytes( aRandomPool, mpnSalt, 16 );
561 rtl_random_destroyPool( aRandomPool );
562
563 memset( mpnSaltDigest, 0, sizeof( mpnSaltDigest ) );
564
565 // generate salt hash.
566 ::msfilter::MSCodec_Std97 aCodec;
567 aCodec.InitCodec( rEncryptionData );
568 aCodec.CreateSaltDigest( mpnSalt, mpnSaltDigest );
569
570 // verify to make sure it's in good shape.
571 mbValid = maCodec.VerifyKey( mpnSalt, mpnSaltDigest );
572 }
573
574 sal_uInt32 XclExpBiff8Encrypter::GetBlockPos( std::size_t nStrmPos )
575 {
576 return static_cast< sal_uInt32 >( nStrmPos / EXC_ENCR_BLOCKSIZE );
577 }
578
579 sal_uInt16 XclExpBiff8Encrypter::GetOffsetInBlock( std::size_t nStrmPos )
580 {
581 return static_cast< sal_uInt16 >( nStrmPos % EXC_ENCR_BLOCKSIZE );
582 }
583
584 void XclExpBiff8Encrypter::EncryptBytes( SvStream& rStrm, vector<sal_uInt8>& aBytes )
585 {
586 sal_uInt64 nStrmPos = rStrm.Tell();
587 sal_uInt16 nBlockOffset = GetOffsetInBlock(nStrmPos);
588 sal_uInt32 nBlockPos = GetBlockPos(nStrmPos);
589
590 #if DEBUG_XL_ENCRYPTION
591 fprintf(stdout, "XclExpBiff8Encrypter::EncryptBytes: stream pos = %ld offset in block = %d block pos = %ld\n",
592 nStrmPos, nBlockOffset, nBlockPos);
593 #endif
594
595 sal_uInt16 nSize = static_cast< sal_uInt16 >( aBytes.size() );
596 if (nSize == 0)
597 return;
598
599 #if DEBUG_XL_ENCRYPTION
600 fprintf(stdout, "RAW: ");
601 for (sal_uInt16 i = 0; i < nSize; ++i)
602 fprintf(stdout, "%2.2X ", aBytes[i]);
603 fprintf(stdout, "\n");
604 #endif
605
606 if (mnOldPos != nStrmPos)
607 {
608 sal_uInt16 nOldOffset = GetOffsetInBlock(mnOldPos);
609 sal_uInt32 nOldBlockPos = GetBlockPos(mnOldPos);
610
611 if ( (nBlockPos != nOldBlockPos) || (nBlockOffset < nOldOffset) )
612 {
613 maCodec.InitCipher(nBlockPos);
614 nOldOffset = 0;
615 }
616
617 if (nBlockOffset > nOldOffset)
618 maCodec.Skip(nBlockOffset - nOldOffset);
619 }
620
621 sal_uInt16 nBytesLeft = nSize;
622 sal_uInt16 nPos = 0;
623 while (nBytesLeft > 0)
624 {
625 sal_uInt16 nBlockLeft = EXC_ENCR_BLOCKSIZE - nBlockOffset;
626 sal_uInt16 nEncBytes = ::std::min(nBlockLeft, nBytesLeft);
627
628 bool bRet = maCodec.Encode(&aBytes[nPos], nEncBytes, &aBytes[nPos], nEncBytes);
629 OSL_ENSURE(bRet, "XclExpBiff8Encrypter::EncryptBytes: encryption failed!!");
630
631 std::size_t nRet = rStrm.WriteBytes(&aBytes[nPos], nEncBytes);
632 OSL_ENSURE(nRet == nEncBytes, "XclExpBiff8Encrypter::EncryptBytes: fail to write to stream!!");
633
634 nStrmPos = rStrm.Tell();
635 nBlockOffset = GetOffsetInBlock(nStrmPos);
636 nBlockPos = GetBlockPos(nStrmPos);
637 if (nBlockOffset == 0)
638 maCodec.InitCipher(nBlockPos);
639
640 nBytesLeft -= nEncBytes;
641 nPos += nEncBytes;
642 }
643 mnOldPos = nStrmPos;
644 }
645
646 static const char* lcl_GetErrorString( FormulaError nScErrCode )
647 {
648 sal_uInt8 nXclErrCode = XclTools::GetXclErrorCode( nScErrCode );
649 switch( nXclErrCode )
650 {
651 case EXC_ERR_NULL: return "#NULL!";
652 case EXC_ERR_DIV0: return "#DIV/0!";
653 case EXC_ERR_VALUE: return "#VALUE!";
654 case EXC_ERR_REF: return "#REF!";
655 case EXC_ERR_NAME: return "#NAME?";
656 case EXC_ERR_NUM: return "#NUM!";
657 case EXC_ERR_NA:
658 default: return "#N/A";
659 }
660 }
661
662 void XclXmlUtils::GetFormulaTypeAndValue( ScFormulaCell& rCell, const char*& rsType, OUString& rsValue )
663 {
664 sc::FormulaResultValue aResValue = rCell.GetResult();
665
666 switch (aResValue.meType)
667 {
668 case sc::FormulaResultValue::Error:
669 rsType = "e";
670 rsValue = ToOUString(lcl_GetErrorString(aResValue.mnError));
671 break;
672 case sc::FormulaResultValue::Value:
673 rsType = rCell.GetFormatType() == SvNumFormatType::LOGICAL
674 && (aResValue.mfValue == 0.0 || aResValue.mfValue == 1.0)
675 ? "b"
676 : "n";
677 rsValue = OUString::number(aResValue.mfValue);
678 break;
679 case sc::FormulaResultValue::String:
680 rsType = "str";
681 rsValue = rCell.GetString().getString();
682 break;
683 case sc::FormulaResultValue::Invalid:
684 default:
685 // TODO : double-check this to see if this is correct.
686 rsType = "inlineStr";
687 rsValue = rCell.GetString().getString();
688 }
689 }
690
691 OUString XclXmlUtils::GetStreamName( const char* sStreamDir, const char* sStream, sal_Int32 nId )
692 {
693 OUStringBuffer sBuf;
694 if( sStreamDir )
695 sBuf.appendAscii( sStreamDir );
696 sBuf.appendAscii( sStream );
697 if( nId )
698 sBuf.append( nId );
699 if( strstr(sStream, "vml") )
700 sBuf.append( ".vml" );
701 else
702 sBuf.append( ".xml" );
703 return sBuf.makeStringAndClear();
704 }
705
706 OString XclXmlUtils::ToOString( const Color& rColor )
707 {
708 char buf[9];
709 sprintf( buf, "%.2X%.2X%.2X%.2X", rColor.GetAlpha(), rColor.GetRed(), rColor.GetGreen(), rColor.GetBlue() );
710 buf[8] = '\0';
711 return OString(buf);
712 }
713
714 OStringBuffer& XclXmlUtils::ToOString( OStringBuffer& s, const ScAddress& rAddress )
715 {
716 rAddress.Format(s, ScRefFlags::VALID, nullptr, ScAddress::Details( FormulaGrammar::CONV_XL_A1));
717 return s;
718 }
719
720 OString XclXmlUtils::ToOString( const ScfUInt16Vec& rBuffer )
721 {
722 if(rBuffer.empty())
723 return OString();
724
725 const sal_uInt16* pBuffer = rBuffer.data();
726 return OString(
727 reinterpret_cast<sal_Unicode const *>(pBuffer), rBuffer.size(),
728 RTL_TEXTENCODING_UTF8);
729 }
730
731 OString XclXmlUtils::ToOString( const ScDocument& rDoc, const ScRange& rRange, bool bFullAddressNotation )
732 {
733 OUString sRange(rRange.Format( rDoc, ScRefFlags::VALID,
734 ScAddress::Details( FormulaGrammar::CONV_XL_A1 ),
735 bFullAddressNotation ) );
736 return sRange.toUtf8();
737 }
738
739 OString XclXmlUtils::ToOString( const ScDocument& rDoc, const ScRangeList& rRangeList )
740 {
741 OUString s;
742 rRangeList.Format(s, ScRefFlags::VALID, rDoc, FormulaGrammar::CONV_XL_OOX, ' ');
743 return s.toUtf8();
744 }
745
746 static ScAddress lcl_ToAddress( const XclAddress& rAddress )
747 {
748 return ScAddress( rAddress.mnCol, rAddress.mnRow, 0 );
749 }
750
751 OStringBuffer& XclXmlUtils::ToOString( OStringBuffer& s, const XclAddress& rAddress )
752 {
753 return ToOString( s, lcl_ToAddress( rAddress ));
754 }
755
756 OString XclXmlUtils::ToOString( const XclExpString& s )
757 {
758 OSL_ENSURE( !s.IsRich(), "XclXmlUtils::ToOString(XclExpString): rich text string found!" );
759 return ToOString( s.GetUnicodeBuffer() );
760 }
761
762 static ScRange lcl_ToRange( const XclRange& rRange )
763 {
764 ScRange aRange;
765
766 aRange.aStart = lcl_ToAddress( rRange.maFirst );
767 aRange.aEnd = lcl_ToAddress( rRange.maLast );
768
769 return aRange;
770 }
771
772 OString XclXmlUtils::ToOString( const ScDocument& rDoc, const XclRangeList& rRanges )
773 {
774 ScRangeList aRanges;
775 for( const auto& rRange : rRanges )
776 {
777 aRanges.push_back( lcl_ToRange( rRange ) );
778 }
779 return ToOString( rDoc, aRanges );
780 }
781
782 OUString XclXmlUtils::ToOUString( const char* s )
783 {
784 return OUString( s, static_cast<sal_Int32>(strlen( s )), RTL_TEXTENCODING_ASCII_US );
785 }
786
787 OUString XclXmlUtils::ToOUString( const ScfUInt16Vec& rBuf, sal_Int32 nStart, sal_Int32 nLength )
788 {
789 if( nLength == -1 || ( nLength > (static_cast<sal_Int32>(rBuf.size()) - nStart) ) )
790 nLength = (rBuf.size() - nStart);
791
792 return nLength > 0
793 ? OUString(
794 reinterpret_cast<sal_Unicode const *>(&rBuf[nStart]), nLength)
795 : OUString();
796 }
797
798 OUString XclXmlUtils::ToOUString(
799 sc::CompileFormulaContext& rCtx, const ScAddress& rAddress, const ScTokenArray* pTokenArray,
800 FormulaError nErrCode )
801 {
802 ScCompiler aCompiler( rCtx, rAddress, const_cast<ScTokenArray&>(*pTokenArray));
803
804 /* TODO: isn't this the same as passed in rCtx and thus superfluous? */
805 aCompiler.SetGrammar(FormulaGrammar::GRAM_OOXML);
806
807 sal_Int32 nLen = pTokenArray->GetLen();
808 OUStringBuffer aBuffer( nLen ? (nLen * 5) : 8 );
809 if (nLen)
810 aCompiler.CreateStringFromTokenArray( aBuffer );
811 else
812 {
813 if (nErrCode != FormulaError::NONE)
814 aCompiler.AppendErrorConstant( aBuffer, nErrCode);
815 else
816 {
817 // No code SHOULD be an "error cell", assert caller thought of that
818 // and it really is.
819 assert(!"No code and no error.");
820 }
821 }
822
823 return aBuffer.makeStringAndClear();
824 }
825
826 OUString XclXmlUtils::ToOUString( const XclExpString& s )
827 {
828 OSL_ENSURE( !s.IsRich(), "XclXmlUtils::ToOString(XclExpString): rich text string found!" );
829 return ToOUString( s.GetUnicodeBuffer() );
830 }
831
832 static void lcl_WriteValue( const sax_fastparser::FSHelperPtr& rStream, sal_Int32 nElement, const char* pValue )
833 {
834 if( !pValue )
835 return;
836 rStream->singleElement(nElement, XML_val, pValue);
837 }
838
839 static const char* lcl_GetUnderlineStyle( FontLineStyle eUnderline, bool& bHaveUnderline )
840 {
841 bHaveUnderline = true;
842 switch( eUnderline )
843 {
844 // OOXTODO: doubleAccounting, singleAccounting
845 // OOXTODO: what should be done with the other FontLineStyle values?
846 case LINESTYLE_SINGLE: return "single";
847 case LINESTYLE_DOUBLE: return "double";
848 case LINESTYLE_NONE:
849 default: bHaveUnderline = false; return "none";
850 }
851 }
852
853 static const char* lcl_ToVerticalAlignmentRun( SvxEscapement eEscapement, bool& bHaveAlignment )
854 {
855 bHaveAlignment = true;
856 switch( eEscapement )
857 {
858 case SvxEscapement::Superscript: return "superscript";
859 case SvxEscapement::Subscript: return "subscript";
860 case SvxEscapement::Off:
861 default: bHaveAlignment = false; return "baseline";
862 }
863 }
864
865 sax_fastparser::FSHelperPtr XclXmlUtils::WriteFontData( sax_fastparser::FSHelperPtr pStream, const XclFontData& rFontData, sal_Int32 nFontId )
866 {
867 bool bHaveUnderline, bHaveVertAlign;
868 const char* pUnderline = lcl_GetUnderlineStyle( rFontData.GetScUnderline(), bHaveUnderline );
869 const char* pVertAlign = lcl_ToVerticalAlignmentRun( rFontData.GetScEscapement(), bHaveVertAlign );
870
871 lcl_WriteValue( pStream, XML_b, rFontData.mnWeight > 400 ? ToPsz( true ) : nullptr );
872 lcl_WriteValue( pStream, XML_i, rFontData.mbItalic ? ToPsz( true ) : nullptr );
873 lcl_WriteValue( pStream, XML_strike, rFontData.mbStrikeout ? ToPsz( true ) : nullptr );
874 // OOXTODO: lcl_WriteValue( rStream, XML_condense, ); // mac compatibility setting
875 // OOXTODO: lcl_WriteValue( rStream, XML_extend, ); // compatibility setting
876 lcl_WriteValue( pStream, XML_outline, rFontData.mbOutline ? ToPsz( true ) : nullptr );
877 lcl_WriteValue( pStream, XML_shadow, rFontData.mbShadow ? ToPsz( true ) : nullptr );
878 lcl_WriteValue( pStream, XML_u, bHaveUnderline ? pUnderline : nullptr );
879 lcl_WriteValue( pStream, XML_vertAlign, bHaveVertAlign ? pVertAlign : nullptr );
880 lcl_WriteValue( pStream, XML_sz, OString::number( rFontData.mnHeight / 20.0 ).getStr() ); // Twips->Pt
881 if( rFontData.maColor != Color( ColorAlpha, 0, 0xFF, 0xFF, 0xFF ) )
882 pStream->singleElement( XML_color,
883 // OOXTODO: XML_auto, bool
884 // OOXTODO: XML_indexed, uint
885 XML_rgb, XclXmlUtils::ToOString(rFontData.maColor)
886 // OOXTODO: XML_theme, index into <clrScheme/>
887 // OOXTODO: XML_tint, double
888 );
889 lcl_WriteValue( pStream, nFontId, rFontData.maName.toUtf8().getStr() );
890 lcl_WriteValue( pStream, XML_family, OString::number( rFontData.mnFamily ).getStr() );
891 lcl_WriteValue( pStream, XML_charset, rFontData.mnCharSet != 0 ? OString::number( rFontData.mnCharSet ).getStr() : nullptr );
892
893 return pStream;
894 }
895
896 XclExpXmlStream::XclExpXmlStream( const uno::Reference< XComponentContext >& rCC, bool bExportVBA, bool bExportTemplate )
897 : XmlFilterBase( rCC ),
898 mpRoot( nullptr ),
899 mbExportVBA(bExportVBA),
900 mbExportTemplate(bExportTemplate)
901 {
902 }
903
904 XclExpXmlStream::~XclExpXmlStream()
905 {
906 assert(maStreams.empty() && "Forgotten PopStream()?");
907 }
908
909 sax_fastparser::FSHelperPtr& XclExpXmlStream::GetCurrentStream()
910 {
911 OSL_ENSURE( !maStreams.empty(), "XclExpXmlStream::GetCurrentStream - no current stream" );
912 return maStreams.top();
913 }
914
915 void XclExpXmlStream::PushStream( sax_fastparser::FSHelperPtr const & aStream )
916 {
917 maStreams.push( aStream );
918 }
919
920 void XclExpXmlStream::PopStream()
921 {
922 OSL_ENSURE( !maStreams.empty(), "XclExpXmlStream::PopStream - stack is empty!" );
923 maStreams.pop();
924 }
925
926 sax_fastparser::FSHelperPtr XclExpXmlStream::GetStreamForPath( const OUString& sPath )
927 {
928 if( maOpenedStreamMap.find( sPath ) == maOpenedStreamMap.end() )
929 return sax_fastparser::FSHelperPtr();
930 return maOpenedStreamMap[ sPath ].second;
931 }
932
933 void XclExpXmlStream::WriteAttribute(sal_Int32 nAttr, std::u16string_view sVal)
934 {
935 GetCurrentStream()->write(" ")->writeId(nAttr)->write("=\"")->writeEscaped(sVal)->write("\"");
936 }
937
938 sax_fastparser::FSHelperPtr XclExpXmlStream::CreateOutputStream (
939 const OUString& sFullStream,
940 std::u16string_view sRelativeStream,
941 const uno::Reference< XOutputStream >& xParentRelation,
942 const char* sContentType,
943 std::u16string_view sRelationshipType,
944 OUString* pRelationshipId )
945 {
946 OUString sRelationshipId;
947 if (xParentRelation.is())
948 sRelationshipId = addRelation( xParentRelation, OUString(sRelationshipType), sRelativeStream );
949 else
950 sRelationshipId = addRelation( OUString(sRelationshipType), sRelativeStream );
951
952 if( pRelationshipId )
953 *pRelationshipId = sRelationshipId;
954
955 sax_fastparser::FSHelperPtr p = openFragmentStreamWithSerializer( sFullStream, OUString::createFromAscii( sContentType ) );
956
957 maOpenedStreamMap[ sFullStream ] = std::make_pair( sRelationshipId, p );
958
959 return p;
960 }
961
962 bool XclExpXmlStream::importDocument() noexcept
963 {
964 return false;
965 }
966
967 oox::vml::Drawing* XclExpXmlStream::getVmlDrawing()
968 {
969 return nullptr;
970 }
971
972 const oox::drawingml::Theme* XclExpXmlStream::getCurrentTheme() const
973 {
974 return nullptr;
975 }
976
977 oox::drawingml::table::TableStyleListPtr XclExpXmlStream::getTableStyles()
978 {
979 return oox::drawingml::table::TableStyleListPtr();
980 }
981
982 oox::drawingml::chart::ChartConverter* XclExpXmlStream::getChartConverter()
983 {
984 // DO NOT CALL
985 return nullptr;
986 }
987
988 ScDocShell* XclExpXmlStream::getDocShell()
989 {
990 uno::Reference< XInterface > xModel( getModel(), UNO_QUERY );
991
992 ScModelObj *pObj = dynamic_cast < ScModelObj* >( xModel.get() );
993
994 if ( pObj )
995 return static_cast < ScDocShell* >( pObj->GetEmbeddedObject() );
996
997 return nullptr;
998 }
999
1000 bool XclExpXmlStream::exportDocument()
1001 {
1002 ScDocShell* pShell = getDocShell();
1003 ScDocument& rDoc = pShell->GetDocument();
1004 ScRefreshTimerProtector aProt(rDoc.GetRefreshTimerControlAddress());
1005
1006 const bool bValidateTabNames = officecfg::Office::Calc::Filter::Export::MS_Excel::TruncateLongSheetNames::get();
1007 std::vector<OUString> aOriginalTabNames;
1008 if (bValidateTabNames)
1009 {
1010 validateTabNames(aOriginalTabNames);
1011 }
1012
1013 uno::Reference<task::XStatusIndicator> xStatusIndicator = getStatusIndicator();
1014
1015 if (xStatusIndicator.is())
1016 xStatusIndicator->start(ScResId(STR_SAVE_DOC), 100);
1017
1018 // NOTE: Don't use SotStorage or SvStream any more, and never call
1019 // SfxMedium::GetOutStream() anywhere in the xlsx export filter code!
1020 // Instead, write via XOutputStream instance.
1021 tools::SvRef<SotStorage> rStorage = static_cast<SotStorage*>(nullptr);
1022 drawingml::DrawingML::ResetMlCounters();
1023
1024 XclExpRootData aData(
1025 EXC_BIFF8, *pShell->GetMedium (), rStorage, rDoc,
1026 msfilter::util::getBestTextEncodingFromLocale(
1027 Application::GetSettings().GetLanguageTag().getLocale()));
1028 aData.meOutput = EXC_OUTPUT_XML_2007;
1029 aData.maXclMaxPos.Set( EXC_MAXCOL_XML_2007, EXC_MAXROW_XML_2007, EXC_MAXTAB_XML_2007 );
1030 aData.maMaxPos.SetCol( ::std::min( aData.maScMaxPos.Col(), aData.maXclMaxPos.Col() ) );
1031 aData.maMaxPos.SetRow( ::std::min( aData.maScMaxPos.Row(), aData.maXclMaxPos.Row() ) );
1032 aData.maMaxPos.SetTab( ::std::min( aData.maScMaxPos.Tab(), aData.maXclMaxPos.Tab() ) );
1033 aData.mpCompileFormulaCxt = std::make_shared<sc::CompileFormulaContext>(rDoc);
1034 // set target path to get correct relative links to target document, not source
1035 INetURLObject aPath(getFileUrl());
1036 aData.maBasePath = OUString("file:///" + aPath.GetPath() + "\\").replace('\\', '/')
1037 // fix for Linux
1038 .replaceFirst("file:////", "file:///");
1039
1040 XclExpRoot aRoot( aData );
1041
1042 mpRoot = &aRoot;
1043 aRoot.GetOldRoot().pER = &aRoot;
1044 aRoot.GetOldRoot().eDateiTyp = Biff8;
1045 // Get the viewsettings before processing
1046 if( ScDocShell::GetViewData() )
1047 ScDocShell::GetViewData()->WriteExtOptions( mpRoot->GetExtDocOptions() );
1048
1049 OUString const workbook = "xl/workbook.xml";
1050 const char* pWorkbookContentType = nullptr;
1051 if (mbExportVBA)
1052 {
1053 if (mbExportTemplate)
1054 {
1055 pWorkbookContentType = "application/vnd.ms-excel.template.macroEnabled.main+xml";
1056 }
1057 else
1058 {
1059 pWorkbookContentType = "application/vnd.ms-excel.sheet.macroEnabled.main+xml";
1060 }
1061 }
1062 else
1063 {
1064 if (mbExportTemplate)
1065 {
1066 pWorkbookContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml";
1067 }
1068 else
1069 {
1070 pWorkbookContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml";
1071 }
1072 }
1073
1074 PushStream( CreateOutputStream( workbook, workbook,
1075 uno::Reference <XOutputStream>(),
1076 pWorkbookContentType,
1077 oox::getRelationship(Relationship::OFFICEDOCUMENT) ) );
1078
1079 if (mbExportVBA)
1080 {
1081 VbaExport aExport(getModel());
1082 if (aExport.containsVBAProject())
1083 {
1084 SvMemoryStream aVbaStream(4096, 4096);
1085 tools::SvRef<SotStorage> pVBAStorage(new SotStorage(aVbaStream));
1086 aExport.exportVBA( pVBAStorage.get() );
1087 aVbaStream.Seek(0);
1088 css::uno::Reference<css::io::XInputStream> xVBAStream(
1089 new utl::OInputStreamWrapper(aVbaStream));
1090 css::uno::Reference<css::io::XOutputStream> xVBAOutput =
1091 openFragmentStream("xl/vbaProject.bin", "application/vnd.ms-office.vbaProject");
1092 comphelper::OStorageHelper::CopyInputToOutput(xVBAStream, xVBAOutput);
1093
1094 addRelation(GetCurrentStream()->getOutputStream(), oox::getRelationship(Relationship::VBAPROJECT), u"vbaProject.bin");
1095 }
1096 }
1097
1098 // destruct at the end of the block
1099 {
1100 ExcDocument aDocRoot( aRoot );
1101 if (xStatusIndicator.is())
1102 xStatusIndicator->setValue(10);
1103 aDocRoot.ReadDoc();
1104 if (xStatusIndicator.is())
1105 xStatusIndicator->setValue(40);
1106 aDocRoot.WriteXml( *this );
1107 rDoc.GetExternalRefManager()->disableSkipUnusedFileIds();
1108 }
1109
1110 PopStream();
1111 // Free all FSHelperPtr, to flush data before committing storage
1112 maOpenedStreamMap.clear();
1113
1114 commitStorage();
1115
1116 if (bValidateTabNames)
1117 {
1118 restoreTabNames(aOriginalTabNames);
1119 }
1120
1121 if (xStatusIndicator.is())
1122 xStatusIndicator->end();
1123 mpRoot = nullptr;
1124 return true;
1125 }
1126
1127 ::oox::ole::VbaProject* XclExpXmlStream::implCreateVbaProject() const
1128 {
1129 return new ::oox::xls::ExcelVbaProject( getComponentContext(), uno::Reference< XSpreadsheetDocument >( getModel(), UNO_QUERY ) );
1130 }
1131
1132 OUString XclExpXmlStream::getImplementationName()
1133 {
1134 return "TODO";
1135 }
1136
1137 void XclExpXmlStream::validateTabNames(std::vector<OUString>& aOriginalTabNames)
1138 {
1139 const int MAX_TAB_NAME_LENGTH = 31;
1140
1141 ScDocShell* pShell = getDocShell();
1142 ScDocument& rDoc = pShell->GetDocument();
1143
1144 // get original names
1145 aOriginalTabNames.resize(rDoc.GetTableCount());
1146 for (SCTAB nTab=0; nTab < rDoc.GetTableCount(); nTab++)
1147 {
1148 rDoc.GetName(nTab, aOriginalTabNames[nTab]);
1149 }
1150
1151 // new tab names
1152 std::vector<OUString> aNewTabNames;
1153 aNewTabNames.reserve(rDoc.GetTableCount());
1154
1155 // check and rename
1156 for (SCTAB nTab=0; nTab < rDoc.GetTableCount(); nTab++)
1157 {
1158 const OUString& rOriginalName = aOriginalTabNames[nTab];
1159 if (rOriginalName.getLength() > MAX_TAB_NAME_LENGTH)
1160 {
1161 OUString aNewName;
1162
1163 // let's try just truncate "<first 31 chars>"
1164 if (aNewName.isEmpty())
1165 {
1166 aNewName = rOriginalName.copy(0, MAX_TAB_NAME_LENGTH);
1167 if (aNewTabNames.end() != std::find(aNewTabNames.begin(), aNewTabNames.end(), aNewName) ||
1168 aOriginalTabNames.end() != std::find(aOriginalTabNames.begin(), aOriginalTabNames.end(), aNewName))
1169 {
1170 // was found => let's use another tab name
1171 aNewName.clear();
1172 }
1173 }
1174
1175 // let's try "<first N chars>-XXX" template
1176 for (int digits=1; digits<10 && aNewName.isEmpty(); digits++)
1177 {
1178 const int rangeStart = pow(10, digits - 1);
1179 const int rangeEnd = pow(10, digits);
1180
1181 for (int i=rangeStart; i<rangeEnd && aNewName.isEmpty(); i++)
1182 {
1183 aNewName = OUString::Concat(rOriginalName.subView(0, MAX_TAB_NAME_LENGTH - 1 - digits)) + "-" + OUString::number(i);
1184 if (aNewTabNames.end() != std::find(aNewTabNames.begin(), aNewTabNames.end(), aNewName) ||
1185 aOriginalTabNames.end() != std::find(aOriginalTabNames.begin(), aOriginalTabNames.end(), aNewName))
1186 {
1187 // was found => let's use another tab name
1188 aNewName.clear();
1189 }
1190 }
1191 }
1192
1193 if (!aNewName.isEmpty())
1194 {
1195 // new name was created => rename
1196 renameTab(nTab, aNewName);
1197 aNewTabNames.push_back(aNewName);
1198 }
1199 else
1200 {
1201 // default: do not rename
1202 aNewTabNames.push_back(rOriginalName);
1203 }
1204 }
1205 else
1206 {
1207 // default: do not rename
1208 aNewTabNames.push_back(rOriginalName);
1209 }
1210 }
1211 }
1212
1213 void XclExpXmlStream::restoreTabNames(const std::vector<OUString>& aOriginalTabNames)
1214 {
1215 ScDocShell* pShell = getDocShell();
1216 ScDocument& rDoc = pShell->GetDocument();
1217
1218 for (SCTAB nTab=0; nTab < rDoc.GetTableCount(); nTab++)
1219 {
1220 const OUString& rOriginalName = aOriginalTabNames[nTab];
1221
1222 OUString rModifiedName;
1223 rDoc.GetName(nTab, rModifiedName);
1224
1225 if (rOriginalName != rModifiedName)
1226 {
1227 renameTab(nTab, rOriginalName);
1228 }
1229 }
1230 }
1231
1232 void XclExpXmlStream::renameTab(SCTAB aTab, OUString aNewName)
1233 {
1234 ScDocShell* pShell = getDocShell();
1235 ScDocument& rDoc = pShell->GetDocument();
1236
1237 bool bAutoCalcShellDisabled = rDoc.IsAutoCalcShellDisabled();
1238 bool bIdleEnabled = rDoc.IsIdleEnabled();
1239
1240 rDoc.SetAutoCalcShellDisabled( true );
1241 rDoc.EnableIdle(false);
1242
1243 if (rDoc.RenameTab(aTab, aNewName))
1244 {
1245 SfxGetpApp()->Broadcast(SfxHint(SfxHintId::ScTablesChanged));
1246 }
1247
1248 rDoc.SetAutoCalcShellDisabled( bAutoCalcShellDisabled );
1249 rDoc.EnableIdle(bIdleEnabled);
1250 }
1251
1252 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE