sw/source/core/edit/acorrect.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 <hintids.hxx>
  21
  22 #include <fmtinfmt.hxx>
  23 #include <editsh.hxx>
  24 #include <doc.hxx>
  25 #include <pam.hxx>
  26 #include <unocrsr.hxx>
  27 #include <txatbase.hxx>
  28 #include <txtfrm.hxx>
  29 #include <ndtxt.hxx>
  30 #include <acorrect.hxx>
  31 #include <shellio.hxx>
  32 #include <swundo.hxx>
  33 #include <viscrs.hxx>
  34 #include <com/sun/star/i18n/BreakType.hpp>
  35 #include <com/sun/star/i18n/WordType.hpp>
  36 #include <com/sun/star/i18n/XBreakIterator.hpp>
  37 #include <com/sun/star/linguistic2/XHyphenator.hpp>
  38 #include <com/sun/star/linguistic2/XHyphenatedWord.hpp>
  39 #include <svl/zforlist.hxx>
  40 #include <svl/zformat.hxx>
  41
  42 #include <editeng/acorrcfg.hxx>
  43 #include <redline.hxx>
  44 #include <IDocumentRedlineAccess.hxx>
  45 #include <rootfrm.hxx>
  46
  47 using namespace ::com::sun::star;
  48
  49 namespace {
  50
  51 class PaMIntoCursorShellRing
  52 {
  53     SwPaM &m_rDelPam, &m_rCursor;
  54     SwPaM* m_pPrevDelPam;
  55     SwPaM* m_pPrevCursor;
  56
  57     static void RemoveFromRing( SwPaM& rPam, SwPaM const * pPrev );
  58 public:
  59     PaMIntoCursorShellRing( SwCursorShell& rSh, SwPaM& rCursor, SwPaM& rPam );
  60     ~PaMIntoCursorShellRing();
  61 };
  62
  63 }
  64
  65 PaMIntoCursorShellRing::PaMIntoCursorShellRing(SwCursorShell& rCSh, SwPaM& rShCursor, SwPaM& rPam)
  66     : m_rDelPam(rPam)
  67     , m_rCursor(rShCursor)
  68 {
  69     SwPaM* pShCursor = rCSh.GetCursor_();
  70
  71     m_pPrevDelPam = m_rDelPam.GetPrev();
  72     m_pPrevCursor = m_rCursor.GetPrev();
  73
  74     m_rDelPam.GetRingContainer().merge(pShCursor->GetRingContainer());
  75     m_rCursor.GetRingContainer().merge(pShCursor->GetRingContainer());
  76 }
  77
  78 PaMIntoCursorShellRing::~PaMIntoCursorShellRing()
  79 {
  80     // and take out the Pam again:
  81     RemoveFromRing(m_rDelPam, m_pPrevDelPam);
  82     RemoveFromRing(m_rCursor, m_pPrevCursor);
  83 }
  84
  85 void PaMIntoCursorShellRing::RemoveFromRing( SwPaM& rPam, SwPaM const * pPrev )
  86 {
  87     SwPaM* p;
  88     SwPaM* pNext = &rPam;
  89     do {
  90         p = pNext;
  91         pNext = p->GetNext();
  92         p->MoveTo( &rPam );
  93     } while( p != pPrev );
  94 }
  95
  96 SwAutoCorrDoc::SwAutoCorrDoc( SwEditShell& rEditShell, SwPaM& rPam,
  97                                 sal_Unicode cIns )
  98     : m_rEditSh( rEditShell ), m_rCursor( rPam )
  99     , m_nEndUndoCounter(0)
 100     , m_bUndoIdInitialized( cIns == 0 )
 101 {
 102 }
 103
 104 SwAutoCorrDoc::~SwAutoCorrDoc()
 105 {
 106     for (int i = 0; i < m_nEndUndoCounter; ++i)
 107     {
 108         m_rEditSh.EndUndo();
 109     }
 110 }
 111
 112 void SwAutoCorrDoc::DeleteSel( SwPaM& rDelPam )
 113 {
 114     // this should work with plain SwPaM as well because start and end
 115     // are always in same node, but since there is GetRanges already...
 116     std::vector<std::shared_ptr<SwUnoCursor>> ranges;
 117     if (sw::GetRanges(ranges, *m_rEditSh.GetDoc(), rDelPam))
 118     {
 119         DeleteSelImpl(rDelPam);
 120     }
 121     else
 122     {
 123         for (auto const& pCursor : ranges)
 124         {
 125             DeleteSelImpl(*pCursor);
 126         }
 127     }
 128 }
 129
 130 void SwAutoCorrDoc::DeleteSelImpl(SwPaM & rDelPam)
 131 {
 132     SwDoc* pDoc = m_rEditSh.GetDoc();
 133     if( pDoc->IsAutoFormatRedline() )
 134     {
 135         // so that also the DelPam be moved,  include it in the
 136         // Shell-Cursr-Ring !!
 137         // ??? is that really necessary - this should never join nodes, so Update should be enough?
 138 //        PaMIntoCursorShellRing aTmp( rEditSh, rCursor, rDelPam );
 139         assert(rDelPam.GetPoint()->nNode == rDelPam.GetMark()->nNode);
 140         pDoc->getIDocumentContentOperations().DeleteAndJoin( rDelPam );
 141     }
 142     else
 143     {
 144         pDoc->getIDocumentContentOperations().DeleteRange( rDelPam );
 145     }
 146 }
 147
 148 bool SwAutoCorrDoc::Delete( sal_Int32 nStt, sal_Int32 nEnd )
 149 {
 150     SwTextNode const*const pTextNd = m_rCursor.GetNode().GetTextNode();
 151     SwTextFrame const*const pFrame(static_cast<SwTextFrame const*>(
 152                 pTextNd->getLayoutFrame(m_rEditSh.GetLayout())));
 153     assert(pFrame);
 154     SwPaM aSel(pFrame->MapViewToModelPos(TextFrameIndex(nStt)),
 155                pFrame->MapViewToModelPos(TextFrameIndex(nEnd)));
 156     DeleteSel( aSel );
 157
 158     if( m_bUndoIdInitialized )
 159         m_bUndoIdInitialized = true;
 160     return true;
 161 }
 162
 163 bool SwAutoCorrDoc::Insert( sal_Int32 nPos, const OUString& rText )
 164 {
 165     SwTextNode const*const pTextNd = m_rCursor.GetNode().GetTextNode();
 166     SwTextFrame const*const pFrame(static_cast<SwTextFrame const*>(
 167                 pTextNd->getLayoutFrame(m_rEditSh.GetLayout())));
 168     assert(pFrame);
 169     SwPaM aPam(pFrame->MapViewToModelPos(TextFrameIndex(nPos)));
 170     m_rEditSh.GetDoc()->getIDocumentContentOperations().InsertString( aPam, rText );
 171     if( !m_bUndoIdInitialized )
 172     {
 173         m_bUndoIdInitialized = true;
 174         if( 1 == rText.getLength() )
 175         {
 176             m_rEditSh.StartUndo( SwUndoId::AUTOCORRECT );
 177             ++m_nEndUndoCounter;
 178         }
 179     }
 180     return true;
 181 }
 182
 183 bool SwAutoCorrDoc::Replace( sal_Int32 nPos, const OUString& rText )
 184 {
 185     return ReplaceRange( nPos, rText.getLength(), rText );
 186 }
 187
 188 bool SwAutoCorrDoc::ReplaceRange( sal_Int32 nPos, sal_Int32 nSourceLength, const OUString& rText )
 189 {
 190     assert(nSourceLength == 1); // sw_redlinehide: this is currently the case,
 191     // and ensures that the replace range cannot *contain* delete redlines,
 192     // so we don't need something along the lines of:
 193     //    if (sw::GetRanges(ranges, *rEditSh.GetDoc(), aPam))
 194     //        ReplaceImpl(...)
 195     //    else
 196     //        ReplaceImpl(ranges.begin())
 197     //        for (ranges.begin() + 1; ranges.end(); )
 198     //            DeleteImpl(*it)
 199
 200     SwTextNode * const pNd = m_rCursor.GetNode().GetTextNode();
 201     if ( !pNd )
 202     {
 203         return false;
 204     }
 205
 206     SwTextFrame const*const pFrame(static_cast<SwTextFrame const*>(
 207                 pNd->getLayoutFrame(m_rEditSh.GetLayout())));
 208     assert(pFrame);
 209     std::pair<SwTextNode *, sal_Int32> const pos(pFrame->MapViewToModel(TextFrameIndex(nPos)));
 210
 211     SwPaM* pPam = &m_rCursor;
 212     if (pPam->GetPoint()->nNode != *pos.first
 213         || pPam->GetPoint()->nContent != pos.second)
 214     {
 215         pPam = new SwPaM(*pos.first, pos.second);
 216     }
 217
 218     // text attributes with dummy characters must not be replaced!
 219     bool bDoReplace = true;
 220     sal_Int32 const nLen = rText.getLength();
 221     for (sal_Int32 n = 0; n < nLen && n + nPos < pFrame->GetText().getLength(); ++n)
 222     {
 223         sal_Unicode const Char = pFrame->GetText()[n + nPos];
 224         if (CH_TXTATR_BREAKWORD == Char || CH_TXTATR_INWORD == Char)
 225         {
 226             assert(pFrame->MapViewToModel(TextFrameIndex(n+nPos)).first->GetTextAttrForCharAt(pFrame->MapViewToModel(TextFrameIndex(n+nPos)).second));
 227             bDoReplace = false;
 228             break;
 229         }
 230     }
 231
 232     // tdf#83419 avoid bad autocorrect with visible redlines
 233     // e.g. replacing the first letter of the tracked deletion
 234     // with its capitalized (and not deleted) version.
 235     if ( bDoReplace && !pFrame->getRootFrame()->IsHideRedlines() &&
 236          m_rEditSh.GetDoc()->getIDocumentRedlineAccess().HasRedline( *pPam, RedlineType::Delete, /*bStartOrEndInRange=*/false ) )
 237     {
 238         bDoReplace = false;
 239     }
 240
 241     if ( bDoReplace )
 242     {
 243         SwDoc* pDoc = m_rEditSh.GetDoc();
 244
 245         if( pDoc->IsAutoFormatRedline() )
 246         {
 247             if (nPos == pFrame->GetText().getLength()) // at the End do an Insert
 248             {
 249                 pDoc->getIDocumentContentOperations().InsertString( *pPam, rText );
 250             }
 251             else
 252             {
 253                 assert(pos.second != pos.first->Len()); // must be _before_ char
 254                 PaMIntoCursorShellRing aTmp( m_rEditSh, m_rCursor, *pPam );
 255
 256                 pPam->SetMark();
 257                 pPam->GetPoint()->nContent = std::min<sal_Int32>(
 258                     pos.first->GetText().getLength(), pos.second + nSourceLength);
 259                 pDoc->getIDocumentContentOperations().ReplaceRange( *pPam, rText, false );
 260                 pPam->Exchange();
 261                 pPam->DeleteMark();
 262             }
 263         }
 264         else
 265         {
 266             pPam->SetMark();
 267             pPam->GetPoint()->nContent = std::min<sal_Int32>(
 268                 pos.first->GetText().getLength(), pos.second + nSourceLength);
 269             pDoc->getIDocumentContentOperations().ReplaceRange( *pPam, rText, false );
 270             pPam->Exchange();
 271             pPam->DeleteMark();
 272         }
 273
 274         if( m_bUndoIdInitialized )
 275         {
 276             m_bUndoIdInitialized = true;
 277             if( 1 == rText.getLength() )
 278             {
 279                 m_rEditSh.StartUndo( SwUndoId::AUTOCORRECT );
 280                 ++m_nEndUndoCounter;
 281             }
 282         }
 283     }
 284
 285     if( pPam != &m_rCursor )
 286         delete pPam;
 287
 288     return true;
 289 }
 290
 291 void SwAutoCorrDoc::SetAttr( sal_Int32 nStt, sal_Int32 nEnd, sal_uInt16 nSlotId,
 292                                         SfxPoolItem& rItem )
 293 {
 294     SwTextNode const*const pTextNd = m_rCursor.GetNode().GetTextNode();
 295     SwTextFrame const*const pFrame(static_cast<SwTextFrame const*>(
 296                 pTextNd->getLayoutFrame(m_rEditSh.GetLayout())));
 297     assert(pFrame);
 298     SwPaM aPam(pFrame->MapViewToModelPos(TextFrameIndex(nStt)),
 299                pFrame->MapViewToModelPos(TextFrameIndex(nEnd)));
 300
 301     SfxItemPool& rPool = m_rEditSh.GetDoc()->GetAttrPool();
 302     sal_uInt16 nWhich = rPool.GetWhich( nSlotId, false );
 303     if( nWhich )
 304     {
 305         rItem.SetWhich( nWhich );
 306
 307         SfxItemSet aSet( rPool, aCharFormatSetRange );
 308         SetAllScriptItem( aSet, rItem );
 309
 310         m_rEditSh.GetDoc()->SetFormatItemByAutoFormat( aPam, aSet );
 311
 312         if( m_bUndoIdInitialized )
 313             m_bUndoIdInitialized = true;
 314     }
 315 }
 316
 317 bool SwAutoCorrDoc::SetINetAttr( sal_Int32 nStt, sal_Int32 nEnd, const OUString& rURL )
 318 {
 319     SwTextNode const*const pTextNd = m_rCursor.GetNode().GetTextNode();
 320     SwTextFrame const*const pFrame(static_cast<SwTextFrame const*>(
 321                 pTextNd->getLayoutFrame(m_rEditSh.GetLayout())));
 322     assert(pFrame);
 323     SwPaM aPam(pFrame->MapViewToModelPos(TextFrameIndex(nStt)),
 324                pFrame->MapViewToModelPos(TextFrameIndex(nEnd)));
 325
 326     SfxItemSet aSet( m_rEditSh.GetDoc()->GetAttrPool(),
 327                         svl::Items<RES_TXTATR_INETFMT, RES_TXTATR_INETFMT>{} );
 328     aSet.Put( SwFormatINetFormat( rURL, OUString() ));
 329     m_rEditSh.GetDoc()->SetFormatItemByAutoFormat( aPam, aSet );
 330     if( m_bUndoIdInitialized )
 331         m_bUndoIdInitialized = true;
 332     return true;
 333 }
 334
 335 /** Return the text of a previous paragraph
 336  *
 337  * @param bAtNormalPos If <true> before the normal insert position; if <false> in which the
 338  *                     corrected word was inserted. (Doesn't need to be the same paragraph!)
 339  * @return text or 0, if previous paragraph does not exists or there are only blankness
 340  */
 341 OUString const* SwAutoCorrDoc::GetPrevPara(bool const bAtNormalPos)
 342 {
 343     OUString const* pStr(nullptr);
 344
 345     if( bAtNormalPos || !m_pIndex )
 346     {
 347         m_pIndex.reset(new SwNodeIndex(m_rCursor.GetPoint()->nNode));
 348     }
 349     sw::GotoPrevLayoutTextFrame(*m_pIndex, m_rEditSh.GetLayout());
 350
 351     SwTextFrame const* pFrame(nullptr);
 352     for (SwTextNode * pTextNd = m_pIndex->GetNode().GetTextNode();
 353              pTextNd; pTextNd = m_pIndex->GetNode().GetTextNode())
 354     {
 355         pFrame = static_cast<SwTextFrame const*>(
 356                 pTextNd->getLayoutFrame(m_rEditSh.GetLayout()));
 357         if (pFrame && !pFrame->GetText().isEmpty())
 358         {
 359             break;
 360         }
 361         sw::GotoPrevLayoutTextFrame(*m_pIndex, m_rEditSh.GetLayout());
 362     }
 363     if (pFrame && 0 == pFrame->GetTextNodeForParaProps()->GetAttrOutlineLevel())
 364         pStr = & pFrame->GetText();
 365
 366     if( m_bUndoIdInitialized )
 367         m_bUndoIdInitialized = true;
 368
 369     return pStr;
 370 }
 371
 372 bool SwAutoCorrDoc::ChgAutoCorrWord( sal_Int32& rSttPos, sal_Int32 nEndPos,
 373                                          SvxAutoCorrect& rACorrect,
 374                                          OUString* pPara )
 375 {
 376     if( m_bUndoIdInitialized )
 377         m_bUndoIdInitialized = true;
 378
 379     // Found a beginning of a paragraph or a Blank,
 380     // search for the word Kuerzel (Shortcut) in the Auto
 381     SwTextNode* pTextNd = m_rCursor.GetNode().GetTextNode();
 382     OSL_ENSURE( pTextNd, "where is the TextNode?" );
 383
 384     bool bRet = false;
 385     if( nEndPos == rSttPos )
 386         return bRet;
 387
 388     LanguageType eLang = GetLanguage(nEndPos);
 389     if(LANGUAGE_SYSTEM == eLang)
 390         eLang = GetAppLanguage();
 391     LanguageTag aLanguageTag( eLang);
 392
 393     SwTextFrame const*const pFrame(static_cast<SwTextFrame const*>(
 394                 pTextNd->getLayoutFrame(m_rEditSh.GetLayout())));
 395     assert(pFrame);
 396
 397     const OUString sFrameText = pFrame->GetText();
 398     const SvxAutocorrWord* pFnd = rACorrect.SearchWordsInList(
 399                 sFrameText, rSttPos, nEndPos, *this, aLanguageTag);
 400     SwDoc* pDoc = m_rEditSh.GetDoc();
 401     if( pFnd )
 402     {
 403         // replace also last colon of keywords surrounded by colons (for example, ":name:")
 404         const bool replaceLastChar = sFrameText.getLength() > nEndPos && pFnd->GetShort()[0] == ':'
 405                                      && pFnd->GetShort().endsWith(":");
 406
 407         SwPosition aStartPos( pFrame->MapViewToModelPos(TextFrameIndex(rSttPos) ));
 408         SwPosition aEndPos( pFrame->MapViewToModelPos(TextFrameIndex(nEndPos + (replaceLastChar ? 1 : 0))) );
 409         SwPaM aPam(aStartPos, aEndPos);
 410
 411         // don't replace, if a redline starts or ends within the original text
 412         if ( pDoc->getIDocumentRedlineAccess().HasRedline( aPam, RedlineType::Any, /*bStartOrEndInRange=*/true ) )
 413         {
 414             return bRet;
 415         }
 416
 417         if( pFnd->IsTextOnly() )
 418         {
 419             //JP 22.04.99: Bug 63883 - Special treatment for dots.
 420             const bool bLastCharIsPoint
 421                 = nEndPos < sFrameText.getLength() && ('.' == sFrameText[nEndPos]);
 422             if( !bLastCharIsPoint || pFnd->GetLong().isEmpty() ||
 423                 '.' != pFnd->GetLong()[ pFnd->GetLong().getLength() - 1 ] )
 424             {
 425                 // replace the selection
 426                 std::vector<std::shared_ptr<SwUnoCursor>> ranges;
 427                 if (sw::GetRanges(ranges, *m_rEditSh.GetDoc(), aPam))
 428                 {
 429                     pDoc->getIDocumentContentOperations().ReplaceRange(aPam, pFnd->GetLong(), false);
 430                     bRet = true;
 431                 }
 432                 else if (!ranges.empty())
 433                 {
 434                     assert(ranges.front()->GetPoint()->nNode == ranges.front()->GetMark()->nNode);
 435                     pDoc->getIDocumentContentOperations().ReplaceRange(
 436                             *ranges.front(), pFnd->GetLong(), false);
 437                     for (auto it = ranges.begin() + 1; it != ranges.end(); ++it)
 438                     {
 439                         DeleteSelImpl(**it);
 440                     }
 441                     bRet = true;
 442                 }
 443
 444                 // tdf#83260 After calling sw::DocumentContentOperationsManager::ReplaceRange
 445                 // pTextNd may become invalid when change tracking is on and Edit -> Track Changes -> Show == OFF.
 446                 // ReplaceRange shows changes, this moves deleted nodes from special section to document.
 447                 // Then Show mode is disabled again. As a result pTextNd may be invalidated.
 448                 pTextNd = m_rCursor.GetNode().GetTextNode();
 449             }
 450         }
 451         else
 452         {
 453             SwTextBlocks aTBlks( rACorrect.GetAutoCorrFileName( aLanguageTag, false, true ));
 454             sal_uInt16 nPos = aTBlks.GetIndex( pFnd->GetShort() );
 455             if( USHRT_MAX != nPos && aTBlks.BeginGetDoc( nPos ) )
 456             {
 457                 DeleteSel( aPam );
 458                 pDoc->DontExpandFormat( *aPam.GetPoint() );
 459
 460                 if( pPara )
 461                 {
 462                     OSL_ENSURE( !m_pIndex, "who has not deleted his Index?" );
 463                     m_pIndex.reset(new SwNodeIndex( m_rCursor.GetPoint()->nNode ));
 464                     sw::GotoPrevLayoutTextFrame(*m_pIndex, m_rEditSh.GetLayout());
 465                 }
 466
 467                 SwDoc* pAutoDoc = aTBlks.GetDoc();
 468                 SwNodeIndex aSttIdx( pAutoDoc->GetNodes().GetEndOfExtras(), 1 );
 469                 SwContentNode* pContentNd = pAutoDoc->GetNodes().GoNext( &aSttIdx );
 470                 SwPaM aCpyPam( aSttIdx );
 471
 472                 const SwTableNode* pTableNd = pContentNd->FindTableNode();
 473                 if( pTableNd )
 474                 {
 475                     aCpyPam.GetPoint()->nContent.Assign( nullptr, 0 );
 476                     aCpyPam.GetPoint()->nNode = *pTableNd;
 477                 }
 478                 aCpyPam.SetMark();
 479
 480                 // then until the end of the Nodes Array
 481                 aCpyPam.GetPoint()->nNode.Assign( pAutoDoc->GetNodes().GetEndOfContent(), -1 );
 482                 pContentNd = aCpyPam.GetContentNode();
 483                 aCpyPam.GetPoint()->nContent.Assign(
 484                        pContentNd, pContentNd ? pContentNd->Len() : 0);
 485
 486                 SwDontExpandItem aExpItem;
 487                 aExpItem.SaveDontExpandItems( *aPam.GetPoint() );
 488
 489                 pAutoDoc->getIDocumentContentOperations().CopyRange(aCpyPam, *aPam.GetPoint(), SwCopyFlags::CheckPosInFly);
 490
 491                 aExpItem.RestoreDontExpandItems( *aPam.GetPoint() );
 492
 493                 if( pPara )
 494                 {
 495                     sw::GotoNextLayoutTextFrame(*m_pIndex, m_rEditSh.GetLayout());
 496                     pTextNd = m_pIndex->GetNode().GetTextNode();
 497                 }
 498                 bRet = true;
 499             }
 500             aTBlks.EndGetDoc();
 501         }
 502     }
 503
 504     if( bRet && pPara && pTextNd )
 505     {
 506         SwTextFrame const*const pNewFrame(static_cast<SwTextFrame const*>(
 507                     pTextNd->getLayoutFrame(m_rEditSh.GetLayout())));
 508         *pPara = pNewFrame->GetText();
 509     }
 510
 511     return bRet;
 512 }
 513
 514 bool SwAutoCorrDoc::TransliterateRTLWord( sal_Int32& rSttPos, sal_Int32 nEndPos )
 515 {
 516     if( m_bUndoIdInitialized )
 517         m_bUndoIdInitialized = true;
 518
 519     SwTextNode* pTextNd = m_rCursor.GetNode().GetTextNode();
 520     OSL_ENSURE( pTextNd, "where is the TextNode?" );
 521
 522     bool bRet = false;
 523     if( nEndPos == rSttPos )
 524         return bRet;
 525
 526     LanguageType eLang = GetLanguage(nEndPos);
 527     if(LANGUAGE_SYSTEM == eLang)
 528         eLang = GetAppLanguage();
 529     LanguageTag aLanguageTag(eLang);
 530
 531     SwTextFrame const*const pFrame(static_cast<SwTextFrame const*>(
 532                 pTextNd->getLayoutFrame(m_rEditSh.GetLayout())));
 533     assert(pFrame);
 534
 535     const OUString sFrameText = pFrame->GetText();
 536     SwDoc* pDoc = m_rEditSh.GetDoc();
 537     if ( pFrame->IsRightToLeft() )
 538     {
 539         // transliterate to Old Hungarian using Numbertext via NatNum12 number format modifier
 540         OUString sWord(sFrameText.copy(rSttPos, nEndPos - rSttPos));
 541         // Consonant disambiguation using hyphenation
 542         uno::Reference< linguistic2::XHyphenator >  xHyph;
 543         xHyph = ::GetHyphenator();
 544         OUStringBuffer sDisambiguatedWord;
 545
 546         const ::css::uno::Sequence< ::css::beans::PropertyValue > aProperties;
 547         css::uno::Reference< css::linguistic2::XHyphenatedWord >  xHyphWord;
 548         for (int i = 0; i+1 < sWord.getLength(); i++ )
 549         {
 550             xHyphWord = xHyph->hyphenate( sWord,
 551                         aLanguageTag.getLocale(),
 552                         i,
 553                         aProperties );
 554             // insert ZWSP at a hyphenation point, if it's not an alternative one (i.e. ssz->sz-sz)
 555             if (xHyphWord.is() && xHyphWord->getHyphenationPos()+1 == i && !xHyphWord->isAlternativeSpelling())
 556             {
 557                 sDisambiguatedWord.append(CHAR_ZWSP);
 558             }
 559             sDisambiguatedWord.append(sWord[i]);
 560         }
 561         sDisambiguatedWord.append(sWord[sWord.getLength()-1]);
 562
 563         SvNumberFormatter* pFormatter = pDoc->GetNumberFormatter();
 564         OUString sConverted;
 565         if (pFormatter && !sWord.isEmpty())
 566         {
 567             const Color* pColor = nullptr;
 568             // Send text as NatNum12 prefix
 569             OUString sPrefix("[NatNum12 " + sDisambiguatedWord.makeStringAndClear() + "]0");
 570             if (pFormatter->GetPreviewString(sPrefix, 0, sConverted, &pColor, LANGUAGE_USER_HUNGARIAN_ROVAS))
 571                 bRet = true;
 572         }
 573
 574         SwPaM aPam(pFrame->MapViewToModelPos(TextFrameIndex(rSttPos)),
 575             pFrame->MapViewToModelPos(TextFrameIndex(nEndPos)));
 576         if (bRet && nEndPos <= sFrameText.getLength())
 577             pDoc->getIDocumentContentOperations().ReplaceRange(aPam, sConverted, false);
 578     }
 579
 580     return bRet;
 581 }
 582
 583 // Called by the functions:
 584 //  - FnCapitalStartWord
 585 //  - FnCapitalStartSentence
 586 // after the exchange of characters. Then the words, if necessary, can be inserted
 587 // into the exception list.
 588 void SwAutoCorrDoc::SaveCpltSttWord( ACFlags nFlag, sal_Int32 nPos,
 589                                             const OUString& rExceptWord,
 590                                             sal_Unicode cChar )
 591 {
 592     sal_uLong nNode = m_pIndex ? m_pIndex->GetIndex() : m_rCursor.GetPoint()->nNode.GetIndex();
 593     LanguageType eLang = GetLanguage(nPos);
 594     m_rEditSh.GetDoc()->SetAutoCorrExceptWord( std::make_unique<SwAutoCorrExceptWord>( nFlag,
 595                                         nNode, nPos, rExceptWord, cChar, eLang ));
 596 }
 597
 598 LanguageType SwAutoCorrDoc::GetLanguage( sal_Int32 nPos ) const
 599 {
 600     LanguageType eRet = LANGUAGE_SYSTEM;
 601
 602     SwTextNode* pNd = m_rCursor.GetPoint()->nNode.GetNode().GetTextNode();
 603
 604     if( pNd )
 605     {
 606         SwTextFrame const*const pFrame(static_cast<SwTextFrame const*>(
 607                     pNd->getLayoutFrame(m_rEditSh.GetLayout())));
 608         assert(pFrame);
 609         eRet = pFrame->GetLangOfChar(TextFrameIndex(nPos), 0, true);
 610     }
 611     if(LANGUAGE_SYSTEM == eRet)
 612         eRet = GetAppLanguage();
 613     return eRet;
 614 }
 615
 616 void SwAutoCorrExceptWord::CheckChar( const SwPosition& rPos, sal_Unicode cChr )
 617 {
 618     // test only if this is an improvement.
 619     // If yes, then add the word to the list.
 620     if (m_cChar == cChr && rPos.nNode.GetIndex() == m_nNode && rPos.nContent.GetIndex() == m_nContent)
 621     {
 622         // get the current autocorrection:
 623         SvxAutoCorrect* pACorr = SvxAutoCorrCfg::Get().GetAutoCorrect();
 624
 625         // then add to the list:
 626         if (ACFlags::CapitalStartWord & m_nFlags)
 627             pACorr->AddWrtSttException(m_sWord, m_eLanguage);
 628         else if (ACFlags::CapitalStartSentence & m_nFlags)
 629             pACorr->AddCplSttException(m_sWord, m_eLanguage);
 630     }
 631 }
 632
 633 bool SwAutoCorrExceptWord::CheckDelChar( const SwPosition& rPos )
 634 {
 635     bool bRet = false;
 636     if (!m_bDeleted && rPos.nNode.GetIndex() == m_nNode && rPos.nContent.GetIndex() == m_nContent)
 637         m_bDeleted = bRet = true;
 638     return bRet;
 639 }
 640
 641 SwDontExpandItem::~SwDontExpandItem()
 642 {
 643 }
 644
 645 void SwDontExpandItem::SaveDontExpandItems( const SwPosition& rPos )
 646 {
 647     const SwTextNode* pTextNd = rPos.nNode.GetNode().GetTextNode();
 648     if( pTextNd )
 649     {
 650         m_pDontExpandItems.reset( new SfxItemSet( const_cast<SwDoc&>(pTextNd->GetDoc()).GetAttrPool(),
 651                                             aCharFormatSetRange ) );
 652         const sal_Int32 n = rPos.nContent.GetIndex();
 653         if (!pTextNd->GetParaAttr( *m_pDontExpandItems, n, n,
 654                                 n != pTextNd->GetText().getLength() ))
 655         {
 656             m_pDontExpandItems.reset();
 657         }
 658     }
 659 }
 660
 661 void SwDontExpandItem::RestoreDontExpandItems( const SwPosition& rPos )
 662 {
 663     SwTextNode* pTextNd = rPos.nNode.GetNode().GetTextNode();
 664     if( !pTextNd )
 665         return;
 666
 667     const sal_Int32 nStart = rPos.nContent.GetIndex();
 668     if( nStart == pTextNd->GetText().getLength() )
 669         pTextNd->FormatToTextAttr( pTextNd );
 670
 671     if( !(pTextNd->GetpSwpHints() && pTextNd->GetpSwpHints()->Count()) )
 672         return;
 673
 674     const size_t nSize = pTextNd->GetpSwpHints()->Count();
 675     sal_Int32 nAttrStart;
 676
 677     for( size_t n = 0; n < nSize; ++n )
 678     {
 679         SwTextAttr* pHt = pTextNd->GetpSwpHints()->Get( n );
 680         nAttrStart = pHt->GetStart();
 681         if( nAttrStart > nStart )       // beyond the area
 682             break;
 683
 684         const sal_Int32* pAttrEnd;
 685         if( nullptr != ( pAttrEnd = pHt->End() ) &&
 686             ( ( nAttrStart < nStart &&
 687                 ( pHt->DontExpand() ? nStart < *pAttrEnd
 688                                     : nStart <= *pAttrEnd )) ||
 689               ( nStart == nAttrStart &&
 690                 ( nAttrStart == *pAttrEnd || !nStart ))) )
 691         {
 692             const SfxPoolItem* pItem;
 693             if( !m_pDontExpandItems || SfxItemState::SET != m_pDontExpandItems->
 694                 GetItemState( pHt->Which(), false, &pItem ) ||
 695                 *pItem != pHt->GetAttr() )
 696             {
 697                 // The attribute was not previously set in this form in the
 698                 // paragraph, so it can only be created through insert/copy
 699                 // Because of that it is a candidate for DontExpand
 700                 pHt->SetDontExpand( true );
 701             }
 702         }
 703     }
 704 }
 705
 706 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */