MSForms: Rework text-based date form field's representation

* Better to represent it similar to text form field with two
marking characters selecting a text range
* So the text between the two marks can be anything (not only
a well formatted date) and also have any character formatting.
* With this we handle the case when the user needs a placeholder
text in the date field or when the user needs time values (hour,
minute, sec) next to the date.

Reviewed-on: https://gerrit.libreoffice.org/75459
Tested-by: Jenkins
Reviewed-by: Tamás Zolnai <tamas.zolnai@collabora.com>
(cherry picked from commit 68e1be4ccbb90ee9a788962219a88312c4ffbea2)

Change-Id: Id60a50a2028058f8a6a080e265c0730d88b98543
Reviewed-on: https://gerrit.libreoffice.org/75552
Tested-by: Jenkins CollaboraOffice <jenkinscollaboraoffice@gmail.com>
Reviewed-by: Andras Timar <andras.timar@collabora.com>

19 files changed, 519 insertions, 327 deletions

diff --git a/sw/source/core/crsr/DateFormFieldButton.cxx b/sw/source/core/crsr/DateFormFieldButton.cxx
index 52a634e6158f..0fdcf842dc30 100644
--- a/sw/source/core/crsr/DateFormFieldButton.cxx
+++ b/sw/source/core/crsr/DateFormFieldButton.cxx
@@ -28,19 +28,19 @@ class SwDatePickerDialog : public FloatingWindow
 {
 private:
     VclPtr<Calendar> m_pCalendar;
-    sw::mark::IFieldmark* m_pFieldmark;
+    sw::mark::DateFieldmark* m_pFieldmark;
     SvNumberFormatter* m_pNumberFormatter;
 
     DECL_LINK(ImplSelectHdl, Calendar*, void);
 
 public:
-    SwDatePickerDialog(SwEditWin* parent, sw::mark::IFieldmark* pFieldmark,
+    SwDatePickerDialog(SwEditWin* parent, sw::mark::DateFieldmark* pFieldmark,
                        SvNumberFormatter* pNumberFormatter);
     virtual ~SwDatePickerDialog() override;
     virtual void dispose() override;
 };
 
-SwDatePickerDialog::SwDatePickerDialog(SwEditWin* parent, sw::mark::IFieldmark* pFieldmark,
+SwDatePickerDialog::SwDatePickerDialog(SwEditWin* parent, sw::mark::DateFieldmark* pFieldmark,
                                        SvNumberFormatter* pNumberFormatter)
     : FloatingWindow(parent, WB_BORDER | WB_SYSTEMWINDOW | WB_NOSHADOW)
     , m_pCalendar(VclPtr<Calendar>::Create(this, WB_TABSTOP))
@@ -49,33 +49,11 @@ SwDatePickerDialog::SwDatePickerDialog(SwEditWin* parent, sw::mark::IFieldmark*
 {
     if (m_pFieldmark != nullptr)
     {
-        sw::mark::IFieldmark::parameter_map_t* pParameters = m_pFieldmark->GetParameters();
-
-        auto pResult = pParameters->find(ODF_FORMDATE_CURRENTDATE);
-        if (pResult != pParameters->end())
+        std::pair<bool, double> aResult = m_pFieldmark->GetCurrentDate();
+        if (aResult.first)
         {
-            OUString sDateString;
-            pResult->second >>= sDateString;
-
-            sal_uInt32 nFormat = m_pNumberFormatter->GetEntryKey(ODF_FORMDATE_CURRENTDATE_FORMAT,
-                                                                 ODF_FORMDATE_CURRENTDATE_LANGUAGE);
-            if (nFormat == NUMBERFORMAT_ENTRY_NOT_FOUND)
-            {
-                sal_Int32 nCheckPos = 0;
-                short nType;
-                OUString sFormat = ODF_FORMDATE_CURRENTDATE_FORMAT;
-                m_pNumberFormatter->PutEntry(sFormat, nCheckPos, nType, nFormat,
-                                             ODF_FORMDATE_CURRENTDATE_LANGUAGE);
-            }
-
-            if (nFormat != NUMBERFORMAT_ENTRY_NOT_FOUND)
-            {
-                double dCurrentDate = 0;
-                m_pNumberFormatter->IsNumberFormat(sDateString, nFormat, dCurrentDate);
-
-                const Date& rNullDate = m_pNumberFormatter->GetNullDate();
-                m_pCalendar->SetCurDate(rNullDate + sal_Int32(dCurrentDate));
-            }
+            const Date& rNullDate = m_pNumberFormatter->GetNullDate();
+            m_pCalendar->SetCurDate(rNullDate + sal_Int32(aResult.second));
         }
     }
     m_pCalendar->SetSelectHdl(LINK(this, SwDatePickerDialog, ImplSelectHdl));
@@ -98,30 +76,9 @@ IMPL_LINK(SwDatePickerDialog, ImplSelectHdl, Calendar*, pCalendar, void)
     {
         if (m_pFieldmark != nullptr)
         {
-            sal_uInt32 nFormat = m_pNumberFormatter->GetEntryKey(ODF_FORMDATE_CURRENTDATE_FORMAT,
-                                                                 ODF_FORMDATE_CURRENTDATE_LANGUAGE);
-            if (nFormat == NUMBERFORMAT_ENTRY_NOT_FOUND)
-            {
-                sal_Int32 nCheckPos = 0;
-                short nType;
-                OUString sFormat = ODF_FORMDATE_CURRENTDATE_FORMAT;
-                m_pNumberFormatter->PutEntry(sFormat, nCheckPos, nType, nFormat,
-                                             ODF_FORMDATE_CURRENTDATE_LANGUAGE);
-            }
-
-            if (nFormat != NUMBERFORMAT_ENTRY_NOT_FOUND)
-            {
-                Color* pCol = nullptr;
-                OUString sOutput;
-
-                const Date& rNullDate = m_pNumberFormatter->GetNullDate();
-                double dDate = pCalendar->GetFirstSelectedDate() - rNullDate;
-
-                m_pNumberFormatter->GetOutputString(dDate, nFormat, sOutput, &pCol, false);
-
-                sw::mark::IFieldmark::parameter_map_t* pParameters = m_pFieldmark->GetParameters();
-                (*pParameters)[ODF_FORMDATE_CURRENTDATE] <<= sOutput;
-            }
+            const Date& rNullDate = m_pNumberFormatter->GetNullDate();
+            double dDate = pCalendar->GetFirstSelectedDate() - rNullDate;
+            m_pFieldmark->SetCurrentDate(dDate);
         }
         EndPopupMode();
     }
@@ -138,8 +95,9 @@ DateFormFieldButton::~DateFormFieldButton() { disposeOnce(); }
 
 void DateFormFieldButton::InitPopup()
 {
+    sw::mark::DateFieldmark* pDateFieldmark = dynamic_cast<sw::mark::DateFieldmark*>(&m_rFieldmark);
     m_pFieldPopup = VclPtr<SwDatePickerDialog>::Create(static_cast<SwEditWin*>(GetParent()),
-                                                       &m_rFieldmark, m_pNumberFormatter);
+                                                       pDateFieldmark, m_pNumberFormatter);
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */
diff --git a/sw/source/core/crsr/bookmrk.cxx b/sw/source/core/crsr/bookmrk.cxx
index a0c9afd4f756..09cd5375f2f3 100644
--- a/sw/source/core/crsr/bookmrk.cxx
+++ b/sw/source/core/crsr/bookmrk.cxx
@@ -40,6 +40,8 @@
 #include <DateFormFieldButton.hxx>
 #include <DropDownFormFieldButton.hxx>
 #include <svx/numfmtsh.hxx>
+#include <ndtxt.hxx>
+#include <DocumentContentOperationsManager.hxx>
 
 using namespace ::sw::mark;
 using namespace ::com::sun::star;
@@ -499,21 +501,6 @@ namespace sw { namespace mark
         m_pButton.disposeAndClear();
     }
 
-    void FieldmarkWithDropDownButton::SetPortionPaintArea(const SwRect& rPortionPaintArea)
-    {
-        if(m_aPortionPaintArea == rPortionPaintArea &&
-           m_pButton && m_pButton->IsVisible())
-            return;
-
-        m_aPortionPaintArea = rPortionPaintArea;
-        if(m_pButton)
-        {
-            m_pButton->Show();
-            m_pButton->CalcPosAndSize(m_aPortionPaintArea);
-            m_pButton->Invalidate();
-        }
-    }
-
     void FieldmarkWithDropDownButton::HideButton()
     {
         if(m_pButton)
@@ -546,8 +533,25 @@ namespace sw { namespace mark
         }
     }
 
+    void DropDownFieldmark::SetPortionPaintArea(const SwRect& rPortionPaintArea)
+    {
+        if(m_aPortionPaintArea == rPortionPaintArea &&
+           m_pButton && m_pButton->IsVisible())
+            return;
+
+        m_aPortionPaintArea = rPortionPaintArea;
+        if(m_pButton)
+        {
+            m_pButton->Show();
+            m_pButton->CalcPosAndSize(m_aPortionPaintArea);
+            m_pButton->Invalidate();
+        }
+    }
+
     DateFieldmark::DateFieldmark(const SwPaM& rPaM)
         : FieldmarkWithDropDownButton(rPaM)
+        , m_pNumberFormatter(nullptr)
+        , m_pDocumentContentOperationsManager(nullptr)
     {
     }
 
@@ -558,7 +562,20 @@ namespace sw { namespace mark
     void DateFieldmark::InitDoc(SwDoc* const io_pDoc, sw::mark::InsertMode eMode)
     {
         m_pNumberFormatter = io_pDoc->GetNumberFormatter();
-        NonTextFieldmark::InitDoc(io_pDoc, eMode);
+        m_pDocumentContentOperationsManager = &io_pDoc->GetDocumentContentOperationsManager();
+        if (eMode == sw::mark::InsertMode::New)
+        {
+            lcl_SetFieldMarks(this, io_pDoc, CH_TXT_ATR_FIELDSTART, CH_TXT_ATR_FIELDEND);
+        }
+        else
+        {
+            lcl_AssertFieldMarksSet(this, CH_TXT_ATR_FIELDSTART, CH_TXT_ATR_FIELDEND);
+        }
+    }
+
+    void DateFieldmark::ReleaseDoc(SwDoc* const pDoc)
+    {
+        lcl_RemoveFieldMarks(this, pDoc, CH_TXT_ATR_FIELDSTART, CH_TXT_ATR_FIELDEND);
     }
 
     void DateFieldmark::ShowButton(SwEditWin* pEditWin)
@@ -567,10 +584,235 @@ namespace sw { namespace mark
         {
             if(!m_pButton)
                 m_pButton = VclPtr<DateFormFieldButton>::Create(pEditWin, *this, m_pNumberFormatter);
-            m_pButton->CalcPosAndSize(m_aPortionPaintArea);
+            m_pButton->CalcPosAndSize(m_aPaintAreaEnd);
             m_pButton->Show();
         }
     }
+
+    void DateFieldmark::SetPortionPaintAreaStart(const SwRect& rPortionPaintArea)
+    {
+        m_aPaintAreaStart = rPortionPaintArea;
+        InvalidateCurrentDateParam();
+    }
+
+    void DateFieldmark::SetPortionPaintAreaEnd(const SwRect& rPortionPaintArea)
+    {
+        if(m_aPaintAreaEnd == rPortionPaintArea &&
+           m_pButton && m_pButton->IsVisible())
+            return;
+
+        m_aPaintAreaEnd = rPortionPaintArea;
+        if(m_pButton)
+        {
+            m_pButton->Show();
+            SwRect aPaintArea(m_aPaintAreaStart.TopLeft(), m_aPaintAreaEnd.BottomRight());
+            m_pButton->CalcPosAndSize(aPaintArea);
+            m_pButton->Invalidate();
+        }
+        InvalidateCurrentDateParam();
+    }
+
+    OUString DateFieldmark::GetContent() const
+    {
+        const SwTextNode* const pTextNode = GetMarkEnd().nNode.GetNode().GetTextNode();
+        const sal_Int32 nStart(GetMarkStart().nContent.GetIndex());
+        const sal_Int32 nEnd  (GetMarkEnd().nContent.GetIndex());
+
+        OUString sContent;
+        if(nStart + 1 < pTextNode->GetText().getLength() && nEnd <= pTextNode->GetText().getLength() &&
+           nEnd > nStart + 2)
+            sContent = pTextNode->GetText().copy(nStart + 1, nEnd - nStart - 2);
+        return sContent;
+    }
+
+    void DateFieldmark::ReplaceContent(const OUString& sNewContent)
+    {
+        if(!m_pDocumentContentOperationsManager)
+            return;
+
+        const SwTextNode* const pTextNode = GetMarkEnd().nNode.GetNode().GetTextNode();
+        const sal_Int32 nStart(GetMarkStart().nContent.GetIndex());
+        const sal_Int32 nEnd  (GetMarkEnd().nContent.GetIndex());
+
+        if(nStart + 1 < pTextNode->GetText().getLength() && nEnd <= pTextNode->GetText().getLength())
+        {
+            SwPaM aFieldPam(GetMarkStart().nNode, nStart + 1,
+                            GetMarkStart().nNode, nEnd - 1);
+            m_pDocumentContentOperationsManager->ReplaceRange(aFieldPam, sNewContent, false);
+        }
+
+    }
+
+    std::pair<bool, double> DateFieldmark::GetCurrentDate() const
+    {
+        // Check current date param first
+        std::pair<bool, double> aResult = ParseCurrentDateParam();
+        if(aResult.first)
+            return aResult;
+
+        const sw::mark::IFieldmark::parameter_map_t* pParameters = GetParameters();
+        bool bFoundValidDate = false;
+        double dCurrentDate = 0;
+        OUString sDateFormat;
+        auto pResult = pParameters->find(ODF_FORMDATE_DATEFORMAT);
+        if (pResult != pParameters->end())
+        {
+            pResult->second >>= sDateFormat;
+        }
+
+        OUString sLang;
+        pResult = pParameters->find(ODF_FORMDATE_DATEFORMAT_LANGUAGE);
+        if (pResult != pParameters->end())
+        {
+            pResult->second >>= sLang;
+        }
+
+        // Get current content of the field
+        OUString sContent = GetContent();
+
+        sal_uInt32 nFormat = m_pNumberFormatter->GetEntryKey(sDateFormat, LanguageTag(sLang).getLanguageType());
+        if (nFormat == NUMBERFORMAT_ENTRY_NOT_FOUND)
+        {
+            sal_Int32 nCheckPos = 0;
+            short nType;
+            m_pNumberFormatter->PutEntry(sDateFormat,
+                                         nCheckPos,
+                                         nType,
+                                         nFormat,
+                                         LanguageTag(sLang).getLanguageType());
+        }
+
+        if (nFormat != NUMBERFORMAT_ENTRY_NOT_FOUND)
+        {
+            bFoundValidDate = m_pNumberFormatter->IsNumberFormat(sContent, nFormat, dCurrentDate);
+        }
+        return std::pair<bool, double>(bFoundValidDate, dCurrentDate);
+    }
+
+    void DateFieldmark::SetCurrentDate(double fDate)
+    {
+        // Replace current content with the selected date
+        ReplaceContent(GetDateInCurrentDateFormat(fDate));
+
+        // Also save the current date in a standard format
+        sw::mark::IFieldmark::parameter_map_t* pParameters = GetParameters();
+        (*pParameters)[ODF_FORMDATE_CURRENTDATE] <<= GetDateInStandardDateFormat(fDate);
+    }
+
+    OUString DateFieldmark::GetDateInStandardDateFormat(double fDate) const
+    {
+        OUString sCurrentDate;
+        sal_uInt32 nFormat = m_pNumberFormatter->GetEntryKey(ODF_FORMDATE_CURRENTDATE_FORMAT, ODF_FORMDATE_CURRENTDATE_LANGUAGE);
+        if (nFormat == NUMBERFORMAT_ENTRY_NOT_FOUND)
+        {
+            sal_Int32 nCheckPos = 0;
+            short nType;
+            OUString sFormat = ODF_FORMDATE_CURRENTDATE_FORMAT;
+            m_pNumberFormatter->PutEntry(sFormat,
+                                         nCheckPos,
+                                         nType,
+                                         nFormat,
+                                         ODF_FORMDATE_CURRENTDATE_LANGUAGE);
+        }
+
+        if (nFormat != NUMBERFORMAT_ENTRY_NOT_FOUND)
+        {
+            Color* pCol = nullptr;
+            m_pNumberFormatter->GetOutputString(fDate, nFormat, sCurrentDate, &pCol, false);
+        }
+        return sCurrentDate;
+    }
+
+    std::pair<bool, double> DateFieldmark::ParseCurrentDateParam() const
+    {
+        bool bFoundValidDate = false;
+        double dCurrentDate = 0;
+
+        const sw::mark::IFieldmark::parameter_map_t* pParameters = GetParameters();
+        auto pResult = pParameters->find(ODF_FORMDATE_CURRENTDATE);
+        OUString sCurrentDate;
+        if (pResult != pParameters->end())
+        {
+            pResult->second >>= sCurrentDate;
+        }
+        if(!sCurrentDate.isEmpty())
+        {
+            sal_uInt32 nFormat = m_pNumberFormatter->GetEntryKey(ODF_FORMDATE_CURRENTDATE_FORMAT, ODF_FORMDATE_CURRENTDATE_LANGUAGE);
+            if (nFormat == NUMBERFORMAT_ENTRY_NOT_FOUND)
+            {
+                sal_Int32 nCheckPos = 0;
+                short nType;
+                OUString sFormat = ODF_FORMDATE_CURRENTDATE_FORMAT;
+                m_pNumberFormatter->PutEntry(sFormat,
+                                             nCheckPos,
+                                             nType,
+                                             nFormat,
+                                             ODF_FORMDATE_CURRENTDATE_LANGUAGE);
+            }
+
+            if(nFormat != NUMBERFORMAT_ENTRY_NOT_FOUND)
+            {
+                bFoundValidDate = m_pNumberFormatter->IsNumberFormat(sCurrentDate, nFormat, dCurrentDate);
+            }
+        }
+        return std::pair<bool, double>(bFoundValidDate, dCurrentDate);
+    }
+
+
+    OUString DateFieldmark::GetDateInCurrentDateFormat(double fDate) const
+    {
+        // Get current date format and language
+        OUString sDateFormat;
+        const sw::mark::IFieldmark::parameter_map_t* pParameters = GetParameters();
+        auto pResult = pParameters->find(ODF_FORMDATE_DATEFORMAT);
+        if (pResult != pParameters->end())
+        {
+            pResult->second >>= sDateFormat;
+        }
+
+        OUString sLang;
+        pResult = pParameters->find(ODF_FORMDATE_DATEFORMAT_LANGUAGE);
+        if (pResult != pParameters->end())
+        {
+            pResult->second >>= sLang;
+        }
+
+        // Fill the content with the specified format
+        OUString sCurrentContent;
+        sal_uInt32 nFormat = m_pNumberFormatter->GetEntryKey(sDateFormat, LanguageTag(sLang).getLanguageType());
+        if (nFormat == NUMBERFORMAT_ENTRY_NOT_FOUND)
+        {
+            sal_Int32 nCheckPos = 0;
+            short nType;
+            OUString sFormat = sDateFormat;
+            m_pNumberFormatter->PutEntry(sFormat,
+                                         nCheckPos,
+                                         nType,
+                                         nFormat,
+                                         LanguageTag(sLang).getLanguageType());
+        }
+
+        if (nFormat != NUMBERFORMAT_ENTRY_NOT_FOUND)
+        {
+            Color* pCol = nullptr;
+            m_pNumberFormatter->GetOutputString(fDate, nFormat, sCurrentContent, &pCol, false);
+        }
+        return sCurrentContent;
+    }
+
+    void DateFieldmark::InvalidateCurrentDateParam()
+    {
+        std::pair<bool, double> aResult = ParseCurrentDateParam();
+        if(!aResult.first)
+            return;
+
+        // Current date became invalid
+        if(GetDateInCurrentDateFormat(aResult.second) != GetContent())
+        {
+            sw::mark::IFieldmark::parameter_map_t* pParameters = GetParameters();
+            (*pParameters)[ODF_FORMDATE_CURRENTDATE] <<= OUString();
+        }
+    }
 }}
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/core/doc/docbm.cxx b/sw/source/core/doc/docbm.cxx
index 985904e27a56..969ab413b0e5 100644
--- a/sw/source/core/doc/docbm.cxx
+++ b/sw/source/core/doc/docbm.cxx
@@ -509,9 +509,19 @@ namespace sw { namespace mark
         bool bUndoIsEnabled = m_pDoc->GetIDocumentUndoRedo().DoesUndo();
         m_pDoc->GetIDocumentUndoRedo().DoUndo(false);
 
-        sw::mark::IMark* pMark = makeMark( rPaM, rName,
-                IDocumentMarkAccess::MarkType::TEXT_FIELDMARK,
-                sw::mark::InsertMode::New);
+        sw::mark::IMark* pMark = nullptr;
+        if(rType == ODF_FORMDATE)
+        {
+            pMark = makeMark(rPaM, rName,
+                             IDocumentMarkAccess::MarkType::DATE_FIELDMARK,
+                              sw::mark::InsertMode::New);
+        }
+        else
+        {
+            pMark = makeMark(rPaM, rName,
+                             IDocumentMarkAccess::MarkType::TEXT_FIELDMARK,
+                             sw::mark::InsertMode::New);
+        }
         sw::mark::IFieldmark* pFieldMark = dynamic_cast<sw::mark::IFieldmark*>( pMark );
         if (pFieldMark)
             pFieldMark->SetFieldname( rType );
@@ -1121,23 +1131,29 @@ namespace sw { namespace mark
         deleteMark(lcl_FindMark(m_vAllMarks, *pFieldmark));
     }
 
-    ::sw::mark::IFieldmark* MarkManager::changeNonTextFieldmarkType(::sw::mark::IFieldmark* pFieldmark, const OUString& rNewType)
+    ::sw::mark::IFieldmark* MarkManager::changeFormFieldmarkType(::sw::mark::IFieldmark* pFieldmark, const OUString& rNewType)
     {
         bool bActualChange = false;
         if(rNewType == ODF_FORMDROPDOWN)
         {
             if (!dynamic_cast<::sw::mark::DropDownFieldmark*>(pFieldmark))
                 bActualChange = true;
+            if (!dynamic_cast<::sw::mark::CheckboxFieldmark*>(pFieldmark)) // only allowed converting between checkbox <-> dropdown
+                return nullptr;
         }
         else if(rNewType == ODF_FORMCHECKBOX)
         {
             if (!dynamic_cast<::sw::mark::CheckboxFieldmark*>(pFieldmark))
                 bActualChange = true;
+            if (!dynamic_cast<::sw::mark::DropDownFieldmark*>(pFieldmark)) // only allowed converting between checkbox <-> dropdown
+                return nullptr;
         }
         else if(rNewType == ODF_FORMDATE)
         {
             if (!dynamic_cast<::sw::mark::DateFieldmark*>(pFieldmark))
                 bActualChange = true;
+            if (!dynamic_cast<::sw::mark::TextFieldmark*>(pFieldmark)) // only allowed converting between date field <-> text field
+                return nullptr;
         }
 
         if (!bActualChange)
@@ -1148,13 +1164,20 @@ namespace sw { namespace mark
         SwPaM aPaM(pFieldmark->GetMarkPos());
 
         // Remove the old fieldmark and create a new one with the new type
-        if(aPaM.GetPoint()->nContent > 0)
+        if(aPaM.GetPoint()->nContent > 0 && (rNewType == ODF_FORMDROPDOWN || rNewType == ODF_FORMCHECKBOX))
         {
             --aPaM.GetPoint()->nContent;
             SwPosition aNewPos (aPaM.GetPoint()->nNode, aPaM.GetPoint()->nContent);
             deleteFieldmarkAt(aNewPos);
             return makeNoTextFieldBookmark(aPaM, sName, rNewType);
         }
+        else if(rNewType == ODF_FORMDATE)
+        {
+            SwPosition aPos (aPaM.GetPoint()->nNode, aPaM.GetPoint()->nContent);
+            SwPaM aNewPaM(pFieldmark->GetMarkStart(), pFieldmark->GetMarkEnd());
+            deleteFieldmarkAt(aPos);
+            return makeFieldBookmark(aNewPaM, sName, rNewType);
+        }
         return nullptr;
     }
 
diff --git a/sw/source/core/inc/MarkManager.hxx b/sw/source/core/inc/MarkManager.hxx
index 6e05a171ce34..0bf8f1e97cdc 100644
--- a/sw/source/core/inc/MarkManager.hxx
+++ b/sw/source/core/inc/MarkManager.hxx
@@ -91,7 +91,7 @@ namespace sw {
             virtual std::vector< ::sw::mark::IFieldmark* > getDropDownsFor(const SwPaM &rPaM) const override;
 
             virtual void deleteFieldmarkAt(const SwPosition& rPos) override;
-            virtual ::sw::mark::IFieldmark* changeNonTextFieldmarkType(::sw::mark::IFieldmark* pFieldmark, const OUString& rNewType) override;
+            virtual ::sw::mark::IFieldmark* changeFormFieldmarkType(::sw::mark::IFieldmark* pFieldmark, const OUString& rNewType) override;
 
             virtual void NotifyCursorUpdate(const SwCursorShell& rCursorShell) override;
             virtual void ClearFieldActivation() override;
diff --git a/sw/source/core/inc/bookmrk.hxx b/sw/source/core/inc/bookmrk.hxx
index 75cd7b1b5c64..34a01ea20995 100644
--- a/sw/source/core/inc/bookmrk.hxx
+++ b/sw/source/core/inc/bookmrk.hxx
@@ -267,15 +267,11 @@ namespace sw {
             FieldmarkWithDropDownButton(const SwPaM& rPaM);
             virtual ~FieldmarkWithDropDownButton() override;
 
-            // This method should be called only by the portion so we can now the portion's painting area
-            void SetPortionPaintArea(const SwRect& rPortionPaintArea);
-
             virtual void ShowButton(SwEditWin* pEditWin) = 0;
             void HideButton();
             void RemoveButton();
 
         protected:
-            SwRect m_aPortionPaintArea;
             VclPtr<FormFieldButton> m_pButton;
         };
 
@@ -288,22 +284,47 @@ namespace sw {
             virtual ~DropDownFieldmark() override;
 
             virtual void ShowButton(SwEditWin* pEditWin) override;
+
+            // This method should be called only by the portion so we can now the portion's painting area
+            void SetPortionPaintArea(const SwRect& rPortionPaintArea);
+
+        private:
+            SwRect m_aPortionPaintArea;
         };
 
         /// Fieldmark representing a date form field.
         class DateFieldmark
-            : public FieldmarkWithDropDownButton
+            : virtual public IDateFieldmark
+            , public FieldmarkWithDropDownButton
         {
         public:
             DateFieldmark(const SwPaM& rPaM);
             virtual ~DateFieldmark() override;
 
             virtual void InitDoc(SwDoc* const io_pDoc, sw::mark::InsertMode eMode) override;
+            virtual void ReleaseDoc(SwDoc* const pDoc) override;
 
             virtual void ShowButton(SwEditWin* pEditWin) override;
 
+            void SetPortionPaintAreaStart(const SwRect& rPortionPaintArea);
+            void SetPortionPaintAreaEnd(const SwRect& rPortionPaintArea);
+
+            virtual OUString GetContent() const override;
+            virtual void ReplaceContent(const OUString& sNewContent) override;
+
+            virtual std::pair<bool, double> GetCurrentDate() const override;
+            virtual void SetCurrentDate(double fDate) override;
+            virtual OUString GetDateInStandardDateFormat(double fDate) const override;
+
         private:
+            OUString GetDateInCurrentDateFormat(double fDate) const;
+            std::pair<bool, double> ParseCurrentDateParam() const;
+            void InvalidateCurrentDateParam();
+
             SvNumberFormatter* m_pNumberFormatter;
+            sw::DocumentContentOperationsManager* m_pDocumentContentOperationsManager;
+            SwRect m_aPaintAreaStart;
+            SwRect m_aPaintAreaEnd;
         };
     }
 }
diff --git a/sw/source/core/text/itrform2.cxx b/sw/source/core/text/itrform2.cxx
index 988a14c18937..9af1839e2bf3 100644
--- a/sw/source/core/text/itrform2.cxx
+++ b/sw/source/core/text/itrform2.cxx
@@ -863,78 +863,6 @@ namespace sw { namespace mark {
         sal_Unicode vEnSpaces[ODF_FORMFIELD_DEFAULT_LENGTH] = {8194, 8194, 8194, 8194, 8194};
         return OUString(vEnSpaces, ODF_FORMFIELD_DEFAULT_LENGTH);
     }
-
-    static OUString ExpandDateFieldmark(IFieldmark* pBM, SvNumberFormatter* pFormatter)
-    {
-        OUString sDateFormat;
-        mark::IFieldmark::parameter_map_t* pParameters = pBM->GetParameters();
-        auto pResult = pParameters->find(ODF_FORMDATE_DATEFORMAT);
-        if (pResult != pParameters->end())
-        {
-            pResult->second >>= sDateFormat;
-        }
-
-        OUString sLang;
-        pResult = pParameters->find(ODF_FORMDATE_DATEFORMAT_LANGUAGE);
-        if (pResult != pParameters->end())
-        {
-            pResult->second >>= sLang;
-        }
-
-        double dCurrentDate = 0.0;
-        bool bHasCurrentDate = false;
-        pResult = pParameters->find(ODF_FORMDATE_CURRENTDATE);
-        if (pResult != pParameters->end())
-        {
-            OUString sFormattedDate;
-            pResult->second >>= sFormattedDate;
-
-            sal_uInt32 nFormat = pFormatter->GetEntryKey(ODF_FORMDATE_CURRENTDATE_FORMAT, ODF_FORMDATE_CURRENTDATE_LANGUAGE);
-            if (nFormat == NUMBERFORMAT_ENTRY_NOT_FOUND)
-            {
-                sal_Int32 nCheckPos = 0;
-                short nType;
-                OUString sFormat = ODF_FORMDATE_CURRENTDATE_FORMAT;
-                pFormatter->PutEntry(sFormat,
-                                     nCheckPos,
-                                     nType,
-                                     nFormat,
-                                     ODF_FORMDATE_CURRENTDATE_LANGUAGE);
-            }
-
-            if (nFormat != NUMBERFORMAT_ENTRY_NOT_FOUND)
-            {
-                pFormatter->IsNumberFormat(sFormattedDate, nFormat, dCurrentDate);
-                bHasCurrentDate = true;
-            }
-        }
-
-        if (!sDateFormat.isEmpty() && !sLang.isEmpty() && bHasCurrentDate)
-        {
-            sal_uInt32 nFormat = pFormatter->GetEntryKey(sDateFormat, LanguageTag(sLang).getLanguageType());
-            if (nFormat == NUMBERFORMAT_ENTRY_NOT_FOUND)
-            {
-                sal_Int32 nCheckPos = 0;
-                short nType;
-                pFormatter->PutEntry(sDateFormat,
-                                     nCheckPos,
-                                     nType,
-                                     nFormat,
-                                     LanguageTag(sLang).getLanguageType());
-            }
-
-            OUString sOutput;
-            if (nFormat != NUMBERFORMAT_ENTRY_NOT_FOUND)
-            {
-                Color* pCol = nullptr;
-                pFormatter->GetOutputString(dCurrentDate, nFormat, sOutput, &pCol, false);
-            }
-            return sOutput;
-        }
-
-        sal_Unicode vEnSpaces[ODF_FORMFIELD_DEFAULT_LENGTH] = {8194, 8194, 8194, 8194, 8194};
-        return OUString(vEnSpaces, ODF_FORMFIELD_DEFAULT_LENGTH);
-    }
 } }
 
 SwTextPortion *SwTextFormatter::WhichTextPor( SwTextFormatInfo &rInf ) const
@@ -961,17 +889,24 @@ SwTextPortion *SwTextFormatter::WhichTextPor( SwTextFormatInfo &rInf ) const
             // Only at the End!
             // If pCurr does not have a width, it can however already have content.
             // E.g. for non-displayable characters
-            if (rInf.GetText()[rInf.GetIdx()]==CH_TXT_ATR_FIELDSTART)
+            SwTextNode *pNd = rInf.GetTextFrame()->GetTextNode();
+            const SwDoc *doc = pNd->GetDoc();
+            SwIndex aIndex(pNd, rInf.GetIdx());
+            SwPosition aPosition(*pNd, aIndex);
+            sw::mark::IFieldmark *pBM = doc->getIDocumentMarkAccess()->getFieldmarkFor(aPosition);
+            if(pBM != nullptr && pBM->GetFieldname( ) == ODF_FORMDATE)
+            {
+                if (rInf.GetText()[rInf.GetIdx()] == CH_TXT_ATR_FIELDSTART)
+                    pPor = new SwFieldFormDatePortion(pBM, true);
+                else if (rInf.GetText()[rInf.GetIdx()] == CH_TXT_ATR_FIELDEND)
+                    pPor = new SwFieldFormDatePortion(pBM, false);
+            }
+            else if (rInf.GetText()[rInf.GetIdx()] == CH_TXT_ATR_FIELDSTART)
                 pPor = new SwFieldMarkPortion();
             else if (rInf.GetText()[rInf.GetIdx()]==CH_TXT_ATR_FIELDEND)
                 pPor = new SwFieldMarkPortion();
             else if (rInf.GetText()[rInf.GetIdx()]==CH_TXT_ATR_FORMELEMENT)
             {
-                SwTextNode *pNd = rInf.GetTextFrame()->GetTextNode();
-                const SwDoc *doc = pNd->GetDoc();
-                SwIndex aIndex(pNd, rInf.GetIdx());
-                SwPosition aPosition(*pNd, aIndex);
-                sw::mark::IFieldmark *pBM = doc->getIDocumentMarkAccess()->getFieldmarkFor(aPosition);
                 OSL_ENSURE(pBM != nullptr, "Where is my form field bookmark???");
                 if (pBM != nullptr)
                 {
@@ -983,11 +918,6 @@ SwTextPortion *SwTextFormatter::WhichTextPor( SwTextFormatInfo &rInf ) const
                     {
                         pPor = new SwFieldFormDropDownPortion(pBM, sw::mark::ExpandFieldmark(pBM));
                     }
-                    else if (pBM->GetFieldname( ) == ODF_FORMDATE)
-                    {
-                        SvNumberFormatter* pFormatter = const_cast<SvNumberFormatter*>(doc->GetNumberFormatter());
-                        pPor = new SwFieldFormDatePortion(pBM, sw::mark::ExpandDateFieldmark(pBM, pFormatter));
-                    }
                     /* we need to check for ODF_FORMTEXT for scenario having FormFields inside FORMTEXT.
                      * Otherwise file will crash on open.
                      */
diff --git a/sw/source/core/text/porfld.cxx b/sw/source/core/text/porfld.cxx
index af29eaec97fe..c959f0125a6a 100644
--- a/sw/source/core/text/porfld.cxx
+++ b/sw/source/core/text/porfld.cxx
@@ -1332,9 +1332,9 @@ void SwFieldFormDropDownPortion::Paint( const SwTextPaintInfo &rInf ) const
     }
 }
 
-SwFieldPortion *SwFieldFormDatePortion::Clone(const OUString &rExpand) const
+SwFieldPortion *SwFieldFormDatePortion::Clone(const OUString &/*rExpand*/) const
 {
-    return new SwFieldFormDatePortion(m_pFieldMark, rExpand);
+    return new SwFieldFormDatePortion(m_pFieldMark, m_bStart);
 }
 
 void SwFieldFormDatePortion::Paint( const SwTextPaintInfo &rInf ) const
@@ -1346,7 +1346,10 @@ void SwFieldFormDatePortion::Paint( const SwTextPaintInfo &rInf ) const
     {
         SwRect aPaintArea;
         rInf.CalcRect( *this, &aPaintArea );
-        pDateField->SetPortionPaintArea(aPaintArea);
+        if(m_bStart)
+            pDateField->SetPortionPaintAreaStart(aPaintArea);
+        else
+            pDateField->SetPortionPaintAreaEnd(aPaintArea);
     }
 }
 
diff --git a/sw/source/core/text/porfld.hxx b/sw/source/core/text/porfld.hxx
index f16b1b2e7c1c..80bf49347b51 100644
--- a/sw/source/core/text/porfld.hxx
+++ b/sw/source/core/text/porfld.hxx
@@ -243,18 +243,20 @@ private:
 class SwFieldFormDatePortion : public SwFieldPortion
 {
 public:
-    explicit SwFieldFormDatePortion(sw::mark::IFieldmark *pFieldMark, const OUString &rExpand)
-        : SwFieldPortion(rExpand)
+    explicit SwFieldFormDatePortion(sw::mark::IFieldmark *pFieldMark, bool bStart)
+        : SwFieldPortion("")
         , m_pFieldMark(pFieldMark)
+        , m_bStart(bStart)
     {
     }
     // Field cloner for SplitGlue
-    virtual SwFieldPortion *Clone( const OUString &rExpand ) const override;
+    virtual SwFieldPortion *Clone( const OUString &rExpand) const override;
 
     virtual void Paint( const SwTextPaintInfo &rInf ) const override;
 
 private:
     sw::mark::IFieldmark* m_pFieldMark;
+    bool m_bStart;
 };
 
 #endif
diff --git a/sw/source/core/unocore/unobkm.cxx b/sw/source/core/unocore/unobkm.cxx
index ed058fb3ccd6..850add3db92a 100644
--- a/sw/source/core/unocore/unobkm.cxx
+++ b/sw/source/core/unocore/unobkm.cxx
@@ -560,7 +560,7 @@ void SwXFieldmark::setFieldType(const OUString & fieldType)
     {
         if(fieldType == ODF_FORMDROPDOWN || fieldType == ODF_FORMCHECKBOX || fieldType == ODF_FORMDATE)
         {
-            ::sw::mark::IFieldmark* pNewFieldmark = GetIDocumentMarkAccess()->changeNonTextFieldmarkType(pBkm, fieldType);
+            ::sw::mark::IFieldmark* pNewFieldmark = GetIDocumentMarkAccess()->changeFormFieldmarkType(pBkm, fieldType);
             if (pNewFieldmark)
             {
                 registerInMark(*this, pNewFieldmark);
@@ -607,7 +607,7 @@ SwXFieldmark::CreateXFieldmark(SwDoc & rDoc, ::sw::mark::IMark *const pMark,
         else if (dynamic_cast< ::sw::mark::DropDownFieldmark* >(pMark))
             pXBkmk = new SwXFieldmark(true, &rDoc);
         else if (dynamic_cast< ::sw::mark::DateFieldmark* >(pMark))
-            pXBkmk = new SwXFieldmark(true, &rDoc);
+            pXBkmk = new SwXFieldmark(false, &rDoc);
         else
             pXBkmk = new SwXFieldmark(isReplacementObject, &rDoc);
 
diff --git a/sw/source/filter/ww8/docxattributeoutput.cxx b/sw/source/filter/ww8/docxattributeoutput.cxx
index 3c58ae0076c3..91127dcc333a 100644
--- a/sw/source/filter/ww8/docxattributeoutput.cxx
+++ b/sw/source/filter/ww8/docxattributeoutput.cxx
@@ -1660,21 +1660,18 @@ void DocxAttributeOutput::WriteFFData(  const FieldInfos& rInfos )
     }
 }
 
-void DocxAttributeOutput::WriteFormDate(const OUString& sCurrentDate, const OUString& sDateFormat, const OUString& sLang)
+void DocxAttributeOutput::WriteFormDateStart(const OUString& sFullDate, const OUString& sDateFormat, const OUString& sLang)
 {
     m_pSerializer->startElementNS(XML_w, XML_sdt, FSEND);
     m_pSerializer->startElementNS(XML_w, XML_sdtPr, FSEND);
 
-    if (!sCurrentDate.isEmpty())
-    {
-        OString sDate = sCurrentDate.toUtf8() + "T00:00:00Z";
-        m_pSerializer->startElementNS(XML_w, XML_date, FSNS(XML_w, XML_fullDate), sDate, FSEND);
-    }
+    if(!sFullDate.isEmpty())
+        m_pSerializer->startElementNS(XML_w, XML_date, FSNS(XML_w, XML_fullDate), sFullDate.toUtf8(), FSEND);
     else
         m_pSerializer->startElementNS(XML_w, XML_date, FSEND);
 
-    OString sUTF8DateFormat = sDateFormat.toUtf8();
     // Replace quotation mark used for marking static strings in date format
+    OString sUTF8DateFormat = sDateFormat.toUtf8();
     sUTF8DateFormat = sUTF8DateFormat.replaceAll("\"", "'");
     m_pSerializer->singleElementNS(XML_w, XML_dateFormat,
                                    FSNS(XML_w, XML_val), sUTF8DateFormat, FSEND);
@@ -1689,58 +1686,11 @@ void DocxAttributeOutput::WriteFormDate(const OUString& sCurrentDate, const OUSt
     m_pSerializer->endElementNS(XML_w, XML_sdtPr);
 
     m_pSerializer->startElementNS(XML_w, XML_sdtContent, FSEND);
-    m_pSerializer->startElementNS(XML_w, XML_r, FSEND);
-
-    // Convert the current date to the right format
-    if (!sCurrentDate.isEmpty())
-    {
-        SvNumberFormatter* pFormatter = m_rExport.m_pDoc->GetNumberFormatter();
-        double dCurrentDate = 0.0;
-        // First get the date internal double representation
-        sal_uInt32 nFormat = pFormatter->GetEntryKey(ODF_FORMDATE_CURRENTDATE_FORMAT, ODF_FORMDATE_CURRENTDATE_LANGUAGE);
-        if (nFormat == NUMBERFORMAT_ENTRY_NOT_FOUND)
-        {
-            sal_Int32 nCheckPos = 0;
-            short nType;
-            OUString sFormat = ODF_FORMDATE_CURRENTDATE_FORMAT;
-            pFormatter->PutEntry(sFormat,
-                                 nCheckPos,
-                                 nType,
-                                 nFormat,
-                                 ODF_FORMDATE_CURRENTDATE_LANGUAGE);
-        }
-        if (nFormat != NUMBERFORMAT_ENTRY_NOT_FOUND)
-        {
-            pFormatter->IsNumberFormat(sCurrentDate, nFormat, dCurrentDate);
-        }
-
-        // Then convert the date to a fromatter string
-        nFormat = pFormatter->GetEntryKey(sDateFormat, LanguageTag(sLang).getLanguageType());
-        if (nFormat == NUMBERFORMAT_ENTRY_NOT_FOUND)
-        {
-            sal_Int32 nCheckPos = 0;
-            short nType;
-            OUString sNonConstDateFormat = sDateFormat;
-            pFormatter->PutEntry(sNonConstDateFormat,
-                                 nCheckPos,
-                                 nType,
-                                 nFormat,
-                                 LanguageTag(sLang).getLanguageType());
-        }
-
-        OUString sOutput;
-        if (nFormat != NUMBERFORMAT_ENTRY_NOT_FOUND)
-        {
-            Color* pCol = nullptr;
-            pFormatter->GetOutputString(dCurrentDate, nFormat, sOutput, &pCol, false);
-        }
-
-        RunText(sOutput);
-    }
+}
 
-    m_pSerializer->endElementNS(XML_w, XML_r);
+void DocxAttributeOutput::WriteFormDateEnd()
+{
     m_pSerializer->endElementNS(XML_w, XML_sdtContent);
-
     m_pSerializer->endElementNS(XML_w, XML_sdt);
 }
 
@@ -1753,17 +1703,31 @@ void DocxAttributeOutput::StartField_Impl( const SwTextNode* pNode, sal_Int32 nP
     }
     else if ( rInfos.eType == ww::eFORMDATE )
     {
-        const ::sw::mark::IFieldmark& rFieldmark = *rInfos.pFieldmark;
-        FieldMarkParamsHelper params( rFieldmark );
+        const sw::mark::IDateFieldmark* const pFieldmark = dynamic_cast<const sw::mark::IDateFieldmark* const>(rInfos.pFieldmark);
+        FieldMarkParamsHelper params( *pFieldmark );
 
+        OUString sFullDate;
         OUString sCurrentDate;
         params.extractParam( ODF_FORMDATE_CURRENTDATE, sCurrentDate );
+        if(!sCurrentDate.isEmpty())
+        {
+            sFullDate = sCurrentDate + "T00:00:00Z";
+        }
+        else
+        {
+            std::pair<bool, double> aResult = pFieldmark->GetCurrentDate();
+            if(aResult.first)
+            {
+                sFullDate = pFieldmark->GetDateInStandardDateFormat(aResult.second) + "T00:00:00Z";
+            }
+        }
+
         OUString sDateFormat;
         params.extractParam( ODF_FORMDATE_DATEFORMAT, sDateFormat );
         OUString sLang;
         params.extractParam( ODF_FORMDATE_DATEFORMAT_LANGUAGE, sLang );
 
-        WriteFormDate( sCurrentDate, sDateFormat, sLang );
+        WriteFormDateStart( sFullDate, sDateFormat, sLang );
     }
     else if ( rInfos.eType != ww::eNONE ) // HYPERLINK fields are just commands
     {
@@ -1995,6 +1959,12 @@ void DocxAttributeOutput::DoWriteFieldRunProperties( const SwTextNode * pNode, s
 
 void DocxAttributeOutput::EndField_Impl( const SwTextNode* pNode, sal_Int32 nPos, FieldInfos& rInfos )
 {
+    if ( rInfos.eType == ww::eFORMDATE )
+    {
+        WriteFormDateEnd();
+        return;
+    }
+
     // The command has to be written before for the hyperlinks
     if ( rInfos.pField )
     {
diff --git a/sw/source/filter/ww8/docxattributeoutput.hxx b/sw/source/filter/ww8/docxattributeoutput.hxx
index ad5b94f0b6c6..ed3c79634605 100644
--- a/sw/source/filter/ww8/docxattributeoutput.hxx
+++ b/sw/source/filter/ww8/docxattributeoutput.hxx
@@ -715,7 +715,8 @@ private:
     /// Closes a currently open SDT block.
     void EndSdtBlock();
 
-    void WriteFormDate(const OUString& sCurrentDate, const OUString& sDateFormat, const OUString& sLang);
+    void WriteFormDateStart(const OUString& sFullDate, const OUString& sDateFormat, const OUString& sLang);
+    void WriteFormDateEnd();
 
     void StartField_Impl( const SwTextNode* pNode, sal_Int32 nPos, FieldInfos const & rInfos, bool bWriteRun = false );
     void DoWriteCmd( const OUString& rCmd );
diff --git a/sw/source/filter/ww8/docxexport.cxx b/sw/source/filter/ww8/docxexport.cxx
index ccfce360f49c..0ddb40dfd1f3 100644
--- a/sw/source/filter/ww8/docxexport.cxx
+++ b/sw/source/filter/ww8/docxexport.cxx
@@ -159,6 +159,9 @@ void DocxExport::AppendBookmarks( const SwTextNode& rNode, sal_Int32 nAktPos, sa
             const sal_Int32 nStart = pMark->GetMarkStart().nContent.GetIndex();
             const sal_Int32 nEnd = pMark->GetMarkEnd().nContent.GetIndex();
 
+            if (dynamic_cast<sw::mark::IDateFieldmark*>(pMark))
+                continue;
+
             if ( nStart == nAktPos )
                 aStarts.push_back( pMark->GetName() );
 
diff --git a/sw/source/filter/ww8/wrtw8nds.cxx b/sw/source/filter/ww8/wrtw8nds.cxx
index cdc1da93f6fe..c1c9de724f6d 100644
--- a/sw/source/filter/ww8/wrtw8nds.cxx
+++ b/sw/source/filter/ww8/wrtw8nds.cxx
@@ -2436,49 +2436,64 @@ void MSWordExportBase::OutputTextNode( SwTextNode& rNode )
                     ::sw::mark::IFieldmark const * const pFieldmark = pMarkAccess->getFieldmarkFor( aPosition );
                     OSL_ENSURE( pFieldmark, "Looks like this doc is broken...; where is the Fieldmark for the FIELDSTART??" );
 
-                    if ( pFieldmark && pFieldmark->GetFieldname() == ODF_FORMTEXT
-                         && GetExportFormat() != MSWordExportBase::ExportFormat::DOCX )
+                    // Date field is exported as content control, not as a simple field
+                    if(pFieldmark && pFieldmark->GetFieldname( ) == ODF_FORMDATE)
                     {
-                       AppendBookmark( pFieldmark->GetName() );
+                        if(GetExportFormat() == MSWordExportBase::ExportFormat::DOCX) // supported by DOCX only
+                        {
+                            OutputField( nullptr, lcl_getFieldId( pFieldmark ),
+                                    lcl_getFieldCode( pFieldmark ),
+                                    FieldFlags::Start | FieldFlags::CmdStart );
+                            WriteFormData( *pFieldmark );
+                        }
                     }
-                    ww::eField eFieldId = lcl_getFieldId( pFieldmark );
-                    OUString sCode = lcl_getFieldCode( pFieldmark );
-                    if ( pFieldmark && pFieldmark->GetFieldname() == ODF_UNHANDLED )
+                    else
                     {
-                        IFieldmark::parameter_map_t::const_iterator it = pFieldmark->GetParameters()->find( ODF_ID_PARAM );
-                        if ( it != pFieldmark->GetParameters()->end() )
+
+                        if ( pFieldmark && pFieldmark->GetFieldname() == ODF_FORMTEXT
+                             && GetExportFormat() != MSWordExportBase::ExportFormat::DOCX )
                         {
-                            OUString sFieldId;
-                            it->second >>= sFieldId;
-                            eFieldId = (ww::eField)sFieldId.toInt32();
+                            AppendBookmark( pFieldmark->GetName() );
                         }
-
-                        it = pFieldmark->GetParameters()->find( ODF_CODE_PARAM );
-                        if ( it != pFieldmark->GetParameters()->end() )
+                        ww::eField eFieldId = lcl_getFieldId( pFieldmark );
+                        OUString sCode = lcl_getFieldCode( pFieldmark );
+                        if ( pFieldmark && pFieldmark->GetFieldname() == ODF_UNHANDLED )
                         {
-                            it->second >>= sCode;
+                            IFieldmark::parameter_map_t::const_iterator it = pFieldmark->GetParameters()->find( ODF_ID_PARAM );
+                            if ( it != pFieldmark->GetParameters()->end() )
+                            {
+                                OUString sFieldId;
+                                it->second >>= sFieldId;
+                                eFieldId = static_cast<ww::eField>(sFieldId.toInt32());
+                            }
+
+                            it = pFieldmark->GetParameters()->find( ODF_CODE_PARAM );
+                            if ( it != pFieldmark->GetParameters()->end() )
+                            {
+                                it->second >>= sCode;
+                            }
                         }
-                    }
 
-                    OutputField( nullptr, eFieldId, sCode, FieldFlags::Start | FieldFlags::CmdStart );
+                        OutputField( nullptr, eFieldId, sCode, FieldFlags::Start | FieldFlags::CmdStart );
 
-                    if ( pFieldmark && pFieldmark->GetFieldname( ) == ODF_FORMTEXT )
-                        WriteFormData( *pFieldmark );
-                    else if ( pFieldmark && pFieldmark->GetFieldname( ) == ODF_HYPERLINK )
-                        WriteHyperlinkData( *pFieldmark );
-                    OutputField( nullptr, lcl_getFieldId( pFieldmark ), OUString(), FieldFlags::CmdEnd );
+                        if ( pFieldmark && pFieldmark->GetFieldname( ) == ODF_FORMTEXT)
+                            WriteFormData( *pFieldmark );
+                        else if ( pFieldmark && pFieldmark->GetFieldname( ) == ODF_HYPERLINK )
+                            WriteHyperlinkData( *pFieldmark );
+                        OutputField( nullptr, lcl_getFieldId( pFieldmark ), OUString(), FieldFlags::CmdEnd );
 
-                    if ( pFieldmark && pFieldmark->GetFieldname() == ODF_UNHANDLED )
-                    {
-                        // Check for the presence of a linked OLE object
-                        IFieldmark::parameter_map_t::const_iterator it = pFieldmark->GetParameters()->find( ODF_OLE_PARAM );
-                        if ( it != pFieldmark->GetParameters()->end() )
+                        if ( pFieldmark && pFieldmark->GetFieldname() == ODF_UNHANDLED )
                         {
-                            OUString sOleId;
-                            uno::Any aValue = it->second;
-                            aValue >>= sOleId;
-                            if ( !sOleId.isEmpty() )
-                                OutputLinkedOLE( sOleId );
+                            // Check for the presence of a linked OLE object
+                            IFieldmark::parameter_map_t::const_iterator it = pFieldmark->GetParameters()->find( ODF_OLE_PARAM );
+                            if ( it != pFieldmark->GetParameters()->end() )
+                            {
+                                OUString sOleId;
+                                uno::Any aValue = it->second;
+                                aValue >>= sOleId;
+                                if ( !sOleId.isEmpty() )
+                                    OutputLinkedOLE( sOleId );
+                            }
                         }
                     }
                 }
@@ -2489,24 +2504,34 @@ void MSWordExportBase::OutputTextNode( SwTextNode& rNode )
 
                     OSL_ENSURE( pFieldmark, "Looks like this doc is broken...; where is the Fieldmark for the FIELDEND??" );
 
-                    ww::eField eFieldId = lcl_getFieldId( pFieldmark );
-                    if ( pFieldmark && pFieldmark->GetFieldname() == ODF_UNHANDLED )
+                    if(pFieldmark && pFieldmark->GetFieldname( ) == ODF_FORMDATE)
                     {
-                        IFieldmark::parameter_map_t::const_iterator it = pFieldmark->GetParameters()->find( ODF_ID_PARAM );
-                        if ( it != pFieldmark->GetParameters()->end() )
+                        if(GetExportFormat() == MSWordExportBase::ExportFormat::DOCX) // supported by DOCX only
                         {
-                            OUString sFieldId;
-                            it->second >>= sFieldId;
-                            eFieldId = (ww::eField)sFieldId.toInt32();
+                            OutputField( nullptr, ww::eFORMDATE, OUString(), FieldFlags::Close );
                         }
                     }
+                    else
+                    {
+                        ww::eField eFieldId = lcl_getFieldId( pFieldmark );
+                        if ( pFieldmark && pFieldmark->GetFieldname() == ODF_UNHANDLED )
+                        {
+                            IFieldmark::parameter_map_t::const_iterator it = pFieldmark->GetParameters()->find( ODF_ID_PARAM );
+                            if ( it != pFieldmark->GetParameters()->end() )
+                            {
+                                OUString sFieldId;
+                                it->second >>= sFieldId;
+                                eFieldId = static_cast<ww::eField>(sFieldId.toInt32());
+                            }
+                        }
 
-                    OutputField( nullptr, eFieldId, OUString(), FieldFlags::Close );
+                        OutputField( nullptr, eFieldId, OUString(), FieldFlags::Close );
 
-                    if ( pFieldmark && pFieldmark->GetFieldname() == ODF_FORMTEXT
-                         && GetExportFormat() != MSWordExportBase::ExportFormat::DOCX )
-                    {
-                        AppendBookmark( pFieldmark->GetName() );
+                        if ( pFieldmark && pFieldmark->GetFieldname() == ODF_FORMTEXT
+                             && GetExportFormat() != MSWordExportBase::ExportFormat::DOCX )
+                        {
+                            AppendBookmark( pFieldmark->GetName() );
+                        }
                     }
                 }
                 else if ( ch == CH_TXT_ATR_FORMELEMENT )
@@ -2514,30 +2539,18 @@ void MSWordExportBase::OutputTextNode( SwTextNode& rNode )
                     SwPosition aPosition( rNode, SwIndex( &rNode, nAktPos ) );
                     ::sw::mark::IFieldmark const * const pFieldmark = pMarkAccess->getFieldmarkFor( aPosition );
 
-                    // Date field is exported as content control, not as a simple field
-                    if(pFieldmark && pFieldmark->GetFieldname( ) == ODF_FORMDATE &&
-                       GetExportFormat() == MSWordExportBase::ExportFormat::DOCX) // supported by DOCX only
-                    {
-                        OutputField( nullptr, lcl_getFieldId( pFieldmark ),
-                                lcl_getFieldCode( pFieldmark ),
-                                FieldFlags::Start | FieldFlags::CmdStart );
+                    bool isDropdownOrCheckbox = pFieldmark && (pFieldmark->GetFieldname( ) == ODF_FORMDROPDOWN ||
+                                                                pFieldmark->GetFieldname( ) == ODF_FORMCHECKBOX );
+                    if ( isDropdownOrCheckbox )
+                        AppendBookmark( pFieldmark->GetName() );
+                    OutputField( nullptr, lcl_getFieldId( pFieldmark ),
+                            lcl_getFieldCode( pFieldmark ),
+                            FieldFlags::Start | FieldFlags::CmdStart );
+                    if ( isDropdownOrCheckbox )
                         WriteFormData( *pFieldmark );
-                    }
-                    else
-                    {
-                        bool isDropdownOrCheckbox = pFieldmark && (pFieldmark->GetFieldname( ) == ODF_FORMDROPDOWN ||
-                                                                    pFieldmark->GetFieldname( ) == ODF_FORMCHECKBOX );
-                        if ( isDropdownOrCheckbox )
-                            AppendBookmark( pFieldmark->GetName() );
-                        OutputField( nullptr, lcl_getFieldId( pFieldmark ),
-                                lcl_getFieldCode( pFieldmark ),
-                                FieldFlags::Start | FieldFlags::CmdStart );
-                        if ( isDropdownOrCheckbox )
-                            WriteFormData( *pFieldmark );
-                        OutputField( nullptr, lcl_getFieldId( pFieldmark ), OUString(), FieldFlags::Close );
-                        if ( isDropdownOrCheckbox )
-                            AppendBookmark( pFieldmark->GetName() );
-                    }
+                    OutputField( nullptr, lcl_getFieldId( pFieldmark ), OUString(), FieldFlags::Close );
+                    if ( isDropdownOrCheckbox )
+                        AppendBookmark( pFieldmark->GetName() );
                 }
                 nLen -= ofs;
 
diff --git a/sw/source/ui/dialog/swdlgfact.cxx b/sw/source/ui/dialog/swdlgfact.cxx
index 08221eb9d7e8..367255f80478 100644
--- a/sw/source/ui/dialog/swdlgfact.cxx
+++ b/sw/source/ui/dialog/swdlgfact.cxx
@@ -783,7 +783,7 @@ VclPtr<VclAbstractDialog> SwAbstractDialogFactory_Impl::CreateDropDownFormFieldD
     return VclPtr<VclAbstractDialog_Impl>::Create( pDlg );
 }
 
-VclPtr<VclAbstractDialog> SwAbstractDialogFactory_Impl::CreateDateFormFieldDialog(sw::mark::IFieldmark* pDateField, SwDoc* pDoc)
+VclPtr<VclAbstractDialog> SwAbstractDialogFactory_Impl::CreateDateFormFieldDialog(sw::mark::IDateFieldmark* pDateField, SwDoc* pDoc)
 {
     VclPtr<sw::DateFormFieldDialog> pDlg = VclPtr<sw::DateFormFieldDialog>::Create(nullptr, pDateField, pDoc);
     return VclPtr<VclAbstractDialog_Impl>::Create( pDlg );
diff --git a/sw/source/ui/dialog/swdlgfact.hxx b/sw/source/ui/dialog/swdlgfact.hxx
index f86653e3204d..b2b0bec1d8d1 100644
--- a/sw/source/ui/dialog/swdlgfact.hxx
+++ b/sw/source/ui/dialog/swdlgfact.hxx
@@ -415,8 +415,9 @@ public:
 
     virtual VclPtr<AbstractDropDownFieldDialog> CreateDropDownFieldDialog(SwWrtShell &rSh,
         SwField* pField, bool bPrevButton, bool bNextButton) override;
+
     virtual VclPtr<VclAbstractDialog> CreateDropDownFormFieldDialog(sw::mark::IFieldmark* pDropDownField) override;
-    virtual VclPtr<VclAbstractDialog> CreateDateFormFieldDialog(sw::mark::IFieldmark* pDateField, SwDoc* pDoc) override;
+    virtual VclPtr<VclAbstractDialog> CreateDateFormFieldDialog(sw::mark::IDateFieldmark* pDateField, SwDoc* pDoc) override;
     virtual VclPtr<SfxAbstractTabDialog> CreateSwEnvDlg ( vcl::Window* pParent, const SfxItemSet& rSet, SwWrtShell* pWrtSh, Printer* pPrt, bool bInsert ) override;
     virtual VclPtr<AbstractSwLabDlg> CreateSwLabDlg(const SfxItemSet& rSet,
                                                      SwDBManager* pDBManager, bool bLabel) override;
diff --git a/sw/source/ui/fldui/DateFormFieldDialog.cxx b/sw/source/ui/fldui/DateFormFieldDialog.cxx
index 45c607b0084c..c0c3dbe59199 100644
--- a/sw/source/ui/fldui/DateFormFieldDialog.cxx
+++ b/sw/source/ui/fldui/DateFormFieldDialog.cxx
@@ -18,7 +18,7 @@
 
 namespace sw
 {
-DateFormFieldDialog::DateFormFieldDialog(vcl::Window* pParent, mark::IFieldmark* pDateField,
+DateFormFieldDialog::DateFormFieldDialog(vcl::Window* pParent, mark::IDateFieldmark* pDateField,
                                          SwDoc* pDoc)
     : SvxStandardDialog(pParent, "DateFormFieldDialog", "modules/swriter/ui/dateformfielddialog.ui")
     , m_pDateField(pDateField)
@@ -46,12 +46,28 @@ void DateFormFieldDialog::Apply()
 {
     if (m_pDateField != nullptr)
     {
-        const SvNumberformat* pFormat = m_pNumberFormatter->GetEntry(m_xFormatLB->GetFormat());
+        // Try to find out the current date value and replace the content
+        // with the right formatted date string
         sw::mark::IFieldmark::parameter_map_t* pParameters = m_pDateField->GetParameters();
+        const SvNumberformat* pFormat = m_pNumberFormatter->GetEntry(m_xFormatLB->GetFormat());
+
+        // Get date value first
+        std::pair<bool, double> aResult = m_pDateField->GetCurrentDate();
+
+        // Then set the date format
         (*pParameters)[ODF_FORMDATE_DATEFORMAT] <<= pFormat->GetFormatstring();
+        (*pParameters)[ODF_FORMDATE_DATEFORMAT_LANGUAGE]
+            <<= LanguageTag(pFormat->GetLanguage()).getBcp47();
 
-        LanguageType aLang = pFormat->GetLanguage();
-        (*pParameters)[ODF_FORMDATE_DATEFORMAT_LANGUAGE] <<= LanguageTag(aLang).getBcp47();
+        // Update current date
+        if (aResult.first)
+        {
+            m_pDateField->SetCurrentDate(aResult.second);
+        }
+        else
+        {
+            (*pParameters)[ODF_FORMDATE_CURRENTDATE] <<= OUString();
+        }
     }
 }
 
@@ -78,16 +94,16 @@ void DateFormFieldDialog::InitControls()
         if (!sFormatString.isEmpty() && !sLang.isEmpty())
         {
             LanguageType aLangType = LanguageTag(sLang).getLanguageType();
-            sal_uInt32 nFormatKey = m_pNumberFormatter->GetEntryKey(sFormatString, aLangType);
-            if (nFormatKey == NUMBERFORMAT_ENTRY_NOT_FOUND)
+            sal_uInt32 nFormat = m_pNumberFormatter->GetEntryKey(sFormatString, aLangType);
+            if (nFormat == NUMBERFORMAT_ENTRY_NOT_FOUND)
             {
                 sal_Int32 nCheckPos = 0;
                 short nType;
-                m_pNumberFormatter->PutEntry(sFormatString, nCheckPos, nType, nFormatKey,
+                m_pNumberFormatter->PutEntry(sFormatString, nCheckPos, nType, nFormat,
                                              LanguageTag(sLang).getLanguageType());
             }
 
-            if (aLangType != LANGUAGE_DONTKNOW && nFormatKey != NUMBERFORMAT_ENTRY_NOT_FOUND)
+            if (aLangType != LANGUAGE_DONTKNOW && nFormat != NUMBERFORMAT_ENTRY_NOT_FOUND)
             {
                 if (m_xFormatLB->GetCurLanguage() == aLangType)
                 {
@@ -102,7 +118,7 @@ void DateFormFieldDialog::InitControls()
                     m_xFormatLB->SetFormatType(css::util::NumberFormat::ALL);
                     m_xFormatLB->SetFormatType(css::util::NumberFormat::DATE);
                 }
-                m_xFormatLB->SetDefFormat(nFormatKey);
+                m_xFormatLB->SetDefFormat(nFormat);
             }
         }
     }
diff --git a/sw/source/uibase/inc/DateFormFieldDialog.hxx b/sw/source/uibase/inc/DateFormFieldDialog.hxx
index b62cb0009865..9e73f6604c97 100644
--- a/sw/source/uibase/inc/DateFormFieldDialog.hxx
+++ b/sw/source/uibase/inc/DateFormFieldDialog.hxx
@@ -21,7 +21,7 @@ namespace sw
 {
 namespace mark
 {
-class IFieldmark;
+class IDateFieldmark;
 }
 } // namespace sw
 
@@ -31,7 +31,7 @@ namespace sw
 class DateFormFieldDialog : public SvxStandardDialog
 {
 private:
-    mark::IFieldmark* m_pDateField;
+    sw::mark::IDateFieldmark* m_pDateField;
     SvNumberFormatter* m_pNumberFormatter;
 
     VclPtr<NumFormatListBox> m_xFormatLB;
@@ -40,7 +40,7 @@ private:
     void InitControls();
 
 public:
-    DateFormFieldDialog(vcl::Window* pParent, mark::IFieldmark* pDateField, SwDoc* pDoc);
+    DateFormFieldDialog(vcl::Window* pParent, sw::mark::IDateFieldmark* pDateField, SwDoc* pDoc);
     virtual ~DateFormFieldDialog() override;
     virtual void dispose() override;
 };
diff --git a/sw/source/uibase/shells/textfld.cxx b/sw/source/uibase/shells/textfld.cxx
index be599349a86f..8af1da077698 100644
--- a/sw/source/uibase/shells/textfld.cxx
+++ b/sw/source/uibase/shells/textfld.cxx
@@ -733,17 +733,25 @@ FIELD_INSERT:
             SwPaM* pCursorPos = rSh.GetCursor();
             if(pCursorPos)
             {
-                IDocumentMarkAccess* pMarksAccess = rSh.GetDoc()->getIDocumentMarkAccess();
-                sw::mark::IFieldmark* pFieldBM = pMarksAccess->makeNoTextFieldBookmark(*pCursorPos, OUString(), ODF_FORMDATE);
-
-                // Use a default date format and language
-                sw::mark::IFieldmark::parameter_map_t* pParameters = pFieldBM->GetParameters();
-                SvNumberFormatter* pFormatter = rSh.GetDoc()->GetNumberFormatter();
-                sal_uInt32 nStandardFormat = pFormatter->GetStandardFormat(css::util::NumberFormat::DATE);
-                const SvNumberformat* pFormat = pFormatter->GetEntry(nStandardFormat);
-
-                (*pParameters)[ODF_FORMDATE_DATEFORMAT] <<= pFormat->GetFormatstring();
-                (*pParameters)[ODF_FORMDATE_DATEFORMAT_LANGUAGE] <<= LanguageTag(pFormat->GetLanguage()).getBcp47();
+                // Insert five enspaces into the text field so the field has extent
+                sal_Unicode vEnSpaces[ODF_FORMFIELD_DEFAULT_LENGTH] = {8194, 8194, 8194, 8194, 8194};
+                bool bSuccess = rSh.GetDoc()->getIDocumentContentOperations().InsertString(*pCursorPos, OUString(vEnSpaces, ODF_FORMFIELD_DEFAULT_LENGTH));
+                if(bSuccess)
+                {
+                    IDocumentMarkAccess* pMarksAccess = rSh.GetDoc()->getIDocumentMarkAccess();
+                    SwPaM aFieldPam(pCursorPos->GetPoint()->nNode, pCursorPos->GetPoint()->nContent.GetIndex()-5,
+                                    pCursorPos->GetPoint()->nNode, pCursorPos->GetPoint()->nContent.GetIndex());
+                    sw::mark::IFieldmark* pFieldBM = pMarksAccess->makeFieldBookmark(aFieldPam, OUString(), ODF_FORMDATE);
+
+                    // Use a default date format and language
+                    sw::mark::IFieldmark::parameter_map_t* pParameters = pFieldBM->GetParameters();
+                    SvNumberFormatter* pFormatter = rSh.GetDoc()->GetNumberFormatter();
+                    sal_uInt32 nStandardFormat = pFormatter->GetStandardFormat(css::util::NumberFormat::DATE);
+                    const SvNumberformat* pFormat = pFormatter->GetEntry(nStandardFormat);
+
+                    (*pParameters)[ODF_FORMDATE_DATEFORMAT] <<= pFormat->GetFormatstring();
+                    (*pParameters)[ODF_FORMDATE_DATEFORMAT_LANGUAGE] <<= LanguageTag(pFormat->GetLanguage()).getBcp47();
+                }
             }
 
             rSh.GetDoc()->GetIDocumentUndoRedo().EndUndo(SwUndoId::INSERT_FORM_FIELD, nullptr);
diff --git a/sw/source/uibase/shells/textsh1.cxx b/sw/source/uibase/shells/textsh1.cxx
index 28f59f61e9f7..ce9599b82334 100644
--- a/sw/source/uibase/shells/textsh1.cxx
+++ b/sw/source/uibase/shells/textsh1.cxx
@@ -1414,7 +1414,8 @@ void SwTextShell::Execute(SfxRequest &rReq)
         else if ( pFieldBM && pFieldBM->GetFieldname() == ODF_FORMDATE )
         {
             SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
-            ScopedVclPtr<VclAbstractDialog> pDlg(pFact->CreateDateFormFieldDialog(pFieldBM, GetView().GetDocShell()->GetDoc()));
+            sw::mark::DateFieldmark* pDateField = dynamic_cast<sw::mark::DateFieldmark*>(pFieldBM);
+            ScopedVclPtr<VclAbstractDialog> pDlg(pFact->CreateDateFormFieldDialog(pDateField, GetView().GetDocShell()->GetDoc()));
             if (pDlg->Execute() == RET_OK)
             {
                 pFieldBM->Invalidate();