sw/source/filter/ww8/writerhelper.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 <sal/config.h>
  21 #include <sal/log.hxx>
  22
  23 #include <com/sun/star/util/CloseVetoException.hpp>
  24
  25 #include <doc.hxx>
  26 #include "writerhelper.hxx"
  27 #include <msfilter.hxx>
  28 #include <com/sun/star/container/XChild.hpp>
  29
  30 #include <algorithm>
  31 #include <svl/itemiter.hxx>
  32 #include <svx/svdobj.hxx>
  33 #include <svx/svdoole2.hxx>
  34 #include <tools/UnitConversion.hxx>
  35 #include <editeng/formatbreakitem.hxx>
  36 #include <osl/diagnose.h>
  37 #include <ndtxt.hxx>
  38 #include <ndnotxt.hxx>
  39 #include <fmtcntnt.hxx>
  40 #include <swtable.hxx>
  41 #include <frmfmt.hxx>
  42 #include <flypos.hxx>
  43 #include <fmtanchr.hxx>
  44 #include <fmtfsize.hxx>
  45 #include <SwStyleNameMapper.hxx>
  46 #include <docary.hxx>
  47 #include <charfmt.hxx>
  48 #include <fchrfmt.hxx>
  49 #include <redline.hxx>
  50 #include "types.hxx"
  51 #include <svtools/embedhlp.hxx>
  52 #include <numrule.hxx>
  53 #include <utility>
  54 #include <vcl/svapp.hxx>
  55 #include <IDocumentDrawModelAccess.hxx>
  56 #include <IDocumentLayoutAccess.hxx>
  57 #include <IDocumentRedlineAccess.hxx>
  58 #include <IDocumentStylePoolAccess.hxx>
  59 #include <IDocumentMarkAccess.hxx>
  60 #include <IMark.hxx>
  61 #include <grfatr.hxx>
  62 #include <poolfmt.hxx>
  63
  64 using namespace com::sun::star;
  65
  66 namespace
  67 {
  68     // #i98791# - adjust sorting
  69     // Utility to sort SwTextFormatColl's by their assigned outline style list level
  70     class outlinecmp
  71     {
  72     public:
  73         bool operator()(const SwTextFormatColl *pA, const SwTextFormatColl *pB) const
  74         {
  75             // #i98791#
  76             bool bResult( false );
  77             const bool bIsAAssignedToOutlineStyle( pA->IsAssignedToListLevelOfOutlineStyle() );
  78             const bool bIsBAssignedToOutlineStyle( pB->IsAssignedToListLevelOfOutlineStyle() );
  79             if ( bIsAAssignedToOutlineStyle != bIsBAssignedToOutlineStyle )
  80             {
  81                 bResult = bIsBAssignedToOutlineStyle;
  82             }
  83             else if ( !bIsAAssignedToOutlineStyle )
  84             {
  85                 // pA and pB are equal regarding the sorting criteria.
  86                 // Thus return value does not matter.
  87                 bResult = false;
  88             }
  89             else
  90             {
  91                 bResult = pA->GetAssignedOutlineStyleLevel() < pB->GetAssignedOutlineStyleLevel();
  92             }
  93
  94             return bResult;
  95        }
  96     };
  97
  98     bool IsValidSlotWhich(sal_uInt16 nSlotId, sal_uInt16 nWhichId)
  99     {
 100         return (nSlotId != 0 && nWhichId != 0 && nSlotId != nWhichId);
 101     }
 102
 103     /*
 104      Utility to convert a SwPosFlyFrames into a simple vector of ww8::Frames
 105
 106      The crucial thing is that a ww8::Frame always has an anchor which
 107      points to some content in the document. This is a requirement of exporting
 108      to Word
 109     */
 110     ww8::Frames SwPosFlyFramesToFrames(const SwPosFlyFrames &rFlys)
 111     {
 112         ww8::Frames aRet;
 113
 114         for(const auto& rFly : rFlys)
 115         {
 116             const SwFrameFormat &rEntry = rFly.GetFormat();
 117             const SwFormat* pParent = rEntry.DerivedFrom();
 118             const SwFormatAnchor& rAnchor = rEntry.GetAnchor();
 119             // keep only Inline Heading frames from the frames anchored as characters
 120             bool bAsChar = rAnchor.GetAnchorId() ==
 121                     static_cast<RndStdIds>(css::text::TextContentAnchorType_AS_CHARACTER);
 122             if ( bAsChar &&
 123                     !(pParent && pParent->GetPoolFormatId() == RES_POOLFRM_INLINE_HEADING) )
 124             {
 125                 continue;
 126             }
 127             if (const SwNode* pAnchor = rAnchor.GetAnchorNode())
 128             {
 129                 // the anchor position will be invalidated by SetRedlineFlags
 130                 // so set a dummy position and fix it in UpdateFramePositions
 131                 SwPosition const dummy(const_cast<SwNodes&>(pAnchor->GetNodes()));
 132                 aRet.emplace_back(rEntry, dummy);
 133             }
 134             else
 135             {
 136                 SwPosition aPos(rFly.GetNode());
 137                 aRet.emplace_back(rEntry, aPos);
 138             }
 139         }
 140         return aRet;
 141     }
 142
 143     //Utility to test if a frame is anchored at a given node
 144     class anchoredto
 145     {
 146     private:
 147         const SwNode& mrNode;
 148     public:
 149         explicit anchoredto(const SwNode& rNode) : mrNode(rNode) {}
 150         bool operator()(const ww8::Frame &rFrame) const
 151         {
 152             return (mrNode == rFrame.GetPosition().GetNode());
 153         }
 154     };
 155 }
 156
 157 namespace ww8
 158 {
 159     //For i120928,size conversion before exporting graphic of bullet
 160     Frame::Frame(const Graphic &rGrf, SwPosition aPos)
 161         : mpFlyFrame(nullptr)
 162         , maPos(std::move(aPos))
 163         , meWriterType(eBulletGrf)
 164         , mpStartFrameContent(nullptr)
 165         , mbIsInline(true)
 166         , mbForBullet(true)
 167         , maGrf(rGrf)
 168     {
 169         const MapMode aMap100mm( MapUnit::Map100thMM );
 170         Size    aSize( rGrf.GetPrefSize() );
 171         if ( MapUnit::MapPixel == rGrf.GetPrefMapMode().GetMapUnit() )
 172         {
 173             aSize = Application::GetDefaultDevice()->PixelToLogic(aSize, aMap100mm );
 174         }
 175         else
 176         {
 177             aSize = OutputDevice::LogicToLogic( aSize,rGrf.GetPrefMapMode(), aMap100mm );
 178         }
 179         maSize = aSize;
 180         maLayoutSize = maSize;
 181     }
 182
 183     Frame::Frame(const SwFrameFormat &rFormat, SwPosition aPos)
 184         : mpFlyFrame(&rFormat)
 185         , maPos(std::move(aPos))
 186         , meWriterType(eTextBox)
 187         , mpStartFrameContent(nullptr)
 188         // #i43447# - move to initialization list
 189         , mbIsInline( (rFormat.GetAnchor().GetAnchorId() == RndStdIds::FLY_AS_CHAR) )
 190         // #i120928# - handle graphic of bullet within existing implementation
 191         , mbForBullet(false)
 192     {
 193         switch (rFormat.Which())
 194         {
 195             case RES_FLYFRMFMT:
 196                 if (const SwNodeIndex* pIdx = rFormat.GetContent().GetContentIdx())
 197                 {
 198                     SwNodeIndex aIdx(*pIdx, 1);
 199                     const SwNode &rNd = aIdx.GetNode();
 200                     // #i43447# - determine layout size
 201                     {
 202                         SwRect aLayRect( rFormat.FindLayoutRect() );
 203                         tools::Rectangle aRect( aLayRect.SVRect() );
 204                         // The Object is not rendered (e.g. something in unused
 205                         // header/footer) - thus, get the values from the format.
 206                         if ( aLayRect.IsEmpty() )
 207                         {
 208                             aRect.SetSize( rFormat.GetFrameSize().GetSize() );
 209                         }
 210                         maLayoutSize = aRect.GetSize();
 211                     }
 212                     switch (rNd.GetNodeType())
 213                     {
 214                         case SwNodeType::Grf:
 215                             meWriterType = eGraphic;
 216                             maSize = rNd.GetNoTextNode()->GetTwipSize();
 217                             break;
 218                         case SwNodeType::Ole:
 219                             meWriterType = eOle;
 220                             maSize = rNd.GetNoTextNode()->GetTwipSize();
 221                             break;
 222                         default:
 223                             meWriterType = eTextBox;
 224                             // #i43447# - Size equals layout size for text boxes
 225                             maSize = maLayoutSize;
 226                             break;
 227                     }
 228                     mpStartFrameContent = &rNd;
 229                 }
 230                 else
 231                 {
 232                     OSL_ENSURE(false, "Impossible");
 233                     meWriterType = eTextBox;
 234                 }
 235                 break;
 236             default:
 237                 if (const SdrObject* pObj = rFormat.FindRealSdrObject())
 238                 {
 239                     if (pObj->GetObjInventor() == SdrInventor::FmForm)
 240                         meWriterType = eFormControl;
 241                     else
 242                         meWriterType = eDrawing;
 243                     maSize = pObj->GetSnapRect().GetSize();
 244                     maLayoutSize = maSize;
 245                 }
 246                 else
 247                 {
 248                     OSL_ENSURE(false, "Impossible");
 249                     meWriterType = eDrawing;
 250                 }
 251                 break;
 252         }
 253     }
 254
 255
 256     void Frame::ForceTreatAsInline()
 257     {
 258         mbIsInline = true;
 259     }
 260 }
 261
 262 namespace sw
 263 {
 264     namespace hack
 265     {
 266
 267         sal_uInt16 TransformWhichBetweenPools(const SfxItemPool &rDestPool,
 268             const SfxItemPool &rSrcPool, sal_uInt16 nWhich)
 269         {
 270             sal_uInt16 nSlotId = rSrcPool.GetSlotId(nWhich);
 271             if (IsValidSlotWhich(nSlotId, nWhich))
 272                 nWhich = rDestPool.GetWhichIDFromSlotID(nSlotId);
 273             else
 274                 nWhich = 0;
 275             return nWhich;
 276         }
 277
 278         sal_uInt16 GetSetWhichFromSwDocWhich(const SfxItemSet &rSet,
 279             const SwDoc &rDoc, sal_uInt16 nWhich)
 280         {
 281             if (RES_WHICHHINT_END < rSet.GetRanges()[0].first)
 282             {
 283                 nWhich = TransformWhichBetweenPools(*rSet.GetPool(),
 284                     rDoc.GetAttrPool(), nWhich);
 285             }
 286             return nWhich;
 287         }
 288
 289         DrawingOLEAdaptor::DrawingOLEAdaptor(SdrOle2Obj &rObj,
 290             SfxObjectShell &rPers)
 291             : mxIPRef(rObj.GetObjRef()), mrPers(rPers),
 292             mpGraphic( rObj.GetGraphic() )
 293         {
 294             rObj.AbandonObject();
 295         }
 296
 297         bool DrawingOLEAdaptor::TransferToDoc( OUString &rName )
 298         {
 299             OSL_ENSURE(mxIPRef.is(), "Transferring invalid object to doc");
 300             if (!mxIPRef.is())
 301                 return false;
 302
 303             uno::Reference < container::XChild > xChild( mxIPRef, uno::UNO_QUERY );
 304             if ( xChild.is() )
 305                 xChild->setParent( mrPers.GetModel() );
 306
 307             bool bSuccess = mrPers.GetEmbeddedObjectContainer().InsertEmbeddedObject( mxIPRef, rName );
 308             if (bSuccess)
 309             {
 310                 if ( mpGraphic )
 311                     ::svt::EmbeddedObjectRef::SetGraphicToContainer( *mpGraphic,
 312                                                                     mrPers.GetEmbeddedObjectContainer(),
 313                                                                     rName,
 314                                                                     OUString() );
 315
 316                 mxIPRef = nullptr;
 317             }
 318
 319             return bSuccess;
 320         }
 321
 322         DrawingOLEAdaptor::~DrawingOLEAdaptor()
 323         {
 324             if (!mxIPRef.is())
 325                 return;
 326
 327             OSL_ENSURE( !mrPers.GetEmbeddedObjectContainer().HasEmbeddedObject( mxIPRef ), "Object in adaptor is inserted?!" );
 328             try
 329             {
 330                 mxIPRef->close(true);
 331             }
 332             catch ( const css::util::CloseVetoException& )
 333             {
 334             }
 335
 336             mxIPRef = nullptr;
 337         }
 338     }
 339
 340     namespace util
 341     {
 342         SwTwips MakeSafePositioningValue(SwTwips nIn)
 343         {
 344             if (nIn > SHRT_MAX)
 345                 nIn = SHRT_MAX;
 346             else if (nIn < SHRT_MIN)
 347                 nIn = SHRT_MIN;
 348             return nIn;
 349         }
 350
 351         void SetLayer::SendObjectToHell(SdrObject &rObject) const
 352         {
 353             SetObjectLayer(rObject, eHell);
 354         }
 355
 356         void SetLayer::SendObjectToHeaven(SdrObject &rObject) const
 357         {
 358             SetObjectLayer(rObject, eHeaven);
 359         }
 360
 361         void SetLayer::SetObjectLayer(SdrObject &rObject, Layer eLayer) const
 362         {
 363             if (SdrInventor::FmForm == rObject.GetObjInventor())
 364                 rObject.SetLayer(mnFormLayer);
 365             else
 366             {
 367                 switch (eLayer)
 368                 {
 369                     case eHeaven:
 370                         rObject.SetLayer(mnHeavenLayer);
 371                         break;
 372                     case eHell:
 373                         rObject.SetLayer(mnHellLayer);
 374                         break;
 375                 }
 376             }
 377         }
 378
 379         //SetLayer boilerplate begin
 380
 381         // #i38889# - by default put objects into the invisible layers.
 382         SetLayer::SetLayer(const SwDoc &rDoc)
 383             : mnHeavenLayer(rDoc.getIDocumentDrawModelAccess().GetInvisibleHeavenId()),
 384               mnHellLayer(rDoc.getIDocumentDrawModelAccess().GetInvisibleHellId()),
 385               mnFormLayer(rDoc.getIDocumentDrawModelAccess().GetInvisibleControlsId())
 386         {
 387         }
 388         //SetLayer boilerplate end
 389
 390         void GetPoolItems(const SfxItemSet &rSet, ww8::PoolItems &rItems, bool bExportParentItemSet )
 391         {
 392             if( bExportParentItemSet )
 393             {
 394                 for (SfxItemIter aIter(rSet); !aIter.IsAtEnd(); aIter.NextItem())
 395                 {
 396                     const SfxPoolItem* pItem(nullptr);
 397                     if(SfxItemState::SET == aIter.GetItemState(true, &pItem))
 398                         rItems[aIter.GetCurWhich()] = pItem;
 399                 }
 400             }
 401             else if( rSet.Count())
 402             {
 403                 for (SfxItemIter aIter(rSet); !aIter.IsAtEnd(); aIter.NextItem())
 404                     rItems[aIter.GetCurWhich()] = aIter.GetCurItem();
 405             }
 406 //            DeduplicateItems(rItems);
 407         }
 408
 409         const SfxPoolItem *SearchPoolItems(const ww8::PoolItems &rItems,
 410             sal_uInt16 eType)
 411         {
 412             auto aIter = rItems.find(eType);
 413             if (aIter != rItems.end())
 414                 return aIter->second;
 415             return nullptr;
 416         }
 417
 418         void ClearOverridesFromSet(const SwFormatCharFormat &rFormat, SfxItemSet &rSet)
 419         {
 420             if (const SwCharFormat* pCharFormat = rFormat.GetCharFormat())
 421             {
 422                 if (pCharFormat->GetAttrSet().Count())
 423                 {
 424                     SfxItemIter aIter(pCharFormat->GetAttrSet());
 425                     const SfxPoolItem *pItem = aIter.GetCurItem();
 426                     do
 427                         rSet.ClearItem(pItem->Which());
 428                     while ((pItem = aIter.NextItem()));
 429                 }
 430             }
 431         }
 432
 433         ww8::ParaStyles GetParaStyles(const SwDoc &rDoc)
 434         {
 435             ww8::ParaStyles aStyles;
 436             typedef ww8::ParaStyles::size_type mysizet;
 437
 438             const SwTextFormatColls *pColls = rDoc.GetTextFormatColls();
 439             mysizet nCount = pColls ? pColls->size() : 0;
 440             aStyles.reserve(nCount);
 441             for (mysizet nI = 0; nI < nCount; ++nI)
 442                 aStyles.push_back((*pColls)[ static_cast< sal_uInt16 >(nI) ]);
 443             return aStyles;
 444         }
 445
 446         SwTextFormatColl* GetParaStyle(SwDoc &rDoc, const OUString& rName)
 447         {
 448             // Search first in the Doc-Styles
 449             SwTextFormatColl* pColl = rDoc.FindTextFormatCollByName(rName);
 450             if (!pColl)
 451             {
 452                 // Collection not found, try in Pool ?
 453                 sal_uInt16 n = SwStyleNameMapper::GetPoolIdFromUIName(rName,
 454                     SwGetPoolIdFromName::TxtColl);
 455                 if (n != SAL_MAX_UINT16)       // found or standard
 456                     pColl = rDoc.getIDocumentStylePoolAccess().GetTextCollFromPool(n, false);
 457             }
 458             return pColl;
 459         }
 460
 461         SwCharFormat* GetCharStyle(SwDoc &rDoc, const OUString& rName)
 462         {
 463             SwCharFormat *pFormat = rDoc.FindCharFormatByName(rName);
 464             if (!pFormat)
 465             {
 466                 // Collection not found, try in Pool ?
 467                 sal_uInt16 n = SwStyleNameMapper::GetPoolIdFromUIName(rName,
 468                     SwGetPoolIdFromName::ChrFmt);
 469                 if (n != SAL_MAX_UINT16)       // found or standard
 470                     pFormat = rDoc.getIDocumentStylePoolAccess().GetCharFormatFromPool(n);
 471             }
 472             return pFormat;
 473         }
 474
 475         // #i98791# - adjust sorting algorithm
 476         void SortByAssignedOutlineStyleListLevel(ww8::ParaStyles &rStyles)
 477         {
 478             std::sort(rStyles.begin(), rStyles.end(), outlinecmp());
 479         }
 480
 481         /*
 482            Utility to extract FlyFormats from a document, potentially from a
 483            selection.
 484            */
 485         ww8::Frames GetFrames(const SwDoc &rDoc, SwPaM const *pPaM /*, bool bAll*/)
 486         {
 487             SwPosFlyFrames aFlys(rDoc.GetAllFlyFormats(pPaM, /*bDrawAlso=*/true, /*bAsCharAlso=*/true));
 488             ww8::Frames aRet(SwPosFlyFramesToFrames(aFlys));
 489             return aRet;
 490         }
 491
 492         void UpdateFramePositions(ww8::Frames & rFrames)
 493         {
 494             for (ww8::Frame & rFrame : rFrames)
 495             {
 496                 SwFormatAnchor const& rAnchor = rFrame.GetFrameFormat().GetAnchor();
 497                 if (SwPosition const*const pAnchor = rAnchor.GetContentAnchor())
 498                 {
 499                     rFrame.SetPosition(*pAnchor);
 500                 }
 501                 else
 502                 {   // these don't need to be corrected, they're not in redlines
 503                     assert(RndStdIds::FLY_AT_PAGE == rAnchor.GetAnchorId());
 504                 }
 505             }
 506         }
 507
 508         ww8::Frames GetFramesInNode(const ww8::Frames &rFrames, const SwNode &rNode)
 509         {
 510             ww8::Frames aRet;
 511             std::copy_if(rFrames.begin(), rFrames.end(),
 512                 std::back_inserter(aRet), anchoredto(rNode));
 513             return aRet;
 514         }
 515
 516         const SwNumFormat* GetNumFormatFromSwNumRuleLevel(const SwNumRule &rRule,
 517             int nLevel)
 518         {
 519             if (nLevel < 0 || nLevel >= MAXLEVEL)
 520             {
 521                 OSL_FAIL("Invalid level");
 522                 return nullptr;
 523             }
 524             return &(rRule.Get( static_cast< sal_uInt16 >(nLevel) ));
 525         }
 526
 527         const SwNumFormat* GetNumFormatFromTextNode(const SwTextNode &rTextNode)
 528         {
 529             const SwNumRule *pRule = nullptr;
 530             if (
 531                 rTextNode.IsNumbered() && rTextNode.IsCountedInList() &&
 532                 nullptr != (pRule = rTextNode.GetNumRule())
 533                 )
 534             {
 535                 return GetNumFormatFromSwNumRuleLevel(*pRule,
 536                     rTextNode.GetActualListLevel());
 537             }
 538
 539             if (
 540                 rTextNode.IsNumbered() && rTextNode.IsCountedInList() &&
 541                 nullptr != (pRule = rTextNode.GetDoc().GetOutlineNumRule())
 542                 )
 543             {
 544                 return GetNumFormatFromSwNumRuleLevel(*pRule,
 545                     rTextNode.GetActualListLevel());
 546             }
 547
 548             return nullptr;
 549         }
 550
 551         const SwNumRule* GetNumRuleFromTextNode(const SwTextNode &rTextNode)
 552         {
 553             return GetNormalNumRuleFromTextNode(rTextNode);
 554         }
 555
 556         const SwNumRule* GetNormalNumRuleFromTextNode(const SwTextNode &rTextNode)
 557         {
 558             const SwNumRule *pRule = nullptr;
 559
 560             if (
 561                 rTextNode.IsNumbered() && rTextNode.IsCountedInList() &&
 562                 nullptr != (pRule = rTextNode.GetNumRule())
 563                )
 564             {
 565                 return pRule;
 566             }
 567             return nullptr;
 568         }
 569
 570         SwNoTextNode *GetNoTextNodeFromSwFrameFormat(const SwFrameFormat &rFormat)
 571         {
 572             const SwNodeIndex *pIndex = rFormat.GetContent().GetContentIdx();
 573             OSL_ENSURE(pIndex, "No NodeIndex in SwFrameFormat ?, suspicious");
 574             if (!pIndex)
 575                 return nullptr;
 576             SwNodeIndex aIdx(*pIndex, 1);
 577             return aIdx.GetNode().GetNoTextNode();
 578         }
 579
 580         bool HasPageBreak(const SwNode &rNd)
 581         {
 582             const SvxFormatBreakItem *pBreak = nullptr;
 583             if (rNd.IsTableNode() && rNd.GetTableNode())
 584             {
 585                 const SwTable& rTable = rNd.GetTableNode()->GetTable();
 586                 const SwFrameFormat* pApply = rTable.GetFrameFormat();
 587                 OSL_ENSURE(pApply, "impossible");
 588                 if (pApply)
 589                     pBreak = &pApply->GetFormatAttr(RES_BREAK);
 590             }
 591             else if (const SwContentNode *pNd = rNd.GetContentNode())
 592                 pBreak = &pNd->GetAttr(RES_BREAK);
 593
 594             return pBreak && pBreak->GetBreak() == SvxBreak::PageBefore;
 595         }
 596
 597         tools::Polygon PolygonFromPolyPolygon(const tools::PolyPolygon &rPolyPoly)
 598         {
 599             if(1 == rPolyPoly.Count())
 600             {
 601                 return rPolyPoly[0];
 602             }
 603             else
 604             {
 605                 // This method will now just concatenate the polygons contained
 606                 // in the given PolyPolygon. Anything else which might be thought of
 607                 // for reducing to a single polygon will just need more power and
 608                 // cannot create more correct results.
 609                 sal_uInt32 nPointCount(0);
 610
 611                 for( auto const& rPoly : rPolyPoly )
 612                 {
 613                     nPointCount += static_cast<sal_uInt32>(rPoly.GetSize());
 614                 }
 615
 616                 if(nPointCount > 0x0000ffff)
 617                 {
 618                     OSL_FAIL("PolygonFromPolyPolygon: too many points for a single polygon (!)");
 619                     nPointCount = 0x0000ffff;
 620                 }
 621
 622                 tools::Polygon aRetval(o3tl::narrowing<sal_uInt16>(nPointCount));
 623                 sal_uInt32 nAppendIndex(0);
 624
 625                 for( auto const& rCandidate : rPolyPoly )
 626                 {
 627                     for(sal_uInt16 b(0); nAppendIndex <= nPointCount && b < rCandidate.GetSize(); b++)
 628                     {
 629                         aRetval[o3tl::narrowing<sal_uInt16>(nAppendIndex++)] = rCandidate[b];
 630                     }
 631                 }
 632
 633                 return aRetval;
 634             }
 635         }
 636
 637         tools::Polygon CorrectWordWrapPolygonForExport(const tools::PolyPolygon& rPolyPoly, const SwNoTextNode* pNd, bool bCorrectCrop)
 638         {
 639             tools::Polygon aPoly(PolygonFromPolyPolygon(rPolyPoly));
 640             const Size aOrigSize = pNd->GetGraphic().GetPrefSize();
 641
 642             const SwAttrSet* pAttrSet = pNd->GetpSwAttrSet();
 643             if (bCorrectCrop && pAttrSet)
 644             {
 645                 if (pAttrSet->HasItem(RES_GRFATR_CROPGRF))
 646                 {
 647                     // Word's wrap polygon deals with a canvas which has the size of the already
 648                     // cropped graphic, do the opposite of correctCrop() in writerfilter/.
 649                     const SwCropGrf& rCrop = pAttrSet->GetCropGrf();
 650                     sal_Int32 nCropLeft = convertTwipToMm100(rCrop.GetLeft());
 651                     sal_Int32 nCropRight = convertTwipToMm100(rCrop.GetRight());
 652                     sal_Int32 nCropTop = convertTwipToMm100(rCrop.GetTop());
 653                     sal_Int32 nCropBottom = convertTwipToMm100(rCrop.GetBottom());
 654                     aPoly.Move(-nCropLeft, -nCropTop);
 655
 656                     Fraction aScaleX(aOrigSize.getWidth(), aOrigSize.getWidth() - nCropLeft - nCropRight);
 657                     Fraction aScaleY(aOrigSize.getHeight(), aOrigSize.getHeight() - nCropTop - nCropBottom);
 658                     aPoly.Scale(double(aScaleX), double(aScaleY));
 659                 }
 660             }
 661
 662             Fraction aMapPolyX(ww::nWrap100Percent, aOrigSize.Width());
 663             Fraction aMapPolyY(ww::nWrap100Percent, aOrigSize.Height());
 664             aPoly.Scale(double(aMapPolyX), double(aMapPolyY));
 665
 666             /*
 667              a) stretch right bound by 15twips
 668              b) shrink bottom bound to where it would have been in word
 669              c) Move it to the left by 15twips
 670
 671              See the import for details
 672             */
 673             const Size aSize = pNd->GetTwipSize();
 674             Fraction aMoveHack(ww::nWrap100Percent, aSize.Width());
 675             aMoveHack *= Fraction(15, 1);
 676             tools::Long nMove(aMoveHack);
 677
 678             Fraction aHackX(ww::nWrap100Percent + nMove,
 679                     ww::nWrap100Percent);
 680             Fraction aHackY(ww::nWrap100Percent - nMove,
 681                     ww::nWrap100Percent);
 682             aPoly.Scale(double(aHackX), double(aHackY));
 683
 684             aPoly.Move(-nMove, 0);
 685             return aPoly;
 686         }
 687
 688         void RedlineStack::open(const SwPosition& rPos, const SfxPoolItem& rAttr)
 689         {
 690             OSL_ENSURE(rAttr.Which() == RES_FLTR_REDLINE, "not a redline");
 691             maStack.emplace_back(new SwFltStackEntry(rPos, std::unique_ptr<SfxPoolItem>(rAttr.Clone())));
 692         }
 693
 694         namespace {
 695
 696         class SameOpenRedlineType
 697         {
 698         private:
 699             RedlineType meType;
 700         public:
 701             explicit SameOpenRedlineType(RedlineType eType) : meType(eType) {}
 702             bool operator()(const std::unique_ptr<SwFltStackEntry> & pEntry) const
 703             {
 704                 const SwFltRedline *pTest = static_cast<const SwFltRedline *>
 705                     (pEntry->m_pAttr.get());
 706                 return (pEntry->m_bOpen && (pTest->m_eType == meType));
 707             }
 708         };
 709
 710         }
 711
 712         bool RedlineStack::close(const SwPosition& rPos, RedlineType eType)
 713         {
 714             //Search from end for same type
 715             auto aResult = std::find_if(maStack.rbegin(), maStack.rend(),
 716                 SameOpenRedlineType(eType));
 717             if (aResult != maStack.rend())
 718             {
 719                 SwTextNode *const pNode(rPos.GetNode().GetTextNode());
 720                 sal_Int32 const nIndex(rPos.GetContentIndex());
 721                 // HACK to prevent overlap of field-mark and redline,
 722                 // which would destroy field-mark invariants when the redline
 723                 // is hidden: move the redline end one to the left
 724                 if (pNode && nIndex > 0
 725                     && pNode->GetText()[nIndex - 1] == CH_TXT_ATR_FIELDEND)
 726                 {
 727                     SwPosition const end(*rPos.GetNode().GetTextNode(),
 728                                          nIndex - 1);
 729                     sw::mark::Fieldmark *const pFieldMark(
 730                         rPos.GetDoc().getIDocumentMarkAccess()->getFieldmarkAt(end));
 731                     SAL_WARN_IF(!pFieldMark, "sw.ww8", "expected a field mark");
 732                     if (pFieldMark && pFieldMark->GetMarkPos().GetNodeIndex() == (*aResult)->m_aMkPos.m_nNode.GetIndex()+1
 733                         && pFieldMark->GetMarkPos().GetContentIndex() < (*aResult)->m_aMkPos.m_nContent)
 734                     {
 735                         (*aResult)->SetEndPos(end);
 736                         return true;
 737                     }
 738                 }
 739                 (*aResult)->SetEndPos(rPos);
 740                 return true;
 741             }
 742             return false;
 743         }
 744
 745         void RedlineStack::closeall(const SwPosition& rPos)
 746         {
 747             std::for_each(maStack.begin(), maStack.end(), SetEndIfOpen(rPos));
 748         }
 749
 750         void MoveAttrFieldmarkInserted(SwFltPosition& rMkPos, SwFltPosition& rPtPos, const SwPosition& rPos)
 751         {
 752             sal_Int32 const nInserted = 2; // CH_TXT_ATR_FIELDSTART, CH_TXT_ATR_FIELDSEP
 753             SwNodeOffset nPosNd = rPos.GetNodeIndex();
 754             sal_Int32 nPosCt = rPos.GetContentIndex() - nInserted;
 755
 756             bool const isPoint(rMkPos == rPtPos);
 757             if ((rMkPos.m_nNode.GetIndex()+1 == nPosNd) &&
 758                 (nPosCt <= rMkPos.m_nContent))
 759             {
 760                 rMkPos.m_nContent += nInserted;
 761                 SAL_WARN_IF(rMkPos.m_nContent > rPos.GetNodes()[nPosNd]->GetContentNode()->Len(),
 762                         "sw.ww8", "redline ends after end of line");
 763                 if (isPoint) // sigh ... important special case...
 764                 {
 765                     rPtPos.m_nContent += nInserted;
 766                     return;
 767                 }
 768             }
 769             // for the end position, leave it alone if it's *on* the dummy
 770             // char position, that should remain *before*
 771             if ((rPtPos.m_nNode.GetIndex()+1 == nPosNd) &&
 772                 (nPosCt < rPtPos.m_nContent))
 773             {
 774                 rPtPos.m_nContent += nInserted;
 775                 SAL_WARN_IF(rPtPos.m_nContent > rPos.GetNodes()[nPosNd]->GetContentNode()->Len(),
 776                         "sw.ww8", "range ends after end of line");
 777             }
 778         }
 779
 780         void RedlineStack::MoveAttrsFieldmarkInserted(const SwPosition& rPos)
 781         {
 782             for (size_t i = 0, nCnt = maStack.size(); i < nCnt; ++i)
 783             {
 784                 SwFltStackEntry& rEntry = *maStack[i];
 785                 MoveAttrFieldmarkInserted(rEntry.m_aMkPos, rEntry.m_aPtPos, rPos);
 786             }
 787         }
 788
 789         void SetInDocAndDelete::operator()(std::unique_ptr<SwFltStackEntry>& pEntry)
 790         {
 791             SwPaM aRegion(pEntry->m_aMkPos.m_nNode);
 792             if (pEntry->MakeRegion(aRegion,
 793                     SwFltStackEntry::RegionMode::CheckNodes|SwFltStackEntry::RegionMode::CheckFieldmark) &&
 794                 (*aRegion.GetPoint() != *aRegion.GetMark())
 795             )
 796             {
 797                 mrDoc.getIDocumentRedlineAccess().SetRedlineFlags(RedlineFlags::On | RedlineFlags::ShowInsert |
 798                                          RedlineFlags::ShowDelete);
 799                 const SwFltRedline *pFltRedline = static_cast<const SwFltRedline*>
 800                     (pEntry->m_pAttr.get());
 801
 802                 SwRedlineData aData(pFltRedline->m_eType, pFltRedline->m_nAutorNo,
 803                         pFltRedline->m_aStamp, 0, OUString(), nullptr);
 804
 805                 SwRangeRedline *const pNewRedline(new SwRangeRedline(aData, aRegion));
 806                 // the point node may be deleted in AppendRedline, so park
 807                 // the PaM somewhere safe
 808                 aRegion.DeleteMark();
 809                 aRegion.GetPoint()->Assign(*mrDoc.GetNodes()[SwNodeOffset(0)]);
 810                 mrDoc.getIDocumentRedlineAccess().AppendRedline(pNewRedline, true);
 811                 mrDoc.getIDocumentRedlineAccess().SetRedlineFlags(RedlineFlags::NONE | RedlineFlags::ShowInsert |
 812                      RedlineFlags::ShowDelete );
 813             }
 814             pEntry.reset();
 815         }
 816
 817         bool CompareRedlines::operator()(const std::unique_ptr<SwFltStackEntry> & pOneE,
 818             const std::unique_ptr<SwFltStackEntry> & pTwoE) const
 819         {
 820             const SwFltRedline *pOne= static_cast<const SwFltRedline*>
 821                 (pOneE->m_pAttr.get());
 822             const SwFltRedline *pTwo= static_cast<const SwFltRedline*>
 823                 (pTwoE->m_pAttr.get());
 824
 825             //Return the earlier time, if two have the same time, prioritize
 826             //inserts over deletes
 827             if (pOne->m_aStamp == pTwo->m_aStamp)
 828                 return (pOne->m_eType == RedlineType::Insert && pTwo->m_eType != RedlineType::Insert);
 829             else
 830                 return (pOne->m_aStamp < pTwo->m_aStamp);
 831         }
 832
 833         void RedlineStack::ImplDestroy()
 834         {
 835             std::stable_sort(maStack.begin(), maStack.end(), CompareRedlines());
 836             std::for_each(maStack.begin(), maStack.end(), SetInDocAndDelete(mrDoc));
 837         }
 838
 839         RedlineStack::~RedlineStack()
 840         {
 841             suppress_fun_call_w_exception(ImplDestroy());
 842         }
 843
 844         sal_uInt16 WrtRedlineAuthor::AddName( const OUString& rNm )
 845         {
 846             sal_uInt16 nRet;
 847             auto aIter = std::find(maAuthors.begin(), maAuthors.end(), rNm);
 848             if (aIter != maAuthors.end())
 849                 nRet = static_cast< sal_uInt16 >(aIter - maAuthors.begin());
 850             else
 851             {
 852                 nRet = static_cast< sal_uInt16 >(maAuthors.size());
 853                 maAuthors.push_back(rNm);
 854             }
 855             return nRet;
 856         }
 857     }
 858
 859     namespace util
 860     {
 861         InsertedTableListener::InsertedTableListener(SwTableNode& rNode)
 862             : m_pTableNode(&rNode)
 863         {
 864             StartListening(rNode.GetNotifier());
 865         }
 866
 867         SwTableNode* InsertedTableListener::GetTableNode()
 868             { return m_pTableNode; }
 869
 870         void  InsertedTableListener::Notify(const SfxHint& rHint)
 871         {
 872             if(rHint.GetId() == SfxHintId::Dying)
 873                 m_pTableNode = nullptr;
 874         }
 875
 876         InsertedTablesManager::InsertedTablesManager(const SwDoc &rDoc)
 877             : mbHasRoot(rDoc.getIDocumentLayoutAccess().GetCurrentLayout())
 878         { }
 879
 880         void InsertedTablesManager::DelAndMakeTableFrames()
 881         {
 882             if (!mbHasRoot)
 883                 return;
 884             for (auto& aTable : maTables)
 885             {
 886                 // If already a layout exists, then the BoxFrames must recreated at this table
 887                 SwTableNode *pTable = aTable.first->GetTableNode();
 888                 OSL_ENSURE(pTable, "Why no expected table");
 889                 if (pTable)
 890                 {
 891                     SwFrameFormat * pFrameFormat = pTable->GetTable().GetFrameFormat();
 892
 893                     if (pFrameFormat != nullptr)
 894                     {
 895                         SwPosition *pIndex = aTable.second;
 896                         pTable->DelFrames();
 897                         pTable->MakeOwnFrames(pIndex);
 898                     }
 899                 }
 900             }
 901         }
 902
 903         void InsertedTablesManager::InsertTable(SwTableNode& rTableNode, SwPaM& rPaM)
 904         {
 905             if (!mbHasRoot)
 906                 return;
 907             //Associate this tablenode with this after position, replace an old
 908             //node association if necessary
 909             maTables.emplace(
 910                     std::unique_ptr<InsertedTableListener>(new InsertedTableListener(rTableNode)),
 911                     rPaM.GetPoint());
 912         }
 913     }
 914
 915 }
 916
 917 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */