sc/source/filter/oox/richstring.cxx

   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 <richstring.hxx>
  21 #include <biffhelper.hxx>
  22
  23 #include <com/sun/star/beans/XPropertySet.hpp>
  24 #include <com/sun/star/text/XText.hpp>
  25 #include <rtl/ustrbuf.hxx>
  26 #include <editeng/editobj.hxx>
  27 #include <osl/diagnose.h>
  28 #include <oox/helper/binaryinputstream.hxx>
  29 #include <oox/helper/attributelist.hxx>
  30 #include <oox/helper/propertyset.hxx>
  31 #include <oox/token/namespaces.hxx>
  32 #include <oox/token/tokens.hxx>
  33 #include <editutil.hxx>
  34
  35 #include <vcl/svapp.hxx>
  36
  37 namespace oox::xls {
  38
  39 using namespace ::com::sun::star::text;
  40 using namespace ::com::sun::star::uno;
  41
  42 namespace {
  43
  44 const sal_uInt8 BIFF12_STRINGFLAG_FONTS         = 0x01;
  45 const sal_uInt8 BIFF12_STRINGFLAG_PHONETICS     = 0x02;
  46
  47 bool lclNeedsRichTextFormat( const oox::xls::Font* pFont )
  48 {
  49     return pFont && pFont->needsRichTextFormat();
  50 }
  51
  52 } // namespace
  53
  54 RichStringPortion::RichStringPortion() :
  55     mnFontId( -1 ),
  56     mbConverted( false )
  57 {
  58 }
  59
  60 void RichStringPortion::setText( const OUString& rText )
  61 {
  62     maText = AttributeConversion::decodeXString(rText);
  63 }
  64
  65 FontRef const & RichStringPortion::createFont(const WorkbookHelper& rHelper)
  66 {
  67     mxFont = std::make_shared<Font>( rHelper, false );
  68     return mxFont;
  69 }
  70
  71 void RichStringPortion::setFontId( sal_Int32 nFontId )
  72 {
  73     mnFontId = nFontId;
  74 }
  75
  76 void RichStringPortion::finalizeImport(const WorkbookHelper& rHelper)
  77 {
  78     if( mxFont )
  79         mxFont->finalizeImport();
  80     else if( mnFontId >= 0 )
  81         mxFont = rHelper.getStyles().getFont( mnFontId );
  82 }
  83
  84 void RichStringPortion::convert( const Reference< XText >& rxText, bool bReplace )
  85 {
  86     if ( mbConverted )
  87         return;
  88
  89     Reference< XTextRange > xRange;
  90     if( bReplace )
  91         xRange = rxText;
  92     else
  93         xRange = rxText->getEnd();
  94     OSL_ENSURE( xRange.is(), "RichStringPortion::convert - cannot get text range interface" );
  95
  96     if( xRange.is() )
  97     {
  98         xRange->setString( maText );
  99         if( mxFont )
 100         {
 101             PropertySet aPropSet( xRange );
 102             mxFont->writeToPropertySet( aPropSet );
 103         }
 104     }
 105
 106     mbConverted = true;
 107 }
 108
 109 void RichStringPortion::convert( ScEditEngineDefaulter& rEE, ESelection& rSelection, const oox::xls::Font* pFont )
 110 {
 111     rSelection.CollapseToEnd();
 112     SfxItemSet aItemSet( rEE.GetEmptyItemSet() );
 113
 114     const Font* pFontToUse = mxFont ? mxFont.get() : lclNeedsRichTextFormat( pFont ) ? pFont : nullptr;
 115
 116     if ( pFontToUse )
 117         pFontToUse->fillToItemSet( aItemSet, true );
 118
 119     // #TODO need to manually adjust nEndPos ( and nEndPara ) to cater for any paragraphs
 120     sal_Int32 nLastParaLoc = -1;
 121     sal_Int32 nSearchIndex = maText.indexOf( '\n' );
 122     sal_Int32 nParaOccurrence = 0;
 123     while ( nSearchIndex != -1 )
 124     {
 125         nLastParaLoc = nSearchIndex;
 126         ++nParaOccurrence;
 127         rSelection.end.nIndex = 0;
 128         nSearchIndex = maText.indexOf( '\n', nSearchIndex + 1);
 129     }
 130
 131     rSelection.end.nPara += nParaOccurrence;
 132     if ( nLastParaLoc != -1 )
 133     {
 134         rSelection.end.nIndex = maText.getLength() - 1 - nLastParaLoc;
 135     }
 136     else
 137     {
 138         rSelection.end.nIndex = rSelection.start.nIndex + maText.getLength();
 139     }
 140     rEE.QuickSetAttribs( aItemSet, rSelection );
 141 }
 142
 143 void RichStringPortion::writeFontProperties( const Reference<XText>& rxText ) const
 144 {
 145     PropertySet aPropSet(rxText);
 146
 147     if (mxFont)
 148         mxFont->writeToPropertySet(aPropSet);
 149 }
 150
 151 void FontPortionModel::read( SequenceInputStream& rStrm )
 152 {
 153     mnPos = rStrm.readuInt16();
 154     mnFontId = rStrm.readuInt16();
 155 }
 156
 157 void FontPortionModelList::appendPortion( const FontPortionModel& rPortion )
 158 {
 159     // #i33341# real life -- same character index may occur several times
 160     OSL_ENSURE( mvModels.empty() || (mvModels.back().mnPos <= rPortion.mnPos), "FontPortionModelList::appendPortion - wrong char order" );
 161     if( mvModels.empty() || (mvModels.back().mnPos < rPortion.mnPos) )
 162         mvModels.push_back( rPortion );
 163     else
 164         mvModels.back().mnFontId = rPortion.mnFontId;
 165 }
 166
 167 void FontPortionModelList::importPortions( SequenceInputStream& rStrm )
 168 {
 169     sal_Int32 nCount = rStrm.readInt32();
 170     mvModels.clear();
 171     if( nCount > 0 )
 172     {
 173         mvModels.reserve( getLimitedValue< size_t, sal_Int64 >( nCount, 0, rStrm.getRemaining() / 4 ) );
 174         /*  #i33341# real life -- same character index may occur several times
 175             -> use appendPortion() to validate string position. */
 176         FontPortionModel aPortion;
 177         for( sal_Int32 nIndex = 0; !rStrm.isEof() && (nIndex < nCount); ++nIndex )
 178         {
 179             aPortion.read( rStrm );
 180             appendPortion( aPortion );
 181         }
 182     }
 183 }
 184
 185 PhoneticDataModel::PhoneticDataModel() :
 186     mnFontId( -1 ),
 187     mnType( XML_fullwidthKatakana ),
 188     mnAlignment( XML_left )
 189 {
 190 }
 191
 192 void PhoneticDataModel::setBiffData( sal_Int32 nType, sal_Int32 nAlignment )
 193 {
 194     static const sal_Int32 spnTypeIds[] = { XML_halfwidthKatakana, XML_fullwidthKatakana, XML_hiragana, XML_noConversion };
 195     mnType = STATIC_ARRAY_SELECT( spnTypeIds, nType, XML_fullwidthKatakana );
 196
 197     static const sal_Int32 spnAlignments[] = { XML_noControl, XML_left, XML_center, XML_distributed };
 198     mnAlignment = STATIC_ARRAY_SELECT( spnAlignments, nAlignment, XML_left );
 199 }
 200
 201 PhoneticSettings::PhoneticSettings( const WorkbookHelper& rHelper ) :
 202     WorkbookHelper( rHelper )
 203 {
 204 }
 205
 206 void PhoneticSettings::importPhoneticPr( const AttributeList& rAttribs )
 207 {
 208     maModel.mnFontId    = rAttribs.getInteger( XML_fontId, -1 );
 209     maModel.mnType      = rAttribs.getToken( XML_type, XML_fullwidthKatakana );
 210     maModel.mnAlignment = rAttribs.getToken( XML_alignment, XML_left );
 211 }
 212
 213 void PhoneticSettings::importPhoneticPr( SequenceInputStream& rStrm )
 214 {
 215     sal_uInt16 nFontId;
 216     sal_Int32 nType, nAlignment;
 217     nFontId = rStrm.readuInt16();
 218     nType = rStrm.readInt32();
 219     nAlignment = rStrm.readInt32();
 220     maModel.mnFontId = nFontId;
 221     maModel.setBiffData( nType, nAlignment );
 222 }
 223
 224 void PhoneticSettings::importStringData( SequenceInputStream& rStrm )
 225 {
 226     sal_uInt16 nFontId, nFlags;
 227     nFontId = rStrm.readuInt16();
 228     nFlags = rStrm.readuInt16();
 229     maModel.mnFontId = nFontId;
 230     maModel.setBiffData( extractValue< sal_Int32 >( nFlags, 0, 2 ), extractValue< sal_Int32 >( nFlags, 2, 2 ) );
 231 }
 232
 233 RichStringPhonetic::RichStringPhonetic() :
 234     mnBasePos( -1 ),
 235     mnBaseEnd( -1 )
 236 {
 237 }
 238
 239 void RichStringPhonetic::setText( const OUString& rText )
 240 {
 241     maText = rText;
 242 }
 243
 244 void RichStringPhonetic::importPhoneticRun( const AttributeList& rAttribs )
 245 {
 246     mnBasePos = rAttribs.getInteger( XML_sb, -1 );
 247     mnBaseEnd = rAttribs.getInteger( XML_eb, -1 );
 248 }
 249
 250 void RichStringPhonetic::setBaseRange( sal_Int32 nBasePos, sal_Int32 nBaseEnd )
 251 {
 252     mnBasePos = nBasePos;
 253     mnBaseEnd = nBaseEnd;
 254 }
 255
 256 void PhoneticPortionModel::read( SequenceInputStream& rStrm )
 257 {
 258     mnPos = rStrm.readuInt16();
 259     mnBasePos = rStrm.readuInt16();
 260     mnBaseLen = rStrm.readuInt16();
 261 }
 262
 263 void PhoneticPortionModelList::appendPortion( const PhoneticPortionModel& rPortion )
 264 {
 265     // same character index may occur several times
 266     OSL_ENSURE( mvModels.empty() || ((mvModels.back().mnPos <= rPortion.mnPos) &&
 267         (mvModels.back().mnBasePos + mvModels.back().mnBaseLen <= rPortion.mnBasePos)),
 268         "PhoneticPortionModelList::appendPortion - wrong char order" );
 269     if( mvModels.empty() || (mvModels.back().mnPos < rPortion.mnPos) )
 270     {
 271         mvModels.push_back( rPortion );
 272     }
 273     else if( mvModels.back().mnPos == rPortion.mnPos )
 274     {
 275         mvModels.back().mnBasePos = rPortion.mnBasePos;
 276         mvModels.back().mnBaseLen = rPortion.mnBaseLen;
 277     }
 278 }
 279
 280 void PhoneticPortionModelList::importPortions( SequenceInputStream& rStrm )
 281 {
 282     sal_Int32 nCount = rStrm.readInt32();
 283     mvModels.clear();
 284     if( nCount > 0 )
 285     {
 286         mvModels.reserve( getLimitedValue< size_t, sal_Int64 >( nCount, 0, rStrm.getRemaining() / 6 ) );
 287         PhoneticPortionModel aPortion;
 288         for( sal_Int32 nIndex = 0; !rStrm.isEof() && (nIndex < nCount); ++nIndex )
 289         {
 290             aPortion.read( rStrm );
 291             appendPortion( aPortion );
 292         }
 293     }
 294 }
 295
 296 sal_Int32 RichString::importText(const AttributeList& rAttribs)
 297 {
 298     setAttributes(rAttribs);
 299
 300     return createPortion();
 301 }
 302
 303 sal_Int32 RichString::importRun()
 304 {
 305     return createPortion();
 306 }
 307
 308 void  RichString::setAttributes(const AttributeList& rAttribs)
 309 {
 310     auto aAttrSpace = rAttribs.getString(oox::NMSP_xml | oox::XML_space);
 311     if (aAttrSpace && *aAttrSpace == "preserve")
 312         mbPreserveSpace = true;
 313 }
 314
 315 RichStringPhoneticRef RichString::importPhoneticRun( const AttributeList& rAttribs )
 316 {
 317     RichStringPhoneticRef xPhonetic = createPhonetic();
 318     xPhonetic->importPhoneticRun( rAttribs );
 319     return xPhonetic;
 320 }
 321
 322 void RichString::importPhoneticPr( const AttributeList& rAttribs, const WorkbookHelper& rHelper )
 323 {
 324     if (!mxPhonSettings)
 325         mxPhonSettings.reset(new PhoneticSettings(rHelper));
 326     mxPhonSettings->importPhoneticPr( rAttribs );
 327 }
 328
 329 void RichString::importString( SequenceInputStream& rStrm, bool bRich, const WorkbookHelper& rHelper )
 330 {
 331     sal_uInt8 nFlags = bRich ? rStrm.readuInt8() : 0;
 332     OUString aBaseText = BiffHelper::readString( rStrm );
 333
 334     if( !rStrm.isEof() && getFlag( nFlags, BIFF12_STRINGFLAG_FONTS ) )
 335     {
 336         FontPortionModelList aPortions;
 337         aPortions.importPortions( rStrm );
 338         createTextPortions( aBaseText, aPortions );
 339     }
 340     else
 341     {
 342         getPortion(createPortion()).setText( aBaseText );
 343     }
 344
 345     if( !rStrm.isEof() && getFlag( nFlags, BIFF12_STRINGFLAG_PHONETICS ) )
 346     {
 347         OUString aPhoneticText = BiffHelper::readString( rStrm );
 348         PhoneticPortionModelList aPortions;
 349         aPortions.importPortions( rStrm );
 350         if (!mxPhonSettings)
 351             mxPhonSettings.reset(new PhoneticSettings(rHelper));
 352         mxPhonSettings->importStringData( rStrm );
 353         createPhoneticPortions( aPhoneticText, aPortions, aBaseText.getLength() );
 354     }
 355 }
 356
 357 void RichString::finalizeImport(const WorkbookHelper& rHelper)
 358 {
 359     for (RichStringPortion& rPortion : maTextPortions)
 360         rPortion.finalizeImport( rHelper );
 361 }
 362
 363 bool RichString::extractPlainString( OUString& orString, const oox::xls::Font* pFirstPortionFont ) const
 364 {
 365     if( !maPhonPortions.empty() )
 366         return false;
 367     if( maTextPortions.empty() )
 368     {
 369         orString.clear();
 370         return true;
 371     }
 372     if( (maTextPortions.size() == 1) && !maTextPortions.front().hasFont() && !lclNeedsRichTextFormat( pFirstPortionFont ) )
 373     {
 374         orString = maTextPortions.front().getText();
 375         return orString.indexOf( '\x0A' ) < 0;
 376     }
 377     return false;
 378 }
 379
 380 void RichString::convert( const Reference< XText >& rxText )
 381 {
 382     if (maTextPortions.size() == 1)
 383     {
 384         // Set text directly to the cell when the string has only one portion.
 385         // It's much faster this way.
 386         const RichStringPortion& rPtn = maTextPortions.front();
 387         rxText->setString(rPtn.getText());
 388         rPtn.writeFontProperties(rxText);
 389         return;
 390     }
 391
 392     bool bReplaceOld = true;
 393     for( auto& rTextPortion : maTextPortions )
 394     {
 395         rTextPortion.convert( rxText, bReplaceOld );
 396         bReplaceOld = false;    // do not replace first portion text with following portions
 397     }
 398 }
 399
 400 OUString RichString::getStringContent() const
 401 {
 402     OUStringBuffer sString;
 403     for( auto& rTextPortion : maTextPortions )
 404         sString.append(rTextPortion.getText());
 405     return sString.makeStringAndClear();
 406 }
 407
 408 std::unique_ptr<EditTextObject> RichString::convert( ScEditEngineDefaulter& rEE, const oox::xls::Font* pFirstPortionFont )
 409 {
 410     ESelection aSelection;
 411
 412     OUString sString(getStringContent());
 413
 414     // fdo#84370 - diving into editeng is not thread safe.
 415     SolarMutexGuard aGuard;
 416
 417     rEE.SetTextCurrentDefaults(sString);
 418
 419     for( auto& rTextPortion : maTextPortions )
 420     {
 421         rTextPortion.convert( rEE, aSelection, pFirstPortionFont );
 422         pFirstPortionFont = nullptr;
 423     }
 424
 425     return rEE.CreateTextObject();
 426 }
 427
 428 // private --------------------------------------------------------------------
 429
 430 sal_Int32 RichString::createPortion()
 431 {
 432     maTextPortions.emplace_back();
 433     return maTextPortions.size() - 1;
 434 }
 435
 436 RichStringPhoneticRef RichString::createPhonetic()
 437 {
 438     RichStringPhoneticRef xPhonetic = std::make_shared<RichStringPhonetic>();
 439     maPhonPortions.push_back( xPhonetic );
 440     return xPhonetic;
 441 }
 442
 443 void RichString::createTextPortions( std::u16string_view aText, FontPortionModelList& rPortions )
 444 {
 445     maTextPortions.clear();
 446     if( aText.empty() )
 447         return;
 448
 449     sal_Int32 nStrLen = aText.size();
 450     // add leading and trailing string position to ease the following loop
 451     if( rPortions.empty() || (rPortions.front().mnPos > 0) )
 452         rPortions.insert( rPortions.begin(), FontPortionModel( 0 ) );
 453     if( rPortions.back().mnPos < nStrLen )
 454         rPortions.push_back( FontPortionModel( nStrLen ) );
 455
 456     // create all string portions according to the font id vector
 457     for( ::std::vector< FontPortionModel >::const_iterator aIt = rPortions.begin(); aIt->mnPos < nStrLen; ++aIt )
 458     {
 459         sal_Int32 nPortionLen = (aIt + 1)->mnPos - aIt->mnPos;
 460         if( (0 < nPortionLen) && (aIt->mnPos + nPortionLen <= nStrLen) )
 461         {
 462             RichStringPortion& rPortion = getPortion(createPortion());
 463             rPortion.setText( OUString(aText.substr( aIt->mnPos, nPortionLen )) );
 464             rPortion.setFontId( aIt->mnFontId );
 465         }
 466     }
 467 }
 468
 469 void RichString::createPhoneticPortions( std::u16string_view aText, PhoneticPortionModelList& rPortions, sal_Int32 nBaseLen )
 470 {
 471     maPhonPortions.clear();
 472     if( aText.empty())
 473         return;
 474
 475     sal_Int32 nStrLen = aText.size();
 476     // no portions - assign phonetic text to entire base text
 477     if( rPortions.empty() )
 478         rPortions.push_back( PhoneticPortionModel( 0, 0, nBaseLen ) );
 479     // add trailing string position to ease the following loop
 480     if( rPortions.back().mnPos < nStrLen )
 481         rPortions.push_back( PhoneticPortionModel( nStrLen, nBaseLen, 0 ) );
 482
 483     // create all phonetic portions according to the portions vector
 484     for( ::std::vector< PhoneticPortionModel >::const_iterator aIt = rPortions.begin(); aIt->mnPos < nStrLen; ++aIt )
 485     {
 486         sal_Int32 nPortionLen = (aIt + 1)->mnPos - aIt->mnPos;
 487         if( (0 < nPortionLen) && (aIt->mnPos + nPortionLen <= nStrLen) )
 488         {
 489             RichStringPhoneticRef xPhonetic = createPhonetic();
 490             xPhonetic->setText( OUString(aText.substr( aIt->mnPos, nPortionLen )) );
 491             xPhonetic->setBaseRange( aIt->mnBasePos, aIt->mnBasePos + aIt->mnBaseLen );
 492         }
 493     }
 494 }
 495
 496 } // namespace oox::xls
 497
 498 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */