editeng/source/uno/unoforou.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
  21 #include <osl/diagnose.h>
  22 #include <tools/debug.hxx>
  23 #include <svl/style.hxx>
  24 #include <com/sun/star/i18n/WordType.hpp>
  25
  26 #include <svl/itemset.hxx>
  27 #include <editeng/editeng.hxx>
  28 #include <editeng/editdata.hxx>
  29 #include <editeng/outliner.hxx>
  30 #include <editeng/unoedhlp.hxx>
  31 #include <svl/poolitem.hxx>
  32
  33 #include <editeng/unoforou.hxx>
  34 #include <editeng/outlobj.hxx>
  35 #include "unofored_internal.hxx"
  36
  37 using namespace ::com::sun::star;
  38
  39
  40 SvxOutlinerForwarder::SvxOutlinerForwarder( Outliner& rOutl, bool bOutlText /* = false */ ) :
  41     rOutliner( rOutl ),
  42     bOutlinerText( bOutlText ),
  43     mnParaAttribsCache( 0 )
  44 {
  45 }
  46
  47 SvxOutlinerForwarder::~SvxOutlinerForwarder()
  48 {
  49     flushCache();
  50 }
  51
  52 sal_Int32 SvxOutlinerForwarder::GetParagraphCount() const
  53 {
  54     return rOutliner.GetParagraphCount();
  55 }
  56
  57 sal_Int32 SvxOutlinerForwarder::GetTextLen( sal_Int32 nParagraph ) const
  58 {
  59     return rOutliner.GetEditEngine().GetTextLen( nParagraph );
  60 }
  61
  62 OUString SvxOutlinerForwarder::GetText( const ESelection& rSel ) const
  63 {
  64     //! GetText (ESelection) should probably also be in the Outliner
  65     // in the time being use as the hack for the EditEngine:
  66     EditEngine* pEditEngine = const_cast<EditEngine*>(&rOutliner.GetEditEngine());
  67     return pEditEngine->GetText( rSel );
  68 }
  69
  70 static SfxItemSet ImplOutlinerForwarderGetAttribs( const ESelection& rSel, EditEngineAttribs nOnlyHardAttrib, EditEngine& rEditEngine )
  71 {
  72     if( rSel.nStartPara == rSel.nEndPara )
  73     {
  74         GetAttribsFlags nFlags = GetAttribsFlags::NONE;
  75
  76         switch( nOnlyHardAttrib )
  77         {
  78         case EditEngineAttribs::All:
  79             nFlags = GetAttribsFlags::ALL;
  80             break;
  81         case EditEngineAttribs::OnlyHard:
  82             nFlags = GetAttribsFlags::CHARATTRIBS;
  83             break;
  84         default:
  85             OSL_FAIL("unknown flags for SvxOutlinerForwarder::GetAttribs");
  86         }
  87         return rEditEngine.GetAttribs( rSel.nStartPara, rSel.nStartPos, rSel.nEndPos, nFlags );
  88     }
  89     else
  90     {
  91         return rEditEngine.GetAttribs( rSel, nOnlyHardAttrib );
  92     }
  93 }
  94
  95 SfxItemSet SvxOutlinerForwarder::GetAttribs( const ESelection& rSel, EditEngineAttribs nOnlyHardAttrib ) const
  96 {
  97     if( mpAttribsCache && ( EditEngineAttribs::All == nOnlyHardAttrib ) )
  98     {
  99         // have we the correct set in cache?
 100         if( maAttribCacheSelection == rSel )
 101         {
 102             // yes! just return the cache
 103             return *mpAttribsCache;
 104         }
 105         else
 106         {
 107             // no, we need delete the old cache
 108             mpAttribsCache.reset();
 109         }
 110     }
 111
 112     //! Does it not exist on the Outliner?
 113     //! and why is the GetAttribs on the EditEngine not a const?
 114     EditEngine& rEditEngine = const_cast<EditEngine&>(rOutliner.GetEditEngine());
 115
 116     SfxItemSet aSet( ImplOutlinerForwarderGetAttribs( rSel, nOnlyHardAttrib, rEditEngine ) );
 117
 118     if( EditEngineAttribs::All == nOnlyHardAttrib )
 119     {
 120         mpAttribsCache.reset(new SfxItemSet( aSet ));
 121         maAttribCacheSelection = rSel;
 122     }
 123
 124     SfxStyleSheet* pStyle = rEditEngine.GetStyleSheet( rSel.nStartPara );
 125     if( pStyle )
 126         aSet.SetParent( &(pStyle->GetItemSet() ) );
 127
 128     return aSet;
 129 }
 130
 131 SfxItemSet SvxOutlinerForwarder::GetParaAttribs( sal_Int32 nPara ) const
 132 {
 133     if( mpParaAttribsCache )
 134     {
 135         // have we the correct set in cache?
 136         if( nPara == mnParaAttribsCache )
 137         {
 138             // yes! just return the cache
 139             return *mpParaAttribsCache;
 140         }
 141         else
 142         {
 143             // no, we need delete the old cache
 144             mpParaAttribsCache.reset();
 145         }
 146     }
 147
 148     mpParaAttribsCache.reset(new SfxItemSet( rOutliner.GetParaAttribs( nPara ) ));
 149     mnParaAttribsCache = nPara;
 150
 151     EditEngine& rEditEngine = const_cast<EditEngine&>(rOutliner.GetEditEngine());
 152
 153     SfxStyleSheet* pStyle = rEditEngine.GetStyleSheet( nPara );
 154     if( pStyle )
 155         mpParaAttribsCache->SetParent( &(pStyle->GetItemSet() ) );
 156
 157     return *mpParaAttribsCache;
 158 }
 159
 160 void SvxOutlinerForwarder::SetParaAttribs( sal_Int32 nPara, const SfxItemSet& rSet )
 161 {
 162     flushCache();
 163
 164     const SfxItemSet* pOldParent = rSet.GetParent();
 165     if( pOldParent )
 166         const_cast<SfxItemSet*>(&rSet)->SetParent( nullptr );
 167
 168     rOutliner.SetParaAttribs( nPara, rSet );
 169
 170     if( pOldParent )
 171         const_cast<SfxItemSet*>(&rSet)->SetParent( pOldParent );
 172 }
 173
 174 void SvxOutlinerForwarder::RemoveAttribs( const ESelection& rSelection )
 175 {
 176     rOutliner.RemoveAttribs( rSelection, false/*bRemoveParaAttribs*/, 0 );
 177 }
 178
 179 SfxItemPool* SvxOutlinerForwarder::GetPool() const
 180 {
 181     return rOutliner.GetEmptyItemSet().GetPool();
 182 }
 183
 184 void SvxOutlinerForwarder::GetPortions( sal_Int32 nPara, std::vector<sal_Int32>& rList ) const
 185 {
 186     const_cast<EditEngine&>(rOutliner.GetEditEngine()).GetPortions( nPara, rList );
 187 }
 188
 189 void SvxOutlinerForwarder::QuickInsertText( const OUString& rText, const ESelection& rSel )
 190 {
 191     flushCache();
 192     if( rText.isEmpty() )
 193     {
 194         rOutliner.QuickDelete( rSel );
 195     }
 196     else
 197     {
 198         rOutliner.QuickInsertText( rText, rSel );
 199     }
 200 }
 201
 202 void SvxOutlinerForwarder::QuickInsertLineBreak( const ESelection& rSel )
 203 {
 204     flushCache();
 205     rOutliner.QuickInsertLineBreak( rSel );
 206 }
 207
 208 void SvxOutlinerForwarder::QuickInsertField( const SvxFieldItem& rFld, const ESelection& rSel )
 209 {
 210     flushCache();
 211     rOutliner.QuickInsertField( rFld, rSel );
 212 }
 213
 214 void SvxOutlinerForwarder::QuickSetAttribs( const SfxItemSet& rSet, const ESelection& rSel )
 215 {
 216     flushCache();
 217     rOutliner.QuickSetAttribs( rSet, rSel );
 218 }
 219
 220 OUString SvxOutlinerForwarder::CalcFieldValue( const SvxFieldItem& rField, sal_Int32 nPara, sal_Int32 nPos, std::optional<Color>& rpTxtColor, std::optional<Color>& rpFldColor )
 221 {
 222     return rOutliner.CalcFieldValue( rField, nPara, nPos, rpTxtColor, rpFldColor );
 223 }
 224
 225 void SvxOutlinerForwarder::FieldClicked( const SvxFieldItem& /*rField*/ )
 226 {
 227 }
 228
 229 bool SvxOutlinerForwarder::IsValid() const
 230 {
 231     // cannot reliably query outliner state
 232     // while in the middle of an update
 233     return rOutliner.GetUpdateMode();
 234 }
 235
 236 SfxItemState SvxOutlinerForwarder::GetItemState( const ESelection& rSel, sal_uInt16 nWhich ) const
 237 {
 238     return GetSvxEditEngineItemState( rOutliner.GetEditEngine(), rSel, nWhich );
 239 }
 240
 241 SfxItemState SvxOutlinerForwarder::GetItemState( sal_Int32 nPara, sal_uInt16 nWhich ) const
 242 {
 243     const SfxItemSet& rSet = rOutliner.GetParaAttribs( nPara );
 244     return rSet.GetItemState( nWhich );
 245 }
 246
 247
 248 void SvxOutlinerForwarder::flushCache()
 249 {
 250     mpAttribsCache.reset();
 251     mpParaAttribsCache.reset();
 252 }
 253
 254 LanguageType SvxOutlinerForwarder::GetLanguage( sal_Int32 nPara, sal_Int32 nIndex ) const
 255 {
 256     return rOutliner.GetLanguage(nPara, nIndex);
 257 }
 258
 259 sal_Int32 SvxOutlinerForwarder::GetFieldCount( sal_Int32 nPara ) const
 260 {
 261     return rOutliner.GetEditEngine().GetFieldCount(nPara);
 262 }
 263
 264 EFieldInfo SvxOutlinerForwarder::GetFieldInfo( sal_Int32 nPara, sal_uInt16 nField ) const
 265 {
 266     return rOutliner.GetEditEngine().GetFieldInfo( nPara, nField );
 267 }
 268
 269 EBulletInfo SvxOutlinerForwarder::GetBulletInfo( sal_Int32 nPara ) const
 270 {
 271     return rOutliner.GetBulletInfo( nPara );
 272 }
 273
 274 tools::Rectangle SvxOutlinerForwarder::GetCharBounds( sal_Int32 nPara, sal_Int32 nIndex ) const
 275 {
 276     // EditEngine's 'internal' methods like GetCharacterBounds()
 277     // don't rotate for vertical text.
 278     Size aSize( rOutliner.CalcTextSize() );
 279     // swap width and height
 280     tools::Long tmp = aSize.Width();
 281     aSize.setWidth(aSize.Height());
 282     aSize.setHeight(tmp);
 283     bool bIsVertical( rOutliner.IsVertical() );
 284
 285     // #108900# Handle virtual position one-past-the end of the string
 286     if( nIndex >= GetTextLen(nPara) )
 287     {
 288         tools::Rectangle aLast;
 289
 290         if( nIndex )
 291         {
 292             // use last character, if possible
 293             aLast = rOutliner.GetEditEngine().GetCharacterBounds( EPosition(nPara, nIndex-1) );
 294
 295             // move at end of this last character, make one pixel wide
 296             aLast.Move( aLast.Right() - aLast.Left(), 0 );
 297             aLast.SetSize( Size(1, aLast.GetHeight()) );
 298
 299             // take care for CTL
 300             aLast = SvxEditSourceHelper::EEToUserSpace( aLast, aSize, bIsVertical );
 301         }
 302         else
 303         {
 304             // #109864# Bounds must lie within the paragraph
 305             aLast = GetParaBounds( nPara );
 306
 307             // #109151# Don't use paragraph height, but line height
 308             // instead. aLast is already CTL-correct
 309             if( bIsVertical)
 310                 aLast.SetSize( Size( rOutliner.GetLineHeight(nPara), 1 ) );
 311             else
 312                 aLast.SetSize( Size( 1, rOutliner.GetLineHeight(nPara) ) );
 313         }
 314
 315         return aLast;
 316     }
 317     else
 318     {
 319         return SvxEditSourceHelper::EEToUserSpace( rOutliner.GetEditEngine().GetCharacterBounds( EPosition(nPara, nIndex) ),
 320                                                    aSize, bIsVertical );
 321     }
 322 }
 323
 324 tools::Rectangle SvxOutlinerForwarder::GetParaBounds( sal_Int32 nPara ) const
 325 {
 326     return rOutliner.GetParaBounds( nPara );
 327 }
 328
 329 MapMode SvxOutlinerForwarder::GetMapMode() const
 330 {
 331     return rOutliner.GetRefMapMode();
 332 }
 333
 334 OutputDevice* SvxOutlinerForwarder::GetRefDevice() const
 335 {
 336     return rOutliner.GetRefDevice();
 337 }
 338
 339 bool SvxOutlinerForwarder::GetIndexAtPoint( const Point& rPos, sal_Int32& nPara, sal_Int32& nIndex ) const
 340 {
 341     Size aSize( rOutliner.CalcTextSize() );
 342     // swap width and height
 343     tools::Long tmp = aSize.Width();
 344     aSize.setWidth(aSize.Height());
 345     aSize.setHeight(tmp);
 346     Point aEEPos( SvxEditSourceHelper::UserSpaceToEE( rPos,
 347                                                       aSize,
 348                                                       rOutliner.IsVertical() ));
 349
 350     EPosition aDocPos = rOutliner.GetEditEngine().FindDocPosition( aEEPos );
 351
 352     nPara = aDocPos.nPara;
 353     nIndex = aDocPos.nIndex;
 354
 355     return true;
 356 }
 357
 358 bool SvxOutlinerForwarder::GetWordIndices( sal_Int32 nPara, sal_Int32 nIndex, sal_Int32& nStart, sal_Int32& nEnd ) const
 359 {
 360     ESelection aRes = rOutliner.GetEditEngine().GetWord( ESelection(nPara, nIndex, nPara, nIndex), css::i18n::WordType::DICTIONARY_WORD );
 361
 362     if( aRes.nStartPara == nPara &&
 363         aRes.nStartPara == aRes.nEndPara )
 364     {
 365         nStart = aRes.nStartPos;
 366         nEnd = aRes.nEndPos;
 367
 368         return true;
 369     }
 370
 371     return false;
 372 }
 373
 374 bool SvxOutlinerForwarder::GetAttributeRun( sal_Int32& nStartIndex, sal_Int32& nEndIndex, sal_Int32 nPara, sal_Int32 nIndex, bool bInCell ) const
 375 {
 376     SvxEditSourceHelper::GetAttributeRun( nStartIndex, nEndIndex, rOutliner.GetEditEngine(), nPara, nIndex, bInCell );
 377     return true;
 378 }
 379
 380 sal_Int32 SvxOutlinerForwarder::GetLineCount( sal_Int32 nPara ) const
 381 {
 382     return rOutliner.GetLineCount(nPara);
 383 }
 384
 385 sal_Int32 SvxOutlinerForwarder::GetLineLen( sal_Int32 nPara, sal_Int32 nLine ) const
 386 {
 387     return rOutliner.GetLineLen(nPara, nLine);
 388 }
 389
 390 void SvxOutlinerForwarder::GetLineBoundaries( /*out*/sal_Int32 &rStart, /*out*/sal_Int32 &rEnd, sal_Int32 nPara, sal_Int32 nLine ) const
 391 {
 392     return rOutliner.GetEditEngine().GetLineBoundaries( rStart, rEnd, nPara, nLine );
 393 }
 394
 395 sal_Int32 SvxOutlinerForwarder::GetLineNumberAtIndex( sal_Int32 nPara, sal_Int32 nIndex ) const
 396 {
 397     return rOutliner.GetEditEngine().GetLineNumberAtIndex( nPara, nIndex );
 398 }
 399
 400 bool SvxOutlinerForwarder::QuickFormatDoc( bool )
 401 {
 402     rOutliner.QuickFormatDoc();
 403
 404     return true;
 405 }
 406
 407 bool SvxOutlinerForwarder::Delete( const ESelection& rSelection )
 408 {
 409     flushCache();
 410     rOutliner.QuickDelete( rSelection );
 411     rOutliner.QuickFormatDoc();
 412
 413     return true;
 414 }
 415
 416 bool SvxOutlinerForwarder::InsertText( const OUString& rStr, const ESelection& rSelection )
 417 {
 418     flushCache();
 419     rOutliner.QuickInsertText( rStr, rSelection );
 420     rOutliner.QuickFormatDoc();
 421
 422     return true;
 423 }
 424
 425 sal_Int16 SvxOutlinerForwarder::GetDepth( sal_Int32 nPara ) const
 426 {
 427     DBG_ASSERT( 0 <= nPara && nPara < GetParagraphCount(), "SvxOutlinerForwarder::GetDepth: Invalid paragraph index");
 428
 429     Paragraph* pPara = rOutliner.GetParagraph( nPara );
 430
 431     sal_Int16 nLevel = -1;
 432
 433     if( pPara )
 434         nLevel = rOutliner.GetDepth( nPara );
 435
 436     return nLevel;
 437 }
 438
 439 bool SvxOutlinerForwarder::SetDepth( sal_Int32 nPara, sal_Int16 nNewDepth )
 440 {
 441     DBG_ASSERT( 0 <= nPara && nPara < GetParagraphCount(), "SvxOutlinerForwarder::SetDepth: Invalid paragraph index");
 442
 443     if( (nNewDepth >= -1) && (nNewDepth <= 9) && (0 <= nPara && nPara < GetParagraphCount()) )
 444     {
 445         Paragraph* pPara = rOutliner.GetParagraph( nPara );
 446         if( pPara )
 447         {
 448             rOutliner.SetDepth( pPara, nNewDepth );
 449
 450 //          const bool bOutlinerText = pSdrObject && (pSdrObject->GetObjInventor() == SdrInventor::Default) && (pSdrObject->GetObjIdentifier() == OBJ_OUTLINETEXT);
 451             if( bOutlinerText )
 452                 rOutliner.SetLevelDependentStyleSheet( nPara );
 453
 454             return true;
 455         }
 456     }
 457
 458     return false;
 459 }
 460
 461 sal_Int32 SvxOutlinerForwarder::GetNumberingStartValue( sal_Int32 nPara )
 462 {
 463     if( 0 <= nPara && nPara < GetParagraphCount() )
 464     {
 465         return rOutliner.GetNumberingStartValue( nPara );
 466     }
 467     else
 468     {
 469         OSL_FAIL( "SvxOutlinerForwarder::GetNumberingStartValue)(), Invalid paragraph index");
 470         return -1;
 471     }
 472 }
 473
 474 void SvxOutlinerForwarder::SetNumberingStartValue(  sal_Int32 nPara, sal_Int32 nNumberingStartValue )
 475 {
 476     if( 0 <= nPara && nPara < GetParagraphCount() )
 477     {
 478         rOutliner.SetNumberingStartValue( nPara, nNumberingStartValue );
 479     }
 480     else
 481     {
 482         OSL_FAIL( "SvxOutlinerForwarder::SetNumberingStartValue)(), Invalid paragraph index");
 483     }
 484 }
 485
 486 bool SvxOutlinerForwarder::IsParaIsNumberingRestart( sal_Int32 nPara )
 487 {
 488     if( 0 <= nPara && nPara < GetParagraphCount() )
 489     {
 490         return rOutliner.IsParaIsNumberingRestart( nPara );
 491     }
 492     else
 493     {
 494         OSL_FAIL( "SvxOutlinerForwarder::IsParaIsNumberingRestart)(), Invalid paragraph index");
 495         return false;
 496     }
 497 }
 498
 499 void SvxOutlinerForwarder::SetParaIsNumberingRestart(  sal_Int32 nPara, bool bParaIsNumberingRestart )
 500 {
 501     if( 0 <= nPara && nPara < GetParagraphCount() )
 502     {
 503         rOutliner.SetParaIsNumberingRestart( nPara, bParaIsNumberingRestart );
 504     }
 505     else
 506     {
 507         OSL_FAIL( "SvxOutlinerForwarder::SetParaIsNumberingRestart)(), Invalid paragraph index");
 508     }
 509 }
 510
 511 const SfxItemSet * SvxOutlinerForwarder::GetEmptyItemSetPtr()
 512 {
 513     EditEngine& rEditEngine = const_cast< EditEngine& >( rOutliner.GetEditEngine() );
 514     return &rEditEngine.GetEmptyItemSet();
 515 }
 516
 517 void SvxOutlinerForwarder::AppendParagraph()
 518 {
 519     EditEngine& rEditEngine = const_cast< EditEngine& >( rOutliner.GetEditEngine() );
 520     rEditEngine.InsertParagraph( rEditEngine.GetParagraphCount(), OUString() );
 521 }
 522
 523 sal_Int32 SvxOutlinerForwarder::AppendTextPortion( sal_Int32 nPara, const OUString &rText, const SfxItemSet & /*rSet*/ )
 524 {
 525     sal_Int32 nLen = 0;
 526
 527     EditEngine& rEditEngine = const_cast< EditEngine& >( rOutliner.GetEditEngine() );
 528     sal_Int32 nParaCount = rEditEngine.GetParagraphCount();
 529     DBG_ASSERT( 0 <= nPara && nPara < nParaCount, "paragraph index out of bounds" );
 530     if (0 <= nPara && nPara < nParaCount)
 531     {
 532         nLen = rEditEngine.GetTextLen( nPara );
 533         rEditEngine.QuickInsertText( rText, ESelection( nPara, nLen, nPara, nLen ) );
 534     }
 535
 536     return nLen;
 537 }
 538
 539 void  SvxOutlinerForwarder::CopyText(const SvxTextForwarder& rSource)
 540 {
 541     const SvxOutlinerForwarder* pSourceForwarder = dynamic_cast< const SvxOutlinerForwarder* >( &rSource );
 542     if( !pSourceForwarder )
 543         return;
 544     std::unique_ptr<OutlinerParaObject> pNewOutlinerParaObject = pSourceForwarder->rOutliner.CreateParaObject();
 545     rOutliner.SetText( *pNewOutlinerParaObject );
 546 }
 547
 548
 549 sal_Int32 SvxTextForwarder::GetNumberingStartValue( sal_Int32 )
 550 {
 551     return -1;
 552 }
 553
 554 void SvxTextForwarder::SetNumberingStartValue( sal_Int32, sal_Int32 )
 555 {
 556 }
 557
 558 bool SvxTextForwarder::IsParaIsNumberingRestart( sal_Int32  )
 559 {
 560     return false;
 561 }
 562
 563 void SvxTextForwarder::SetParaIsNumberingRestart( sal_Int32, bool )
 564 {
 565 }
 566
 567
 568 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */