formatcontentcontrol.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */
 
#pragma once
 
#include <com/sun/star/text/XTextContent.hpp>
#include <com/sun/star/beans/PropertyValue.hpp>
 
#include <cppuhelper/weakref.hxx>
#include <sal/types.h>
#include <svl/poolitem.hxx>
#include <unotools/weakref.hxx>
 
#include "calbck.hxx"
#include "swdllapi.h"
 
namespace vcl
{
class KeyCode;
}
class SwContentControl;
class SwTextContentControl;
class SwTextNode;
class SwXContentControl;
 
enum class SwContentControlType
{
    RICH_TEXT,
    CHECKBOX,
    DROP_DOWN_LIST,
    PICTURE,
    DATE,
    PLAIN_TEXT,
    COMBO_BOX,
};
 
class SW_DLLPUBLIC SwFormatContentControl final : public SfxPoolItem
{
    std::shared_ptr<SwContentControl> m_pContentControl;
    SwTextContentControl* m_pTextAttr;
 
public:
    SwTextContentControl* GetTextAttr() { return m_pTextAttr; }
    void SetTextAttr(SwTextContentControl* pTextAttr);
 
    void DoCopy(SwTextNode& rTargetTextNode);
 
    explicit SwFormatContentControl(sal_uInt16 nWhich);
 
    explicit SwFormatContentControl(const std::shared_ptr<SwContentControl>& pContentControl,
                                    sal_uInt16 nWhich);
    ~SwFormatContentControl() override;
 
    bool operator==(const SfxPoolItem&) const override;
    SwFormatContentControl* Clone(SfxItemPool* pPool = nullptr) const override;
 
    void NotifyChangeTextNode(SwTextNode* pTextNode);
    SwTextNode* GetTextNode() const;
    static SwFormatContentControl* CreatePoolDefault(sal_uInt16 nWhich);
    const std::shared_ptr<SwContentControl>& GetContentControl() const { return m_pContentControl; }
 
    void dumpAsXml(xmlTextWriterPtr pWriter) const override;
};
 
class SW_DLLPUBLIC SwContentControlListItem
{
public:
    OUString m_aDisplayText;
    OUString m_aValue;
 
    void dumpAsXml(xmlTextWriterPtr pWriter) const;
 
    const OUString& ToString() const;
 
    bool operator==(const SwContentControlListItem& rOther) const;
 
    static void ItemsToAny(const std::vector<SwContentControlListItem>& rItems,
                           css::uno::Any& rVal);
 
    static std::vector<SwContentControlListItem> ItemsFromAny(const css::uno::Any& rVal);
};
 
class SW_DLLPUBLIC SwContentControl final : public sw::BroadcastingModify
{
    unotools::WeakReference<SwXContentControl> m_wXContentControl;
 
    SwFormatContentControl* m_pFormat;
 
    SwTextNode* m_pTextNode;
 
    bool m_bShowingPlaceHolder = false;
 
    bool m_bCheckbox = false;
 
    bool m_bChecked = false;
 
    OUString m_aCheckedState;
 
    OUString m_aUncheckedState;
 
    std::vector<SwContentControlListItem> m_aListItems;
 
    bool m_bPicture = false;
 
    bool m_bDate = false;
 
    OUString m_aDateFormat;
 
    OUString m_aDateLanguage;
 
    OUString m_aCurrentDate;
 
    bool m_bPlainText = false;
 
    bool m_bComboBox = false;
 
    bool m_bDropDown = false;
 
    OUString m_aPlaceholderDocPart;
 
    OUString m_aDataBindingPrefixMappings;
 
    OUString m_aDataBindingXpath;
 
    OUString m_aDataBindingStoreItemID;
 
    OUString m_aColor;
 
    OUString m_aAppearance;
 
    OUString m_aAlias;
 
    OUString m_aTag;
 
    sal_Int32 m_nId = 0;
 
    sal_uInt32 m_nTabIndex = 0;
 
    OUString m_aLock;
 
    // i.e. temporarily store the selected item until the text is inserted by GotoContentControl.
    std::optional<size_t> m_oSelectedListItem;
 
    // i.e. temporarily store the date until the text is inserted by GotoContentControl.
    std::optional<double> m_oSelectedDate;
 
    bool m_bReadWrite = false;
 
public:
    SwTextContentControl* GetTextAttr() const;
 
    SwTextNode* GetTextNode() const { return m_pTextNode; }
 
    SwFormatContentControl* GetFormatContentControl() const { return m_pFormat; }
 
    void SetFormatContentControl(SwFormatContentControl* pFormat) { m_pFormat = pFormat; };
 
    void NotifyChangeTextNode(SwTextNode* pTextNode);
 
    const unotools::WeakReference<SwXContentControl>& GetXContentControl() const
    {
        return m_wXContentControl;
    }
 
    void SetXContentControl(const rtl::Reference<SwXContentControl>& xContentControl);
 
    virtual void SwClientNotify(const SwModify&, const SfxHint&) override;
 
    explicit SwContentControl(SwFormatContentControl* pFormat);
 
    virtual ~SwContentControl() override;
 
    void SetShowingPlaceHolder(bool bShowingPlaceHolder)
    {
        m_bShowingPlaceHolder = bShowingPlaceHolder;
    }
 
    bool GetShowingPlaceHolder() const { return m_bShowingPlaceHolder; }
 
    void SetCheckbox(bool bCheckbox) { m_bCheckbox = bCheckbox; }
 
    bool GetCheckbox() const { return m_bCheckbox; }
 
    void SetChecked(bool bChecked) { m_bChecked = bChecked; }
 
    bool GetChecked() const { return m_bChecked; }
 
