sfx2/source/doc/SfxRedactionHelper.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
   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
  10 #include <SfxRedactionHelper.hxx>
  11 #include <autoredactdialog.hxx>
  12
  13 #include <com/sun/star/beans/XPropertySet.hpp>
  14 #include <com/sun/star/drawing/XDrawPagesSupplier.hpp>
  15 #include <com/sun/star/drawing/LineStyle.hpp>
  16 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  17 #include <com/sun/star/graphic/XGraphic.hpp>
  18 #include <com/sun/star/frame/XLayoutManager.hpp>
  19
  20 // For page margin related methods
  21 #include <com/sun/star/style/XStyle.hpp>
  22 #include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
  23 #include <com/sun/star/text/XPageCursor.hpp>
  24 #include <com/sun/star/text/XTextViewCursorSupplier.hpp>
  25 #include <com/sun/star/sheet/XSpreadsheetView.hpp>
  26
  27 // Search util
  28 #include <i18nutil/searchopt.hxx>
  29 #include <com/sun/star/util/SearchAlgorithms.hpp>
  30 #include <com/sun/star/util/SearchAlgorithms2.hpp>
  31 #include <com/sun/star/util/SearchFlags.hpp>
  32 #include <vcl/svapp.hxx>
  33 #include <vcl/settings.hxx>
  34 #include <i18nlangtag/languagetag.hxx>
  35 #include <unotools/textsearch.hxx>
  36
  37 #include <sfx2/request.hxx>
  38 #include <sfx2/sfxsids.hrc>
  39 #include <sfx2/viewfrm.hxx>
  40
  41 #include <svl/eitem.hxx>
  42 #include <svl/stritem.hxx>
  43
  44 #include <svtools/DocumentToGraphicRenderer.hxx>
  45
  46 #include <tools/gen.hxx>
  47 #include <tools/stream.hxx>
  48 #include <comphelper/diagnose_ex.hxx>
  49
  50 #include <vcl/gdimtf.hxx>
  51 #include <vcl/graph.hxx>
  52 #include <sal/log.hxx>
  53
  54 #include <vcl/wmf.hxx>
  55 #include <vcl/metaact.hxx>
  56 #include <vcl/outdev.hxx>
  57 #include <vcl/vcllayout.hxx>
  58 #include <o3tl/string_view.hxx>
  59
  60 using namespace ::com::sun::star;
  61 using namespace ::com::sun::star::lang;
  62 using namespace ::com::sun::star::uno;
  63
  64 bool SfxRedactionHelper::isRedactMode(const SfxRequest& rReq)
  65 {
  66     const SfxItemSet* pArgs = rReq.GetArgs();
  67     if (pArgs)
  68     {
  69         const SfxBoolItem* pIsRedactMode = rReq.GetArg<SfxBoolItem>(SID_IS_REDACT_MODE);
  70         if (pIsRedactMode && pIsRedactMode->GetValue())
  71             return true;
  72     }
  73
  74     return false;
  75 }
  76
  77 OUString SfxRedactionHelper::getStringParam(const SfxRequest& rReq, sal_uInt16 nParamId)
  78 {
  79     OUString sStringParam;
  80
  81     const SfxItemSet* pArgs = rReq.GetArgs();
  82     if (!pArgs)
  83         return sStringParam;
  84
  85     const SfxStringItem* pStringArg = rReq.GetArg<SfxStringItem>(nParamId);
  86     if (!pStringArg)
  87         return sStringParam;
  88
  89     sStringParam = pStringArg->GetValue();
  90     return sStringParam;
  91 }
  92
  93 namespace
  94 {
  95 /*
  96  * Roundtrip the gdimetafile to and from WMF
  97  * to get rid of the position and size irregularities
  98  * We better check the conversion method to see what it
  99  * actually does to correct these issues, and do it ourselves.
 100  * */
 101 void fixMetaFile(GDIMetaFile& tmpMtf)
 102 {
 103     SvMemoryStream aDestStrm(65535, 65535);
 104     ConvertGDIMetaFileToWMF(tmpMtf, aDestStrm, nullptr, false);
 105     aDestStrm.Seek(0);
 106
 107     tmpMtf.Clear();
 108
 109     ReadWindowMetafile(aDestStrm, tmpMtf);
 110 }
 111
 112 /*
 113  * Sets page margins for a Draw page. Negative values are considered erroneous
 114  * */
 115 void setPageMargins(const uno::Reference<beans::XPropertySet>& xPageProperySet,
 116                     const PageMargins& aPageMargins)
 117 {
 118     if (aPageMargins.nTop < 0 || aPageMargins.nBottom < 0 || aPageMargins.nLeft < 0
 119         || aPageMargins.nRight < 0)
 120         return;
 121
 122     xPageProperySet->setPropertyValue(u"BorderTop"_ustr, css::uno::Any(aPageMargins.nTop));
 123     xPageProperySet->setPropertyValue(u"BorderBottom"_ustr, css::uno::Any(aPageMargins.nBottom));
 124     xPageProperySet->setPropertyValue(u"BorderLeft"_ustr, css::uno::Any(aPageMargins.nLeft));
 125     xPageProperySet->setPropertyValue(u"BorderRight"_ustr, css::uno::Any(aPageMargins.nRight));
 126 }
 127
 128 // #i10613# Extracted from ImplCheckRect::ImplCreate
 129 tools::Rectangle ImplCalcActionBounds(const MetaAction& rAct, const OutputDevice& rOut,
 130                                       sal_Int32 nStrStartPos, sal_Int32 nStrEndPos)
 131 {
 132     tools::Rectangle aActionBounds;
 133
 134     switch (rAct.GetType())
 135     {
 136         case MetaActionType::TEXTARRAY:
 137         {
 138             const MetaTextArrayAction& rTextAct = static_cast<const MetaTextArrayAction&>(rAct);
 139             const OUString aString(rTextAct.GetText().copy(rTextAct.GetIndex(), rTextAct.GetLen()));
 140
 141             if (!aString.isEmpty())
 142             {
 143                 // #105987# ImplLayout takes everything in logical coordinates
 144                 std::unique_ptr<SalLayout> pSalLayout1 = rOut.ImplLayout(
 145                     aString, 0, nStrStartPos, rTextAct.GetPoint(), 0, rTextAct.GetDXArray());
 146                 std::unique_ptr<SalLayout> pSalLayout2 = rOut.ImplLayout(
 147                     aString, 0, nStrEndPos, rTextAct.GetPoint(), 0, rTextAct.GetDXArray());
 148                 if (pSalLayout2)
 149                 {
 150                     tools::Rectangle aBoundRect2(rOut.ImplGetTextBoundRect(*pSalLayout2));
 151                     aActionBounds = rOut.PixelToLogic(aBoundRect2);
 152                 }
 153                 if (pSalLayout1 && nStrStartPos > 0)
 154                 {
 155                     tools::Rectangle aBoundRect1(rOut.ImplGetTextBoundRect(*pSalLayout1));
 156                     aActionBounds.SetLeft(rOut.PixelToLogic(aBoundRect1).Right());
 157                 }
 158             }
 159         }
 160         break;
 161
 162         default:
 163             break;
 164     }
 165
 166     if (!aActionBounds.IsEmpty())
 167     {
 168         // fdo#40421 limit current action's output to clipped area
 169         if (rOut.IsClipRegion())
 170             return rOut.GetClipRegion().GetBoundRect().Intersection(aActionBounds);
 171         else
 172             return aActionBounds;
 173     }
 174     else
 175         return aActionBounds;
 176 }
 177
 178 } // End of anon namespace
 179
 180 void SfxRedactionHelper::getPageMetaFilesFromDoc(std::vector<GDIMetaFile>& aMetaFiles,
 181                                                  std::vector<::Size>& aPageSizes, sal_Int32 nPages,
 182                                                  DocumentToGraphicRenderer& aRenderer)
 183 {
 184     for (sal_Int32 nPage = 1; nPage <= nPages; ++nPage)
 185     {
 186         ::Size aDocumentSizePixel = aRenderer.getDocumentSizeInPixels(nPage);
 187         ::Point aLogicPos;
 188         ::Point aCalcPageLogicPos;
 189         ::Size aCalcPageContentSize;
 190         ::Size aLogic = aRenderer.getDocumentSizeIn100mm(nPage, &aLogicPos, &aCalcPageLogicPos,
 191                                                          &aCalcPageContentSize);
 192
 193         aPageSizes.push_back(aLogic);
 194
 195         Graphic aGraphic = aRenderer.renderToGraphic(nPage, aDocumentSizePixel, aDocumentSizePixel,
 196                                                      COL_TRANSPARENT, true);
 197         auto& rGDIMetaFile = const_cast<GDIMetaFile&>(aGraphic.GetGDIMetaFile());
 198
 199         // Set preferred map unit and size on the metafile, so the Shape size
 200         // will be correct in MM.
 201         MapMode aMapMode;
 202         aMapMode.SetMapUnit(MapUnit::Map100thMM);
 203
 204         rGDIMetaFile.SetPrefMapMode(aMapMode);
 205         rGDIMetaFile.SetPrefSize(aLogic);
 206
 207         fixMetaFile(rGDIMetaFile);
 208
 209         aMetaFiles.push_back(rGDIMetaFile);
 210     }
 211 }
 212
 213 void SfxRedactionHelper::addPagesToDraw(
 214     const uno::Reference<XComponent>& xComponent, sal_Int32 nPages,
 215     const std::vector<GDIMetaFile>& aMetaFiles, const std::vector<::Size>& aPageSizes,
 216     const PageMargins& aPageMargins,
 217     const std::vector<std::pair<RedactionTarget, OUString>>& r_aTableTargets, bool bIsAutoRedact)
 218 {
 219     // Access the draw pages
 220     uno::Reference<drawing::XDrawPagesSupplier> xDrawPagesSupplier(xComponent, uno::UNO_QUERY);
 221     uno::Reference<drawing::XDrawPages> xDrawPages = xDrawPagesSupplier->getDrawPages();
 222
 223     uno::Reference<css::lang::XMultiServiceFactory> xFactory(xComponent, uno::UNO_QUERY);
 224
 225     for (sal_Int32 nPage = 0; nPage < nPages; ++nPage)
 226     {
 227         const GDIMetaFile& rGDIMetaFile = aMetaFiles[nPage];
 228         Graphic aGraphic(rGDIMetaFile);
 229
 230         sal_Int32 nPageHeight(aPageSizes[nPage].Height());
 231         sal_Int32 nPageWidth(aPageSizes[nPage].Width());
 232
 233         uno::Reference<graphic::XGraphic> xGraph = aGraphic.GetXGraphic();
 234         uno::Reference<drawing::XDrawPage> xPage = xDrawPages->insertNewByIndex(nPage);
 235
 236         // Set page size & margins
 237         uno::Reference<beans::XPropertySet> xPageProperySet(xPage, uno::UNO_QUERY);
 238         xPageProperySet->setPropertyValue(u"Height"_ustr, css::uno::Any(nPageHeight));
 239         xPageProperySet->setPropertyValue(u"Width"_ustr, css::uno::Any(nPageWidth));
 240
 241         setPageMargins(xPageProperySet, aPageMargins);
 242
 243         // Create and insert the shape
 244         uno::Reference<drawing::XShape> xShape(
 245             xFactory->createInstance(u"com.sun.star.drawing.GraphicObjectShape"_ustr),
 246             uno::UNO_QUERY);
 247         uno::Reference<beans::XPropertySet> xShapeProperySet(xShape, uno::UNO_QUERY);
 248         xShapeProperySet->setPropertyValue(u"Graphic"_ustr, uno::Any(xGraph));
 249         xShapeProperySet->setPropertyValue(u"MoveProtect"_ustr, uno::Any(true));
 250         xShapeProperySet->setPropertyValue(u"SizeProtect"_ustr, uno::Any(true));
 251
 252         // Set size
 253         xShape->setSize(
 254             awt::Size(rGDIMetaFile.GetPrefSize().Width(), rGDIMetaFile.GetPrefSize().Height()));
 255
 256         xPage->add(xShape);
 257
 258         if (bIsAutoRedact && !r_aTableTargets.empty())
 259         {
 260             for (const auto& targetPair : r_aTableTargets)
 261             {
 262                 autoRedactPage(targetPair.first, rGDIMetaFile, xPage, xComponent);
 263             }
 264         }
 265     }
 266
 267     // Remove the extra page at the beginning
 268     uno::Reference<drawing::XDrawPage> xPage(xDrawPages->getByIndex(0), uno::UNO_QUERY_THROW);
 269     xDrawPages->remove(xPage);
 270 }
 271
 272 void SfxRedactionHelper::showRedactionToolbar(const SfxViewFrame* pViewFrame)
 273 {
 274     if (!pViewFrame)
 275         return;
 276
 277     Reference<frame::XFrame> xFrame = pViewFrame->GetFrame().GetFrameInterface();
 278     Reference<css::beans::XPropertySet> xPropSet(xFrame, UNO_QUERY);
 279     Reference<css::frame::XLayoutManager> xLayoutManager;
 280
 281     if (!xPropSet.is())
 282         return;
 283
 284     try
 285     {
 286         Any aValue = xPropSet->getPropertyValue(u"LayoutManager"_ustr);
 287         aValue >>= xLayoutManager;
 288         xLayoutManager->createElement(u"private:resource/toolbar/redactionbar"_ustr);
 289         xLayoutManager->showElement(u"private:resource/toolbar/redactionbar"_ustr);
 290     }
 291     catch (const css::uno::RuntimeException&)
 292     {
 293         throw;
 294     }
 295     catch (css::uno::Exception&)
 296     {
 297         TOOLS_WARN_EXCEPTION("sfx.doc", "Exception while trying to show the Redaction Toolbar!");
 298     }
 299 }
 300
 301 PageMargins
 302 SfxRedactionHelper::getPageMarginsForWriter(const css::uno::Reference<css::frame::XModel>& xModel)
 303 {
 304     PageMargins aPageMargins = { -1, -1, -1, -1 };
 305
 306     Reference<text::XTextViewCursorSupplier> xTextViewCursorSupplier(xModel->getCurrentController(),
 307                                                                      UNO_QUERY);
 308     if (!xTextViewCursorSupplier.is())
 309     {
 310         SAL_WARN("sfx.doc", "Ref to xTextViewCursorSupplier is null in setPageMargins().");
 311         return aPageMargins;
 312     }
 313
 314     Reference<text::XPageCursor> xCursor(xTextViewCursorSupplier->getViewCursor(), UNO_QUERY);
 315
 316     uno::Reference<beans::XPropertySet> xPageProperySet(xCursor, UNO_QUERY);
 317     OUString sPageStyleName;
 318     Any aValue = xPageProperySet->getPropertyValue(u"PageStyleName"_ustr);
 319     aValue >>= sPageStyleName;
 320
 321     Reference<css::style::XStyleFamiliesSupplier> xStyleFamiliesSupplier(xModel, UNO_QUERY);
 322     if (!xStyleFamiliesSupplier.is())
 323     {
 324         SAL_WARN("sfx.doc", "Ref to xStyleFamiliesSupplier is null in setPageMargins().");
 325         return aPageMargins;
 326     }
 327     uno::Reference<container::XNameAccess> xStyleFamilies
 328         = xStyleFamiliesSupplier->getStyleFamilies();
 329
 330     if (!xStyleFamilies.is())
 331         return aPageMargins;
 332
 333     uno::Reference<container::XNameAccess> xPageStyles(
 334         xStyleFamilies->getByName(u"PageStyles"_ustr), UNO_QUERY);
 335
 336     if (!xPageStyles.is())
 337         return aPageMargins;
 338
 339     uno::Reference<css::style::XStyle> xPageStyle(xPageStyles->getByName(sPageStyleName),
 340                                                   UNO_QUERY);
 341
 342     if (!xPageStyle.is())
 343         return aPageMargins;
 344
 345     uno::Reference<beans::XPropertySet> xPageProperties(xPageStyle, uno::UNO_QUERY);
 346
 347     if (!xPageProperties.is())
 348         return aPageMargins;
 349
 350     xPageProperties->getPropertyValue(u"LeftMargin"_ustr) >>= aPageMargins.nLeft;
 351     xPageProperties->getPropertyValue(u"RightMargin"_ustr) >>= aPageMargins.nRight;
 352     xPageProperties->getPropertyValue(u"TopMargin"_ustr) >>= aPageMargins.nTop;
 353     xPageProperties->getPropertyValue(u"BottomMargin"_ustr) >>= aPageMargins.nBottom;
 354
 355     return aPageMargins;
 356 }
 357
 358 PageMargins
 359 SfxRedactionHelper::getPageMarginsForCalc(const css::uno::Reference<css::frame::XModel>& xModel)
 360 {
 361     PageMargins aPageMargins = { -1, -1, -1, -1 };
 362     OUString sPageStyleName(u"Default"_ustr);
 363
 364     css::uno::Reference<css::sheet::XSpreadsheetView> xSpreadsheetView(
 365         xModel->getCurrentController(), UNO_QUERY);
 366
 367     if (!xSpreadsheetView.is())
 368     {
 369         SAL_WARN("sfx.doc", "Ref to xSpreadsheetView is null in getPageMarginsForCalc().");
 370         return aPageMargins;
 371     }
 372
 373     uno::Reference<beans::XPropertySet> xSheetProperties(xSpreadsheetView->getActiveSheet(),
 374                                                          UNO_QUERY);
 375
 376     xSheetProperties->getPropertyValue(u"PageStyle"_ustr) >>= sPageStyleName;
 377
 378     Reference<css::style::XStyleFamiliesSupplier> xStyleFamiliesSupplier(xModel, UNO_QUERY);
 379     if (!xStyleFamiliesSupplier.is())
 380     {
 381         SAL_WARN("sfx.doc", "Ref to xStyleFamiliesSupplier is null in getPageMarginsForCalc().");
 382         return aPageMargins;
 383     }
 384     uno::Reference<container::XNameAccess> xStyleFamilies
 385         = xStyleFamiliesSupplier->getStyleFamilies();
 386
 387     if (!xStyleFamilies.is())
 388         return aPageMargins;
 389
 390     uno::Reference<container::XNameAccess> xPageStyles(
 391         xStyleFamilies->getByName(u"PageStyles"_ustr), UNO_QUERY);
 392
 393     if (!xPageStyles.is())
 394         return aPageMargins;
 395
 396     uno::Reference<css::style::XStyle> xPageStyle(xPageStyles->getByName(sPageStyleName),
 397                                                   UNO_QUERY);
 398
 399     if (!xPageStyle.is())
 400         return aPageMargins;
 401
 402     uno::Reference<beans::XPropertySet> xPageProperties(xPageStyle, uno::UNO_QUERY);
 403
 404     if (!xPageProperties.is())
 405         return aPageMargins;
 406
 407     xPageProperties->getPropertyValue(u"LeftMargin"_ustr) >>= aPageMargins.nLeft;
 408     xPageProperties->getPropertyValue(u"RightMargin"_ustr) >>= aPageMargins.nRight;
 409     xPageProperties->getPropertyValue(u"TopMargin"_ustr) >>= aPageMargins.nTop;
 410     xPageProperties->getPropertyValue(u"BottomMargin"_ustr) >>= aPageMargins.nBottom;
 411
 412     return aPageMargins;
 413 }
 414
 415 void SfxRedactionHelper::searchInMetaFile(const RedactionTarget& rRedactionTarget,
 416                                           const GDIMetaFile& rMtf,
 417                                           std::vector<::tools::Rectangle>& aRedactionRectangles,
 418                                           const uno::Reference<XComponent>& xComponent)
 419 {
 420     // Initialize search
 421     i18nutil::SearchOptions2 aSearchOptions;
 422     fillSearchOptions(aSearchOptions, rRedactionTarget);
 423
 424     utl::TextSearch textSearch(aSearchOptions);
 425
 426     OutputDevice* pOutputDevice
 427         = SfxObjectShell::GetShellFromComponent(xComponent)->GetDocumentRefDev();
 428     pOutputDevice->Push(::vcl::PushFlags::FONT);
 429
 430     MetaAction* pCurrAct;
 431
 432     for (pCurrAct = const_cast<GDIMetaFile&>(rMtf).FirstAction(); pCurrAct;
 433          pCurrAct = const_cast<GDIMetaFile&>(rMtf).NextAction())
 434     {
 435         // Watch for TEXTARRAY actions.
 436         // They contain the text of paragraphs.
 437         if (pCurrAct->GetType() == MetaActionType::TEXTARRAY)
 438         {
 439             MetaTextArrayAction* pMetaTextArrayAction = static_cast<MetaTextArrayAction*>(pCurrAct);
 440
 441             // Search operation takes place here
 442             OUString sText = pMetaTextArrayAction->GetText();
 443             sal_Int32 nStart = 0;
 444             sal_Int32 nEnd = sText.getLength();
 445
 446             bool bFound = textSearch.SearchForward(sText, &nStart, &nEnd);
 447
 448             // If found the string, add the corresponding rectangle to the collection
 449             while (bFound)
 450             {
 451                 tools::Rectangle aNewRect(
 452                     ImplCalcActionBounds(*pMetaTextArrayAction, *pOutputDevice, nStart, nEnd));
 453
 454                 if (!aNewRect.IsEmpty())
 455                 {
 456                     // Then increase 10% of the new value to make it look better.
 457                     auto const adj(aNewRect.GetHeight() / 20);
 458                     aNewRect.AdjustTop(-adj);
 459                     aNewRect.AdjustBottom(adj);
 460                     aNewRect.AdjustRight(adj); // also add a bit on the right
 461                     aRedactionRectangles.push_back(aNewRect);
 462                 }
 463
 464                 // Search for the next occurrence
 465                 nStart = nEnd;
 466                 nEnd = sText.getLength();
 467                 bFound = textSearch.SearchForward(sText, &nStart, &nEnd);
 468             }
 469         }
 470         else if (pCurrAct->GetType() == MetaActionType::FONT)
 471         {
 472             const MetaFontAction* pFontAct = static_cast<const MetaFontAction*>(pCurrAct);
 473             vcl::Font const font{ pFontAct->GetFont() };
 474             pOutputDevice->SetFont(font);
 475         }
 476     }
 477
 478     pOutputDevice->Pop();
 479 }
 480
 481 void SfxRedactionHelper::addRedactionRectToPage(
 482     const uno::Reference<XComponent>& xComponent, const uno::Reference<drawing::XDrawPage>& xPage,
 483     const std::vector<::tools::Rectangle>& aNewRectangles)
 484 {
 485     if (!xComponent.is() || !xPage.is())
 486         return;
 487
 488     if (aNewRectangles.empty())
 489         return;
 490
 491     uno::Reference<css::lang::XMultiServiceFactory> xFactory(xComponent, uno::UNO_QUERY);
 492
 493     for (auto const& aNewRectangle : aNewRectangles)
 494     {
 495         uno::Reference<drawing::XShape> xRectShape(
 496             xFactory->createInstance(u"com.sun.star.drawing.RectangleShape"_ustr), uno::UNO_QUERY);
 497         uno::Reference<beans::XPropertySet> xRectShapeProperySet(xRectShape, uno::UNO_QUERY);
 498
 499         xRectShapeProperySet->setPropertyValue(u"Name"_ustr,
 500                                                uno::Any(u"RectangleRedactionShape"_ustr));
 501         xRectShapeProperySet->setPropertyValue(u"FillTransparence"_ustr,
 502                                                css::uno::Any(static_cast<sal_Int16>(50)));
 503         xRectShapeProperySet->setPropertyValue(u"FillColor"_ustr, css::uno::Any(COL_GRAY7));
 504         xRectShapeProperySet->setPropertyValue(
 505             u"LineStyle"_ustr, css::uno::Any(css::drawing::LineStyle::LineStyle_NONE));
 506
 507         xRectShape->setSize(awt::Size(aNewRectangle.GetWidth(), aNewRectangle.GetHeight()));
 508         xRectShape->setPosition(awt::Point(aNewRectangle.Left(), aNewRectangle.Top()));
 509
 510         xPage->add(xRectShape);
 511     }
 512 }
 513
 514 void SfxRedactionHelper::autoRedactPage(const RedactionTarget& rRedactionTarget,
 515                                         const GDIMetaFile& rGDIMetaFile,
 516                                         const uno::Reference<drawing::XDrawPage>& xPage,
 517                                         const uno::Reference<XComponent>& xComponent)
 518 {
 519     if (rRedactionTarget.sContent.isEmpty())
 520         return;
 521
 522     // Search for the redaction strings, and get the rectangle coordinates
 523     std::vector<::tools::Rectangle> aRedactionRectangles;
 524     searchInMetaFile(rRedactionTarget, rGDIMetaFile, aRedactionRectangles, xComponent);
 525
 526     // Add the redaction rectangles to the page
 527     addRedactionRectToPage(xComponent, xPage, aRedactionRectangles);
 528 }
 529
 530 namespace
 531 {
 532 const LanguageTag& GetAppLanguageTag() { return Application::GetSettings().GetLanguageTag(); }
 533 }
 534
 535 void SfxRedactionHelper::fillSearchOptions(i18nutil::SearchOptions2& rSearchOpt,
 536                                            const RedactionTarget& rTarget)
 537 {
 538     if (rTarget.sType == RedactionTargetType::REDACTION_TARGET_REGEX
 539         || rTarget.sType == RedactionTargetType::REDACTION_TARGET_PREDEFINED)
 540     {
 541         rSearchOpt.AlgorithmType2 = util::SearchAlgorithms2::REGEXP;
 542     }
 543     else
 544     {
 545         rSearchOpt.AlgorithmType2 = util::SearchAlgorithms2::ABSOLUTE;
 546     }
 547
 548     rSearchOpt.Locale = GetAppLanguageTag().getLocale();
 549     if (rTarget.sType == RedactionTargetType::REDACTION_TARGET_PREDEFINED)
 550     {
 551         auto nPredefIndex = o3tl::toUInt32(o3tl::getToken(rTarget.sContent, 0, ';'));
 552         rSearchOpt.searchString = m_aPredefinedTargets[nPredefIndex];
 553     }
 554     else
 555         rSearchOpt.searchString = rTarget.sContent;
 556
 557     rSearchOpt.replaceString.clear();
 558
 559     if (!rTarget.bCaseSensitive && rTarget.sType != RedactionTargetType::REDACTION_TARGET_REGEX
 560         && rTarget.sType != RedactionTargetType::REDACTION_TARGET_PREDEFINED)
 561         rSearchOpt.transliterateFlags |= TransliterationFlags::IGNORE_CASE;
 562     if (rTarget.bWholeWords)
 563         rSearchOpt.searchFlag |= util::SearchFlags::NORM_WORD_ONLY;
 564 }
 565
 566 /* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */