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