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