    void SetCheckedState(const OUString& rCheckedState) { m_aCheckedState = rCheckedState; }
 
    const OUString& GetCheckedState() const { return m_aCheckedState; }
 
    void SetUncheckedState(const OUString& rUncheckedState) { m_aUncheckedState = rUncheckedState; }
 
    const OUString& GetUncheckedState() const { return m_aUncheckedState; }
 
    const std::vector<SwContentControlListItem>& GetListItems() const { return m_aListItems; }
 
    void SetListItems(const std::vector<SwContentControlListItem>& rListItems)
    {
        m_aListItems = rListItems;
    }
 
    bool AddListItem(size_t nZIndex, const OUString& rDisplayText, const OUString& rValue);
    void DeleteListItem(size_t nZIndex);
    void ClearListItems();
 
    void SetPicture(bool bPicture) { m_bPicture = bPicture; }
 
    bool GetPicture() const { return m_bPicture; }
 
    void SetDate(bool bDate) { m_bDate = bDate; }
 
    bool GetDate() const { return m_bDate; }
 
    void SetDateFormat(const OUString& rDateFormat) { m_aDateFormat = rDateFormat; }
 
    const OUString& GetDateFormat() const { return m_aDateFormat; }
 
    void SetDateLanguage(const OUString& rDateLanguage) { m_aDateLanguage = rDateLanguage; }
 
    const OUString& GetDateLanguage() const { return m_aDateLanguage; }
 
    void SetCurrentDate(const OUString& rCurrentDate) { m_aCurrentDate = rCurrentDate; }
 
    const OUString& GetCurrentDate() const { return m_aCurrentDate; }
 
    void SetCurrentDateValue(double fCurrentDate);
 
    double GetCurrentDateValue() const;
 
    OUString GetDateString() const;
 
    void SetPlainText(bool bPlainText) { m_bPlainText = bPlainText; }
 
    bool GetPlainText() const { return m_bPlainText; }
 
    void SetComboBox(bool bComboBox) { m_bComboBox = bComboBox; }
 
    bool GetComboBox() const { return m_bComboBox; }
 
    void SetDropDown(bool bDropDown) { m_bDropDown = bDropDown; }
 
    bool GetDropDown() const { return m_bDropDown; }
 
    void SetPlaceholderDocPart(const OUString& rPlaceholderDocPart)
    {
        m_aPlaceholderDocPart = rPlaceholderDocPart;
    }
 
    const OUString& GetPlaceholderDocPart() const { return m_aPlaceholderDocPart; }
 
    void SetSelectedListItem(std::optional<size_t> oSelectedListItem)
    {
        m_oSelectedListItem = oSelectedListItem;
    }
 
    const std::optional<size_t>& GetSelectedListItem() const { return m_oSelectedListItem; }
 
    std::optional<size_t> GetSelectedListItem(bool bCheckDocModel) const;
 
    void SetSelectedDate(std::optional<double> oSelectedDate) { m_oSelectedDate = oSelectedDate; }
 
    const std::optional<double>& GetSelectedDate() const { return m_oSelectedDate; }
 
    bool IsInteractingCharacter(sal_Unicode cCh);
 
    bool ShouldOpenPopup(const vcl::KeyCode& rKeyCode);
 
    void dumpAsXml(xmlTextWriterPtr pWriter) const;
 
    void SetDataBindingPrefixMappings(const OUString& rDataBindingPrefixMappings)
    {
        m_aDataBindingPrefixMappings = rDataBindingPrefixMappings;
    }
 
    const OUString& GetDataBindingPrefixMappings() const { return m_aDataBindingPrefixMappings; }
 
    void SetDataBindingXpath(const OUString& rDataBindingXpath)
    {
        m_aDataBindingXpath = rDataBindingXpath;
    }
 
    const OUString& GetDataBindingXpath() const { return m_aDataBindingXpath; }
 
    void SetDataBindingStoreItemID(const OUString& rDataBindingStoreItemID)
    {
        m_aDataBindingStoreItemID = rDataBindingStoreItemID;
    }
 
    const OUString& GetDataBindingStoreItemID() const { return m_aDataBindingStoreItemID; }
 
    void SetColor(const OUString& rColor) { m_aColor = rColor; }
 
    const OUString& GetColor() const { return m_aColor; }
 
    void SetAppearance(const OUString& rAppearance) { m_aAppearance = rAppearance; }
 
    const OUString& GetAppearance() const { return m_aAppearance; }
 
    void SetAlias(const OUString& rAlias) { m_aAlias = rAlias; }
 
    const OUString& GetAlias() const { return m_aAlias; }
 
    void SetTag(const OUString& rTag) { m_aTag = rTag; }
 
    const OUString& GetTag() const { return m_aTag; }
 
    void SetId(sal_Int32 nId) { m_nId = nId; }
 
    sal_Int32 GetId() const { return m_nId; }
 
    void SetTabIndex(sal_uInt32 nTabIndex) { m_nTabIndex = nTabIndex; }
 
    sal_uInt32 GetTabIndex() const { return m_nTabIndex; }
 
    // At the design level, define how the control should be locked. No effect at implementation lvl
    void SetLock(bool bLockContent, bool bLockControl);
    void SetLock(const OUString& rLock) { m_aLock = rLock; }
 
    // At the design level, get how the control is locked. Does not reflect actual implementation.
    std::optional<bool> GetLock(bool bControl) const;
    const OUString& GetLock() const { return m_aLock; }
 
    void SetReadWrite(bool bReadWrite) { m_bReadWrite = bReadWrite; }
 
    // At the implementation level, define whether the user can directly modify the contents.
    bool GetReadWrite() const { return m_bReadWrite; }
 
    SwContentControlType GetType() const;
};
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */