sw/source/core/unocore/unoflatpara.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 <unobaseclass.hxx>
  21 #include <unocrsrhelper.hxx>
  22 #include <unoflatpara.hxx>
  23
  24 #include <o3tl/safeint.hxx>
  25 #include <utility>
  26 #include <vcl/svapp.hxx>
  27 #include <com/sun/star/text/TextMarkupType.hpp>
  28 #include <com/sun/star/beans/PropertyAttribute.hpp>
  29 #include <unotextmarkup.hxx>
  30 #include <ndtxt.hxx>
  31 #include <doc.hxx>
  32 #include <IDocumentLayoutAccess.hxx>
  33 #include <IDocumentStylePoolAccess.hxx>
  34 #include <viewsh.hxx>
  35 #include <viewimp.hxx>
  36 #include <breakit.hxx>
  37 #include <pam.hxx>
  38 #include <unotextrange.hxx>
  39 #include <pagefrm.hxx>
  40 #include <cntfrm.hxx>
  41 #include <txtfrm.hxx>
  42 #include <rootfrm.hxx>
  43 #include <poolfmt.hxx>
  44 #include <pagedesc.hxx>
  45 #include <GrammarContact.hxx>
  46 #include <viewopt.hxx>
  47 #include <comphelper/servicehelper.hxx>
  48 #include <comphelper/propertysetinfo.hxx>
  49 #include <comphelper/sequence.hxx>
  50 #include <sal/log.hxx>
  51
  52 #include <com/sun/star/lang/XUnoTunnel.hpp>
  53 #include <com/sun/star/text/XTextRange.hpp>
  54
  55 using namespace ::com::sun::star;
  56
  57 namespace SwUnoCursorHelper {
  58
  59 uno::Reference<text::XFlatParagraphIterator>
  60 CreateFlatParagraphIterator(SwDoc & rDoc, sal_Int32 const nTextMarkupType,
  61         bool const bAutomatic)
  62 {
  63     return new SwXFlatParagraphIterator(rDoc, nTextMarkupType, bAutomatic);
  64 }
  65
  66 }
  67
  68 SwXFlatParagraph::SwXFlatParagraph( SwTextNode& rTextNode, OUString aExpandText, const ModelToViewHelper& rMap )
  69     : SwXFlatParagraph_Base(& rTextNode, rMap)
  70     , maExpandText(std::move(aExpandText))
  71     , maOrigText(rTextNode.GetText())
  72 {
  73 }
  74
  75 SwXFlatParagraph::~SwXFlatParagraph()
  76 {
  77 }
  78
  79
  80 // XPropertySet
  81 uno::Reference< beans::XPropertySetInfo > SAL_CALL
  82 SwXFlatParagraph::getPropertySetInfo()
  83 {
  84     static const comphelper::PropertyMapEntry s_Entries[] = {
  85         { u"FieldPositions"_ustr, -1, ::cppu::UnoType<uno::Sequence<sal_Int32>>::get(), beans::PropertyAttribute::READONLY, 0 },
  86         { u"FootnotePositions"_ustr, -1, ::cppu::UnoType<uno::Sequence<sal_Int32>>::get(), beans::PropertyAttribute::READONLY, 0 },
  87         { u"SortedTextId"_ustr, -1, ::cppu::UnoType<sal_Int32>::get(), beans::PropertyAttribute::READONLY, 0 },
  88         { u"DocumentElementsCount"_ustr, -1, ::cppu::UnoType<sal_Int32>::get(), beans::PropertyAttribute::READONLY, 0 },
  89     };
  90     return new comphelper::PropertySetInfo(s_Entries);
  91 }
  92
  93 void SAL_CALL
  94 SwXFlatParagraph::setPropertyValue(const OUString&, const uno::Any&)
  95 {
  96     throw lang::IllegalArgumentException(u"no values can be set"_ustr,
  97             getXWeak(), 0);
  98 }
  99
 100 uno::Any SAL_CALL
 101 SwXFlatParagraph::getPropertyValue(const OUString& rPropertyName)
 102 {
 103     SolarMutexGuard g;
 104
 105     if (rPropertyName == "FieldPositions")
 106     {
 107         return uno::Any( comphelper::containerToSequence( GetConversionMap().getFieldPositions() ) );
 108     }
 109     else if (rPropertyName == "FootnotePositions")
 110     {
 111         return uno::Any( comphelper::containerToSequence( GetConversionMap().getFootnotePositions() ) );
 112     }
 113     else if (rPropertyName == "SortedTextId")
 114     {
 115         SwTextNode const*const pCurrentNode = GetTextNode();
 116         sal_Int32 nIndex = -1;
 117         if ( pCurrentNode )
 118             nIndex = pCurrentNode->GetIndex().get();
 119         return uno::Any( nIndex );
 120     }
 121     else if (rPropertyName == "DocumentElementsCount")
 122     {
 123         SwTextNode const*const pCurrentNode = GetTextNode();
 124         sal_Int32 nCount = -1;
 125         if ( pCurrentNode )
 126             nCount = pCurrentNode->GetDoc().GetNodes().Count().get();
 127         return uno::Any( nCount );
 128     }
 129     return uno::Any();
 130 }
 131
 132 void SAL_CALL
 133 SwXFlatParagraph::addPropertyChangeListener(
 134         const OUString& /*rPropertyName*/,
 135         const uno::Reference< beans::XPropertyChangeListener >& /*xListener*/)
 136 {
 137     SAL_WARN("sw.uno",
 138         "SwXFlatParagraph::addPropertyChangeListener(): not implemented");
 139 }
 140
 141 void SAL_CALL
 142 SwXFlatParagraph::removePropertyChangeListener(
 143         const OUString& /*rPropertyName*/,
 144         const uno::Reference< beans::XPropertyChangeListener >& /*xListener*/)
 145 {
 146     SAL_WARN("sw.uno",
 147         "SwXFlatParagraph::removePropertyChangeListener(): not implemented");
 148 }
 149
 150 void SAL_CALL
 151 SwXFlatParagraph::addVetoableChangeListener(
 152         const OUString& /*rPropertyName*/,
 153         const uno::Reference< beans::XVetoableChangeListener >& /*xListener*/)
 154 {
 155     SAL_WARN("sw.uno",
 156         "SwXFlatParagraph::addVetoableChangeListener(): not implemented");
 157 }
 158
 159 void SAL_CALL
 160 SwXFlatParagraph::removeVetoableChangeListener(
 161         const OUString& /*rPropertyName*/,
 162         const uno::Reference< beans::XVetoableChangeListener >& /*xListener*/)
 163 {
 164     SAL_WARN("sw.uno",
 165         "SwXFlatParagraph::removeVetoableChangeListener(): not implemented");
 166 }
 167
 168
 169 css::uno::Reference< css::container::XStringKeyMap > SAL_CALL SwXFlatParagraph::getMarkupInfoContainer()
 170 {
 171     return SwXTextMarkup::getMarkupInfoContainer();
 172 }
 173
 174 void SAL_CALL SwXFlatParagraph::commitTextRangeMarkup(::sal_Int32 nType, const OUString & aIdentifier, const uno::Reference< text::XTextRange> & xRange,
 175                                                       const css::uno::Reference< css::container::XStringKeyMap > & xMarkupInfoContainer)
 176 {
 177     SolarMutexGuard aGuard;
 178     SwXTextMarkup::commitTextRangeMarkup( nType, aIdentifier, xRange,  xMarkupInfoContainer );
 179 }
 180
 181 void SAL_CALL SwXFlatParagraph::commitStringMarkup(::sal_Int32 nType, const OUString & rIdentifier, ::sal_Int32 nStart, ::sal_Int32 nLength, const css::uno::Reference< css::container::XStringKeyMap > & rxMarkupInfoContainer)
 182 {
 183     SolarMutexGuard aGuard;
 184     SwXTextMarkup::commitStringMarkup( nType, rIdentifier, nStart, nLength,  rxMarkupInfoContainer );
 185 }
 186
 187 // text::XFlatParagraph:
 188 OUString SAL_CALL SwXFlatParagraph::getText()
 189 {
 190     return maExpandText;
 191 }
 192
 193 // text::XFlatParagraph:
 194 void SAL_CALL SwXFlatParagraph::setChecked( ::sal_Int32 nType, sal_Bool bVal )
 195 {
 196     SolarMutexGuard aGuard;
 197
 198     if (!GetTextNode())
 199         return;
 200
 201     if ( text::TextMarkupType::SPELLCHECK == nType )
 202     {
 203         GetTextNode()->SetWrongDirty(
 204             bVal ? sw::WrongState::DONE : sw::WrongState::TODO);
 205     }
 206     else if ( text::TextMarkupType::SMARTTAG == nType )
 207         GetTextNode()->SetSmartTagDirty( !bVal );
 208     else if( text::TextMarkupType::PROOFREADING == nType )
 209     {
 210         GetTextNode()->SetGrammarCheckDirty( !bVal );
 211         if( bVal )
 212             sw::finishGrammarCheckFor(*GetTextNode());
 213     }
 214 }
 215
 216 // text::XFlatParagraph:
 217 sal_Bool SAL_CALL SwXFlatParagraph::isChecked( ::sal_Int32 nType )
 218 {
 219     SolarMutexGuard aGuard;
 220     if (GetTextNode())
 221     {
 222         if ( text::TextMarkupType::SPELLCHECK == nType )
 223             return !GetTextNode()->IsWrongDirty();
 224         else if ( text::TextMarkupType::PROOFREADING == nType )
 225             return !GetTextNode()->IsGrammarCheckDirty();
 226         else if ( text::TextMarkupType::SMARTTAG == nType )
 227             return !GetTextNode()->IsSmartTagDirty();
 228     }
 229
 230     return true;
 231 }
 232
 233 // text::XFlatParagraph:
 234 sal_Bool SAL_CALL SwXFlatParagraph::isModified()
 235 {
 236     SolarMutexGuard aGuard;
 237     return !GetTextNode() || GetTextNode()->GetText() != maOrigText;
 238 }
 239
 240 // text::XFlatParagraph:
 241 lang::Locale SAL_CALL SwXFlatParagraph::getLanguageOfText(::sal_Int32 nPos, ::sal_Int32 nLen)
 242 {
 243     SolarMutexGuard aGuard;
 244     if (!GetTextNode())
 245         return LanguageTag::convertToLocale( LANGUAGE_NONE );
 246
 247     const lang::Locale aLocale( SW_BREAKITER()->GetLocale( GetTextNode()->GetLang(nPos, nLen) ) );
 248     return aLocale;
 249 }
 250
 251 // text::XFlatParagraph:
 252 lang::Locale SAL_CALL SwXFlatParagraph::getPrimaryLanguageOfText(::sal_Int32 nPos, ::sal_Int32 nLen)
 253 {
 254     SolarMutexGuard aGuard;
 255
 256     if (!GetTextNode())
 257         return LanguageTag::convertToLocale( LANGUAGE_NONE );
 258
 259     const lang::Locale aLocale( SW_BREAKITER()->GetLocale( GetTextNode()->GetLang(nPos, nLen) ) );
 260     return aLocale;
 261 }
 262
 263 // text::XFlatParagraph:
 264 void SAL_CALL SwXFlatParagraph::changeText(::sal_Int32 nPos, ::sal_Int32 nLen, const OUString & aNewText, const css::uno::Sequence< css::beans::PropertyValue > & aAttributes)
 265 {
 266     SolarMutexGuard aGuard;
 267
 268     if (!GetTextNode())
 269         return;
 270
 271     SwTextNode *const pOldTextNode = GetTextNode();
 272
 273     if (nPos < 0 || pOldTextNode->Len() < nPos || nLen < 0 || o3tl::make_unsigned(pOldTextNode->Len()) < static_cast<sal_uInt32>(nPos) + nLen)
 274     {
 275         throw lang::IllegalArgumentException();
 276     }
 277
 278     SwPaM aPaM( *GetTextNode(), nPos, *GetTextNode(), nPos+nLen );
 279
 280     UnoActionContext aAction( &GetTextNode()->GetDoc() );
 281
 282     const rtl::Reference<SwXTextRange> xRange =
 283         SwXTextRange::CreateXTextRange(
 284             GetTextNode()->GetDoc(), *aPaM.GetPoint(), aPaM.GetMark() );
 285     if ( xRange.is() )
 286     {
 287         for ( const auto& rAttribute : aAttributes )
 288             xRange->setPropertyValue( rAttribute.Name, rAttribute.Value );
 289     }
 290
 291     IDocumentContentOperations& rIDCO = pOldTextNode->getIDocumentContentOperations();
 292     rIDCO.ReplaceRange( aPaM, aNewText, false );
 293
 294     ClearTextNode(); // TODO: is this really needed?
 295 }
 296
 297 // text::XFlatParagraph:
 298 void SAL_CALL SwXFlatParagraph::changeAttributes(::sal_Int32 nPos, ::sal_Int32 nLen, const css::uno::Sequence< css::beans::PropertyValue > & aAttributes)
 299 {
 300     SolarMutexGuard aGuard;
 301
 302     if (!GetTextNode())
 303         return;
 304
 305     if (nPos < 0 || GetTextNode()->Len() < nPos || nLen < 0 || o3tl::make_unsigned(GetTextNode()->Len()) < static_cast<sal_uInt32>(nPos) + nLen)
 306     {
 307         throw lang::IllegalArgumentException();
 308     }
 309
 310     SwPaM aPaM( *GetTextNode(), nPos, *GetTextNode(), nPos+nLen );
 311
 312     UnoActionContext aAction( &GetTextNode()->GetDoc() );
 313
 314     const rtl::Reference<SwXTextRange> xRange =
 315         SwXTextRange::CreateXTextRange(
 316             GetTextNode()->GetDoc(), *aPaM.GetPoint(), aPaM.GetMark() );
 317     if ( xRange.is() )
 318     {
 319         for ( const auto& rAttribute : aAttributes )
 320             xRange->setPropertyValue( rAttribute.Name, rAttribute.Value );
 321     }
 322
 323     ClearTextNode(); // TODO: is this really needed?
 324 }
 325
 326 // text::XFlatParagraph:
 327 css::uno::Sequence< ::sal_Int32 > SAL_CALL SwXFlatParagraph::getLanguagePortions()
 328 {
 329     return css::uno::Sequence< ::sal_Int32>();
 330 }
 331
 332 SwXFlatParagraphIterator::SwXFlatParagraphIterator( SwDoc& rDoc, sal_Int32 nType, bool bAutomatic )
 333     : mpDoc( &rDoc ),
 334       mnType( nType ),
 335       mbAutomatic( bAutomatic ),
 336       mnCurrentNode( 0 ),
 337       mnEndNode( rDoc.GetNodes().Count() )
 338 {
 339     //mnStartNode = mnCurrentNode = get node from current cursor TODO!
 340
 341     // register as listener and get notified when document is closed
 342     StartListening(mpDoc->getIDocumentStylePoolAccess().GetPageDescFromPool( RES_POOLPAGE_STANDARD )->GetNotifier());
 343 }
 344
 345 SwXFlatParagraphIterator::~SwXFlatParagraphIterator()
 346 {
 347     SolarMutexGuard aGuard;
 348     EndListeningAll();
 349 }
 350
 351 void SwXFlatParagraphIterator::Notify( const SfxHint& rHint )
 352 {
 353     if(rHint.GetId() == SfxHintId::Dying)
 354     {
 355         SolarMutexGuard aGuard;
 356         mpDoc = nullptr;
 357     }
 358 }
 359
 360 uno::Reference< text::XFlatParagraph > SwXFlatParagraphIterator::getFirstPara()
 361 {
 362     return getNextPara();   // TODO
 363 }
 364
 365 uno::Reference< text::XFlatParagraph > SwXFlatParagraphIterator::getNextPara()
 366 {
 367     SolarMutexGuard aGuard;
 368
 369     uno::Reference< text::XFlatParagraph > xRet;
 370     if (!mpDoc)
 371         return xRet;
 372
 373     SwTextNode* pRet = nullptr;
 374     if ( mbAutomatic )
 375     {
 376         SwViewShell* pViewShell = mpDoc->getIDocumentLayoutAccess().GetCurrentViewShell();
 377
 378         SwPageFrame* pCurrentPage = pViewShell ? pViewShell->Imp()->GetFirstVisPage(pViewShell->GetOut()) : nullptr;
 379         SwPageFrame* pStartPage = pCurrentPage;
 380         SwPageFrame* pStopPage = nullptr;
 381
 382         while ( pCurrentPage && pCurrentPage != pStopPage )
 383         {
 384             if (mnType != text::TextMarkupType::SPELLCHECK || pCurrentPage->IsInvalidSpelling() )
 385             {
 386                 // this method is supposed to return an empty paragraph in case Online Checking is disabled
 387                 if ( ( mnType == text::TextMarkupType::PROOFREADING || mnType == text::TextMarkupType::SPELLCHECK )
 388                     && !pViewShell->GetViewOptions()->IsOnlineSpell() )
 389                     return xRet;
 390
 391                 // search for invalid content:
 392                 SwContentFrame* pCnt = pCurrentPage->ContainsContent();
 393
 394                 while( pCnt && pCurrentPage->IsAnLower( pCnt ) )
 395                 {
 396                     if (pCnt->IsTextFrame())
 397                     {
 398                         SwTextFrame const*const pText(static_cast<SwTextFrame const*>(pCnt));
 399                         if (sw::MergedPara const*const pMergedPara = pText->GetMergedPara()
 400             )
 401                         {
 402                             SwTextNode * pTextNode(nullptr);
 403                             for (auto const& e : pMergedPara->extents)
 404                             {
 405                                 if (e.pNode != pTextNode)
 406                                 {
 407                                     pTextNode = e.pNode;
 408                                     if ((mnType == text::TextMarkupType::SPELLCHECK
 409                                             && pTextNode->IsWrongDirty()) ||
 410                                         (mnType == text::TextMarkupType::PROOFREADING
 411                                              && pTextNode->IsGrammarCheckDirty()))
 412                                     {
 413                                         pRet = pTextNode;
 414                                         break;
 415                                     }
 416                                 }
 417                             }
 418                         }
 419                         else
 420                         {
 421                             SwTextNode const*const pTextNode(pText->GetTextNodeFirst());
 422                             if ((mnType == text::TextMarkupType::SPELLCHECK
 423                                     && pTextNode->IsWrongDirty()) ||
 424                                 (mnType == text::TextMarkupType::PROOFREADING
 425                                      && pTextNode->IsGrammarCheckDirty()))
 426
 427                             {
 428                                 pRet = const_cast<SwTextNode*>(pTextNode);
 429                             }
 430                         }
 431
 432                         if (pRet)
 433                         {
 434                             break;
 435                         }
 436                     }
 437
 438                     pCnt = pCnt->GetNextContentFrame();
 439                 }
 440             }
 441
 442             if ( pRet )
 443                 break;
 444
 445             // if there is no invalid text node on the current page,
 446             // we validate the page
 447             pCurrentPage->ValidateSpelling();
 448
 449             // proceed with next page, wrap at end of document if required:
 450             pCurrentPage = static_cast<SwPageFrame*>(pCurrentPage->GetNext());
 451
 452             if ( !pCurrentPage && !pStopPage )
 453             {
 454                 pStopPage = pStartPage;
 455                 pCurrentPage = static_cast<SwPageFrame*>(pViewShell->GetLayout()->Lower());
 456             }
 457         }
 458     }
 459     else    // non-automatic checking
 460     {
 461         const SwNodes& rNodes = mpDoc->GetNodes();
 462         const SwNodeOffset nMaxNodes = rNodes.Count();
 463
 464         while ( mnCurrentNode < mnEndNode && mnCurrentNode < nMaxNodes )
 465         {
 466             SwNode* pNd = rNodes[ mnCurrentNode ];
 467
 468             ++mnCurrentNode;
 469
 470             pRet = pNd->GetTextNode();
 471             if ( pRet )
 472                 break;
 473
 474             if ( mnCurrentNode == mnEndNode )
 475             {
 476                 mnCurrentNode = SwNodeOffset(0);
 477                 mnEndNode = SwNodeOffset(0);
 478             }
 479         }
 480     }
 481
 482     if ( pRet )
 483     {
 484         // Expand the string:
 485         const ModelToViewHelper aConversionMap(*pRet, mpDoc->getIDocumentLayoutAccess().GetCurrentLayout());
 486         const OUString& aExpandText = aConversionMap.getViewText();
 487
 488         xRet = new SwXFlatParagraph( *pRet, aExpandText, aConversionMap );
 489     }
 490
 491     return xRet;
 492 }
 493
 494 uno::Reference< text::XFlatParagraph > SwXFlatParagraphIterator::getLastPara()
 495 {
 496     return getNextPara();
 497 }
 498
 499 uno::Reference< text::XFlatParagraph > SwXFlatParagraphIterator::getParaAfter(const uno::Reference< text::XFlatParagraph > & xPara)
 500 {
 501     SolarMutexGuard aGuard;
 502
 503     uno::Reference< text::XFlatParagraph > xRet;
 504     if (!mpDoc)
 505         return xRet;
 506
 507     SwXFlatParagraph* const pFlatParagraph(dynamic_cast<SwXFlatParagraph*>(xPara.get()));
 508     SAL_WARN_IF(!pFlatParagraph, "sw.core", "invalid argument");
 509     if ( !pFlatParagraph )
 510         return xRet;
 511
 512     SwTextNode const*const pCurrentNode = pFlatParagraph->GetTextNode();
 513
 514     if ( !pCurrentNode )
 515         return xRet;
 516
 517     SwTextNode* pNextTextNode = nullptr;
 518     const SwNodes& rNodes = pCurrentNode->GetDoc().GetNodes();
 519
 520     for( SwNodeOffset nCurrentNode = pCurrentNode->GetIndex() + 1; nCurrentNode < rNodes.Count(); ++nCurrentNode )
 521     {
 522         SwNode* pNd = rNodes[ nCurrentNode ];
 523         pNextTextNode = pNd->GetTextNode();
 524         if ( pNextTextNode )
 525             break;
 526     }
 527
 528     if ( pNextTextNode )
 529     {
 530         // Expand the string:
 531         const ModelToViewHelper aConversionMap(*pNextTextNode, mpDoc->getIDocumentLayoutAccess().GetCurrentLayout());
 532         const OUString& aExpandText = aConversionMap.getViewText();
 533
 534         xRet = new SwXFlatParagraph( *pNextTextNode, aExpandText, aConversionMap );
 535     }
 536
 537     return xRet;
 538 }
 539
 540 uno::Reference< text::XFlatParagraph > SwXFlatParagraphIterator::getParaBefore(const uno::Reference< text::XFlatParagraph > & xPara )
 541 {
 542     SolarMutexGuard aGuard;
 543
 544     uno::Reference< text::XFlatParagraph > xRet;
 545     if (!mpDoc)
 546         return xRet;
 547
 548     SwXFlatParagraph* const pFlatParagraph(dynamic_cast<SwXFlatParagraph*>(xPara.get()));
 549     SAL_WARN_IF(!pFlatParagraph, "sw.core", "invalid argument");
 550     if ( !pFlatParagraph )
 551         return xRet;
 552
 553     SwTextNode const*const pCurrentNode = pFlatParagraph->GetTextNode();
 554
 555     if ( !pCurrentNode )
 556         return xRet;
 557
 558     SwTextNode* pPrevTextNode = nullptr;
 559     const SwNodes& rNodes = pCurrentNode->GetDoc().GetNodes();
 560
 561     for( SwNodeOffset nCurrentNode = pCurrentNode->GetIndex() - 1; nCurrentNode > SwNodeOffset(0); --nCurrentNode )
 562     {
 563         SwNode* pNd = rNodes[ nCurrentNode ];
 564         pPrevTextNode = pNd->GetTextNode();
 565         if ( pPrevTextNode )
 566             break;
 567     }
 568
 569     if ( pPrevTextNode )
 570     {
 571         // Expand the string:
 572         const ModelToViewHelper aConversionMap(*pPrevTextNode, mpDoc->getIDocumentLayoutAccess().GetCurrentLayout());
 573         const OUString& aExpandText = aConversionMap.getViewText();
 574
 575         xRet = new SwXFlatParagraph( *pPrevTextNode, aExpandText, aConversionMap );
 576     }
 577
 578     return xRet;
 579 }
 580
 581 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */