writerfilter/source/rtftok/rtfsprm.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
  10 #include "rtfsprm.hxx"
  11 #include <ooxml/resourceids.hxx>
  12 #include <ooxml/QNameToString.hxx>
  13 #include <rtl/strbuf.hxx>
  14 #include "rtfdocumentimpl.hxx"
  15 #include <algorithm>
  16
  17 namespace writerfilter
  18 {
  19 namespace rtftok
  20 {
  21 RTFSprm::RTFSprm(Id nKeyword, RTFValue::Pointer_t& pValue)
  22     : m_nKeyword(nKeyword)
  23     , m_pValue(pValue)
  24 {
  25 }
  26
  27 sal_uInt32 RTFSprm::getId() const { return m_nKeyword; }
  28
  29 Value::Pointer_t RTFSprm::getValue() { return Value::Pointer_t(m_pValue->Clone()); }
  30
  31 writerfilter::Reference<Properties>::Pointer_t RTFSprm::getProps()
  32 {
  33     return m_pValue->getProperties();
  34 }
  35
  36 #ifdef DBG_UTIL
  37 std::string RTFSprm::getName() const { return "RTFSprm"; }
  38 #endif
  39
  40 #ifdef DBG_UTIL
  41 std::string RTFSprm::toString() const
  42 {
  43     OStringBuffer aBuf("RTFSprm");
  44
  45     std::string sResult = (*QNameToString::Instance())(m_nKeyword);
  46
  47     aBuf.append(" ('");
  48     if (sResult.length() == 0)
  49         aBuf.append(sal_Int32(m_nKeyword));
  50     else
  51         aBuf.append(sResult.c_str());
  52     aBuf.append("', '");
  53     aBuf.append(m_pValue->toString().c_str());
  54     aBuf.append("')");
  55
  56     return aBuf.makeStringAndClear().getStr();
  57 }
  58 #endif
  59
  60 namespace
  61 {
  62 class RTFSprms_compare
  63 {
  64     Id keyword;
  65
  66 public:
  67     RTFSprms_compare(Id kw)
  68         : keyword{ kw }
  69     {
  70     }
  71     bool operator()(const std::pair<Id, RTFValue::Pointer_t>& raPair) const
  72     {
  73         return raPair.first == keyword;
  74     }
  75 };
  76 }
  77
  78 RTFValue::Pointer_t RTFSprms::find(Id nKeyword, bool bFirst, bool bForWrite)
  79 {
  80     if (bForWrite)
  81         ensureCopyBeforeWrite();
  82
  83     RTFSprms_compare cmp{ nKeyword };
  84
  85     if (bFirst)
  86     {
  87         auto it = std::find_if(m_pSprms->begin(), m_pSprms->end(), cmp);
  88         if (it != m_pSprms->end())
  89             return it->second;
  90     }
  91     else
  92     // find last
  93     {
  94         auto rit = std::find_if(m_pSprms->rbegin(), m_pSprms->rend(), cmp);
  95         if (rit != m_pSprms->rend())
  96             return rit->second;
  97     }
  98
  99     return RTFValue::Pointer_t{};
 100 }
 101
 102 void RTFSprms::set(Id nKeyword, const RTFValue::Pointer_t& pValue, RTFOverwrite eOverwrite)
 103 {
 104     ensureCopyBeforeWrite();
 105
 106     switch (eOverwrite)
 107     {
 108         case RTFOverwrite::YES_PREPEND:
 109         {
 110             m_pSprms->erase(
 111                 std::remove_if(m_pSprms->begin(), m_pSprms->end(), RTFSprms_compare{ nKeyword }),
 112                 m_pSprms->end());
 113             m_pSprms->emplace(m_pSprms->cbegin(), nKeyword, pValue);
 114             break;
 115         }
 116         case RTFOverwrite::YES:
 117         {
 118             auto it
 119                 = std::find_if(m_pSprms->begin(), m_pSprms->end(), RTFSprms_compare{ nKeyword });
 120             if (it != m_pSprms->end())
 121                 it->second = pValue;
 122             else
 123                 m_pSprms->emplace_back(nKeyword, pValue);
 124             break;
 125         }
 126         case RTFOverwrite::NO_IGNORE:
 127         {
 128             if (std::none_of(m_pSprms->cbegin(), m_pSprms->cend(), RTFSprms_compare{ nKeyword }))
 129                 m_pSprms->emplace_back(nKeyword, pValue);
 130             break;
 131         }
 132         case RTFOverwrite::NO_APPEND:
 133         {
 134             m_pSprms->emplace_back(nKeyword, pValue);
 135             break;
 136         }
 137     }
 138 }
 139
 140 bool RTFSprms::erase(Id nKeyword)
 141 {
 142     ensureCopyBeforeWrite();
 143
 144     auto i = std::find_if(m_pSprms->begin(), m_pSprms->end(), RTFSprms_compare{ nKeyword });
 145     if (i != m_pSprms->end())
 146     {
 147         m_pSprms->erase(i);
 148         return true;
 149     }
 150     return false;
 151 }
 152
 153 void RTFSprms::eraseLast(Id nKeyword)
 154 {
 155     ensureCopyBeforeWrite();
 156
 157     auto i = std::find_if(m_pSprms->rbegin(), m_pSprms->rend(), RTFSprms_compare{ nKeyword });
 158     if (i != m_pSprms->rend())
 159         m_pSprms->erase(std::next(i).base());
 160 }
 161
 162 static RTFValue::Pointer_t getDefaultSPRM(Id const id, Id nStyleType)
 163 {
 164     if (!nStyleType || nStyleType == NS_ooxml::LN_Value_ST_StyleType_character)
 165     {
 166         switch (id)
 167         {
 168             case NS_ooxml::LN_EG_RPrBase_b:
 169                 return new RTFValue(0);
 170             default:
 171                 break;
 172         }
 173     }
 174
 175     if (!nStyleType || nStyleType == NS_ooxml::LN_Value_ST_StyleType_paragraph)
 176     {
 177         switch (id)
 178         {
 179             case NS_ooxml::LN_CT_Spacing_before:
 180             case NS_ooxml::LN_CT_Spacing_after:
 181             case NS_ooxml::LN_CT_Ind_left:
 182             case NS_ooxml::LN_CT_Ind_right:
 183             case NS_ooxml::LN_CT_Ind_firstLine:
 184                 return new RTFValue(0);
 185
 186             case NS_ooxml::LN_CT_Spacing_lineRule:
 187                 return new RTFValue(NS_ooxml::LN_Value_doc_ST_LineSpacingRule_auto);
 188             case NS_ooxml::LN_CT_Spacing_line:
 189                 // presumably this means 100%, cf. static const int nSingleLineSpacing = 240;
 190                 return new RTFValue(240);
 191
 192             default:
 193                 break;
 194         }
 195     }
 196
 197     return RTFValue::Pointer_t();
 198 }
 199
 200 /// Is it problematic to deduplicate this SPRM?
 201 static bool isSPRMDeduplicateBlacklist(Id nId)
 202 {
 203     switch (nId)
 204     {
 205         // See the NS_ooxml::LN_CT_PPrBase_tabs handler in DomainMapper,
 206         // deduplication is explicitly not wanted for these tokens.
 207         case NS_ooxml::LN_CT_TabStop_val:
 208         case NS_ooxml::LN_CT_TabStop_leader:
 209         case NS_ooxml::LN_CT_TabStop_pos:
 210         // \htmautsp arrives after the style table, so only the non-style value is
 211         // correct, keep these.
 212         case NS_ooxml::LN_CT_Spacing_beforeAutospacing:
 213         case NS_ooxml::LN_CT_Spacing_afterAutospacing:
 214             return true;
 215
 216         default:
 217             return false;
 218     }
 219 }
 220
 221 /// Should this SPRM be removed if all its children are removed?
 222 static bool isSPRMChildrenExpected(Id nId)
 223 {
 224     switch (nId)
 225     {
 226         case NS_ooxml::LN_CT_PBdr_top:
 227         case NS_ooxml::LN_CT_PBdr_left:
 228         case NS_ooxml::LN_CT_PBdr_bottom:
 229         case NS_ooxml::LN_CT_PBdr_right:
 230             // Expected children are NS_ooxml::LN_CT_Border_*.
 231         case NS_ooxml::LN_CT_PrBase_shd:
 232             // Expected children are NS_ooxml::LN_CT_Shd_*.
 233         case NS_ooxml::LN_CT_PPrBase_ind:
 234             // Expected children are NS_ooxml::LN_CT_Ind_*.
 235             return true;
 236
 237         default:
 238             return false;
 239     }
 240 }
 241
 242 /// Does the clone / deduplication of a single sprm.
 243 static void cloneAndDeduplicateSprm(std::pair<Id, RTFValue::Pointer_t> const& rSprm, RTFSprms& ret,
 244                                     Id nStyleType)
 245 {
 246     RTFValue::Pointer_t const pValue(ret.find(rSprm.first));
 247     if (pValue)
 248     {
 249         if (rSprm.second->equals(*pValue))
 250         {
 251             if (!isSPRMDeduplicateBlacklist(rSprm.first))
 252                 ret.erase(rSprm.first); // duplicate to style
 253         }
 254         else if (!rSprm.second->getSprms().empty() || !rSprm.second->getAttributes().empty())
 255         {
 256             RTFSprms const sprms(
 257                 pValue->getSprms().cloneAndDeduplicate(rSprm.second->getSprms(), nStyleType));
 258             RTFSprms const attributes(pValue->getAttributes().cloneAndDeduplicate(
 259                 rSprm.second->getAttributes(), nStyleType));
 260             // Don't copy the sprm in case we expect it to have children but it doesn't have some.
 261             if (!isSPRMChildrenExpected(rSprm.first) || !sprms.empty() || !attributes.empty())
 262                 ret.set(rSprm.first,
 263                         RTFValue::Pointer_t(pValue->CloneWithSprms(attributes, sprms)));
 264         }
 265     }
 266     else
 267     {
 268         // not found - try to override style with default
 269         RTFValue::Pointer_t const pDefault(getDefaultSPRM(rSprm.first, nStyleType));
 270         if (pDefault)
 271         {
 272             ret.set(rSprm.first, pDefault);
 273         }
 274         else if (!rSprm.second->getSprms().empty() || !rSprm.second->getAttributes().empty())
 275         {
 276             RTFSprms const sprms(
 277                 RTFSprms().cloneAndDeduplicate(rSprm.second->getSprms(), nStyleType));
 278             RTFSprms const attributes(
 279                 RTFSprms().cloneAndDeduplicate(rSprm.second->getAttributes(), nStyleType));
 280             if (!sprms.empty() || !attributes.empty())
 281             {
 282                 ret.set(rSprm.first, new RTFValue(attributes, sprms));
 283             }
 284         }
 285     }
 286 }
 287
 288 /// Extracts the list level matching nLevel from pAbstract.
 289 static RTFValue::Pointer_t getListLevel(const RTFValue::Pointer_t& pAbstract, int nLevel)
 290 {
 291     for (const auto& rPair : pAbstract->getSprms())
 292     {
 293         if (rPair.first != NS_ooxml::LN_CT_AbstractNum_lvl)
 294             continue;
 295
 296         RTFValue::Pointer_t pLevel = rPair.second->getAttributes().find(NS_ooxml::LN_CT_Lvl_ilvl);
 297         if (!pLevel)
 298             continue;
 299
 300         if (pLevel->getInt() != nLevel)
 301             continue;
 302
 303         return rPair.second;
 304     }
 305
 306     return RTFValue::Pointer_t();
 307 }
 308
 309 void RTFSprms::deduplicateList(const std::map<int, int>& rInvalidListLevelFirstIndents)
 310 {
 311     int nLevel = 0;
 312     RTFValue::Pointer_t pLevelId
 313         = getNestedSprm(*this, NS_ooxml::LN_CT_PPrBase_numPr, NS_ooxml::LN_CT_NumPr_ilvl);
 314     if (pLevelId)
 315         nLevel = pLevelId->getInt();
 316
 317     auto it = rInvalidListLevelFirstIndents.find(nLevel);
 318     if (it == rInvalidListLevelFirstIndents.end())
 319         return;
 320
 321     int nListValue = it->second;
 322
 323     RTFValue::Pointer_t pParagraphValue
 324         = getNestedAttribute(*this, NS_ooxml::LN_CT_PPrBase_ind, NS_ooxml::LN_CT_Ind_firstLine);
 325     if (!pParagraphValue)
 326         return;
 327
 328     int nParagraphValue = pParagraphValue->getInt();
 329
 330     if (nParagraphValue == nListValue)
 331         eraseNestedAttribute(*this, NS_ooxml::LN_CT_PPrBase_ind, NS_ooxml::LN_CT_Ind_firstLine);
 332 }
 333
 334 void RTFSprms::duplicateList(const RTFValue::Pointer_t& pAbstract)
 335 {
 336     int nLevel = 0;
 337     RTFValue::Pointer_t pLevelId
 338         = getNestedSprm(*this, NS_ooxml::LN_CT_PPrBase_numPr, NS_ooxml::LN_CT_NumPr_ilvl);
 339     if (pLevelId)
 340         nLevel = pLevelId->getInt();
 341
 342     RTFValue::Pointer_t pLevel = getListLevel(pAbstract, nLevel);
 343     if (!pLevel)
 344         return;
 345
 346     RTFValue::Pointer_t pLevelInd = pLevel->getSprms().find(NS_ooxml::LN_CT_PPrBase_ind);
 347     if (!pLevelInd)
 348         return;
 349
 350     for (const auto& rListLevelPair : pLevelInd->getAttributes())
 351     {
 352         switch (rListLevelPair.first)
 353         {
 354             case NS_ooxml::LN_CT_Ind_left:
 355             case NS_ooxml::LN_CT_Ind_right:
 356             case NS_ooxml::LN_CT_Ind_firstLine:
 357                 RTFValue::Pointer_t pParagraphValue
 358                     = getNestedAttribute(*this, NS_ooxml::LN_CT_PPrBase_ind, rListLevelPair.first);
 359                 if (!pParagraphValue)
 360                     putNestedAttribute(*this, NS_ooxml::LN_CT_PPrBase_ind, rListLevelPair.first,
 361                                        getDefaultSPRM(rListLevelPair.first, 0));
 362
 363                 break;
 364         }
 365     }
 366 }
 367
 368 RTFSprms RTFSprms::cloneAndDeduplicate(RTFSprms& rReference, Id const nStyleType,
 369                                        bool const bImplicitPPr) const
 370 {
 371     RTFSprms ret(*this);
 372     ret.ensureCopyBeforeWrite();
 373
 374     // Note: apparently some attributes are set with OVERWRITE_NO_APPEND;
 375     // it is probably a bad idea to mess with those in any way here?
 376     for (auto& rSprm : rReference)
 377     {
 378         // Paragraph formatting sprms are directly contained in case of
 379         // paragraphs, but they are below NS_ooxml::LN_CT_Style_pPr in case of
 380         // styles. So handle those children directly, to avoid unexpected
 381         // addition of direct formatting sprms at the paragraph level.
 382         if (bImplicitPPr && rSprm.first == NS_ooxml::LN_CT_Style_pPr)
 383         {
 384             for (const auto& i : rSprm.second->getSprms())
 385                 cloneAndDeduplicateSprm(i, ret, nStyleType);
 386         }
 387         else
 388             cloneAndDeduplicateSprm(rSprm, ret, nStyleType);
 389     }
 390     return ret;
 391 }
 392
 393 bool RTFSprms::equals(const RTFValue& rOther) const
 394 {
 395     return std::all_of(m_pSprms->cbegin(), m_pSprms->cend(),
 396                        [&](const std::pair<Id, RTFValue::Pointer_t>& raPair) -> bool {
 397                            return raPair.second->equals(rOther);
 398                        });
 399 }
 400
 401 void RTFSprms::ensureCopyBeforeWrite()
 402 {
 403     if (m_pSprms->GetRefCount() > 1)
 404     {
 405         tools::SvRef<RTFSprmsImpl> pClone(new RTFSprmsImpl);
 406         for (auto& rSprm : *m_pSprms)
 407             pClone->push_back(
 408                 std::make_pair(rSprm.first, RTFValue::Pointer_t(rSprm.second->Clone())));
 409         m_pSprms = pClone;
 410     }
 411 }
 412
 413 RTFSprms::RTFSprms()
 414     : m_pSprms(new RTFSprmsImpl)
 415 {
 416 }
 417
 418 RTFSprms::~RTFSprms() = default;
 419
 420 void RTFSprms::clear()
 421 {
 422     if (m_pSprms->GetRefCount() == 1)
 423         return m_pSprms->clear();
 424
 425     m_pSprms = tools::SvRef<RTFSprmsImpl>(new RTFSprmsImpl);
 426 }
 427
 428 } // namespace rtftok
 429 } // namespace writerfilter
 430
 431 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */