loplugin:ostr in lotuswordpro

Change-Id: Ifea660ab9e0663312f9013670c27d3feda314d81 Reviewed-on: https://gerrit.libreoffice.org/c/core/+/167427 Tested-by: Jenkins Reviewed-by: Noel Grandin <noel.grandin@collabora.co.uk>
author: Noel Grandin <noel.grandin@collabora.co.uk> 2024-05-10 08:25:57 +0200
committer: Noel Grandin <noel.grandin@collabora.co.uk> 2024-05-10 09:51:45 +0200
commit: e00f6e0b9df5ef8629738b551def2464d9a8e2ed (patch)
tree: 88c2e2c173a35f18aeebb6dbc6a6fcced81c98e7
parent: 239ceb315521d9e88fb8290ba391c70a53095af4 (diff)
99 files changed, 1364 insertions, 1363 deletions
diff --git a/lotuswordpro/inc/xfilter/xfannotation.hxx b/lotuswordpro/inc/xfilter/xfannotation.hxx
index 080dc92fd4ea..e8773974e013 100644
--- a/lotuswordpro/inc/xfilter/xfannotation.hxx
+++ b/lotuswordpro/inc/xfilter/xfannotation.hxx
@@ -88,14 +88,14 @@ inline void XFAnnotation::ToXml(IXFStream* pStrm)
     pAttrList->Clear();
 
     if (!m_strDate.isEmpty())
-        pAttrList->AddAttribute("office:create-date", m_strDate);
+        pAttrList->AddAttribute(u"office:create-date"_ustr, m_strDate);
     if (!m_strAuthor.isEmpty())
-        pAttrList->AddAttribute("office:author", m_strAuthor);
-    pStrm->StartElement("office:annotation");
+        pAttrList->AddAttribute(u"office:author"_ustr, m_strAuthor);
+    pStrm->StartElement(u"office:annotation"_ustr);
 
     XFContentContainer::ToXml(pStrm);
 
-    pStrm->EndElement("office:annotation");
+    pStrm->EndElement(u"office:annotation"_ustr);
 }
 
 #endif
diff --git a/lotuswordpro/inc/xfilter/xfarrowstyle.hxx b/lotuswordpro/inc/xfilter/xfarrowstyle.hxx
index 26a2372fa54a..1a7fbc324e64 100644
--- a/lotuswordpro/inc/xfilter/xfarrowstyle.hxx
+++ b/lotuswordpro/inc/xfilter/xfarrowstyle.hxx
@@ -101,14 +101,14 @@ inline void XFArrowStyle::ToXml(IXFStream* pStrm)
     pAttrList->Clear();
 
     if (!m_strName.isEmpty())
-        pAttrList->AddAttribute("draw:name", m_strName);
+        pAttrList->AddAttribute(u"draw:name"_ustr, m_strName);
     else
-        pAttrList->AddAttribute("draw:name", GetStyleName());
+        pAttrList->AddAttribute(u"draw:name"_ustr, GetStyleName());
 
-    pAttrList->AddAttribute("svg:viewBox", m_strViewBox);
-    pAttrList->AddAttribute("svg:d", m_strPath);
-    pStrm->StartElement("draw:marker");
-    pStrm->EndElement("draw:marker");
+    pAttrList->AddAttribute(u"svg:viewBox"_ustr, m_strViewBox);
+    pAttrList->AddAttribute(u"svg:d"_ustr, m_strPath);
+    pStrm->StartElement(u"draw:marker"_ustr);
+    pStrm->EndElement(u"draw:marker"_ustr);
 }
 
 #endif
diff --git a/lotuswordpro/inc/xfilter/xfbookmark.hxx b/lotuswordpro/inc/xfilter/xfbookmark.hxx
index 1dd473f94c44..c67e5b9645b2 100644
--- a/lotuswordpro/inc/xfilter/xfbookmark.hxx
+++ b/lotuswordpro/inc/xfilter/xfbookmark.hxx
@@ -96,16 +96,16 @@ public:
         IXFAttrList *pAttrList = pStrm->GetAttrList();
         pAttrList->Clear();
 
-        pAttrList->AddAttribute( "text:name", m_strName );
+        pAttrList->AddAttribute( u"text:name"_ustr, m_strName );
         if( m_bStart )
         {
-            pStrm->StartElement( "text:bookmark-start" );
-            pStrm->EndElement( "text:bookmark-start" );
+            pStrm->StartElement( u"text:bookmark-start"_ustr );
+            pStrm->EndElement( u"text:bookmark-start"_ustr );
         }
         else
         {
-            pStrm->StartElement( "text:bookmark-end" );
-            pStrm->EndElement( "text:bookmark-end" );
+            pStrm->StartElement( u"text:bookmark-end"_ustr );
+            pStrm->EndElement( u"text:bookmark-end"_ustr );
         }
     }
 
diff --git a/lotuswordpro/inc/xfilter/xfbreaks.hxx b/lotuswordpro/inc/xfilter/xfbreaks.hxx
index fe2d7cee19d1..550487e7f86a 100644
--- a/lotuswordpro/inc/xfilter/xfbreaks.hxx
+++ b/lotuswordpro/inc/xfilter/xfbreaks.hxx
@@ -105,19 +105,19 @@ inline void XFBreaks::ToXml(IXFStream *pStrm)
     case enumXFBreakAuto:
         break;
     case enumXFBreakBefPage:
-        pAttrList->AddAttribute( "fo:break-before", "page" );
+        pAttrList->AddAttribute( u"fo:break-before"_ustr, u"page"_ustr );
         break;
     case enumXFBreakBefColumn:
-        pAttrList->AddAttribute( "fo:break-before", "column" );
+        pAttrList->AddAttribute( u"fo:break-before"_ustr, u"column"_ustr );
         break;
     case enumXFBreakAftPage:
-        pAttrList->AddAttribute( "fo:break-after", "page" );
+        pAttrList->AddAttribute( u"fo:break-after"_ustr, u"page"_ustr );
         break;
     case enumXFBreakAftColumn:
-        pAttrList->AddAttribute( "fo:break-after", "column" );
+        pAttrList->AddAttribute( u"fo:break-after"_ustr, u"column"_ustr );
         break;
     case enumXFBreakKeepWithNext:
-        pAttrList->AddAttribute( "fo:keep-with-next", "true" );
+        pAttrList->AddAttribute( u"fo:keep-with-next"_ustr, u"true"_ustr );
         break;
     }
 }
diff --git a/lotuswordpro/inc/xfilter/xfdrawgroup.hxx b/lotuswordpro/inc/xfilter/xfdrawgroup.hxx
index b5e1f367c837..a7ee54ff5749 100644
--- a/lotuswordpro/inc/xfilter/xfdrawgroup.hxx
+++ b/lotuswordpro/inc/xfilter/xfdrawgroup.hxx
@@ -107,11 +107,11 @@ inline void XFDrawGroup::ToXml(IXFStream* pStrm)
     pAttrList->Clear();
     XFDrawObject::ToXml(pStrm);
 
-    pStrm->StartElement("draw:g");
+    pStrm->StartElement(u"draw:g"_ustr);
 
     m_aChildren->ToXml(pStrm);
 
-    pStrm->EndElement("draw:g");
+    pStrm->EndElement(u"draw:g"_ustr);
 }
 
 #endif
diff --git a/lotuswordpro/inc/xfilter/xfdropcap.hxx b/lotuswordpro/inc/xfilter/xfdropcap.hxx
index eb5fb992ed22..a7a9203b8f86 100644
--- a/lotuswordpro/inc/xfilter/xfdropcap.hxx
+++ b/lotuswordpro/inc/xfilter/xfdropcap.hxx
@@ -121,13 +121,13 @@ inline void XFDropcap::ToXml(IXFStream *pStrm)
 
     if( m_nCharCount < 1 || m_nLines < 2 )
         return;
-    pAttrList->AddAttribute("style:length", OUString::number(m_nCharCount) );
-    pAttrList->AddAttribute("style:lines", OUString::number(m_nLines) );
-    pAttrList->AddAttribute("style:distance", OUString::number(m_fDistance) + "cm" );
+    pAttrList->AddAttribute(u"style:length"_ustr, OUString::number(m_nCharCount) );
+    pAttrList->AddAttribute(u"style:lines"_ustr, OUString::number(m_nLines) );
+    pAttrList->AddAttribute(u"style:distance"_ustr, OUString::number(m_fDistance) + "cm" );
     if( !m_strStyleName.isEmpty() )
-        pAttrList->AddAttribute("style:style-name", m_strStyleName );
-    pStrm->StartElement( "style:drop-cap" );
-    pStrm->EndElement( "style:drop-cap" );
+        pAttrList->AddAttribute(u"style:style-name"_ustr, m_strStyleName );
+    pStrm->StartElement( u"style:drop-cap"_ustr );
+    pStrm->EndElement( u"style:drop-cap"_ustr );
 }
 
 inline bool operator==(XFDropcap const & dc1, XFDropcap const & dc2)
diff --git a/lotuswordpro/inc/xfilter/xfendnote.hxx b/lotuswordpro/inc/xfilter/xfendnote.hxx
index 98bb280900f8..db6a47ed410d 100644
--- a/lotuswordpro/inc/xfilter/xfendnote.hxx
+++ b/lotuswordpro/inc/xfilter/xfendnote.hxx
@@ -92,23 +92,23 @@ inline void XFEndNote::ToXml(IXFStream *pStrm)
     IXFAttrList *pAttrList = pStrm->GetAttrList();
     pAttrList->Clear();
 
-    pAttrList->AddAttribute( "text:id", m_strID );
-    pStrm->StartElement( "text:endnote" );
+    pAttrList->AddAttribute( u"text:id"_ustr, m_strID );
+    pStrm->StartElement( u"text:endnote"_ustr );
 
     pAttrList->Clear();
     if( !m_strLabel.isEmpty() )
-        pAttrList->AddAttribute( "text:label", m_strLabel );
-    pStrm->StartElement( "text:endnote-citation" );
+        pAttrList->AddAttribute( u"text:label"_ustr, m_strLabel );
+    pStrm->StartElement( u"text:endnote-citation"_ustr );
     if( !m_strLabel.isEmpty())
         pStrm->Characters(m_strLabel);
-    pStrm->EndElement( "text:endnote-citation" );
+    pStrm->EndElement( u"text:endnote-citation"_ustr );
 
     pAttrList->Clear();
-    pStrm->StartElement( "text:endnote-body" );
+    pStrm->StartElement( u"text:endnote-body"_ustr );
     XFContentContainer::ToXml(pStrm);
-    pStrm->EndElement( "text:endnote-body" );
+    pStrm->EndElement( u"text:endnote-body"_ustr );
 
-    pStrm->EndElement( "text:endnote" );
+    pStrm->EndElement( u"text:endnote"_ustr );
 }
 
 #endif
diff --git a/lotuswordpro/inc/xfilter/xffooter.hxx b/lotuswordpro/inc/xfilter/xffooter.hxx
index cefca8263268..3060969f724b 100644
--- a/lotuswordpro/inc/xfilter/xffooter.hxx
+++ b/lotuswordpro/inc/xfilter/xffooter.hxx
@@ -75,9 +75,9 @@ public:
     {
         IXFAttrList* pAttrList = pStrm->GetAttrList();
         pAttrList->Clear();
-        pStrm->StartElement("style:footer");
+        pStrm->StartElement(u"style:footer"_ustr);
         XFContentContainer::ToXml(pStrm);
-        pStrm->EndElement("style:footer");
+        pStrm->EndElement(u"style:footer"_ustr);
     }
 };
 
diff --git a/lotuswordpro/inc/xfilter/xffootnote.hxx b/lotuswordpro/inc/xfilter/xffootnote.hxx
index 289217129287..f98d4389ed73 100644
--- a/lotuswordpro/inc/xfilter/xffootnote.hxx
+++ b/lotuswordpro/inc/xfilter/xffootnote.hxx
@@ -89,23 +89,23 @@ inline void XFFootNote::ToXml(IXFStream* pStrm)
     IXFAttrList* pAttrList = pStrm->GetAttrList();
     pAttrList->Clear();
 
-    pAttrList->AddAttribute("text:id", m_strID);
-    pStrm->StartElement("text:footnote");
+    pAttrList->AddAttribute(u"text:id"_ustr, m_strID);
+    pStrm->StartElement(u"text:footnote"_ustr);
 
     pAttrList->Clear();
     if (!m_strLabel.isEmpty())
-        pAttrList->AddAttribute("text:label", m_strLabel);
-    pStrm->StartElement("text:footnote-citation");
+        pAttrList->AddAttribute(u"text:label"_ustr, m_strLabel);
+    pStrm->StartElement(u"text:footnote-citation"_ustr);
     if (!m_strLabel.isEmpty())
         pStrm->Characters(m_strLabel);
-    pStrm->EndElement("text:footnote-citation");
+    pStrm->EndElement(u"text:footnote-citation"_ustr);
 
     pAttrList->Clear();
-    pStrm->StartElement("text:footnote-body");
+    pStrm->StartElement(u"text:footnote-body"_ustr);
     XFContentContainer::ToXml(pStrm);
-    pStrm->EndElement("text:footnote-body");
+    pStrm->EndElement(u"text:footnote-body"_ustr);
 
-    pStrm->EndElement("text:footnote");
+    pStrm->EndElement(u"text:footnote"_ustr);
 }
 
 #endif
diff --git a/lotuswordpro/inc/xfilter/xffootnoteconfig.hxx b/lotuswordpro/inc/xfilter/xffootnoteconfig.hxx
index b24b3c2acddf..085af2352ce6 100644
--- a/lotuswordpro/inc/xfilter/xffootnoteconfig.hxx
+++ b/lotuswordpro/inc/xfilter/xffootnoteconfig.hxx
@@ -157,66 +157,66 @@ inline void XFFootnoteConfig::ToXml(IXFStream *pStrm)
     pAttrList->Clear();
 
     if( !m_strCitationStyle.isEmpty() )
-        pAttrList->AddAttribute( "text:citation-style-name", m_strCitationStyle);
+        pAttrList->AddAttribute( u"text:citation-style-name"_ustr, m_strCitationStyle);
 
     if( !m_strBodyStyle.isEmpty() )
-        pAttrList->AddAttribute( "text:citation-body-style-name", m_strBodyStyle);
+        pAttrList->AddAttribute( u"text:citation-body-style-name"_ustr, m_strBodyStyle);
 
     if( !m_strNumPrefix.isEmpty() )
-        pAttrList->AddAttribute( "style:num-prefix", m_strNumPrefix);
+        pAttrList->AddAttribute( u"style:num-prefix"_ustr, m_strNumPrefix);
 
     if( !m_strNumSuffix.isEmpty() )
-        pAttrList->AddAttribute( "style:num-suffix", m_strNumSuffix);
+        pAttrList->AddAttribute( u"style:num-suffix"_ustr, m_strNumSuffix);
 
     if( !m_strNumFmt.isEmpty() )
-        pAttrList->AddAttribute( "style:num-format", m_strNumFmt);
+        pAttrList->AddAttribute( u"style:num-format"_ustr, m_strNumFmt);
 
     if( !m_strDefaultStyle.isEmpty() )
-        pAttrList->AddAttribute( "text:default-style-name", m_strDefaultStyle);
+        pAttrList->AddAttribute( u"text:default-style-name"_ustr, m_strDefaultStyle);
 
     if( !m_strMasterPage.isEmpty() )
-        pAttrList->AddAttribute( "text:master-page-name", m_strMasterPage);
+        pAttrList->AddAttribute( u"text:master-page-name"_ustr, m_strMasterPage);
 
-    pAttrList->AddAttribute( "text:start-value", OUString::number(m_nStartValue) );
+    pAttrList->AddAttribute( u"text:start-value"_ustr, OUString::number(m_nStartValue) );
 
     if( m_bIsFootnote )
     {
         if( m_nRestartType == -1 )
-            pAttrList->AddAttribute( "text:start-numbering-at", "document" );
+            pAttrList->AddAttribute( u"text:start-numbering-at"_ustr, u"document"_ustr );
         else if( m_nRestartType == 0 )
-            pAttrList->AddAttribute( "text:start-numbering-at", "page" );
+            pAttrList->AddAttribute( u"text:start-numbering-at"_ustr, u"page"_ustr );
         else if( m_nRestartType == 1 )
-            pAttrList->AddAttribute( "text:start-numbering-at", "chapter" );
+            pAttrList->AddAttribute( u"text:start-numbering-at"_ustr, u"chapter"_ustr );
 
         if( m_bInsertInPage )
-            pAttrList->AddAttribute( "text:footnotes-position", "page" );
+            pAttrList->AddAttribute( u"text:footnotes-position"_ustr, u"page"_ustr );
         else
-            pAttrList->AddAttribute( "text:footnotes-position", "document" );
+            pAttrList->AddAttribute( u"text:footnotes-position"_ustr, u"document"_ustr );
     }
 
     if(m_bIsFootnote)
     {
-        pStrm->StartElement( "text:footnotes-configuration" );
+        pStrm->StartElement( u"text:footnotes-configuration"_ustr );
         if( !m_strMessageOn.isEmpty() )
         {
-            pStrm->StartElement( "text:footnote-continuation-notice-forward" );
+            pStrm->StartElement( u"text:footnote-continuation-notice-forward"_ustr );
             pStrm->Characters(m_strMessageOn);
-            pStrm->EndElement( "text:footnote-continuation-notice-forward" );
+            pStrm->EndElement( u"text:footnote-continuation-notice-forward"_ustr );
         }
 
         if( !m_strMessageFrom.isEmpty() )
         {
-            pStrm->StartElement( "text:footnote-continuation-notice-backward" );
+            pStrm->StartElement( u"text:footnote-continuation-notice-backward"_ustr );
             pStrm->Characters(m_strMessageFrom);
-            pStrm->EndElement( "text:footnote-continuation-notice-backward" );
+            pStrm->EndElement( u"text:footnote-continuation-notice-backward"_ustr );
         }
 
-        pStrm->EndElement( "text:footnotes-configuration" );
+        pStrm->EndElement( u"text:footnotes-configuration"_ustr );
     }
     else
     {
-        pStrm->StartElement( "text:endnotes-configuration" );
-        pStrm->EndElement( "text:endnotes-configuration" );
+        pStrm->StartElement( u"text:endnotes-configuration"_ustr );
+        pStrm->EndElement( u"text:endnotes-configuration"_ustr );
     }
 
 }
diff --git a/lotuswordpro/inc/xfilter/xfheader.hxx b/lotuswordpro/inc/xfilter/xfheader.hxx
index af569b25c6d1..31e43f210e99 100644
--- a/lotuswordpro/inc/xfilter/xfheader.hxx
+++ b/lotuswordpro/inc/xfilter/xfheader.hxx
@@ -75,9 +75,9 @@ public:
         IXFAttrList* pAttrList = pStrm->GetAttrList();
         pAttrList->Clear();
 
-        pStrm->StartElement("style:header");
+        pStrm->StartElement(u"style:header"_ustr);
         XFContentContainer::ToXml(pStrm);
-        pStrm->EndElement("style:header");
+        pStrm->EndElement(u"style:header"_ustr);
     }
 };
 
diff --git a/lotuswordpro/inc/xfilter/xfhyperlink.hxx b/lotuswordpro/inc/xfilter/xfhyperlink.hxx
index 3847de61b337..9585d4c2afb4 100644
--- a/lotuswordpro/inc/xfilter/xfhyperlink.hxx
+++ b/lotuswordpro/inc/xfilter/xfhyperlink.hxx
@@ -94,25 +94,25 @@ inline void XFHyperlink::ToXml(IXFStream* pStrm)
     IXFAttrList* pAttrList = pStrm->GetAttrList();
     pAttrList->Clear();
 
-    pAttrList->AddAttribute("xlink:type", "simple");
-    pAttrList->AddAttribute("xlink:href", m_strHRef);
+    pAttrList->AddAttribute(u"xlink:type"_ustr, u"simple"_ustr);
+    pAttrList->AddAttribute(u"xlink:href"_ustr, m_strHRef);
     if (!m_strName.isEmpty())
-        pAttrList->AddAttribute("office:name", m_strName);
-    pAttrList->AddAttribute("office:target-frame-name", m_strFrame);
-    pAttrList->AddAttribute("xlink:show", "replace");
-    pStrm->StartElement("text:a");
+        pAttrList->AddAttribute(u"office:name"_ustr, m_strName);
+    pAttrList->AddAttribute(u"office:target-frame-name"_ustr, m_strFrame);
+    pAttrList->AddAttribute(u"xlink:show"_ustr, u"replace"_ustr);
+    pStrm->StartElement(u"text:a"_ustr);
 
     pAttrList->Clear();
     if (!GetStyleName().isEmpty())
-        pAttrList->AddAttribute("text:style-name", GetStyleName());
-    pStrm->StartElement("text:span");
+        pAttrList->AddAttribute(u"text:style-name"_ustr, GetStyleName());
+    pStrm->StartElement(u"text:span"_ustr);
     if (!m_strText.isEmpty())
         pStrm->Characters(m_strText);
     else
         pStrm->Characters(m_strHRef);
-    pStrm->EndElement("text:span");
+    pStrm->EndElement(u"text:span"_ustr);
 
-    pStrm->EndElement("text:a");
+    pStrm->EndElement(u"text:a"_ustr);
 }
 
 #endif
diff --git a/lotuswordpro/inc/xfilter/xfinputlist.hxx b/lotuswordpro/inc/xfilter/xfinputlist.hxx
index 85dae8836e56..34e682b1c205 100644
--- a/lotuswordpro/inc/xfilter/xfinputlist.hxx
+++ b/lotuswordpro/inc/xfilter/xfinputlist.hxx
@@ -92,21 +92,21 @@ inline void XFInputList::ToXml(IXFStream *pStrm)
     IXFAttrList *pAttrList = pStrm->GetAttrList();
     pAttrList->Clear();
 
-    pAttrList->AddAttribute( "text:name", m_strName );
-    pStrm->StartElement( "text:drop-down" );
+    pAttrList->AddAttribute( u"text:name"_ustr, m_strName );
+    pStrm->StartElement( u"text:drop-down"_ustr );
 
     pAttrList->Clear();
-    pAttrList->AddAttribute( "text:value", " " );
-    pStrm->StartElement( "text:label" );
-    pStrm->EndElement( "text:label" );
+    pAttrList->AddAttribute( u"text:value"_ustr, u" "_ustr );
+    pStrm->StartElement( u"text:label"_ustr );
+    pStrm->EndElement( u"text:label"_ustr );
     for(const OUString& rLabel : m_list)
     {
         pAttrList->Clear();
-        pAttrList->AddAttribute( "text:value", rLabel);
-        pStrm->StartElement( "text:label" );
-        pStrm->EndElement( "text:label" );
+        pAttrList->AddAttribute( u"text:value"_ustr, rLabel);
+        pStrm->StartElement( u"text:label"_ustr );
+        pStrm->EndElement( u"text:label"_ustr );
     }
-    pStrm->EndElement( "text:drop-down" );
+    pStrm->EndElement( u"text:drop-down"_ustr );
 }
 
 #endif
diff --git a/lotuswordpro/inc/xfilter/xflinebreak.hxx b/lotuswordpro/inc/xfilter/xflinebreak.hxx
index b2c6412982cb..2eda7bf97b00 100644
--- a/lotuswordpro/inc/xfilter/xflinebreak.hxx
+++ b/lotuswordpro/inc/xfilter/xflinebreak.hxx
@@ -74,8 +74,8 @@ inline void XFLineBreak::ToXml(IXFStream* pStrm)
     IXFAttrList* pAttrList = pStrm->GetAttrList();
 
     pAttrList->Clear();
-    pStrm->StartElement("text:line-break");
-    pStrm->EndElement("text:line-break");
+    pStrm->StartElement(u"text:line-break"_ustr);
+    pStrm->EndElement(u"text:line-break"_ustr);
 }
 
 #endif
diff --git a/lotuswordpro/inc/xfilter/xflineheight.hxx b/lotuswordpro/inc/xfilter/xflineheight.hxx
index cffff2457226..0f8a83d8cbff 100644
--- a/lotuswordpro/inc/xfilter/xflineheight.hxx
+++ b/lotuswordpro/inc/xfilter/xflineheight.hxx
@@ -131,16 +131,16 @@ inline void XFLineHeight::ToXml(IXFStream *pStrm)
     case enumLHNone:
         return;
     case enumLHHeight:
-        pAttrList->AddAttribute( "fo:line-height",OUString::number(m_Value.m_fValue) + "cm" );
+        pAttrList->AddAttribute( u"fo:line-height"_ustr,OUString::number(m_Value.m_fValue) + "cm" );
         break;
     case enumLHLeast:
-        pAttrList->AddAttribute( "style:line-height-at-least",OUString::number(m_Value.m_fValue) + "cm" );
+        pAttrList->AddAttribute( u"style:line-height-at-least"_ustr,OUString::number(m_Value.m_fValue) + "cm" );
         break;
     case enumLHPercent:
-        pAttrList->AddAttribute( "fo:line-height", OUString::number(m_Value.m_nValue) + "%" );
+        pAttrList->AddAttribute( u"fo:line-height"_ustr, OUString::number(m_Value.m_nValue) + "%" );
         break;
     case enumLHSpace:
-        pAttrList->AddAttribute( "style:line-spacing", OUString::number(m_Value.m_fValue) + "cm" );
+        pAttrList->AddAttribute( u"style:line-spacing"_ustr, OUString::number(m_Value.m_fValue) + "cm" );
         break;
     }
 }
diff --git a/lotuswordpro/inc/xfilter/xflinenumberconfig.hxx b/lotuswordpro/inc/xfilter/xflinenumberconfig.hxx
index 5c0516bce940..1984b0b37faf 100644
--- a/lotuswordpro/inc/xfilter/xflinenumberconfig.hxx
+++ b/lotuswordpro/inc/xfilter/xflinenumberconfig.hxx
@@ -131,42 +131,42 @@ inline void XFLineNumberConfig::ToXml(IXFStream *pStrm)
     IXFAttrList *pAttrList = pStrm->GetAttrList();
 
     if( !m_strTextStyle.isEmpty() )
-        pAttrList->AddAttribute( "text:style-name", m_strTextStyle );
-    pAttrList->AddAttribute( "text:offset", OUString::number(m_fOffset) + "cm" );
-    pAttrList->AddAttribute( "style:num-format", m_strNumFmt );
+        pAttrList->AddAttribute( u"text:style-name"_ustr, m_strTextStyle );
+    pAttrList->AddAttribute( u"text:offset"_ustr, OUString::number(m_fOffset) + "cm" );
+    pAttrList->AddAttribute( u"style:num-format"_ustr, m_strNumFmt );
     //position:
     if( m_ePosition == enumXFLineNumberLeft )
-        pAttrList->AddAttribute( "text:number-position", "left" );
+        pAttrList->AddAttribute( u"text:number-position"_ustr, u"left"_ustr );
     else if( m_ePosition == enumXFLineNumberRight )
-        pAttrList->AddAttribute( "text:number-position", "right" );
+        pAttrList->AddAttribute( u"text:number-position"_ustr, u"right"_ustr );
     else if( m_ePosition == enumXFLineNumberInner )
-        pAttrList->AddAttribute( "text:number-position", "inner" );
+        pAttrList->AddAttribute( u"text:number-position"_ustr, u"inner"_ustr );
     else if( m_ePosition == enumXFLineNumberOuter )
-        pAttrList->AddAttribute( "text:number-position", "outer" );
+        pAttrList->AddAttribute( u"text:number-position"_ustr, u"outer"_ustr );
 
-    pAttrList->AddAttribute( "text:increment", OUString::number(m_nIncrement) );
+    pAttrList->AddAttribute( u"text:increment"_ustr, OUString::number(m_nIncrement) );
 
     if( m_bRestartOnPage )
-        pAttrList->AddAttribute( "text:restart-on-page", "true" );
+        pAttrList->AddAttribute( u"text:restart-on-page"_ustr, u"true"_ustr );
     else
-        pAttrList->AddAttribute( "text:restart-on-page", "false" );
+        pAttrList->AddAttribute( u"text:restart-on-page"_ustr, u"false"_ustr );
 
     if( m_bCountEmptyLines )
-        pAttrList->AddAttribute( "text:count-empty-lines", "true" );
+        pAttrList->AddAttribute( u"text:count-empty-lines"_ustr, u"true"_ustr );
     else
-        pAttrList->AddAttribute( "text:count-empty-lines", "false" );
+        pAttrList->AddAttribute( u"text:count-empty-lines"_ustr, u"false"_ustr );
 
-    pAttrList->AddAttribute( "text:count-in-floating-frames", "false" );
+    pAttrList->AddAttribute( u"text:count-in-floating-frames"_ustr, u"false"_ustr );
 
-    pStrm->StartElement( "text:linenumbering-configuration" );
+    pStrm->StartElement( u"text:linenumbering-configuration"_ustr );
 
     pAttrList->Clear();
-    pAttrList->AddAttribute( "text:increment", OUString::number(m_nSepIncrement) );
-    pStrm->StartElement( "text:linenumbering-separator" );
+    pAttrList->AddAttribute( u"text:increment"_ustr, OUString::number(m_nSepIncrement) );
+    pStrm->StartElement( u"text:linenumbering-separator"_ustr );
     pStrm->Characters(m_strSeparator);
-    pStrm->EndElement( "text:linenumbering-separator" );
+    pStrm->EndElement( u"text:linenumbering-separator"_ustr );
 
-    pStrm->EndElement( "text:linenumbering-configuration" );
+    pStrm->EndElement( u"text:linenumbering-configuration"_ustr );
 }
 
 #endif
diff --git a/lotuswordpro/inc/xfilter/xflistitem.hxx b/lotuswordpro/inc/xfilter/xflistitem.hxx
index 329eb822016b..1debf6567645 100644
--- a/lotuswordpro/inc/xfilter/xflistitem.hxx
+++ b/lotuswordpro/inc/xfilter/xflistitem.hxx
@@ -87,19 +87,19 @@ inline void XFListItem::ToXml(IXFStream* pStrm)
     pAttrList->Clear();
 
     if (!GetStyleName().isEmpty())
-        pAttrList->AddAttribute("text:style-name", GetStyleName());
+        pAttrList->AddAttribute(u"text:style-name"_ustr, GetStyleName());
 
     if (!m_bIsHeader)
     {
-        pStrm->StartElement("text:list-item");
+        pStrm->StartElement(u"text:list-item"_ustr);
         XFContentContainer::ToXml(pStrm);
-        pStrm->EndElement("text:list-item");
+        pStrm->EndElement(u"text:list-item"_ustr);
     }
     else
     {
-        pStrm->StartElement("text:list-header");
+        pStrm->StartElement(u"text:list-header"_ustr);
         XFContentContainer::ToXml(pStrm);
-        pStrm->EndElement("text:list-header");
+        pStrm->EndElement(u"text:list-header"_ustr);
     }
 }
 
diff --git a/lotuswordpro/inc/xfilter/xfnumfmt.hxx b/lotuswordpro/inc/xfilter/xfnumfmt.hxx
index da4a866ecd15..37170a1d0b73 100644
--- a/lotuswordpro/inc/xfilter/xfnumfmt.hxx
+++ b/lotuswordpro/inc/xfilter/xfnumfmt.hxx
@@ -132,12 +132,12 @@ public:
         IXFAttrList *pAttrList = pStrm->GetAttrList();
 
         if( !m_strPrefix.isEmpty() )
-            pAttrList->AddAttribute( "style:num-prefix", m_strPrefix );
+            pAttrList->AddAttribute( u"style:num-prefix"_ustr, m_strPrefix );
         if( !m_strSuffix.isEmpty() )
-            pAttrList->AddAttribute( "style:num-suffix", m_strSuffix );
-        pAttrList->AddAttribute( "style:num-format", m_strFormat );
+            pAttrList->AddAttribute( u"style:num-suffix"_ustr, m_strSuffix );
+        pAttrList->AddAttribute( u"style:num-format"_ustr, m_strFormat );
         if( m_nStartValue != 0 )
-            pAttrList->AddAttribute( "text:start-value", OUString::number(static_cast<sal_Int32>(m_nStartValue)) );
+            pAttrList->AddAttribute( u"text:start-value"_ustr, OUString::number(static_cast<sal_Int32>(m_nStartValue)) );
     }
 private:
     OUString   m_strPrefix;
diff --git a/lotuswordpro/inc/xfilter/xfpadding.hxx b/lotuswordpro/inc/xfilter/xfpadding.hxx
index 6276a8623de7..a2bec2a190a2 100644
--- a/lotuswordpro/inc/xfilter/xfpadding.hxx
+++ b/lotuswordpro/inc/xfilter/xfpadding.hxx
@@ -162,28 +162,28 @@ inline void XFPadding::ToXml(IXFStream *pStrm)
 
     if( (m_fLeft == m_fRight) && (m_fLeft == m_fTop) && (m_fLeft== m_fBottom ) && m_nFlag == 0x00000015 )
     {
-        pAttrList->AddAttribute( "fo:padding", OUString::number(m_fLeft) + "cm" );
+        pAttrList->AddAttribute( u"fo:padding"_ustr, OUString::number(m_fLeft) + "cm" );
         return;
     }
     //margin left:
     if( m_nFlag&XFPADDING_FLAG_LEFT )
     {
-        pAttrList->AddAttribute( "fo:padding-left", OUString::number(m_fLeft) + "cm" );
+        pAttrList->AddAttribute( u"fo:padding-left"_ustr, OUString::number(m_fLeft) + "cm" );
     }
     //margin right:
     if( m_nFlag&XFPADDING_FLAG_RIGHT )
     {
-        pAttrList->AddAttribute("fo:padding-right", OUString::number(m_fRight) + "cm" );
+        pAttrList->AddAttribute(u"fo:padding-right"_ustr, OUString::number(m_fRight) + "cm" );
     }
     //margin top:
     if( m_nFlag&XFPADDING_FLAG_TOP )
     {
-        pAttrList->AddAttribute("fo:padding-top", OUString::number(m_fTop) + "cm" );
+        pAttrList->AddAttribute(u"fo:padding-top"_ustr, OUString::number(m_fTop) + "cm" );
     }
     //margin bottom:
     if( m_nFlag&XFPADDING_FLAG_BOTTOM )
     {
-        pAttrList->AddAttribute("fo:padding-bottom", OUString::number(m_fBottom) + "cm" );
+        pAttrList->AddAttribute(u"fo:padding-bottom"_ustr, OUString::number(m_fBottom) + "cm" );
     }
 }
 
diff --git a/lotuswordpro/inc/xfilter/xfpagecount.hxx b/lotuswordpro/inc/xfilter/xfpagecount.hxx
index 25b7d4be1472..baa9baab7688 100644
--- a/lotuswordpro/inc/xfilter/xfpagecount.hxx
+++ b/lotuswordpro/inc/xfilter/xfpagecount.hxx
@@ -78,8 +78,8 @@ inline void XFPageCount::ToXml(IXFStream* pStrm)
     IXFAttrList* pAttrList = pStrm->GetAttrList();
     pAttrList->Clear();
 
-    pStrm->StartElement("text:page-count");
-    pStrm->EndElement("text:page-count");
+    pStrm->StartElement(u"text:page-count"_ustr);
+    pStrm->EndElement(u"text:page-count"_ustr);
 }
 
 #endif
diff --git a/lotuswordpro/inc/xfilter/xfpagenumber.hxx b/lotuswordpro/inc/xfilter/xfpagenumber.hxx
index 80516c452eec..57cf357751eb 100644
--- a/lotuswordpro/inc/xfilter/xfpagenumber.hxx
+++ b/lotuswordpro/inc/xfilter/xfpagenumber.hxx
@@ -86,9 +86,9 @@ inline void XFPageNumber::ToXml(IXFStream* pStrm)
     pAttrList->Clear();
 
     m_aNumFmt.ToXml(pStrm);
-    pAttrList->AddAttribute("text:select-page", "current");
-    pStrm->StartElement("text:page-number");
-    pStrm->EndElement("text:page-number");
+    pAttrList->AddAttribute(u"text:select-page"_ustr, u"current"_ustr);
+    pStrm->StartElement(u"text:page-number"_ustr);
+    pStrm->EndElement(u"text:page-number"_ustr);
 }
 
 #endif
diff --git a/lotuswordpro/inc/xfilter/xfplaceholder.hxx b/lotuswordpro/inc/xfilter/xfplaceholder.hxx
index 9bc598405b9b..c172172e8024 100644
--- a/lotuswordpro/inc/xfilter/xfplaceholder.hxx
+++ b/lotuswordpro/inc/xfilter/xfplaceholder.hxx
@@ -97,10 +97,10 @@ inline void XFHolderStart::ToXml(IXFStream* pStrm)
 {
     IXFAttrList* pAttrList = pStrm->GetAttrList();
     pAttrList->Clear();
-    pAttrList->AddAttribute("text:placeholder-type", m_strType);
+    pAttrList->AddAttribute(u"text:placeholder-type"_ustr, m_strType);
     if (!m_strDesc.isEmpty())
-        pAttrList->AddAttribute("text:description", m_strDesc);
-    pStrm->StartElement("text:placeholder");
+        pAttrList->AddAttribute(u"text:description"_ustr, m_strDesc);
+    pStrm->StartElement(u"text:placeholder"_ustr);
     if (!m_strText.isEmpty())
         pStrm->Characters(m_strText);
 }
@@ -117,7 +117,7 @@ XFHolderEnd::XFHolderEnd() {}
 
 XFHolderEnd::~XFHolderEnd() {}
 
-inline void XFHolderEnd::ToXml(IXFStream* pStrm) { pStrm->EndElement("text:placeholder"); }
+inline void XFHolderEnd::ToXml(IXFStream* pStrm) { pStrm->EndElement(u"text:placeholder"_ustr); }
 
 #endif
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/inc/xfilter/xfruby.hxx b/lotuswordpro/inc/xfilter/xfruby.hxx
index e92b55318540..3073c97c405b 100644
--- a/lotuswordpro/inc/xfilter/xfruby.hxx
+++ b/lotuswordpro/inc/xfilter/xfruby.hxx
@@ -84,26 +84,26 @@ void XFRubyStart::ToXml(IXFStream* pStrm)
     IXFAttrList* pAttrList = pStrm->GetAttrList();
     pAttrList->Clear();
     if (!GetStyleName().isEmpty())
-        pAttrList->AddAttribute("text:style-name", GetStyleName());
-    pStrm->StartElement("text:ruby");
+        pAttrList->AddAttribute(u"text:style-name"_ustr, GetStyleName());
+    pStrm->StartElement(u"text:ruby"_ustr);
     pAttrList->Clear();
-    pStrm->StartElement("text:ruby-base");
+    pStrm->StartElement(u"text:ruby-base"_ustr);
 }
 
 void XFRubyEnd::SetText(const OUString& sText) { m_strText = sText; }
 
 void XFRubyEnd::ToXml(IXFStream* pStrm)
 {
-    pStrm->EndElement("text:ruby-base");
+    pStrm->EndElement(u"text:ruby-base"_ustr);
     IXFAttrList* pAttrList = pStrm->GetAttrList();
     pAttrList->Clear();
     if (!GetStyleName().isEmpty())
-        pAttrList->AddAttribute("text:style-name", GetStyleName());
-    pStrm->StartElement("text:ruby-text");
+        pAttrList->AddAttribute(u"text:style-name"_ustr, GetStyleName());
+    pStrm->StartElement(u"text:ruby-text"_ustr);
     if (!m_strText.isEmpty())
         pStrm->Characters(m_strText);
-    pStrm->EndElement("text:ruby-text");
-    pStrm->EndElement("text:ruby");
+    pStrm->EndElement(u"text:ruby-text"_ustr);
+    pStrm->EndElement(u"text:ruby"_ustr);
 }
 
 #endif
diff --git a/lotuswordpro/inc/xfilter/xfrubystyle.hxx b/lotuswordpro/inc/xfilter/xfrubystyle.hxx
index eee1a75b179d..71dc0709595e 100644
--- a/lotuswordpro/inc/xfilter/xfrubystyle.hxx
+++ b/lotuswordpro/inc/xfilter/xfrubystyle.hxx
@@ -92,9 +92,9 @@ void XFRubyStyle::ToXml(IXFStream* pStrm)
 
     pAttrList->Clear();
     if (!style.isEmpty())
-        pAttrList->AddAttribute("style:name", GetStyleName());
-    pAttrList->AddAttribute("style:family", "ruby");
-    pStrm->StartElement("style:style");
+        pAttrList->AddAttribute(u"style:name"_ustr, GetStyleName());
+    pAttrList->AddAttribute(u"style:family"_ustr, u"ruby"_ustr);
+    pStrm->StartElement(u"style:style"_ustr);
 
     pAttrList->Clear();
 
@@ -112,7 +112,7 @@ void XFRubyStyle::ToXml(IXFStream* pStrm)
         sPos = "center";
     }
     if (!sPos.isEmpty())
-        pAttrList->AddAttribute("style:ruby-align", sPos);
+        pAttrList->AddAttribute(u"style:ruby-align"_ustr, sPos);
 
     OUString sAlign;
     if (m_ePos == enumXFRubyTop)
@@ -124,11 +124,11 @@ void XFRubyStyle::ToXml(IXFStream* pStrm)
         sAlign = "below";
     }
     if (!sAlign.isEmpty())
-        pAttrList->AddAttribute("style:ruby-position", sAlign);
+        pAttrList->AddAttribute(u"style:ruby-position"_ustr, sAlign);
 
-    pStrm->StartElement("style:properties");
-    pStrm->EndElement("style:properties");
-    pStrm->EndElement("style:style");
+    pStrm->StartElement(u"style:properties"_ustr);
+    pStrm->EndElement(u"style:properties"_ustr);
+    pStrm->EndElement(u"style:style"_ustr);
 }
 
 #endif
diff --git a/lotuswordpro/inc/xfilter/xftabstop.hxx b/lotuswordpro/inc/xfilter/xftabstop.hxx
index 466ea535bdd8..05248c760a6f 100644
--- a/lotuswordpro/inc/xfilter/xftabstop.hxx
+++ b/lotuswordpro/inc/xfilter/xftabstop.hxx
@@ -74,8 +74,8 @@ inline void XFTabStop::ToXml(IXFStream* pStrm)
     IXFAttrList* pAttrList = pStrm->GetAttrList();
 
     pAttrList->Clear();
-    pStrm->StartElement("text:tab-stop");
-    pStrm->EndElement("text:tab-stop");
+    pStrm->StartElement(u"text:tab-stop"_ustr);
+    pStrm->EndElement(u"text:tab-stop"_ustr);
 }
 
 #endif
diff --git a/lotuswordpro/qa/cppunit/import_test.cxx b/lotuswordpro/qa/cppunit/import_test.cxx
index 9514395a02df..2e8ffe21ebd9 100644
--- a/lotuswordpro/qa/cppunit/import_test.cxx
+++ b/lotuswordpro/qa/cppunit/import_test.cxx
@@ -27,7 +27,7 @@ class LotusWordProTest : public UnoApiTest
 {
 public:
     LotusWordProTest()
-        : UnoApiTest("/lotuswordpro/qa/cppunit/data/")
+        : UnoApiTest(u"/lotuswordpro/qa/cppunit/data/"_ustr)
     {
     }
 };
@@ -52,85 +52,85 @@ CPPUNIT_TEST_FIXTURE(LotusWordProTest, testtdf33787OrderedBullets)
 
     uno::Reference<beans::XPropertySet> xPara(xParaEnum->nextElement(), uno::UNO_QUERY);
     OUString aListLabelString;
-    xPara->getPropertyValue("ListLabelString") >>= aListLabelString;
+    xPara->getPropertyValue(u"ListLabelString"_ustr) >>= aListLabelString;
     // Make sure the list start from 1.
-    CPPUNIT_ASSERT_EQUAL(OUString("1."), aListLabelString);
+    CPPUNIT_ASSERT_EQUAL(u"1."_ustr, aListLabelString);
     xPara.set(xParaEnum->nextElement(), uno::UNO_QUERY);
-    xPara->getPropertyValue("ListLabelString") >>= aListLabelString;
+    xPara->getPropertyValue(u"ListLabelString"_ustr) >>= aListLabelString;
     // Without the accompanying fix in place, this test would have failed, the list label was "1.".
-    CPPUNIT_ASSERT_EQUAL(OUString("2."), aListLabelString);
+    CPPUNIT_ASSERT_EQUAL(u"2."_ustr, aListLabelString);
 
     xPara.set(xParaEnum->nextElement(), uno::UNO_QUERY);
-    xPara->getPropertyValue("ListLabelString") >>= aListLabelString;
+    xPara->getPropertyValue(u"ListLabelString"_ustr) >>= aListLabelString;
     // Without the accompanying fix in place, this test would have failed, the list label was "1.".
-    CPPUNIT_ASSERT_EQUAL(OUString("3."), aListLabelString);
+    CPPUNIT_ASSERT_EQUAL(u"3."_ustr, aListLabelString);
 
     xPara.set(xParaEnum->nextElement(), uno::UNO_QUERY);
     xPara.set(xParaEnum->nextElement(), uno::UNO_QUERY);
-    xPara->getPropertyValue("ListLabelString") >>= aListLabelString;
+    xPara->getPropertyValue(u"ListLabelString"_ustr) >>= aListLabelString;
     // Make sure the list start from i.
-    CPPUNIT_ASSERT_EQUAL(OUString("i."), aListLabelString);
+    CPPUNIT_ASSERT_EQUAL(u"i."_ustr, aListLabelString);
 
     xPara.set(xParaEnum->nextElement(), uno::UNO_QUERY);
-    xPara->getPropertyValue("ListLabelString") >>= aListLabelString;
+    xPara->getPropertyValue(u"ListLabelString"_ustr) >>= aListLabelString;
     // Without the accompanying fix in place, this test would have failed, the list label was "i.".
-    CPPUNIT_ASSERT_EQUAL(OUString("ii."), aListLabelString);
+    CPPUNIT_ASSERT_EQUAL(u"ii."_ustr, aListLabelString);
 
     xPara.set(xParaEnum->nextElement(), uno::UNO_QUERY);
-    xPara->getPropertyValue("ListLabelString") >>= aListLabelString;
+    xPara->getPropertyValue(u"ListLabelString"_ustr) >>= aListLabelString;
     // Without the accompanying fix in place, this test would have failed, the list label was "i.".
-    CPPUNIT_ASSERT_EQUAL(OUString("iii."), aListLabelString);
+    CPPUNIT_ASSERT_EQUAL(u"iii."_ustr, aListLabelString);
 
     xPara.set(xParaEnum->nextElement(), uno::UNO_QUERY);
     xPara.set(xParaEnum->nextElement(), uno::UNO_QUERY);
-    xPara->getPropertyValue("ListLabelString") >>= aListLabelString;
+    xPara->getPropertyValue(u"ListLabelString"_ustr) >>= aListLabelString;
     // Make sure the list start from I.
-    CPPUNIT_ASSERT_EQUAL(OUString("I."), aListLabelString);
+    CPPUNIT_ASSERT_EQUAL(u"I."_ustr, aListLabelString);
 
     xPara.set(xParaEnum->nextElement(), uno::UNO_QUERY);
-    xPara->getPropertyValue("ListLabelString") >>= aListLabelString;
+    xPara->getPropertyValue(u"ListLabelString"_ustr) >>= aListLabelString;
     // Without the accompanying fix in place, this test would have failed, the list label was "I.".
-    CPPUNIT_ASSERT_EQUAL(OUString("II."), aListLabelString);
+    CPPUNIT_ASSERT_EQUAL(u"II."_ustr, aListLabelString);
 
     xPara.set(xParaEnum->nextElement(), uno::UNO_QUERY);
-    xPara->getPropertyValue("ListLabelString") >>= aListLabelString;
+    xPara->getPropertyValue(u"ListLabelString"_ustr) >>= aListLabelString;
     // Without the accompanying fix in place, this test would have failed, the list label was "I.".
-    CPPUNIT_ASSERT_EQUAL(OUString("III."), aListLabelString);
+    CPPUNIT_ASSERT_EQUAL(u"III."_ustr, aListLabelString);
 
     for (int i = 0; i < 7; ++i)
         xParaEnum->nextElement();
 
     xPara.set(xParaEnum->nextElement(), uno::UNO_QUERY);
-    xPara->getPropertyValue("ListLabelString") >>= aListLabelString;
+    xPara->getPropertyValue(u"ListLabelString"_ustr) >>= aListLabelString;
     // Without the accompanying fix in place, this test would have failed, the list label was "A.".
-    CPPUNIT_ASSERT_EQUAL(OUString("C."), aListLabelString);
+    CPPUNIT_ASSERT_EQUAL(u"C."_ustr, aListLabelString);
 
     xPara.set(xParaEnum->nextElement(), uno::UNO_QUERY);
     xPara.set(xParaEnum->nextElement(), uno::UNO_QUERY);
-    xPara->getPropertyValue("ListLabelString") >>= aListLabelString;
+    xPara->getPropertyValue(u"ListLabelString"_ustr) >>= aListLabelString;
     // Make sure the nested list (with indentation) starts from 1).
-    CPPUNIT_ASSERT_EQUAL(OUString("1)"), aListLabelString);
+    CPPUNIT_ASSERT_EQUAL(u"1)"_ustr, aListLabelString);
 
     xPara.set(xParaEnum->nextElement(), uno::UNO_QUERY);
-    xPara->getPropertyValue("ListLabelString") >>= aListLabelString;
+    xPara->getPropertyValue(u"ListLabelString"_ustr) >>= aListLabelString;
     // Make sure skipped element has no prefix
-    CPPUNIT_ASSERT_EQUAL(OUString(""), aListLabelString);
+    CPPUNIT_ASSERT_EQUAL(u""_ustr, aListLabelString);
 
     xPara.set(xParaEnum->nextElement(), uno::UNO_QUERY);
-    xPara->getPropertyValue("ListLabelString") >>= aListLabelString;
+    xPara->getPropertyValue(u"ListLabelString"_ustr) >>= aListLabelString;
     // Make sure the value after Skip is incremented properly
     // Without the accompanying fix in place, this test would have failed, the list label was "1)".
-    CPPUNIT_ASSERT_EQUAL(OUString("2)"), aListLabelString);
+    CPPUNIT_ASSERT_EQUAL(u"2)"_ustr, aListLabelString);
 
     xPara.set(xParaEnum->nextElement(), uno::UNO_QUERY);
-    xPara->getPropertyValue("ListLabelString") >>= aListLabelString;
+    xPara->getPropertyValue(u"ListLabelString"_ustr) >>= aListLabelString;
     // Next nested list
-    CPPUNIT_ASSERT_EQUAL(OUString("a)"), aListLabelString);
+    CPPUNIT_ASSERT_EQUAL(u"a)"_ustr, aListLabelString);
 
     xPara.set(xParaEnum->nextElement(), uno::UNO_QUERY);
-    xPara->getPropertyValue("ListLabelString") >>= aListLabelString;
+    xPara->getPropertyValue(u"ListLabelString"_ustr) >>= aListLabelString;
     // Without the accompanying fix in place, this test would have failed, the list label was "a)".
-    CPPUNIT_ASSERT_EQUAL(OUString("b)"), aListLabelString);
+    CPPUNIT_ASSERT_EQUAL(u"b)"_ustr, aListLabelString);
 }
 
 CPPUNIT_TEST_FIXTURE(LotusWordProTest, testTdf129993)
@@ -144,7 +144,8 @@ CPPUNIT_TEST_FIXTURE(LotusWordProTest, testTdf129993)
         xParaEnum->nextElement();
     uno::Reference<lang::XServiceInfo> xServiceInfo(xParaEnum->nextElement(), uno::UNO_QUERY);
 
-    CPPUNIT_ASSERT_EQUAL(sal_True, xServiceInfo->supportsService("com.sun.star.text.TextTable"));
+    CPPUNIT_ASSERT_EQUAL(sal_True,
+                         xServiceInfo->supportsService(u"com.sun.star.text.TextTable"_ustr));
 }
 
 CPPUNIT_TEST_FIXTURE(LotusWordProTest, paragraphProperties)
@@ -164,7 +165,7 @@ CPPUNIT_TEST_FIXTURE(LotusWordProTest, paragraphProperties)
                                                       uno::UNO_QUERY_THROW);
     uno::Reference<beans::XPropertySet> xPropertySet(xParagraph, uno::UNO_QUERY);
     float fFontWeight;
-    xPropertySet->getPropertyValue("CharWeight") >>= fFontWeight;
+    xPropertySet->getPropertyValue(u"CharWeight"_ustr) >>= fFontWeight;
     CPPUNIT_ASSERT_EQUAL(awt::FontWeight::BOLD, fFontWeight);
 
     // italic
@@ -172,7 +173,7 @@ CPPUNIT_TEST_FIXTURE(LotusWordProTest, paragraphProperties)
                                                        uno::UNO_QUERY_THROW);
     uno::Reference<beans::XPropertySet> xPropertySet2(xParagraph2, uno::UNO_QUERY);
     awt::FontSlant fFontSlant;
-    xPropertySet2->getPropertyValue("CharPosture") >>= fFontSlant;
+    xPropertySet2->getPropertyValue(u"CharPosture"_ustr) >>= fFontSlant;
     CPPUNIT_ASSERT_EQUAL(awt::FontSlant_ITALIC, fFontSlant);
 
     // underline
@@ -180,7 +181,7 @@ CPPUNIT_TEST_FIXTURE(LotusWordProTest, paragraphProperties)
                                                        uno::UNO_QUERY_THROW);
     uno::Reference<beans::XPropertySet> xPropertySet3(xParagraph3, uno::UNO_QUERY);
     sal_Int16 nCharUnderline;
-    xPropertySet3->getPropertyValue("CharUnderline") >>= nCharUnderline;
+    xPropertySet3->getPropertyValue(u"CharUnderline"_ustr) >>= nCharUnderline;
     CPPUNIT_ASSERT_EQUAL(awt::FontUnderline::SINGLE, nCharUnderline);
 
     // striked through
@@ -188,7 +189,7 @@ CPPUNIT_TEST_FIXTURE(LotusWordProTest, paragraphProperties)
                                                        uno::UNO_QUERY_THROW);
     uno::Reference<beans::XPropertySet> xPropertySet4(xParagraph4, uno::UNO_QUERY);
     sal_Int16 nFontStrikeout;
-    xPropertySet4->getPropertyValue("CharStrikeout") >>= nFontStrikeout;
+    xPropertySet4->getPropertyValue(u"CharStrikeout"_ustr) >>= nFontStrikeout;
     CPPUNIT_ASSERT_EQUAL(awt::FontStrikeout::SINGLE, nFontStrikeout);
 
     //superscript
@@ -196,11 +197,11 @@ CPPUNIT_TEST_FIXTURE(LotusWordProTest, paragraphProperties)
                                                        uno::UNO_QUERY_THROW);
     uno::Reference<beans::XPropertySet> xPropertySet5(xParagraph5, uno::UNO_QUERY);
     sal_Int32 nCharEscapement;
-    xPropertySet5->getPropertyValue("CharEscapement") >>= nCharEscapement;
+    xPropertySet5->getPropertyValue(u"CharEscapement"_ustr) >>= nCharEscapement;
     CPPUNIT_ASSERT_EQUAL(sal_Int32(33), nCharEscapement);
 
     sal_Int32 nCharEscapementHeight;
-    xPropertySet5->getPropertyValue("CharEscapementHeight") >>= nCharEscapementHeight;
+    xPropertySet5->getPropertyValue(u"CharEscapementHeight"_ustr) >>= nCharEscapementHeight;
     CPPUNIT_ASSERT_EQUAL(sal_Int32(58), nCharEscapementHeight);
 
     //subscript
@@ -208,11 +209,11 @@ CPPUNIT_TEST_FIXTURE(LotusWordProTest, paragraphProperties)
                                                        uno::UNO_QUERY_THROW);
     uno::Reference<beans::XPropertySet> xPropertySet6(xParagraph6, uno::UNO_QUERY);
     sal_Int32 nCharEscapement2;
-    xPropertySet6->getPropertyValue("CharEscapement") >>= nCharEscapement2;
+    xPropertySet6->getPropertyValue(u"CharEscapement"_ustr) >>= nCharEscapement2;
     CPPUNIT_ASSERT_EQUAL(sal_Int32(-33), nCharEscapement2);
 
     sal_Int32 nCharEscapementHeight2;
-    xPropertySet6->getPropertyValue("CharEscapementHeight") >>= nCharEscapementHeight2;
+    xPropertySet6->getPropertyValue(u"CharEscapementHeight"_ustr) >>= nCharEscapementHeight2;
     CPPUNIT_ASSERT_EQUAL(sal_Int32(58), nCharEscapementHeight2);
 
     // red background and borders
@@ -220,23 +221,23 @@ CPPUNIT_TEST_FIXTURE(LotusWordProTest, paragraphProperties)
                                                        uno::UNO_QUERY_THROW);
     uno::Reference<beans::XPropertySet> xPropertySet7(xParagraph7, uno::UNO_QUERY);
     Color nParaBackColor;
-    xPropertySet7->getPropertyValue("ParaBackColor") >>= nParaBackColor;
+    xPropertySet7->getPropertyValue(u"ParaBackColor"_ustr) >>= nParaBackColor;
     CPPUNIT_ASSERT_EQUAL(COL_LIGHTRED, nParaBackColor);
 
     table::BorderLine2 aTopBorder;
-    xPropertySet7->getPropertyValue("TopBorder") >>= aTopBorder;
+    xPropertySet7->getPropertyValue(u"TopBorder"_ustr) >>= aTopBorder;
     CPPUNIT_ASSERT_EQUAL(sal_Int16(35), aTopBorder.OuterLineWidth);
 
     table::BorderLine2 aBottomBorder;
-    xPropertySet7->getPropertyValue("BottomBorder") >>= aBottomBorder;
+    xPropertySet7->getPropertyValue(u"BottomBorder"_ustr) >>= aBottomBorder;
     CPPUNIT_ASSERT_EQUAL(sal_Int16(35), aBottomBorder.OuterLineWidth);
 
     table::BorderLine2 aLeftBorder;
-    xPropertySet7->getPropertyValue("LeftBorder") >>= aLeftBorder;
+    xPropertySet7->getPropertyValue(u"LeftBorder"_ustr) >>= aLeftBorder;
     CPPUNIT_ASSERT_EQUAL(sal_Int16(35), aLeftBorder.OuterLineWidth);
 
     table::BorderLine2 aRightBorder;
-    xPropertySet7->getPropertyValue("RightBorder") >>= aRightBorder;
+    xPropertySet7->getPropertyValue(u"RightBorder"_ustr) >>= aRightBorder;
     CPPUNIT_ASSERT_EQUAL(sal_Int16(35), aRightBorder.OuterLineWidth);
 
     // centered
@@ -244,7 +245,7 @@ CPPUNIT_TEST_FIXTURE(LotusWordProTest, paragraphProperties)
                                                        uno::UNO_QUERY_THROW);
     uno::Reference<beans::XPropertySet> xPropertySet8(xParagraph8, uno::UNO_QUERY);
     sal_Int16 nParaAdjust = {}; // spurious -Werror=maybe-uninitialized
-    xPropertySet8->getPropertyValue("ParaAdjust") >>= nParaAdjust;
+    xPropertySet8->getPropertyValue(u"ParaAdjust"_ustr) >>= nParaAdjust;
     CPPUNIT_ASSERT_EQUAL(style::ParagraphAdjust_CENTER,
                          static_cast<style::ParagraphAdjust>(nParaAdjust));
 
@@ -253,7 +254,7 @@ CPPUNIT_TEST_FIXTURE(LotusWordProTest, paragraphProperties)
                                                        uno::UNO_QUERY_THROW);
     uno::Reference<beans::XPropertySet> xPropertySet9(xParagraph9, uno::UNO_QUERY);
     sal_Int32 nParaLeftMargin;
-    xPropertySet9->getPropertyValue("ParaLeftMargin") >>= nParaLeftMargin;
+    xPropertySet9->getPropertyValue(u"ParaLeftMargin"_ustr) >>= nParaLeftMargin;
     CPPUNIT_ASSERT_EQUAL(sal_Int32(2000), nParaLeftMargin);
 
     // double line spacing
@@ -261,7 +262,7 @@ CPPUNIT_TEST_FIXTURE(LotusWordProTest, paragraphProperties)
                                                         uno::UNO_QUERY_THROW);
     uno::Reference<beans::XPropertySet> xPropertySet10(xParagraph10, uno::UNO_QUERY);
     style::LineSpacing nParaLineSpacing;
-    xPropertySet10->getPropertyValue("ParaLineSpacing") >>= nParaLineSpacing;
+    xPropertySet10->getPropertyValue(u"ParaLineSpacing"_ustr) >>= nParaLineSpacing;
     CPPUNIT_ASSERT_EQUAL(sal_Int16(200), nParaLineSpacing.Height);
 
     // time new roman 12
@@ -269,10 +270,10 @@ CPPUNIT_TEST_FIXTURE(LotusWordProTest, paragraphProperties)
                                                         uno::UNO_QUERY_THROW);
     uno::Reference<beans::XPropertySet> xPropertySet11(xParagraph11, uno::UNO_QUERY);
     OUString sCharFontName;
-    xPropertySet11->getPropertyValue("CharFontName") >>= sCharFontName;
-    CPPUNIT_ASSERT_EQUAL(OUString("Times New Roman"), sCharFontName);
+    xPropertySet11->getPropertyValue(u"CharFontName"_ustr) >>= sCharFontName;
+    CPPUNIT_ASSERT_EQUAL(u"Times New Roman"_ustr, sCharFontName);
     float fCharFontHeight;
-    xPropertySet11->getPropertyValue("CharHeight") >>= fCharFontHeight;
+    xPropertySet11->getPropertyValue(u"CharHeight"_ustr) >>= fCharFontHeight;
     CPPUNIT_ASSERT_EQUAL(float(12.), fCharFontHeight);
 
     // time new roman 16
@@ -280,10 +281,10 @@ CPPUNIT_TEST_FIXTURE(LotusWordProTest, paragraphProperties)
                                                         uno::UNO_QUERY_THROW);
     uno::Reference<beans::XPropertySet> xPropertySet12(xParagraph12, uno::UNO_QUERY);
     OUString sCharFontName2;
-    xPropertySet12->getPropertyValue("CharFontName") >>= sCharFontName2;
-    CPPUNIT_ASSERT_EQUAL(OUString("Times New Roman"), sCharFontName2);
+    xPropertySet12->getPropertyValue(u"CharFontName"_ustr) >>= sCharFontName2;
+    CPPUNIT_ASSERT_EQUAL(u"Times New Roman"_ustr, sCharFontName2);
     float fCharFontHeight2;
-    xPropertySet12->getPropertyValue("CharHeight") >>= fCharFontHeight2;
+    xPropertySet12->getPropertyValue(u"CharHeight"_ustr) >>= fCharFontHeight2;
     CPPUNIT_ASSERT_EQUAL(float(16.), fCharFontHeight2);
 
     //ignore this paragraph
@@ -294,7 +295,7 @@ CPPUNIT_TEST_FIXTURE(LotusWordProTest, paragraphProperties)
                                                         uno::UNO_QUERY_THROW);
     uno::Reference<beans::XPropertySet> xPropertySet13(xParagraph13, uno::UNO_QUERY);
     Color nCharColor;
-    xPropertySet13->getPropertyValue("CharColor") >>= nCharColor;
+    xPropertySet13->getPropertyValue(u"CharColor"_ustr) >>= nCharColor;
     CPPUNIT_ASSERT_EQUAL(COL_LIGHTGREEN, nCharColor);
 }
 
diff --git a/lotuswordpro/qa/cppunit/test_lotuswordpro.cxx b/lotuswordpro/qa/cppunit/test_lotuswordpro.cxx
index f4c16903059f..784bb6af66f4 100644
--- a/lotuswordpro/qa/cppunit/test_lotuswordpro.cxx
+++ b/lotuswordpro/qa/cppunit/test_lotuswordpro.cxx
@@ -46,7 +46,7 @@ namespace
         test::BootstrapFixture::setUp();
 
         m_xFilter.set(m_xSFactory->createInstance(
-            "com.sun.star.comp.Writer.LotusWordProImportFilter"),
+            u"com.sun.star.comp.Writer.LotusWordProImportFilter"_ustr),
             uno::UNO_QUERY_THROW);
     }
 
@@ -54,7 +54,7 @@ namespace
         const OUString &rURL, const OUString &,
         SfxFilterFlags, SotClipboardFormatId, unsigned int)
     {
-        uno::Sequence aDescriptor{ comphelper::makePropertyValue("URL", rURL) };
+        uno::Sequence aDescriptor{ comphelper::makePropertyValue(u"URL"_ustr, rURL) };
         return m_xFilter->filter(aDescriptor);
     }
 
diff --git a/lotuswordpro/source/filter/LotusWordProImportFilter.cxx b/lotuswordpro/source/filter/LotusWordProImportFilter.cxx
index a4f9671760d6..ad1687bde41e 100644
--- a/lotuswordpro/source/filter/LotusWordProImportFilter.cxx
+++ b/lotuswordpro/source/filter/LotusWordProImportFilter.cxx
@@ -90,7 +90,7 @@ public:
             const uno::Reference< xml::sax::XAttributeList > & xAttribs) override
     {
         m_handler->startElement(aName, xAttribs);
-        m_debug->ignorableWhitespace(" "); // NOTE: needed for pretty-printing
+        m_debug->ignorableWhitespace(u" "_ustr); // NOTE: needed for pretty-printing
         m_debug->startElement(aName, xAttribs);
     }
 
@@ -98,7 +98,7 @@ public:
     endElement(const OUString& aName) override
     {
         m_handler->endElement(aName);
-        m_debug->ignorableWhitespace(" "); // NOTE: needed for pretty-printing
+        m_debug->ignorableWhitespace(u" "_ustr); // NOTE: needed for pretty-printing
         m_debug->endElement(aName);
     }
 
@@ -168,7 +168,7 @@ bool LotusWordProImportFilter::importImpl( const Sequence< css::beans::PropertyV
 
     // An XML import service: what we push sax messages to...
     uno::Reference< XDocumentHandler > xInternalHandler(
-        mxContext->getServiceManager()->createInstanceWithContext( "com.sun.star.comp.Writer.XMLImporter", mxContext ), UNO_QUERY );
+        mxContext->getServiceManager()->createInstanceWithContext( u"com.sun.star.comp.Writer.XMLImporter"_ustr, mxContext ), UNO_QUERY );
 
 #if OSL_DEBUG_LEVEL > 0
     std::unique_ptr<osl::File> pDebugFile;
@@ -224,7 +224,7 @@ void SAL_CALL LotusWordProImportFilter::setTargetDocument( const uno::Reference<
 // XExtendedFilterDetection
 OUString SAL_CALL LotusWordProImportFilter::detect( css::uno::Sequence< PropertyValue >& Descriptor )
 {
-    OUString sTypeName( "writer_LotusWordPro_Document" );
+    OUString sTypeName( u"writer_LotusWordPro_Document"_ustr );
     OUString sURL;
     uno::Reference < XInputStream > xInputStream;
     for (const PropertyValue& rValue : Descriptor)
@@ -271,7 +271,7 @@ void SAL_CALL LotusWordProImportFilter::initialize( const Sequence< Any >& /*aAr
 // XServiceInfo
 OUString SAL_CALL LotusWordProImportFilter::getImplementationName()
 {
-    return "com.sun.star.comp.Writer.LotusWordProImportFilter";
+    return u"com.sun.star.comp.Writer.LotusWordProImportFilter"_ustr;
 }
 
 sal_Bool SAL_CALL LotusWordProImportFilter::supportsService(const OUString& rServiceName)
@@ -281,7 +281,7 @@ sal_Bool SAL_CALL LotusWordProImportFilter::supportsService(const OUString& rSer
 
 Sequence<OUString> SAL_CALL LotusWordProImportFilter::getSupportedServiceNames()
 {
-    return { "com.sun.star.document.ImportFilter", "com.sun.star.document.ExtendedTypeDetection" };
+    return { u"com.sun.star.document.ImportFilter"_ustr, u"com.sun.star.document.ExtendedTypeDetection"_ustr };
 }
 
 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
diff --git a/lotuswordpro/source/filter/lwp9reader.cxx b/lotuswordpro/source/filter/lwp9reader.cxx
index dfcadf541fad..b11a5332401e 100644
--- a/lotuswordpro/source/filter/lwp9reader.cxx
+++ b/lotuswordpro/source/filter/lwp9reader.cxx
@@ -162,7 +162,7 @@ bool Lwp9Reader::ParseDocument()
 
     //Parse document content
     m_pStream->GetAttrList()->Clear();
-    m_pStream->StartElement("office:body");
+    m_pStream->StartElement(u"office:body"_ustr);
 
     //Parse change list
     LwpGlobalMgr* pGlobal = LwpGlobalMgr::GetInstance();
@@ -170,7 +170,7 @@ bool Lwp9Reader::ParseDocument()
     pChangeMgr->ConvertAllChange(m_pStream);
 
     doc->Parse(m_pStream);
-    m_pStream->EndElement("office:body");
+    m_pStream->EndElement(u"office:body"_ustr);
 
     WriteDocEnd();
     return true;
@@ -185,29 +185,29 @@ void Lwp9Reader::WriteDocHeader()
 
     IXFAttrList* pAttrList = m_pStream->GetAttrList();
 
-    pAttrList->AddAttribute("xmlns:office", "http://openoffice.org/2000/office");
-    pAttrList->AddAttribute("xmlns:style", "http://openoffice.org/2000/style");
-    pAttrList->AddAttribute("xmlns:text", "http://openoffice.org/2000/text");
-    pAttrList->AddAttribute("xmlns:table", "http://openoffice.org/2000/table");
-    pAttrList->AddAttribute("xmlns:draw", "http://openoffice.org/2000/drawing");
-
-    pAttrList->AddAttribute("xmlns:fo", "http://www.w3.org/1999/XSL/Format");
-    pAttrList->AddAttribute("xmlns:xlink", "http://www.w3.org/1999/xlink");
-    pAttrList->AddAttribute("xmlns:number", "http://openoffice.org/2000/datastyle");
-    pAttrList->AddAttribute("xmlns:svg", "http://www.w3.org/2000/svg");
-    pAttrList->AddAttribute("xmlns:chart", "http://openoffice.org/2000/chart");
-
-    pAttrList->AddAttribute("xmlns:dr3d", "http://openoffice.org/2000/dr3d");
-    pAttrList->AddAttribute("xmlns:math", "http://www.w3.org/1998/Math/MathML");
-    pAttrList->AddAttribute("xmlns:form", "http://openoffice.org/2000/form");
-    pAttrList->AddAttribute("xmlns:script", "http://openoffice.org/2000/script");
-    pAttrList->AddAttribute("xmlns:dc", "http://purl.org/dc/elements/1.1/");
-
-    pAttrList->AddAttribute("xmlns:meta", "http://openoffice.org/2000/meta");
-    pAttrList->AddAttribute("office:class", "text");
-    pAttrList->AddAttribute("office:version", "1.0");
-
-    m_pStream->StartElement("office:document");
+    pAttrList->AddAttribute(u"xmlns:office"_ustr, u"http://openoffice.org/2000/office"_ustr);
+    pAttrList->AddAttribute(u"xmlns:style"_ustr, u"http://openoffice.org/2000/style"_ustr);
+    pAttrList->AddAttribute(u"xmlns:text"_ustr, u"http://openoffice.org/2000/text"_ustr);
+    pAttrList->AddAttribute(u"xmlns:table"_ustr, u"http://openoffice.org/2000/table"_ustr);
+    pAttrList->AddAttribute(u"xmlns:draw"_ustr, u"http://openoffice.org/2000/drawing"_ustr);
+
+    pAttrList->AddAttribute(u"xmlns:fo"_ustr, u"http://www.w3.org/1999/XSL/Format"_ustr);
+    pAttrList->AddAttribute(u"xmlns:xlink"_ustr, u"http://www.w3.org/1999/xlink"_ustr);
+    pAttrList->AddAttribute(u"xmlns:number"_ustr, u"http://openoffice.org/2000/datastyle"_ustr);
+    pAttrList->AddAttribute(u"xmlns:svg"_ustr, u"http://www.w3.org/2000/svg"_ustr);
+    pAttrList->AddAttribute(u"xmlns:chart"_ustr, u"http://openoffice.org/2000/chart"_ustr);
+
+    pAttrList->AddAttribute(u"xmlns:dr3d"_ustr, u"http://openoffice.org/2000/dr3d"_ustr);
+    pAttrList->AddAttribute(u"xmlns:math"_ustr, u"http://www.w3.org/1998/Math/MathML"_ustr);
+    pAttrList->AddAttribute(u"xmlns:form"_ustr, u"http://openoffice.org/2000/form"_ustr);
+    pAttrList->AddAttribute(u"xmlns:script"_ustr, u"http://openoffice.org/2000/script"_ustr);
+    pAttrList->AddAttribute(u"xmlns:dc"_ustr, u"http://purl.org/dc/elements/1.1/"_ustr);
+
+    pAttrList->AddAttribute(u"xmlns:meta"_ustr, u"http://openoffice.org/2000/meta"_ustr);
+    pAttrList->AddAttribute(u"office:class"_ustr, u"text"_ustr);
+    pAttrList->AddAttribute(u"office:version"_ustr, u"1.0"_ustr);
+
+    m_pStream->StartElement(u"office:document"_ustr);
     pAttrList->Clear();
 }
 /**
@@ -215,7 +215,7 @@ void Lwp9Reader::WriteDocHeader()
  */
 void Lwp9Reader::WriteDocEnd()
 {
-    m_pStream->EndElement("office:document");
+    m_pStream->EndElement(u"office:document"_ustr);
     m_pStream->EndDocument();
 }
 
diff --git a/lotuswordpro/source/filter/lwparrowstyles.hxx b/lotuswordpro/source/filter/lwparrowstyles.hxx
index 55b0a3b148f9..b5c87e697129 100644
--- a/lotuswordpro/source/filter/lwparrowstyles.hxx
+++ b/lotuswordpro/source/filter/lwparrowstyles.hxx
@@ -72,30 +72,30 @@ void RegisteArrowStyles()
         return;
     //reversed arrow:
     std::unique_ptr<XFArrowStyle> pArrowStyle100(new XFArrowStyle());
-    pArrowStyle100->SetArrowName("arrow100");
-    pArrowStyle100->SetViewbox("0 0 140 200");
-    pArrowStyle100->SetSVGPath("M0 180 L70 0 L140 180 L120 180 L70 30 L20 180 L0 180");
+    pArrowStyle100->SetArrowName(u"arrow100"_ustr);
+    pArrowStyle100->SetViewbox(u"0 0 140 200"_ustr);
+    pArrowStyle100->SetSVGPath(u"M0 180 L70 0 L140 180 L120 180 L70 30 L20 180 L0 180"_ustr);
     pXFStyleManager->AddStyle(std::move(pArrowStyle100));
 
     //reversed arrow:
     std::unique_ptr<XFArrowStyle> pArrowStyle1(new XFArrowStyle());
-    pArrowStyle1->SetArrowName("reverse arrow");
-    pArrowStyle1->SetViewbox("0 0 140 200");
-    pArrowStyle1->SetSVGPath("M0 0 L70 200 L140 0");
+    pArrowStyle1->SetArrowName(u"reverse arrow"_ustr);
+    pArrowStyle1->SetViewbox(u"0 0 140 200"_ustr);
+    pArrowStyle1->SetSVGPath(u"M0 0 L70 200 L140 0"_ustr);
     pXFStyleManager->AddStyle(std::move(pArrowStyle1));
 
     //reversed concave arrow
     std::unique_ptr<XFArrowStyle> pArrowStyle2(new XFArrowStyle());
-    pArrowStyle2->SetArrowName("reverse concave arrow");
-    pArrowStyle2->SetViewbox("0 0 140 200");
-    pArrowStyle2->SetSVGPath("M0 0 L80 200 L160 0 L80 100");
+    pArrowStyle2->SetArrowName(u"reverse concave arrow"_ustr);
+    pArrowStyle2->SetViewbox(u"0 0 140 200"_ustr);
+    pArrowStyle2->SetSVGPath(u"M0 0 L80 200 L160 0 L80 100"_ustr);
     pXFStyleManager->AddStyle(std::move(pArrowStyle2));
 
     //reversed line arrow
     std::unique_ptr<XFArrowStyle> pArrowStyle3(new XFArrowStyle());
-    pArrowStyle3->SetArrowName("reverse line arrow");
-    pArrowStyle3->SetViewbox("0 0 140 200");
-    pArrowStyle3->SetSVGPath("M0 0 L70 200 L140 0L110 0 L70 160 L20 0 L0 0");
+    pArrowStyle3->SetArrowName(u"reverse line arrow"_ustr);
+    pArrowStyle3->SetViewbox(u"0 0 140 200"_ustr);
+    pArrowStyle3->SetSVGPath(u"M0 0 L70 200 L140 0L110 0 L70 160 L20 0 L0 0"_ustr);
     pXFStyleManager->AddStyle(std::move(pArrowStyle3));
 }
 
diff --git a/lotuswordpro/source/filter/lwpbulletstylemgr.cxx b/lotuswordpro/source/filter/lwpbulletstylemgr.cxx
index 9a9bca7fec36..b633f9d18626 100644
--- a/lotuswordpro/source/filter/lwpbulletstylemgr.cxx
+++ b/lotuswordpro/source/filter/lwpbulletstylemgr.cxx
@@ -223,7 +223,7 @@ OUString LwpBulletStyleMgr::RegisterBulletStyle(LwpPara* pPara, const LwpBulletO
                     }
 
                     pListStyle->SetListBullet(nPos, LwpSilverBullet::GetNumCharByStyleID(pParaNumber),
-                        "Times New Roman", aPrefix, aSuffix);
+                        u"Times New Roman"_ustr, aPrefix, aSuffix);
                 }
 
                 pListStyle->SetListPosition(nPos, 0.0, 0.635, 0.0);
diff --git a/lotuswordpro/source/filter/lwpchangemgr.cxx b/lotuswordpro/source/filter/lwpchangemgr.cxx
index ee8c8f8dd8df..833beee4cd78 100644
--- a/lotuswordpro/source/filter/lwpchangemgr.cxx
+++ b/lotuswordpro/source/filter/lwpchangemgr.cxx
@@ -121,12 +121,12 @@ void LwpChangeMgr::ConvertAllChange(IXFStream* pStream)
     if (m_ChangeList.empty())
         return;
     // Add for disable change tracking
-    pStream->GetAttrList()->AddAttribute("text:track-changes", "false");
-    pStream->StartElement("text:tracked-changes");
+    pStream->GetAttrList()->AddAttribute(u"text:track-changes"_ustr, u"false"_ustr);
+    pStream->StartElement(u"text:tracked-changes"_ustr);
     for (auto const& elem : m_ChangeList)
         elem->ToXml(pStream);
 
-    pStream->EndElement("text:tracked-changes");
+    pStream->EndElement(u"text:tracked-changes"_ustr);
 
     m_ChangeList.clear();
 }
diff --git a/lotuswordpro/source/filter/lwpdoc.cxx b/lotuswordpro/source/filter/lwpdoc.cxx
index a00f29e0c9ce..8a2b0de32944 100644
--- a/lotuswordpro/source/filter/lwpdoc.cxx
+++ b/lotuswordpro/source/filter/lwpdoc.cxx
@@ -367,7 +367,7 @@ void LwpDocument::RegisterFootnoteStyles()
             = dynamic_cast<LwpFootnoteOptions*>(m_FootnoteOpts.obj().get());
         if (pFootnoteOpts)
         {
-            pFootnoteOpts->SetMasterPage("Endnote");
+            pFootnoteOpts->SetMasterPage(u"Endnote"_ustr);
             pFootnoteOpts->RegisterStyle();
         }
     }
@@ -788,7 +788,7 @@ void LwpDocument::ChangeStyleName()
     XFTextStyle* pStyle = dynamic_cast<XFTextStyle*>(pXFStyleManager->FindStyle(u"ClickHere"));
     if (pStyle)
     {
-        pStyle->SetStyleName("Placeholder");
+        pStyle->SetStyleName(u"Placeholder"_ustr);
     }
 }
 LwpDocSock::LwpDocSock(LwpObjectHeader const& objHdr, LwpSvStream* pStrm)
diff --git a/lotuswordpro/source/filter/lwpfrib.cxx b/lotuswordpro/source/filter/lwpfrib.cxx
index fb4c47ebd84e..50196175cca6 100644
--- a/lotuswordpro/source/filter/lwpfrib.cxx
+++ b/lotuswordpro/source/filter/lwpfrib.cxx
@@ -252,7 +252,7 @@ void LwpFrib::RegisterStyle(LwpFoundry* pFoundry)
             std::unique_ptr<XFTextStyle> pNewStyle(new XFTextStyle());
             *pNewStyle = *pNamedStyle;
 
-            pNewStyle->SetStyleName("");
+            pNewStyle->SetStyleName(u""_ustr);
             pFont = pFoundry->GetFontManager().CreateOverrideFont(pCharStyle->GetFinalFontID(),
                                                                   m_pModifiers->FontID);
             pNewStyle->SetFont(pFont);
diff --git a/lotuswordpro/source/filter/lwpfribbreaks.cxx b/lotuswordpro/source/filter/lwpfribbreaks.cxx
index 52dd3e8ae1d1..6ccf14b2d9dc 100644
--- a/lotuswordpro/source/filter/lwpfribbreaks.cxx
+++ b/lotuswordpro/source/filter/lwpfribbreaks.cxx
@@ -75,7 +75,7 @@ void LwpFribColumnBreak::RegisterBreakStyle(LwpPara* pPara)
 
     std::unique_ptr<XFParaStyle> pOverStyle(new XFParaStyle);
     *pOverStyle = *pBaseStyle;
-    pOverStyle->SetStyleName("");
+    pOverStyle->SetStyleName(u""_ustr);
 
     //New code
     LwpStory* pStory = dynamic_cast<LwpStory*>(pPara->GetStoryID().obj().get());
@@ -128,7 +128,7 @@ void LwpFribPageBreak::RegisterBreakStyle(LwpPara* pPara)
 
     std::unique_ptr<XFParaStyle> pOverStyle(new XFParaStyle);
     *pOverStyle = *pBaseStyle;
-    pOverStyle->SetStyleName("");
+    pOverStyle->SetStyleName(u""_ustr);
     pOverStyle->SetMasterPage(pBaseStyle->GetMasterPage());
 
     if (!GetNext() || GetNext()->GetType() == FRIB_TAG_EOP)
diff --git a/lotuswordpro/source/filter/lwpfribmark.cxx b/lotuswordpro/source/filter/lwpfribmark.cxx
index f4e35c0d8477..2dda5912fbca 100644
--- a/lotuswordpro/source/filter/lwpfribmark.cxx
+++ b/lotuswordpro/source/filter/lwpfribmark.cxx
@@ -199,9 +199,9 @@ void LwpFribBookMark::XFConvert(XFContentContainer* pXFPara)
 LwpFribField::LwpFribField(LwpPara* pPara)
     : LwpFrib(pPara)
     , m_nType(0)
-    , m_TimeStyle("")
+    , m_TimeStyle(u""_ustr)
     , m_nSubType(0)
-    , m_sFormula("")
+    , m_sFormula(u""_ustr)
     , m_nCrossRefType(0)
     , m_nDateTimeType(0)
     , m_nDocPowerType(0)
@@ -245,7 +245,7 @@ void LwpFribField::XFConvert(XFContentContainer* pXFPara)
         if (pFieldMark->IsFormulaInsert())
         {
             XFTextContent* pSpan = new XFTextContent();
-            pSpan->SetText(">");
+            pSpan->SetText(u">"_ustr);
             pXFPara->Add(pSpan);
         }
         if (fieldType == LwpFieldMark::FLD_FIELD)
@@ -329,7 +329,7 @@ void LwpFribField::XFConvert(XFContentContainer* pXFPara)
     if (pFieldMark->IsFormulaInsert())
     {
         XFTextContent* pSpan = new XFTextContent();
-        pSpan->SetText("<");
+        pSpan->SetText(u"<"_ustr);
         pXFPara->Add(pSpan);
     }
 
@@ -409,119 +409,119 @@ void LwpFribField::RegisterDateTimeStyle(std::u16string_view sFormula)
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddYear();
-            pDateStyle->AddText("/");
+            pDateStyle->AddText(u"/"_ustr);
             pDateStyle->AddMonth();
-            pDateStyle->AddText("/");
+            pDateStyle->AddText(u"/"_ustr);
             pDateStyle->AddMonthDay();
         }
         else if (sFormula == u"%FLISODate2" || sFormula == u"%FLYYYY/MM/DD HH:mm:SS")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddYear();
-            pDateStyle->AddText("/");
+            pDateStyle->AddText(u"/"_ustr);
             pDateStyle->AddMonth();
-            pDateStyle->AddText("/");
+            pDateStyle->AddText(u"/"_ustr);
             pDateStyle->AddMonthDay();
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddHour();
-            pDateStyle->AddText(":");
+            pDateStyle->AddText(u":"_ustr);
             pDateStyle->AddMinute();
-            pDateStyle->AddText(":");
+            pDateStyle->AddText(u":"_ustr);
             pDateStyle->AddSecond();
         }
         else if (sFormula == u"%FLM/D/YY")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddMonth(false);
-            pDateStyle->AddText("/");
+            pDateStyle->AddText(u"/"_ustr);
             pDateStyle->AddMonthDay(false);
-            pDateStyle->AddText("/");
+            pDateStyle->AddText(u"/"_ustr);
             pDateStyle->AddYear(false);
         }
         else if (sFormula == u"%FLMonth D, YYYY")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddMonth(true, true);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonthDay(false);
-            pDateStyle->AddText(", ");
+            pDateStyle->AddText(u", "_ustr);
             pDateStyle->AddYear();
         }
         else if (sFormula == u"%FLWeekday, Month D, YYYY")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddWeekDay();
-            pDateStyle->AddText(", ");
+            pDateStyle->AddText(u", "_ustr);
             pDateStyle->AddMonth(true, true);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonthDay(false);
-            pDateStyle->AddText(", ");
+            pDateStyle->AddText(u", "_ustr);
             pDateStyle->AddYear();
         }
         else if (sFormula == u"%FLMn D, YYYY")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddMonth(false, true);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonthDay(false);
-            pDateStyle->AddText(", ");
+            pDateStyle->AddText(u", "_ustr);
             pDateStyle->AddYear();
         }
         else if (sFormula == u"%FLWday, Mn D, YYYY")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddWeekDay(false);
-            pDateStyle->AddText(", ");
+            pDateStyle->AddText(u", "_ustr);
             pDateStyle->AddMonth(false, true);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonthDay(false);
-            pDateStyle->AddText(", ");
+            pDateStyle->AddText(u", "_ustr);
             pDateStyle->AddYear();
         }
         else if (sFormula == u"%FLMn D")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddMonth(false, true);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonthDay(false);
         }
         else if (sFormula == u"%FLWeekday, Mn D")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddWeekDay();
-            pDateStyle->AddText(", ");
+            pDateStyle->AddText(u", "_ustr);
             pDateStyle->AddMonth(false, true);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonthDay(false);
         }
         else if (sFormula == u"%FLMn D, YY")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddMonth(false, true);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonthDay(false);
-            pDateStyle->AddText(", ");
+            pDateStyle->AddText(u", "_ustr);
             pDateStyle->AddYear(false);
         }
         else if (sFormula == u"%FLM/D")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddMonth(false);
-            pDateStyle->AddText("/");
+            pDateStyle->AddText(u"/"_ustr);
             pDateStyle->AddMonthDay(false);
         }
         else if (sFormula == u"%FLM/YY")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddMonth(false);
-            pDateStyle->AddText("/");
+            pDateStyle->AddText(u"/"_ustr);
             pDateStyle->AddYear(false);
         }
         else if (sFormula == u"%FLMn YY")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddMonth(false, true);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddYear(false);
         }
         else if (sFormula == u"%FLWeekday")
@@ -569,49 +569,49 @@ void LwpFribField::RegisterDateTimeStyle(std::u16string_view sFormula)
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddYear(false);
-            pDateStyle->AddText("-");
+            pDateStyle->AddText(u"-"_ustr);
             pDateStyle->AddMonth(false);
-            pDateStyle->AddText("-");
+            pDateStyle->AddText(u"-"_ustr);
             pDateStyle->AddMonthDay(false);
         }
         else if (sFormula == u"%FLYYYY Month D")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddYear();
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonth(true, true);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonthDay(false);
         }
         else if (sFormula == u"%FLWeekday, YYYY Month D")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddWeekDay();
-            pDateStyle->AddText(",");
+            pDateStyle->AddText(u","_ustr);
             pDateStyle->AddYear();
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonth(true, true);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonthDay(false);
         }
         else if (sFormula == u"%FLYYYY Mn D")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddYear();
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonth(false, true);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonthDay(false);
         }
         else if (sFormula == u"%FLWday, YYYY Mn D")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddWeekDay(false);
-            pDateStyle->AddText(",");
+            pDateStyle->AddText(u","_ustr);
             pDateStyle->AddYear();
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonth(true, true);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonthDay(false);
         }
         //next 2 are the same with english version
@@ -619,23 +619,23 @@ void LwpFribField::RegisterDateTimeStyle(std::u16string_view sFormula)
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddYear(false);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonth(false, true);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonthDay(false);
         }
         else if (sFormula == u"%FLYY/M")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddMonth(false);
-            pDateStyle->AddText("-");
+            pDateStyle->AddText(u"-"_ustr);
             pDateStyle->AddMonth(false);
         }
         else if (sFormula == u"%FLYY Mn")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddMonth(false);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonth(false, true);
         }
         else if (sFormula == u"%FLeeeeoa" || sFormula == u"%FLffffooaa" || sFormula == u"%FLEEEEOA")
@@ -667,18 +667,18 @@ void LwpFribField::RegisterDateTimeStyle(std::u16string_view sFormula)
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddYear();
-            pDateStyle->AddText("-");
+            pDateStyle->AddText(u"-"_ustr);
             pDateStyle->AddMonth(false);
-            pDateStyle->AddText("-");
+            pDateStyle->AddText(u"-"_ustr);
             pDateStyle->AddMonthDay(false);
         }
         else if (sFormula == u"%FLYY.M.D")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddYear(false);
-            pDateStyle->AddText(".");
+            pDateStyle->AddText(u"."_ustr);
             pDateStyle->AddMonth(false);
-            pDateStyle->AddText(".");
+            pDateStyle->AddText(u"."_ustr);
             pDateStyle->AddMonthDay(false);
         }
         //chinese version end
@@ -687,182 +687,182 @@ void LwpFribField::RegisterDateTimeStyle(std::u16string_view sFormula)
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddWeekDay();
-            pDateStyle->AddText(", ");
+            pDateStyle->AddText(u", "_ustr);
             pDateStyle->AddMonth(true, true);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonthDay();
-            pDateStyle->AddText(", ");
+            pDateStyle->AddText(u", "_ustr);
             pDateStyle->AddYear();
         }
         else if (sFormula == u"%FLYYYY/MM/DD")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddWeekDay();
-            pDateStyle->AddText(", ");
+            pDateStyle->AddText(u", "_ustr);
             pDateStyle->AddMonth(true, true);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonthDay();
-            pDateStyle->AddText(", ");
+            pDateStyle->AddText(u", "_ustr);
             pDateStyle->AddYear();
         }
         else if (sFormula == u"%FLD/M/YY")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddMonthDay(false);
-            pDateStyle->AddText("/");
+            pDateStyle->AddText(u"/"_ustr);
             pDateStyle->AddMonth(false);
-            pDateStyle->AddText("/");
+            pDateStyle->AddText(u"/"_ustr);
             pDateStyle->AddYear(false);
         }
         else if (sFormula == u"%FLD Month YYYY")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddMonthDay(false);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonth(true, true);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddYear();
         }
         else if (sFormula == u"%FLDD Month YYYY")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddMonthDay();
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonth(true, true);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddYear();
         }
         else if (sFormula == u"%FLWeekday, D Month YYYY")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddWeekDay();
-            pDateStyle->AddText(", ");
+            pDateStyle->AddText(u", "_ustr);
             pDateStyle->AddMonthDay(false);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonth(true, true);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddYear();
         }
         else if (sFormula == u"%FLWeekday, DD Month YYYY")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddWeekDay();
-            pDateStyle->AddText(", ");
+            pDateStyle->AddText(u", "_ustr);
             pDateStyle->AddMonthDay();
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonth(true, true);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddYear();
         }
         else if (sFormula == u"%FLD Mn YYYY")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddMonthDay(false);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonth(false, true);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddYear();
         }
         else if (sFormula == u"%FLWday, D Mn YYYY")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddWeekDay(false);
-            pDateStyle->AddText(", ");
+            pDateStyle->AddText(u", "_ustr);
             pDateStyle->AddMonthDay(false);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonth(false, true);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddYear();
         }
         else if (sFormula == u"%FLWday, DD Mn YYYY")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddWeekDay(false);
-            pDateStyle->AddText(", ");
+            pDateStyle->AddText(u", "_ustr);
             pDateStyle->AddMonthDay();
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonth(false, true);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddYear();
         }
         else if (sFormula == u"%FLD Mn")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddMonthDay(false);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonth(false, true);
         }
         else if (sFormula == u"%FLDD Mn")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddMonthDay();
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonth(false, true);
         }
         else if (sFormula == u"%FLWeekday, D Mn")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddWeekDay();
-            pDateStyle->AddText(", ");
+            pDateStyle->AddText(u", "_ustr);
             pDateStyle->AddMonthDay(false);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonth(false, true);
         }
         else if (sFormula == u"%FLWeekday, DD Mn")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddWeekDay();
-            pDateStyle->AddText(", ");
+            pDateStyle->AddText(u", "_ustr);
             pDateStyle->AddMonthDay();
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonth(false, true);
         }
         else if (sFormula == u"%FLD Mn YY")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddMonthDay(false);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonth(false, true);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddYear(false);
         }
         else if (sFormula == u"%FLDD Mn YY")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddMonthDay();
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonth(false, true);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddYear(false);
         }
         else if (sFormula == u"%FLD/M")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddMonthDay(false);
-            pDateStyle->AddText("/");
+            pDateStyle->AddText(u"/"_ustr);
             pDateStyle->AddMonth(false);
         }
         else if (sFormula == u"%FLDD/MM")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddMonthDay();
-            pDateStyle->AddText("/");
+            pDateStyle->AddText(u"/"_ustr);
             pDateStyle->AddMonth();
         }
         else if (sFormula == u"%FLDD/MM/YY")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddMonthDay();
-            pDateStyle->AddText("/");
+            pDateStyle->AddText(u"/"_ustr);
             pDateStyle->AddMonth();
-            pDateStyle->AddText("/");
+            pDateStyle->AddText(u"/"_ustr);
             pDateStyle->AddYear(false);
         }
         else if (sFormula == u"%FLMM/YY")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddMonth();
-            pDateStyle->AddText("/");
+            pDateStyle->AddText(u"/"_ustr);
             pDateStyle->AddYear(false);
         }
         //other version end
@@ -875,52 +875,52 @@ void LwpFribField::RegisterDateTimeStyle(std::u16string_view sFormula)
         {
             pTimeStyle.reset(new XFTimeStyle);
             pTimeStyle->AddHour();
-            pTimeStyle->AddText(":");
+            pTimeStyle->AddText(u":"_ustr);
             pTimeStyle->AddMinute();
-            pTimeStyle->AddText(":");
+            pTimeStyle->AddText(u":"_ustr);
             pTimeStyle->AddSecond();
         }
         else if (sFormula == u"%FLH:mm ampm")
         {
             pTimeStyle.reset(new XFTimeStyle);
             pTimeStyle->AddHour(false);
-            pTimeStyle->AddText(":");
+            pTimeStyle->AddText(u":"_ustr);
             pTimeStyle->AddMinute();
-            pTimeStyle->AddText(" ");
+            pTimeStyle->AddText(u" "_ustr);
             pTimeStyle->SetAmPm(true);
         }
         else if (sFormula == u"%FLH:mm")
         {
             pTimeStyle.reset(new XFTimeStyle);
             pTimeStyle->AddHour(false);
-            pTimeStyle->AddText(":");
+            pTimeStyle->AddText(u":"_ustr);
             pTimeStyle->AddMinute();
         }
         else if (sFormula == u"%FLH:mm:SS ampm")
         {
             pTimeStyle.reset(new XFTimeStyle);
             pTimeStyle->AddHour(false);
-            pTimeStyle->AddText(":");
+            pTimeStyle->AddText(u":"_ustr);
             pTimeStyle->AddMinute();
-            pTimeStyle->AddText(":");
+            pTimeStyle->AddText(u":"_ustr);
             pTimeStyle->AddSecond();
-            pTimeStyle->AddText(" ");
+            pTimeStyle->AddText(u" "_ustr);
             pTimeStyle->SetAmPm(true);
         }
         else if (sFormula == u"%FLH:mm:SS")
         {
             pTimeStyle.reset(new XFTimeStyle);
             pTimeStyle->AddHour(false);
-            pTimeStyle->AddText(":");
+            pTimeStyle->AddText(u":"_ustr);
             pTimeStyle->AddMinute();
-            pTimeStyle->AddText(":");
+            pTimeStyle->AddText(u":"_ustr);
             pTimeStyle->AddSecond();
         }
         else if (sFormula == u"%FLH ampm")
         {
             pTimeStyle.reset(new XFTimeStyle);
             pTimeStyle->AddHour(false);
-            pTimeStyle->AddText(" ");
+            pTimeStyle->AddText(u" "_ustr);
             pTimeStyle->SetAmPm(true);
         }
         else if (sFormula == u"%FLH")
@@ -974,43 +974,43 @@ void LwpFribField::RegisterDateTimeStyle(std::u16string_view sFormula)
         {
             pTimeStyle.reset(new XFTimeStyle);
             pTimeStyle->AddHour();
-            pTimeStyle->AddText(":");
+            pTimeStyle->AddText(u":"_ustr);
             pTimeStyle->AddMinute();
-            pTimeStyle->AddText(" ");
+            pTimeStyle->AddText(u" "_ustr);
             pTimeStyle->SetAmPm(true);
         }
         else if (sFormula == u"%FLHH ampm")
         {
             pTimeStyle.reset(new XFTimeStyle);
             pTimeStyle->AddHour();
-            pTimeStyle->AddText(" ");
+            pTimeStyle->AddText(u" "_ustr);
             pTimeStyle->SetAmPm(true);
         }
         else if (sFormula == u"%FLHH:mm:SS ampm")
         {
             pTimeStyle.reset(new XFTimeStyle);
             pTimeStyle->AddHour();
-            pTimeStyle->AddText(":");
+            pTimeStyle->AddText(u":"_ustr);
             pTimeStyle->AddMinute();
-            pTimeStyle->AddText(":");
+            pTimeStyle->AddText(u":"_ustr);
             pTimeStyle->AddSecond();
-            pTimeStyle->AddText(" ");
+            pTimeStyle->AddText(u" "_ustr);
             pTimeStyle->SetAmPm(true);
         }
         else if (sFormula == u"%FLHH:mm")
         {
             pTimeStyle.reset(new XFTimeStyle);
             pTimeStyle->AddHour();
-            pTimeStyle->AddText(":");
+            pTimeStyle->AddText(u":"_ustr);
             pTimeStyle->AddMinute();
         }
         else if (sFormula == u"%FLHH:mm:SS")
         {
             pTimeStyle.reset(new XFTimeStyle);
             pTimeStyle->AddHour();
-            pTimeStyle->AddText(":");
+            pTimeStyle->AddText(u":"_ustr);
             pTimeStyle->AddMinute();
-            pTimeStyle->AddText(":");
+            pTimeStyle->AddText(u":"_ustr);
             pTimeStyle->AddSecond();
         }
         //other version end
@@ -1025,102 +1025,102 @@ void LwpFribField::RegisterDateTimeStyle(std::u16string_view sFormula)
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddMonth(true, true);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonthDay(false);
-            pDateStyle->AddText(", ");
+            pDateStyle->AddText(u", "_ustr);
             pDateStyle->AddYear();
         }
         else if (sFormula == u"%Dc" || sFormula == u"%DC")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddMonthDay(false);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonth(true, true);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddYear();
         }
         else if (sFormula == u"%Dd" || sFormula == u"%DD")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddWeekDay();
-            pDateStyle->AddText(", ");
+            pDateStyle->AddText(u", "_ustr);
             pDateStyle->AddMonth(true, true);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonthDay(false);
-            pDateStyle->AddText(", ");
+            pDateStyle->AddText(u", "_ustr);
             pDateStyle->AddYear();
         }
         else if (sFormula == u"%DE" || sFormula == u"%De")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddMonth(true, true);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonthDay(false);
         }
         else if (sFormula == u"%Df" || sFormula == u"%DF")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddWeekDay();
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonth(true, true);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonthDay(false);
         }
         else if (sFormula == u"%Dg")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddMonth(false);
-            pDateStyle->AddText("/");
+            pDateStyle->AddText(u"/"_ustr);
             pDateStyle->AddMonthDay(false);
         }
         else if (sFormula == u"%Dh")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddMonth(false);
-            pDateStyle->AddText("/");
+            pDateStyle->AddText(u"/"_ustr);
             pDateStyle->AddMonthDay(false);
-            pDateStyle->AddText("/");
+            pDateStyle->AddText(u"/"_ustr);
             pDateStyle->AddYear();
         }
         else if (sFormula == u"%Di" || sFormula == u"%DI")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddMonthDay(false);
-            pDateStyle->AddText(".");
+            pDateStyle->AddText(u"."_ustr);
             pDateStyle->AddMonth(true, true);
         }
         else if (sFormula == u"%Dj" || sFormula == u"%DJ")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddMonthDay(false);
-            pDateStyle->AddText(".");
+            pDateStyle->AddText(u"."_ustr);
             pDateStyle->AddMonth(true, true);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddYear();
         }
         else if (sFormula == u"%Dk" || sFormula == u"%DK")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddYear();
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonth(true, true);
-            pDateStyle->AddText(" ");
+            pDateStyle->AddText(u" "_ustr);
             pDateStyle->AddMonthDay(false);
         }
         else if (sFormula == u"%DL" || sFormula == u"%Dl")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddMonth(true, true);
-            pDateStyle->AddText(",");
+            pDateStyle->AddText(u","_ustr);
             pDateStyle->AddYear();
         }
         else if (sFormula == u"%Dm")
         {
             pDateStyle.reset(new XFDateStyle);
             pDateStyle->AddMonthDay();
-            pDateStyle->AddText("/");
+            pDateStyle->AddText(u"/"_ustr);
             pDateStyle->AddMonth();
-            pDateStyle->AddText("/");
+            pDateStyle->AddText(u"/"_ustr);
             pDateStyle->AddYear();
         }
     }
@@ -1130,7 +1130,7 @@ void LwpFribField::RegisterDateTimeStyle(std::u16string_view sFormula)
         {
             pTimeStyle.reset(new XFTimeStyle);
             pTimeStyle->AddHour();
-            pTimeStyle->AddText(":");
+            pTimeStyle->AddText(u":"_ustr);
             pTimeStyle->AddMinute();
         }
         else if (sFormula == u"%T2" || sFormula == u"%T6" || sFormula == u"%T4"
@@ -1138,9 +1138,9 @@ void LwpFribField::RegisterDateTimeStyle(std::u16string_view sFormula)
         {
             pTimeStyle.reset(new XFTimeStyle);
             pTimeStyle->AddHour(false);
-            pTimeStyle->AddText(":");
+            pTimeStyle->AddText(u":"_ustr);
             pTimeStyle->AddMinute();
-            pTimeStyle->AddText(":");
+            pTimeStyle->AddText(u":"_ustr);
             pTimeStyle->SetAmPm(true);
         }
         else if (sFormula == u"%T3" || sFormula == u"%T7" || sFormula == u"%T5"
@@ -1148,9 +1148,9 @@ void LwpFribField::RegisterDateTimeStyle(std::u16string_view sFormula)
         {
             pTimeStyle.reset(new XFTimeStyle);
             pTimeStyle->AddHour();
-            pTimeStyle->AddText(":");
+            pTimeStyle->AddText(u":"_ustr);
             pTimeStyle->AddMinute();
-            pTimeStyle->AddText(":");
+            pTimeStyle->AddText(u":"_ustr);
             pTimeStyle->SetAmPm(true);
         }
     }
diff --git a/lotuswordpro/source/filter/lwpfribsection.cxx b/lotuswordpro/source/filter/lwpfribsection.cxx
index a65763f38bd0..c7975129e5f7 100644
--- a/lotuswordpro/source/filter/lwpfribsection.cxx
+++ b/lotuswordpro/source/filter/lwpfribsection.cxx
@@ -177,35 +177,35 @@ void LwpFribSection::ParseSection()
 void LwpFribSection::SetDefaultAlphaIndex(XFIndex* pXFIndex)
 {
     LwpFoundry* pFoundry = m_pPara->GetFoundry();
-    OUString styleName = pFoundry->FindActualStyleName("Separator");
+    OUString styleName = pFoundry->FindActualStyleName(u"Separator"_ustr);
 
     LwpIndexSection* pIndexSection = dynamic_cast<LwpIndexSection*>(m_Section.obj().get());
     XFIndexTemplate* pTemplateSep = new XFIndexTemplate();
     if (pIndexSection && pIndexSection->IsFormatSeparator())
     {
         pXFIndex->SetSeparator(true);
-        pTemplateSep->AddEntry(enumXFIndexTemplateText, "");
+        pTemplateSep->AddEntry(enumXFIndexTemplateText, u""_ustr);
     }
     //pXFIndex->AddTemplate("separator","Separator",pTemplateSep);
-    pXFIndex->AddTemplate("separator", styleName, pTemplateSep);
+    pXFIndex->AddTemplate(u"separator"_ustr, styleName, pTemplateSep);
 
-    styleName = pFoundry->FindActualStyleName("Primary");
+    styleName = pFoundry->FindActualStyleName(u"Primary"_ustr);
 
     XFIndexTemplate* pTemplate1 = new XFIndexTemplate();
-    pTemplate1->AddEntry(enumXFIndexTemplateText, "");
-    pTemplate1->AddEntry(enumXFIndexTemplateTab, "");
-    pTemplate1->AddEntry(enumXFIndexTemplatePage, "");
+    pTemplate1->AddEntry(enumXFIndexTemplateText, u""_ustr);
+    pTemplate1->AddEntry(enumXFIndexTemplateTab, u""_ustr);
+    pTemplate1->AddEntry(enumXFIndexTemplatePage, u""_ustr);
     //pXFIndex->AddTemplate(OUString::number(1),"Primary",pTemplate1);
     pXFIndex->AddTemplate(OUString::number(1), styleName, pTemplate1);
 
     XFIndexTemplate* pTemplate2 = new XFIndexTemplate();
-    pTemplate2->AddEntry(enumXFIndexTemplateText, "");
-    pTemplate2->AddEntry(enumXFIndexTemplateTab, "");
-    pTemplate2->AddEntry(enumXFIndexTemplatePage, "");
+    pTemplate2->AddEntry(enumXFIndexTemplateText, u""_ustr);
+    pTemplate2->AddEntry(enumXFIndexTemplateTab, u""_ustr);
+    pTemplate2->AddEntry(enumXFIndexTemplatePage, u""_ustr);
     XFIndexTemplate* pTemplate3 = new XFIndexTemplate();
-    pTemplate3->AddEntry(enumXFIndexTemplateText, "");
-    pTemplate3->AddEntry(enumXFIndexTemplateTab, "");
-    pTemplate3->AddEntry(enumXFIndexTemplatePage, "");
+    pTemplate3->AddEntry(enumXFIndexTemplateText, u""_ustr);
+    pTemplate3->AddEntry(enumXFIndexTemplateTab, u""_ustr);
+    pTemplate3->AddEntry(enumXFIndexTemplatePage, u""_ustr);
 
     if (pIndexSection && pIndexSection->IsFormatRunin())
     {
@@ -218,7 +218,7 @@ void LwpFribSection::SetDefaultAlphaIndex(XFIndex* pXFIndex)
     {
         //pXFIndex->AddTemplate(OUString::number(2),"Secondary",pTemplate2);
         //pXFIndex->AddTemplate(OUString::number(3),"Secondary",pTemplate3);
-        styleName = pFoundry->FindActualStyleName("Secondary");
+        styleName = pFoundry->FindActualStyleName(u"Secondary"_ustr);
         pXFIndex->AddTemplate(OUString::number(2), styleName, pTemplate2);
         pXFIndex->AddTemplate(OUString::number(3), styleName, pTemplate3);
     }
@@ -254,7 +254,7 @@ void LwpMasterPage::RegisterMasterPage(LwpFrib* pFrib)
 
     std::unique_ptr<XFParaStyle> xOverStyle(new XFParaStyle);
     *xOverStyle = *(m_pPara->GetXFParaStyle());
-    xOverStyle->SetStyleName("");
+    xOverStyle->SetStyleName(u""_ustr);
 
     LwpLayout::UseWhenType eUserType = m_pLayout->GetUseWhenType();
     switch (eUserType)
@@ -430,7 +430,7 @@ void LwpMasterPage::RegisterFillerPageStyle()
     {
         std::unique_ptr<XFParaStyle> pPagebreakStyle(new XFParaStyle);
         *pPagebreakStyle = *(m_pPara->GetXFParaStyle());
-        pPagebreakStyle->SetStyleName("");
+        pPagebreakStyle->SetStyleName(u""_ustr);
         pPagebreakStyle->SetBreaks(enumXFBreakAftPage);
         XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager();
         m_FillerPageStyleName
diff --git a/lotuswordpro/source/filter/lwpfribtext.cxx b/lotuswordpro/source/filter/lwpfribtext.cxx
index b48050be6b42..11a23bbda4ae 100644
--- a/lotuswordpro/source/filter/lwpfribtext.cxx
+++ b/lotuswordpro/source/filter/lwpfribtext.cxx
@@ -175,15 +175,15 @@ void LwpFribDocVar::RegisterDefaultTimeStyle()
     std::unique_ptr<XFDateStyle> pDateStyle(new XFDateStyle);//use the default format
 
     pDateStyle->AddMonth();
-    pDateStyle->AddText("/");
+    pDateStyle->AddText(u"/"_ustr);
     pDateStyle->AddMonthDay();
-    pDateStyle->AddText("/");
+    pDateStyle->AddText(u"/"_ustr);
     pDateStyle->AddYear();
-    pDateStyle->AddText(",");
+    pDateStyle->AddText(u","_ustr);
     pDateStyle->AddHour();
-    pDateStyle->AddText(":");
+    pDateStyle->AddText(u":"_ustr);
     pDateStyle->AddMinute();
-    pDateStyle->AddText(":");
+    pDateStyle->AddText(u":"_ustr);
     pDateStyle->AddSecond();
 
     XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager();
@@ -209,13 +209,13 @@ void LwpFribDocVar::XFConvert(XFContentContainer* pXFPara)
     case FILENAME:
     {
         pContent = new XFFileName;
-        static_cast<XFFileName*>(pContent)->SetType("FileName");
+        static_cast<XFFileName*>(pContent)->SetType(u"FileName"_ustr);
         break;
     }
     case PATH:
     {
         pContent = new XFFileName;
-        static_cast<XFFileName*>(pContent)->SetType("Path");
+        static_cast<XFFileName*>(pContent)->SetType(u"Path"_ustr);
         break;
     }
     case DESCRIPTION:
@@ -263,55 +263,55 @@ void LwpFribDocVar::XFConvert(XFContentContainer* pXFPara)
         static_cast<XFAnnotation*>(pContent)->Add(pPara);
         break;
 */
-        LwpFrib::ConvertChars(pXFPara,"<Document Size>");
+        LwpFrib::ConvertChars(pXFPara,u"<Document Size>"_ustr);
         return;
     case SMARTMASTER:
-        LwpFrib::ConvertChars(pXFPara,"<Smart master>");
+        LwpFrib::ConvertChars(pXFPara,u"<Smart master>"_ustr);
         return;
     case DIVISIONNAME:
-        LwpFrib::ConvertChars(pXFPara,"<Division name>");
+        LwpFrib::ConvertChars(pXFPara,u"<Division name>"_ustr);
         return;
     case SECTIONNAME:
-        LwpFrib::ConvertChars(pXFPara,"<Section name>");
+        LwpFrib::ConvertChars(pXFPara,u"<Section name>"_ustr);
         return;
     case VERSIONCREATEBY:
-        LwpFrib::ConvertChars(pXFPara,"<Version Creat by>");
+        LwpFrib::ConvertChars(pXFPara,u"<Version Creat by>"_ustr);
         return;
     case VERSIONCREATEDATE:
-        LwpFrib::ConvertChars(pXFPara,"<Version Creat date>");
+        LwpFrib::ConvertChars(pXFPara,u"<Version Creat date>"_ustr);
         return;
     case VERSIONOTHEREDITORS:
-        LwpFrib::ConvertChars(pXFPara,"<Version other Editors>");
+        LwpFrib::ConvertChars(pXFPara,u"<Version other Editors>"_ustr);
         return;
     case VERSIONNAME:
-        LwpFrib::ConvertChars(pXFPara,"<Version Name>");
+        LwpFrib::ConvertChars(pXFPara,u"<Version Name>"_ustr);
         return;
     case VERSIONNUMBER:
-        LwpFrib::ConvertChars(pXFPara,"<Version Numbers>");
+        LwpFrib::ConvertChars(pXFPara,u"<Version Numbers>"_ustr);
         return;
     case ALLVERSIONNAME:
-        LwpFrib::ConvertChars(pXFPara,"<All Version Name>");
+        LwpFrib::ConvertChars(pXFPara,u"<All Version Name>"_ustr);
         return;
     case VERSIONREMARK:
-        LwpFrib::ConvertChars(pXFPara,"<Version Remark>");
+        LwpFrib::ConvertChars(pXFPara,u"<Version Remark>"_ustr);
         return;
     case DOCUMENTCATEGORY:
-        LwpFrib::ConvertChars(pXFPara,"<Document Category>");
+        LwpFrib::ConvertChars(pXFPara,u"<Document Category>"_ustr);
         return;
     case VERSIONLASTDATE:
-        LwpFrib::ConvertChars(pXFPara,"<Version Last Modify Date>");
+        LwpFrib::ConvertChars(pXFPara,u"<Version Last Modify Date>"_ustr);
         return;
     case VERSIONLASTEDITOR:
-        LwpFrib::ConvertChars(pXFPara,"<Version Last Editor>");
+        LwpFrib::ConvertChars(pXFPara,u"<Version Last Editor>"_ustr);
         return;
     case LASTEDIT:
-        LwpFrib::ConvertChars(pXFPara,"<Last Editor>");
+        LwpFrib::ConvertChars(pXFPara,u"<Last Editor>"_ustr);
         return;
     case OTHEREDITORS:
-        LwpFrib::ConvertChars(pXFPara,"<Other Editors>");
+        LwpFrib::ConvertChars(pXFPara,u"<Other Editors>"_ustr);
         return;
     case NUMOFREVISION:
-        LwpFrib::ConvertChars(pXFPara,"<Number of Revision>");
+        LwpFrib::ConvertChars(pXFPara,u"<Number of Revision>"_ustr);
         return;
     default:
         return;
@@ -382,19 +382,19 @@ void LwpFribPageNumber::XFConvert(XFContentContainer* pXFPara)
     switch(m_nNumStyle)
     {
     case 0x01:
-        pNum->SetNumFmt("1");
+        pNum->SetNumFmt(u"1"_ustr);
         break;
     case 0x02:
-        pNum->SetNumFmt("A");
+        pNum->SetNumFmt(u"A"_ustr);
         break;
     case 0x03:
-        pNum->SetNumFmt("a");
+        pNum->SetNumFmt(u"a"_ustr);
         break;
     case 0x04:
-        pNum->SetNumFmt("I");
+        pNum->SetNumFmt(u"I"_ustr);
         break;
     case 0x05:
-        pNum->SetNumFmt("i");
+        pNum->SetNumFmt(u"i"_ustr);
         break;
     }
     OUString styleName = GetStyleName();
diff --git a/lotuswordpro/source/filter/lwpgrfobj.cxx b/lotuswordpro/source/filter/lwpgrfobj.cxx
index 066e3eec24f8..fddd72bd7dd2 100644
--- a/lotuswordpro/source/filter/lwpgrfobj.cxx
+++ b/lotuswordpro/source/filter/lwpgrfobj.cxx
@@ -643,7 +643,7 @@ void LwpGraphicObject::XFConvertEquation(XFContentContainer * pCont)
 
     //convert equation
     XFParagraph* pXFPara = new XFParagraph;
-    pXFPara->Add("Formula:");
+    pXFPara->Add(u"Formula:"_ustr);
     //add notes
     XFAnnotation* pXFNote = new XFAnnotation;
     //add equation to comment notes
diff --git a/lotuswordpro/source/filter/lwpmarker.cxx b/lotuswordpro/source/filter/lwpmarker.cxx
index e6b29c23c55c..15faeeadeabf 100644
--- a/lotuswordpro/source/filter/lwpmarker.cxx
+++ b/lotuswordpro/source/filter/lwpmarker.cxx
@@ -193,16 +193,16 @@ void LwpCHBlkMarker::ProcessPlaceHolder(XFContentContainer* pXFPara,sal_uInt16 n
         switch(nAction)
         {
         case CLICKHERE_CHBEHAVIORTEXT:
-            pHolder->SetType("text");
+            pHolder->SetType(u"text"_ustr);
             break;
         case CLICKHERE_CHBEHAVIORTABLE:
-            pHolder->SetType("table");
+            pHolder->SetType(u"table"_ustr);
             break;
         case CLICKHERE_CHBEHAVIORPICTURE:
-            pHolder->SetType("image");
+            pHolder->SetType(u"image"_ustr);
             break;
         case CLICKHERE_CHBEHAVIOROLEOBJECT:
-            pHolder->SetType("object");
+            pHolder->SetType(u"object"_ustr);
             break;
         default:
             break;
@@ -230,7 +230,7 @@ void LwpCHBlkMarker::ProcessOtherCHB(XFContentContainer* pXFPara,sal_uInt8 nType
     if (nType == MARKER_START)
     {
         XFHolderStart* pHolder= new XFHolderStart;
-        pHolder->SetType("text");
+        pHolder->SetType(u"text"_ustr);
         if (bHelpFlag)
             pHolder->SetDesc(m_Help.str());
         pHolder->SetPrompt(GetPromptText());
@@ -273,7 +273,7 @@ void LwpCHBlkMarker::ProcessKeylist(XFContentContainer* pXFPara,sal_uInt8 nType)
             pXFPara->Add(pList);
 
             XFHolderStart* pHolder= new XFHolderStart;
-            pHolder->SetType("text");
+            pHolder->SetType(u"text"_ustr);
             pHolder->SetPrompt(GetPromptText());
             pXFPara->Add(pHolder);
         }
@@ -297,9 +297,9 @@ bool LwpCHBlkMarker::IsBubbleHelp() const
 
 void LwpCHBlkMarker::EnumAllKeywords()
 {
-    OUString name1("");
-    OUString value1("");
-    OUString name2("start");
+    OUString name1(u""_ustr);
+    OUString value1(u""_ustr);
+    OUString name2(u"start"_ustr);
     LwpPropList* pProp = GetPropList();
     if (!pProp)
         return;
diff --git a/lotuswordpro/source/filter/lwpnumericfmt.hxx b/lotuswordpro/source/filter/lwpnumericfmt.hxx
index 4bc0a345071c..38490303b967 100644
--- a/lotuswordpro/source/filter/lwpnumericfmt.hxx
+++ b/lotuswordpro/source/filter/lwpnumericfmt.hxx
@@ -186,50 +186,50 @@ public:
 private:
     std::map<sal_uInt16,LwpCurrencyInfo> m_aCurrencyInfo
     {
-        { FMT_ARGENTINEANPESO, LwpCurrencyInfo("A") },
-        { FMT_AUSTRALIANDOLLAR, LwpCurrencyInfo("A$") },
-        { FMT_AUSTRIANSCHILLING, LwpCurrencyInfo("oS",true, true) },
-        { FMT_BELGIANFRANC, LwpCurrencyInfo("BF",true, true) },
-        { FMT_BRAZILIANCRUZEIRO, LwpCurrencyInfo("R$",false, true) },
+        { FMT_ARGENTINEANPESO, LwpCurrencyInfo(u"A"_ustr) },
+        { FMT_AUSTRALIANDOLLAR, LwpCurrencyInfo(u"A$"_ustr) },
+        { FMT_AUSTRIANSCHILLING, LwpCurrencyInfo(u"oS"_ustr,true, true) },
+        { FMT_BELGIANFRANC, LwpCurrencyInfo(u"BF"_ustr,true, true) },
+        { FMT_BRAZILIANCRUZEIRO, LwpCurrencyInfo(u"R$"_ustr,false, true) },
         { FMT_BRITISHPOUND, LwpCurrencyInfo(u"\uFFE1"_ustr) },
-        { FMT_CANADIANDOLLAR, LwpCurrencyInfo("C$") },
+        { FMT_CANADIANDOLLAR, LwpCurrencyInfo(u"C$"_ustr) },
         { FMT_CHINESEYUAN, LwpCurrencyInfo(u"PRC\uFFE5"_ustr,false,true) },
-        { FMT_CZECHKORUNA, LwpCurrencyInfo("Kc",true, true) },
-        { FMT_DANISHKRONE, LwpCurrencyInfo("Dkr",false, true) },
-        { FMT_ECU, LwpCurrencyInfo("ECU",true, true) },
-        { FMT_FINNISHMARKKA, LwpCurrencyInfo("mk",true, true) },
-        { FMT_FRENCHFRANC, LwpCurrencyInfo("F",true, true) },
-        { FMT_GERMANMARK, LwpCurrencyInfo("DM",true, true) },
-        { FMT_GREEKDRACHMA, LwpCurrencyInfo("Dr",true, true) },
-        { FMT_HONGKONGDOLLAR, LwpCurrencyInfo("HK$") },
-        { FMT_HUNGARIANFORINT, LwpCurrencyInfo("Ft",true, true) },
-        { FMT_INDIANRUPEE, LwpCurrencyInfo("Rs",false, true) },
-        { FMT_INDONESIANRUPIAH, LwpCurrencyInfo("Rp",false, true) },
+        { FMT_CZECHKORUNA, LwpCurrencyInfo(u"Kc"_ustr,true, true) },
+        { FMT_DANISHKRONE, LwpCurrencyInfo(u"Dkr"_ustr,false, true) },
+        { FMT_ECU, LwpCurrencyInfo(u"ECU"_ustr,true, true) },
+        { FMT_FINNISHMARKKA, LwpCurrencyInfo(u"mk"_ustr,true, true) },
+        { FMT_FRENCHFRANC, LwpCurrencyInfo(u"F"_ustr,true, true) },
+        { FMT_GERMANMARK, LwpCurrencyInfo(u"DM"_ustr,true, true) },
+        { FMT_GREEKDRACHMA, LwpCurrencyInfo(u"Dr"_ustr,true, true) },
+        { FMT_HONGKONGDOLLAR, LwpCurrencyInfo(u"HK$"_ustr) },
+        { FMT_HUNGARIANFORINT, LwpCurrencyInfo(u"Ft"_ustr,true, true) },
+        { FMT_INDIANRUPEE, LwpCurrencyInfo(u"Rs"_ustr,false, true) },
+        { FMT_INDONESIANRUPIAH, LwpCurrencyInfo(u"Rp"_ustr,false, true) },
         { FMT_IRISHPUNT, LwpCurrencyInfo(u"IR\uFFE1"_ustr) },
-        { FMT_ITALIANLIRA, LwpCurrencyInfo("L.",false, true) },
+        { FMT_ITALIANLIRA, LwpCurrencyInfo(u"L."_ustr,false, true) },
         { FMT_JAPANESEYEN, LwpCurrencyInfo(u"\uFFE5"_ustr) },
-        { FMT_LUXEMBOURGFRANC, LwpCurrencyInfo("LF",true, true) },
-        { FMT_MALAYSIANRINGGIT, LwpCurrencyInfo("Rm",false, true) },
-        { FMT_MEXICANPESO, LwpCurrencyInfo("Mex$") },
-        { FMT_NETHERLANDSGUILDER, LwpCurrencyInfo("F",false, true) },
-        { FMT_NEWZEALANDDOLLAR, LwpCurrencyInfo("NZ$") },
-        { FMT_NORWEGIANKRONE, LwpCurrencyInfo("Nkr",false, true) },
-        { FMT_POLISHZLOTY, LwpCurrencyInfo("Zl",true, true) },
-        { FMT_PORTUGUESEESCUDO, LwpCurrencyInfo("Esc.",true, true) },
-        { FMT_ROMANIANLEI, LwpCurrencyInfo("Leu",true, true) },
-        { FMT_RUSSIANRUBLE, LwpCurrencyInfo("R",true, true) },
-        { FMT_SINGAPOREDOLLAR, LwpCurrencyInfo("S$") },
-        { FMT_SLOVAKIANKORUNA, LwpCurrencyInfo("Sk",true, true) },
-        { FMT_SLOVENIANTHOLAR, LwpCurrencyInfo("SIT",false, true) },
-        { FMT_SOUTHAFRICANRAND, LwpCurrencyInfo("R") },
-        { FMT_SOUTHKOREANWON, LwpCurrencyInfo("W") },
-        { FMT_SPANISHPESETA, LwpCurrencyInfo("Pts",true, true) },
-        { FMT_SWEDISHKRONA, LwpCurrencyInfo("Skr",true, true) },
-        { FMT_SWISSFRANC, LwpCurrencyInfo("SFr",false, true) },
-        { FMT_TAIWANDOLLAR, LwpCurrencyInfo("NT$") },
-        { FMT_THAIBAHT, LwpCurrencyInfo("Bt",true, true) },
-        { FMT_USDOLLAR, LwpCurrencyInfo("$") },
-        { FMT_OTHERCURRENCY, LwpCurrencyInfo("OTH",false, true) },
+        { FMT_LUXEMBOURGFRANC, LwpCurrencyInfo(u"LF"_ustr,true, true) },
+        { FMT_MALAYSIANRINGGIT, LwpCurrencyInfo(u"Rm"_ustr,false, true) },
+        { FMT_MEXICANPESO, LwpCurrencyInfo(u"Mex$"_ustr) },
+        { FMT_NETHERLANDSGUILDER, LwpCurrencyInfo(u"F"_ustr,false, true) },
+        { FMT_NEWZEALANDDOLLAR, LwpCurrencyInfo(u"NZ$"_ustr) },
+        { FMT_NORWEGIANKRONE, LwpCurrencyInfo(u"Nkr"_ustr,false, true) },
+        { FMT_POLISHZLOTY, LwpCurrencyInfo(u"Zl"_ustr,true, true) },
+        { FMT_PORTUGUESEESCUDO, LwpCurrencyInfo(u"Esc."_ustr,true, true) },
+        { FMT_ROMANIANLEI, LwpCurrencyInfo(u"Leu"_ustr,true, true) },
+        { FMT_RUSSIANRUBLE, LwpCurrencyInfo(u"R"_ustr,true, true) },
+        { FMT_SINGAPOREDOLLAR, LwpCurrencyInfo(u"S$"_ustr) },
+        { FMT_SLOVAKIANKORUNA, LwpCurrencyInfo(u"Sk"_ustr,true, true) },
+        { FMT_SLOVENIANTHOLAR, LwpCurrencyInfo(u"SIT"_ustr,false, true) },
+        { FMT_SOUTHAFRICANRAND, LwpCurrencyInfo(u"R"_ustr) },
+        { FMT_SOUTHKOREANWON, LwpCurrencyInfo(u"W"_ustr) },
+        { FMT_SPANISHPESETA, LwpCurrencyInfo(u"Pts"_ustr,true, true) },
+        { FMT_SWEDISHKRONA, LwpCurrencyInfo(u"Skr"_ustr,true, true) },
+        { FMT_SWISSFRANC, LwpCurrencyInfo(u"SFr"_ustr,false, true) },
+        { FMT_TAIWANDOLLAR, LwpCurrencyInfo(u"NT$"_ustr) },
+        { FMT_THAIBAHT, LwpCurrencyInfo(u"Bt"_ustr,true, true) },
+        { FMT_USDOLLAR, LwpCurrencyInfo(u"$"_ustr) },
+        { FMT_OTHERCURRENCY, LwpCurrencyInfo(u"OTH"_ustr,false, true) },
         { FMT_EURO, LwpCurrencyInfo(u"\u20AC"_ustr) }
     };
 };
diff --git a/lotuswordpro/source/filter/lwppagelayout.cxx b/lotuswordpro/source/filter/lwppagelayout.cxx
index e2505d30f70d..4a83bfd7e15c 100644
--- a/lotuswordpro/source/filter/lwppagelayout.cxx
+++ b/lotuswordpro/source/filter/lwppagelayout.cxx
@@ -400,7 +400,7 @@ OUString LwpPageLayout::RegisterEndnoteStyle()
 
     //Add master page
     std::unique_ptr<XFMasterPage> p1(new XFMasterPage);
-    p1->SetStyleName("Endnote");
+    p1->SetStyleName(u"Endnote"_ustr);
     p1->SetPageMaster(pmname);
 
     //Set footer style
diff --git a/lotuswordpro/source/filter/lwppara.cxx b/lotuswordpro/source/filter/lwppara.cxx
index f6c9cd5e6bb3..f1ddeddae2ab 100644
--- a/lotuswordpro/source/filter/lwppara.cxx
+++ b/lotuswordpro/source/filter/lwppara.cxx
@@ -87,11 +87,11 @@ LwpPara::LwpPara(LwpObjectHeader const & objHdr, LwpSvStream* pStrm)
     , m_nFlags(0)
     , m_nLevel(0)
     , m_FontID(0)
-    , m_AllText("")
+    , m_AllText(u""_ustr)
     , m_bHasBullet(false)
     , m_pSilverBullet(nullptr)
     , m_bBullContinue(false)
-    , m_SectionStyleName("")
+    , m_SectionStyleName(u""_ustr)
     , m_bHasDropcap(false)
     , m_nLines(0)
     , m_nChars(0)
@@ -260,7 +260,7 @@ void LwpPara::RegisterMasterPage(XFParaStyle const * pBaseStyle)
     //register master page style
     std::unique_ptr<XFParaStyle> xOverStyle(new XFParaStyle);
     *xOverStyle = *pBaseStyle;
-    xOverStyle->SetStyleName( "");
+    xOverStyle->SetStyleName( u""_ustr);
     xOverStyle->SetMasterPage(pLayout->GetStyleName());
     if (!m_ParentStyleName.isEmpty())
         xOverStyle->SetParentStyleName(m_ParentStyleName);
@@ -300,7 +300,7 @@ void LwpPara::RegisterStyle()
         bool noIndent = true;
         xOverStyle.reset(new XFParaStyle);
         *xOverStyle = *pBaseStyle;
-        xOverStyle->SetStyleName("");
+        xOverStyle->SetStyleName(u""_ustr);
         sal_uInt32 PropType;
         LwpParaStyle& rParaStyle = dynamic_cast<LwpParaStyle&>(*m_ParaStyle.obj());
         for (auto & pProps : m_vProps)
diff --git a/lotuswordpro/source/filter/lwpsilverbullet.cxx b/lotuswordpro/source/filter/lwpsilverbullet.cxx
index da19ca474e60..793836c7b559 100644
--- a/lotuswordpro/source/filter/lwpsilverbullet.cxx
+++ b/lotuswordpro/source/filter/lwpsilverbullet.cxx
@@ -172,7 +172,7 @@ void LwpSilverBullet::RegisterStyle()
                     }
 
                     xListStyle->SetListBullet(nPos, GetNumCharByStyleID(pParaNumber),
-                        "Times New Roman", aPrefix, aSuffix);
+                        u"Times New Roman"_ustr, aPrefix, aSuffix);
                 }
 
                 xListStyle->SetListPosition(nPos, 0.0, 0.635, 0.0);
@@ -258,7 +258,7 @@ OUString LwpSilverBullet::GetNumCharByStyleID(LwpFribParaNumber const * pParaNum
         return OUString();
     }
 
-    OUString strNumChar("1");
+    OUString strNumChar(u"1"_ustr);
     sal_uInt16 nStyleID = pParaNumber->GetStyleID();
 
     switch (nStyleID)
diff --git a/lotuswordpro/source/filter/lwptablelayout.cxx b/lotuswordpro/source/filter/lwptablelayout.cxx
index f36a553b16cf..9c1ceea67f5b 100644
--- a/lotuswordpro/source/filter/lwptablelayout.cxx
+++ b/lotuswordpro/source/filter/lwptablelayout.cxx
@@ -1285,7 +1285,7 @@ void LwpTableLayout::PostProcessParagraph(XFCell *pCell, sal_uInt16 nRowID, sal_
         }
     }
 
-    xOverStyle->SetStyleName("");
+    xOverStyle->SetStyleName(u""_ustr);
     OUString StyleName
         = pXFStyleManager->AddStyle(std::move(xOverStyle)).m_pStyle->GetStyleName();
 
diff --git a/lotuswordpro/source/filter/lwptoc.cxx b/lotuswordpro/source/filter/lwptoc.cxx
index 9268f8e33106..d6b1984beace 100644
--- a/lotuswordpro/source/filter/lwptoc.cxx
+++ b/lotuswordpro/source/filter/lwptoc.cxx
@@ -219,7 +219,7 @@ void  LwpTocSuperLayout::XFConvert(XFContentContainer* pCont)
                         pTemplate->AddTextEntry(sSep, m_TabStyleName);
                     }
                     //"TOC Page Number Text Style" style always exists in Word Pro file
-                    pTemplate->AddEntry(enumXFIndexTemplatePage, "TOC Page Number Text Style");
+                    pTemplate->AddEntry(enumXFIndexTemplatePage, u"TOC Page Number Text Style"_ustr);
                 }
 
                 xToc->AddTemplate(OUString::number(static_cast<sal_Int32>(i)),  m_pFoundry->FindActualStyleName(pLevel->GetSearchStyle()), pTemplate);
diff --git a/lotuswordpro/source/filter/lwptools.cxx b/lotuswordpro/source/filter/lwptools.cxx
index 8a171fda7755..16b1259ba291 100644
--- a/lotuswordpro/source/filter/lwptools.cxx
+++ b/lotuswordpro/source/filter/lwptools.cxx
@@ -588,7 +588,7 @@ std::unique_ptr<XFDateStyle> LwpTools::GetSystemDateStyle(bool bLongFormat)
             }
             case '"':
             {
-                pDateStyle->AddText("'");
+                pDateStyle->AddText(u"'"_ustr);
                 break;
             }
             default:
@@ -810,7 +810,7 @@ std::unique_ptr<XFTimeStyle> LwpTools::GetSystemTimeStyle()
             }
             case '"':
             {
-                pTimeStyle->AddText("'");
+                pTimeStyle->AddText(u"'"_ustr);
                 break;
             }
             default:
diff --git a/lotuswordpro/source/filter/xfilter/xfbgimage.cxx b/lotuswordpro/source/filter/xfilter/xfbgimage.cxx
index d4b4e5be6520..0a7899fa5046 100644
--- a/lotuswordpro/source/filter/xfilter/xfbgimage.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfbgimage.cxx
@@ -89,11 +89,11 @@ void    XFBGImage::ToXml(IXFStream *pStrm)
 
     if( m_bUserFileLink )
     {
-        pAttrList->AddAttribute( "xlink:href", m_strFileName);
+        pAttrList->AddAttribute( u"xlink:href"_ustr, m_strFileName);
     }
 
-    pAttrList->AddAttribute( "xlink:type", "simple" );
-    pAttrList->AddAttribute( "xlink:actuate", "onLoad");
+    pAttrList->AddAttribute( u"xlink:type"_ustr, u"simple"_ustr );
+    pAttrList->AddAttribute( u"xlink:actuate"_ustr, u"onLoad"_ustr);
 
     if( m_bPosition )
     {
@@ -105,25 +105,25 @@ void    XFBGImage::ToXml(IXFStream *pStrm)
         else if( m_eHoriAlign == enumXFAlignEnd )
             str += "right";
 
-        pAttrList->AddAttribute( "style:position", str );
-        pAttrList->AddAttribute( "style:repeat", "no-repeat" );
+        pAttrList->AddAttribute( u"style:position"_ustr, str );
+        pAttrList->AddAttribute( u"style:repeat"_ustr, u"no-repeat"_ustr );
     }
     else if( m_bRepeate )
-        pAttrList->AddAttribute( "style:repeat", "repeat" );
+        pAttrList->AddAttribute( u"style:repeat"_ustr, u"repeat"_ustr );
     else if( m_bStretch )
-        pAttrList->AddAttribute( "style:repeat", "stretch" );
+        pAttrList->AddAttribute( u"style:repeat"_ustr, u"stretch"_ustr );
 
-    pStrm->StartElement( "style:background-image" );
+    pStrm->StartElement( u"style:background-image"_ustr );
 
     if( !m_bUserFileLink )
     {
         pAttrList->Clear();
-        pStrm->StartElement( "office:binary-data" );
+        pStrm->StartElement( u"office:binary-data"_ustr );
         pStrm->Characters(m_strData);
-        pStrm->EndElement( "office:binary-data" );
+        pStrm->EndElement( u"office:binary-data"_ustr );
     }
 
-    pStrm->EndElement( "style:background-image" );
+    pStrm->EndElement( u"style:background-image"_ustr );
 }
 
 bool operator==(XFBGImage const & img1, XFBGImage const & img2)
diff --git a/lotuswordpro/source/filter/xfilter/xfborders.cxx b/lotuswordpro/source/filter/xfilter/xfborders.cxx
index f6027a1558ad..f483d9ff7e45 100644
--- a/lotuswordpro/source/filter/xfilter/xfborders.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfborders.cxx
@@ -333,33 +333,33 @@ void    XFBorders::ToXml(IXFStream *pStrm)
     IXFAttrList *pAttrList = pStrm->GetAttrList();
 
     if( !m_aBorderLeft.GetLineWidth().isEmpty() )
-        pAttrList->AddAttribute( "style:border-line-width-left", m_aBorderLeft.GetLineWidth() );
+        pAttrList->AddAttribute( u"style:border-line-width-left"_ustr, m_aBorderLeft.GetLineWidth() );
     if( !m_aBorderRight.GetLineWidth().isEmpty() )
-        pAttrList->AddAttribute( "style:border-line-width-right", m_aBorderRight.GetLineWidth() );
+        pAttrList->AddAttribute( u"style:border-line-width-right"_ustr, m_aBorderRight.GetLineWidth() );
     if( !m_aBorderTop.GetLineWidth().isEmpty() )
-        pAttrList->AddAttribute( "style:border-line-width-top", m_aBorderTop.GetLineWidth() );
+        pAttrList->AddAttribute( u"style:border-line-width-top"_ustr, m_aBorderTop.GetLineWidth() );
     if( !m_aBorderBottom.GetLineWidth().isEmpty() )
-        pAttrList->AddAttribute( "style:border-line-width-bottom", m_aBorderBottom.GetLineWidth() );
+        pAttrList->AddAttribute( u"style:border-line-width-bottom"_ustr, m_aBorderBottom.GetLineWidth() );
 
     if( !m_aBorderLeft.ToString().isEmpty() )
-        pAttrList->AddAttribute( "fo:border-left", m_aBorderLeft.ToString() );
+        pAttrList->AddAttribute( u"fo:border-left"_ustr, m_aBorderLeft.ToString() );
     else
-        pAttrList->AddAttribute( "fo:border-left", "none" );
+        pAttrList->AddAttribute( u"fo:border-left"_ustr, u"none"_ustr );
 
     if( !m_aBorderRight.ToString().isEmpty() )
-        pAttrList->AddAttribute( "fo:border-right", m_aBorderRight.ToString() );
+        pAttrList->AddAttribute( u"fo:border-right"_ustr, m_aBorderRight.ToString() );
     else
-        pAttrList->AddAttribute( "fo:border-right", "none" );
+        pAttrList->AddAttribute( u"fo:border-right"_ustr, u"none"_ustr );
 
     if( !m_aBorderTop.ToString().isEmpty() )
-        pAttrList->AddAttribute( "fo:border-top", m_aBorderTop.ToString() );
+        pAttrList->AddAttribute( u"fo:border-top"_ustr, m_aBorderTop.ToString() );
     else
-        pAttrList->AddAttribute( "fo:border-top", "none" );
+        pAttrList->AddAttribute( u"fo:border-top"_ustr, u"none"_ustr );
 
     if( !m_aBorderBottom.ToString().isEmpty() )
-        pAttrList->AddAttribute( "fo:border-bottom", m_aBorderBottom.ToString() );
+        pAttrList->AddAttribute( u"fo:border-bottom"_ustr, m_aBorderBottom.ToString() );
     else
-        pAttrList->AddAttribute( "fo:border-bottom", "none" );
+        pAttrList->AddAttribute( u"fo:border-bottom"_ustr, u"none"_ustr );
 
 }
 
diff --git a/lotuswordpro/source/filter/xfilter/xfcell.cxx b/lotuswordpro/source/filter/xfilter/xfcell.cxx
index dfc5889db652..d589244098e8 100644
--- a/lotuswordpro/source/filter/xfilter/xfcell.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfcell.cxx
@@ -163,26 +163,26 @@ void XFCell::ToXml(IXFStream *pStrm)
 
     pAttrList->Clear();
     if( !GetStyleName().isEmpty() )
-        pAttrList->AddAttribute( "table:style-name", GetStyleName() );
+        pAttrList->AddAttribute( u"table:style-name"_ustr, GetStyleName() );
     if( m_nColSpaned>1 )
-        pAttrList->AddAttribute( "table:number-columns-spanned", OUString::number(m_nColSpaned) );
+        pAttrList->AddAttribute( u"table:number-columns-spanned"_ustr, OUString::number(m_nColSpaned) );
     if( m_nRepeated )
-        pAttrList->AddAttribute( "table:number-columns-repeated", OUString::number(m_nRepeated) );
+        pAttrList->AddAttribute( u"table:number-columns-repeated"_ustr, OUString::number(m_nRepeated) );
     if( m_eValueType != enumXFValueTypeNone )
     {
-        pAttrList->AddAttribute( "table:value-type", GetValueType(m_eValueType) );
-        pAttrList->AddAttribute( "table:value", m_strValue );
+        pAttrList->AddAttribute( u"table:value-type"_ustr, GetValueType(m_eValueType) );
+        pAttrList->AddAttribute( u"table:value"_ustr, m_strValue );
     }
     if( !m_strFormula.isEmpty() )
-        pAttrList->AddAttribute( "table:formula", m_strFormula );
+        pAttrList->AddAttribute( u"table:formula"_ustr, m_strFormula );
 
     if( m_bProtect )
-        pAttrList->AddAttribute( "table:protected", "true" );
+        pAttrList->AddAttribute( u"table:protected"_ustr, u"true"_ustr );
 
     //for test only.
 //  pAttrList->AddAttribute( "table:cell-name", GetCellName() );
 
-    pStrm->StartElement( "table:table-cell" );
+    pStrm->StartElement( u"table:table-cell"_ustr );
 
     if( m_pSubTable.is() )
         m_pSubTable->ToXml(pStrm);
@@ -191,7 +191,7 @@ void XFCell::ToXml(IXFStream *pStrm)
         XFContentContainer::ToXml(pStrm);
     }
 
-    pStrm->EndElement( "table:table-cell" );
+    pStrm->EndElement( u"table:table-cell"_ustr );
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/source/filter/xfilter/xfcellstyle.cxx b/lotuswordpro/source/filter/xfilter/xfcellstyle.cxx
index e615778a94f1..122a0b840e9b 100644
--- a/lotuswordpro/source/filter/xfilter/xfcellstyle.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfcellstyle.cxx
@@ -188,17 +188,17 @@ void XFCellStyle::ToXml(IXFStream *pStrm)
 
     pAttrList->Clear();
     if( !style.isEmpty() )
-        pAttrList->AddAttribute("style:name",GetStyleName());
+        pAttrList->AddAttribute(u"style:name"_ustr,GetStyleName());
     if( !GetParentStyleName().isEmpty() )
-        pAttrList->AddAttribute("style:parent-style-name",GetParentStyleName());
+        pAttrList->AddAttribute(u"style:parent-style-name"_ustr,GetParentStyleName());
 
-    pAttrList->AddAttribute("style:family", "table-cell");
+    pAttrList->AddAttribute(u"style:family"_ustr, u"table-cell"_ustr);
     if( !m_strParentStyleName.isEmpty() )
-        pAttrList->AddAttribute("style:parent-style-name",m_strParentStyleName);
+        pAttrList->AddAttribute(u"style:parent-style-name"_ustr,m_strParentStyleName);
     if( !m_strDataStyle.isEmpty() )
-        pAttrList->AddAttribute( "style:data-style-name", m_strDataStyle );
+        pAttrList->AddAttribute( u"style:data-style-name"_ustr, m_strDataStyle );
 
-    pStrm->StartElement("style:style");
+    pStrm->StartElement(u"style:style"_ustr);
 
     //Paragraph properties:
     pAttrList->Clear();
@@ -211,11 +211,11 @@ void XFCellStyle::ToXml(IXFStream *pStrm)
     //text horizontal align:
     if( m_eHoriAlign != enumXFAlignNone )
     {
-        pAttrList->AddAttribute("fo:text-align", GetAlignName(m_eHoriAlign) );
+        pAttrList->AddAttribute(u"fo:text-align"_ustr, GetAlignName(m_eHoriAlign) );
     }
     //text vertical align
     if( m_eVertAlign != enumXFAlignNone )
-        pAttrList->AddAttribute( "fo:vertical-align", GetAlignName(m_eVertAlign) );
+        pAttrList->AddAttribute( u"fo:vertical-align"_ustr, GetAlignName(m_eVertAlign) );
 
     //shadow:
     m_aShadow.ToXml(pStrm);
@@ -226,20 +226,20 @@ void XFCellStyle::ToXml(IXFStream *pStrm)
     //background color:
     if( m_aBackColor.IsValid() && !m_xBackImage )
     {
-        pAttrList->AddAttribute("fo:background-color", m_aBackColor.ToString() );
+        pAttrList->AddAttribute(u"fo:background-color"_ustr, m_aBackColor.ToString() );
     }
     //Font properties:
     if( m_pFont.is() )
         m_pFont->ToXml(pStrm);
 
-    pStrm->StartElement("style:properties");
+    pStrm->StartElement(u"style:properties"_ustr);
 
     if( m_xBackImage )
         m_xBackImage->ToXml(pStrm);
 
-    pStrm->EndElement("style:properties");
+    pStrm->EndElement(u"style:properties"_ustr);
 
-    pStrm->EndElement("style:style");
+    pStrm->EndElement(u"style:style"_ustr);
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/source/filter/xfilter/xfchange.cxx b/lotuswordpro/source/filter/xfilter/xfchange.cxx
index 0beef2120b43..550d67c82b19 100644
--- a/lotuswordpro/source/filter/xfilter/xfchange.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfchange.cxx
@@ -68,10 +68,10 @@ void XFChangeList::ToXml(IXFStream *pStrm)
     IXFAttrList *pAttrList = pStrm->GetAttrList();
     pAttrList->Clear();
     // Add for disable change tracking
-    pAttrList->AddAttribute( "text:track-changes","false");
-    pStrm->StartElement( "text:tracked-changes" );
+    pAttrList->AddAttribute( u"text:track-changes"_ustr,u"false"_ustr);
+    pStrm->StartElement( u"text:tracked-changes"_ustr );
     XFContentContainer::ToXml(pStrm);
-    pStrm->EndElement("text:tracked-changes");
+    pStrm->EndElement(u"text:tracked-changes"_ustr);
 }
 
 void XFChangeRegion::ToXml(IXFStream * /*pStrm*/)
@@ -85,17 +85,17 @@ void XFChangeInsert::ToXml(IXFStream *pStrm)
     pAttrList->Clear();
     if(m_sID.isEmpty())
         return;
-    pAttrList->AddAttribute( "text:id",m_sID);
+    pAttrList->AddAttribute( u"text:id"_ustr,m_sID);
 
-    pStrm->StartElement( "text:changed-region" );
-    pStrm->StartElement( "text:insertion" );
+    pStrm->StartElement( u"text:changed-region"_ustr );
+    pStrm->StartElement( u"text:insertion"_ustr );
     pAttrList->Clear();
-    pAttrList->AddAttribute( "office:chg-author",m_sEditor);
-    pAttrList->AddAttribute( "office:chg-date-time","0000-00-00T00:00:00");
-    pStrm->StartElement( "office:change-info" );
-    pStrm->EndElement( "office:change-info" );
-    pStrm->EndElement( "text:insertion" );
-    pStrm->EndElement( "text:changed-region" );
+    pAttrList->AddAttribute( u"office:chg-author"_ustr,m_sEditor);
+    pAttrList->AddAttribute( u"office:chg-date-time"_ustr,u"0000-00-00T00:00:00"_ustr);
+    pStrm->StartElement( u"office:change-info"_ustr );
+    pStrm->EndElement( u"office:change-info"_ustr );
+    pStrm->EndElement( u"text:insertion"_ustr );
+    pStrm->EndElement( u"text:changed-region"_ustr );
 }
 
 void XFChangeDelete::ToXml(IXFStream *pStrm)
@@ -105,18 +105,18 @@ void XFChangeDelete::ToXml(IXFStream *pStrm)
     pAttrList->Clear();
     if(m_sID.isEmpty())
         return;
-    pAttrList->AddAttribute( "text:id",m_sID);
+    pAttrList->AddAttribute( u"text:id"_ustr,m_sID);
 
-    pStrm->StartElement( "text:changed-region" );
-    pStrm->StartElement( "text:deletion" );
+    pStrm->StartElement( u"text:changed-region"_ustr );
+    pStrm->StartElement( u"text:deletion"_ustr );
     pAttrList->Clear();
-    pAttrList->AddAttribute( "office:chg-author",m_sEditor);
-    pAttrList->AddAttribute( "office:chg-date-time","0000-00-00T00:00:00");
-    pStrm->StartElement( "office:change-info" );
-    pStrm->EndElement( "office:change-info" );
+    pAttrList->AddAttribute( u"office:chg-author"_ustr,m_sEditor);
+    pAttrList->AddAttribute( u"office:chg-date-time"_ustr,u"0000-00-00T00:00:00"_ustr);
+    pStrm->StartElement( u"office:change-info"_ustr );
+    pStrm->EndElement( u"office:change-info"_ustr );
 
-    pStrm->EndElement( "text:deletion" );
-    pStrm->EndElement( "text:changed-region" );
+    pStrm->EndElement( u"text:deletion"_ustr );
+    pStrm->EndElement( u"text:changed-region"_ustr );
 }
 
 void XFChangeStart::ToXml(IXFStream *pStrm)
@@ -126,10 +126,10 @@ void XFChangeStart::ToXml(IXFStream *pStrm)
     pAttrList->Clear();
     if(m_sID.isEmpty())
         return;
-    pAttrList->AddAttribute( "text:change-id",m_sID);
+    pAttrList->AddAttribute( u"text:change-id"_ustr,m_sID);
 
-    pStrm->StartElement( "text:change-start" );
-    pStrm->EndElement( "text:change-start" );
+    pStrm->StartElement( u"text:change-start"_ustr );
+    pStrm->EndElement( u"text:change-start"_ustr );
 }
 
 void XFChangeEnd::ToXml(IXFStream *pStrm)
@@ -139,10 +139,10 @@ void XFChangeEnd::ToXml(IXFStream *pStrm)
     pAttrList->Clear();
     if(m_sID.isEmpty())
         return;
-    pAttrList->AddAttribute( "text:change-id",m_sID);
+    pAttrList->AddAttribute( u"text:change-id"_ustr,m_sID);
 
-    pStrm->StartElement( "text:change-end" );
-    pStrm->EndElement( "text:change-end" );
+    pStrm->StartElement( u"text:change-end"_ustr );
+    pStrm->EndElement( u"text:change-end"_ustr );
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/source/filter/xfilter/xfcolstyle.cxx b/lotuswordpro/source/filter/xfilter/xfcolstyle.cxx
index c44720a6bd3a..f9792c146113 100644
--- a/lotuswordpro/source/filter/xfilter/xfcolstyle.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfcolstyle.cxx
@@ -72,15 +72,15 @@ void XFColStyle::ToXml(IXFStream* pStrm)
 
     pAttrList->Clear();
 
-    pAttrList->AddAttribute("style:name", GetStyleName());
-    pAttrList->AddAttribute("style:family", "table-column");
-    pStrm->StartElement("style:style");
+    pAttrList->AddAttribute(u"style:name"_ustr, GetStyleName());
+    pAttrList->AddAttribute(u"style:family"_ustr, u"table-column"_ustr);
+    pStrm->StartElement(u"style:style"_ustr);
 
     pAttrList->Clear();
-    pAttrList->AddAttribute("style:column-width", OUString::number(m_fWidth) + "cm");
-    pStrm->StartElement("style:properties");
-    pStrm->EndElement("style:properties");
+    pAttrList->AddAttribute(u"style:column-width"_ustr, OUString::number(m_fWidth) + "cm");
+    pStrm->StartElement(u"style:properties"_ustr);
+    pStrm->EndElement(u"style:properties"_ustr);
 
-    pStrm->EndElement("style:style");
+    pStrm->EndElement(u"style:style"_ustr);
 }
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/source/filter/xfilter/xfcolumns.cxx b/lotuswordpro/source/filter/xfilter/xfcolumns.cxx
index b5f427d883b8..ee37826809d9 100644
--- a/lotuswordpro/source/filter/xfilter/xfcolumns.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfcolumns.cxx
@@ -76,12 +76,12 @@ void    XFColumn::ToXml(IXFStream *pStrm)
     IXFAttrList *pAttrList = pStrm->GetAttrList();
     pAttrList->Clear();
 
-    pAttrList->AddAttribute( "style:rel-width", OUString::number(m_nRelWidth) + "*" );
-    pAttrList->AddAttribute( "fo:margin-left", OUString::number(m_fMarginLeft) + "cm" );
-    pAttrList->AddAttribute( "fo:margin-right", OUString::number(m_fMarginRight) + "cm" );
+    pAttrList->AddAttribute( u"style:rel-width"_ustr, OUString::number(m_nRelWidth) + "*" );
+    pAttrList->AddAttribute( u"fo:margin-left"_ustr, OUString::number(m_fMarginLeft) + "cm" );
+    pAttrList->AddAttribute( u"fo:margin-right"_ustr, OUString::number(m_fMarginRight) + "cm" );
 
-    pStrm->StartElement( "style:column" );
-    pStrm->EndElement( "style:column" );
+    pStrm->StartElement( u"style:column"_ustr );
+    pStrm->EndElement( u"style:column"_ustr );
 }
 
 void    XFColumnSep::SetRelHeight(sal_Int32 height)
@@ -107,26 +107,26 @@ void    XFColumnSep::ToXml(IXFStream *pStrm)
     IXFAttrList *pAttrList = pStrm->GetAttrList();
 
     pAttrList->Clear();
-    pAttrList->AddAttribute( "style:width", OUString::number(m_fWidth) + "cm" );
+    pAttrList->AddAttribute( u"style:width"_ustr, OUString::number(m_fWidth) + "cm" );
     if( m_aColor.IsValid() )
-        pAttrList->AddAttribute( "style:color", m_aColor.ToString() );
-    pAttrList->AddAttribute( "style:height", OUString::number(m_nRelHeight) + "%" );
+        pAttrList->AddAttribute( u"style:color"_ustr, m_aColor.ToString() );
+    pAttrList->AddAttribute( u"style:height"_ustr, OUString::number(m_nRelHeight) + "%" );
     //text align:
     if( m_eVertAlign == enumXFAlignTop )
     {
-        pAttrList->AddAttribute("style:vertical-align","top");
+        pAttrList->AddAttribute(u"style:vertical-align"_ustr,u"top"_ustr);
     }
     else if( m_eVertAlign == enumXFAlignMiddle )
     {
-        pAttrList->AddAttribute("style:vertical-align","middle");
+        pAttrList->AddAttribute(u"style:vertical-align"_ustr,u"middle"_ustr);
     }
     else if( m_eVertAlign == enumXFAlignBottom )
     {
-        pAttrList->AddAttribute("style:vertical-align","bottom");
+        pAttrList->AddAttribute(u"style:vertical-align"_ustr,u"bottom"_ustr);
     }
 
-    pStrm->StartElement( "style:column-sep" );
-    pStrm->EndElement( "style:column-sep" );
+    pStrm->StartElement( u"style:column-sep"_ustr );
+    pStrm->EndElement( u"style:column-sep"_ustr );
 }
 
 void    XFColumns::SetSeparator(XFColumnSep const & aSeparator)
@@ -156,13 +156,13 @@ void    XFColumns::ToXml(IXFStream *pStrm)
     IXFAttrList *pAttrList = pStrm->GetAttrList();
     pAttrList->Clear();
 
-    pAttrList->AddAttribute( "fo:column-count", OUString::number(m_nCount));
+    pAttrList->AddAttribute( u"fo:column-count"_ustr, OUString::number(m_nCount));
     if( m_nFlag&XFCOLUMNS_FLAG_GAP )
     {
-        pAttrList->AddAttribute( "fo:column-gap", OUString::number(m_fGap)+"cm" );
+        pAttrList->AddAttribute( u"fo:column-gap"_ustr, OUString::number(m_fGap)+"cm" );
     }
 
-    pStrm->StartElement( "style:columns" );
+    pStrm->StartElement( u"style:columns"_ustr );
 
     if( m_nFlag&XFCOLUMNS_FLAG_SEPARATOR )  //column-sep:
     {
@@ -176,6 +176,6 @@ void    XFColumns::ToXml(IXFStream *pStrm)
             column.ToXml(pStrm);
         }
     }
-    pStrm->EndElement( "style:columns" );
+    pStrm->EndElement( u"style:columns"_ustr );
 }
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/source/filter/xfilter/xfcrossref.cxx b/lotuswordpro/source/filter/xfilter/xfcrossref.cxx
index e0405261101f..bf8594d71c4e 100644
--- a/lotuswordpro/source/filter/xfilter/xfcrossref.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfcrossref.cxx
@@ -78,23 +78,23 @@ void XFCrossRefStart::ToXml(IXFStream* pStrm)
 
     if (m_nType == CROSSREF_TEXT)
     {
-        pAttrList->AddAttribute("text:reference-format", "text");
+        pAttrList->AddAttribute(u"text:reference-format"_ustr, u"text"_ustr);
     }
     else if (m_nType == CROSSREF_PAGE)
     {
-        pAttrList->AddAttribute("text:reference-format", "page");
+        pAttrList->AddAttribute(u"text:reference-format"_ustr, u"page"_ustr);
     }
     else if (m_nType == CROSSREF_PARANUMBER)
     {
-        pAttrList->AddAttribute("text:reference-format", "chapter");
+        pAttrList->AddAttribute(u"text:reference-format"_ustr, u"chapter"_ustr);
     }
-    pAttrList->AddAttribute("text:ref-name", m_strMarkName);
-    pStrm->StartElement("text:bookmark-ref");
+    pAttrList->AddAttribute(u"text:ref-name"_ustr, m_strMarkName);
+    pStrm->StartElement(u"text:bookmark-ref"_ustr);
 }
 
 XFCrossRefEnd::XFCrossRefEnd() {}
 
 XFCrossRefEnd::~XFCrossRefEnd() {}
 
-void XFCrossRefEnd::ToXml(IXFStream* pStrm) { pStrm->EndElement("text:bookmark-ref"); }
+void XFCrossRefEnd::ToXml(IXFStream* pStrm) { pStrm->EndElement(u"text:bookmark-ref"_ustr); }
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/source/filter/xfilter/xfdate.cxx b/lotuswordpro/source/filter/xfilter/xfdate.cxx
index 73425802f8d5..04887740ba59 100644
--- a/lotuswordpro/source/filter/xfilter/xfdate.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfdate.cxx
@@ -74,12 +74,12 @@ void    XFDate::ToXml(IXFStream *pStrm)
 
     pAttrList->Clear();
     if( !GetStyleName().isEmpty() )
-        pAttrList->AddAttribute( "style:data-style-name", GetStyleName() );
+        pAttrList->AddAttribute( u"style:data-style-name"_ustr, GetStyleName() );
 
-    pStrm->StartElement( "text:date" );
+    pStrm->StartElement( u"text:date"_ustr );
     if (!m_strText.isEmpty())
         pStrm->Characters(m_strText);
-    pStrm->EndElement( "text:date" );
+    pStrm->EndElement( u"text:date"_ustr );
 }
 
 void XFDateStart::ToXml(IXFStream *pStrm)
@@ -88,7 +88,7 @@ void XFDateStart::ToXml(IXFStream *pStrm)
 
     pAttrList->Clear();
     if( !GetStyleName().isEmpty() )
-        pAttrList->AddAttribute( "style:data-style-name", GetStyleName() );
+        pAttrList->AddAttribute( u"style:data-style-name"_ustr, GetStyleName() );
 /*  if (m_bValued)
         pAttrList->AddAttribute( "text:date-value", DateTimeToOUString(m_aDateTime) );
     if( m_bFixed )
@@ -98,12 +98,12 @@ void XFDateStart::ToXml(IXFStream *pStrm)
     if (m_strText.getLength()>0)
         pStrm->Characters(m_strText);
 */
-    pStrm->StartElement( "text:date" );
+    pStrm->StartElement( u"text:date"_ustr );
 }
 
 void XFDateEnd::ToXml(IXFStream *pStrm)
 {
-    pStrm->EndElement( "text:date" );
+    pStrm->EndElement( u"text:date"_ustr );
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/source/filter/xfilter/xfdatestyle.cxx b/lotuswordpro/source/filter/xfilter/xfdatestyle.cxx
index 77eeb6acab25..08bb7fd109b3 100644
--- a/lotuswordpro/source/filter/xfilter/xfdatestyle.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfdatestyle.cxx
@@ -76,84 +76,84 @@ void    XFDatePart::ToXml(IXFStream *pStrm)
     case enumXFDateYear:
         pAttrList->Clear();
         if( m_bLongFmt )
-            pAttrList->AddAttribute( "number:style", "long" );
-        pStrm->StartElement( "number:year" );
-        pStrm->EndElement( "number:year" );
+            pAttrList->AddAttribute( u"number:style"_ustr, u"long"_ustr );
+        pStrm->StartElement( u"number:year"_ustr );
+        pStrm->EndElement( u"number:year"_ustr );
         break;
     case enumXFDateMonth:
         pAttrList->Clear();
         if( m_bTexture )
-            pAttrList->AddAttribute( "number:textual", "true" );
+            pAttrList->AddAttribute( u"number:textual"_ustr, u"true"_ustr );
         if( m_bLongFmt )
-            pAttrList->AddAttribute( "number:style", "long" );
-        pStrm->StartElement( "number:month" );
-        pStrm->EndElement( "number:month" );
+            pAttrList->AddAttribute( u"number:style"_ustr, u"long"_ustr );
+        pStrm->StartElement( u"number:month"_ustr );
+        pStrm->EndElement( u"number:month"_ustr );
         break;
     case enumXFDateMonthDay:
         pAttrList->Clear();
         if( m_bLongFmt )
-            pAttrList->AddAttribute( "number:style", "long" );
-        pStrm->StartElement( "number:day" );
-        pStrm->EndElement( "number:day" );
+            pAttrList->AddAttribute( u"number:style"_ustr, u"long"_ustr );
+        pStrm->StartElement( u"number:day"_ustr );
+        pStrm->EndElement( u"number:day"_ustr );
         break;
     case enumXFDateWeekDay:
         pAttrList->Clear();
         if( m_bLongFmt )
-            pAttrList->AddAttribute( "number:style", "long" );
-        pStrm->StartElement( "number:day-of-week" );
-        pStrm->EndElement( "number:day-of-week" );
+            pAttrList->AddAttribute( u"number:style"_ustr, u"long"_ustr );
+        pStrm->StartElement( u"number:day-of-week"_ustr );
+        pStrm->EndElement( u"number:day-of-week"_ustr );
         break;
     case enumXFDateYearWeek:
         pAttrList->Clear();
-        pStrm->StartElement( "number:week-of-year" );
-        pStrm->EndElement( "number:week-of-year" );
+        pStrm->StartElement( u"number:week-of-year"_ustr );
+        pStrm->EndElement( u"number:week-of-year"_ustr );
         break;
     case enumXFDateEra:
         pAttrList->Clear();
         if( m_bLongFmt )
-            pAttrList->AddAttribute( "number:style", "long" );
-        pStrm->StartElement( "number:era" );
-        pStrm->EndElement( "number:era" );
+            pAttrList->AddAttribute( u"number:style"_ustr, u"long"_ustr );
+        pStrm->StartElement( u"number:era"_ustr );
+        pStrm->EndElement( u"number:era"_ustr );
         break;
     case enumXFDateQuarter:
         pAttrList->Clear();
         if( m_bLongFmt )
-            pAttrList->AddAttribute( "number:style", "long" );
-        pStrm->StartElement( "number:quarter" );
-        pStrm->EndElement( "number:quarter" );
+            pAttrList->AddAttribute( u"number:style"_ustr, u"long"_ustr );
+        pStrm->StartElement( u"number:quarter"_ustr );
+        pStrm->EndElement( u"number:quarter"_ustr );
         break;
     case enumXFDateHour:
         pAttrList->Clear();
         if( m_bLongFmt )
-            pAttrList->AddAttribute( "number:style", "long" );
-        pStrm->StartElement( "number:hours" );
-        pStrm->EndElement( "number:hours" );
+            pAttrList->AddAttribute( u"number:style"_ustr, u"long"_ustr );
+        pStrm->StartElement( u"number:hours"_ustr );
+        pStrm->EndElement( u"number:hours"_ustr );
         break;
     case enumXFDateMinute:
         pAttrList->Clear();
         if( m_bLongFmt )
-            pAttrList->AddAttribute( "number:style", "long" );
-        pStrm->StartElement( "number:minutes" );
-        pStrm->EndElement( "number:minutes" );
+            pAttrList->AddAttribute( u"number:style"_ustr, u"long"_ustr );
+        pStrm->StartElement( u"number:minutes"_ustr );
+        pStrm->EndElement( u"number:minutes"_ustr );
         break;
     case enumXFDateSecond:
         pAttrList->Clear();
         if( m_bLongFmt )
-            pAttrList->AddAttribute( "number:style", "long" );
+            pAttrList->AddAttribute( u"number:style"_ustr, u"long"_ustr );
         if( m_nDecimalPos )
-            pAttrList->AddAttribute( "number:decimal-places", OUString::number(m_nDecimalPos) );
-        pStrm->StartElement( "number:seconds" );
-        pStrm->EndElement( "number:seconds" );
+            pAttrList->AddAttribute( u"number:decimal-places"_ustr, OUString::number(m_nDecimalPos) );
+        pStrm->StartElement( u"number:seconds"_ustr );
+        pStrm->EndElement( u"number:seconds"_ustr );
         break;
     case enumXFDateAmPm:
-        pStrm->StartElement( "number:am-pm" );
-        pStrm->EndElement( "number:am-pm" );
+        pStrm->StartElement( u"number:am-pm"_ustr );
+        pStrm->EndElement( u"number:am-pm"_ustr );
         break;
     case enumXFDateText:
         pAttrList->Clear();
-        pStrm->StartElement( "number:text" );
+        pStrm->StartElement( u"number:text"_ustr );
         pStrm->Characters( m_strText );
-        pStrm->EndElement( "number:text" );
+        pStrm->EndElement( u"number:text"_ustr );
         break;
     }
 }
@@ -176,14 +176,14 @@ void    XFDateStyle::ToXml(IXFStream *pStrm)
     IXFAttrList *pAttrList = pStrm->GetAttrList();
 
     pAttrList->Clear();
-    pAttrList->AddAttribute( "style:name", GetStyleName() );
-    pAttrList->AddAttribute( "style:family", "data-style" );
+    pAttrList->AddAttribute( u"style:name"_ustr, GetStyleName() );
+    pAttrList->AddAttribute( u"style:family"_ustr, u"data-style"_ustr );
 
-    pStrm->StartElement( "number:date-style" );
+    pStrm->StartElement( u"number:date-style"_ustr );
 
     m_aParts.ToXml(pStrm);
 
-    pStrm->EndElement( "number:date-style" );
+    pStrm->EndElement( u"number:date-style"_ustr );
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/source/filter/xfilter/xfdocfield.cxx b/lotuswordpro/source/filter/xfilter/xfdocfield.cxx
index da32ed829cf8..84c1cac7157d 100644
--- a/lotuswordpro/source/filter/xfilter/xfdocfield.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfdocfield.cxx
@@ -71,90 +71,90 @@ void XFFileName::ToXml(IXFStream *pStrm)
     IXFAttrList *pAttrList = pStrm->GetAttrList();
     pAttrList->Clear();
     if (m_strType == "FileName")
-        pAttrList->AddAttribute( "text:display", "name-and-extension" );
+        pAttrList->AddAttribute( u"text:display"_ustr, u"name-and-extension"_ustr );
     else if (m_strType == "Path")
-        pAttrList->AddAttribute( "text:display", "path" );
-    pStrm->StartElement( "text:file-name" );
-    pStrm->EndElement( "text:file-name" );
+        pAttrList->AddAttribute( u"text:display"_ustr, u"path"_ustr );
+    pStrm->StartElement( u"text:file-name"_ustr );
+    pStrm->EndElement( u"text:file-name"_ustr );
 }
 
 void XFWordCount::ToXml(IXFStream *pStrm)
 {
     IXFAttrList *pAttrList = pStrm->GetAttrList();
     pAttrList->Clear();
-    pStrm->StartElement( "text:word-count" );
-    pStrm->EndElement( "text:word-count" );
+    pStrm->StartElement( u"text:word-count"_ustr );
+    pStrm->EndElement( u"text:word-count"_ustr );
 }
 
 void XFCharCount::ToXml(IXFStream *pStrm)
 {
     IXFAttrList *pAttrList = pStrm->GetAttrList();
     pAttrList->Clear();
-    pStrm->StartElement( "text:character-count" );
-    pStrm->EndElement( "text:character-count" );
+    pStrm->StartElement( u"text:character-count"_ustr );
+    pStrm->EndElement( u"text:character-count"_ustr );
 }
 
 void XFDescription::ToXml(IXFStream *pStrm)
 {
     IXFAttrList *pAttrList = pStrm->GetAttrList();
     pAttrList->Clear();
-    pStrm->StartElement( "text:description" );
-    pStrm->EndElement( "text:description" );
+    pStrm->StartElement( u"text:description"_ustr );
+    pStrm->EndElement( u"text:description"_ustr );
 }
 
 void XFPageCountStart::ToXml(IXFStream *pStrm)
 {
     IXFAttrList *pAttrList = pStrm->GetAttrList();
     pAttrList->Clear();
-    pStrm->StartElement( "text:page-count" );
+    pStrm->StartElement( u"text:page-count"_ustr );
 }
 void XFPageCountEnd::ToXml(IXFStream *pStrm)
 {
-    pStrm->EndElement( "text:page-count" );
+    pStrm->EndElement( u"text:page-count"_ustr );
 }
 
 void XFWordCountStart::ToXml(IXFStream *pStrm)
 {
     IXFAttrList *pAttrList = pStrm->GetAttrList();
     pAttrList->Clear();
-    pStrm->StartElement( "text:word-count" );
+    pStrm->StartElement( u"text:word-count"_ustr );
 }
 
 void XFCharCountStart::ToXml(IXFStream *pStrm)
 {
     IXFAttrList *pAttrList = pStrm->GetAttrList();
     pAttrList->Clear();
-    pStrm->StartElement( "text:character-count" );
+    pStrm->StartElement( u"text:character-count"_ustr );
 }
 
 void XFDescriptionStart::ToXml(IXFStream *pStrm)
 {
     IXFAttrList *pAttrList = pStrm->GetAttrList();
     pAttrList->Clear();
-    pStrm->StartElement( "text:description" );
+    pStrm->StartElement( u"text:description"_ustr );
 }
 
 void XFWordCountEnd::ToXml(IXFStream *pStrm)
 {
-    pStrm->EndElement( "text:word-count" );
+    pStrm->EndElement( u"text:word-count"_ustr );
 }
 
 void XFCharCountEnd::ToXml(IXFStream *pStrm)
 {
-    pStrm->EndElement( "text:character-count" );
+    pStrm->EndElement( u"text:character-count"_ustr );
 }
 
 void XFDescriptionEnd::ToXml(IXFStream *pStrm)
 {
-    pStrm->EndElement( "text:description" );
+    pStrm->EndElement( u"text:description"_ustr );
 }
 
 void XFKeywords::ToXml(IXFStream *pStrm)
 {
     IXFAttrList *pAttrList = pStrm->GetAttrList();
     pAttrList->Clear();
-    pStrm->StartElement( "text:keywords" );
-    pStrm->EndElement( "text:keywords" );
+    pStrm->StartElement( u"text:keywords"_ustr );
+    pStrm->EndElement( u"text:keywords"_ustr );
 }
 
 void XFTotalEditTime::ToXml(IXFStream *pStrm)
@@ -162,39 +162,39 @@ void XFTotalEditTime::ToXml(IXFStream *pStrm)
     IXFAttrList *pAttrList = pStrm->GetAttrList();
     pAttrList->Clear();
     if (!m_strStyleName.isEmpty())
-        pAttrList->AddAttribute( "style:data-style-name", m_strStyleName );
-    pStrm->StartElement( "text:editing-duration" );
-    pStrm->EndElement( "text:editing-duration" );
+        pAttrList->AddAttribute( u"style:data-style-name"_ustr, m_strStyleName );
+    pStrm->StartElement( u"text:editing-duration"_ustr );
+    pStrm->EndElement( u"text:editing-duration"_ustr );
 }
 void XFTotalEditTimeStart::ToXml(IXFStream *pStrm)
 {
     IXFAttrList *pAttrList = pStrm->GetAttrList();
     pAttrList->Clear();
     if (!m_strStyleName.isEmpty())
-        pAttrList->AddAttribute( "style:data-style-name", m_strStyleName );
-    pStrm->StartElement( "text:editing-duration" );
+        pAttrList->AddAttribute( u"style:data-style-name"_ustr, m_strStyleName );
+    pStrm->StartElement( u"text:editing-duration"_ustr );
 }
 void XFTotalEditTimeEnd::ToXml(IXFStream *pStrm)
 {
-    pStrm->EndElement( "text:editing-duration" );
+    pStrm->EndElement( u"text:editing-duration"_ustr );
 }
 void XFCreateTime::ToXml(IXFStream *pStrm)
 {
     IXFAttrList *pAttrList = pStrm->GetAttrList();
     pAttrList->Clear();
     if (!m_strStyleName.isEmpty())
-        pAttrList->AddAttribute( "style:data-style-name", m_strStyleName );
-    pStrm->StartElement( "text:creation-time" );
-    pStrm->EndElement( "text:creation-time" );
+        pAttrList->AddAttribute( u"style:data-style-name"_ustr, m_strStyleName );
+    pStrm->StartElement( u"text:creation-time"_ustr );
+    pStrm->EndElement( u"text:creation-time"_ustr );
 }
 void XFLastEditTime::ToXml(IXFStream *pStrm)
 {
     IXFAttrList *pAttrList = pStrm->GetAttrList();
     pAttrList->Clear();
     if (!m_strStyleName.isEmpty())
-        pAttrList->AddAttribute( "style:data-style-name", m_strStyleName );
-    pStrm->StartElement( "text:modification-time" );
-    pStrm->EndElement( "text:modification-time" );
+        pAttrList->AddAttribute( u"style:data-style-name"_ustr, m_strStyleName );
+    pStrm->StartElement( u"text:modification-time"_ustr );
+    pStrm->EndElement( u"text:modification-time"_ustr );
 }
 
 void XFCreateTimeStart::ToXml(IXFStream *pStrm)
@@ -202,8 +202,8 @@ void XFCreateTimeStart::ToXml(IXFStream *pStrm)
     IXFAttrList *pAttrList = pStrm->GetAttrList();
     pAttrList->Clear();
     if (!m_strStyleName.isEmpty())
-        pAttrList->AddAttribute( "style:data-style-name", m_strStyleName );
-    pStrm->StartElement( "text:creation-time" );
+        pAttrList->AddAttribute( u"style:data-style-name"_ustr, m_strStyleName );
+    pStrm->StartElement( u"text:creation-time"_ustr );
 }
 
 void XFLastEditTimeStart::ToXml(IXFStream *pStrm)
@@ -211,24 +211,24 @@ void XFLastEditTimeStart::ToXml(IXFStream *pStrm)
     IXFAttrList *pAttrList = pStrm->GetAttrList();
     pAttrList->Clear();
     if (!m_strStyleName.isEmpty())
-        pAttrList->AddAttribute( "style:data-style-name", m_strStyleName );
-    pStrm->StartElement( "text:modification-time" );
+        pAttrList->AddAttribute( u"style:data-style-name"_ustr, m_strStyleName );
+    pStrm->StartElement( u"text:modification-time"_ustr );
 }
 void XFCreateTimeEnd::ToXml(IXFStream *pStrm)
 {
-    pStrm->EndElement( "text:creation-time" );
+    pStrm->EndElement( u"text:creation-time"_ustr );
 }
 
 void XFLastEditTimeEnd::ToXml(IXFStream *pStrm)
 {
-    pStrm->EndElement( "text:modification-time" );
+    pStrm->EndElement( u"text:modification-time"_ustr );
 }
 
 void XFInitialCreator::ToXml(IXFStream *pStrm)
 {
     IXFAttrList *pAttrList = pStrm->GetAttrList();
     pAttrList->Clear();
-    pStrm->StartElement( "text:initial-creator" );
-    pStrm->EndElement( "text:initial-creator" );
+    pStrm->StartElement( u"text:initial-creator"_ustr );
+    pStrm->EndElement( u"text:initial-creator"_ustr );
 }
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/source/filter/xfilter/xfdrawareastyle.cxx b/lotuswordpro/source/filter/xfilter/xfdrawareastyle.cxx
index 4f086032f2c2..df5271bd3046 100644
--- a/lotuswordpro/source/filter/xfilter/xfdrawareastyle.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfdrawareastyle.cxx
@@ -76,20 +76,20 @@ void XFDrawAreaStyle::ToXml(IXFStream* pStrm)
 
     pAttrList->Clear();
 
-    pAttrList->AddAttribute("draw:name", GetStyleName());
+    pAttrList->AddAttribute(u"draw:name"_ustr, GetStyleName());
 
     if (m_eLineStyle == enumXFAreaLineSingle)
-        pAttrList->AddAttribute("draw:style", "single");
+        pAttrList->AddAttribute(u"draw:style"_ustr, u"single"_ustr);
     else if (m_eLineStyle == enumXFAreaLineCrossed)
-        pAttrList->AddAttribute("draw:style", "double");
+        pAttrList->AddAttribute(u"draw:style"_ustr, u"double"_ustr);
     else if (m_eLineStyle == enumXFAreaLineTriple)
-        pAttrList->AddAttribute("draw:style", "triple");
+        pAttrList->AddAttribute(u"draw:style"_ustr, u"triple"_ustr);
 
-    pAttrList->AddAttribute("draw:color", m_aLineColor.ToString());
-    pAttrList->AddAttribute("draw:rotation", OUString::number(m_nAngle * 10));
-    pAttrList->AddAttribute("draw:distance", OUString::number(m_fSpace) + "cm");
+    pAttrList->AddAttribute(u"draw:color"_ustr, m_aLineColor.ToString());
+    pAttrList->AddAttribute(u"draw:rotation"_ustr, OUString::number(m_nAngle * 10));
+    pAttrList->AddAttribute(u"draw:distance"_ustr, OUString::number(m_fSpace) + "cm");
 
-    pStrm->StartElement("draw:hatch");
-    pStrm->EndElement("draw:hatch");
+    pStrm->StartElement(u"draw:hatch"_ustr);
+    pStrm->EndElement(u"draw:hatch"_ustr);
 }
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/source/filter/xfilter/xfdrawline.cxx b/lotuswordpro/source/filter/xfilter/xfdrawline.cxx
index 32a68f9dff82..202ce2e6648e 100644
--- a/lotuswordpro/source/filter/xfilter/xfdrawline.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfdrawline.cxx
@@ -69,38 +69,38 @@ void XFDrawLine::ToXml(IXFStream *pStrm)
     IXFAttrList *pAttrList = pStrm->GetAttrList();
 
     if( !GetStyleName().isEmpty() )
-        pAttrList->AddAttribute( "draw:style-name", GetStyleName() );
+        pAttrList->AddAttribute( u"draw:style-name"_ustr, GetStyleName() );
 
     assert(!m_strName.isEmpty() && "name should not be null.");
     if( !m_strName.isEmpty() )
-        pAttrList->AddAttribute( "draw:name", m_strName );
+        pAttrList->AddAttribute( u"draw:name"_ustr, m_strName );
     //anchor type:
     switch( m_eAnchor )
     {
     case enumXFAnchorPara:
-        pAttrList->AddAttribute( "text:anchor-type", "paragraph" );
+        pAttrList->AddAttribute( u"text:anchor-type"_ustr, u"paragraph"_ustr );
         break;
     case enumXFAnchorPage:
-        pAttrList->AddAttribute( "text:anchor-type", "page" );
+        pAttrList->AddAttribute( u"text:anchor-type"_ustr, u"page"_ustr );
         break;
     case enumXFAnchorChar:
-        pAttrList->AddAttribute( "text:anchor-type", "char" );
+        pAttrList->AddAttribute( u"text:anchor-type"_ustr, u"char"_ustr );
         break;
     case enumXFAnchorAsChar:
-        pAttrList->AddAttribute( "text:anchor-type", "as-char" );
+        pAttrList->AddAttribute( u"text:anchor-type"_ustr, u"as-char"_ustr );
         break;
     case enumXFAnchorFrame:
-        pAttrList->AddAttribute( "text:anchor-type", "frame" );
+        pAttrList->AddAttribute( u"text:anchor-type"_ustr, u"frame"_ustr );
         break;
     default:
         break;
     }
-    pAttrList->AddAttribute( "draw:z-index", OUString::number(m_nZIndex) );
+    pAttrList->AddAttribute( u"draw:z-index"_ustr, OUString::number(m_nZIndex) );
 
-    pAttrList->AddAttribute( "svg:x1", OUString::number(m_aPoint1.GetX()) + "cm" );
-    pAttrList->AddAttribute( "svg:y1", OUString::number(m_aPoint1.GetY()) + "cm" );
-    pAttrList->AddAttribute( "svg:x2", OUString::number(m_aPoint2.GetX()) + "cm" );
-    pAttrList->AddAttribute( "svg:y2", OUString::number(m_aPoint2.GetY()) + "cm" );
+    pAttrList->AddAttribute( u"svg:x1"_ustr, OUString::number(m_aPoint1.GetX()) + "cm" );
+    pAttrList->AddAttribute( u"svg:y1"_ustr, OUString::number(m_aPoint1.GetY()) + "cm" );
+    pAttrList->AddAttribute( u"svg:x2"_ustr, OUString::number(m_aPoint2.GetX()) + "cm" );
+    pAttrList->AddAttribute( u"svg:y2"_ustr, OUString::number(m_aPoint2.GetY()) + "cm" );
 
     //transform
     OUString   strTransform;
@@ -115,10 +115,10 @@ void XFDrawLine::ToXml(IXFStream *pStrm)
     strTransform = strTransform.trim();
 
     if( !strTransform.isEmpty() )
-        pAttrList->AddAttribute( "draw:transform", strTransform );
+        pAttrList->AddAttribute( u"draw:transform"_ustr, strTransform );
 
-    pStrm->StartElement( "draw:line" );
+    pStrm->StartElement( u"draw:line"_ustr );
     ContentToXml(pStrm);
-    pStrm->EndElement( "draw:line" );
+    pStrm->EndElement( u"draw:line"_ustr );
 }
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/source/filter/xfilter/xfdrawlinestyle.cxx b/lotuswordpro/source/filter/xfilter/xfdrawlinestyle.cxx
index 575e6184cf43..5ab95dac6562 100644
--- a/lotuswordpro/source/filter/xfilter/xfdrawlinestyle.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfdrawlinestyle.cxx
@@ -79,39 +79,39 @@ void XFDrawLineStyle::ToXml(IXFStream* pStrm)
     IXFAttrList* pAttrList = pStrm->GetAttrList();
 
     pAttrList->Clear();
-    pAttrList->AddAttribute("draw:name", GetStyleName());
+    pAttrList->AddAttribute(u"draw:name"_ustr, GetStyleName());
     //simple place here:
-    pAttrList->AddAttribute("draw:style", "rect");
+    pAttrList->AddAttribute(u"draw:style"_ustr, u"rect"_ustr);
 
     if (m_eLineStyle == enumXFLineDot)
     {
     }
     else if (m_eLineStyle == enumXFLineDash)
     {
-        pAttrList->AddAttribute("draw:dots1", OUString::number(m_nNumber1));
-        pAttrList->AddAttribute(" draw:dots1-length", OUString::number(m_fLength1) + "cm");
+        pAttrList->AddAttribute(u"draw:dots1"_ustr, OUString::number(m_nNumber1));
+        pAttrList->AddAttribute(u" draw:dots1-length"_ustr, OUString::number(m_fLength1) + "cm");
 
-        pAttrList->AddAttribute("draw:dots2", OUString::number(m_nNumber2));
-        pAttrList->AddAttribute(" draw:dots2-length", OUString::number(m_fLength2) + "cm");
+        pAttrList->AddAttribute(u"draw:dots2"_ustr, OUString::number(m_nNumber2));
+        pAttrList->AddAttribute(u" draw:dots2-length"_ustr, OUString::number(m_fLength2) + "cm");
     }
     else if (m_eLineStyle == enumXFLineDotDash)
     {
-        pAttrList->AddAttribute("draw:dots1", OUString::number(m_nNumber1));
+        pAttrList->AddAttribute(u"draw:dots1"_ustr, OUString::number(m_nNumber1));
 
-        pAttrList->AddAttribute("draw:dots2", OUString::number(m_nNumber2));
-        pAttrList->AddAttribute(" draw:dots2-length", OUString::number(m_fLength2) + "cm");
+        pAttrList->AddAttribute(u"draw:dots2"_ustr, OUString::number(m_nNumber2));
+        pAttrList->AddAttribute(u" draw:dots2-length"_ustr, OUString::number(m_fLength2) + "cm");
     }
     else if (m_eLineStyle == enumXFLineDashDot)
     {
-        pAttrList->AddAttribute("draw:dots1", OUString::number(m_nNumber1));
-        pAttrList->AddAttribute(" draw:dots1-length", OUString::number(m_fLength1) + "cm");
+        pAttrList->AddAttribute(u"draw:dots1"_ustr, OUString::number(m_nNumber1));
+        pAttrList->AddAttribute(u" draw:dots1-length"_ustr, OUString::number(m_fLength1) + "cm");
 
-        pAttrList->AddAttribute("draw:dots2", OUString::number(m_nNumber2));
+        pAttrList->AddAttribute(u"draw:dots2"_ustr, OUString::number(m_nNumber2));
     }
 
-    pAttrList->AddAttribute("draw:distance", OUString::number(m_fSpace) + "cm");
+    pAttrList->AddAttribute(u"draw:distance"_ustr, OUString::number(m_fSpace) + "cm");
 
-    pStrm->StartElement("draw:stroke-dash");
-    pStrm->EndElement("draw:stroke-dash");
+    pStrm->StartElement(u"draw:stroke-dash"_ustr);
+    pStrm->EndElement(u"draw:stroke-dash"_ustr);
 }
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/source/filter/xfilter/xfdrawobj.cxx b/lotuswordpro/source/filter/xfilter/xfdrawobj.cxx
index 0cac7a8f797c..335ce168b408 100644
--- a/lotuswordpro/source/filter/xfilter/xfdrawobj.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfdrawobj.cxx
@@ -77,38 +77,38 @@ void XFDrawObject::ToXml(IXFStream *pStrm)
     IXFAttrList *pAttrList = pStrm->GetAttrList();
 
     if( !GetStyleName().isEmpty() )
-        pAttrList->AddAttribute( "draw:style-name", GetStyleName() );
+        pAttrList->AddAttribute( u"draw:style-name"_ustr, GetStyleName() );
 
     assert(!m_strName.isEmpty() && "name should not be null.");
     if( !m_strName.isEmpty() )
-        pAttrList->AddAttribute( "draw:name", m_strName );
+        pAttrList->AddAttribute( u"draw:name"_ustr, m_strName );
     //anchor type:
     switch( m_eAnchor )
     {
     case enumXFAnchorPara:
-        pAttrList->AddAttribute( "text:anchor-type", "paragraph" );
+        pAttrList->AddAttribute( u"text:anchor-type"_ustr, u"paragraph"_ustr );
         break;
     case enumXFAnchorPage:
-        pAttrList->AddAttribute( "text:anchor-type", "page" );
+        pAttrList->AddAttribute( u"text:anchor-type"_ustr, u"page"_ustr );
         break;
     case enumXFAnchorChar:
-        pAttrList->AddAttribute( "text:anchor-type", "char" );
+        pAttrList->AddAttribute( u"text:anchor-type"_ustr, u"char"_ustr );
         break;
     case enumXFAnchorAsChar:
-        pAttrList->AddAttribute( "text:anchor-type", "as-char" );
+        pAttrList->AddAttribute( u"text:anchor-type"_ustr, u"as-char"_ustr );
         break;
     case enumXFAnchorFrame:
-        pAttrList->AddAttribute( "text:anchor-type", "frame" );
+        pAttrList->AddAttribute( u"text:anchor-type"_ustr, u"frame"_ustr );
         break;
     default:
         break;
     }
-    pAttrList->AddAttribute( "draw:z-index", OUString::number(m_nZIndex) );
+    pAttrList->AddAttribute( u"draw:z-index"_ustr, OUString::number(m_nZIndex) );
 
-    pAttrList->AddAttribute( "svg:x", OUString::number(m_aRect.GetX()) + "cm" );
-    pAttrList->AddAttribute( "svg:y", OUString::number(m_aRect.GetY()) + "cm" );
-    pAttrList->AddAttribute( "svg:width", OUString::number(m_aRect.GetWidth()) + "cm" );
-    pAttrList->AddAttribute( "svg:height", OUString::number(m_aRect.GetHeight()) + "cm" );
+    pAttrList->AddAttribute( u"svg:x"_ustr, OUString::number(m_aRect.GetX()) + "cm" );
+    pAttrList->AddAttribute( u"svg:y"_ustr, OUString::number(m_aRect.GetY()) + "cm" );
+    pAttrList->AddAttribute( u"svg:width"_ustr, OUString::number(m_aRect.GetWidth()) + "cm" );
+    pAttrList->AddAttribute( u"svg:height"_ustr, OUString::number(m_aRect.GetHeight()) + "cm" );
 
     //transform
     OUString   strTransform;
@@ -125,6 +125,6 @@ void XFDrawObject::ToXml(IXFStream *pStrm)
     strTransform = strTransform.trim();
 
     if( !strTransform.isEmpty() )
-        pAttrList->AddAttribute( "draw:transform", strTransform );
+        pAttrList->AddAttribute( u"draw:transform"_ustr, strTransform );
 }
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/source/filter/xfilter/xfdrawpath.cxx b/lotuswordpro/source/filter/xfilter/xfdrawpath.cxx
index b85f2d6dc473..7be87eef0f91 100644
--- a/lotuswordpro/source/filter/xfilter/xfdrawpath.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfdrawpath.cxx
@@ -86,7 +86,7 @@ void    XFDrawPath::MoveTo(XFPoint pt)
 {
     XFSvgPathEntry  entry;
 
-    entry.SetCommand("M");
+    entry.SetCommand(u"M"_ustr);
     entry.AddPoint(pt);
     m_aPaths.push_back(entry);
 }
@@ -95,7 +95,7 @@ void    XFDrawPath::LineTo(XFPoint pt)
 {
     XFSvgPathEntry  entry;
 
-    entry.SetCommand("L");
+    entry.SetCommand(u"L"_ustr);
     entry.AddPoint(pt);
     m_aPaths.push_back(entry);
 }
@@ -104,7 +104,7 @@ void    XFDrawPath::CurveTo(XFPoint dest, XFPoint ctrl1, XFPoint ctrl2)
 {
     XFSvgPathEntry  entry;
 
-    entry.SetCommand("C");
+    entry.SetCommand(u"C"_ustr);
     entry.AddPoint(ctrl1);
     entry.AddPoint(ctrl2);
     entry.AddPoint(dest);
@@ -116,7 +116,7 @@ void    XFDrawPath::ClosePath()
 {
     XFSvgPathEntry  entry;
 
-    entry.SetCommand("Z");
+    entry.SetCommand(u"Z"_ustr);
 
     m_aPaths.push_back(entry);
 }
@@ -132,7 +132,7 @@ void    XFDrawPath::ToXml(IXFStream *pStrm)
     OUString strViewBox = "0 0 " +
         OUString::number(rect.GetWidth()*1000) + " " +
         OUString::number(rect.GetHeight()*1000);
-    pAttrList->AddAttribute( "svg:viewBox", strViewBox);
+    pAttrList->AddAttribute( u"svg:viewBox"_ustr, strViewBox);
 
     //points
     OUStringBuffer strPath;
@@ -142,14 +142,14 @@ void    XFDrawPath::ToXml(IXFStream *pStrm)
     }
     if (!strPath.isEmpty())
         strPath.setLength(strPath.getLength()-1);
-    pAttrList->AddAttribute( "svg:d", strPath.makeStringAndClear());
+    pAttrList->AddAttribute( u"svg:d"_ustr, strPath.makeStringAndClear());
 
     SetPosition(rect);
     XFDrawObject::ToXml(pStrm);
 
-    pStrm->StartElement( "draw:path" );
+    pStrm->StartElement( u"draw:path"_ustr );
     ContentToXml(pStrm);
-    pStrm->EndElement( "draw:path" );
+    pStrm->EndElement( u"draw:path"_ustr );
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/source/filter/xfilter/xfdrawpolygon.cxx b/lotuswordpro/source/filter/xfilter/xfdrawpolygon.cxx
index d0e0239947af..b6cbb86b018e 100644
--- a/lotuswordpro/source/filter/xfilter/xfdrawpolygon.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfdrawpolygon.cxx
@@ -75,7 +75,7 @@ void XFDrawPolygon::ToXml(IXFStream *pStrm)
     OUString strViewBox = "0 0 " +
         OUString::number(rect.GetWidth()*1000) + " " +
         OUString::number(rect.GetHeight()*1000);
-    pAttrList->AddAttribute( "svg:viewBox", strViewBox);
+    pAttrList->AddAttribute( u"svg:viewBox"_ustr, strViewBox);
 
     //points
     OUStringBuffer strPoints;
@@ -86,14 +86,14 @@ void XFDrawPolygon::ToXml(IXFStream *pStrm)
         strPoints.append( OUString::number(x) + " " + OUString::number(y) + " ");
     }
     strPoints.stripEnd(' ');
-    pAttrList->AddAttribute( "draw:points", strPoints.makeStringAndClear());
+    pAttrList->AddAttribute( u"draw:points"_ustr, strPoints.makeStringAndClear());
 
     SetPosition(rect.GetX(),rect.GetY(),rect.GetWidth(),rect.GetHeight());
     XFDrawObject::ToXml(pStrm);
 
-    pStrm->StartElement( "draw:polygon" );
+    pStrm->StartElement( u"draw:polygon"_ustr );
     ContentToXml(pStrm);
-    pStrm->EndElement( "draw:polygon" );
+    pStrm->EndElement( u"draw:polygon"_ustr );
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/source/filter/xfilter/xfdrawpolyline.cxx b/lotuswordpro/source/filter/xfilter/xfdrawpolyline.cxx
index 6f5fb1a0f8a2..aafec7e25392 100644
--- a/lotuswordpro/source/filter/xfilter/xfdrawpolyline.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfdrawpolyline.cxx
@@ -75,7 +75,7 @@ void XFDrawPolyline::ToXml(IXFStream *pStrm)
     OUString strViewBox = "0 0 " +
         OUString::number(rect.GetWidth()*1000) + " " +
         OUString::number(rect.GetHeight()*1000);
-    pAttrList->AddAttribute( "svg:viewBox", strViewBox);
+    pAttrList->AddAttribute( u"svg:viewBox"_ustr, strViewBox);
 
     //points
     OUStringBuffer strPoints;
@@ -86,14 +86,14 @@ void XFDrawPolyline::ToXml(IXFStream *pStrm)
         strPoints.append( OUString::number(x) + "," + OUString::number(y) + " ");
     }
     strPoints.stripEnd(' ');
-    pAttrList->AddAttribute( "draw:points", strPoints.makeStringAndClear());
+    pAttrList->AddAttribute( u"draw:points"_ustr, strPoints.makeStringAndClear());
 
     SetPosition(rect.GetX(),rect.GetY(),rect.GetWidth(),rect.GetHeight());
     XFDrawObject::ToXml(pStrm);
 
-    pStrm->StartElement( "draw:polyline" );
+    pStrm->StartElement( u"draw:polyline"_ustr );
     ContentToXml(pStrm);
-    pStrm->EndElement( "draw:polyline" );
+    pStrm->EndElement( u"draw:polyline"_ustr );
 }
 
 XFRect  XFDrawPolyline::CalcViewBox()
diff --git a/lotuswordpro/source/filter/xfilter/xfdrawrect.cxx b/lotuswordpro/source/filter/xfilter/xfdrawrect.cxx
index 6f613b1533fd..dce277c86303 100644
--- a/lotuswordpro/source/filter/xfilter/xfdrawrect.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfdrawrect.cxx
@@ -70,8 +70,8 @@ void XFDrawRect::ToXml(IXFStream* pStrm)
 
     XFDrawObject::ToXml(pStrm);
 
-    pStrm->StartElement("draw:rect");
+    pStrm->StartElement(u"draw:rect"_ustr);
     ContentToXml(pStrm);
-    pStrm->EndElement("draw:rect");
+    pStrm->EndElement(u"draw:rect"_ustr);
 }
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/source/filter/xfilter/xfdrawstyle.cxx b/lotuswordpro/source/filter/xfilter/xfdrawstyle.cxx
index f824dd5a8793..c2c4289a8939 100644
--- a/lotuswordpro/source/filter/xfilter/xfdrawstyle.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfdrawstyle.cxx
@@ -168,14 +168,14 @@ void    XFDrawStyle::ToXml(IXFStream *pStrm)
 
     pAttrList->Clear();
 
-    pAttrList->AddAttribute( "style:name", GetStyleName() );
-    pAttrList->AddAttribute( "style:family", "graphics" );
-    pStrm->StartElement( "style:style" );
+    pAttrList->AddAttribute( u"style:name"_ustr, GetStyleName() );
+    pAttrList->AddAttribute( u"style:family"_ustr, u"graphics"_ustr );
+    pStrm->StartElement( u"style:style"_ustr );
 
     pAttrList->Clear();
 
-    pAttrList->AddAttribute( "style:run-through", "foreground" );
-    pAttrList->AddAttribute( "style:wrap", "none" );
+    pAttrList->AddAttribute( u"style:run-through"_ustr, u"foreground"_ustr );
+    pAttrList->AddAttribute( u"style:wrap"_ustr, u"none"_ustr );
 
     //line style:
     if( m_pLineStyle )
@@ -184,69 +184,69 @@ void    XFDrawStyle::ToXml(IXFStream *pStrm)
         if( !m_pLineStyle->IsSolid() )
         {
 //          pAttrList->Clear();
-            pAttrList->AddAttribute( "draw:stroke", "dash" );
-            pAttrList->AddAttribute( "draw:stroke-dash", m_pLineStyle->GetStyleName() );
+            pAttrList->AddAttribute( u"draw:stroke"_ustr, u"dash"_ustr );
+            pAttrList->AddAttribute( u"draw:stroke-dash"_ustr, m_pLineStyle->GetStyleName() );
         }
         else
         {
-            pAttrList->AddAttribute( "draw:stroke", "solid" );
+            pAttrList->AddAttribute( u"draw:stroke"_ustr, u"solid"_ustr );
         }
 
         if( m_pLineStyle->GetWidth() > 0 )
-            pAttrList->AddAttribute( "svg:stroke-width", OUString::number(m_pLineStyle->GetWidth()) + "cm" );
+            pAttrList->AddAttribute( u"svg:stroke-width"_ustr, OUString::number(m_pLineStyle->GetWidth()) + "cm" );
 
         XFColor color = m_pLineStyle->GetColor();
         if( color.IsValid() )
-            pAttrList->AddAttribute( "svg:stroke-color", color.ToString() );
+            pAttrList->AddAttribute( u"svg:stroke-color"_ustr, color.ToString() );
 
         if( m_pLineStyle->GetTransparency()>0 )
-            pAttrList->AddAttribute( "svg:stroke-opacity", OUString::number(m_pLineStyle->GetTransparency()) + "%" );
+            pAttrList->AddAttribute( u"svg:stroke-opacity"_ustr, OUString::number(m_pLineStyle->GetTransparency()) + "%" );
     }
     else
-        pAttrList->AddAttribute( "draw:stroke", "none" );
+        pAttrList->AddAttribute( u"draw:stroke"_ustr, u"none"_ustr );
     //area style:
     if( m_pAreaStyle )
     {
         if( enumXFAreaSolid == m_pAreaStyle->GetAreaStyle() )
         {
-            pAttrList->AddAttribute( "draw:fill", "solid" );
+            pAttrList->AddAttribute( u"draw:fill"_ustr, u"solid"_ustr );
             XFColor color = m_pAreaStyle->GetBackColor();
             if( color.IsValid() )
-                pAttrList->AddAttribute( "draw:fill-color", color.ToString() );
+                pAttrList->AddAttribute( u"draw:fill-color"_ustr, color.ToString() );
         }
         else if( enumXFAreaHatch == m_pAreaStyle->GetAreaStyle() )
         {
-            pAttrList->AddAttribute( "draw:fill", "hatch" );
-            pAttrList->AddAttribute( "draw:fill-hatch-name", m_pAreaStyle->GetStyleName() );
+            pAttrList->AddAttribute( u"draw:fill"_ustr, u"hatch"_ustr );
+            pAttrList->AddAttribute( u"draw:fill-hatch-name"_ustr, m_pAreaStyle->GetStyleName() );
             XFColor color = m_pAreaStyle->GetBackColor();
             if( color.IsValid() )
             {
-                pAttrList->AddAttribute( "draw:fill-hatch-solid", "true" );
-                pAttrList->AddAttribute( "draw:fill-color", color.ToString() );
+                pAttrList->AddAttribute( u"draw:fill-hatch-solid"_ustr, u"true"_ustr );
+                pAttrList->AddAttribute( u"draw:fill-color"_ustr, color.ToString() );
             }
         }
     }
     else
-        pAttrList->AddAttribute( "draw:fill", "none" );
+        pAttrList->AddAttribute( u"draw:fill"_ustr, u"none"_ustr );
 
     if( !m_strArrowStart.isEmpty() )
     {
-        pAttrList->AddAttribute( "draw:marker-start", m_strArrowStart );
-        pAttrList->AddAttribute( "draw:marker-start-width", OUString::number(m_fArrowStartSize)+"cm" );
+        pAttrList->AddAttribute( u"draw:marker-start"_ustr, m_strArrowStart );
+        pAttrList->AddAttribute( u"draw:marker-start-width"_ustr, OUString::number(m_fArrowStartSize)+"cm" );
         if( m_bArrowStartCenter )
-            pAttrList->AddAttribute( "draw:draw:marker-start-center", "true"  );
+            pAttrList->AddAttribute( u"draw:draw:marker-start-center"_ustr, u"true"_ustr  );
     }
     if( !m_strArrowEnd.isEmpty() )
     {
-        pAttrList->AddAttribute( "draw:marker-end", m_strArrowEnd );
-        pAttrList->AddAttribute( "draw:marker-end-width", OUString::number(m_fArrowEndSize)+"cm" );
+        pAttrList->AddAttribute( u"draw:marker-end"_ustr, m_strArrowEnd );
+        pAttrList->AddAttribute( u"draw:marker-end-width"_ustr, OUString::number(m_fArrowEndSize)+"cm" );
         if( m_bArrowEndCenter )
-            pAttrList->AddAttribute( "draw:draw:marker-end-center", "true"  );
+            pAttrList->AddAttribute( u"draw:draw:marker-end-center"_ustr, u"true"_ustr  );
     }
     if (m_pFontWorkStyle)
     {
         // style
-        OUString aStr = "";
+        OUString aStr = u""_ustr;
         switch (m_pFontWorkStyle->GetStyleType())
         {
         default: // fall through!
@@ -267,7 +267,7 @@ void    XFDrawStyle::ToXml(IXFStream *pStrm)
         }
         if (!aStr.isEmpty())
         {
-            pAttrList->AddAttribute("draw:fontwork-style", aStr);
+            pAttrList->AddAttribute(u"draw:fontwork-style"_ustr, aStr);
         }
 
         //adjust
@@ -290,7 +290,7 @@ void    XFDrawStyle::ToXml(IXFStream *pStrm)
         }
         if (!aStr.isEmpty())
         {
-            pAttrList->AddAttribute("draw:fontwork-adjust", aStr);
+            pAttrList->AddAttribute(u"draw:fontwork-adjust"_ustr, aStr);
         }
 
         //form
@@ -309,7 +309,7 @@ void    XFDrawStyle::ToXml(IXFStream *pStrm)
         }
         if (!aStr.isEmpty())
         {
-            pAttrList->AddAttribute("draw:fontwork-form", aStr);
+            pAttrList->AddAttribute(u"draw:fontwork-form"_ustr, aStr);
         }
 
         // distance
@@ -317,11 +317,11 @@ void    XFDrawStyle::ToXml(IXFStream *pStrm)
         //  OUString::number(m_pFontWorkStyle->GetFWDistance())+"cm");
     }
 
-    pStrm->StartElement( "style:properties" );
+    pStrm->StartElement( u"style:properties"_ustr );
 
-    pStrm->EndElement( "style:properties" );
+    pStrm->EndElement( u"style:properties"_ustr );
 
-    pStrm->EndElement( "style:style" );
+    pStrm->EndElement( u"style:style"_ustr );
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/source/filter/xfilter/xfentry.cxx b/lotuswordpro/source/filter/xfilter/xfentry.cxx
index d252cc2bc7cf..38a98223ab6d 100644
--- a/lotuswordpro/source/filter/xfilter/xfentry.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfentry.cxx
@@ -75,33 +75,33 @@ void XFEntry::ToXml(IXFStream* pStrm)
     IXFAttrList* pAttrList = pStrm->GetAttrList();
     pAttrList->Clear();
 
-    pAttrList->AddAttribute("text:string-value", m_strValue);
+    pAttrList->AddAttribute(u"text:string-value"_ustr, m_strValue);
 
     if (m_eType == enumXFEntryTOC)
     {
-        pAttrList->AddAttribute("text:outline-level", OUString::number(m_nOutlineLevel));
-        pStrm->StartElement("text:toc-mark");
+        pAttrList->AddAttribute(u"text:outline-level"_ustr, OUString::number(m_nOutlineLevel));
+        pStrm->StartElement(u"text:toc-mark"_ustr);
         //      pStrm->Characters(m_strDisplay);
-        pStrm->EndElement("text:toc-mark");
+        pStrm->EndElement(u"text:toc-mark"_ustr);
     }
     else if (m_eType == enumXFEntryAlphabetical)
     {
-        pAttrList->AddAttribute("text:key1", m_strKey1);
+        pAttrList->AddAttribute(u"text:key1"_ustr, m_strKey1);
         if (!m_strKey2.isEmpty())
-            pAttrList->AddAttribute("text:key2", m_strKey2);
+            pAttrList->AddAttribute(u"text:key2"_ustr, m_strKey2);
 
-        pStrm->StartElement("text:alphabetical-index-mark");
+        pStrm->StartElement(u"text:alphabetical-index-mark"_ustr);
         //      pStrm->Characters(m_strDisplay);
-        pStrm->EndElement("text:alphabetical-index-mark");
+        pStrm->EndElement(u"text:alphabetical-index-mark"_ustr);
     }
     else if (m_eType == enumXFEntryUserIndex)
     {
-        pAttrList->AddAttribute("text:outline-level", OUString::number(m_nOutlineLevel));
-        pAttrList->AddAttribute("text:index-name", m_strName);
+        pAttrList->AddAttribute(u"text:outline-level"_ustr, OUString::number(m_nOutlineLevel));
+        pAttrList->AddAttribute(u"text:index-name"_ustr, m_strName);
 
-        pStrm->StartElement("text:user-index-mark");
+        pStrm->StartElement(u"text:user-index-mark"_ustr);
         //      pStrm->Characters(m_strDisplay);
-        pStrm->EndElement("text:user-index-mark");
+        pStrm->EndElement(u"text:user-index-mark"_ustr);
     }
 }
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/source/filter/xfilter/xffont.cxx b/lotuswordpro/source/filter/xfilter/xffont.cxx
index 14bb56db6160..4fb042937a3f 100644
--- a/lotuswordpro/source/filter/xfilter/xffont.cxx
+++ b/lotuswordpro/source/filter/xfilter/xffont.cxx
@@ -195,96 +195,96 @@ void XFFont::ToXml(IXFStream *pStrm)
 
     if( m_nFlag & XFFONT_FLAG_NAME )
     {
-        pAttrList->AddAttribute("style:font-name",m_strFontName );
+        pAttrList->AddAttribute(u"style:font-name"_ustr,m_strFontName );
     }
 
     if( m_nFlag & XFFONT_FLAG_NAME_ASIA )
     {
-        pAttrList->AddAttribute("style:font-name-asian",m_strFontNameAsia );
+        pAttrList->AddAttribute(u"style:font-name-asian"_ustr,m_strFontNameAsia );
     }
 
     if( m_nFlag & XFFONT_FLAG_NAME_COMPLEX )
     {
-        pAttrList->AddAttribute("style:font-name-complex", m_strFontNameComplex);
+        pAttrList->AddAttribute(u"style:font-name-complex"_ustr, m_strFontNameComplex);
     }
 
     //font size:
     if( (m_nFlag & XFFONT_FLAG_SIZE) && m_nFontSize != 0 )
     {
         OUString strSize = OUString::number(m_nFontSize) + "pt";
-        pAttrList->AddAttribute("fo:font-size",strSize);
+        pAttrList->AddAttribute(u"fo:font-size"_ustr,strSize);
     }
     if( (m_nFlag & XFFONT_FLAG_SIZE_ASIA) && m_nFontSizeAsia )
     {
         OUString strSize = OUString::number(m_nFontSizeAsia) + "pt";
-        pAttrList->AddAttribute("style:font-size-asian",strSize);
+        pAttrList->AddAttribute(u"style:font-size-asian"_ustr,strSize);
     }
     if( (m_nFlag & XFFONT_FLAG_SIZE_COMPLEX) && m_nFontSizeComplex )
     {
         OUString strSize = OUString::number(m_nFontSizeComplex) + "pt";
-        pAttrList->AddAttribute("style:font-size-complex",strSize);
+        pAttrList->AddAttribute(u"style:font-size-complex"_ustr,strSize);
     }
 
     //italic flag:
     if( ( m_nFlag & XFFONT_FLAG_ITALIC) && m_bItalic )
     {
-        pAttrList->AddAttribute("fo:font-style", "italic");
+        pAttrList->AddAttribute(u"fo:font-style"_ustr, u"italic"_ustr);
     }
     if( (m_nFlag & XFFONT_FLAG_ITALIC_ASIA) && m_bItalicAsia )
     {
-        pAttrList->AddAttribute("style:font-style-asian", "italic");
+        pAttrList->AddAttribute(u"style:font-style-asian"_ustr, u"italic"_ustr);
     }
     if( (m_nFlag & XFFONT_FLAG_ITALIC_COMPLEX) && m_bItalicComplex )
     {
-        pAttrList->AddAttribute("style:font-style-complex", "italic");
+        pAttrList->AddAttribute(u"style:font-style-complex"_ustr, u"italic"_ustr);
     }
 
     //Bold flag:
     if( (m_nFlag & XFFONT_FLAG_BOLD) && m_bBold )
     {
-        pAttrList->AddAttribute("fo:font-weight", "bold");
+        pAttrList->AddAttribute(u"fo:font-weight"_ustr, u"bold"_ustr);
     }
     if( (m_nFlag & XFFONT_FLAG_BOLD_ASIA) && m_bBoldAsia )
     {
-        pAttrList->AddAttribute("style:font-weight-asian", "bold");
+        pAttrList->AddAttribute(u"style:font-weight-asian"_ustr, u"bold"_ustr);
     }
     if( (m_nFlag & XFFONT_FLAG_BOLD_ASIA) && m_bBoldComplex )
     {
-        pAttrList->AddAttribute("style:font-weight-complex", "bold");
+        pAttrList->AddAttribute(u"style:font-weight-complex"_ustr, u"bold"_ustr);
     }
     //underline:
     if( (m_nFlag & XFFONT_FLAG_UNDERLINE) && m_eUnderline )
     {
-        pAttrList->AddAttribute("style:text-underline", GetUnderlineName(m_eUnderline) );
+        pAttrList->AddAttribute(u"style:text-underline"_ustr, GetUnderlineName(m_eUnderline) );
         if( m_nFlag & XFFONT_FLAG_UNDERLINECOLOR )
         {
-            pAttrList->AddAttribute( "style:text-underline-color", m_aUnderlineColor.ToString() );
+            pAttrList->AddAttribute( u"style:text-underline-color"_ustr, m_aUnderlineColor.ToString() );
         }
         else
-            pAttrList->AddAttribute( "style:text-underline-color", "font-color" );
+            pAttrList->AddAttribute( u"style:text-underline-color"_ustr, u"font-color"_ustr );
     }
 
     //enumCrossoutType  m_eCrossout;
     if( (m_nFlag & XFFONT_FLAG_CROSSOUT) && m_eCrossout )
     {
-        pAttrList->AddAttribute("style:text-crossing-out", GetCrossoutName(m_eCrossout) );
+        pAttrList->AddAttribute(u"style:text-crossing-out"_ustr, GetCrossoutName(m_eCrossout) );
     }
 
     if( m_nFlag & XFFONT_FLAG_UNDERLINE || m_nFlag & XFFONT_FLAG_CROSSOUT )
     {
         if( m_bWordByWord )
-            pAttrList->AddAttribute("fo:score-spaces", "false" );
+            pAttrList->AddAttribute(u"fo:score-spaces"_ustr, u"false"_ustr );
         else
-            pAttrList->AddAttribute("fo:score-spaces", "true" );
+            pAttrList->AddAttribute(u"fo:score-spaces"_ustr, u"true"_ustr );
     }
 
     if( (m_nFlag & XFFONT_FLAG_TRANSFORM) && m_eTransform )
     {
         //enumTransformSmallCap is different:
         if( m_eTransform == enumXFTransformSmallCaps )
-            pAttrList->AddAttribute("fo:font-variant", GetTransformName(m_eTransform) );
+            pAttrList->AddAttribute(u"fo:font-variant"_ustr, GetTransformName(m_eTransform) );
         else
-            pAttrList->AddAttribute("fo:text-transform", GetTransformName(m_eTransform) );
+            pAttrList->AddAttribute(u"fo:text-transform"_ustr, GetTransformName(m_eTransform) );
     }
 
     //position & scale:
@@ -294,21 +294,21 @@ void XFFont::ToXml(IXFStream *pStrm)
     {
         OUString tmp = OUString::number(m_nPosition) + "% "
                         + OUString::number(m_nScale) + "%";
-        pAttrList->AddAttribute("style:text-position", tmp );
+        pAttrList->AddAttribute(u"style:text-position"_ustr, tmp );
     }
 
     //Color:
     if( m_nFlag & XFFONT_FLAG_COLOR )
     {
-        pAttrList->AddAttribute( "fo:color", m_aColor.ToString() );
+        pAttrList->AddAttribute( u"fo:color"_ustr, m_aColor.ToString() );
     }
 
     if( m_nFlag & XFFONT_FLAG_BGCOLOR )
     {
         if (m_bTransparent)
-            pAttrList->AddAttribute( "style:text-background-color", "transparent");
+            pAttrList->AddAttribute( u"style:text-background-color"_ustr, u"transparent"_ustr);
         else
-            pAttrList->AddAttribute( "style:text-background-color", m_aBackColor.ToString() );
+            pAttrList->AddAttribute( u"style:text-background-color"_ustr, m_aBackColor.ToString() );
     }
 }
 
diff --git a/lotuswordpro/source/filter/xfilter/xfframe.cxx b/lotuswordpro/source/filter/xfilter/xfframe.cxx
index 62bd2caf26cd..bdf1b475d876 100644
--- a/lotuswordpro/source/filter/xfilter/xfframe.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfframe.cxx
@@ -130,56 +130,56 @@ void    XFFrame::StartFrame(IXFStream *pStrm)
     IXFAttrList *pAttrList = pStrm->GetAttrList();
 
     if( !GetStyleName().isEmpty() )
-        pAttrList->AddAttribute( "draw:style-name", GetStyleName() );
+        pAttrList->AddAttribute( u"draw:style-name"_ustr, GetStyleName() );
 
     assert(!m_strName.isEmpty() && "name should not be null.");
     if( !m_strName.isEmpty() && !m_isTextBox)
-        pAttrList->AddAttribute( "draw:name", m_strName );
+        pAttrList->AddAttribute( u"draw:name"_ustr, m_strName );
     //anchor type:
     switch( m_eAnchor )
     {
     case enumXFAnchorPara:
-        pAttrList->AddAttribute( "text:anchor-type", "paragraph" );
+        pAttrList->AddAttribute( u"text:anchor-type"_ustr, u"paragraph"_ustr );
         break;
     case enumXFAnchorPage:
-        pAttrList->AddAttribute( "text:anchor-type", "page" );
-        pAttrList->AddAttribute( "text:anchor-page-number", OUString::number(m_nAnchorPage) );
+        pAttrList->AddAttribute( u"text:anchor-type"_ustr, u"page"_ustr );
+        pAttrList->AddAttribute( u"text:anchor-page-number"_ustr, OUString::number(m_nAnchorPage) );
         break;
     case enumXFAnchorChar:
-        pAttrList->AddAttribute( "text:anchor-type", "char" );
+        pAttrList->AddAttribute( u"text:anchor-type"_ustr, u"char"_ustr );
         break;
     case enumXFAnchorAsChar:
-        pAttrList->AddAttribute( "text:anchor-type", "as-char" );
+        pAttrList->AddAttribute( u"text:anchor-type"_ustr, u"as-char"_ustr );
         break;
     case enumXFAnchorFrame:
-        pAttrList->AddAttribute( "text:anchor-type", "frame" );
+        pAttrList->AddAttribute( u"text:anchor-type"_ustr, u"frame"_ustr );
         break;
     default:
         break;
     }
-    pAttrList->AddAttribute( "svg:x", OUString::number(m_aRect.GetX()) + "cm" );
-    pAttrList->AddAttribute( "svg:y", OUString::number(m_aRect.GetY()) + "cm" );
-    pAttrList->AddAttribute( "svg:width", OUString::number(m_aRect.GetWidth()) + "cm" );
+    pAttrList->AddAttribute( u"svg:x"_ustr, OUString::number(m_aRect.GetX()) + "cm" );
+    pAttrList->AddAttribute( u"svg:y"_ustr, OUString::number(m_aRect.GetY()) + "cm" );
+    pAttrList->AddAttribute( u"svg:width"_ustr, OUString::number(m_aRect.GetWidth()) + "cm" );
     if( m_nFrameFlag& XFFRAME_FLAG_MINHEIGHT )
     {
-        pAttrList->AddAttribute( "fo:min-height", OUString::number(m_fMinHeight) + "cm" );
+        pAttrList->AddAttribute( u"fo:min-height"_ustr, OUString::number(m_fMinHeight) + "cm" );
         if( m_nFrameFlag&XFFRAME_FLAG_MAXHEIGHT )
-            pAttrList->AddAttribute( "fo:max-height", OUString::number(0) + "cm" );
+            pAttrList->AddAttribute( u"fo:max-height"_ustr, OUString::number(0) + "cm" );
     }
     else
-        pAttrList->AddAttribute( "svg:height", OUString::number(m_aRect.GetHeight()) + "cm" );
+        pAttrList->AddAttribute( u"svg:height"_ustr, OUString::number(m_aRect.GetHeight()) + "cm" );
 
-    pAttrList->AddAttribute( "draw:z-index", OUString::number(m_nZIndex) );
+    pAttrList->AddAttribute( u"draw:z-index"_ustr, OUString::number(m_nZIndex) );
 
     if( !m_strNextLink.isEmpty() )
-        pAttrList->AddAttribute( "draw:chain-next-name", m_strNextLink );
+        pAttrList->AddAttribute( u"draw:chain-next-name"_ustr, m_strNextLink );
 
-    pStrm->StartElement( "draw:text-box" );
+    pStrm->StartElement( u"draw:text-box"_ustr );
 }
 
 void    XFFrame::EndFrame(IXFStream *pStrm)
 {
-    pStrm->EndElement( "draw:text-box" );
+    pStrm->EndElement( u"draw:text-box"_ustr );
 }
 
 void    XFFrame::AdjustZIndex()
diff --git a/lotuswordpro/source/filter/xfilter/xfframestyle.cxx b/lotuswordpro/source/filter/xfilter/xfframestyle.cxx
index e3c5b315cc45..429258d694a1 100644
--- a/lotuswordpro/source/filter/xfilter/xfframestyle.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfframestyle.cxx
@@ -111,37 +111,37 @@ void    XFFrameStyle::ToXml(IXFStream *pStrm)
     IXFAttrList *pAttrList = pStrm->GetAttrList();
 
     pAttrList->Clear();
-    pAttrList->AddAttribute( "style:name", GetStyleName() );
+    pAttrList->AddAttribute( u"style:name"_ustr, GetStyleName() );
     if( GetParentStyleName().getLength() > 0 )
-        pAttrList->AddAttribute("style:parent-style-name",GetParentStyleName());
-    pAttrList->AddAttribute( "style:family", "graphics" );
+        pAttrList->AddAttribute(u"style:parent-style-name"_ustr,GetParentStyleName());
+    pAttrList->AddAttribute( u"style:family"_ustr, u"graphics"_ustr );
     //parent style name ignore now.
-    pStrm->StartElement( "style:style" );
+    pStrm->StartElement( u"style:style"_ustr );
 
     m_aMargins.ToXml(pStrm);
 
     pAttrList->Clear();
 
-    pAttrList->AddAttribute( "style:run-through", "foreground" );
+    pAttrList->AddAttribute( u"style:run-through"_ustr, u"foreground"_ustr );
 
     if( m_eWrap == enumXFWrapNone )
-        pAttrList->AddAttribute( "style:wrap", "none" );
+        pAttrList->AddAttribute( u"style:wrap"_ustr, u"none"_ustr );
     else if( m_eWrap == enumXFWrapLeft )
-        pAttrList->AddAttribute( "style:wrap", "left" );
+        pAttrList->AddAttribute( u"style:wrap"_ustr, u"left"_ustr );
     else if( m_eWrap == enumXFWrapRight )
-        pAttrList->AddAttribute( "style:wrap", "right" );
+        pAttrList->AddAttribute( u"style:wrap"_ustr, u"right"_ustr );
     else if( m_eWrap == enumXFWrapParallel )
-        pAttrList->AddAttribute( "style:wrap", "parallel" );
+        pAttrList->AddAttribute( u"style:wrap"_ustr, u"parallel"_ustr );
     else if( m_eWrap == enumXFWrapRunThrough )
-        pAttrList->AddAttribute( "style:wrap", "run-through" );
+        pAttrList->AddAttribute( u"style:wrap"_ustr, u"run-through"_ustr );
     else if( m_eWrap == enumXFWrapBest )
-        pAttrList->AddAttribute( "style:wrap", "dynamic" );
+        pAttrList->AddAttribute( u"style:wrap"_ustr, u"dynamic"_ustr );
     //}
     //background
     if( m_aBackColor.IsValid() )
     {
-        pAttrList->AddAttribute( "fo:background-color", m_aBackColor.ToString() );
-        pAttrList->AddAttribute( "style:background-transparency", OUString::number(static_cast<sal_Int32>(m_nTransparency)) + "%");
+        pAttrList->AddAttribute( u"fo:background-color"_ustr, m_aBackColor.ToString() );
+        pAttrList->AddAttribute( u"style:background-transparency"_ustr, OUString::number(static_cast<sal_Int32>(m_nTransparency)) + "%");
     }
 
     //pad
@@ -152,15 +152,15 @@ void    XFFrameStyle::ToXml(IXFStream *pStrm)
     if( m_pBorders )
         m_pBorders->ToXml(pStrm);
     else
-        pAttrList->AddAttribute( "fo:border", "none" );
+        pAttrList->AddAttribute( u"fo:border"_ustr, u"none"_ustr );
     //shadow
     if( m_pShadow )
         m_pShadow->ToXml(pStrm);
     //print
-    pAttrList->AddAttribute( "style:print-content", "true" );
+    pAttrList->AddAttribute( u"style:print-content"_ustr, u"true"_ustr );
     //text directory
     if( m_eTextDir != enumXFTextDirNone )
-        pAttrList->AddAttribute( "style:writing-mode", GetTextDirName(m_eTextDir) );
+        pAttrList->AddAttribute( u"style:writing-mode"_ustr, GetTextDirName(m_eTextDir) );
     //protect:
     if( m_bProtectContent || m_bProtectSize || m_bProtectPos )
     {
@@ -179,21 +179,21 @@ void    XFFrameStyle::ToXml(IXFStream *pStrm)
                 protect += " ";
             protect += "position";
         }
-        pAttrList->AddAttribute( "style:protect", protect );
+        pAttrList->AddAttribute( u"style:protect"_ustr, protect );
     }
     //vertical pos and horizon pos:
-    pAttrList->AddAttribute( "style:vertical-pos", GetFrameYPos(m_eYPos) );
-    pAttrList->AddAttribute( "style:vertical-rel", GetFrameYRel(m_eYRel) );
-    pAttrList->AddAttribute( "style:horizontal-pos", GetFrameXPos(m_eXPos) );
-    pAttrList->AddAttribute( "style:horizontal-rel", GetFrameXRel(m_eXRel) );
+    pAttrList->AddAttribute( u"style:vertical-pos"_ustr, GetFrameYPos(m_eYPos) );
+    pAttrList->AddAttribute( u"style:vertical-rel"_ustr, GetFrameYRel(m_eYRel) );
+    pAttrList->AddAttribute( u"style:horizontal-pos"_ustr, GetFrameXPos(m_eXPos) );
+    pAttrList->AddAttribute( u"style:horizontal-rel"_ustr, GetFrameXRel(m_eXRel) );
 
-    pStrm->StartElement( "style:properties" );
+    pStrm->StartElement( u"style:properties"_ustr );
     if( m_pColumns )
         m_pColumns->ToXml(pStrm);
     if( m_pBGImage )
         m_pBGImage->ToXml(pStrm);
-    pStrm->EndElement( "style:properties" );
+    pStrm->EndElement( u"style:properties"_ustr );
 
-    pStrm->EndElement( "style:style" );
+    pStrm->EndElement( u"style:style"_ustr );
 }
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/source/filter/xfilter/xfheaderstyle.cxx b/lotuswordpro/source/filter/xfilter/xfheaderstyle.cxx
index eb061b6d55af..68882274171a 100644
--- a/lotuswordpro/source/filter/xfilter/xfheaderstyle.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfheaderstyle.cxx
@@ -124,15 +124,15 @@ void    XFHeaderStyle::ToXml(IXFStream *pStrm)
     pAttrList->Clear();
 
     if( m_bIsFooter )
-        pStrm->StartElement( "style:footer-style" );
+        pStrm->StartElement( u"style:footer-style"_ustr );
     else
-        pStrm->StartElement( "style:header-style" );
+        pStrm->StartElement( u"style:header-style"_ustr );
 
     //height
     if( m_fMinHeight>0 )
-        pAttrList->AddAttribute( "fo:min-height", OUString::number(m_fMinHeight) + "cm" );
+        pAttrList->AddAttribute( u"fo:min-height"_ustr, OUString::number(m_fMinHeight) + "cm" );
     else if( m_fHeight>0 )
-        pAttrList->AddAttribute( "svg:height", OUString::number(m_fHeight) + "cm" );
+        pAttrList->AddAttribute( u"svg:height"_ustr, OUString::number(m_fHeight) + "cm" );
 
     m_aMargin.ToXml(pStrm);
     if(m_pShadow)
@@ -142,25 +142,25 @@ void    XFHeaderStyle::ToXml(IXFStream *pStrm)
         m_pBorders->ToXml(pStrm);
 
     if( m_aBackColor.IsValid() )
-        pAttrList->AddAttribute( "fo:background-color", m_aBackColor.ToString() );
+        pAttrList->AddAttribute( u"fo:background-color"_ustr, m_aBackColor.ToString() );
 
     if( m_bDynamicSpace )
-        pAttrList->AddAttribute( "style:dynamic-spacing", "true" );
+        pAttrList->AddAttribute( u"style:dynamic-spacing"_ustr, u"true"_ustr );
     else
-        pAttrList->AddAttribute( "style:dynamic-spacing", "false" );
+        pAttrList->AddAttribute( u"style:dynamic-spacing"_ustr, u"false"_ustr );
 
-    pStrm->StartElement( "style:properties" );
+    pStrm->StartElement( u"style:properties"_ustr );
 
     // background image
     if( m_pBGImage )
         m_pBGImage->ToXml(pStrm);
 
-    pStrm->EndElement( "style:properties" );
+    pStrm->EndElement( u"style:properties"_ustr );
 
     if( m_bIsFooter )
-        pStrm->EndElement( "style:footer-style" );
+        pStrm->EndElement( u"style:footer-style"_ustr );
     else
-        pStrm->EndElement( "style:header-style" );
+        pStrm->EndElement( u"style:header-style"_ustr );
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/source/filter/xfilter/xfimage.cxx b/lotuswordpro/source/filter/xfilter/xfimage.cxx
index 33f483c7c5f5..42b6b9ca874b 100644
--- a/lotuswordpro/source/filter/xfilter/xfimage.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfimage.cxx
@@ -93,55 +93,55 @@ void    XFImage::ToXml(IXFStream *pStrm)
     IXFAttrList *pAttrList = pStrm->GetAttrList();
 
     if( !GetStyleName().isEmpty() )
-        pAttrList->AddAttribute( "draw:style-name", GetStyleName() );
+        pAttrList->AddAttribute( u"draw:style-name"_ustr, GetStyleName() );
 
     assert(!m_strName.isEmpty() && "name should not be null.");
     if( !m_strName.isEmpty() )
-        pAttrList->AddAttribute( "draw:name", m_strName );
+        pAttrList->AddAttribute( u"draw:name"_ustr, m_strName );
     //anchor type:
     switch( m_eAnchor )
     {
     case enumXFAnchorPara:
-        pAttrList->AddAttribute( "text:anchor-type", "paragraph" );
+        pAttrList->AddAttribute( u"text:anchor-type"_ustr, u"paragraph"_ustr );
         break;
     case enumXFAnchorPage:
-        pAttrList->AddAttribute( "text:anchor-type", "page" );
-        pAttrList->AddAttribute( "text:anchor-page-number", OUString::number(m_nAnchorPage) );
+        pAttrList->AddAttribute( u"text:anchor-type"_ustr, u"page"_ustr );
+        pAttrList->AddAttribute( u"text:anchor-page-number"_ustr, OUString::number(m_nAnchorPage) );
         break;
     case enumXFAnchorChar:
-        pAttrList->AddAttribute( "text:anchor-type", "char" );
+        pAttrList->AddAttribute( u"text:anchor-type"_ustr, u"char"_ustr );
         break;
     case enumXFAnchorAsChar:
-        pAttrList->AddAttribute( "text:anchor-type", "as-char" );
+        pAttrList->AddAttribute( u"text:anchor-type"_ustr, u"as-char"_ustr );
         break;
     case enumXFAnchorFrame:
-        pAttrList->AddAttribute( "text:anchor-type", "frame" );
+        pAttrList->AddAttribute( u"text:anchor-type"_ustr, u"frame"_ustr );
         break;
     default:
         break;
     }
-    pAttrList->AddAttribute( "svg:x", OUString::number(m_aRect.GetX()) + "cm" );
-    pAttrList->AddAttribute( "svg:y", OUString::number(m_aRect.GetY()) + "cm" );
-    pAttrList->AddAttribute( "svg:width", OUString::number(m_aRect.GetWidth()) + "cm" );
-    pAttrList->AddAttribute( "svg:height", OUString::number(m_aRect.GetHeight()) + "cm" );
-    pAttrList->AddAttribute( "draw:z-index", OUString::number(m_nZIndex) );
+    pAttrList->AddAttribute( u"svg:x"_ustr, OUString::number(m_aRect.GetX()) + "cm" );
+    pAttrList->AddAttribute( u"svg:y"_ustr, OUString::number(m_aRect.GetY()) + "cm" );
+    pAttrList->AddAttribute( u"svg:width"_ustr, OUString::number(m_aRect.GetWidth()) + "cm" );
+    pAttrList->AddAttribute( u"svg:height"_ustr, OUString::number(m_aRect.GetHeight()) + "cm" );
+    pAttrList->AddAttribute( u"draw:z-index"_ustr, OUString::number(m_nZIndex) );
 
     if( m_bUseLink )
     {
-        pAttrList->AddAttribute( "xlink:href", m_strImageFile );
-        pAttrList->AddAttribute( "xlink:type", "simple" );
-        pAttrList->AddAttribute( "xlink:show", "embed" );
-        pAttrList->AddAttribute( "xlink:actuate", "onLoad" );
+        pAttrList->AddAttribute( u"xlink:href"_ustr, m_strImageFile );
+        pAttrList->AddAttribute( u"xlink:type"_ustr, u"simple"_ustr );
+        pAttrList->AddAttribute( u"xlink:show"_ustr, u"embed"_ustr );
+        pAttrList->AddAttribute( u"xlink:actuate"_ustr, u"onLoad"_ustr );
     }
 
-    pStrm->StartElement( "draw:image" );
+    pStrm->StartElement( u"draw:image"_ustr );
     if( !m_bUseLink )
     {
         pAttrList->Clear();
-        pStrm->StartElement( "office:binary-data" );
+        pStrm->StartElement( u"office:binary-data"_ustr );
         pStrm->Characters(m_strData);
-        pStrm->EndElement( "office:binary-data" );
+        pStrm->EndElement( u"office:binary-data"_ustr );
     }
-    pStrm->EndElement( "draw:image" );
+    pStrm->EndElement( u"draw:image"_ustr );
 }
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/source/filter/xfilter/xfimagestyle.cxx b/lotuswordpro/source/filter/xfilter/xfimagestyle.cxx
index 0694fdc26770..0d0791a664f2 100644
--- a/lotuswordpro/source/filter/xfilter/xfimagestyle.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfimagestyle.cxx
@@ -77,12 +77,12 @@ void XFImageStyle::ToXml(IXFStream *pStrm)
     IXFAttrList *pAttrList = pStrm->GetAttrList();
 
     pAttrList->Clear();
-    pAttrList->AddAttribute( "style:name", GetStyleName() );
+    pAttrList->AddAttribute( u"style:name"_ustr, GetStyleName() );
     if( !GetParentStyleName().isEmpty() )
-        pAttrList->AddAttribute("style:parent-style-name",GetParentStyleName());
-    pAttrList->AddAttribute( "style:family", "graphics" );
+        pAttrList->AddAttribute(u"style:parent-style-name"_ustr,GetParentStyleName());
+    pAttrList->AddAttribute( u"style:family"_ustr, u"graphics"_ustr );
     //parent style name ignore now.
-    pStrm->StartElement( "style:style" );
+    pStrm->StartElement( u"style:style"_ustr );
 
     m_aMargins.ToXml(pStrm);
 
@@ -90,39 +90,39 @@ void XFImageStyle::ToXml(IXFStream *pStrm)
 
     if( m_eWrap == enumXFWrapBackground )
     {
-        pAttrList->AddAttribute( "style:run-through", "background" );
+        pAttrList->AddAttribute( u"style:run-through"_ustr, u"background"_ustr );
     }
     else
     {
-        pAttrList->AddAttribute( "style:run-through", "foreground" );
+        pAttrList->AddAttribute( u"style:run-through"_ustr, u"foreground"_ustr );
 
         if( m_eWrap == enumXFWrapNone )
-            pAttrList->AddAttribute( "style:wrap", "none" );
+            pAttrList->AddAttribute( u"style:wrap"_ustr, u"none"_ustr );
         else if( m_eWrap == enumXFWrapLeft )
-            pAttrList->AddAttribute( "style:wrap", "left" );
+            pAttrList->AddAttribute( u"style:wrap"_ustr, u"left"_ustr );
         else if( m_eWrap == enumXFWrapRight )
-            pAttrList->AddAttribute( "style:wrap", "right" );
+            pAttrList->AddAttribute( u"style:wrap"_ustr, u"right"_ustr );
         else if( m_eWrap == enumXFWrapParallel )
-            pAttrList->AddAttribute( "style:wrap", "parallel" );
+            pAttrList->AddAttribute( u"style:wrap"_ustr, u"parallel"_ustr );
         else if( m_eWrap == enumXFWrapRunThrough )
-            pAttrList->AddAttribute( "style:wrap", "run-through" );
+            pAttrList->AddAttribute( u"style:wrap"_ustr, u"run-through"_ustr );
         else if( m_eWrap == enumXFWrapBest )
-            pAttrList->AddAttribute( "style:wrap", "dynamic" );
+            pAttrList->AddAttribute( u"style:wrap"_ustr, u"dynamic"_ustr );
     }
     //background
     if( m_aBackColor.IsValid() )
-        pAttrList->AddAttribute( "fo:background-color", m_aBackColor.ToString() );
+        pAttrList->AddAttribute( u"fo:background-color"_ustr, m_aBackColor.ToString() );
     //pad
     m_aPad.ToXml(pStrm);
     //margin:
     m_aMargins.ToXml(pStrm);
 
     if( m_nBrightness )
-        pAttrList->AddAttribute( "draw:luminance", OUString::number(m_nBrightness) + "%" );
+        pAttrList->AddAttribute( u"draw:luminance"_ustr, OUString::number(m_nBrightness) + "%" );
     if( m_nContrast )
-        pAttrList->AddAttribute( "draw:contrast", OUString::number(m_nContrast) + "%" );
+        pAttrList->AddAttribute( u"draw:contrast"_ustr, OUString::number(m_nContrast) + "%" );
 
-    pAttrList->AddAttribute("draw:color-mode", GetColorMode(enumXFColorStandard));
+    pAttrList->AddAttribute(u"draw:color-mode"_ustr, GetColorMode(enumXFColorStandard));
     //border
     if( m_pBorders )
         m_pBorders->ToXml(pStrm);
@@ -130,7 +130,7 @@ void XFImageStyle::ToXml(IXFStream *pStrm)
     if( m_pShadow )
         m_pShadow->ToXml(pStrm);
 
-    pAttrList->AddAttribute( "style:print-content", "true" );
+    pAttrList->AddAttribute( u"style:print-content"_ustr, u"true"_ustr );
     //protect:
     if( m_bProtectContent || m_bProtectSize || m_bProtectPos )
     {
@@ -149,13 +149,13 @@ void XFImageStyle::ToXml(IXFStream *pStrm)
                 protect += " ";
             protect += "position";
         }
-        pAttrList->AddAttribute( "style:protect", protect );
+        pAttrList->AddAttribute( u"style:protect"_ustr, protect );
     }
     //vertical pos and horizon pos:
-    pAttrList->AddAttribute( "style:vertical-pos", GetFrameYPos(m_eYPos) );
-    pAttrList->AddAttribute( "style:vertical-rel", GetFrameYRel(m_eYRel) );
-    pAttrList->AddAttribute( "style:horizontal-pos", GetFrameXPos(m_eXPos) );
-    pAttrList->AddAttribute( "style:horizontal-rel", GetFrameXRel(m_eXRel) );
+    pAttrList->AddAttribute( u"style:vertical-pos"_ustr, GetFrameYPos(m_eYPos) );
+    pAttrList->AddAttribute( u"style:vertical-rel"_ustr, GetFrameYRel(m_eYRel) );
+    pAttrList->AddAttribute( u"style:horizontal-pos"_ustr, GetFrameXPos(m_eXPos) );
+    pAttrList->AddAttribute( u"style:horizontal-rel"_ustr, GetFrameXRel(m_eXRel) );
 
     //clip:
     if( FABS(m_fClipLeft)>FLOAT_MIN || FABS(m_fClipRight)>FLOAT_MIN || FABS(m_fClipTop)>FLOAT_MIN || FABS(m_fClipBottom)>FLOAT_MIN )
@@ -164,13 +164,13 @@ void XFImageStyle::ToXml(IXFStream *pStrm)
             OUString::number(m_fClipRight) + "cm " +
             OUString::number(m_fClipBottom) + "cm " +
             OUString::number(m_fClipLeft) + "cm)";
-        pAttrList->AddAttribute("fo:clip",clip);
+        pAttrList->AddAttribute(u"fo:clip"_ustr,clip);
     }
 
-    pStrm->StartElement( "style:properties" );
-    pStrm->EndElement( "style:properties" );
+    pStrm->StartElement( u"style:properties"_ustr );
+    pStrm->EndElement( u"style:properties"_ustr );
 
-    pStrm->EndElement( "style:style" );
+    pStrm->EndElement( u"style:style"_ustr );
 
 }
 
diff --git a/lotuswordpro/source/filter/xfilter/xfindex.cxx b/lotuswordpro/source/filter/xfilter/xfindex.cxx
index 902e1e970612..a341d4eca4ab 100644
--- a/lotuswordpro/source/filter/xfilter/xfindex.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfindex.cxx
@@ -146,13 +146,13 @@ void    XFIndex::ToXml(IXFStream *pStrm)
     }
 
     if( !GetStyleName().isEmpty() )
-        pAttrList->AddAttribute( "text:style-name", GetStyleName() );
+        pAttrList->AddAttribute( u"text:style-name"_ustr, GetStyleName() );
     if( m_bProtect )
-        pAttrList->AddAttribute( "text:protected", "true" );
+        pAttrList->AddAttribute( u"text:protected"_ustr, u"true"_ustr );
     else
-        pAttrList->AddAttribute( "text:protected", "false" );
+        pAttrList->AddAttribute( u"text:protected"_ustr, u"false"_ustr );
 
-    pAttrList->AddAttribute( "text:name", m_strTitle );
+    pAttrList->AddAttribute( u"text:name"_ustr, m_strTitle );
     pStrm->StartElement( strIndexName );
 
     //text:table-of-content-source:
@@ -160,21 +160,21 @@ void    XFIndex::ToXml(IXFStream *pStrm)
 
     if(m_eType == enumXFIndexTOC )
     {
-        pAttrList->AddAttribute( "text:outline-level", OUString::number(10));
-        pAttrList->AddAttribute( "text:use-index-source-styles", "true");
-        pAttrList->AddAttribute( "text:use-index-marks", "true");
-        pAttrList->AddAttribute( "text:use-outline-level", "false");
+        pAttrList->AddAttribute( u"text:outline-level"_ustr, OUString::number(10));
+        pAttrList->AddAttribute( u"text:use-index-source-styles"_ustr, u"true"_ustr);
+        pAttrList->AddAttribute( u"text:use-index-marks"_ustr, u"true"_ustr);
+        pAttrList->AddAttribute( u"text:use-outline-level"_ustr, u"false"_ustr);
     }
     if (m_bSeparator)
-        pAttrList->AddAttribute( "text:alphabetical-separators", "true" );
+        pAttrList->AddAttribute( u"text:alphabetical-separators"_ustr, u"true"_ustr );
 
     pStrm->StartElement( strSourceName );
     //title template:
     pAttrList->Clear();
 
-    pStrm->StartElement( "text:index-title-template" );
+    pStrm->StartElement( u"text:index-title-template"_ustr );
     pStrm->Characters( m_strTitle );
-    pStrm->EndElement( "text:index-title-template" );
+    pStrm->EndElement( u"text:index-title-template"_ustr );
 
     //entry templates:
     for (auto const& elem : m_aTemplates)
@@ -195,17 +195,17 @@ void    XFIndex::ToXml(IXFStream *pStrm)
             }
 
             pAttrList->Clear();
-            pAttrList->AddAttribute( "text:outline-level", OUString::number(i));
-            pStrm->StartElement( "text:index-source-styles" );
+            pAttrList->AddAttribute( u"text:outline-level"_ustr, OUString::number(i));
+            pStrm->StartElement( u"text:index-source-styles"_ustr );
 
             for (auto const& elemTOCSource : m_aTOCSource[i])
             {
                 pAttrList->Clear();
-                pAttrList->AddAttribute( "text:style-name", elemTOCSource);
-                pStrm->StartElement( "text:index-source-style" );
-                pStrm->EndElement( "text:index-source-style" );
+                pAttrList->AddAttribute( u"text:style-name"_ustr, elemTOCSource);
+                pStrm->StartElement( u"text:index-source-style"_ustr );
+                pStrm->EndElement( u"text:index-source-style"_ustr );
             }
-            pStrm->EndElement( "text:index-source-styles" );
+            pStrm->EndElement( u"text:index-source-styles"_ustr );
         }
     }
 
@@ -213,17 +213,17 @@ void    XFIndex::ToXml(IXFStream *pStrm)
 
     //index-body:
     pAttrList->Clear();
-    pStrm->StartElement( "text:index-body" );
+    pStrm->StartElement( u"text:index-body"_ustr );
     //index-title:
     if(!m_strTitle.isEmpty())
     {
-        pAttrList->AddAttribute( "text:name", m_strTitle + "_Head" );
-        pStrm->StartElement( "text:index-title" );
-        pStrm->EndElement( "text:index-title" );
+        pAttrList->AddAttribute( u"text:name"_ustr, m_strTitle + "_Head" );
+        pStrm->StartElement( u"text:index-title"_ustr );
+        pStrm->EndElement( u"text:index-title"_ustr );
     }
 
     XFContentContainer::ToXml(pStrm);
-    pStrm->EndElement( "text:index-body" );
+    pStrm->EndElement( u"text:index-body"_ustr );
 
     pStrm->EndElement( strIndexName );
 }
@@ -233,8 +233,8 @@ void XFIndexTemplate::ToXml(IXFStream *pStrm)
     IXFAttrList *pAttrList = pStrm->GetAttrList();
     pAttrList->Clear();
 
-    pAttrList->AddAttribute( "text:outline-level", m_nLevel );
-    pAttrList->AddAttribute( "text:style-name", m_strStyle );
+    pAttrList->AddAttribute( u"text:outline-level"_ustr, m_nLevel );
+    pAttrList->AddAttribute( u"text:style-name"_ustr, m_strStyle );
     if( m_strTagName.isEmpty() )
         m_strTagName = "text:table-of-content-entry-template";
     pStrm->StartElement( m_strTagName );
@@ -247,77 +247,77 @@ void XFIndexTemplate::ToXml(IXFStream *pStrm)
         {
         case enumXFIndexTemplateChapter:
             if(!m_aEntries[i].second.isEmpty())
-                pAttrList->AddAttribute( "text:style-name", m_aEntries[i].second );
+                pAttrList->AddAttribute( u"text:style-name"_ustr, m_aEntries[i].second );
 
-            pStrm->StartElement( "text:index-entry-chapter-number" );
-            pStrm->EndElement( "text:index-entry-chapter-number" );
+            pStrm->StartElement( u"text:index-entry-chapter-number"_ustr );
+            pStrm->EndElement( u"text:index-entry-chapter-number"_ustr );
             break;
         case enumXFIndexTemplateText:
             if(!m_aEntries[i].second.isEmpty())
-                pAttrList->AddAttribute( "text:style-name", m_aEntries[i].second );
+                pAttrList->AddAttribute( u"text:style-name"_ustr, m_aEntries[i].second );
 
-            pStrm->StartElement( "text:index-entry-text" );
-            pStrm->EndElement( "text:index-entry-text" );
+            pStrm->StartElement( u"text:index-entry-text"_ustr );
+            pStrm->EndElement( u"text:index-entry-text"_ustr );
             break;
         case enumXFIndexTemplateTab:
             if( m_eTabType != enumXFTabRight )
-                pAttrList->AddAttribute( "style:position", OUString::number(m_fTabLength) + "cm" );
+                pAttrList->AddAttribute( u"style:position"_ustr, OUString::number(m_fTabLength) + "cm" );
 
             if(!m_aEntries[i].second.isEmpty())
-                pAttrList->AddAttribute( "text:style-name", m_aEntries[i].second );
+                pAttrList->AddAttribute( u"text:style-name"_ustr, m_aEntries[i].second );
 
             switch(m_eTabType)
             {
             case enumXFTabLeft:
-                pAttrList->AddAttribute( "style:type", "left" );
+                pAttrList->AddAttribute( u"style:type"_ustr, u"left"_ustr );
                 break;
             case enumXFTabCenter:
-                pAttrList->AddAttribute( "style:type", "center" );
+                pAttrList->AddAttribute( u"style:type"_ustr, u"center"_ustr );
                 break;
             case enumXFTabRight:
-                pAttrList->AddAttribute( "style:type", "right" );
+                pAttrList->AddAttribute( u"style:type"_ustr, u"right"_ustr );
                 break;
             case enumXFTabChar:
-                pAttrList->AddAttribute( "style:type", "char" );
+                pAttrList->AddAttribute( u"style:type"_ustr, u"char"_ustr );
                 break;
             default:
                 break;
             }
             //delimiter:
             if( m_eTabType == enumXFTabChar )
-                pAttrList->AddAttribute( "style:char", m_strTabDelimiter );
+                pAttrList->AddAttribute( u"style:char"_ustr, m_strTabDelimiter );
             //leader char:
             if( !m_strTabLeader.isEmpty() )
-                pAttrList->AddAttribute( "style:leader-char", m_strTabLeader );
+                pAttrList->AddAttribute( u"style:leader-char"_ustr, m_strTabLeader );
 
-            pStrm->StartElement( "text:index-entry-tab-stop" );
-            pStrm->EndElement( "text:index-entry-tab-stop" );
+            pStrm->StartElement( u"text:index-entry-tab-stop"_ustr );
+            pStrm->EndElement( u"text:index-entry-tab-stop"_ustr );
             break;
         case enumXFIndexTemplatePage:
             if(!m_aEntries[i].second.isEmpty())
-                pAttrList->AddAttribute( "text:style-name", m_aEntries[i].second );
+                pAttrList->AddAttribute( u"text:style-name"_ustr, m_aEntries[i].second );
 
-            pStrm->StartElement( "text:index-entry-page-number" );
-            pStrm->EndElement( "text:index-entry-page-number" );
+            pStrm->StartElement( u"text:index-entry-page-number"_ustr );
+            pStrm->EndElement( u"text:index-entry-page-number"_ustr );
             break;
         case enumXFIndexTemplateLinkStart:
-            pStrm->StartElement( "text:index-entry-link-start" );
-            pStrm->EndElement( "text:index-entry-link-start" );
+            pStrm->StartElement( u"text:index-entry-link-start"_ustr );
+            pStrm->EndElement( u"text:index-entry-link-start"_ustr );
             break;
         case enumXFIndexTemplateLinkEnd:
-            pStrm->StartElement( "text:index-entry-link-end" );
-            pStrm->EndElement( "text:index-entry-link-end" );
+            pStrm->StartElement( u"text:index-entry-link-end"_ustr );
+            pStrm->EndElement( u"text:index-entry-link-end"_ustr );
             break;
         case enumXFIndexTemplateSpan:
             pAttrList->Clear();
-            pAttrList->AddAttribute("text:style-name", GetStyleName());
-            pStrm->StartElement( "text:index-entry-span" );
+            pAttrList->AddAttribute(u"text:style-name"_ustr, GetStyleName());
+            pStrm->StartElement( u"text:index-entry-span"_ustr );
             pStrm->Characters(m_aTextEntries[i]);
-            pStrm->EndElement( "text:index-entry-span" );
+            pStrm->EndElement( u"text:index-entry-span"_ustr );
             break;
         case enumXFIndexTemplateBibliography:
-            pStrm->StartElement( "text:index-entry-bibliography" );
-            pStrm->EndElement( "text:index-entry-bibliography" );
+            pStrm->StartElement( u"text:index-entry-bibliography"_ustr );
+            pStrm->EndElement( u"text:index-entry-bibliography"_ustr );
             break;
         default:
             break;
diff --git a/lotuswordpro/source/filter/xfilter/xflist.cxx b/lotuswordpro/source/filter/xfilter/xflist.cxx
index ae61aef6c961..b95220e3001b 100644
--- a/lotuswordpro/source/filter/xfilter/xflist.cxx
+++ b/lotuswordpro/source/filter/xfilter/xflist.cxx
@@ -76,21 +76,21 @@ void XFList::ToXml(IXFStream* pStrm)
 
     pAttrList->Clear();
     if (!GetStyleName().isEmpty())
-        pAttrList->AddAttribute("text:style-name", GetStyleName());
+        pAttrList->AddAttribute(u"text:style-name"_ustr, GetStyleName());
     if (m_bContinueNumber)
-        pAttrList->AddAttribute("text:continue-numbering", "true");
+        pAttrList->AddAttribute(u"text:continue-numbering"_ustr, u"true"_ustr);
 
     if (m_bOrdered)
-        pStrm->StartElement("text:ordered-list");
+        pStrm->StartElement(u"text:ordered-list"_ustr);
     else
-        pStrm->StartElement("text:unordered-list");
+        pStrm->StartElement(u"text:unordered-list"_ustr);
 
     XFContentContainer::ToXml(pStrm);
 
     if (m_bOrdered)
-        pStrm->EndElement("text:ordered-list");
+        pStrm->EndElement(u"text:ordered-list"_ustr);
     else
-        pStrm->EndElement("text:unordered-list");
+        pStrm->EndElement(u"text:unordered-list"_ustr);
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/source/filter/xfilter/xfliststyle.cxx b/lotuswordpro/source/filter/xfilter/xfliststyle.cxx
index 4f4f32ea7f72..6af8291742ba 100644
--- a/lotuswordpro/source/filter/xfilter/xfliststyle.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfliststyle.cxx
@@ -80,34 +80,34 @@ void XFListlevelNumber::ToXml(IXFStream *pStrm)
     IXFAttrList *pAttrList = pStrm->GetAttrList();
 
     pAttrList->Clear();
-    pAttrList->AddAttribute( "text:level", OUString::number(static_cast<sal_Int32>(m_nLevel)) );
+    pAttrList->AddAttribute( u"text:level"_ustr, OUString::number(static_cast<sal_Int32>(m_nLevel)) );
     //text:style-name,ignore now.
     m_aNumFmt.ToXml(pStrm);
     if( m_nDisplayLevel )
-        pAttrList->AddAttribute( "text:display-levels", OUString::number(static_cast<sal_Int32>(m_nDisplayLevel)) );
+        pAttrList->AddAttribute( u"text:display-levels"_ustr, OUString::number(static_cast<sal_Int32>(m_nDisplayLevel)) );
 
-    pStrm->StartElement( "text:list-level-style-number" );
+    pStrm->StartElement( u"text:list-level-style-number"_ustr );
 
     //<style:properties>...</style:properties>
     pAttrList->Clear();
     if( m_fIndent > FLOAT_MIN )
     {
-        pAttrList->AddAttribute( "text:space-before", OUString::number(m_fIndent) + "cm" );
+        pAttrList->AddAttribute( u"text:space-before"_ustr, OUString::number(m_fIndent) + "cm" );
     }
     if( m_fMinLabelWidth > FLOAT_MIN )
     {
-        pAttrList->AddAttribute( "text:min-label-width", OUString::number(m_fMinLabelWidth) + "cm" );
+        pAttrList->AddAttribute( u"text:min-label-width"_ustr, OUString::number(m_fMinLabelWidth) + "cm" );
     }
     if( m_fMinLabelDistance > FLOAT_MIN )
     {
-        pAttrList->AddAttribute( "text:min-label-distance", OUString::number(m_fMinLabelDistance) + "cm" );
+        pAttrList->AddAttribute( u"text:min-label-distance"_ustr, OUString::number(m_fMinLabelDistance) + "cm" );
     }
-    pAttrList->AddAttribute( "fo:text-align", GetAlignName(m_eAlign) );
+    pAttrList->AddAttribute( u"fo:text-align"_ustr, GetAlignName(m_eAlign) );
 
-    pStrm->StartElement( "style:properties" );
-    pStrm->EndElement( "style:properties" );
+    pStrm->StartElement( u"style:properties"_ustr );
+    pStrm->EndElement( u"style:properties"_ustr );
 
-    pStrm->EndElement( "text:list-level-style-number" );
+    pStrm->EndElement( u"text:list-level-style-number"_ustr );
 }
 
 void    XFListLevelBullet::ToXml(IXFStream *pStrm)
@@ -115,46 +115,46 @@ void    XFListLevelBullet::ToXml(IXFStream *pStrm)
     IXFAttrList *pAttrList = pStrm->GetAttrList();
 
     pAttrList->Clear();
-    pAttrList->AddAttribute( "text:level", OUString::number(static_cast<sal_Int32>(m_nLevel)) );
+    pAttrList->AddAttribute( u"text:level"_ustr, OUString::number(static_cast<sal_Int32>(m_nLevel)) );
     //text:style-name,ignore now.
     m_aNumFmt.ToXml(pStrm);
     //bullet-char
-    pAttrList->AddAttribute( "text:bullet-char", m_chBullet );
+    pAttrList->AddAttribute( u"text:bullet-char"_ustr, m_chBullet );
 
-    pStrm->StartElement( "text:list-level-style-bullet" );
+    pStrm->StartElement( u"text:list-level-style-bullet"_ustr );
 
     //<style:properties>...</style:properties>
     pAttrList->Clear();
     if( m_fIndent != 0 )
     {
-        pAttrList->AddAttribute( "text:space-before", OUString::number(m_fIndent) + "cm" );
+        pAttrList->AddAttribute( u"text:space-before"_ustr, OUString::number(m_fIndent) + "cm" );
     }
     if( m_fMinLabelWidth != 0 )
     {
-        pAttrList->AddAttribute( "text:min-label-width", OUString::number(m_fMinLabelWidth) + "cm" );
+        pAttrList->AddAttribute( u"text:min-label-width"_ustr, OUString::number(m_fMinLabelWidth) + "cm" );
     }
     if( m_fMinLabelDistance != 0 )
     {
-        pAttrList->AddAttribute( "text:min-label-distance", OUString::number(m_fMinLabelDistance) + "cm" );
+        pAttrList->AddAttribute( u"text:min-label-distance"_ustr, OUString::number(m_fMinLabelDistance) + "cm" );
     }
 
-    pAttrList->AddAttribute( "fo:text-align", GetAlignName(m_eAlign) );
+    pAttrList->AddAttribute( u"fo:text-align"_ustr, GetAlignName(m_eAlign) );
 
     if( !m_strFontName.isEmpty() )
     {
-        pAttrList->AddAttribute( "style:font-name", m_strFontName );
+        pAttrList->AddAttribute( u"style:font-name"_ustr, m_strFontName );
     }
-    pStrm->StartElement( "style:properties" );
-    pStrm->EndElement( "style:properties" );
+    pStrm->StartElement( u"style:properties"_ustr );
+    pStrm->EndElement( u"style:properties"_ustr );
 
-    pStrm->EndElement( "text:list-level-style-bullet" );
+    pStrm->EndElement( u"text:list-level-style-bullet"_ustr );
 }
 
 XFListStyle::XFListStyle()
 {
     XFNumFmt    nf;
-    nf.SetSuffix( "." );
-    nf.SetFormat( "1" );
+    nf.SetSuffix( u"."_ustr );
+    nf.SetFormat( u"1"_ustr );
 
     for( int i=0; i<10; i++ )
     {
@@ -273,10 +273,10 @@ void XFListStyle::ToXml(IXFStream *pStrm)
     IXFAttrList *pAttrList = pStrm->GetAttrList();
 
     pAttrList->Clear();
-    pAttrList->AddAttribute( "style:name", GetStyleName() );
+    pAttrList->AddAttribute( u"style:name"_ustr, GetStyleName() );
     if( !GetParentStyleName().isEmpty() )
-        pAttrList->AddAttribute("style:parent-style-name",GetParentStyleName());
-    pStrm->StartElement( "text:list-style" );
+        pAttrList->AddAttribute(u"style:parent-style-name"_ustr,GetParentStyleName());
+    pStrm->StartElement( u"text:list-style"_ustr );
 
     for(auto const & pLevel : m_pListLevels)
     {
@@ -284,7 +284,7 @@ void XFListStyle::ToXml(IXFStream *pStrm)
             pLevel->ToXml(pStrm);
     }
 
-    pStrm->EndElement( "text:list-style" );
+    pStrm->EndElement( u"text:list-style"_ustr );
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/source/filter/xfilter/xfmargins.cxx b/lotuswordpro/source/filter/xfilter/xfmargins.cxx
index b6aab56d0451..eb8f6eb77648 100644
--- a/lotuswordpro/source/filter/xfilter/xfmargins.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfmargins.cxx
@@ -81,22 +81,22 @@ void    XFMargins::ToXml(IXFStream *pStrm)
     //margin left:
     if( m_nFlag&XFMARGINS_FLAG_LEFT )
     {
-        pAttrList->AddAttribute( "fo:margin-left", OUString::number(m_fLeft) + "cm" );
+        pAttrList->AddAttribute( u"fo:margin-left"_ustr, OUString::number(m_fLeft) + "cm" );
     }
     //margin right:
     if( m_nFlag&XFMARGINS_FLAG_RIGHT )
     {
-        pAttrList->AddAttribute("fo:margin-right", OUString::number(m_fRight) + "cm" );
+        pAttrList->AddAttribute(u"fo:margin-right"_ustr, OUString::number(m_fRight) + "cm" );
     }
     //margin top:
     if( m_nFlag&XFMARGINS_FLAG_TOP )
     {
-        pAttrList->AddAttribute("fo:margin-top", OUString::number(m_fTop) + "cm" );
+        pAttrList->AddAttribute(u"fo:margin-top"_ustr, OUString::number(m_fTop) + "cm" );
     }
     //margin bottom:
     if( m_nFlag&XFMARGINS_FLAG_BOTTOM )
     {
-        pAttrList->AddAttribute("fo:margin-bottom", OUString::number(m_fBottom) + "cm" );
+        pAttrList->AddAttribute(u"fo:margin-bottom"_ustr, OUString::number(m_fBottom) + "cm" );
     }
 }
 
diff --git a/lotuswordpro/source/filter/xfilter/xfmasterpage.cxx b/lotuswordpro/source/filter/xfilter/xfmasterpage.cxx
index 29eb8a9e7b33..f289f3e5b01b 100644
--- a/lotuswordpro/source/filter/xfilter/xfmasterpage.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfmasterpage.cxx
@@ -74,13 +74,13 @@ void XFMasterPage::ToXml(IXFStream* pStrm)
     IXFAttrList* pAttrList = pStrm->GetAttrList();
 
     pAttrList->Clear();
-    pAttrList->AddAttribute("style:name", m_strStyleName);
-    pAttrList->AddAttribute("style:page-master-name", m_strPageMaster);
-    pStrm->StartElement("style:master-page");
+    pAttrList->AddAttribute(u"style:name"_ustr, m_strStyleName);
+    pAttrList->AddAttribute(u"style:page-master-name"_ustr, m_strPageMaster);
+    pStrm->StartElement(u"style:master-page"_ustr);
     if (m_xHeader)
         m_xHeader->ToXml(pStrm);
     if (m_xFooter)
         m_xFooter->ToXml(pStrm);
-    pStrm->EndElement("style:master-page");
+    pStrm->EndElement(u"style:master-page"_ustr);
 }
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/source/filter/xfilter/xfnumberstyle.cxx b/lotuswordpro/source/filter/xfilter/xfnumberstyle.cxx
index 169f5e7e5a30..0b7135b30347 100644
--- a/lotuswordpro/source/filter/xfilter/xfnumberstyle.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfnumberstyle.cxx
@@ -141,32 +141,32 @@ void XFNumberStyle::ToXml_StartElement(IXFStream *pStrm)
     IXFAttrList *pAttrList = pStrm->GetAttrList();
     pAttrList->Clear();
 
-    pAttrList->AddAttribute( "style:name", GetStyleName() );
+    pAttrList->AddAttribute( u"style:name"_ustr, GetStyleName() );
     if( !GetParentStyleName().isEmpty() )
-        pAttrList->AddAttribute("style:parent-style-name",GetParentStyleName());
+        pAttrList->AddAttribute(u"style:parent-style-name"_ustr,GetParentStyleName());
 
-    pAttrList->AddAttribute( "style:family", "data-style" );
+    pAttrList->AddAttribute( u"style:family"_ustr, u"data-style"_ustr );
 
     if( m_eType == enumXFNumberNumber )
     {
-        pStrm->StartElement( "number:number-style" );
+        pStrm->StartElement( u"number:number-style"_ustr );
     }
     else if( m_eType == enumXFNumberPercent )
     {
-        pStrm->StartElement( "number:percentage-style" );
+        pStrm->StartElement( u"number:percentage-style"_ustr );
     }
     else if( m_eType == enuMXFNumberCurrency )
     {
-        pStrm->StartElement( "number:currency-style" );
+        pStrm->StartElement( u"number:currency-style"_ustr );
     }
     else if( m_eType == enumXFNumberScientific )
     {
-        pStrm->StartElement( "number:number-style" );
+        pStrm->StartElement( u"number:number-style"_ustr );
     }
     // for Text content number format
     else if (m_eType == enumXFText)
     {
-        pStrm->StartElement( "number:text-content");
+        pStrm->StartElement( u"number:text-content"_ustr);
     }
 
 }
@@ -176,29 +176,29 @@ void XFNumberStyle::ToXml_EndElement(IXFStream *pStrm)
     IXFAttrList *pAttrList = pStrm->GetAttrList();
     pAttrList->Clear();
 
-    pAttrList->AddAttribute( "style:name", GetStyleName() );
-    pAttrList->AddAttribute( "style:family", "data-style" );
+    pAttrList->AddAttribute( u"style:name"_ustr, GetStyleName() );
+    pAttrList->AddAttribute( u"style:family"_ustr, u"data-style"_ustr );
 
     if( m_eType == enumXFNumberNumber )
     {
-        pStrm->EndElement( "number:number-style" );
+        pStrm->EndElement( u"number:number-style"_ustr );
     }
     else if( m_eType == enumXFNumberPercent )
     {
-        pStrm->EndElement( "number:percentage-style" );
+        pStrm->EndElement( u"number:percentage-style"_ustr );
     }
     else if( m_eType == enuMXFNumberCurrency )
     {
-        pStrm->EndElement( "number:currency-style" );
+        pStrm->EndElement( u"number:currency-style"_ustr );
     }
     else if( m_eType == enumXFNumberScientific )
     {
-        pStrm->EndElement( "number:number-style" );
+        pStrm->EndElement( u"number:number-style"_ustr );
     }
     // for Text content number format
     else if (m_eType == enumXFText)
     {
-        pStrm->EndElement( "number:text-content");
+        pStrm->EndElement( u"number:text-content"_ustr);
     }
     // END for Text content number format
 
@@ -229,10 +229,10 @@ void XFNumberStyle::ToXml_Negative(IXFStream *pStrm)
     ToXml_Content(pStrm,true);
 
     pAttrList->Clear();
-    pAttrList->AddAttribute( "style:condition", "value()>=0" );
-    pAttrList->AddAttribute( "style:apply-style-name", strGEStyle );
-    pStrm->StartElement( "style:map" );
-    pStrm->EndElement( "style:map" );
+    pAttrList->AddAttribute( u"style:condition"_ustr, u"value()>=0"_ustr );
+    pAttrList->AddAttribute( u"style:apply-style-name"_ustr, strGEStyle );
+    pStrm->StartElement( u"style:map"_ustr );
+    pStrm->EndElement( u"style:map"_ustr );
 
     ToXml_EndElement(pStrm);
 }
@@ -243,20 +243,20 @@ void XFNumberStyle::ToXml_Content(IXFStream *pStrm, bool nagetive)
     pAttrList->Clear();
     //color:
     if( !nagetive )
-        pAttrList->AddAttribute( "fo:color", m_aColor.ToString() );
+        pAttrList->AddAttribute( u"fo:color"_ustr, m_aColor.ToString() );
     else
-        pAttrList->AddAttribute( "fo:color", m_aNegativeColor.ToString() );
+        pAttrList->AddAttribute( u"fo:color"_ustr, m_aNegativeColor.ToString() );
 
-    pStrm->StartElement( "style:properties" );
-    pStrm->EndElement( "style:properties" );
+    pStrm->StartElement( u"style:properties"_ustr );
+    pStrm->EndElement( u"style:properties"_ustr );
 
     if( !nagetive )
     {
         if( !m_strPrefix.isEmpty() )
         {
-            pStrm->StartElement( "number:text" );
+            pStrm->StartElement( u"number:text"_ustr );
             pStrm->Characters(m_strPrefix);
-            pStrm->EndElement( "number:text" );
+            pStrm->EndElement( u"number:text"_ustr );
         }
     }
     else
@@ -265,16 +265,16 @@ void XFNumberStyle::ToXml_Content(IXFStream *pStrm, bool nagetive)
             m_strNegativePrefix = m_strPrefix;
         if( !m_strNegativePrefix.isEmpty() )
         {
-            pStrm->StartElement( "number:text" );
+            pStrm->StartElement( u"number:text"_ustr );
             // pStrm->Characters(m_strNegativePrefix);
             pStrm->Characters(m_strNegativePrefix + "-");
-            pStrm->EndElement( "number:text" );
+            pStrm->EndElement( u"number:text"_ustr );
         }
         else
         {
-            pStrm->StartElement( "number:text" );
-            pStrm->Characters("-");
-            pStrm->EndElement( "number:text" );
+            pStrm->StartElement( u"number:text"_ustr );
+            pStrm->Characters(u"-"_ustr);
+            pStrm->EndElement( u"number:text"_ustr );
         }
     }
 
@@ -282,9 +282,9 @@ void XFNumberStyle::ToXml_Content(IXFStream *pStrm, bool nagetive)
     {
         if( !m_strCurrencySymbol.isEmpty() )
         {
-            pStrm->StartElement( "number:currency-symbol" );
+            pStrm->StartElement( u"number:currency-symbol"_ustr );
             pStrm->Characters(m_strCurrencySymbol);
-            pStrm->EndElement( "number:currency-symbol" );
+            pStrm->EndElement( u"number:currency-symbol"_ustr );
         }
     }
 
@@ -292,42 +292,42 @@ void XFNumberStyle::ToXml_Content(IXFStream *pStrm, bool nagetive)
     if ( m_eType == enumXFNumberScientific )
     {
         pAttrList->Clear();
-        pAttrList->AddAttribute("number:decimal-places", OUString::number(m_nDecimalDigits));
-        pAttrList->AddAttribute("number:min-integer-digits", OUString::number(1));
-        pAttrList->AddAttribute("number:min-exponent-digits", OUString::number(2));
-        pStrm->StartElement( "number:scientific-number" );
-        pStrm->EndElement( "number:scientific-number" );
+        pAttrList->AddAttribute(u"number:decimal-places"_ustr, OUString::number(m_nDecimalDigits));
+        pAttrList->AddAttribute(u"number:min-integer-digits"_ustr, OUString::number(1));
+        pAttrList->AddAttribute(u"number:min-exponent-digits"_ustr, OUString::number(2));
+        pStrm->StartElement( u"number:scientific-number"_ustr );
+        pStrm->EndElement( u"number:scientific-number"_ustr );
     }
     else
     {
         pAttrList->Clear();
-        pAttrList->AddAttribute("number:decimal-places", OUString::number(m_nDecimalDigits));
-        pAttrList->AddAttribute("number:min-integer-digits", OUString::number(1));
+        pAttrList->AddAttribute(u"number:decimal-places"_ustr, OUString::number(m_nDecimalDigits));
+        pAttrList->AddAttribute(u"number:min-integer-digits"_ustr, OUString::number(1));
 
         if( m_bGroup )
-            pAttrList->AddAttribute("number:grouping","true");
+            pAttrList->AddAttribute(u"number:grouping"_ustr,u"true"_ustr);
         else
-            pAttrList->AddAttribute("number:grouping","false");
+            pAttrList->AddAttribute(u"number:grouping"_ustr,u"false"_ustr);
 
-        pStrm->StartElement( "number:number" );
-        pStrm->EndElement( "number:number" );
+        pStrm->StartElement( u"number:number"_ustr );
+        pStrm->EndElement( u"number:number"_ustr );
     }
 
     if( !nagetive )
     {
         if( !m_strSuffix.isEmpty() )
         {
-            pStrm->StartElement( "number:text" );
+            pStrm->StartElement( u"number:text"_ustr );
             pStrm->Characters(m_strSuffix);
-            pStrm->EndElement( "number:text" );
+            pStrm->EndElement( u"number:text"_ustr );
         }
         else
         {
             if( m_eType == enumXFNumberPercent )
             {
-                pStrm->StartElement( "number:text" );
-                pStrm->Characters("%");
-                pStrm->EndElement( "number:text" );
+                pStrm->StartElement( u"number:text"_ustr );
+                pStrm->Characters(u"%"_ustr);
+                pStrm->EndElement( u"number:text"_ustr );
             }
         }
     }
@@ -337,17 +337,17 @@ void XFNumberStyle::ToXml_Content(IXFStream *pStrm, bool nagetive)
             m_strNegativeSuffix = m_strSuffix;
         if( !m_strNegativeSuffix.isEmpty() )
         {
-            pStrm->StartElement( "number:text" );
+            pStrm->StartElement( u"number:text"_ustr );
             pStrm->Characters(m_strNegativeSuffix);
-            pStrm->EndElement( "number:text" );
+            pStrm->EndElement( u"number:text"_ustr );
         }
         else
         {
             if( m_eType == enumXFNumberPercent )
             {
-                pStrm->StartElement( "number:text" );
-                pStrm->Characters("%");
-                pStrm->EndElement( "number:text" );
+                pStrm->StartElement( u"number:text"_ustr );
+                pStrm->Characters(u"%"_ustr);
+                pStrm->EndElement( u"number:text"_ustr );
             }
         }
     }
diff --git a/lotuswordpro/source/filter/xfilter/xfofficemeta.cxx b/lotuswordpro/source/filter/xfilter/xfofficemeta.cxx
index 9867449bc34c..9adaa46791c3 100644
--- a/lotuswordpro/source/filter/xfilter/xfofficemeta.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfofficemeta.cxx
@@ -90,49 +90,49 @@ void    XFOfficeMeta::ToXml(IXFStream *pStream)
     IXFAttrList *pAttrList = pStream->GetAttrList();
 
     pAttrList->Clear();
-    pStream->StartElement( "office:meta" );
+    pStream->StartElement( u"office:meta"_ustr );
 
     //generator:
-    pStream->StartElement( "meta:generator" );
+    pStream->StartElement( u"meta:generator"_ustr );
     pStream->Characters( m_strGenerator );
-    pStream->EndElement( "meta:generator" );
+    pStream->EndElement( u"meta:generator"_ustr );
 
     //title
-    pStream->StartElement( "dc:title" );
+    pStream->StartElement( u"dc:title"_ustr );
     pStream->Characters( m_strTitle );
-    pStream->EndElement( "dc:title" );
+    pStream->EndElement( u"dc:title"_ustr );
 
     //keywords
-    pStream->StartElement( "meta:keywords" );
-    pStream->StartElement( "meta:keyword" );
+    pStream->StartElement( u"meta:keywords"_ustr );
+    pStream->StartElement( u"meta:keyword"_ustr );
     pStream->Characters( m_strKeywords );
-    pStream->EndElement( "meta:keyword" );
-    pStream->EndElement( "meta:keywords" );
+    pStream->EndElement( u"meta:keyword"_ustr );
+    pStream->EndElement( u"meta:keywords"_ustr );
 
     //creation time
-    pStream->StartElement( "meta:creation-date" );
+    pStream->StartElement( u"meta:creation-date"_ustr );
     pStream->Characters( m_strCrtime);
-    pStream->EndElement( "meta:creation-date" );
+    pStream->EndElement( u"meta:creation-date"_ustr );
 
     //last revision time
-    pStream->StartElement( "dc:date" );
+    pStream->StartElement( u"dc:date"_ustr );
     pStream->Characters( m_strLstime);
-    pStream->EndElement( "dc:date" );
+    pStream->EndElement( u"dc:date"_ustr );
     //total edit time
-    pStream->StartElement( "meta:editing-duration" );
+    pStream->StartElement( u"meta:editing-duration"_ustr );
     pStream->Characters( m_strEdtime);
-    pStream->EndElement( "meta:editing-duration" );
+    pStream->EndElement( u"meta:editing-duration"_ustr );
 
     //description
-    pStream->StartElement( "dc:description" );
+    pStream->StartElement( u"dc:description"_ustr );
     pStream->Characters( m_strDsr );
-    pStream->EndElement( "dc:description" );
+    pStream->EndElement( u"dc:description"_ustr );
     //creator
-    pStream->StartElement( "meta:initial-creator" );
+    pStream->StartElement( u"meta:initial-creator"_ustr );
     pStream->Characters( m_strCreator );
-    pStream->EndElement( "meta:initial-creator" );
+    pStream->EndElement( u"meta:initial-creator"_ustr );
 
-    pStream->EndElement( "office:meta" );
+    pStream->EndElement( u"office:meta"_ustr );
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/source/filter/xfilter/xfpagemaster.cxx b/lotuswordpro/source/filter/xfilter/xfpagemaster.cxx
index d6419e1dfe0f..986da109071e 100644
--- a/lotuswordpro/source/filter/xfilter/xfpagemaster.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfpagemaster.cxx
@@ -194,37 +194,37 @@ void    XFPageMaster::ToXml(IXFStream *pStream)
     IXFAttrList *pAttrList = pStream->GetAttrList();
 
     pAttrList->Clear();
-    pAttrList->AddAttribute("style:name",GetStyleName());
+    pAttrList->AddAttribute(u"style:name"_ustr,GetStyleName());
 
     if( m_eUsage != enumXFPageUsageNone )
-        pAttrList->AddAttribute("style:page-usage", GetPageUsageName(m_eUsage));
+        pAttrList->AddAttribute(u"style:page-usage"_ustr, GetPageUsageName(m_eUsage));
 
-    pStream->StartElement( "style:page-master" );
+    pStream->StartElement( u"style:page-master"_ustr );
 
     //style:properties
     pAttrList->Clear();
     if( m_fPageWidth != 0 )
-        pAttrList->AddAttribute( "fo:page-width", OUString::number(m_fPageWidth) + "cm" );
+        pAttrList->AddAttribute( u"fo:page-width"_ustr, OUString::number(m_fPageWidth) + "cm" );
     if( m_fPageHeight != 0 )
-        pAttrList->AddAttribute( "fo:page-height", OUString::number(m_fPageHeight) + "cm" );
+        pAttrList->AddAttribute( u"fo:page-height"_ustr, OUString::number(m_fPageHeight) + "cm" );
 
     m_aMargin.ToXml(pStream);
 
-    pAttrList->AddAttribute( "style:print-orientation", "portrait" );
+    pAttrList->AddAttribute( u"style:print-orientation"_ustr, u"portrait"_ustr );
 
     if( m_pBorders )
         m_pBorders->ToXml(pStream);
     if( m_pShadow )
-        pAttrList->AddAttribute( "style:shadow", m_pShadow->ToString() );
+        pAttrList->AddAttribute( u"style:shadow"_ustr, m_pShadow->ToString() );
 
     if( m_aBackColor.IsValid() )
-        pAttrList->AddAttribute( "fo:background-color", m_aBackColor.ToString() );
+        pAttrList->AddAttribute( u"fo:background-color"_ustr, m_aBackColor.ToString() );
 
     //text directory
     if( m_eTextDir != enumXFTextDirNone )
-        pAttrList->AddAttribute( "style:writing-mode", GetTextDirName(m_eTextDir) );
+        pAttrList->AddAttribute( u"style:writing-mode"_ustr, GetTextDirName(m_eTextDir) );
 
-    pStream->StartElement( "style:properties" );
+    pStream->StartElement( u"style:properties"_ustr );
     if( m_pColumns )
         m_pColumns->ToXml(pStream);
 
@@ -234,22 +234,22 @@ void    XFPageMaster::ToXml(IXFStream *pStream)
     if( m_eSepAlign || m_nSepLengthPercent>0 || m_fSepSpaceAbove>0 || m_fSepSpaceBelow>0 )
     {
         pAttrList->Clear();
-        pAttrList->AddAttribute( "style:width", OUString::number(m_fSepWidth) + "cm" );
-        pAttrList->AddAttribute( "style:distance-before-sep", OUString::number(m_fSepSpaceAbove) + "cm" );
-        pAttrList->AddAttribute( "style:distance-after-sep", OUString::number(m_fSepSpaceBelow) + "cm" );
-        pAttrList->AddAttribute( "style:color", m_aSepColor.ToString() );
+        pAttrList->AddAttribute( u"style:width"_ustr, OUString::number(m_fSepWidth) + "cm" );
+        pAttrList->AddAttribute( u"style:distance-before-sep"_ustr, OUString::number(m_fSepSpaceAbove) + "cm" );
+        pAttrList->AddAttribute( u"style:distance-after-sep"_ustr, OUString::number(m_fSepSpaceBelow) + "cm" );
+        pAttrList->AddAttribute( u"style:color"_ustr, m_aSepColor.ToString() );
         if( m_eSepAlign == enumXFAlignStart )
-            pAttrList->AddAttribute( "style:adjustment", "left" );
+            pAttrList->AddAttribute( u"style:adjustment"_ustr, u"left"_ustr );
         else if( m_eSepAlign == enumXFAlignCenter )
-            pAttrList->AddAttribute( "style:adjustment", "center" );
+            pAttrList->AddAttribute( u"style:adjustment"_ustr, u"center"_ustr );
         else if( m_eSepAlign == enumXFAlignEnd )
-            pAttrList->AddAttribute( "style:adjustment", "right" );
-        pAttrList->AddAttribute( "style:rel-width", OUString::number(m_nSepLengthPercent) + "%" );
-        pStream->StartElement( "style:footnote-sep" );
-        pStream->EndElement( "style:footnote-sep" );
+            pAttrList->AddAttribute( u"style:adjustment"_ustr, u"right"_ustr );
+        pAttrList->AddAttribute( u"style:rel-width"_ustr, OUString::number(m_nSepLengthPercent) + "%" );
+        pStream->StartElement( u"style:footnote-sep"_ustr );
+        pStream->EndElement( u"style:footnote-sep"_ustr );
     }
 
-    pStream->EndElement( "style:properties" );
+    pStream->EndElement( u"style:properties"_ustr );
 
     //header style:
     if( m_pHeaderStyle )
@@ -258,7 +258,7 @@ void    XFPageMaster::ToXml(IXFStream *pStream)
     if( m_pFooterStyle )
         m_pFooterStyle->ToXml(pStream);
 
-    pStream->EndElement( "style:page-master" );
+    pStream->EndElement( u"style:page-master"_ustr );
 
 }
 
diff --git a/lotuswordpro/source/filter/xfilter/xfparagraph.cxx b/lotuswordpro/source/filter/xfilter/xfparagraph.cxx
index bc070e36a23e..93f37b11f59b 100644
--- a/lotuswordpro/source/filter/xfilter/xfparagraph.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfparagraph.cxx
@@ -83,12 +83,12 @@ void XFParagraph::ToXml(IXFStream* pStrm)
 
     pAttrList->Clear();
     if (!GetStyleName().isEmpty())
-        pAttrList->AddAttribute("text:style-name", GetStyleName());
-    pStrm->StartElement("text:p");
+        pAttrList->AddAttribute(u"text:style-name"_ustr, GetStyleName());
+    pStrm->StartElement(u"text:p"_ustr);
 
     XFContentContainer::ToXml(pStrm);
 
-    pStrm->EndElement("text:p");
+    pStrm->EndElement(u"text:p"_ustr);
 }
 
 bool XFParagraph::HasContents() const { return GetCount() > 0; }
diff --git a/lotuswordpro/source/filter/xfilter/xfparastyle.cxx b/lotuswordpro/source/filter/xfilter/xfparastyle.cxx
index 4e298a248b3b..f3914bfa49d9 100644
--- a/lotuswordpro/source/filter/xfilter/xfparastyle.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfparastyle.cxx
@@ -357,14 +357,14 @@ void    XFParaStyle::ToXml(IXFStream *pStrm)
 
     pAttrList->Clear();
     if( !style.isEmpty() )
-        pAttrList->AddAttribute("style:name",GetStyleName());
-    pAttrList->AddAttribute("style:family", "paragraph");
+        pAttrList->AddAttribute(u"style:name"_ustr,GetStyleName());
+    pAttrList->AddAttribute(u"style:family"_ustr, u"paragraph"_ustr);
     if( !GetParentStyleName().isEmpty() )
-        pAttrList->AddAttribute("style:parent-style-name",GetParentStyleName());
+        pAttrList->AddAttribute(u"style:parent-style-name"_ustr,GetParentStyleName());
 
     if( !m_strMasterPage.isEmpty() )
-        pAttrList->AddAttribute("style:master-page-name",m_strMasterPage);
-    pStrm->StartElement("style:style");
+        pAttrList->AddAttribute(u"style:master-page-name"_ustr,m_strMasterPage);
+    pStrm->StartElement(u"style:style"_ustr);
 
     //Paragraph properties:
     pAttrList->Clear();
@@ -372,7 +372,7 @@ void    XFParaStyle::ToXml(IXFStream *pStrm)
     //text indent:
     if( m_fTextIndent )
     {
-        pAttrList->AddAttribute("fo:text-indent", OUString::number(m_fTextIndent) + "cm" );
+        pAttrList->AddAttribute(u"fo:text-indent"_ustr, OUString::number(m_fTextIndent) + "cm" );
     }
     //padding:
     m_aPadding.ToXml(pStrm);
@@ -382,11 +382,11 @@ void    XFParaStyle::ToXml(IXFStream *pStrm)
     //text align:
     if( m_eAlignType != enumXFAlignNone )
     {
-        pAttrList->AddAttribute("fo:text-align", GetAlignName(m_eAlignType) );
+        pAttrList->AddAttribute(u"fo:text-align"_ustr, GetAlignName(m_eAlignType) );
     }
     //line number:
-    pAttrList->AddAttribute( "text:number-lines", "true" );
-    pAttrList->AddAttribute( "text:line-number", OUString::number(0) );
+    pAttrList->AddAttribute( u"text:number-lines"_ustr, u"true"_ustr );
+    pAttrList->AddAttribute( u"text:line-number"_ustr, OUString::number(0) );
 
     //shadow:
     m_aShadow.ToXml(pStrm);
@@ -399,7 +399,7 @@ void    XFParaStyle::ToXml(IXFStream *pStrm)
     //background color:
     if( m_nFlag&XFPARA_FLAG_BACKCOLOR && m_aBackColor.IsValid() )
     {
-        pAttrList->AddAttribute("fo:background-color", m_aBackColor.ToString() );
+        pAttrList->AddAttribute(u"fo:background-color"_ustr, m_aBackColor.ToString() );
     }
     //Font properties:
     if( m_pFont.is() )
@@ -408,7 +408,7 @@ void    XFParaStyle::ToXml(IXFStream *pStrm)
     //page breaks:
     m_aBreaks.ToXml(pStrm);
 
-    pStrm->StartElement("style:properties");
+    pStrm->StartElement(u"style:properties"_ustr);
 
     //dropcap:
     m_aDropcap.ToXml(pStrm);
@@ -417,18 +417,18 @@ void    XFParaStyle::ToXml(IXFStream *pStrm)
     if( m_aTabs.GetCount() > 0 )
     {
         pAttrList->Clear();
-        pStrm->StartElement( "style:tab-stops" );
+        pStrm->StartElement( u"style:tab-stops"_ustr );
         m_aTabs.ToXml(pStrm);
-        pStrm->EndElement( "style:tab-stops" );
+        pStrm->EndElement( u"style:tab-stops"_ustr );
     }
 
     //background color:
     if( m_pBGImage )
         m_pBGImage->ToXml(pStrm);
 
-    pStrm->EndElement("style:properties");
+    pStrm->EndElement(u"style:properties"_ustr);
 
-    pStrm->EndElement("style:style");
+    pStrm->EndElement(u"style:style"_ustr);
 }
 
 XFDefaultParaStyle::XFDefaultParaStyle()
@@ -445,17 +445,17 @@ void XFDefaultParaStyle::ToXml(IXFStream * pStrm)
 {
     IXFAttrList *pAttrList = pStrm->GetAttrList();
     pAttrList->Clear();
-    pAttrList->AddAttribute("style:family", "paragraph");
-    pStrm->StartElement("style:default-style");
+    pAttrList->AddAttribute(u"style:family"_ustr, u"paragraph"_ustr);
+    pStrm->StartElement(u"style:default-style"_ustr);
 
     //Paragraph properties:
     pAttrList->Clear();
 
-    pAttrList->AddAttribute("style:tab-stop-distance", OUString::number(m_fTabDistance) + "cm" );
+    pAttrList->AddAttribute(u"style:tab-stop-distance"_ustr, OUString::number(m_fTabDistance) + "cm" );
 
-    pStrm->StartElement("style:properties");
-    pStrm->EndElement("style:properties");
-    pStrm->EndElement("style:default-style");
+    pStrm->StartElement(u"style:properties"_ustr);
+    pStrm->EndElement(u"style:properties"_ustr);
+    pStrm->EndElement(u"style:default-style"_ustr);
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/source/filter/xfilter/xfrow.cxx b/lotuswordpro/source/filter/xfilter/xfrow.cxx
index 1bdfb8849a05..97484c3f82f5 100644
--- a/lotuswordpro/source/filter/xfilter/xfrow.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfrow.cxx
@@ -108,10 +108,10 @@ void    XFRow::ToXml(IXFStream *pStrm)
 
     pAttrList->Clear();
     if( !GetStyleName().isEmpty() )
-        pAttrList->AddAttribute( "table:style-name", GetStyleName() );
+        pAttrList->AddAttribute( u"table:style-name"_ustr, GetStyleName() );
     if( m_nRepeat )
-        pAttrList->AddAttribute( "table:number-rows-repeated", OUString::number(m_nRepeat) );
-    pStrm->StartElement( "table:table-row" );
+        pAttrList->AddAttribute( u"table:number-rows-repeated"_ustr, OUString::number(m_nRepeat) );
+    pStrm->StartElement( u"table:table-row"_ustr );
 
     for (size_t nIndex = 0, nCount = m_aCells.size(); nIndex < nCount; ++nIndex)
     {
@@ -130,6 +130,6 @@ void    XFRow::ToXml(IXFStream *pStrm)
         lastCol = col;
     }
 
-    pStrm->EndElement( "table:table-row" );
+    pStrm->EndElement( u"table:table-row"_ustr );
 }
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/source/filter/xfilter/xfrowstyle.cxx b/lotuswordpro/source/filter/xfilter/xfrowstyle.cxx
index 99d654da4871..86ffc89bac69 100644
--- a/lotuswordpro/source/filter/xfilter/xfrowstyle.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfrowstyle.cxx
@@ -76,25 +76,25 @@ void    XFRowStyle::ToXml(IXFStream *pStrm)
     IXFAttrList *pAttrList = pStrm->GetAttrList();
     pAttrList->Clear();
 
-    pAttrList->AddAttribute( "style:name", GetStyleName() );
+    pAttrList->AddAttribute( u"style:name"_ustr, GetStyleName() );
     if( !GetParentStyleName().isEmpty() )
-        pAttrList->AddAttribute("style:parent-style-name",GetParentStyleName());
+        pAttrList->AddAttribute(u"style:parent-style-name"_ustr,GetParentStyleName());
 
-    pAttrList->AddAttribute( "style:family", "table-row" );
-    pStrm->StartElement( "style:style" );
+    pAttrList->AddAttribute( u"style:family"_ustr, u"table-row"_ustr );
+    pStrm->StartElement( u"style:style"_ustr );
 
     pAttrList->Clear();
     if( m_fMinHeight )
-        pAttrList->AddAttribute( "style:min-row-height", OUString::number(m_fMinHeight) + "cm" );
+        pAttrList->AddAttribute( u"style:min-row-height"_ustr, OUString::number(m_fMinHeight) + "cm" );
     else if( m_fHeight )
-        pAttrList->AddAttribute( "style:row-height", OUString::number(m_fHeight) + "cm" );
+        pAttrList->AddAttribute( u"style:row-height"_ustr, OUString::number(m_fHeight) + "cm" );
 
     if( m_aBackColor.IsValid() )
-        pAttrList->AddAttribute( "fo:background-color", m_aBackColor.ToString() );
-    pStrm->StartElement( "style:properties" );
-    pStrm->EndElement( "style:properties" );
+        pAttrList->AddAttribute( u"fo:background-color"_ustr, m_aBackColor.ToString() );
+    pStrm->StartElement( u"style:properties"_ustr );
+    pStrm->EndElement( u"style:properties"_ustr );
 
-    pStrm->EndElement( "style:style" );
+    pStrm->EndElement( u"style:style"_ustr );
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/source/filter/xfilter/xfsection.cxx b/lotuswordpro/source/filter/xfilter/xfsection.cxx
index 994f9227c780..edc3c548cbaa 100644
--- a/lotuswordpro/source/filter/xfilter/xfsection.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfsection.cxx
@@ -74,23 +74,23 @@ void XFSection::ToXml(IXFStream* pStrm)
     pAttrList->Clear();
     OUString style = GetStyleName();
     if (!style.isEmpty())
-        pAttrList->AddAttribute("text:style-name", style);
+        pAttrList->AddAttribute(u"text:style-name"_ustr, style);
     //section name
     if (!m_strSectionName.isEmpty())
-        pAttrList->AddAttribute("text:name", m_strSectionName);
+        pAttrList->AddAttribute(u"text:name"_ustr, m_strSectionName);
 
-    pStrm->StartElement("text:section");
+    pStrm->StartElement(u"text:section"_ustr);
     if (!m_strSourceLink.isEmpty())
     {
         pAttrList->Clear();
-        pAttrList->AddAttribute("xlink:href", m_strSourceLink);
-        pAttrList->AddAttribute("text:filter-name", "wordpro");
-        pStrm->StartElement("text:section-source");
-        pStrm->EndElement("text:section-source");
+        pAttrList->AddAttribute(u"xlink:href"_ustr, m_strSourceLink);
+        pAttrList->AddAttribute(u"text:filter-name"_ustr, u"wordpro"_ustr);
+        pStrm->StartElement(u"text:section-source"_ustr);
+        pStrm->EndElement(u"text:section-source"_ustr);
     }
 
     XFContentContainer::ToXml(pStrm);
 
-    pStrm->EndElement("text:section");
+    pStrm->EndElement(u"text:section"_ustr);
 }
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/source/filter/xfilter/xfsectionstyle.cxx b/lotuswordpro/source/filter/xfilter/xfsectionstyle.cxx
index 0bf664d6a077..a617ee85bfdf 100644
--- a/lotuswordpro/source/filter/xfilter/xfsectionstyle.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfsectionstyle.cxx
@@ -97,37 +97,37 @@ void XFSectionStyle::ToXml(IXFStream *pStrm)
     IXFAttrList *pAttrList = pStrm->GetAttrList();
 
     pAttrList->Clear();
-    pAttrList->AddAttribute( "style:name", GetStyleName() );
-    pAttrList->AddAttribute( "style:family", "section" );
+    pAttrList->AddAttribute( u"style:name"_ustr, GetStyleName() );
+    pAttrList->AddAttribute( u"style:family"_ustr, u"section"_ustr );
 
-    pStrm->StartElement( "style:style" );
+    pStrm->StartElement( u"style:style"_ustr );
 
     pAttrList->Clear();
     if( m_fMarginLeft != 0 )
     {
-        pAttrList->AddAttribute( "fo:margin-left", OUString::number(m_fMarginLeft) + "cm" );
+        pAttrList->AddAttribute( u"fo:margin-left"_ustr, OUString::number(m_fMarginLeft) + "cm" );
     }
     if( m_fMarginRight != 0 )
     {
-        pAttrList->AddAttribute( "fo:margin-right", OUString::number(m_fMarginRight) + "cm" );
+        pAttrList->AddAttribute( u"fo:margin-right"_ustr, OUString::number(m_fMarginRight) + "cm" );
     }
     if( m_aBackColor.IsValid() )
     {
-        pAttrList->AddAttribute( "fo:background-color", m_aBackColor.ToString() );
+        pAttrList->AddAttribute( u"fo:background-color"_ustr, m_aBackColor.ToString() );
     }
     else
     {
-        pAttrList->AddAttribute( "fo:background-color", "transparent" );
+        pAttrList->AddAttribute( u"fo:background-color"_ustr, u"transparent"_ustr );
     }
 
-    pStrm->StartElement( "style:properties" );
+    pStrm->StartElement( u"style:properties"_ustr );
 
     if( m_pColumns )
         m_pColumns->ToXml(pStrm);
 
-    pStrm->EndElement( "style:properties" );
+    pStrm->EndElement( u"style:properties"_ustr );
 
-    pStrm->EndElement( "style:style" );
+    pStrm->EndElement( u"style:style"_ustr );
 
 }
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/source/filter/xfilter/xfshadow.cxx b/lotuswordpro/source/filter/xfilter/xfshadow.cxx
index a5acfb343eda..e1469748fed2 100644
--- a/lotuswordpro/source/filter/xfilter/xfshadow.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfshadow.cxx
@@ -99,7 +99,7 @@ void    XFShadow::ToXml(IXFStream *pStrm)
     if( m_ePosition == enumXFShadowNone )
         return;
     else
-        pAttrList->AddAttribute( "style:shadow", ToString() );
+        pAttrList->AddAttribute( u"style:shadow"_ustr, ToString() );
 }
 
 bool operator==(XFShadow const & s1, XFShadow const & s2)
diff --git a/lotuswordpro/source/filter/xfilter/xfstylemanager.cxx b/lotuswordpro/source/filter/xfilter/xfstylemanager.cxx
index 7cf97f8a41d5..402da83b2ab5 100644
--- a/lotuswordpro/source/filter/xfilter/xfstylemanager.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfstylemanager.cxx
@@ -65,11 +65,11 @@
 #include <xfilter/xftextstyle.hxx>
 #include <xfilter/ixfstyle.hxx>
 
-XFStyleManager::XFStyleManager() : s_aStdArrowStyles( "arrow" ), s_aTextStyles( "T" ),
-    s_aParaStyles( "P" ),s_aListStyles( "L" ),s_aSectionStyles( "Sect" ),
-    s_aPageMasters( "PM" ),s_aMasterpages( "MP" ),s_aDateStyles( "N" ),
-    s_aGraphicsStyles( "fr" ),s_aTableStyles( "table" ),s_aTableCellStyles( "cell" ),
-    s_aTableRowStyles( "row" ),s_aTableColStyles( "col" )
+XFStyleManager::XFStyleManager() : s_aStdArrowStyles( u"arrow"_ustr ), s_aTextStyles( u"T"_ustr ),
+    s_aParaStyles( u"P"_ustr ),s_aListStyles( u"L"_ustr ),s_aSectionStyles( u"Sect"_ustr ),
+    s_aPageMasters( u"PM"_ustr ),s_aMasterpages( u"MP"_ustr ),s_aDateStyles( u"N"_ustr ),
+    s_aGraphicsStyles( u"fr"_ustr ),s_aTableStyles( u"table"_ustr ),s_aTableCellStyles( u"cell"_ustr ),
+    s_aTableRowStyles( u"row"_ustr ),s_aTableColStyles( u"col"_ustr )
 {
 }
 
@@ -310,24 +310,24 @@ void    XFStyleManager::ToXml(IXFStream *pStrm)
     IXFAttrList *pAttrList = pStrm->GetAttrList();
 
     pAttrList->Clear();
-    pStrm->StartElement( "office:font-decls" );
+    pStrm->StartElement( u"office:font-decls"_ustr );
 
     //font declarations:
     for (const auto & fontDecl : s_aFontDecls)
     {
         pAttrList->Clear();
-        pAttrList->AddAttribute( "style:name", fontDecl.GetFontName() );
-        pAttrList->AddAttribute( "fo:font-family", fontDecl.GetFontFamily() );
-        pAttrList->AddAttribute( "style:font-pitch", "variable" );
-        pStrm->StartElement( "style:font-decl" );
-        pStrm->EndElement( "style:font-decl" );
+        pAttrList->AddAttribute( u"style:name"_ustr, fontDecl.GetFontName() );
+        pAttrList->AddAttribute( u"fo:font-family"_ustr, fontDecl.GetFontFamily() );
+        pAttrList->AddAttribute( u"style:font-pitch"_ustr, u"variable"_ustr );
+        pStrm->StartElement( u"style:font-decl"_ustr );
+        pStrm->EndElement( u"style:font-decl"_ustr );
     }
 
-    pStrm->EndElement( "office:font-decls" );
+    pStrm->EndElement( u"office:font-decls"_ustr );
 
     //office:styles:
     pAttrList->Clear();
-    pStrm->StartElement( "office:styles" );
+    pStrm->StartElement( u"office:styles"_ustr );
 
     s_aStdParaStyles.ToXml(pStrm);
     s_aStdTextStyles.ToXml(pStrm);
@@ -343,11 +343,11 @@ void    XFStyleManager::ToXml(IXFStream *pStrm)
     if( s_pOutlineStyle )
         s_pOutlineStyle->ToXml(pStrm);
 
-    pStrm->EndElement( "office:styles" );
+    pStrm->EndElement( u"office:styles"_ustr );
 
     //automatic styles:
     pAttrList->Clear();
-    pStrm->StartElement( "office:automatic-styles" );
+    pStrm->StartElement( u"office:automatic-styles"_ustr );
 
     s_aTableStyles.ToXml(pStrm);
     s_aTableCellStyles.ToXml(pStrm);
@@ -361,15 +361,15 @@ void    XFStyleManager::ToXml(IXFStream *pStrm)
     //graphics:
     s_aGraphicsStyles.ToXml(pStrm);
 
-    pStrm->EndElement( "office:automatic-styles" );
+    pStrm->EndElement( u"office:automatic-styles"_ustr );
 
     //master:styles
     pAttrList->Clear();
-    pStrm->StartElement( "office:master-styles" );
+    pStrm->StartElement( u"office:master-styles"_ustr );
     //masters pages:
     s_aMasterpages.ToXml(pStrm);
 
-    pStrm->EndElement( "office:master-styles" );
+    pStrm->EndElement( u"office:master-styles"_ustr );
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/source/filter/xfilter/xftable.cxx b/lotuswordpro/source/filter/xfilter/xftable.cxx
index 976ee8bb9d86..2ba5fd76a840 100644
--- a/lotuswordpro/source/filter/xfilter/xftable.cxx
+++ b/lotuswordpro/source/filter/xfilter/xftable.cxx
@@ -192,15 +192,15 @@ void    XFTable::ToXml(IXFStream *pStrm)
     pAttrList->Clear();
     //sub table shouldn't use table name.
     if( !m_bSubTable )
-        pAttrList->AddAttribute( "table:name", m_strName);
+        pAttrList->AddAttribute( u"table:name"_ustr, m_strName);
 
     if( !GetStyleName().isEmpty() )
-        pAttrList->AddAttribute( "table:style-name", GetStyleName() );
+        pAttrList->AddAttribute( u"table:style-name"_ustr, GetStyleName() );
 
     if( m_bSubTable )
-        pStrm->StartElement( "table:sub-table" );
+        pStrm->StartElement( u"table:sub-table"_ustr );
     else
-        pStrm->StartElement( "table:table" );
+        pStrm->StartElement( u"table:table"_ustr );
 
     //output columns:
     {
@@ -217,29 +217,29 @@ void    XFTable::ToXml(IXFStream *pStrm)
                 {
                     if( !m_strDefColStyle.isEmpty() )
                     {
-                        pAttrList->AddAttribute( "table:style-name", m_strDefColStyle );
+                        pAttrList->AddAttribute( u"table:style-name"_ustr, m_strDefColStyle );
                     }
-                    pAttrList->AddAttribute( "table:number-columns-repeated", OUString::number(col-lastCol-1) );
+                    pAttrList->AddAttribute( u"table:number-columns-repeated"_ustr, OUString::number(col-lastCol-1) );
                 }
-                pStrm->StartElement( "table:table-column" );
-                pStrm->EndElement( "table:table-column" );
+                pStrm->StartElement( u"table:table-column"_ustr );
+                pStrm->EndElement( u"table:table-column"_ustr );
             }
 
             if( !style.isEmpty() )
             {
-                pAttrList->AddAttribute( "table:style-name", style );
+                pAttrList->AddAttribute( u"table:style-name"_ustr, style );
             }
-            pStrm->StartElement( "table:table-column" );
-            pStrm->EndElement( "table:table-column" );
+            pStrm->StartElement( u"table:table-column"_ustr );
+            pStrm->EndElement( u"table:table-column"_ustr );
             lastCol = col;
         }
     }
 
     if (m_aHeaderRows.is() && m_aHeaderRows->GetCount()>0)
     {
-        pStrm->StartElement( "table:table-header-rows" );
+        pStrm->StartElement( u"table:table-header-rows"_ustr );
         m_aHeaderRows->ToXml(pStrm);
-        pStrm->EndElement( "table:table-header-rows" );
+        pStrm->EndElement( u"table:table-header-rows"_ustr );
     }
     //output rows:
     {
@@ -268,8 +268,8 @@ void    XFTable::ToXml(IXFStream *pStrm)
     }
 
     if( m_bSubTable )
-        pStrm->EndElement( "table:sub-table" );
+        pStrm->EndElement( u"table:sub-table"_ustr );
     else
-        pStrm->EndElement( "table:table" );
+        pStrm->EndElement( u"table:table"_ustr );
 }
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/source/filter/xfilter/xftablestyle.cxx b/lotuswordpro/source/filter/xfilter/xftablestyle.cxx
index cf1229f59ff5..49b6e1d1912c 100644
--- a/lotuswordpro/source/filter/xfilter/xftablestyle.cxx
+++ b/lotuswordpro/source/filter/xfilter/xftablestyle.cxx
@@ -84,34 +84,34 @@ void    XFTableStyle::ToXml(IXFStream *pStrm)
     IXFAttrList *pAttrList = pStrm->GetAttrList();
     pAttrList->Clear();
 
-    pAttrList->AddAttribute( "style:name", GetStyleName() );
+    pAttrList->AddAttribute( u"style:name"_ustr, GetStyleName() );
     if( !GetParentStyleName().isEmpty() )
-        pAttrList->AddAttribute("style:parent-style-name",GetParentStyleName());
-    pAttrList->AddAttribute( "style:family", "table" );
-    pStrm->StartElement( "style:style" );
+        pAttrList->AddAttribute(u"style:parent-style-name"_ustr,GetParentStyleName());
+    pAttrList->AddAttribute( u"style:family"_ustr, u"table"_ustr );
+    pStrm->StartElement( u"style:style"_ustr );
 
     pAttrList->Clear();
-    pAttrList->AddAttribute( "style:width", OUString::number(m_fWidth) + "cm" );
+    pAttrList->AddAttribute( u"style:width"_ustr, OUString::number(m_fWidth) + "cm" );
     //text align:
     if( m_eAlign == enumXFAlignStart )
     {
-        pAttrList->AddAttribute("table:align","left");
+        pAttrList->AddAttribute(u"table:align"_ustr,u"left"_ustr);
     }
     else if( m_eAlign == enumXFAlignCenter )
     {
-        pAttrList->AddAttribute("table:align","center");
+        pAttrList->AddAttribute(u"table:align"_ustr,u"center"_ustr);
     }
     else if( m_eAlign == enumXFAlignEnd )
     {
-        pAttrList->AddAttribute("table:align","right");
+        pAttrList->AddAttribute(u"table:align"_ustr,u"right"_ustr);
     }
     else if( m_eAlign == enumXFALignMargins )
     {
-        pAttrList->AddAttribute("table:align","margins");
+        pAttrList->AddAttribute(u"table:align"_ustr,u"margins"_ustr);
     }
     //background color:
     if( m_aBackColor.IsValid() && !m_pBGImage )
-        pAttrList->AddAttribute("fo:background-color", m_aBackColor.ToString() );
+        pAttrList->AddAttribute(u"fo:background-color"_ustr, m_aBackColor.ToString() );
     //shadow:
     m_aShadow.ToXml(pStrm);
     //margin:
@@ -119,12 +119,12 @@ void    XFTableStyle::ToXml(IXFStream *pStrm)
     //breaks:
     m_aBreaks.ToXml(pStrm);
 
-    pStrm->StartElement( "style:properties" );
+    pStrm->StartElement( u"style:properties"_ustr );
     if( m_pBGImage )
         m_pBGImage->ToXml(pStrm);
 
-    pStrm->EndElement( "style:properties" );
+    pStrm->EndElement( u"style:properties"_ustr );
 
-    pStrm->EndElement( "style:style" );
+    pStrm->EndElement( u"style:style"_ustr );
 }
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/source/filter/xfilter/xftabstyle.cxx b/lotuswordpro/source/filter/xfilter/xftabstyle.cxx
index c86d6420ff08..c3da354f7066 100644
--- a/lotuswordpro/source/filter/xfilter/xftabstyle.cxx
+++ b/lotuswordpro/source/filter/xfilter/xftabstyle.cxx
@@ -70,32 +70,32 @@ void XFTabStyle::ToXml(IXFStream *pStrm)
     IXFAttrList *pAttrList = pStrm->GetAttrList();
     pAttrList->Clear();
 
-    pAttrList->AddAttribute( "style:position", OUString::number(m_fLength) + "cm" );
+    pAttrList->AddAttribute( u"style:position"_ustr, OUString::number(m_fLength) + "cm" );
     switch(m_eType)
     {
     case enumXFTabLeft:
-        pAttrList->AddAttribute( "style:type", "left" );
+        pAttrList->AddAttribute( u"style:type"_ustr, u"left"_ustr );
         break;
     case enumXFTabCenter:
-        pAttrList->AddAttribute( "style:type", "center" );
+        pAttrList->AddAttribute( u"style:type"_ustr, u"center"_ustr );
         break;
     case enumXFTabRight:
-        pAttrList->AddAttribute( "style:type", "right" );
+        pAttrList->AddAttribute( u"style:type"_ustr, u"right"_ustr );
         break;
     case enumXFTabChar:
-        pAttrList->AddAttribute( "style:type", "char" );
+        pAttrList->AddAttribute( u"style:type"_ustr, u"char"_ustr );
         break;
     default:
         break;
     }
     //delimiter:
     if( m_eType == enumXFTabChar )
-        pAttrList->AddAttribute( "style:char", m_strDelimiter );
+        pAttrList->AddAttribute( u"style:char"_ustr, m_strDelimiter );
     //leader char:
     if( !m_strLeader.isEmpty() )
-        pAttrList->AddAttribute( "style:leader-char", m_strLeader );
+        pAttrList->AddAttribute( u"style:leader-char"_ustr, m_strLeader );
 
-    pStrm->StartElement( "style:tab-stop" );
-    pStrm->EndElement( "style:tab-stop" );
+    pStrm->StartElement( u"style:tab-stop"_ustr );
+    pStrm->EndElement( u"style:tab-stop"_ustr );
 }
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/source/filter/xfilter/xftextboxstyle.cxx b/lotuswordpro/source/filter/xfilter/xftextboxstyle.cxx
index a399f4c333d9..244206c69205 100644
--- a/lotuswordpro/source/filter/xfilter/xftextboxstyle.cxx
+++ b/lotuswordpro/source/filter/xfilter/xftextboxstyle.cxx
@@ -74,28 +74,28 @@ void    XFTextBoxStyle::ToXml(IXFStream *pStrm)
     IXFAttrList *pAttrList = pStrm->GetAttrList();
 
     pAttrList->Clear();
-    pAttrList->AddAttribute( "style:name", GetStyleName() );
+    pAttrList->AddAttribute( u"style:name"_ustr, GetStyleName() );
     if( !GetParentStyleName().isEmpty() )
-        pAttrList->AddAttribute("style:parent-style-name",GetParentStyleName());
-    pAttrList->AddAttribute( "style:family", "graphics" );
+        pAttrList->AddAttribute(u"style:parent-style-name"_ustr,GetParentStyleName());
+    pAttrList->AddAttribute( u"style:family"_ustr, u"graphics"_ustr );
     //parent style name ignore now.
-    pStrm->StartElement( "style:style" );
+    pStrm->StartElement( u"style:style"_ustr );
 
     pAttrList->Clear();
-    pAttrList->AddAttribute( "draw:stroke", "none" );
-    pAttrList->AddAttribute( "svg:stroke-color", "#000000" );
-    pAttrList->AddAttribute( "draw:fill", "none" );
-    pAttrList->AddAttribute( "draw:fill-color", "#ffffff" );
-    pAttrList->AddAttribute( "draw:auto-grow-height", "true" );
-    pAttrList->AddAttribute( "style:run-through", "foreground" );
-    pAttrList->AddAttribute( "style:wrap", "run-through" );
-    pAttrList->AddAttribute( "style:wrap", "run-through" );
-    pAttrList->AddAttribute( "style:number-wrapped-paragraphs", "no-limit" );
-    pAttrList->AddAttribute( "style:wrap-contour", "false" );
+    pAttrList->AddAttribute( u"draw:stroke"_ustr, u"none"_ustr );
+    pAttrList->AddAttribute( u"svg:stroke-color"_ustr, u"#000000"_ustr );
+    pAttrList->AddAttribute( u"draw:fill"_ustr, u"none"_ustr );
+    pAttrList->AddAttribute( u"draw:fill-color"_ustr, u"#ffffff"_ustr );
+    pAttrList->AddAttribute( u"draw:auto-grow-height"_ustr, u"true"_ustr );
+    pAttrList->AddAttribute( u"style:run-through"_ustr, u"foreground"_ustr );
+    pAttrList->AddAttribute( u"style:wrap"_ustr, u"run-through"_ustr );
+    pAttrList->AddAttribute( u"style:wrap"_ustr, u"run-through"_ustr );
+    pAttrList->AddAttribute( u"style:number-wrapped-paragraphs"_ustr, u"no-limit"_ustr );
+    pAttrList->AddAttribute( u"style:wrap-contour"_ustr, u"false"_ustr );
 
-    pStrm->StartElement( "style:properties" );
-    pStrm->EndElement( "style:properties" );
+    pStrm->StartElement( u"style:properties"_ustr );
+    pStrm->EndElement( u"style:properties"_ustr );
 
-    pStrm->EndElement( "style:style" );
+    pStrm->EndElement( u"style:style"_ustr );
 }
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/source/filter/xfilter/xftextcontent.cxx b/lotuswordpro/source/filter/xfilter/xftextcontent.cxx
index 79d10ee5b56f..cfc54f59a805 100644
--- a/lotuswordpro/source/filter/xfilter/xftextcontent.cxx
+++ b/lotuswordpro/source/filter/xfilter/xftextcontent.cxx
@@ -104,9 +104,9 @@ void    XFTextContent::ToXml(IXFStream *pStrm)
             }
             IXFAttrList *pAttrList = pStrm->GetAttrList();
             pAttrList->Clear();
-            pAttrList->AddAttribute( "text:c", OUString::number(j-nIndex) );
-            pStrm->StartElement( "text:s" );
-            pStrm->EndElement( "text:s" );
+            pAttrList->AddAttribute( u"text:c"_ustr, OUString::number(j-nIndex) );
+            pStrm->StartElement( u"text:s"_ustr );
+            pStrm->EndElement( u"text:s"_ustr );
 
             i+=j;
         }
diff --git a/lotuswordpro/source/filter/xfilter/xftextspan.cxx b/lotuswordpro/source/filter/xfilter/xftextspan.cxx
index 14a6874c27f0..c3ea62ace9f3 100644
--- a/lotuswordpro/source/filter/xfilter/xftextspan.cxx
+++ b/lotuswordpro/source/filter/xfilter/xftextspan.cxx
@@ -104,8 +104,8 @@ void    XFTextSpan::ToXml(IXFStream *pStrm)
 
     pAttrList->Clear();
     if( !style.isEmpty() )
-        pAttrList->AddAttribute( "text:style-name", GetStyleName() );
-    pStrm->StartElement( "text:span" );
+        pAttrList->AddAttribute( u"text:style-name"_ustr, GetStyleName() );
+    pStrm->StartElement( u"text:span"_ustr );
 
     for (auto const& content : m_aContents)
     {
@@ -114,7 +114,7 @@ void    XFTextSpan::ToXml(IXFStream *pStrm)
             pContent->DoToXml(pStrm);
     }
 
-    pStrm->EndElement( "text:span" );
+    pStrm->EndElement( u"text:span"_ustr );
 }
 
 void    XFTextSpanStart::ToXml(IXFStream *pStrm)
@@ -126,8 +126,8 @@ void    XFTextSpanStart::ToXml(IXFStream *pStrm)
 
     pAttrList->Clear();
     if( !style.isEmpty() )
-        pAttrList->AddAttribute( "text:style-name", GetStyleName() );
-    pStrm->StartElement( "text:span" );
+        pAttrList->AddAttribute( u"text:style-name"_ustr, GetStyleName() );
+    pStrm->StartElement( u"text:span"_ustr );
 
     for (auto const& content : m_aContents)
     {
@@ -144,7 +144,7 @@ void    XFTextSpanEnd::ToXml(IXFStream *pStrm)
         if( pContent )
             pContent->DoToXml(pStrm);
     }
-    pStrm->EndElement( "text:span" );
+    pStrm->EndElement( u"text:span"_ustr );
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/source/filter/xfilter/xftextstyle.cxx b/lotuswordpro/source/filter/xfilter/xftextstyle.cxx
index e70603ab2e4c..98e2fc946753 100644
--- a/lotuswordpro/source/filter/xfilter/xftextstyle.cxx
+++ b/lotuswordpro/source/filter/xfilter/xftextstyle.cxx
@@ -104,12 +104,12 @@ void XFTextStyle::ToXml(IXFStream* strm)
 
     pAttrList->Clear();
     if (!style.isEmpty())
-        pAttrList->AddAttribute("style:name", GetStyleName());
+        pAttrList->AddAttribute(u"style:name"_ustr, GetStyleName());
     if (!GetParentStyleName().isEmpty())
-        pAttrList->AddAttribute("style:parent-style-name", GetParentStyleName());
+        pAttrList->AddAttribute(u"style:parent-style-name"_ustr, GetParentStyleName());
 
-    pAttrList->AddAttribute("style:family", "text");
-    strm->StartElement("style:style");
+    pAttrList->AddAttribute(u"style:family"_ustr, u"text"_ustr);
+    strm->StartElement(u"style:style"_ustr);
 
     //Font properties:
     pAttrList->Clear();
@@ -117,10 +117,10 @@ void XFTextStyle::ToXml(IXFStream* strm)
     if (m_pFont.is())
         m_pFont->ToXml(strm);
 
-    strm->StartElement("style:properties");
-    strm->EndElement("style:properties");
+    strm->StartElement(u"style:properties"_ustr);
+    strm->EndElement(u"style:properties"_ustr);
 
-    strm->EndElement("style:style");
+    strm->EndElement(u"style:style"_ustr);
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/source/filter/xfilter/xftimestyle.cxx b/lotuswordpro/source/filter/xfilter/xftimestyle.cxx
index 95a8e7acb875..1ac767d6c0c4 100644
--- a/lotuswordpro/source/filter/xfilter/xftimestyle.cxx
+++ b/lotuswordpro/source/filter/xfilter/xftimestyle.cxx
@@ -75,32 +75,32 @@ void    XFTimePart::ToXml(IXFStream *pStrm)
     case enumXFDateHour:
         pAttrList->Clear();
         if( m_bLongFmt )
-            pAttrList->AddAttribute( "number:style", "long" );
-        pStrm->StartElement( "number:hours" );
-        pStrm->EndElement( "number:hours" );
+            pAttrList->AddAttribute( u"number:style"_ustr, u"long"_ustr );
+        pStrm->StartElement( u"number:hours"_ustr );
+        pStrm->EndElement( u"number:hours"_ustr );
         break;
     case enumXFDateMinute:
         pAttrList->Clear();
         if( m_bLongFmt )
-            pAttrList->AddAttribute( "number:style", "long" );
+            pAttrList->AddAttribute( u"number:style"_ustr, u"long"_ustr );
         if( m_nDecimalPos>0 )
-            pAttrList->AddAttribute( "number:decimal-places", OUString::number(m_nDecimalPos) );
+            pAttrList->AddAttribute( u"number:decimal-places"_ustr, OUString::number(m_nDecimalPos) );
 
-        pStrm->StartElement( "number:minutes" );
-        pStrm->EndElement( "number:minutes" );
+        pStrm->StartElement( u"number:minutes"_ustr );
+        pStrm->EndElement( u"number:minutes"_ustr );
         break;
     case enumXFDateSecond:
         pAttrList->Clear();
         if( m_bLongFmt )
-            pAttrList->AddAttribute( "number:style", "long" );
-        pStrm->StartElement( "number:seconds" );
-        pStrm->EndElement( "number:seconds" );
+            pAttrList->AddAttribute( u"number:style"_ustr, u"long"_ustr );
+        pStrm->StartElement( u"number:seconds"_ustr );
+        pStrm->EndElement( u"number:seconds"_ustr );
         break;
     case enumXFDateText:
         pAttrList->Clear();
-        pStrm->StartElement( "number:text" );
+        pStrm->StartElement( u"number:text"_ustr );
         pStrm->Characters( m_strText );
-        pStrm->EndElement( "number:text" );
+        pStrm->EndElement( u"number:text"_ustr );
         break;
     default:
         break;
@@ -127,13 +127,13 @@ void    XFTimeStyle::ToXml(IXFStream *pStrm)
     IXFAttrList *pAttrList = pStrm->GetAttrList();
 
     pAttrList->Clear();
-    pAttrList->AddAttribute( "style:name", GetStyleName() );
+    pAttrList->AddAttribute( u"style:name"_ustr, GetStyleName() );
     if( !GetParentStyleName().isEmpty() )
-        pAttrList->AddAttribute("style:parent-style-name",GetParentStyleName());
-    pAttrList->AddAttribute( "style:family", "data-style" );
+        pAttrList->AddAttribute(u"style:parent-style-name"_ustr,GetParentStyleName());
+    pAttrList->AddAttribute( u"style:family"_ustr, u"data-style"_ustr );
     if (!m_bTruncate)
-        pAttrList->AddAttribute( "number:truncate-on-overflow", "false" );
-    pStrm->StartElement( "number:time-style" );
+        pAttrList->AddAttribute( u"number:truncate-on-overflow"_ustr, u"false"_ustr );
+    pStrm->StartElement( u"number:time-style"_ustr );
 
     for (auto & part : m_aParts)
     {
@@ -142,9 +142,9 @@ void    XFTimeStyle::ToXml(IXFStream *pStrm)
     if( m_bAmPm )
     {
         pAttrList->Clear();
-        pStrm->StartElement( "number:am-pm" );
-        pStrm->EndElement( "number:am-pm" );
+        pStrm->StartElement( u"number:am-pm"_ustr );
+        pStrm->EndElement( u"number:am-pm"_ustr );
     }
-    pStrm->EndElement( "number:time-style" );
+    pStrm->EndElement( u"number:time-style"_ustr );
 }
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lotuswordpro/source/filter/xfilter/xfutil.cxx b/lotuswordpro/source/filter/xfilter/xfutil.cxx
index b396f2f6f1d3..f55b45232a08 100644
--- a/lotuswordpro/source/filter/xfilter/xfutil.cxx
+++ b/lotuswordpro/source/filter/xfilter/xfutil.cxx
@@ -91,41 +91,41 @@ OUString   GetUnderlineName(enumXFUnderline type)
     switch(type)
     {
     case enumXFUnderlineNone:
-        return "none";
+        return u"none"_ustr;
     case enumXFUnderlineSingle:
-        return "single";
+        return u"single"_ustr;
     case enumXFUnderlineDouble:
-        return "double";
+        return u"double"_ustr;
     case enumXFUnderlineDotted:
-        return "dotted";
+        return u"dotted"_ustr;
     case enumXFUnderlineDash:
-        return "dash";
+        return u"dash"_ustr;
     case enumXFUnderlineLongDash:
-        return "long-dash";
+        return u"long-dash"_ustr;
     case enumXFUnderlineDotDash:
-        return "dot-dash";
+        return u"dot-dash"_ustr;
     case enumXFUnderlineDotDotDash:
-        return "dot-dot-dash";
+        return u"dot-dot-dash"_ustr;
     case enumXFUnderlineWave:
-        return "wave";
+        return u"wave"_ustr;
     case enumXFUnderlineBold:
-        return "bold";
+        return u"bold"_ustr;
     case enumXFUnderlineBoldDotted:
-        return "bold-dotted";
+        return u"bold-dotted"_ustr;
     case enumXFUnderlineBoldDash:
-        return "bold-dash";
+        return u"bold-dash"_ustr;
     case enumXFUnderlineBoldLongDash:
-        return "bold-long-dash";
+        return u"bold-long-dash"_ustr;
     case enumXFUnderlineBoldDotDash:
-        return "bold-dot-dash";
+        return u"bold-dot-dash"_ustr;
     case enumXFUnderlineBoldDotDotDash:
-        return "bold-dot-dot-dash";
+        return u"bold-dot-dot-dash"_ustr;
     case enumXFUnderlineBoldWave:
-        return "bold-wave";
+        return u"bold-wave"_ustr;
     case enumXFUnderlineDoubleWave:
-        return "double-wave";
+        return u"double-wave"_ustr;
     case enumXFUnderlineSmallWave:
-        return "small-wave";
+        return u"small-wave"_ustr;
     }
     return OUString();
 }
@@ -135,15 +135,15 @@ OUString   GetCrossoutName(enumXFCrossout type)
     switch(type)
     {
     case enumXFCrossoutSignel:
-        return "single-line";
+        return u"single-line"_ustr;
     case enumXFCrossoutDouble:
-        return "double-line";
+        return u"double-line"_ustr;
     case enumXFCrossoutThick:
-        return "thick-line";
+        return u"thick-line"_ustr;
     case enumXFCrossoutSlash:
-        return "slash";
+        return u"slash"_ustr;
     case enumXFCrossoutX:
-        return "X";
+        return u"X"_ustr;
     default:
         break;
     }
@@ -154,13 +154,13 @@ OUString   GetTransformName(enumXFTransform type)
 {
     switch(type) {
     case enumXFTransformUpper:
-        return "uppercase";
+        return u"uppercase"_ustr;
     case enumXFTransformLower:
-        return "lowercase";
+        return u"lowercase"_ustr;
     case enumXFTransformCapitalize:
-        return "capitalize";
+        return u"capitalize"_ustr;
     case enumXFTransformSmallCaps:
-        return "small-caps";
+        return u"small-caps"_ustr;
     default:
         break;
     }
@@ -172,21 +172,21 @@ OUString   GetTextDirName(enumXFTextDir dir)
     switch(dir)
     {
     case enumXFTextDirLR:
-        return "lr";
+        return u"lr"_ustr;
     case enumXFTextDirLR_TB:
-        return "lr-tb";
+        return u"lr-tb"_ustr;
     case enumXFTextDirPage:
-        return "page";
+        return u"page"_ustr;
     case enumXFTextDirRL:
-        return "rl";
+        return u"rl"_ustr;
     case enumXFTextDirRL_TB:
-        return "rl-tb";
+        return u"rl-tb"_ustr;
     case enumXFTextDirTB:
-        return "tb";
+        return u"tb"_ustr;
     case enumXFTextDirTB_LR:
-        return "tb-lr";
+        return u"tb-lr"_ustr;
     case enumXFTextDirTB_RL:
-        return "tb-rl";
+        return u"tb-rl"_ustr;
     default:
         break;
     }
@@ -198,13 +198,13 @@ OUString   GetFrameXPos(enumXFFrameXPos pos)
     switch(pos)
     {
     case enumXFFrameXPosLeft:
-        return "left";
+        return u"left"_ustr;
     case enumXFFrameXPosRight:
-        return "right";
+        return u"right"_ustr;
     case enumXFFrameXPosCenter:
-        return "center";
+        return u"center"_ustr;
     case enumXFFrameXPosFromLeft:
-        return "from-left";
+        return u"from-left"_ustr;
     default:
         break;
     }
@@ -216,31 +216,31 @@ OUString   GetFrameXRel(enumXFFrameXRel rel)
     switch(rel)
     {
     case enumXFFrameXRelPage:
-        return "page";
+        return u"page"_ustr;
     case enumXFFrameXRelPageContent:
-        return "page-content";
+        return u"page-content"_ustr;
     case enumXFFrameXRelPageEndMargin:
-        return "page-end-margin";
+        return u"page-end-margin"_ustr;
     case enumXFFrameXRelPageStartMargin:
-        return "page-start-margin";
+        return u"page-start-margin"_ustr;
     case enumXFFrameXRelPara:
-        return "paragraph";
+        return u"paragraph"_ustr;
     case enumXFFrameXRelParaContent:
-        return "paragraph-content";
+        return u"paragraph-content"_ustr;
     case enumXFFrameXRelParaEndMargin:
-        return "paragraph-end-margin";
+        return u"paragraph-end-margin"_ustr;
     case enumXFFrameXRelParaStartMargin:
-        return "paragraph-start-margin";
+        return u"paragraph-start-margin"_ustr;
     case enumXFFrameXRelChar:
-        return "char";
+        return u"char"_ustr;
     case enumXFFrameXRelFrame:
-        return "frame";
+        return u"frame"_ustr;
     case enumXFFrameXRelFrameContent:
-        return "frame-content";
+        return u"frame-content"_ustr;
     case enumXFFrameXRelFrameEndMargin:
-        return "frame-end-margin";
+        return u"frame-end-margin"_ustr;
     case enumXFFrameXRelFrameStartMargin:
-        return "frame-start-margin";
+        return u"frame-start-margin"_ustr;
     default:
         break;
     }
@@ -252,15 +252,15 @@ OUString   GetFrameYPos(enumXFFrameYPos pos)
     switch(pos)
     {
     case enumXFFrameYPosTop:
-        return "top";
+        return u"top"_ustr;
     case enumXFFrameYPosMiddle:
-        return "middle";
+        return u"middle"_ustr;
     case enumXFFrameYPosBottom:
-        return "bottom";
+        return u"bottom"_ustr;
     case enumXFFrameYPosFromTop:
-        return "from-top";
+        return u"from-top"_ustr;
     case enumXFFrameYPosBelow:
-        return "below";
+        return u"below"_ustr;
     }
     return OUString();
 }
@@ -270,25 +270,25 @@ OUString   GetFrameYRel(enumXFFrameYRel rel)
     switch(rel)
     {
     case enumXFFrameYRelBaseLine:
-        return "baseline";
+        return u"baseline"_ustr;
     case enumXFFrameYRelChar:
-        return "char";
+        return u"char"_ustr;
     case enumXFFrameYRelFrame:
-        return "frame";
+        return u"frame"_ustr;
     case enumXFFrameYRelFrameContent:
-        return "frame-content";
+        return u"frame-content"_ustr;
     case enumXFFrameYRelLine:
-        return "line";
+        return u"line"_ustr;
     case enumXFFrameYRelPage:
-        return "page";
+        return u"page"_ustr;
     case enumXFFrameYRelPageContent:
-        return "page-content";
+        return u"page-content"_ustr;
     case enumXFFrameYRelPara:
-        return "paragraph";
+        return u"paragraph"_ustr;
     case enumXFFrameYRelParaContent:
-        return "paragraph-content";
+        return u"paragraph-content"_ustr;
     case enumXFFrameYRelText:
-        return "text";
+        return u"text"_ustr;
     }
     return OUString();
 }
@@ -296,21 +296,21 @@ OUString   GetFrameYRel(enumXFFrameYRel rel)
 OUString   GetAlignName(enumXFAlignType align)
 {
     if( align == enumXFAlignStart )
-        return "start";
+        return u"start"_ustr;
     else if( align == enumXFAlignCenter )
-        return "center";
+        return u"center"_ustr;
     else if( align == enumXFAlignEnd )
-        return "end";
+        return u"end"_ustr;
     else if( align == enumXFAlignJustify )
-        return "justify";
+        return u"justify"_ustr;
     else if( align == enumXFAlignBottom )
-        return "bottom";
+        return u"bottom"_ustr;
     else if( align == enumXFAlignTop )
-        return "top";
+        return u"top"_ustr;
     else if( align == enumXFAlignMiddle )
-        return "middle";
+        return u"middle"_ustr;
     else if( align == enumXFALignMargins )
-        return "margins";
+        return u"margins"_ustr;
 
     return OUString();
 }
@@ -377,13 +377,13 @@ OUString   GetColorMode(enumXFColorMode mode)
     switch(mode)
     {
     case enumXFColorStandard:
-        return "standard";
+        return u"standard"_ustr;
     case enumXFColorGreyscale:
-        return "greyscale";
+        return u"greyscale"_ustr;
     case enumXFColorWatermark:
-        return "watermark";
+        return u"watermark"_ustr;
     case enumXFColorMono:
-        return "mono";
+        return u"mono"_ustr;
     }
     return OUString();
 }
author	Noel Grandin <noel.grandin@collabora.co.uk>	2024-05-10 08:25:57 +0200
committer	Noel Grandin <noel.grandin@collabora.co.uk>	2024-05-10 09:51:45 +0200
commit	e00f6e0b9df5ef8629738b551def2464d9a8e2ed (patch)
tree	88c2e2c173a35f18aeebb6dbc6a6fcced81c98e7
parent	239ceb315521d9e88fb8290ba391c70a53095af4 (diff)