sw/source/core/txtnode/attrcontentcontrol.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 <formatcontentcontrol.hxx>
  21
  22 #include <libxml/xmlwriter.h>
  23
  24 #include <sal/log.hxx>
  25 #include <comphelper/propertyvalue.hxx>
  26 #include <comphelper/sequenceashashmap.hxx>
  27 #include <svl/numformat.hxx>
  28 #include <vcl/keycod.hxx>
  29
  30 #include <ndtxt.hxx>
  31 #include <textcontentcontrol.hxx>
  32 #include <doc.hxx>
  33 #include <unocontentcontrol.hxx>
  34 #include <unoport.hxx>
  35 #include <wrtsh.hxx>
  36
  37 using namespace com::sun::star;
  38
  39 namespace
  40 {
  41 inline constexpr OUString CURRENT_DATE_FORMAT = u"YYYY-MM-DD"_ustr;
  42 }
  43
  44 SwFormatContentControl* SwFormatContentControl::CreatePoolDefault(sal_uInt16 nWhich)
  45 {
  46     return new SwFormatContentControl(nWhich);
  47 }
  48
  49 SwFormatContentControl::SwFormatContentControl(sal_uInt16 nWhich)
  50     : SfxPoolItem(nWhich)
  51     , m_pTextAttr(nullptr)
  52 {
  53     setNonShareable();
  54 }
  55
  56 SwFormatContentControl::SwFormatContentControl(
  57     const std::shared_ptr<SwContentControl>& pContentControl, sal_uInt16 nWhich)
  58     : SfxPoolItem(nWhich)
  59     , m_pContentControl(pContentControl)
  60     , m_pTextAttr(nullptr)
  61 {
  62     setNonShareable();
  63     if (!pContentControl)
  64     {
  65         SAL_WARN("sw.core", "SwFormatContentControl ctor: no pContentControl?");
  66     }
  67     // Not calling m_pContentControl->SetFormatContentControl(this) here; only from SetTextAttr.
  68 }
  69
  70 SwFormatContentControl::~SwFormatContentControl()
  71 {
  72     if (m_pContentControl
  73         // SwFormatContentControl is not shareable, so ptr compare is OK
  74         && areSfxPoolItemPtrsEqual(m_pContentControl->GetFormatContentControl(), this))
  75     {
  76         NotifyChangeTextNode(nullptr);
  77         m_pContentControl->SetFormatContentControl(nullptr);
  78     }
  79 }
  80
  81 bool SwFormatContentControl::operator==(const SfxPoolItem& rOther) const
  82 {
  83     return SfxPoolItem::operator==(rOther)
  84            && m_pContentControl
  85                   == static_cast<const SwFormatContentControl&>(rOther).m_pContentControl;
  86 }
  87
  88 SwFormatContentControl* SwFormatContentControl::Clone(SfxItemPool* /*pPool*/) const
  89 {
  90     // If this is indeed a copy, then DoCopy will be called later.
  91     if (m_pContentControl)
  92     {
  93         return new SwFormatContentControl(m_pContentControl, Which());
  94     }
  95     else
  96     {
  97         return new SwFormatContentControl(Which());
  98     }
  99 }
 100
 101 void SwFormatContentControl::SetTextAttr(SwTextContentControl* pTextAttr)
 102 {
 103     if (m_pTextAttr && pTextAttr)
 104     {
 105         SAL_WARN("sw.core", "SwFormatContentControl::SetTextAttr: already has a text attribute");
 106     }
 107     if (!m_pTextAttr && !pTextAttr)
 108     {
 109         SAL_WARN("sw.core", "SwFormatContentControl::SetTextAttr: no attribute to remove");
 110     }
 111     m_pTextAttr = pTextAttr;
 112     if (!m_pContentControl)
 113     {
 114         SAL_WARN("sw.core", "inserted SwFormatContentControl has no SwContentControl");
 115     }
 116     // The SwContentControl should be able to find the current text attribute.
 117     if (m_pContentControl)
 118     {
 119         if (pTextAttr)
 120         {
 121             m_pContentControl->SetFormatContentControl(this);
 122         }
 123         // SwFormatContentControl is not shareable, so ptr compare is OK
 124         else if (areSfxPoolItemPtrsEqual(m_pContentControl->GetFormatContentControl(), this))
 125         {
 126             // The text attribute is gone, so de-register from text node.
 127             NotifyChangeTextNode(nullptr);
 128             m_pContentControl->SetFormatContentControl(nullptr);
 129         }
 130     }
 131 }
 132
 133 void SwFormatContentControl::NotifyChangeTextNode(SwTextNode* pTextNode)
 134 {
 135     // Not deleting m_pTextAttr here, SwNodes::ChgNode() doesn't do that, either.
 136     if (!m_pContentControl)
 137     {
 138         SAL_WARN("sw.core", "SwFormatContentControl::NotifyChangeTextNode: no content control?");
 139     }
 140     if (m_pContentControl
 141         // SwFormatContentControl is not shareable, so ptr compare is OK
 142         && areSfxPoolItemPtrsEqual(m_pContentControl->GetFormatContentControl(), this))
 143     {
 144         // Not calling Modify, that would call SwXContentControl::SwClientNotify.
 145         m_pContentControl->NotifyChangeTextNode(pTextNode);
 146     }
 147 }
 148
 149 SwTextNode* SwFormatContentControl::GetTextNode() const
 150 {
 151     if (!m_pContentControl)
 152     {
 153         return nullptr;
 154     }
 155
 156     return m_pContentControl->GetTextNode();
 157 }
 158
 159 // This SwFormatContentControl has been cloned and points at the same SwContentControl as the
 160 // source: this function copies the SwContentControl.
 161 void SwFormatContentControl::DoCopy(SwTextNode& rTargetTextNode)
 162 {
 163     if (!m_pContentControl)
 164     {
 165         SAL_WARN("sw.core", "SwFormatContentControl::DoCopy: called for SwFormatContentControl "
 166                             "with no SwContentControl.");
 167         return;
 168     }
 169
 170     m_pContentControl = std::make_shared<SwContentControl>(this);
 171     m_pContentControl->NotifyChangeTextNode(&rTargetTextNode);
 172 }
 173
 174 void SwFormatContentControl::dumpAsXml(xmlTextWriterPtr pWriter) const
 175 {
 176     (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwFormatContentControl"));
 177     (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
 178     (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("m_pTextAttr"), "%p", m_pTextAttr);
 179     SfxPoolItem::dumpAsXml(pWriter);
 180
 181     if (m_pContentControl)
 182     {
 183         m_pContentControl->dumpAsXml(pWriter);
 184     }
 185
 186     (void)xmlTextWriterEndElement(pWriter);
 187 }
 188
 189 SwContentControl::SwContentControl(SwFormatContentControl* pFormat)
 190     : sw::BroadcastingModify()
 191     , m_pFormat(pFormat)
 192     , m_pTextNode(nullptr)
 193 {
 194     if (!pFormat)
 195     {
 196         return;
 197     }
 198
 199     const std::shared_ptr<SwContentControl>& pOther = pFormat->GetContentControl();
 200     if (!pOther)
 201     {
 202         return;
 203     }
 204
 205     SetShowingPlaceHolder(pOther->m_bShowingPlaceHolder);
 206     SetCheckbox(pOther->m_bCheckbox);
 207     SetChecked(pOther->m_bChecked);
 208     SetCheckedState(pOther->m_aCheckedState);
 209     SetUncheckedState(pOther->m_aUncheckedState);
 210     SetListItems(pOther->m_aListItems);
 211     SetPicture(pOther->m_bPicture);
 212     SetDate(pOther->m_bDate);
 213     SetDateFormat(pOther->m_aDateFormat);
 214     SetDateLanguage(pOther->m_aDateLanguage);
 215     SetCurrentDate(pOther->m_aCurrentDate);
 216     SetPlainText(pOther->m_bPlainText);
 217     SetComboBox(pOther->m_bComboBox);
 218     SetDropDown(pOther->m_bDropDown);
 219     SetPlaceholderDocPart(pOther->m_aPlaceholderDocPart);
 220     SetDataBindingPrefixMappings(pOther->m_aDataBindingPrefixMappings);
 221     SetDataBindingXpath(pOther->m_aDataBindingXpath);
 222     SetDataBindingStoreItemID(pOther->m_aDataBindingStoreItemID);
 223     SetColor(pOther->m_aColor);
 224     SetAppearance(pOther->m_aAppearance);
 225     SetAlias(pOther->m_aAlias);
 226     SetTag(pOther->m_aTag);
 227     SetId(pOther->m_nId);
 228     SetTabIndex(pOther->m_nTabIndex);
 229     SetLock(pOther->m_aLock);
 230     SetMultiLine(pOther->m_aMultiLine);
 231 }
 232
 233 SwContentControl::~SwContentControl() {}
 234
 235 void SwContentControl::SetXContentControl(const rtl::Reference<SwXContentControl>& xContentControl)
 236 {
 237     m_wXContentControl = xContentControl.get();
 238 }
 239
 240 SwTextContentControl* SwContentControl::GetTextAttr() const
 241 {
 242     return m_pFormat ? m_pFormat->GetTextAttr() : nullptr;
 243 }
 244
 245 void SwContentControl::NotifyChangeTextNode(SwTextNode* pTextNode)
 246 {
 247     m_pTextNode = pTextNode;
 248     if (m_pTextNode && (GetRegisteredIn() != m_pTextNode))
 249     {
 250         m_pTextNode->Add(*this);
 251     }
 252     else if (!m_pTextNode)
 253     {
 254         EndListeningAll();
 255     }
 256     if (!pTextNode)
 257     {
 258         // If the text node is gone, then invalidate clients (e.g. UNO object).
 259         GetNotifier().Broadcast(SfxHint(SfxHintId::Deinitializing));
 260     }
 261 }
 262
 263 void SwContentControl::SwClientNotify(const SwModify&, const SfxHint& rHint)
 264 {
 265     if (SfxHintId::SwRemoveUnoObject == rHint.GetId())
 266     {
 267         CallSwClientNotify(rHint);
 268         GetNotifier().Broadcast(SfxHint(SfxHintId::DataChanged));
 269         // Invalidate cached uno object.
 270         SetXContentControl(nullptr);
 271         GetNotifier().Broadcast(SfxHint(SfxHintId::Deinitializing));
 272     }
 273     else if (rHint.GetId() == SfxHintId::SwLegacyModify
 274              || rHint.GetId() == SfxHintId::SwFormatChange
 275              || rHint.GetId() == SfxHintId::SwAttrSetChange
 276              || rHint.GetId() == SfxHintId::SwObjectDying
 277              || rHint.GetId() == SfxHintId::SwUpdateAttr)
 278     {
 279         CallSwClientNotify(rHint);
 280         GetNotifier().Broadcast(SfxHint(SfxHintId::DataChanged));
 281     }
 282 }
 283
 284 std::optional<size_t> SwContentControl::GetSelectedListItem(bool bCheckDocModel) const
 285 {
 286     if (!bCheckDocModel || m_oSelectedListItem)
 287         return m_oSelectedListItem;
 288
 289     const size_t nLen = GetListItems().size();
 290     if (GetShowingPlaceHolder() || !nLen || !GetTextAttr())
 291         return std::nullopt;
 292
 293     const OUString aText = GetTextAttr()->ToString();
 294     for (size_t i = 0; i < nLen; ++i)
 295     {
 296         if (GetTextAttr()[i].ToString() == aText)
 297             return i;
 298     }
 299     assert(!GetDropDown() && "DropDowns must always have an associated list item");
 300     return std::nullopt;
 301 }
 302
 303 bool SwContentControl::AddListItem(size_t nZIndex, const OUString& rDisplayText,
 304                                    const OUString& rValue)
 305 {
 306     SwContentControlListItem aListItem;
 307     if (rValue.isEmpty())
 308     {
 309         if (rDisplayText.isEmpty())
 310             return false;
 311         aListItem.m_aValue = rDisplayText;
 312     }
 313     else
 314     {
 315         aListItem.m_aValue = rValue;
 316         aListItem.m_aDisplayText = rDisplayText;
 317     }
 318
 319     // Avoid adding duplicates
 320     for (auto& rListItem : GetListItems())
 321     {
 322         if (rListItem == aListItem)
 323             return false;
 324     }
 325
 326     const size_t nLen = GetListItems().size();
 327     nZIndex = std::min(nZIndex, nLen);
 328     const std::optional<size_t> oSelected = GetSelectedListItem();
 329     if (oSelected && *oSelected >= nZIndex)
 330     {
 331         if (*oSelected < nLen)
 332             SetSelectedListItem(*oSelected + 1);
 333     }
 334     std::vector<SwContentControlListItem> vListItems = GetListItems();
 335     vListItems.insert(vListItems.begin() + nZIndex, aListItem);
 336     SetListItems(vListItems);
 337     return true;
 338 }
 339
 340 void SwContentControl::DeleteListItem(size_t nZIndex)
 341 {
 342     if (nZIndex >= GetListItems().size())
 343         return;
 344
 345     const std::optional<size_t> oSelected = GetSelectedListItem();
 346     if (oSelected)
 347     {
 348         if (*oSelected == nZIndex)
 349         {
 350             SetSelectedListItem(std::nullopt);
 351             if (m_bDropDown && GetTextAttr())
 352                 GetTextAttr()->Invalidate();
 353         }
 354         else if (*oSelected < nZIndex)
 355             SetSelectedListItem(*oSelected - 1);
 356     }
 357
 358     std::vector<SwContentControlListItem> vListItems = GetListItems();
 359     vListItems.erase(vListItems.begin() + nZIndex);
 360     SetListItems(vListItems);
 361     return;
 362 }
 363
 364 void SwContentControl::ClearListItems()
 365 {
 366     SetSelectedListItem(std::nullopt);
 367     SetListItems(std::vector<SwContentControlListItem>());
 368     if (m_bDropDown && GetTextAttr())
 369         GetTextAttr()->Invalidate();
 370 }
 371
 372 OUString SwContentControl::GetDateString() const
 373 {
 374     SwDoc& rDoc = m_pTextNode->GetDoc();
 375     SvNumberFormatter* pNumberFormatter = rDoc.GetNumberFormatter();
 376     sal_uInt32 nFormat = pNumberFormatter->GetEntryKey(
 377         m_aDateFormat, LanguageTag(m_aDateLanguage).getLanguageType());
 378
 379     if (nFormat == NUMBERFORMAT_ENTRY_NOT_FOUND)
 380     {
 381         // If not found, then create it.
 382         sal_Int32 nCheckPos = 0;
 383         SvNumFormatType nType;
 384         OUString aFormat = m_aDateFormat;
 385         pNumberFormatter->PutEntry(aFormat, nCheckPos, nType, nFormat,
 386                                    LanguageTag(m_aDateLanguage).getLanguageType());
 387     }
 388
 389     const Color* pColor = nullptr;
 390     OUString aFormatted;
 391     double fSelectedDate = 0;
 392     if (m_oSelectedDate)
 393     {
 394         fSelectedDate = *m_oSelectedDate;
 395     }
 396     else
 397     {
 398         fSelectedDate = GetCurrentDateValue();
 399     }
 400
 401     if (nFormat == NUMBERFORMAT_ENTRY_NOT_FOUND)
 402     {
 403         return OUString();
 404     }
 405
 406     pNumberFormatter->GetOutputString(fSelectedDate, nFormat, aFormatted, &pColor, false);
 407     return aFormatted;
 408 }
 409
 410 void SwContentControl::SetCurrentDateValue(double fCurrentDate)
 411 {
 412     SwDoc& rDoc = m_pTextNode->GetDoc();
 413     SvNumberFormatter* pNumberFormatter = rDoc.GetNumberFormatter();
 414     OUString aFormatted;
 415     sal_uInt32 nFormat = pNumberFormatter->GetEntryKey(CURRENT_DATE_FORMAT, LANGUAGE_ENGLISH_US);
 416     if (nFormat == NUMBERFORMAT_ENTRY_NOT_FOUND)
 417     {
 418         // If not found, then create it.
 419         sal_Int32 nCheckPos = 0;
 420         SvNumFormatType nType;
 421         OUString sFormat = CURRENT_DATE_FORMAT;
 422         pNumberFormatter->PutEntry(sFormat, nCheckPos, nType, nFormat, LANGUAGE_ENGLISH_US);
 423     }
 424
 425     if (nFormat == NUMBERFORMAT_ENTRY_NOT_FOUND)
 426     {
 427         return;
 428     }
 429
 430     const Color* pColor = nullptr;
 431     pNumberFormatter->GetOutputString(fCurrentDate, nFormat, aFormatted, &pColor, false);
 432     m_aCurrentDate = aFormatted + "T00:00:00Z";
 433 }
 434
 435 double SwContentControl::GetCurrentDateValue() const
 436 {
 437     if (m_aCurrentDate.isEmpty())
 438     {
 439         return 0;
 440     }
 441
 442     SwDoc& rDoc = m_pTextNode->GetDoc();
 443     SvNumberFormatter* pNumberFormatter = rDoc.GetNumberFormatter();
 444     sal_uInt32 nFormat = pNumberFormatter->GetEntryKey(CURRENT_DATE_FORMAT, LANGUAGE_ENGLISH_US);
 445     if (nFormat == NUMBERFORMAT_ENTRY_NOT_FOUND)
 446     {
 447         sal_Int32 nCheckPos = 0;
 448         SvNumFormatType nType;
 449         OUString sFormat = CURRENT_DATE_FORMAT;
 450         pNumberFormatter->PutEntry(sFormat, nCheckPos, nType, nFormat, LANGUAGE_ENGLISH_US);
 451     }
 452
 453     if (nFormat == NUMBERFORMAT_ENTRY_NOT_FOUND)
 454     {
 455         return 0;
 456     }
 457
 458     double dCurrentDate = 0;
 459     OUString aCurrentDate = m_aCurrentDate.replaceAll("T00:00:00Z", "");
 460     (void)pNumberFormatter->IsNumberFormat(aCurrentDate, nFormat, dCurrentDate);
 461     return dCurrentDate;
 462 }
 463
 464 bool SwContentControl::IsInteractingCharacter(sal_Unicode cCh)
 465 {
 466     if (GetCheckbox())
 467     {
 468         return cCh == ' ';
 469     }
 470
 471     if (GetPicture())
 472     {
 473         return cCh == '\r';
 474     }
 475
 476     return false;
 477 }
 478
 479 bool SwContentControl::ShouldOpenPopup(const vcl::KeyCode& rKeyCode)
 480 {
 481     switch (GetType())
 482     {
 483         case SwContentControlType::DROP_DOWN_LIST:
 484         case SwContentControlType::COMBO_BOX:
 485         case SwContentControlType::DATE:
 486         {
 487             // Alt-down opens the popup.
 488             return rKeyCode.IsMod2() && rKeyCode.GetCode() == KEY_DOWN;
 489         }
 490         default:
 491             break;
 492     }
 493
 494     return false;
 495 }
 496
 497 // NOTE: call SetReadWrite separately to implement true (un)locking.
 498 // This is mostly a theoretical function; the lock state is mainly kept for round-tripping purposes.
 499 // It is implemented here primarily for pointless VBA control, but with the intention that it
 500 // could be made functionally useful as well for checkboxes/dropdowns/pictures.
 501 // Returns whether the content (bControl=false) cannot be modified,
 502 // or if the control cannot be deleted.
 503 std::optional<bool> SwContentControl::GetLock(bool bControl) const
 504 {
 505     std::optional<bool> oLock;
 506     if (m_aLock.isEmpty())
 507         return oLock;
 508     else if (m_aLock.equalsIgnoreAsciiCase("sdtContentLocked"))
 509         oLock = true;
 510     else if (m_aLock.equalsIgnoreAsciiCase("unlocked"))
 511         oLock = false;
 512     else if (m_aLock.equalsIgnoreAsciiCase("sdtLocked"))
 513         oLock = bControl;
 514     else if (m_aLock.equalsIgnoreAsciiCase("contentLocked"))
 515         oLock = !bControl;
 516
 517     assert(oLock.has_value() && "invalid or unknown lock state");
 518     return oLock;
 519 }
 520
 521 void SwContentControl::SetLock(bool bLockContent, bool bLockControl)
 522 {
 523     if (!bLockContent && !bLockControl)
 524         m_aLock = "unlocked";
 525     else if (bLockContent && bLockControl)
 526         m_aLock = "sdtContentLocked";
 527     else if (bLockContent)
 528         m_aLock = "contentLocked";
 529     else
 530         m_aLock = "sdtLocked";
 531 }
 532
 533 SwContentControlType SwContentControl::GetType() const
 534 {
 535     if (m_bCheckbox)
 536     {
 537         return SwContentControlType::CHECKBOX;
 538     }
 539
 540     if (m_bComboBox)
 541     {
 542         return SwContentControlType::COMBO_BOX;
 543     }
 544
 545     if (m_bDropDown)
 546     {
 547         return SwContentControlType::DROP_DOWN_LIST;
 548     }
 549
 550     if (m_bPicture)
 551     {
 552         return SwContentControlType::PICTURE;
 553     }
 554
 555     if (m_bDate)
 556     {
 557         return SwContentControlType::DATE;
 558     }
 559
 560     if (m_bPlainText)
 561     {
 562         return SwContentControlType::PLAIN_TEXT;
 563     }
 564
 565     return SwContentControlType::RICH_TEXT;
 566 }
 567
 568 void SwContentControl::dumpAsXml(xmlTextWriterPtr pWriter) const
 569 {
 570     (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwContentControl"));
 571     (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
 572     (void)xmlTextWriterWriteFormatAttribute(
 573         pWriter, BAD_CAST("showing-place-holder"), "%s",
 574         BAD_CAST(OString::boolean(m_bShowingPlaceHolder).getStr()));
 575     (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("checkbox"), "%s",
 576                                             BAD_CAST(OString::boolean(m_bCheckbox).getStr()));
 577     (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("checked"), "%s",
 578                                             BAD_CAST(OString::boolean(m_bChecked).getStr()));
 579     (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("checked-state"), "%s",
 580                                             BAD_CAST(m_aCheckedState.toUtf8().getStr()));
 581     (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("unchecked-state"), "%s",
 582                                             BAD_CAST(m_aUncheckedState.toUtf8().getStr()));
 583     (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("picture"),
 584                                       BAD_CAST(OString::boolean(m_bPicture).getStr()));
 585     (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("date"),
 586                                       BAD_CAST(OString::boolean(m_bDate).getStr()));
 587     (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("date-format"),
 588                                       BAD_CAST(m_aDateFormat.toUtf8().getStr()));
 589     (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("date-language"),
 590                                       BAD_CAST(m_aDateLanguage.toUtf8().getStr()));
 591     (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("current-date"),
 592                                       BAD_CAST(m_aCurrentDate.toUtf8().getStr()));
 593     (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("plain-text"),
 594                                       BAD_CAST(OString::boolean(m_bPlainText).getStr()));
 595     (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("combo-box"),
 596                                       BAD_CAST(OString::boolean(m_bComboBox).getStr()));
 597     (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("drop-down"),
 598                                       BAD_CAST(OString::boolean(m_bDropDown).getStr()));
 599     (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("placeholder-doc-part"),
 600                                       BAD_CAST(m_aPlaceholderDocPart.toUtf8().getStr()));
 601     (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("data-binding-prefix-mappings"),
 602                                       BAD_CAST(m_aDataBindingPrefixMappings.toUtf8().getStr()));
 603     (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("data-binding-xpath"),
 604                                       BAD_CAST(m_aDataBindingXpath.toUtf8().getStr()));
 605     (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("data-binding-store-item-id"),
 606                                       BAD_CAST(m_aDataBindingStoreItemID.toUtf8().getStr()));
 607     (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("color"),
 608                                       BAD_CAST(m_aColor.toUtf8().getStr()));
 609     (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("appearance"),
 610                                       BAD_CAST(m_aAppearance.toUtf8().getStr()));
 611     (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("alias"),
 612                                       BAD_CAST(m_aAlias.toUtf8().getStr()));
 613     (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("tag"), BAD_CAST(m_aTag.toUtf8().getStr()));
 614     (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("id"),
 615                                       BAD_CAST(OString::number(m_nId).getStr()));
 616     (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("tab-index"),
 617                                       BAD_CAST(OString::number(m_nTabIndex).getStr()));
 618     (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("lock"),
 619                                       BAD_CAST(m_aLock.toUtf8().getStr()));
 620     (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("multiline"),
 621                                       BAD_CAST(m_aMultiLine.toUtf8().getStr()));
 622
 623     if (!m_aListItems.empty())
 624     {
 625         for (const auto& rListItem : m_aListItems)
 626         {
 627             rListItem.dumpAsXml(pWriter);
 628         }
 629     }
 630
 631     (void)xmlTextWriterEndElement(pWriter);
 632 }
 633
 634 void SwContentControlListItem::dumpAsXml(xmlTextWriterPtr pWriter) const
 635 {
 636     (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwContentControlListItem"));
 637     (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
 638     (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("display-text"),
 639                                       BAD_CAST(m_aDisplayText.toUtf8().getStr()));
 640     (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
 641                                       BAD_CAST(m_aValue.toUtf8().getStr()));
 642
 643     (void)xmlTextWriterEndElement(pWriter);
 644 }
 645
 646 const OUString& SwContentControlListItem::ToString() const
 647 {
 648     if (!m_aDisplayText.isEmpty())
 649     {
 650         return m_aDisplayText;
 651     }
 652
 653     return m_aValue;
 654 }
 655
 656 bool SwContentControlListItem::operator==(const SwContentControlListItem& rOther) const
 657 {
 658     return m_aDisplayText == rOther.m_aDisplayText && m_aValue == rOther.m_aValue;
 659 }
 660
 661 void SwContentControlListItem::ItemsToAny(const std::vector<SwContentControlListItem>& rItems,
 662                                           uno::Any& rVal)
 663 {
 664     uno::Sequence<uno::Sequence<beans::PropertyValue>> aRet(rItems.size());
 665
 666     uno::Sequence<beans::PropertyValue>* pRet = aRet.getArray();
 667     for (size_t i = 0; i < rItems.size(); ++i)
 668     {
 669         const SwContentControlListItem& rItem = rItems[i];
 670         pRet[i] = {
 671             comphelper::makePropertyValue(u"DisplayText"_ustr, rItem.m_aDisplayText),
 672             comphelper::makePropertyValue(u"Value"_ustr, rItem.m_aValue),
 673         };
 674     }
 675
 676     rVal <<= aRet;
 677 }
 678
 679 std::vector<SwContentControlListItem>
 680 SwContentControlListItem::ItemsFromAny(const css::uno::Any& rVal)
 681 {
 682     std::vector<SwContentControlListItem> aRet;
 683
 684     uno::Sequence<uno::Sequence<beans::PropertyValue>> aSequence;
 685     rVal >>= aSequence;
 686     for (const auto& rItem : aSequence)
 687     {
 688         comphelper::SequenceAsHashMap aMap(rItem);
 689         SwContentControlListItem aItem;
 690         auto it = aMap.find(u"DisplayText"_ustr);
 691         if (it != aMap.end())
 692         {
 693             it->second >>= aItem.m_aDisplayText;
 694         }
 695         it = aMap.find(u"Value"_ustr);
 696         if (it != aMap.end())
 697         {
 698             it->second >>= aItem.m_aValue;
 699         }
 700         aRet.push_back(aItem);
 701     }
 702
 703     return aRet;
 704 }
 705
 706 SwTextContentControl*
 707 SwTextContentControl::CreateTextContentControl(SwDoc& rDoc, SwTextNode* pTargetTextNode,
 708                                                const SfxPoolItemHolder& rHolder, sal_Int32 nStart,
 709                                                sal_Int32 nEnd, bool bIsCopy)
 710 {
 711     if (bIsCopy)
 712     {
 713         // the item in rHolder is already cloned, now call DoCopy to copy the SwContentControl
 714         assert(pTargetTextNode
 715                && "SwTextContentControl ctor: cannot copy content control without target node");
 716         SwFormatContentControl* pSwFormatContentControl(
 717             static_cast<SwFormatContentControl*>(const_cast<SfxPoolItem*>(rHolder.getItem())));
 718         pSwFormatContentControl->DoCopy(*pTargetTextNode);
 719     }
 720     SwContentControlManager* pManager = &rDoc.GetContentControlManager();
 721     auto pTextContentControl(new SwTextContentControl(pManager, rHolder, nStart, nEnd));
 722     return pTextContentControl;
 723 }
 724
 725 SwTextContentControl::SwTextContentControl(SwContentControlManager* pManager,
 726                                            const SfxPoolItemHolder& rAttr, sal_Int32 nStart,
 727                                            sal_Int32 nEnd)
 728     : SwTextAttr(rAttr, nStart)
 729     , SwTextAttrNesting(rAttr, nStart, nEnd)
 730     , m_pManager(pManager)
 731 {
 732     SwFormatContentControl& rSwFormatContentControl(
 733         static_cast<SwFormatContentControl&>(GetAttr()));
 734     rSwFormatContentControl.SetTextAttr(this);
 735     SetHasDummyChar(true);
 736     m_pManager->Insert(this);
 737 }
 738
 739 SwTextContentControl::~SwTextContentControl()
 740 {
 741     auto& rFormatContentControl = static_cast<SwFormatContentControl&>(GetAttr());
 742     if (rFormatContentControl.GetTextAttr() == this)
 743     {
 744         rFormatContentControl.SetTextAttr(nullptr);
 745     }
 746 }
 747
 748 void SwTextContentControl::ChgTextNode(SwTextNode* pNode)
 749 {
 750     auto& rFormatContentControl = static_cast<SwFormatContentControl&>(GetAttr());
 751     if (rFormatContentControl.GetTextAttr() == this)
 752     {
 753         rFormatContentControl.NotifyChangeTextNode(pNode);
 754
 755         if (pNode)
 756         {
 757             m_pManager = &pNode->GetDoc().GetContentControlManager();
 758         }
 759         else
 760         {
 761             if (m_pManager)
 762             {
 763                 m_pManager->Erase(this);
 764             }
 765             m_pManager = nullptr;
 766         }
 767     }
 768 }
 769
 770 void SwTextContentControl::Delete(bool bSaveContents)
 771 {
 772     if (!GetTextNode())
 773         return;
 774
 775     SwPaM aPaM(*GetTextNode(), GetStart(), *GetTextNode(), *End());
 776     if (bSaveContents)
 777         GetTextNode()->GetDoc().ResetAttrs(aPaM, /*bTextAttr=*/true, { RES_TXTATR_CONTENTCONTROL });
 778     else
 779         GetTextNode()->GetDoc().getIDocumentContentOperations().DeleteAndJoin(aPaM);
 780 }
 781
 782 SwTextNode* SwTextContentControl::GetTextNode() const
 783 {
 784     auto& rFormatContentControl = static_cast<const SwFormatContentControl&>(GetAttr());
 785     return rFormatContentControl.GetTextNode();
 786 }
 787
 788 OUString SwTextContentControl::ToString() const
 789 {
 790     if (!GetTextNode())
 791         return OUString();
 792
 793     // Don't select the text attribute itself at the start.
 794     sal_Int32 nStart = GetStart() + 1;
 795     // Don't select the CH_TXTATR_BREAKWORD itself at the end.
 796     sal_Int32 nEnd = *End() - 1;
 797
 798     SwPaM aPaM(*GetTextNode(), nStart, *GetTextNode(), nEnd);
 799     return aPaM.GetText();
 800 }
 801
 802 void SwTextContentControl::Invalidate()
 803 {
 804     SwDocShell* pDocShell = GetTextNode() ? GetTextNode()->GetDoc().GetDocShell() : nullptr;
 805     if (!pDocShell || !pDocShell->GetWrtShell())
 806         return;
 807
 808     // save the cursor
 809     // NOTE: needs further testing to see if this is adequate (i.e. in auto-run macros...)
 810     pDocShell->GetWrtShell()->Push();
 811
 812     // visit the control in the text (which makes any necessary visual changes)
 813     // NOTE: simply going to a checkbox causes a toggle, unless bOnlyRefresh
 814     auto& rFormatContentControl = static_cast<SwFormatContentControl&>(GetAttr());
 815     pDocShell->GetWrtShell()->GotoContentControl(rFormatContentControl, /*bOnlyRefresh=*/true);
 816
 817     pDocShell->GetWrtShell()->Pop(SwCursorShell::PopMode::DeleteCurrent);
 818 }
 819
 820 void SwTextContentControl::dumpAsXml(xmlTextWriterPtr pWriter) const
 821 {
 822     (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwTextContentControl"));
 823     (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
 824     SwTextAttr::dumpAsXml(pWriter);
 825
 826     (void)xmlTextWriterEndElement(pWriter);
 827 }
 828
 829 SwContentControlManager::SwContentControlManager() {}
 830
 831 void SwContentControlManager::Insert(SwTextContentControl* pTextContentControl)
 832 {
 833     m_aContentControls.push_back(pTextContentControl);
 834 }
 835
 836 void SwContentControlManager::Erase(SwTextContentControl* pTextContentControl)
 837 {
 838     std::erase(m_aContentControls, pTextContentControl);
 839 }
 840
 841 SwTextContentControl* SwContentControlManager::Get(size_t nIndex)
 842 {
 843     // Only sort now: the items may not have an associated text node by the time they are inserted
 844     // into the container.
 845     std::sort(m_aContentControls.begin(), m_aContentControls.end(),
 846               [](SwTextContentControl*& pLhs, SwTextContentControl*& pRhs) -> bool {
 847                   SwNodeOffset nIdxLHS = pLhs->GetTextNode()->GetIndex();
 848                   SwNodeOffset nIdxRHS = pRhs->GetTextNode()->GetIndex();
 849                   if (nIdxLHS == nIdxRHS)
 850                   {
 851                       return pLhs->GetStart() < pRhs->GetStart();
 852                   }
 853
 854                   return nIdxLHS < nIdxRHS;
 855               });
 856
 857     return m_aContentControls[nIndex];
 858 }
 859
 860 SwTextContentControl* SwContentControlManager::UnsortedGet(size_t nIndex)
 861 {
 862     assert(nIndex < m_aContentControls.size());
 863     return m_aContentControls[nIndex];
 864 }
 865
 866 void SwContentControlManager::dumpAsXml(xmlTextWriterPtr pWriter) const
 867 {
 868     (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwContentControlManager"));
 869     (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
 870     for (const auto& pContentControl : m_aContentControls)
 871     {
 872         (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwTextContentControl"));
 873         (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", pContentControl);
 874         (void)xmlTextWriterEndElement(pWriter);
 875     }
 876
 877     (void)xmlTextWriterEndElement(pWriter);
 878 }
 879
 880 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */