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