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.start.nPara == rSel.end.nPara)
  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.start.nPara, rSel.start.nIndex, rSel.end.nIndex, 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( moAttribsCache && ( 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 *moAttribsCache;
 104         }
 105         else
 106         {
 107             // no, we need delete the old cache
 108             moAttribsCache.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         moAttribsCache.emplace( aSet );
 121         maAttribCacheSelection = rSel;
 122     }
 123
 124     SfxStyleSheet* pStyle = rEditEngine.GetStyleSheet(rSel.start.nPara);
 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( moParaAttribsCache )
 134     {
 135         // have we the correct set in cache?
 136         if( nPara == mnParaAttribsCache )
 137         {
 138             // yes! just return the cache
 139             return *moParaAttribsCache;
 140         }
 141         else
 142         {
 143             // no, we need delete the old cache
 144             moParaAttribsCache.reset();
 145         }
 146     }
 147
 148     moParaAttribsCache.emplace( 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         moParaAttribsCache->SetParent( &(pStyle->GetItemSet() ) );
 156
 157     return *moParaAttribsCache;
 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 OUString SvxOutlinerForwarder::GetStyleSheet(sal_Int32 nPara) const
 190 {
 191     if (auto pStyle = rOutliner.GetStyleSheet(nPara))
 192         return pStyle->GetName();
 193     return OUString();
 194 }
 195
 196 void SvxOutlinerForwarder::SetStyleSheet(sal_Int32 nPara, const OUString& rStyleName)
 197 {
 198     auto pStyleSheetPool = rOutliner.GetStyleSheetPool();
 199     if (auto pStyle = pStyleSheetPool ? pStyleSheetPool->Find(rStyleName, SfxStyleFamily::Para) : nullptr)
 200         rOutliner.SetStyleSheet(nPara, static_cast<SfxStyleSheet*>(pStyle));
 201 }
 202
 203 void SvxOutlinerForwarder::QuickInsertText( const OUString& rText, const ESelection& rSel )
 204 {
 205     flushCache();
 206     if( rText.isEmpty() )
 207     {
 208         rOutliner.QuickDelete( rSel );
 209     }
 210     else
 211     {
 212         rOutliner.QuickInsertText( rText, rSel );
 213     }
 214 }
 215
 216 void SvxOutlinerForwarder::QuickInsertLineBreak( const ESelection& rSel )
 217 {
 218     flushCache();
 219     rOutliner.QuickInsertLineBreak( rSel );
 220 }
 221
 222 void SvxOutlinerForwarder::QuickInsertField( const SvxFieldItem& rFld, const ESelection& rSel )
 223 {
 224     flushCache();
 225     rOutliner.QuickInsertField( rFld, rSel );
 226 }
 227
 228 void SvxOutlinerForwarder::QuickSetAttribs( const SfxItemSet& rSet, const ESelection& rSel )
 229 {
 230     flushCache();
 231     rOutliner.QuickSetAttribs( rSet, rSel );
 232 }
 233
 234 OUString SvxOutlinerForwarder::CalcFieldValue( const SvxFieldItem& rField, sal_Int32 nPara, sal_Int32 nPos, std::optional<Color>& rpTxtColor, std::optional<Color>& rpFldColor, std::optional<FontLineStyle>& rpFldLineStyle )
 235 {
 236     return rOutliner.CalcFieldValue( rField, nPara, nPos, rpTxtColor, rpFldColor, rpFldLineStyle );
 237 }
 238
 239 void SvxOutlinerForwarder::FieldClicked( const SvxFieldItem& /*rField*/ )
 240 {
 241 }
 242
 243 bool SvxOutlinerForwarder::IsValid() const
 244 {
 245     // cannot reliably query outliner state
 246     // while in the middle of an update
 247     return rOutliner.IsUpdateLayout();
 248 }
 249
 250 SfxItemState SvxOutlinerForwarder::GetItemState( const ESelection& rSel, sal_uInt16 nWhich ) const
 251 {
 252     return GetSvxEditEngineItemState( rOutliner.GetEditEngine(), rSel, nWhich );
 253 }
 254
 255 SfxItemState SvxOutlinerForwarder::GetItemState( sal_Int32 nPara, sal_uInt16 nWhich ) const
 256 {
 257     const SfxItemSet& rSet = rOutliner.GetParaAttribs( nPara );
 258     return rSet.GetItemState( nWhich );
 259 }
 260
 261
 262 void SvxOutlinerForwarder::flushCache()
 263 {
 264     moAttribsCache.reset();
 265     moParaAttribsCache.reset();
 266 }
 267
 268 LanguageType SvxOutlinerForwarder::GetLanguage( sal_Int32 nPara, sal_Int32 nIndex ) const
 269 {
 270     return rOutliner.GetLanguage(nPara, nIndex);
 271 }
 272
 273 std::vector<EFieldInfo> SvxOutlinerForwarder::GetFieldInfo( sal_Int32 nPara ) const
 274 {
 275     return rOutliner.GetEditEngine().GetFieldInfo( nPara );
 276 }
 277
 278 EBulletInfo SvxOutlinerForwarder::GetBulletInfo( sal_Int32 nPara ) const
 279 {
 280     return rOutliner.GetBulletInfo( nPara );
 281 }
 282
 283 tools::Rectangle SvxOutlinerForwarder::GetCharBounds( sal_Int32 nPara, sal_Int32 nIndex ) const
 284 {
 285     // EditEngine's 'internal' methods like GetCharacterBounds()
 286     // don't rotate for vertical text.
 287     Size aSize( rOutliner.CalcTextSize() );
 288     // swap width and height
 289     tools::Long tmp = aSize.Width();
 290     aSize.setWidth(aSize.Height());
 291     aSize.setHeight(tmp);
 292     bool bIsVertical( rOutliner.IsVertical() );
 293
 294     // #108900# Handle virtual position one-past-the end of the string
 295     if( nIndex >= GetTextLen(nPara) )
 296     {
 297         tools::Rectangle aLast;
 298
 299         if( nIndex )
 300         {
 301             // use last character, if possible
 302             aLast = rOutliner.GetEditEngine().GetCharacterBounds(EPaM(nPara, nIndex - 1));
 303
 304             // move at end of this last character, make one pixel wide
 305             aLast.Move( aLast.Right() - aLast.Left(), 0 );
 306             aLast.SetSize( Size(1, aLast.GetHeight()) );
 307
 308             // take care for CTL
 309             aLast = SvxEditSourceHelper::EEToUserSpace( aLast, aSize, bIsVertical );
 310         }
 311         else
 312         {
 313             // #109864# Bounds must lie within the paragraph
 314             aLast = GetParaBounds( nPara );
 315
 316             // #109151# Don't use paragraph height, but line height
 317             // instead. aLast is already CTL-correct
 318             if( bIsVertical)
 319                 aLast.SetSize( Size( rOutliner.GetLineHeight(nPara), 1 ) );
 320             else
 321                 aLast.SetSize( Size( 1, rOutliner.GetLineHeight(nPara) ) );
 322         }
 323
 324         return aLast;
 325     }
 326     else
 327     {
 328         return SvxEditSourceHelper::EEToUserSpace( rOutliner.GetEditEngine().GetCharacterBounds( EPaM(nPara, nIndex) ),
 329                                                    aSize, bIsVertical );
 330     }
 331 }
 332
 333 tools::Rectangle SvxOutlinerForwarder::GetParaBounds( sal_Int32 nPara ) const
 334 {
 335     return rOutliner.GetParaBounds( nPara );
 336 }
 337
 338 MapMode SvxOutlinerForwarder::GetMapMode() const
 339 {
 340     return rOutliner.GetRefMapMode();
 341 }
 342
 343 OutputDevice* SvxOutlinerForwarder::GetRefDevice() const
 344 {
 345     return rOutliner.GetRefDevice();
 346 }
 347
 348 bool SvxOutlinerForwarder::GetIndexAtPoint( const Point& rPos, sal_Int32& nPara, sal_Int32& nIndex ) const
 349 {
 350     Size aSize( rOutliner.CalcTextSize() );
 351     // swap width and height
 352     tools::Long tmp = aSize.Width();
 353     aSize.setWidth(aSize.Height());
 354     aSize.setHeight(tmp);
 355     Point aEEPos( SvxEditSourceHelper::UserSpaceToEE( rPos,
 356                                                       aSize,
 357                                                       rOutliner.IsVertical() ));
 358
 359     EPaM aDocPos = rOutliner.GetEditEngine().FindDocPosition(aEEPos);
 360
 361     nPara = aDocPos.nPara;
 362     nIndex = aDocPos.nIndex;
 363
 364     return true;
 365 }
 366
 367 bool SvxOutlinerForwarder::GetWordIndices( sal_Int32 nPara, sal_Int32 nIndex, sal_Int32& nStart, sal_Int32& nEnd ) const
 368 {
 369     ESelection aRes = rOutliner.GetEditEngine().GetWord( ESelection(nPara, nIndex), css::i18n::WordType::DICTIONARY_WORD );
 370
 371     if( aRes.start.nPara == nPara &&
 372         aRes.start.nPara == aRes.end.nPara )
 373     {
 374         nStart = aRes.start.nIndex;
 375         nEnd = aRes.end.nIndex;
 376
 377         return true;
 378     }
 379
 380     return false;
 381 }
 382
 383 bool SvxOutlinerForwarder::GetAttributeRun( sal_Int32& nStartIndex, sal_Int32& nEndIndex, sal_Int32 nPara, sal_Int32 nIndex, bool bInCell ) const
 384 {
 385     SvxEditSourceHelper::GetAttributeRun( nStartIndex, nEndIndex, rOutliner.GetEditEngine(), nPara, nIndex, bInCell );
 386     return true;
 387 }
 388
 389 sal_Int32 SvxOutlinerForwarder::GetLineCount( sal_Int32 nPara ) const
 390 {
 391     return rOutliner.GetLineCount(nPara);
 392 }
 393
 394 sal_Int32 SvxOutlinerForwarder::GetLineLen( sal_Int32 nPara, sal_Int32 nLine ) const
 395 {
 396     return rOutliner.GetLineLen(nPara, nLine);
 397 }
 398
 399 void SvxOutlinerForwarder::GetLineBoundaries( /*out*/sal_Int32 &rStart, /*out*/sal_Int32 &rEnd, sal_Int32 nPara, sal_Int32 nLine ) const
 400 {
 401     return rOutliner.GetEditEngine().GetLineBoundaries( rStart, rEnd, nPara, nLine );
 402 }
 403
 404 sal_Int32 SvxOutlinerForwarder::GetLineNumberAtIndex( sal_Int32 nPara, sal_Int32 nIndex ) const
 405 {
 406     return rOutliner.GetEditEngine().GetLineNumberAtIndex( nPara, nIndex );
 407 }
 408
 409 bool SvxOutlinerForwarder::QuickFormatDoc( bool )
 410 {
 411     rOutliner.QuickFormatDoc();
 412
 413     return true;
 414 }
 415
 416 bool SvxOutlinerForwarder::Delete( const ESelection& rSelection )
 417 {
 418     flushCache();
 419     rOutliner.QuickDelete( rSelection );
 420     rOutliner.QuickFormatDoc();
 421
 422     return true;
 423 }
 424
 425 bool SvxOutlinerForwarder::InsertText( const OUString& rStr, const ESelection& rSelection )
 426 {
 427     flushCache();
 428     rOutliner.QuickInsertText( rStr, rSelection );
 429     rOutliner.QuickFormatDoc();
 430
 431     return true;
 432 }
 433
 434 bool SvxOutlinerForwarder::SupportsOutlineDepth() const
 435 {
 436     return true;
 437 }
 438
 439 sal_Int16 SvxOutlinerForwarder::GetDepth( sal_Int32 nPara ) const
 440 {
 441     DBG_ASSERT( 0 <= nPara && nPara < GetParagraphCount(), "SvxOutlinerForwarder::GetDepth: Invalid paragraph index");
 442
 443     Paragraph* pPara = rOutliner.GetParagraph( nPara );
 444
 445     sal_Int16 nLevel = -1;
 446
 447     if( pPara )
 448         nLevel = rOutliner.GetDepth( nPara );
 449
 450     return nLevel;
 451 }
 452
 453 bool SvxOutlinerForwarder::SetDepth( sal_Int32 nPara, sal_Int16 nNewDepth )
 454 {
 455     DBG_ASSERT( 0 <= nPara && nPara < GetParagraphCount(), "SvxOutlinerForwarder::SetDepth: Invalid paragraph index");
 456
 457     if( (nNewDepth >= -1) && (nNewDepth <= 9) && (0 <= nPara && nPara < GetParagraphCount()) )
 458     {
 459         Paragraph* pPara = rOutliner.GetParagraph( nPara );
 460         if( pPara )
 461         {
 462             rOutliner.SetDepth( pPara, nNewDepth );
 463
 464 //          const bool bOutlinerText = pSdrObject && (pSdrObject->GetObjInventor() == SdrInventor::Default) && (pSdrObject->GetObjIdentifier() == OBJ_OUTLINETEXT);
 465             if( bOutlinerText )
 466                 rOutliner.SetLevelDependentStyleSheet( nPara );
 467
 468             return true;
 469         }
 470     }
 471
 472     return false;
 473 }
 474
 475 sal_Int32 SvxOutlinerForwarder::GetNumberingStartValue( sal_Int32 nPara )
 476 {
 477     if( 0 <= nPara && nPara < GetParagraphCount() )
 478     {
 479         return rOutliner.GetNumberingStartValue( nPara );
 480     }
 481     else
 482     {
 483         OSL_FAIL( "SvxOutlinerForwarder::GetNumberingStartValue)(), Invalid paragraph index");
 484         return -1;
 485     }
 486 }
 487
 488 void SvxOutlinerForwarder::SetNumberingStartValue(  sal_Int32 nPara, sal_Int32 nNumberingStartValue )
 489 {
 490     if( 0 <= nPara && nPara < GetParagraphCount() )
 491     {
 492         rOutliner.SetNumberingStartValue( nPara, nNumberingStartValue );
 493     }
 494     else
 495     {
 496         OSL_FAIL( "SvxOutlinerForwarder::SetNumberingStartValue)(), Invalid paragraph index");
 497     }
 498 }
 499
 500 bool SvxOutlinerForwarder::IsParaIsNumberingRestart( sal_Int32 nPara )
 501 {
 502     if( 0 <= nPara && nPara < GetParagraphCount() )
 503     {
 504         return rOutliner.IsParaIsNumberingRestart( nPara );
 505     }
 506     else
 507     {
 508         OSL_FAIL( "SvxOutlinerForwarder::IsParaIsNumberingRestart)(), Invalid paragraph index");
 509         return false;
 510     }
 511 }
 512
 513 void SvxOutlinerForwarder::SetParaIsNumberingRestart(  sal_Int32 nPara, bool bParaIsNumberingRestart )
 514 {
 515     if( 0 <= nPara && nPara < GetParagraphCount() )
 516     {
 517         rOutliner.SetParaIsNumberingRestart( nPara, bParaIsNumberingRestart );
 518     }
 519     else
 520     {
 521         OSL_FAIL( "SvxOutlinerForwarder::SetParaIsNumberingRestart)(), Invalid paragraph index");
 522     }
 523 }
 524
 525 const SfxItemSet * SvxOutlinerForwarder::GetEmptyItemSetPtr()
 526 {
 527     EditEngine& rEditEngine = const_cast< EditEngine& >( rOutliner.GetEditEngine() );
 528     return &rEditEngine.GetEmptyItemSet();
 529 }
 530
 531 void SvxOutlinerForwarder::AppendParagraph()
 532 {
 533     EditEngine& rEditEngine = const_cast< EditEngine& >( rOutliner.GetEditEngine() );
 534     rEditEngine.InsertParagraph( rEditEngine.GetParagraphCount(), OUString() );
 535 }
 536
 537 sal_Int32 SvxOutlinerForwarder::AppendTextPortion( sal_Int32 nPara, const OUString &rText, const SfxItemSet & /*rSet*/ )
 538 {
 539     sal_Int32 nLen = 0;
 540
 541     EditEngine& rEditEngine = const_cast< EditEngine& >( rOutliner.GetEditEngine() );
 542     sal_Int32 nParaCount = rEditEngine.GetParagraphCount();
 543     DBG_ASSERT( 0 <= nPara && nPara < nParaCount, "paragraph index out of bounds" );
 544     if (0 <= nPara && nPara < nParaCount)
 545     {
 546         nLen = rEditEngine.GetTextLen( nPara );
 547         rEditEngine.QuickInsertText(rText, ESelection(nPara, nLen));
 548     }
 549
 550     return nLen;
 551 }
 552
 553 void  SvxOutlinerForwarder::CopyText(const SvxTextForwarder& rSource)
 554 {
 555     const SvxOutlinerForwarder* pSourceForwarder = dynamic_cast< const SvxOutlinerForwarder* >( &rSource );
 556     if( !pSourceForwarder )
 557         return;
 558     std::optional<OutlinerParaObject> pNewOutlinerParaObject = pSourceForwarder->rOutliner.CreateParaObject();
 559     rOutliner.SetText( *pNewOutlinerParaObject );
 560 }
 561
 562
 563 sal_Int32 SvxTextForwarder::GetNumberingStartValue( sal_Int32 )
 564 {
 565     return -1;
 566 }
 567
 568 void SvxTextForwarder::SetNumberingStartValue( sal_Int32, sal_Int32 )
 569 {
 570 }
 571
 572 bool SvxTextForwarder::IsParaIsNumberingRestart( sal_Int32  )
 573 {
 574     return false;
 575 }
 576
 577 void SvxTextForwarder::SetParaIsNumberingRestart( sal_Int32, bool )
 578 {
 579 }
 580
 581
 582 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */