?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Version 5.2.6.1, tag libreoffice-5.2.6.1
[LibreOffice.git] / sc / source / filter / excel / xestring.cxx
blobcdb1601bb30fbef1ddcab53c10fab9c7feb974d8
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 <algorithm>
21 #include <cassert>
22
23 #include <osl/diagnose.h>
24 #include "xlstyle.hxx"
25 #include "xestyle.hxx"
26 #include "xestream.hxx"
27 #include "xestring.hxx"
28
29 using namespace ::oox;
30
31 namespace {
32
33 // compare vectors
34
35 /** Compares two vectors.
36 @return A negative value, if rLeft<rRight; or a positive value, if rLeft>rRight;
37 or 0, if rLeft==rRight. */
38 template< typename Type >
39 int lclCompareVectors( const ::std::vector< Type >& rLeft, const ::std::vector< Type >& rRight )
40 {
41 int nResult = 0;
42
43 // 1st: compare all elements of the vectors
44 typedef typename ::std::vector< Type >::const_iterator CIT;
45 CIT aEndL = rLeft.end(), aEndR = rRight.end();
46 for( CIT aItL = rLeft.begin(), aItR = rRight.begin(); !nResult && (aItL != aEndL) && (aItR != aEndR); ++aItL, ++aItR )
47 nResult = static_cast< int >( *aItL ) - static_cast< int >( *aItR );
48
49 // 2nd: no differences found so far -> compare the vector sizes. Shorter vector is less
50 if( !nResult )
51 nResult = static_cast< int >( rLeft.size() ) - static_cast< int >( rRight.size() );
52
53 return nResult;
54 }
55
56 // hashing helpers
57
58 /** Base class for value hashers.
59 @descr These function objects are used to hash any value to a sal_uInt32 value. */
60 template< typename Type >
61 struct XclHasher : public ::std::unary_function< Type, sal_uInt32 > {};
62
63 template< typename Type >
64 struct XclDirectHasher : public XclHasher< Type >
65 {
66 inline sal_uInt32 operator()( Type nVal ) const { return nVal; }
67 };
68
69 struct XclFormatRunHasher : public XclHasher< const XclFormatRun& >
70 {
71 inline sal_uInt32 operator()( const XclFormatRun& rRun ) const
72 { return (rRun.mnChar << 8) ^ rRun.mnFontIdx; }
73 };
74
75 /** Calculates a hash value from a vector.
76 @descr Uses the passed hasher function object to calculate hash values from
77 all vector elements. */
78 template< typename Type, typename ValueHasher >
79 sal_uInt16 lclHashVector( const ::std::vector< Type >& rVec, const ValueHasher& rHasher )
80 {
81 sal_uInt32 nHash = rVec.size();
82 typedef typename ::std::vector< Type >::const_iterator CIT;
83 for( CIT aIt = rVec.begin(), aEnd = rVec.end(); aIt != aEnd; ++aIt )
84 (nHash *= 31) += rHasher( *aIt );
85 return static_cast< sal_uInt16 >( nHash ^ (nHash >> 16) );
86 }
87
88 /** Calculates a hash value from a vector. Uses XclDirectHasher to hash the vector elements. */
89 template< typename Type >
90 inline sal_uInt16 lclHashVector( const ::std::vector< Type >& rVec )
91 {
92 return lclHashVector( rVec, XclDirectHasher< Type >() );
93 }
94
95 } // namespace
96
97 // constructors ---------------------------------------------------------------
98
99 XclExpString::XclExpString( XclStrFlags nFlags, sal_uInt16 nMaxLen )
100 {
101 Init( 0, nFlags, nMaxLen, true );
102 }
103
104 XclExpString::XclExpString( const OUString& rString, XclStrFlags nFlags, sal_uInt16 nMaxLen )
105 {
106 Assign( rString, nFlags, nMaxLen );
107 }
108
109 // assign ---------------------------------------------------------------------
110
111 void XclExpString::Assign( const OUString& rString, XclStrFlags nFlags, sal_uInt16 nMaxLen )
112 {
113 Build( rString.getStr(), rString.getLength(), nFlags, nMaxLen );
114 }
115
116 void XclExpString::Assign( sal_Unicode cChar )
117 {
118 Build( &cChar, 1, EXC_STR_DEFAULT, EXC_STR_MAXLEN );
119 }
120
121 void XclExpString::AssignByte(
122 const OUString& rString, rtl_TextEncoding eTextEnc, XclStrFlags nFlags, sal_uInt16 nMaxLen )
123 {
124 // length may differ from length of rString
125 OString aByteStr(OUStringToOString(rString, eTextEnc));
126 Build(aByteStr.getStr(), aByteStr.getLength(), nFlags, nMaxLen);
127 }
128
129 // append ---------------------------------------------------------------------
130
131 void XclExpString::Append( const OUString& rString )
132 {
133 BuildAppend( rString.getStr(), rString.getLength() );
134 }
135
136 void XclExpString::AppendByte( const OUString& rString, rtl_TextEncoding eTextEnc )
137 {
138 if (!rString.isEmpty())
139 {
140 // length may differ from length of rString
141 OString aByteStr(OUStringToOString(rString, eTextEnc));
142 BuildAppend(aByteStr.getStr(), aByteStr.getLength());
143 }
144 }
145
146 void XclExpString::AppendByte( sal_Unicode cChar, rtl_TextEncoding eTextEnc )
147 {
148 if( !cChar )
149 {
150 sal_Char cByteChar = 0;
151 BuildAppend( &cByteChar, 1 );
152 }
153 else
154 {
155 OString aByteStr( &cChar, 1, eTextEnc ); // length may be >1
156 BuildAppend( aByteStr.getStr(), aByteStr.getLength() );
157 }
158 }
159
160 // formatting runs ------------------------------------------------------------
161
162 void XclExpString::AppendFormat( sal_uInt16 nChar, sal_uInt16 nFontIdx, bool bDropDuplicate )
163 {
164 OSL_ENSURE( maFormats.empty() || (maFormats.back().mnChar < nChar), "XclExpString::AppendFormat - invalid char index" );
165 size_t nMaxSize = static_cast< size_t >( mbIsBiff8 ? EXC_STR_MAXLEN : EXC_STR_MAXLEN_8BIT );
166 if( maFormats.empty() || ((maFormats.size() < nMaxSize) && (!bDropDuplicate || (maFormats.back().mnFontIdx != nFontIdx))) )
167 maFormats.push_back( XclFormatRun( nChar, nFontIdx ) );
168 }
169
170 void XclExpString::AppendTrailingFormat( sal_uInt16 nFontIdx )
171 {
172 AppendFormat( mnLen, nFontIdx, false );
173 }
174
175 void XclExpString::LimitFormatCount( sal_uInt16 nMaxCount )
176 {
177 if( maFormats.size() > nMaxCount )
178 maFormats.erase( maFormats.begin() + nMaxCount, maFormats.end() );
179 }
180
181 sal_uInt16 XclExpString::GetLeadingFont()
182 {
183 sal_uInt16 nFontIdx = EXC_FONT_NOTFOUND;
184 if( !maFormats.empty() && (maFormats.front().mnChar == 0) )
185 {
186 nFontIdx = maFormats.front().mnFontIdx;
187 }
188 return nFontIdx;
189 }
190
191 sal_uInt16 XclExpString::RemoveLeadingFont()
192 {
193 sal_uInt16 nFontIdx = GetLeadingFont();
194 if( nFontIdx != EXC_FONT_NOTFOUND )
195 {
196 maFormats.erase( maFormats.begin() );
197 }
198 return nFontIdx;
199 }
200
201 bool XclExpString::IsEqual( const XclExpString& rCmp ) const
202 {
203 return
204 (mnLen == rCmp.mnLen) &&
205 (mbIsBiff8 == rCmp.mbIsBiff8) &&
206 (mbIsUnicode == rCmp.mbIsUnicode) &&
207 (mbWrapped == rCmp.mbWrapped) &&
208 (
209 ( mbIsBiff8 && (maUniBuffer == rCmp.maUniBuffer)) ||
210 (!mbIsBiff8 && (maCharBuffer == rCmp.maCharBuffer))
211 ) &&
212 (maFormats == rCmp.maFormats);
213 }
214
215 bool XclExpString::IsLessThan( const XclExpString& rCmp ) const
216 {
217 int nResult = mbIsBiff8 ?
218 lclCompareVectors( maUniBuffer, rCmp.maUniBuffer ) :
219 lclCompareVectors( maCharBuffer, rCmp.maCharBuffer );
220 return (nResult != 0) ? (nResult < 0) : (maFormats < rCmp.maFormats);
221 }
222
223 // get data -------------------------------------------------------------------
224
225 sal_uInt16 XclExpString::GetFormatsCount() const
226 {
227 return static_cast< sal_uInt16 >( maFormats.size() );
228 }
229
230 sal_uInt8 XclExpString::GetFlagField() const
231 {
232 return (mbIsUnicode ? EXC_STRF_16BIT : 0) | (IsWriteFormats() ? EXC_STRF_RICH : 0);
233 }
234
235 sal_uInt16 XclExpString::GetHeaderSize() const
236 {
237 return
238 (mb8BitLen ? 1 : 2) + // length field
239 (IsWriteFlags() ? 1 : 0) + // flag field
240 (IsWriteFormats() ? 2 : 0); // richtext formattting count
241 }
242
243 sal_Size XclExpString::GetBufferSize() const
244 {
245 return static_cast<sal_Size>(mnLen) * (mbIsUnicode ? 2 : 1);
246 }
247
248 sal_Size XclExpString::GetSize() const
249 {
250 return
251 GetHeaderSize() + // header
252 GetBufferSize() + // character buffer
253 (IsWriteFormats() ? (4 * GetFormatsCount()) : 0); // richtext formattting
254 }
255
256 sal_uInt16 XclExpString::GetChar( sal_uInt16 nCharIdx ) const
257 {
258 OSL_ENSURE( nCharIdx < Len(), "XclExpString::GetChar - invalid character index" );
259 return static_cast< sal_uInt16 >( mbIsBiff8 ? maUniBuffer[ nCharIdx ] : maCharBuffer[ nCharIdx ] );
260 }
261
262 sal_uInt16 XclExpString::GetHash() const
263 {
264 return
265 (mbIsBiff8 ? lclHashVector( maUniBuffer ) : lclHashVector( maCharBuffer )) ^
266 lclHashVector( maFormats, XclFormatRunHasher() );
267 }
268
269 // streaming ------------------------------------------------------------------
270
271 void XclExpString::WriteLenField( XclExpStream& rStrm ) const
272 {
273 if( mb8BitLen )
274 rStrm << static_cast< sal_uInt8 >( mnLen );
275 else
276 rStrm << mnLen;
277 }
278
279 void XclExpString::WriteFlagField( XclExpStream& rStrm ) const
280 {
281 if( mbIsBiff8 )
282 {
283 PrepareWrite( rStrm, 1 );
284 rStrm << GetFlagField();
285 rStrm.SetSliceSize( 0 );
286 }
287 }
288
289 void XclExpString::WriteHeader( XclExpStream& rStrm ) const
290 {
291 OSL_ENSURE( !mb8BitLen || (mnLen < 256), "XclExpString::WriteHeader - string too long" );
292 PrepareWrite( rStrm, GetHeaderSize() );
293 // length
294 WriteLenField( rStrm );
295 // flag field
296 if( IsWriteFlags() )
297 rStrm << GetFlagField();
298 // format run count
299 if( IsWriteFormats() )
300 rStrm << GetFormatsCount();
301 rStrm.SetSliceSize( 0 );
302 }
303
304 void XclExpString::WriteBuffer( XclExpStream& rStrm ) const
305 {
306 if( mbIsBiff8 )
307 rStrm.WriteUnicodeBuffer( maUniBuffer, GetFlagField() );
308 else
309 rStrm.WriteCharBuffer( maCharBuffer );
310 }
311
312 void XclExpString::WriteFormats( XclExpStream& rStrm, bool bWriteSize ) const
313 {
314 if( IsRich() )
315 {
316 XclFormatRunVec::const_iterator aIt = maFormats.begin(), aEnd = maFormats.end();
317 if( mbIsBiff8 )
318 {
319 if( bWriteSize )
320 rStrm << GetFormatsCount();
321 rStrm.SetSliceSize( 4 );
322 for( ; aIt != aEnd; ++aIt )
323 rStrm << aIt->mnChar << aIt->mnFontIdx;
324 }
325 else
326 {
327 if( bWriteSize )
328 rStrm << static_cast< sal_uInt8 >( GetFormatsCount() );
329 rStrm.SetSliceSize( 2 );
330 for( ; aIt != aEnd; ++aIt )
331 rStrm << static_cast< sal_uInt8 >( aIt->mnChar ) << static_cast< sal_uInt8 >( aIt->mnFontIdx );
332 }
333 rStrm.SetSliceSize( 0 );
334 }
335 }
336
337 void XclExpString::Write( XclExpStream& rStrm ) const
338 {
339 if (!mbSkipHeader)
340 WriteHeader( rStrm );
341 WriteBuffer( rStrm );
342 if( IsWriteFormats() ) // only in BIFF8 included in string
343 WriteFormats( rStrm );
344 }
345
346 void XclExpString::WriteHeaderToMem( sal_uInt8* pnMem ) const
347 {
348 assert(pnMem);
349 OSL_ENSURE( !mb8BitLen || (mnLen < 256), "XclExpString::WriteHeaderToMem - string too long" );
350 OSL_ENSURE( !IsWriteFormats(), "XclExpString::WriteHeaderToMem - formatted strings not supported" );
351 // length
352 if( mb8BitLen )
353 {
354 *pnMem = static_cast< sal_uInt8 >( mnLen );
355 ++pnMem;
356 }
357 else
358 {
359 ShortToSVBT16( mnLen, pnMem );
360 pnMem += 2;
361 }
362 // flag field
363 if( IsWriteFlags() )
364 *pnMem = GetFlagField();
365 }
366
367 void XclExpString::WriteBufferToMem( sal_uInt8* pnMem ) const
368 {
369 assert(pnMem);
370 if( !IsEmpty() )
371 {
372 if( mbIsBiff8 )
373 {
374 for( ScfUInt16Vec::const_iterator aIt = maUniBuffer.begin(), aEnd = maUniBuffer.end(); aIt != aEnd; ++aIt )
375 {
376 sal_uInt16 nChar = *aIt;
377 *pnMem = static_cast< sal_uInt8 >( nChar );
378 ++pnMem;
379 if( mbIsUnicode )
380 {
381 *pnMem = static_cast< sal_uInt8 >( nChar >> 8 );
382 ++pnMem;
383 }
384 }
385 }
386 else
387 memcpy( pnMem, &maCharBuffer[ 0 ], mnLen );
388 }
389 }
390
391 void XclExpString::WriteToMem( sal_uInt8* pnMem ) const
392 {
393 WriteHeaderToMem( pnMem );
394 WriteBufferToMem( pnMem + GetHeaderSize() );
395 }
396
397 static sal_uInt16 lcl_WriteRun( XclExpXmlStream& rStrm, const ScfUInt16Vec& rBuffer, sal_uInt16 nStart, sal_Int32 nLength, const XclExpFont* pFont )
398 {
399 if( nLength == 0 )
400 return nStart;
401
402 sax_fastparser::FSHelperPtr& rWorksheet = rStrm.GetCurrentStream();
403
404 rWorksheet->startElement( XML_r, FSEND );
405 if( pFont )
406 {
407 const XclFontData& rFontData = pFont->GetFontData();
408 rWorksheet->startElement( XML_rPr, FSEND );
409 XclXmlUtils::WriteFontData( rWorksheet, rFontData, XML_rFont );
410 rWorksheet->endElement( XML_rPr );
411 }
412 rWorksheet->startElement( XML_t,
413 FSNS(XML_xml, XML_space), "preserve", FSEND );
414 rWorksheet->writeEscaped( XclXmlUtils::ToOUString( rBuffer, nStart, nLength ) );
415 rWorksheet->endElement( XML_t );
416 rWorksheet->endElement( XML_r );
417 return nStart + nLength;
418 }
419
420 void XclExpString::WriteXml( XclExpXmlStream& rStrm ) const
421 {
422 sax_fastparser::FSHelperPtr rWorksheet = rStrm.GetCurrentStream();
423
424 if( !IsWriteFormats() )
425 {
426 rWorksheet->startElement( XML_t,
427 FSNS(XML_xml, XML_space), "preserve", FSEND );
428 rWorksheet->writeEscaped( XclXmlUtils::ToOUString( *this ) );
429 rWorksheet->endElement( XML_t );
430 }
431 else
432 {
433 XclExpFontBuffer& rFonts = rStrm.GetRoot().GetFontBuffer();
434 XclFormatRunVec::const_iterator aIt = maFormats.begin(), aEnd = maFormats.end();
435
436 sal_uInt16 nStart = 0;
437 const XclExpFont* pFont = nullptr;
438 for ( ; aIt != aEnd; ++aIt )
439 {
440 nStart = lcl_WriteRun( rStrm, GetUnicodeBuffer(),
441 nStart, aIt->mnChar-nStart, pFont );
442 pFont = rFonts.GetFont( aIt->mnFontIdx );
443 }
444 lcl_WriteRun( rStrm, GetUnicodeBuffer(),
445 nStart, GetUnicodeBuffer().size() - nStart, pFont );
446 }
447 }
448
449 bool XclExpString::IsWriteFlags() const
450 {
451 return mbIsBiff8 && (!IsEmpty() || !mbSmartFlags);
452 }
453
454 bool XclExpString::IsWriteFormats() const
455 {
456 return mbIsBiff8 && !mbSkipFormats && IsRich();
457 }
458
459 void XclExpString::SetStrLen( sal_Int32 nNewLen )
460 {
461 sal_uInt16 nAllowedLen = (mb8BitLen && (mnMaxLen > 255)) ? 255 : mnMaxLen;
462 mnLen = limit_cast< sal_uInt16 >( nNewLen, 0, nAllowedLen );
463 }
464
465 void XclExpString::CharsToBuffer( const sal_Unicode* pcSource, sal_Int32 nBegin, sal_Int32 nLen )
466 {
467 OSL_ENSURE( maUniBuffer.size() >= static_cast< size_t >( nBegin + nLen ),
468 "XclExpString::CharsToBuffer - char buffer invalid" );
469 ScfUInt16Vec::iterator aBeg = maUniBuffer.begin() + nBegin;
470 ScfUInt16Vec::iterator aEnd = aBeg + nLen;
471 const sal_Unicode* pcSrcChar = pcSource;
472 for( ScfUInt16Vec::iterator aIt = aBeg; aIt != aEnd; ++aIt, ++pcSrcChar )
473 {
474 *aIt = static_cast< sal_uInt16 >( *pcSrcChar );
475 if( *aIt & 0xFF00 )
476 mbIsUnicode = true;
477 }
478 if( !mbWrapped )
479 mbWrapped = ::std::find( aBeg, aEnd, EXC_LF ) != aEnd;
480 }
481
482 void XclExpString::CharsToBuffer( const sal_Char* pcSource, sal_Int32 nBegin, sal_Int32 nLen )
483 {
484 OSL_ENSURE( maCharBuffer.size() >= static_cast< size_t >( nBegin + nLen ),
485 "XclExpString::CharsToBuffer - char buffer invalid" );
486 ScfUInt8Vec::iterator aBeg = maCharBuffer.begin() + nBegin;
487 ScfUInt8Vec::iterator aEnd = aBeg + nLen;
488 const sal_Char* pcSrcChar = pcSource;
489 for( ScfUInt8Vec::iterator aIt = aBeg; aIt != aEnd; ++aIt, ++pcSrcChar )
490 *aIt = static_cast< sal_uInt8 >( *pcSrcChar );
491 mbIsUnicode = false;
492 if( !mbWrapped )
493 mbWrapped = ::std::find( aBeg, aEnd, EXC_LF_C ) != aEnd;
494 }
495
496 void XclExpString::Init( sal_Int32 nCurrLen, XclStrFlags nFlags, sal_uInt16 nMaxLen, bool bBiff8 )
497 {
498 mbIsBiff8 = bBiff8;
499 mbIsUnicode = bBiff8 && ::get_flag( nFlags, EXC_STR_FORCEUNICODE );
500 mb8BitLen = ::get_flag( nFlags, EXC_STR_8BITLENGTH );
501 mbSmartFlags = bBiff8 && ::get_flag( nFlags, EXC_STR_SMARTFLAGS );
502 mbSkipFormats = ::get_flag( nFlags, EXC_STR_SEPARATEFORMATS );
503 mbWrapped = false;
504 mbSkipHeader = ::get_flag( nFlags, EXC_STR_NOHEADER );
505 mnMaxLen = nMaxLen;
506 SetStrLen( nCurrLen );
507
508 maFormats.clear();
509 if( mbIsBiff8 )
510 {
511 maCharBuffer.clear();
512 maUniBuffer.resize( mnLen );
513 }
514 else
515 {
516 maUniBuffer.clear();
517 maCharBuffer.resize( mnLen );
518 }
519 }
520
521 void XclExpString::Build( const sal_Unicode* pcSource, sal_Int32 nCurrLen, XclStrFlags nFlags, sal_uInt16 nMaxLen )
522 {
523 Init( nCurrLen, nFlags, nMaxLen, true );
524 CharsToBuffer( pcSource, 0, mnLen );
525 }
526
527 void XclExpString::Build( const sal_Char* pcSource, sal_Int32 nCurrLen, XclStrFlags nFlags, sal_uInt16 nMaxLen )
528 {
529 Init( nCurrLen, nFlags, nMaxLen, false );
530 CharsToBuffer( pcSource, 0, mnLen );
531 }
532
533 void XclExpString::InitAppend( sal_Int32 nAddLen )
534 {
535 SetStrLen( static_cast< sal_Int32 >( mnLen ) + nAddLen );
536 if( mbIsBiff8 )
537 maUniBuffer.resize( mnLen );
538 else
539 maCharBuffer.resize( mnLen );
540 }
541
542 void XclExpString::BuildAppend( const sal_Unicode* pcSource, sal_Int32 nAddLen )
543 {
544 OSL_ENSURE( mbIsBiff8, "XclExpString::BuildAppend - must not be called at byte strings" );
545 if( mbIsBiff8 )
546 {
547 sal_uInt16 nOldLen = mnLen;
548 InitAppend( nAddLen );
549 CharsToBuffer( pcSource, nOldLen, mnLen - nOldLen );
550 }
551 }
552
553 void XclExpString::BuildAppend( const sal_Char* pcSource, sal_Int32 nAddLen )
554 {
555 OSL_ENSURE( !mbIsBiff8, "XclExpString::BuildAppend - must not be called at unicode strings" );
556 if( !mbIsBiff8 )
557 {
558 sal_uInt16 nOldLen = mnLen;
559 InitAppend( nAddLen );
560 CharsToBuffer( pcSource, nOldLen, mnLen - nOldLen );
561 }
562 }
563
564 void XclExpString::PrepareWrite( XclExpStream& rStrm, sal_uInt16 nBytes ) const
565 {
566 rStrm.SetSliceSize( nBytes + (mbIsUnicode ? 2 : 1) );
567 }
568
569 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE