editeng/source/uno/unofored.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 <editeng/eeitem.hxx>
  24 #include <com/sun/star/i18n/WordType.hpp>
  25
  26 #include <svl/itemset.hxx>
  27 #include <editeng/editeng.hxx>
  28 #include <editeng/unoedhlp.hxx>
  29 #include <editeng/editdata.hxx>
  30 #include <editeng/outliner.hxx>
  31 #include <editeng/editobj.hxx>
  32
  33 #include <editeng/unofored.hxx>
  34 #include "unofored_internal.hxx"
  35
  36 using namespace ::com::sun::star;
  37
  38
  39 SvxEditEngineForwarder::SvxEditEngineForwarder( EditEngine& rEngine ) :
  40     rEditEngine( rEngine )
  41 {
  42 }
  43
  44 SvxEditEngineForwarder::~SvxEditEngineForwarder()
  45 {
  46     // the EditEngine may need to be deleted from the outside
  47 }
  48
  49 sal_Int32 SvxEditEngineForwarder::GetParagraphCount() const
  50 {
  51     return rEditEngine.GetParagraphCount();
  52 }
  53
  54 sal_Int32 SvxEditEngineForwarder::GetTextLen( sal_Int32 nParagraph ) const
  55 {
  56     return rEditEngine.GetTextLen( nParagraph );
  57 }
  58
  59 OUString SvxEditEngineForwarder::GetText( const ESelection& rSel ) const
  60 {
  61     return convertLineEnd(rEditEngine.GetText(rSel), GetSystemLineEnd());
  62 }
  63
  64 SfxItemSet SvxEditEngineForwarder::GetAttribs( const ESelection& rSel, EditEngineAttribs nOnlyHardAttrib ) const
  65 {
  66     if (rSel.start.nPara == rSel.end.nPara)
  67     {
  68         GetAttribsFlags nFlags = GetAttribsFlags::NONE;
  69         switch( nOnlyHardAttrib )
  70         {
  71         case EditEngineAttribs::All:
  72             nFlags = GetAttribsFlags::ALL;
  73             break;
  74         case EditEngineAttribs::OnlyHard:
  75             nFlags = GetAttribsFlags::CHARATTRIBS;
  76             break;
  77         default:
  78             OSL_FAIL("unknown flags for SvxOutlinerForwarder::GetAttribs");
  79         }
  80
  81         return rEditEngine.GetAttribs( rSel.start.nPara, rSel.start.nIndex, rSel.end.nIndex, nFlags );
  82     }
  83     else
  84     {
  85         return rEditEngine.GetAttribs( rSel, nOnlyHardAttrib );
  86     }
  87 }
  88
  89 SfxItemSet SvxEditEngineForwarder::GetParaAttribs( sal_Int32 nPara ) const
  90 {
  91     SfxItemSet aSet( rEditEngine.GetParaAttribs( nPara ) );
  92
  93     sal_uInt16 nWhich = EE_PARA_START;
  94     while( nWhich <= EE_PARA_END )
  95     {
  96         if( aSet.GetItemState( nWhich ) != SfxItemState::SET )
  97         {
  98             if( rEditEngine.HasParaAttrib( nPara, nWhich ) )
  99                 aSet.Put( rEditEngine.GetParaAttrib( nPara, nWhich ) );
 100         }
 101         nWhich++;
 102     }
 103
 104     return aSet;
 105 }
 106
 107 void SvxEditEngineForwarder::SetParaAttribs( sal_Int32 nPara, const SfxItemSet& rSet )
 108 {
 109     rEditEngine.SetParaAttribs( nPara, rSet );
 110 }
 111
 112 void SvxEditEngineForwarder::RemoveAttribs( const ESelection& rSelection )
 113 {
 114     rEditEngine.RemoveAttribs( rSelection, false/*bRemoveParaAttribs*/, 0 );
 115 }
 116
 117 SfxItemPool* SvxEditEngineForwarder::GetPool() const
 118 {
 119     return rEditEngine.GetEmptyItemSet().GetPool();
 120 }
 121
 122 void SvxEditEngineForwarder::GetPortions( sal_Int32 nPara, std::vector<sal_Int32>& rList ) const
 123 {
 124     rEditEngine.GetPortions( nPara, rList );
 125 }
 126
 127 OUString SvxEditEngineForwarder::GetStyleSheet(sal_Int32 nPara) const
 128 {
 129     if (auto pStyle = rEditEngine.GetStyleSheet(nPara))
 130         return pStyle->GetName();
 131     return OUString();
 132 }
 133
 134 void SvxEditEngineForwarder::SetStyleSheet(sal_Int32 nPara, const OUString& rStyleName)
 135 {
 136     auto pStyleSheetPool = rEditEngine.GetStyleSheetPool();
 137     if (auto pStyle = pStyleSheetPool ? pStyleSheetPool->Find(rStyleName, SfxStyleFamily::Para) : nullptr)
 138         rEditEngine.SetStyleSheet(nPara, static_cast<SfxStyleSheet*>(pStyle));
 139 }
 140
 141 void SvxEditEngineForwarder::QuickInsertText( const OUString& rText, const ESelection& rSel )
 142 {
 143     rEditEngine.QuickInsertText( rText, rSel );
 144 }
 145
 146 void SvxEditEngineForwarder::QuickInsertLineBreak( const ESelection& rSel )
 147 {
 148     rEditEngine.QuickInsertLineBreak( rSel );
 149 }
 150
 151 void SvxEditEngineForwarder::QuickInsertField( const SvxFieldItem& rFld, const ESelection& rSel )
 152 {
 153     rEditEngine.QuickInsertField( rFld, rSel );
 154 }
 155
 156 void SvxEditEngineForwarder::QuickSetAttribs( const SfxItemSet& rSet, const ESelection& rSel )
 157 {
 158     rEditEngine.QuickSetAttribs( rSet, rSel );
 159 }
 160
 161 bool SvxEditEngineForwarder::IsValid() const
 162 {
 163     // cannot reliably query EditEngine state
 164     // while in the middle of an update
 165     return rEditEngine.IsUpdateLayout();
 166 }
 167
 168 OUString SvxEditEngineForwarder::CalcFieldValue( const SvxFieldItem& rField, sal_Int32 nPara, sal_Int32 nPos, std::optional<Color>& rpTxtColor, std::optional<Color>& rpFldColor, std::optional<FontLineStyle>& rpFldLineStyle )
 169 {
 170     return rEditEngine.CalcFieldValue( rField, nPara, nPos, rpTxtColor, rpFldColor, rpFldLineStyle );
 171 }
 172
 173 void SvxEditEngineForwarder::FieldClicked( const SvxFieldItem& rField )
 174 {
 175     rEditEngine.FieldClicked( rField );
 176 }
 177
 178 SfxItemState GetSvxEditEngineItemState( EditEngine const & rEditEngine, const ESelection& rSel, sal_uInt16 nWhich )
 179 {
 180     std::vector<EECharAttrib> aAttribs;
 181
 182     const SfxPoolItem*  pLastItem = nullptr;
 183
 184     SfxItemState eState = SfxItemState::DEFAULT;
 185
 186     // check all paragraphs inside the selection
 187     for (sal_Int32 nPara = rSel.start.nPara; nPara <= rSel.end.nPara; nPara++)
 188     {
 189         SfxItemState eParaState = SfxItemState::DEFAULT;
 190
 191         // calculate start and endpos for this paragraph
 192         sal_Int32 nPos = 0;
 193         if (rSel.start.nPara == nPara)
 194             nPos = rSel.start.nIndex;
 195
 196         sal_Int32 nEndPos = rSel.end.nIndex;
 197         if (rSel.end.nPara != nPara)
 198             nEndPos = rEditEngine.GetTextLen( nPara );
 199
 200
 201         // get list of char attribs
 202         rEditEngine.GetCharAttribs( nPara, aAttribs );
 203
 204         bool bEmpty = true;     // we found no item inside the selection of this paragraph
 205         bool bGaps  = false;    // we found items but there are gaps between them
 206         sal_Int32 nLastEnd = nPos;
 207
 208         const SfxPoolItem* pParaItem = nullptr;
 209
 210         for (auto const& attrib : aAttribs)
 211         {
 212             assert(attrib.pAttr && "GetCharAttribs gives corrupt data");
 213
 214             const bool bEmptyPortion = attrib.nStart == attrib.nEnd;
 215             if((!bEmptyPortion && attrib.nStart >= nEndPos) ||
 216                (bEmptyPortion && attrib.nStart > nEndPos))
 217                 break;  // break if we are already behind our selection
 218
 219             if((!bEmptyPortion && attrib.nEnd <= nPos) ||
 220                (bEmptyPortion && attrib.nEnd < nPos))
 221                 continue;   // or if the attribute ends before our selection
 222
 223             if(attrib.pAttr->Which() != nWhich)
 224                 continue; // skip if is not the searched item
 225
 226             // if we already found an item
 227             if( pParaItem )
 228             {
 229                 // ... and its different to this one than the state is don't care
 230                 if(*pParaItem != *(attrib.pAttr))
 231                     return SfxItemState::INVALID;
 232             }
 233             else
 234                 pParaItem = attrib.pAttr;
 235
 236             if( bEmpty )
 237                 bEmpty = false;
 238
 239             if(!bGaps && attrib.nStart > nLastEnd)
 240                 bGaps = true;
 241
 242             nLastEnd = attrib.nEnd;
 243         }
 244
 245         if( !bEmpty && !bGaps && nLastEnd < ( nEndPos - 1 ) )
 246             bGaps = true;
 247
 248         if( bEmpty )
 249             eParaState = SfxItemState::DEFAULT;
 250         else if( bGaps )
 251             eParaState = SfxItemState::INVALID;
 252         else
 253             eParaState = SfxItemState::SET;
 254
 255         // if we already found an item check if we found the same
 256         if( pLastItem )
 257         {
 258             if( (pParaItem == nullptr) || (*pLastItem != *pParaItem) )
 259                 return SfxItemState::INVALID;
 260         }
 261         else
 262         {
 263             pLastItem = pParaItem;
 264             eState = eParaState;
 265         }
 266     }
 267
 268     return eState;
 269 }
 270
 271 SfxItemState SvxEditEngineForwarder::GetItemState( const ESelection& rSel, sal_uInt16 nWhich ) const
 272 {
 273     return GetSvxEditEngineItemState( rEditEngine, rSel, nWhich );
 274 }
 275
 276 SfxItemState SvxEditEngineForwarder::GetItemState( sal_Int32 nPara, sal_uInt16 nWhich ) const
 277 {
 278     const SfxItemSet& rSet = rEditEngine.GetParaAttribs( nPara );
 279     return rSet.GetItemState( nWhich );
 280 }
 281
 282 LanguageType SvxEditEngineForwarder::GetLanguage( sal_Int32 nPara, sal_Int32 nIndex ) const
 283 {
 284     return rEditEngine.GetLanguage(nPara, nIndex).nLang;
 285 }
 286
 287 std::vector<EFieldInfo> SvxEditEngineForwarder::GetFieldInfo( sal_Int32 nPara ) const
 288 {
 289     return rEditEngine.GetFieldInfo( nPara );
 290 }
 291
 292 EBulletInfo SvxEditEngineForwarder::GetBulletInfo( sal_Int32 ) const
 293 {
 294     return EBulletInfo();
 295 }
 296
 297 tools::Rectangle SvxEditEngineForwarder::GetCharBounds( sal_Int32 nPara, sal_Int32 nIndex ) const
 298 {
 299     // EditEngine's 'internal' methods like GetCharacterBounds()
 300     // don't rotate for vertical text.
 301     Size aSize( rEditEngine.CalcTextWidth(), rEditEngine.GetTextHeight() );
 302     // swap width and height
 303     tools::Long tmp = aSize.Width();
 304     aSize.setWidth(aSize.Height());
 305     aSize.setHeight(tmp);
 306     bool bIsVertical( rEditEngine.IsEffectivelyVertical() );
 307
 308     // #108900# Handle virtual position one-past-the end of the string
 309     if( nIndex >= rEditEngine.GetTextLen(nPara) )
 310     {
 311         tools::Rectangle aLast;
 312
 313         if( nIndex )
 314         {
 315             // use last character, if possible
 316             aLast = rEditEngine.GetCharacterBounds(EPaM(nPara, nIndex - 1));
 317
 318             // move at end of this last character, make one pixel wide
 319             aLast.Move( aLast.Right() - aLast.Left(), 0 );
 320             aLast.SetSize( Size(1, aLast.GetHeight()) );
 321
 322             // take care for CTL
 323             aLast = SvxEditSourceHelper::EEToUserSpace( aLast, aSize, bIsVertical );
 324         }
 325         else
 326         {
 327             // #109864# Bounds must lie within the paragraph
 328             aLast = GetParaBounds( nPara );
 329
 330             // #109151# Don't use paragraph height, but line height
 331             // instead. aLast is already CTL-correct
 332             if( bIsVertical)
 333                 aLast.SetSize( Size( rEditEngine.GetLineHeight(nPara), 1 ) );
 334             else
 335                 aLast.SetSize( Size( 1, rEditEngine.GetLineHeight(nPara) ) );
 336         }
 337
 338         return aLast;
 339     }
 340     else
 341     {
 342         return SvxEditSourceHelper::EEToUserSpace( rEditEngine.GetCharacterBounds( EPaM(nPara, nIndex) ),
 343                                                    aSize, bIsVertical );
 344     }
 345 }
 346
 347 tools::Rectangle SvxEditEngineForwarder::GetParaBounds( sal_Int32 nPara ) const
 348 {
 349     const Point aPnt = rEditEngine.GetDocPosTopLeft( nPara );
 350     sal_uInt32 nWidth;
 351     sal_uInt32 nHeight;
 352
 353     if( rEditEngine.IsEffectivelyVertical() )
 354     {
 355         // Hargl. EditEngine's 'external' methods return the rotated
 356         // dimensions, 'internal' methods like GetTextHeight( n )
 357         // don't rotate.
 358         nWidth = rEditEngine.GetTextHeight( nPara );
 359         nHeight = rEditEngine.GetTextHeight();
 360         sal_uInt32 nTextWidth = rEditEngine.GetTextHeight();
 361
 362         return tools::Rectangle( nTextWidth - aPnt.Y() - nWidth, 0, nTextWidth - aPnt.Y(), nHeight );
 363     }
 364     else
 365     {
 366         nWidth = rEditEngine.CalcTextWidth();
 367         nHeight = rEditEngine.GetTextHeight( nPara );
 368
 369         return tools::Rectangle( 0, aPnt.Y(), nWidth, aPnt.Y() + nHeight );
 370     }
 371 }
 372
 373 MapMode SvxEditEngineForwarder::GetMapMode() const
 374 {
 375     return rEditEngine.GetRefMapMode();
 376 }
 377
 378 OutputDevice* SvxEditEngineForwarder::GetRefDevice() const
 379 {
 380     return rEditEngine.GetRefDevice();
 381 }
 382
 383 bool SvxEditEngineForwarder::GetIndexAtPoint( const Point& rPos, sal_Int32& nPara, sal_Int32& nIndex ) const
 384 {
 385     Size aSize( rEditEngine.CalcTextWidth(), rEditEngine.GetTextHeight() );
 386     // swap width and height
 387     tools::Long tmp = aSize.Width();
 388     aSize.setWidth(aSize.Height());
 389     aSize.setHeight(tmp);
 390     Point aEEPos( SvxEditSourceHelper::UserSpaceToEE( rPos,
 391                                                       aSize,
 392                                                       rEditEngine.IsEffectivelyVertical() ));
 393
 394     EPaM aDocPos = rEditEngine.FindDocPosition(aEEPos);
 395
 396     nPara = aDocPos.nPara;
 397     nIndex = aDocPos.nIndex;
 398
 399     return true;
 400 }
 401
 402 bool SvxEditEngineForwarder::GetWordIndices( sal_Int32 nPara, sal_Int32 nIndex, sal_Int32& nStart, sal_Int32& nEnd ) const
 403 {
 404     ESelection aRes = rEditEngine.GetWord( ESelection(nPara, nIndex, nPara, nIndex), css::i18n::WordType::DICTIONARY_WORD );
 405
 406     if( aRes.start.nPara == nPara &&
 407         aRes.start.nPara == aRes.end.nPara )
 408     {
 409         nStart = aRes.start.nIndex;
 410         nEnd = aRes.end.nIndex;
 411
 412         return true;
 413     }
 414
 415     return false;
 416 }
 417
 418 bool SvxEditEngineForwarder::GetAttributeRun( sal_Int32& nStartIndex, sal_Int32& nEndIndex, sal_Int32 nPara, sal_Int32 nIndex, bool bInCell ) const
 419 {
 420     SvxEditSourceHelper::GetAttributeRun( nStartIndex, nEndIndex, rEditEngine, nPara, nIndex, bInCell );
 421     return true;
 422 }
 423
 424 sal_Int32 SvxEditEngineForwarder::GetLineCount( sal_Int32 nPara ) const
 425 {
 426     return rEditEngine.GetLineCount(nPara);
 427 }
 428
 429 sal_Int32 SvxEditEngineForwarder::GetLineLen( sal_Int32 nPara, sal_Int32 nLine ) const
 430 {
 431     return rEditEngine.GetLineLen(nPara, nLine);
 432 }
 433
 434 void SvxEditEngineForwarder::GetLineBoundaries( /*out*/sal_Int32 &rStart, /*out*/sal_Int32 &rEnd, sal_Int32 nPara, sal_Int32 nLine ) const
 435 {
 436     rEditEngine.GetLineBoundaries(rStart, rEnd, nPara, nLine);
 437 }
 438
 439 sal_Int32 SvxEditEngineForwarder::GetLineNumberAtIndex( sal_Int32 nPara, sal_Int32 nIndex ) const
 440 {
 441     return rEditEngine.GetLineNumberAtIndex(nPara, nIndex);
 442 }
 443
 444
 445 bool SvxEditEngineForwarder::QuickFormatDoc( bool )
 446 {
 447     rEditEngine.QuickFormatDoc();
 448
 449     return true;
 450 }
 451
 452 bool SvxEditEngineForwarder::Delete( const ESelection& rSelection )
 453 {
 454     rEditEngine.QuickDelete( rSelection );
 455     rEditEngine.QuickFormatDoc();
 456
 457     return true;
 458 }
 459
 460 bool SvxEditEngineForwarder::InsertText( const OUString& rStr, const ESelection& rSelection )
 461 {
 462     rEditEngine.QuickInsertText( rStr, rSelection );
 463     rEditEngine.QuickFormatDoc();
 464
 465     return true;
 466 }
 467
 468 bool SvxEditEngineForwarder::SupportsOutlineDepth() const
 469 {
 470     // EditEngine does not support outline depth indirectly - directly supports EE_PARA_OUTLLEVEL
 471     return false;
 472 }
 473
 474 sal_Int16 SvxEditEngineForwarder::GetDepth( sal_Int32 ) const
 475 {
 476     // EditEngine does not support outline depth
 477     return -1;
 478 }
 479
 480 bool SvxEditEngineForwarder::SetDepth( sal_Int32, sal_Int16 nNewDepth )
 481 {
 482     // EditEngine does not support outline depth
 483     return nNewDepth == -1;
 484 }
 485
 486 const SfxItemSet * SvxEditEngineForwarder::GetEmptyItemSetPtr()
 487 {
 488     return &rEditEngine.GetEmptyItemSet();
 489 }
 490
 491 void SvxEditEngineForwarder::AppendParagraph()
 492 {
 493     rEditEngine.InsertParagraph( rEditEngine.GetParagraphCount(), OUString() );
 494 }
 495
 496 sal_Int32 SvxEditEngineForwarder::AppendTextPortion( sal_Int32 nPara, const OUString &rText, const SfxItemSet & /*rSet*/ )
 497 {
 498     sal_Int32 nLen = 0;
 499
 500     sal_Int32 nParaCount = rEditEngine.GetParagraphCount();
 501     DBG_ASSERT( nPara < nParaCount, "paragraph index out of bounds" );
 502     if (0 <= nPara && nPara < nParaCount)
 503     {
 504         nLen = rEditEngine.GetTextLen( nPara );
 505         rEditEngine.QuickInsertText(rText, ESelection(nPara, nLen));
 506     }
 507
 508     return nLen;
 509 }
 510
 511 void SvxEditEngineForwarder::CopyText(const SvxTextForwarder& rSource)
 512 {
 513     const SvxEditEngineForwarder* pSourceForwarder = dynamic_cast< const SvxEditEngineForwarder* >( &rSource );
 514     if( !pSourceForwarder )
 515         return;
 516     std::unique_ptr<EditTextObject> pNewTextObject = pSourceForwarder->rEditEngine.CreateTextObject();
 517     rEditEngine.SetText( *pNewTextObject );
 518 }
 519
 520
 521 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */