diff --git a/drawinglayer/qa/unit/vclmetafileprocessor2d.cxx b/drawinglayer/qa/unit/vclmetafileprocessor2d.cxx
index e5b5ed3cfc8a..262e50b97290 100644
--- a/drawinglayer/qa/unit/vclmetafileprocessor2d.cxx
+++ b/drawinglayer/qa/unit/vclmetafileprocessor2d.cxx
@@ -131,7 +131,7 @@ public:
             cppCanvas, metafile, cppcanvas::Renderer::Parameters());
         renderer->setTransformation(basegfx::B2DHomMatrix(14548, 0, -2, 0, 3350, 3431));
         CPPUNIT_ASSERT(renderer->draw());
-        exportDevice("test-tdf136957", mVclDevice);
+        exportDevice(u"test-tdf136957"_ustr, mVclDevice);
         Bitmap bitmap = mVclDevice->GetBitmap(Point(), Size(1920, 1080));
         BitmapScopedReadAccess access(bitmap);
         // There should be a dotted line, without the fix it wouldn't be there, so check
diff --git a/drawinglayer/qa/unit/vclpixelprocessor2d.cxx b/drawinglayer/qa/unit/vclpixelprocessor2d.cxx
index c132d0927408..209d4273120e 100644
--- a/drawinglayer/qa/unit/vclpixelprocessor2d.cxx
+++ b/drawinglayer/qa/unit/vclpixelprocessor2d.cxx
@@ -115,7 +115,7 @@ public:
         };
         processor->process(primitives);
 
-        exportDevice("test-tdf139000.png", device);
+        exportDevice(u"test-tdf139000.png"_ustr, device);
         Bitmap bitmap = device->GetBitmap(Point(), device->GetOutputSizePixel());
         BitmapScopedReadAccess access(bitmap);
         // The upper half should keep its red background color.
diff --git a/drawinglayer/source/drawinglayeruno/xprimitive2drenderer.cxx b/drawinglayer/source/drawinglayeruno/xprimitive2drenderer.cxx
index 22a20f095d24..0fea457deab3 100644
--- a/drawinglayer/source/drawinglayeruno/xprimitive2drenderer.cxx
+++ b/drawinglayer/source/drawinglayeruno/xprimitive2drenderer.cxx
@@ -83,7 +83,7 @@ namespace drawinglayer::unorenderer
         {
             o3tl::Length eRangeUnit = o3tl::Length::mm100;
             comphelper::SequenceAsHashMap aViewInformationMap(aViewInformationSequence);
-            auto it = aViewInformationMap.find("RangeUnit");
+            auto it = aViewInformationMap.find(u"RangeUnit"_ustr);
             if (it != aViewInformationMap.end())
             {
                 sal_Int32 nVal{};
@@ -165,7 +165,7 @@ namespace drawinglayer::unorenderer
 
         OUString SAL_CALL XPrimitive2DRenderer::getImplementationName()
         {
-            return "drawinglayer::unorenderer::XPrimitive2DRenderer";
+            return u"drawinglayer::unorenderer::XPrimitive2DRenderer"_ustr;
         }
 
         sal_Bool SAL_CALL XPrimitive2DRenderer::supportsService(const OUString& rServiceName)
@@ -175,7 +175,7 @@ namespace drawinglayer::unorenderer
 
         uno::Sequence< OUString > SAL_CALL XPrimitive2DRenderer::getSupportedServiceNames()
         {
-            return { "com.sun.star.graphic.Primitive2DTools" };
+            return { u"com.sun.star.graphic.Primitive2DTools"_ustr };
         }
 
 } // end of namespace
diff --git a/drawinglayer/source/dumper/EnhancedShapeDumper.cxx b/drawinglayer/source/dumper/EnhancedShapeDumper.cxx
index 6e83f15db044..333bf4bff7c7 100644
--- a/drawinglayer/source/dumper/EnhancedShapeDumper.cxx
+++ b/drawinglayer/source/dumper/EnhancedShapeDumper.cxx
@@ -19,139 +19,139 @@ using namespace com::sun::star;
 void EnhancedShapeDumper::dumpEnhancedCustomShapeExtrusionService(const uno::Reference< beans::XPropertySet >& xPropSet)
 {
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("Extrusion");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"Extrusion"_ustr);
         bool bExtrusion;
         if(anotherAny >>= bExtrusion)
             dumpExtrusionAsAttribute(bExtrusion);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("Brightness");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"Brightness"_ustr);
         double aBrightness = double();
         if(anotherAny >>= aBrightness)
             dumpBrightnessAsAttribute(aBrightness);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("Depth");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"Depth"_ustr);
         drawing::EnhancedCustomShapeParameterPair aDepth;
         if(anotherAny >>= aDepth)
             dumpDepthAsElement(aDepth);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("Diffusion");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"Diffusion"_ustr);
         double aDiffusion = double();
         if(anotherAny >>= aDiffusion)
             dumpDiffusionAsAttribute(aDiffusion);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("NumberOfLineSegments");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"NumberOfLineSegments"_ustr);
         sal_Int32 aNumberOfLineSegments = sal_Int32();
         if(anotherAny >>= aNumberOfLineSegments)
             dumpNumberOfLineSegmentsAsAttribute(aNumberOfLineSegments);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("LightFace");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"LightFace"_ustr);
         bool bLightFace;
         if(anotherAny >>= bLightFace)
             dumpLightFaceAsAttribute(bLightFace);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("FirstLightHarsh");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"FirstLightHarsh"_ustr);
         bool bFirstLightHarsh;
         if(anotherAny >>= bFirstLightHarsh)
             dumpFirstLightHarshAsAttribute(bFirstLightHarsh);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("SecondLightHarsh");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"SecondLightHarsh"_ustr);
         bool bSecondLightHarsh;
         if(anotherAny >>= bSecondLightHarsh)
             dumpSecondLightHarshAsAttribute(bSecondLightHarsh);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("FirstLightLevel");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"FirstLightLevel"_ustr);
         double aFirstLightLevel = double();
         if(anotherAny >>= aFirstLightLevel)
             dumpFirstLightLevelAsAttribute(aFirstLightLevel);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("SecondLightLevel");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"SecondLightLevel"_ustr);
         double aSecondLightLevel = double();
         if(anotherAny >>= aSecondLightLevel)
             dumpSecondLightLevelAsAttribute(aSecondLightLevel);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("FirstLightDirection");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"FirstLightDirection"_ustr);
         drawing::Direction3D aFirstLightDirection;
         if(anotherAny >>= aFirstLightDirection)
             dumpFirstLightDirectionAsElement(aFirstLightDirection);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("SecondLightDirection");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"SecondLightDirection"_ustr);
         drawing::Direction3D aSecondLightDirection;
         if(anotherAny >>= aSecondLightDirection)
             dumpSecondLightDirectionAsElement(aSecondLightDirection);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("Metal");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"Metal"_ustr);
         bool bMetal;
         if(anotherAny >>= bMetal)
             dumpMetalAsAttribute(bMetal);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("ShadeMode");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"ShadeMode"_ustr);
         drawing::ShadeMode eShadeMode;
         if(anotherAny >>= eShadeMode)
             dumpShadeModeAsAttribute(eShadeMode);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("RotateAngle");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"RotateAngle"_ustr);
         drawing::EnhancedCustomShapeParameterPair aRotateAngle;
         if(anotherAny >>= aRotateAngle)
             dumpRotateAngleAsElement(aRotateAngle);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("RotationCenter");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"RotationCenter"_ustr);
         drawing::Direction3D aRotationCenter;
         if(anotherAny >>= aRotationCenter)
             dumpRotationCenterAsElement(aRotationCenter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("Shininess");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"Shininess"_ustr);
         double aShininess = double();
         if(anotherAny >>= aShininess)
             dumpShininessAsAttribute(aShininess);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("Skew");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"Skew"_ustr);
         drawing::EnhancedCustomShapeParameterPair aSkew;
         if(anotherAny >>= aSkew)
             dumpSkewAsElement(aSkew);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("Specularity");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"Specularity"_ustr);
         double aSpecularity = double();
         if(anotherAny >>= aSpecularity)
             dumpSpecularityAsAttribute(aSpecularity);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("ProjectionMode");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"ProjectionMode"_ustr);
         drawing::ProjectionMode eProjectionMode;
         if(anotherAny >>= eProjectionMode)
             dumpProjectionModeAsAttribute(eProjectionMode);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("ViewPoint");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"ViewPoint"_ustr);
         drawing::Position3D aViewPoint;
         if(anotherAny >>= aViewPoint)
             dumpViewPointAsElement(aViewPoint);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("Origin");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"Origin"_ustr);
         drawing::EnhancedCustomShapeParameterPair aOrigin;
         if(anotherAny >>= aOrigin)
             dumpOriginAsElement(aOrigin);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("ExtrusionColor");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"ExtrusionColor"_ustr);
         bool bExtrusionColor;
         if(anotherAny >>= bExtrusionColor)
             dumpExtrusionColorAsAttribute(bExtrusionColor);
@@ -363,67 +363,67 @@ void EnhancedShapeDumper::dumpExtrusionColorAsAttribute(bool bExtrusionColor)
 void EnhancedShapeDumper::dumpEnhancedCustomShapeGeometryService(const uno::Reference< beans::XPropertySet >& xPropSet)
 {
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("Type");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"Type"_ustr);
         OUString sType;
         if(anotherAny >>= sType)
             dumpTypeAsAttribute(sType);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("ViewBox");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"ViewBox"_ustr);
         awt::Rectangle aViewBox;
         if(anotherAny >>= aViewBox)
             dumpViewBoxAsElement(aViewBox);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("MirroredX");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"MirroredX"_ustr);
         bool bMirroredX;
         if(anotherAny >>= bMirroredX)
             dumpMirroredXAsAttribute(bMirroredX);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("MirroredY");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"MirroredY"_ustr);
         bool bMirroredY;
         if(anotherAny >>= bMirroredY)
             dumpMirroredYAsAttribute(bMirroredY);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("TextRotateAngle");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"TextRotateAngle"_ustr);
         double aTextRotateAngle = double();
         if(anotherAny >>= aTextRotateAngle)
             dumpTextRotateAngleAsAttribute(aTextRotateAngle);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("AdjustmentValues");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"AdjustmentValues"_ustr);
         uno::Sequence< drawing::EnhancedCustomShapeAdjustmentValue> aAdjustmentValues;
         if(anotherAny >>= aAdjustmentValues)
             dumpAdjustmentValuesAsElement(aAdjustmentValues);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("Extrusion");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"Extrusion"_ustr);
         uno::Sequence< beans::PropertyValue > aExtrusion;
         if(anotherAny >>= aExtrusion)
             dumpExtrusionAsElement(aExtrusion);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("Path");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"Path"_ustr);
         uno::Sequence< beans::PropertyValue > aPath;
         if(anotherAny >>= aPath)
             dumpPathAsElement(aPath);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("TextPath");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"TextPath"_ustr);
         uno::Sequence< beans::PropertyValue > aTextPath;
         if(anotherAny >>= aTextPath)
             dumpTextPathAsElement(aTextPath);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("Equations");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"Equations"_ustr);
         uno::Sequence< OUString > aEquations;
         if(anotherAny >>= aEquations)
             dumpEquationsAsElement(aEquations);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("Handles");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"Handles"_ustr);
         uno::Sequence< beans::PropertyValues > aHandles;
         if(anotherAny >>= aHandles)
             dumpHandlesAsElement(aHandles);
@@ -613,91 +613,91 @@ void EnhancedShapeDumper::dumpHandlesAsElement(const uno::Sequence< beans::Prope
 void EnhancedShapeDumper::dumpEnhancedCustomShapeHandleService(const uno::Reference< beans::XPropertySet >& xPropSet)
 {
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("MirroredX");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"MirroredX"_ustr);
         bool bMirroredX;
         if(anotherAny >>= bMirroredX)
             dumpMirroredXAsAttribute(bMirroredX);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("MirroredY");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"MirroredY"_ustr);
         bool bMirroredY;
         if(anotherAny >>= bMirroredY)
             dumpMirroredYAsAttribute(bMirroredY);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("Switched");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"Switched"_ustr);
         bool bSwitched;
         if(anotherAny >>= bSwitched)
             dumpSwitchedAsAttribute(bSwitched);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("Position");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"Position"_ustr);
         drawing::EnhancedCustomShapeParameterPair aPosition;
         if(anotherAny >>= aPosition)
             dumpPositionAsElement(aPosition);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("Polar");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"Polar"_ustr);
         drawing::EnhancedCustomShapeParameterPair aPolar;
         if(anotherAny >>= aPolar)
             dumpPolarAsElement(aPolar);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("RefX");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"RefX"_ustr);
         sal_Int32 aRefX = sal_Int32();
         if(anotherAny >>= aRefX)
             dumpRefXAsAttribute(aRefX);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("RefY");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"RefY"_ustr);
         sal_Int32 aRefY = sal_Int32();
         if(anotherAny >>= aRefY)
             dumpRefYAsAttribute(aRefY);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("RefAngle");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"RefAngle"_ustr);
         sal_Int32 aRefAngle = sal_Int32();
         if(anotherAny >>= aRefAngle)
             dumpRefAngleAsAttribute(aRefAngle);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("RefR");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"RefR"_ustr);
         sal_Int32 aRefR = sal_Int32();
         if(anotherAny >>= aRefR)
             dumpRefRAsAttribute(aRefR);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("RangeXMinimum");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"RangeXMinimum"_ustr);
         drawing::EnhancedCustomShapeParameter aRangeXMinimum;
         if(anotherAny >>= aRangeXMinimum)
             dumpRangeXMinimumAsElement(aRangeXMinimum);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("RangeXMaximum");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"RangeXMaximum"_ustr);
         drawing::EnhancedCustomShapeParameter aRangeXMaximum;
         if(anotherAny >>= aRangeXMaximum)
             dumpRangeXMaximumAsElement(aRangeXMaximum);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("RangeYMinimum");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"RangeYMinimum"_ustr);
         drawing::EnhancedCustomShapeParameter aRangeYMinimum;
         if(anotherAny >>= aRangeYMinimum)
             dumpRangeYMinimumAsElement(aRangeYMinimum);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("RangeYMaximum");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"RangeYMaximum"_ustr);
         drawing::EnhancedCustomShapeParameter aRangeYMaximum;
         if(anotherAny >>= aRangeYMaximum)
             dumpRangeYMaximumAsElement(aRangeYMaximum);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("RadiusRangeMinimum");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"RadiusRangeMinimum"_ustr);
         drawing::EnhancedCustomShapeParameter aRadiusRangeMinimum;
         if(anotherAny >>= aRadiusRangeMinimum)
             dumpRadiusRangeMinimumAsElement(aRadiusRangeMinimum);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("RadiusRangeMaximum");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"RadiusRangeMaximum"_ustr);
         drawing::EnhancedCustomShapeParameter aRadiusRangeMaximum;
         if(anotherAny >>= aRadiusRangeMaximum)
             dumpRadiusRangeMaximumAsElement(aRadiusRangeMaximum);
@@ -824,73 +824,73 @@ void EnhancedShapeDumper::dumpRadiusRangeMaximumAsElement(const drawing::Enhance
 void EnhancedShapeDumper::dumpEnhancedCustomShapePathService(const uno::Reference< beans::XPropertySet >& xPropSet)
 {
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("Coordinates");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"Coordinates"_ustr);
         uno::Sequence< drawing::EnhancedCustomShapeParameterPair > aCoordinates;
         if(anotherAny >>= aCoordinates)
             dumpCoordinatesAsElement(aCoordinates);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("Segments");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"Segments"_ustr);
         uno::Sequence< drawing::EnhancedCustomShapeSegment > aSegments;
         if(anotherAny >>= aSegments)
             dumpSegmentsAsElement(aSegments);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("StretchX");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"StretchX"_ustr);
         sal_Int32 aStretchX = sal_Int32();
         if(anotherAny >>= aStretchX)
             dumpStretchXAsAttribute(aStretchX);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("StretchY");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"StretchY"_ustr);
         sal_Int32 aStretchY = sal_Int32();
         if(anotherAny >>= aStretchY)
             dumpStretchYAsAttribute(aStretchY);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("TextFrames");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"TextFrames"_ustr);
         uno::Sequence< drawing::EnhancedCustomShapeTextFrame > aTextFrames;
         if(anotherAny >>= aTextFrames)
             dumpTextFramesAsElement(aTextFrames);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("GluePoints");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"GluePoints"_ustr);
         uno::Sequence< drawing::EnhancedCustomShapeParameterPair > aGluePoints;
         if(anotherAny >>= aGluePoints)
             dumpGluePointsAsElement(aGluePoints);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("GluePointLeavingDirections");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"GluePointLeavingDirections"_ustr);
         uno::Sequence< double > aGluePointLeavingDirections;
         if(anotherAny >>= aGluePointLeavingDirections)
             dumpGluePointLeavingDirectionsAsElement(aGluePointLeavingDirections);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("GluePointType");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"GluePointType"_ustr);
         sal_Int32 aGluePointType = sal_Int32();
         if(anotherAny >>= aGluePointType)
             dumpGluePointTypeAsAttribute(aGluePointType);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("ExtrusionAllowed");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"ExtrusionAllowed"_ustr);
         bool bExtrusionAllowed;
         if(anotherAny >>= bExtrusionAllowed)
             dumpExtrusionAllowedAsAttribute(bExtrusionAllowed);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("ConcentricGradientFillAllowed");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"ConcentricGradientFillAllowed"_ustr);
         bool bConcentricGradientFillAllowed;
         if(anotherAny >>= bConcentricGradientFillAllowed)
             dumpConcentricGradientFillAllowedAsAttribute(bConcentricGradientFillAllowed);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("TextPathAllowed");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"TextPathAllowed"_ustr);
         bool bTextPathAllowed;
         if(anotherAny >>= bTextPathAllowed)
             dumpTextPathAllowedAsAttribute(bTextPathAllowed);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("SubViewSize");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"SubViewSize"_ustr);
         uno::Sequence< awt::Size > aSubViewSize;
         if(anotherAny >>= aSubViewSize)
             dumpSubViewSizeAsElement(aSubViewSize);
@@ -1025,19 +1025,19 @@ void EnhancedShapeDumper::dumpSubViewSizeAsElement(const uno::Sequence< awt::Siz
 void EnhancedShapeDumper::dumpEnhancedCustomShapeTextPathService(const uno::Reference< beans::XPropertySet >& xPropSet)
 {
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("TextPath");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"TextPath"_ustr);
         bool bTextPath;
         if(anotherAny >>= bTextPath)
             dumpTextPathAsAttribute(bTextPath);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("TextPathMode");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"TextPathMode"_ustr);
         drawing::EnhancedCustomShapeTextPathMode eTextPathMode;
         if(anotherAny >>= eTextPathMode)
             dumpTextPathModeAsAttribute(eTextPathMode);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("ScaleX");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"ScaleX"_ustr);
         bool bScaleX;
         if(anotherAny >>= bScaleX)
             dumpScaleXAsAttribute(bScaleX);
diff --git a/drawinglayer/source/dumper/XShapeDumper.cxx b/drawinglayer/source/dumper/XShapeDumper.cxx
index cf0da17e4398..61428d16e19c 100644
--- a/drawinglayer/source/dumper/XShapeDumper.cxx
+++ b/drawinglayer/source/dumper/XShapeDumper.cxx
@@ -1228,157 +1228,157 @@ void dumpCustomShapeReplacementURLAsAttribute(std::u16string_view sCustomShapeRe
 void dumpTextPropertiesService(const uno::Reference< beans::XPropertySet >& xPropSet, xmlTextWriterPtr xmlWriter)
 {
     uno::Reference< beans::XPropertySetInfo> xInfo = xPropSet->getPropertySetInfo();
-    if(xInfo->hasPropertyByName("CharHeight"))
+    if(xInfo->hasPropertyByName(u"CharHeight"_ustr))
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("CharHeight");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"CharHeight"_ustr);
         float fHeight;
         if(anotherAny >>= fHeight)
             dumpCharHeightAsAttribute(fHeight, xmlWriter);
     }
-    if(xInfo->hasPropertyByName("CharColor"))
+    if(xInfo->hasPropertyByName(u"CharColor"_ustr))
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("CharColor");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"CharColor"_ustr);
         sal_Int32 aColor = sal_Int32();
         if(anotherAny >>= aColor)
             dumpCharColorAsAttribute(aColor, xmlWriter);
     }
     // TODO - more properties from CharacterProperties.idl (similar to above)
 
-    if(xInfo->hasPropertyByName("IsNumbering"))
+    if(xInfo->hasPropertyByName(u"IsNumbering"_ustr))
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("IsNumbering");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"IsNumbering"_ustr);
         bool bIsNumbering;
         if(anotherAny >>= bIsNumbering)
             dumpIsNumberingAsAttribute(bIsNumbering, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("TextAutoGrowHeight");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"TextAutoGrowHeight"_ustr);
         bool bTextAutoGrowHeight;
         if(anotherAny >>= bTextAutoGrowHeight)
             dumpTextAutoGrowHeightAsAttribute(bTextAutoGrowHeight, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("TextAutoGrowWidth");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"TextAutoGrowWidth"_ustr);
         bool bTextAutoGrowWidth;
         if(anotherAny >>= bTextAutoGrowWidth)
             dumpTextAutoGrowWidthAsAttribute(bTextAutoGrowWidth, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("TextContourFrame");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"TextContourFrame"_ustr);
         bool bTextContourFrame;
         if(anotherAny >>= bTextContourFrame)
             dumpTextContourFrameAsAttribute(bTextContourFrame, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("TextFitToSize");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"TextFitToSize"_ustr);
         drawing::TextFitToSizeType eTextFitToSize;
         if(anotherAny >>= eTextFitToSize)
             dumpTextFitToSizeAsAttribute(eTextFitToSize, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("TextHorizontalAdjust");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"TextHorizontalAdjust"_ustr);
         drawing::TextHorizontalAdjust eTextHorizontalAdjust;
         if(anotherAny >>= eTextHorizontalAdjust)
             dumpTextHorizontalAdjustAsAttribute(eTextHorizontalAdjust, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("TextVerticalAdjust");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"TextVerticalAdjust"_ustr);
         drawing::TextVerticalAdjust eTextVerticalAdjust;
         if(anotherAny >>= eTextVerticalAdjust)
             dumpTextVerticalAdjustAsAttribute(eTextVerticalAdjust, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("TextLeftDistance");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"TextLeftDistance"_ustr);
         sal_Int32 aTextLeftDistance = sal_Int32();
         if(anotherAny >>= aTextLeftDistance)
             dumpTextLeftDistanceAsAttribute(aTextLeftDistance, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("TextRightDistance");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"TextRightDistance"_ustr);
         sal_Int32 aTextRightDistance = sal_Int32();
         if(anotherAny >>= aTextRightDistance)
             dumpTextRightDistanceAsAttribute(aTextRightDistance, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("TextUpperDistance");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"TextUpperDistance"_ustr);
         sal_Int32 aTextUpperDistance = sal_Int32();
         if(anotherAny >>= aTextUpperDistance)
             dumpTextUpperDistanceAsAttribute(aTextUpperDistance, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("TextLowerDistance");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"TextLowerDistance"_ustr);
         sal_Int32 aTextLowerDistance = sal_Int32();
         if(anotherAny >>= aTextLowerDistance)
             dumpTextLowerDistanceAsAttribute(aTextLowerDistance, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("TextMaximumFrameHeight");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"TextMaximumFrameHeight"_ustr);
         sal_Int32 aTextMaximumFrameHeight = sal_Int32();
         if(anotherAny >>= aTextMaximumFrameHeight)
             dumpTextMaximumFrameHeightAsAttribute(aTextMaximumFrameHeight, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("TextMaximumFrameWidth");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"TextMaximumFrameWidth"_ustr);
         sal_Int32 aTextMaximumFrameWidth = sal_Int32();
         if(anotherAny >>= aTextMaximumFrameWidth)
             dumpTextMaximumFrameWidthAsAttribute(aTextMaximumFrameWidth, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("TextMinimumFrameHeight");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"TextMinimumFrameHeight"_ustr);
         sal_Int32 aTextMinimumFrameHeight = sal_Int32();
         if(anotherAny >>= aTextMinimumFrameHeight)
             dumpTextMinimumFrameHeightAsAttribute(aTextMinimumFrameHeight, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("TextMinimumFrameWidth");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"TextMinimumFrameWidth"_ustr);
         sal_Int32 aTextMinimumFrameWidth = sal_Int32();
         if(anotherAny >>= aTextMinimumFrameWidth)
             dumpTextMinimumFrameWidthAsAttribute(aTextMinimumFrameWidth, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("TextAnimationAmount");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"TextAnimationAmount"_ustr);
         sal_Int32 aTextAnimationAmount = sal_Int32();
         if(anotherAny >>= aTextAnimationAmount)
             dumpTextAnimationAmountAsAttribute(aTextAnimationAmount, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("TextAnimationCount");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"TextAnimationCount"_ustr);
         sal_Int32 aTextAnimationCount = sal_Int32();
         if(anotherAny >>= aTextAnimationCount)
             dumpTextAnimationCountAsAttribute(aTextAnimationCount, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("TextAnimationDelay");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"TextAnimationDelay"_ustr);
         sal_Int32 aTextAnimationDelay = sal_Int32();
         if(anotherAny >>= aTextAnimationDelay)
             dumpTextAnimationDelayAsAttribute(aTextAnimationDelay, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("TextAnimationDirection");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"TextAnimationDirection"_ustr);
         drawing::TextAnimationDirection eTextAnimationDirection;
         if(anotherAny >>= eTextAnimationDirection)
             dumpTextAnimationDirectionAsAttribute(eTextAnimationDirection, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("TextAnimationKind");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"TextAnimationKind"_ustr);
         drawing::TextAnimationKind eTextAnimationKind;
         if(anotherAny >>= eTextAnimationKind)
             dumpTextAnimationKindAsAttribute(eTextAnimationKind, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("TextAnimationStartInside");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"TextAnimationStartInside"_ustr);
         bool bTextAnimationStartInside;
         if(anotherAny >>= bTextAnimationStartInside)
             dumpTextAnimationStartInsideAsAttribute(bTextAnimationStartInside, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("TextAnimationStopInside");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"TextAnimationStopInside"_ustr);
         bool bTextAnimationStopInside;
         if(anotherAny >>= bTextAnimationStopInside)
             dumpTextAnimationStopInsideAsAttribute(bTextAnimationStopInside, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("TextWritingMode");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"TextWritingMode"_ustr);
         text::WritingMode eTextWritingMode;
         if(anotherAny >>= eTextWritingMode)
             dumpTextWritingModeAsAttribute(eTextWritingMode, xmlWriter);
@@ -1388,139 +1388,139 @@ void dumpTextPropertiesService(const uno::Reference< beans::XPropertySet >& xPro
 void dumpFillPropertiesService(const uno::Reference< beans::XPropertySet >& xPropSet, xmlTextWriterPtr xmlWriter)
 {
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("FillStyle");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"FillStyle"_ustr);
         drawing::FillStyle eFillStyle;
         if(anotherAny >>= eFillStyle)
             dumpFillStyleAsAttribute(eFillStyle, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("FillColor");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"FillColor"_ustr);
         sal_Int32 aColor = sal_Int32();
         if(anotherAny >>= aColor)
             dumpFillColorAsAttribute(aColor, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("FillTransparence");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"FillTransparence"_ustr);
         sal_Int32 aTransparence = sal_Int32();
         if(anotherAny >>= aTransparence)
             dumpFillTransparenceAsAttribute(aTransparence, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("FillTransparenceGradientName");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"FillTransparenceGradientName"_ustr);
         OUString sTranspGradName;
         if(anotherAny >>= sTranspGradName)
             dumpFillTransparenceGradientNameAsAttribute(sTranspGradName, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("FillTransparenceGradient");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"FillTransparenceGradient"_ustr);
         awt::Gradient aTranspGrad;
         if(anotherAny >>= aTranspGrad)
             dumpFillTransparenceGradientAsElement(aTranspGrad, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("FillGradientName");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"FillGradientName"_ustr);
         OUString sGradName;
         if(anotherAny >>= sGradName)
             dumpFillGradientNameAsAttribute(sGradName, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("FillGradient");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"FillGradient"_ustr);
         awt::Gradient aGradient;
         if(anotherAny >>= aGradient)
             dumpFillGradientAsElement(aGradient, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("FillHatchName");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"FillHatchName"_ustr);
         OUString sHatchName;
         if(anotherAny >>= sHatchName)
             dumpFillGradientNameAsAttribute(sHatchName, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("FillHatch");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"FillHatch"_ustr);
         drawing::Hatch aHatch;
         if(anotherAny >>= aHatch)
             dumpFillHatchAsElement(aHatch, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("FillBackground");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"FillBackground"_ustr);
         bool bFillBackground;
         if(anotherAny >>= bFillBackground)
             dumpFillBackgroundAsAttribute(bFillBackground, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("FillBitmapName");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"FillBitmapName"_ustr);
         OUString sBitmapName;
         if(anotherAny >>= sBitmapName)
             dumpFillGradientNameAsAttribute(sBitmapName, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("FillBitmap");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"FillBitmap"_ustr);
         uno::Reference<awt::XBitmap> xBitmap;
         if(anotherAny >>= xBitmap)
             dumpFillBitmapAsElement(xBitmap, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("FillBitmapPositionOffsetX");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"FillBitmapPositionOffsetX"_ustr);
         sal_Int32 aBitmapPositionOffsetX = sal_Int32();
         if(anotherAny >>= aBitmapPositionOffsetX)
             dumpFillBitmapPositionOffsetXAsAttribute(aBitmapPositionOffsetX, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("FillBitmapPositionOffsetY");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"FillBitmapPositionOffsetY"_ustr);
         sal_Int32 aBitmapPositionOffsetY = sal_Int32();
         if(anotherAny >>= aBitmapPositionOffsetY)
             dumpFillBitmapPositionOffsetYAsAttribute(aBitmapPositionOffsetY, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("FillBitmapOffsetX");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"FillBitmapOffsetX"_ustr);
         sal_Int32 aBitmapOffsetX = sal_Int32();
         if(anotherAny >>= aBitmapOffsetX)
             dumpFillBitmapOffsetXAsAttribute(aBitmapOffsetX, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("FillBitmapOffsetY");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"FillBitmapOffsetY"_ustr);
         sal_Int32 aBitmapOffsetY = sal_Int32();
         if(anotherAny >>= aBitmapOffsetY)
             dumpFillBitmapOffsetYAsAttribute(aBitmapOffsetY, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("FillBitmapRectanglePoint");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"FillBitmapRectanglePoint"_ustr);
         drawing::RectanglePoint eBitmapRectanglePoint;
         if(anotherAny >>= eBitmapRectanglePoint)
             dumpFillBitmapRectanglePointAsAttribute(eBitmapRectanglePoint, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("FillBitmapLogicalSize");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"FillBitmapLogicalSize"_ustr);
         bool bBitmapLogicalSize;
         if(anotherAny >>= bBitmapLogicalSize)
             dumpFillBitmapLogicalSizeAsAttribute(bBitmapLogicalSize, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("FillBitmapSizeX");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"FillBitmapSizeX"_ustr);
         sal_Int32 aBitmapSizeX = sal_Int32();
         if(anotherAny >>= aBitmapSizeX)
             dumpFillBitmapSizeXAsAttribute(aBitmapSizeX, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("FillBitmapSizeY");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"FillBitmapSizeY"_ustr);
         sal_Int32 aBitmapSizeY = sal_Int32();
         if(anotherAny >>= aBitmapSizeY)
             dumpFillBitmapSizeYAsAttribute(aBitmapSizeY, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("FillBitmapMode");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"FillBitmapMode"_ustr);
         drawing::BitmapMode eBitmapMode;
         if(anotherAny >>= eBitmapMode)
             dumpFillBitmapModeAsAttribute(eBitmapMode, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("FillBitmapStretch");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"FillBitmapStretch"_ustr);
         bool bBitmapStretch;
         if(anotherAny >>= bBitmapStretch)
             dumpFillBitmapStretchAsAttribute(bBitmapStretch, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("FillBitmapTile");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"FillBitmapTile"_ustr);
         bool bBitmapTile;
         if(anotherAny >>= bBitmapTile)
             dumpFillBitmapTileAsAttribute(bBitmapTile, xmlWriter);
@@ -1530,91 +1530,91 @@ void dumpFillPropertiesService(const uno::Reference< beans::XPropertySet >& xPro
 void dumpLinePropertiesService(const uno::Reference< beans::XPropertySet >& xPropSet, xmlTextWriterPtr xmlWriter)
 {
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("LineStyle");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"LineStyle"_ustr);
         drawing::LineStyle eLineStyle;
         if(anotherAny >>= eLineStyle)
             dumpLineStyleAsAttribute(eLineStyle, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("LineDash");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"LineDash"_ustr);
         drawing::LineDash aLineDash;
         if(anotherAny >>= aLineDash)
             dumpLineDashAsElement(aLineDash, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("LineDashName");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"LineDashName"_ustr);
         OUString sLineDashName;
         if(anotherAny >>= sLineDashName)
             dumpLineDashNameAsAttribute(sLineDashName, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("LineColor");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"LineColor"_ustr);
         sal_Int32 aLineColor = sal_Int32();
         if(anotherAny >>= aLineColor)
             dumpLineColorAsAttribute(aLineColor, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("LineTransparence");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"LineTransparence"_ustr);
         sal_Int32 aLineTransparence = sal_Int32();
         if(anotherAny >>= aLineTransparence)
             dumpLineTransparenceAsAttribute(aLineTransparence, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("LineWidth");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"LineWidth"_ustr);
         sal_Int32 aLineWidth = sal_Int32();
         if(anotherAny >>= aLineWidth)
             dumpLineWidthAsAttribute(aLineWidth, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("LineJoint");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"LineJoint"_ustr);
         drawing::LineJoint eLineJoint;
         if(anotherAny >>= eLineJoint)
             dumpLineJointAsAttribute(eLineJoint, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("LineStartName");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"LineStartName"_ustr);
         OUString sLineStartName;
         if(anotherAny >>= sLineStartName)
             dumpLineStartNameAsAttribute(sLineStartName, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("LineEndName");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"LineEndName"_ustr);
         OUString sLineEndName;
         if(anotherAny >>= sLineEndName)
             dumpLineEndNameAsAttribute(sLineEndName, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("LineStart");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"LineStart"_ustr);
         drawing::PolyPolygonBezierCoords aLineStart;
         if(anotherAny >>= aLineStart)
             dumpLineStartAsElement(aLineStart, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("LineEnd");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"LineEnd"_ustr);
         drawing::PolyPolygonBezierCoords aLineEnd;
         if(anotherAny >>= aLineEnd)
             dumpLineEndAsElement(aLineEnd, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("LineStartCenter");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"LineStartCenter"_ustr);
         bool bLineStartCenter;
         if(anotherAny >>= bLineStartCenter)
             dumpLineStartCenterAsAttribute(bLineStartCenter, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("LineStartWidth");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"LineStartWidth"_ustr);
         sal_Int32 aLineStartWidth = sal_Int32();
         if(anotherAny >>= aLineStartWidth)
             dumpLineStartWidthAsAttribute(aLineStartWidth, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("LineEndCenter");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"LineEndCenter"_ustr);
         bool bLineEndCenter;
         if(anotherAny >>= bLineEndCenter)
             dumpLineEndCenterAsAttribute(bLineEndCenter, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("LineEndWidth");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"LineEndWidth"_ustr);
         sal_Int32 aLineEndWidth = sal_Int32();
         if(anotherAny >>= aLineEndWidth)
             dumpLineEndWidthAsAttribute(aLineEndWidth, xmlWriter);
@@ -1624,31 +1624,31 @@ void dumpLinePropertiesService(const uno::Reference< beans::XPropertySet >& xPro
 void dumpShadowPropertiesService(const uno::Reference< beans::XPropertySet >& xPropSet, xmlTextWriterPtr xmlWriter)
 {
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("Shadow");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"Shadow"_ustr);
         bool bShadow;
         if(anotherAny >>= bShadow)
             dumpShadowAsAttribute(bShadow, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("ShadowColor");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"ShadowColor"_ustr);
         sal_Int32 aShadowColor = sal_Int32();
         if(anotherAny >>= aShadowColor)
             dumpShadowColorAsAttribute(aShadowColor, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("ShadowTransparence");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"ShadowTransparence"_ustr);
         sal_Int32 aShadowTransparence = sal_Int32();
         if(anotherAny >>= aShadowTransparence)
             dumpShadowTransparenceAsAttribute(aShadowTransparence, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("ShadowXDistance");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"ShadowXDistance"_ustr);
         sal_Int32 aShadowXDistance = sal_Int32();
         if(anotherAny >>= aShadowXDistance)
             dumpShadowXDistanceAsAttribute(aShadowXDistance, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("ShadowYDistance");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"ShadowYDistance"_ustr);
         sal_Int32 aShadowYDistance = sal_Int32();
         if(anotherAny >>= aShadowYDistance)
             dumpShadowYDistanceAsAttribute(aShadowYDistance, xmlWriter);
@@ -1658,19 +1658,19 @@ void dumpShadowPropertiesService(const uno::Reference< beans::XPropertySet >& xP
 void dumpPolyPolygonDescriptorService(const uno::Reference< beans::XPropertySet >& xPropSet, xmlTextWriterPtr xmlWriter)
 {
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("PolygonKind");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"PolygonKind"_ustr);
         drawing::PolygonKind ePolygonKind;
         if(anotherAny >>= ePolygonKind)
             dumpPolygonKindAsAttribute(ePolygonKind, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("PolyPolygon");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"PolyPolygon"_ustr);
         drawing::PointSequenceSequence aPolyPolygon;
         if(anotherAny >>= aPolyPolygon)
             dumpPolyPolygonAsElement(aPolyPolygon, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("Geometry");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"Geometry"_ustr);
         drawing::PointSequenceSequence aGeometry;
         if(anotherAny >>= aGeometry)
             dumpGeometryAsElement(aGeometry, xmlWriter);
@@ -1681,75 +1681,75 @@ void dumpShapeService(const uno::Reference< beans::XPropertySet >& xPropSet, xml
 {
     uno::Reference< beans::XPropertySetInfo> xInfo = xPropSet->getPropertySetInfo();
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("ZOrder");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"ZOrder"_ustr);
         sal_Int32 aZOrder = sal_Int32();
         if(anotherAny >>= aZOrder)
             dumpZOrderAsAttribute(aZOrder, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("LayerID");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"LayerID"_ustr);
         sal_Int32 aLayerID = sal_Int32();
         if(anotherAny >>= aLayerID)
             dumpLayerIDAsAttribute(aLayerID, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("LayerName");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"LayerName"_ustr);
         OUString sLayerName;
         if(anotherAny >>= sLayerName)
             dumpLayerNameAsAttribute(sLayerName, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("Visible");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"Visible"_ustr);
         bool bVisible;
         if(anotherAny >>= bVisible)
             dumpVisibleAsAttribute(bVisible, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("Printable");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"Printable"_ustr);
         bool bPrintable;
         if(anotherAny >>= bPrintable)
             dumpPrintableAsAttribute(bPrintable, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("MoveProtect");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"MoveProtect"_ustr);
         bool bMoveProtect;
         if(anotherAny >>= bMoveProtect)
             dumpMoveProtectAsAttribute(bMoveProtect, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("Name");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"Name"_ustr);
         OUString sName;
         if(anotherAny >>= sName)
             dumpNameAsAttribute(sName, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("SizeProtect");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"SizeProtect"_ustr);
         bool bSizeProtect;
         if(anotherAny >>= bSizeProtect)
             dumpSizeProtectAsAttribute(bSizeProtect, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("Transformation");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"Transformation"_ustr);
         drawing::HomogenMatrix3 aTransformation;
         if(anotherAny >>= aTransformation)
             dumpTransformationAsElement(aTransformation, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("NavigationOrder");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"NavigationOrder"_ustr);
         sal_Int32 aNavigationOrder = sal_Int32();
         if(anotherAny >>= aNavigationOrder)
             dumpNavigationOrderAsAttribute(aNavigationOrder, xmlWriter);
     }
-    if(xInfo->hasPropertyByName("Hyperlink"))
+    if(xInfo->hasPropertyByName(u"Hyperlink"_ustr))
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("Hyperlink");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"Hyperlink"_ustr);
         OUString sHyperlink;
         if(anotherAny >>= sHyperlink)
             dumpHyperlinkAsAttribute(sHyperlink, xmlWriter);
     }
-    if(xInfo->hasPropertyByName("InteropGrabBag") && bDumpInteropProperties)
+    if(xInfo->hasPropertyByName(u"InteropGrabBag"_ustr) && bDumpInteropProperties)
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("InteropGrabBag");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"InteropGrabBag"_ustr);
         uno::Sequence< beans::PropertyValue> aInteropGrabBag;
         if(anotherAny >>= aInteropGrabBag)
             dumpInteropGrabBagAsElement(aInteropGrabBag, xmlWriter);
@@ -1759,19 +1759,19 @@ void dumpShapeService(const uno::Reference< beans::XPropertySet >& xPropSet, xml
 void dumpPolyPolygonBezierDescriptorService(const uno::Reference< beans::XPropertySet >& xPropSet, xmlTextWriterPtr xmlWriter)
 {
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("PolygonKind");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"PolygonKind"_ustr);
         drawing::PolygonKind ePolygonKind;
         if(anotherAny >>= ePolygonKind)
             dumpPolygonKindAsAttribute(ePolygonKind, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("PolyPolygonBezier");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"PolyPolygonBezier"_ustr);
         drawing::PolyPolygonBezierCoords aPolyPolygonBezier;
         if(anotherAny >>= aPolyPolygonBezier)
             dumpPolyPolygonBezierCoords(aPolyPolygonBezier, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("Geometry");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"Geometry"_ustr);
         drawing::PolyPolygonBezierCoords aGeometry;
         if(anotherAny >>= aGeometry)
             dumpPolyPolygonBezierCoords(aGeometry, xmlWriter);
@@ -1782,26 +1782,26 @@ void dumpCustomShapeService(const uno::Reference< beans::XPropertySet >& xPropSe
 {
     uno::Reference< beans::XPropertySetInfo> xInfo = xPropSet->getPropertySetInfo();
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("CustomShapeEngine");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"CustomShapeEngine"_ustr);
         OUString sCustomShapeEngine;
         if(anotherAny >>= sCustomShapeEngine)
             dumpCustomShapeEngineAsAttribute(sCustomShapeEngine, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("CustomShapeData");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"CustomShapeData"_ustr);
         OUString sCustomShapeData;
         if(anotherAny >>= sCustomShapeData)
             dumpCustomShapeDataAsAttribute(sCustomShapeData, xmlWriter);
     }
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("CustomShapeGeometry");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"CustomShapeGeometry"_ustr);
         uno::Sequence< beans::PropertyValue> aCustomShapeGeometry;
         if(anotherAny >>= aCustomShapeGeometry)
             dumpCustomShapeGeometryAsElement(aCustomShapeGeometry, xmlWriter);
     }
-    if(xInfo->hasPropertyByName("CustomShapeReplacementURL"))
+    if(xInfo->hasPropertyByName(u"CustomShapeReplacementURL"_ustr))
     {
-        uno::Any anotherAny = xPropSet->getPropertyValue("CustomShapeReplacementURL");
+        uno::Any anotherAny = xPropSet->getPropertyValue(u"CustomShapeReplacementURL"_ustr);
         OUString sCustomShapeReplacementURL;
         if(anotherAny >>= sCustomShapeReplacementURL)
             dumpCustomShapeReplacementURLAsAttribute(sCustomShapeReplacementURL, xmlWriter);
@@ -1825,9 +1825,9 @@ void dumpXShape(const uno::Reference< drawing::XShape >& xShape, xmlTextWriterPt
     uno::Reference< lang::XServiceInfo > xServiceInfo( xShape, uno::UNO_QUERY_THROW );
 
     uno::Reference< beans::XPropertySetInfo> xInfo = xPropSet->getPropertySetInfo();
-    if(xInfo->hasPropertyByName("Name"))
+    if(xInfo->hasPropertyByName(u"Name"_ustr))
     {
-        uno::Any aAny = xPropSet->getPropertyValue("Name");
+        uno::Any aAny = xPropSet->getPropertyValue(u"Name"_ustr);
         if ((aAny >>= aName) && !aName.isEmpty())
         {
             (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("name"), "%s", OUStringToOString(aName, RTL_TEXTENCODING_UTF8).getStr());
@@ -1837,65 +1837,65 @@ void dumpXShape(const uno::Reference< drawing::XShape >& xShape, xmlTextWriterPt
 
     try
     {
-    if (xServiceInfo->supportsService("com.sun.star.drawing.Text"))
+    if (xServiceInfo->supportsService(u"com.sun.star.drawing.Text"_ustr))
     {
         uno::Reference< text::XText > xText(xShape, uno::UNO_QUERY_THROW);
         OUString aText = xText->getString();
         if(!aText.isEmpty())
             (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("text"), "%s", OUStringToOString(aText, RTL_TEXTENCODING_UTF8).getStr());
     }
-    if(xServiceInfo->supportsService("com.sun.star.drawing.TextProperties"))
+    if(xServiceInfo->supportsService(u"com.sun.star.drawing.TextProperties"_ustr))
         dumpTextPropertiesService(xPropSet, xmlWriter);
 
-    if(xServiceInfo->supportsService("com.sun.star.drawing.GroupShape"))
+    if(xServiceInfo->supportsService(u"com.sun.star.drawing.GroupShape"_ustr))
     {
         uno::Reference< drawing::XShapes > xShapes(xShape, uno::UNO_QUERY_THROW);
         dumpXShapes(xShapes, xmlWriter, bDumpInteropProperties);
     }
-    if(xServiceInfo->supportsService("com.sun.star.drawing.FillProperties"))
+    if(xServiceInfo->supportsService(u"com.sun.star.drawing.FillProperties"_ustr))
         dumpFillPropertiesService(xPropSet, xmlWriter);
 
-    if(xServiceInfo->supportsService("com.sun.star.drawing.LineProperties"))
+    if(xServiceInfo->supportsService(u"com.sun.star.drawing.LineProperties"_ustr))
         dumpLinePropertiesService(xPropSet, xmlWriter);
 
-    if(xServiceInfo->supportsService("com.sun.star.drawing.PolyPolygonDescriptor"))
+    if(xServiceInfo->supportsService(u"com.sun.star.drawing.PolyPolygonDescriptor"_ustr))
         dumpPolyPolygonDescriptorService(xPropSet, xmlWriter);
 
-    if(xServiceInfo->supportsService("com.sun.star.drawing.ShadowProperties"))
+    if(xServiceInfo->supportsService(u"com.sun.star.drawing.ShadowProperties"_ustr))
         dumpShadowPropertiesService(xPropSet, xmlWriter);
 
-    if(xServiceInfo->supportsService("com.sun.star.drawing.Shape"))
+    if(xServiceInfo->supportsService(u"com.sun.star.drawing.Shape"_ustr))
         dumpShapeService(xPropSet, xmlWriter, bDumpInteropProperties);
 
-    if(xServiceInfo->supportsService("com.sun.star.drawing.PolyPolygonBezierDescriptor"))
+    if(xServiceInfo->supportsService(u"com.sun.star.drawing.PolyPolygonBezierDescriptor"_ustr))
         dumpPolyPolygonBezierDescriptorService(xPropSet, xmlWriter);
 
-    if(xServiceInfo->supportsService("com.sun.star.drawing.CustomShape"))
+    if(xServiceInfo->supportsService(u"com.sun.star.drawing.CustomShape"_ustr))
         dumpCustomShapeService(xPropSet, xmlWriter);
 
     // EnhancedShapeDumper used
 
-    if(xServiceInfo->supportsService("com.sun.star.drawing.EnhancedCustomShapeExtrusion"))
+    if(xServiceInfo->supportsService(u"com.sun.star.drawing.EnhancedCustomShapeExtrusion"_ustr))
     {
         EnhancedShapeDumper enhancedDumper(xmlWriter);
         enhancedDumper.dumpEnhancedCustomShapeExtrusionService(xPropSet);
     }
-    if(xServiceInfo->supportsService("com.sun.star.drawing.EnhancedCustomShapeGeometry"))
+    if(xServiceInfo->supportsService(u"com.sun.star.drawing.EnhancedCustomShapeGeometry"_ustr))
     {
         EnhancedShapeDumper enhancedDumper(xmlWriter);
         enhancedDumper.dumpEnhancedCustomShapeGeometryService(xPropSet);
     }
-    if(xServiceInfo->supportsService("com.sun.star.drawing.EnhancedCustomShapeHandle"))
+    if(xServiceInfo->supportsService(u"com.sun.star.drawing.EnhancedCustomShapeHandle"_ustr))
     {
         EnhancedShapeDumper enhancedDumper(xmlWriter);
         enhancedDumper.dumpEnhancedCustomShapeHandleService(xPropSet);
     }
-    if(xServiceInfo->supportsService("com.sun.star.drawing.EnhancedCustomShapePath"))
+    if(xServiceInfo->supportsService(u"com.sun.star.drawing.EnhancedCustomShapePath"_ustr))
     {
         EnhancedShapeDumper enhancedDumper(xmlWriter);
         enhancedDumper.dumpEnhancedCustomShapePathService(xPropSet);
     }
-    if(xServiceInfo->supportsService("com.sun.star.drawing.EnhancedCustomShapeTextPath"))
+    if(xServiceInfo->supportsService(u"com.sun.star.drawing.EnhancedCustomShapeTextPath"_ustr))
     {
         EnhancedShapeDumper enhancedDumper(xmlWriter);
         enhancedDumper.dumpEnhancedCustomShapeTextPathService(xPropSet);
diff --git a/drawinglayer/source/primitive2d/Tools.cxx b/drawinglayer/source/primitive2d/Tools.cxx
index e20c34a6c4f7..bd74a4b5cd00 100644
--- a/drawinglayer/source/primitive2d/Tools.cxx
+++ b/drawinglayer/source/primitive2d/Tools.cxx
@@ -80,159 +80,159 @@ OUString idToString(sal_uInt32 nId)
     switch (nId)
     {
         case PRIMITIVE2D_ID_TRANSPARENCEPRIMITIVE2D:
-            return "TRANSPARENCE";
+            return u"TRANSPARENCE"_ustr;
         case PRIMITIVE2D_ID_ANIMATEDSWITCHPRIMITIVE2D:
-            return "ANIMATEDSWITCH";
+            return u"ANIMATEDSWITCH"_ustr;
         case PRIMITIVE2D_ID_ANIMATEDBLINKPRIMITIVE2D:
-            return "ANIMATEDBLINK";
+            return u"ANIMATEDBLINK"_ustr;
         case PRIMITIVE2D_ID_ANIMATEDINTERPOLATEPRIMITIVE2D:
-            return "ANIMATEDINTERPOLATE";
+            return u"ANIMATEDINTERPOLATE"_ustr;
         case PRIMITIVE2D_ID_BACKGROUNDCOLORPRIMITIVE2D:
-            return "BACKGROUNDCOLOR";
+            return u"BACKGROUNDCOLOR"_ustr;
         case PRIMITIVE2D_ID_BITMAPPRIMITIVE2D:
-            return "BITMAP";
+            return u"BITMAP"_ustr;
         case PRIMITIVE2D_ID_CONTROLPRIMITIVE2D:
-            return "CONTROL";
+            return u"CONTROL"_ustr;
         case PRIMITIVE2D_ID_EMBEDDED3DPRIMITIVE2D:
-            return "EMBEDDED3D";
+            return u"EMBEDDED3D"_ustr;
         case PRIMITIVE2D_ID_FILLGRAPHICPRIMITIVE2D:
-            return "FILLGRAPHIC";
+            return u"FILLGRAPHIC"_ustr;
         case PRIMITIVE2D_ID_FILLGRADIENTPRIMITIVE2D:
-            return "FILLGRADIENT";
+            return u"FILLGRADIENT"_ustr;
         case PRIMITIVE2D_ID_FILLHATCHPRIMITIVE2D:
-            return "FILLHATCH";
+            return u"FILLHATCH"_ustr;
         case PRIMITIVE2D_ID_GRAPHICPRIMITIVE2D:
-            return "GRAPHIC";
+            return u"GRAPHIC"_ustr;
         case PRIMITIVE2D_ID_GRIDPRIMITIVE2D:
-            return "GRID";
+            return u"GRID"_ustr;
         case PRIMITIVE2D_ID_GROUPPRIMITIVE2D:
-            return "GROUP";
+            return u"GROUP"_ustr;
         case PRIMITIVE2D_ID_HELPLINEPRIMITIVE2D:
-            return "HELPLINE";
+            return u"HELPLINE"_ustr;
         case PRIMITIVE2D_ID_MARKERARRAYPRIMITIVE2D:
-            return "MARKERARRAY";
+            return u"MARKERARRAY"_ustr;
         case PRIMITIVE2D_ID_MASKPRIMITIVE2D:
-            return "MASK";
+            return u"MASK"_ustr;
         case PRIMITIVE2D_ID_MEDIAPRIMITIVE2D:
-            return "MEDIA";
+            return u"MEDIA"_ustr;
         case PRIMITIVE2D_ID_METAFILEPRIMITIVE2D:
-            return "METAFILE";
+            return u"METAFILE"_ustr;
         case PRIMITIVE2D_ID_MODIFIEDCOLORPRIMITIVE2D:
-            return "MODIFIEDCOLOR";
+            return u"MODIFIEDCOLOR"_ustr;
         case PRIMITIVE2D_ID_POLYGONHAIRLINEPRIMITIVE2D:
-            return "POLYGONHAIRLINE";
+            return u"POLYGONHAIRLINE"_ustr;
         case PRIMITIVE2D_ID_POLYGONMARKERPRIMITIVE2D:
-            return "POLYGONMARKER";
+            return u"POLYGONMARKER"_ustr;
         case PRIMITIVE2D_ID_POLYGONSTROKEPRIMITIVE2D:
-            return "POLYGONSTROKE";
+            return u"POLYGONSTROKE"_ustr;
         case PRIMITIVE2D_ID_POLYGONSTROKEARROWPRIMITIVE2D:
-            return "POLYGONSTROKEARROW";
+            return u"POLYGONSTROKEARROW"_ustr;
         case PRIMITIVE2D_ID_POLYPOLYGONSTROKEPRIMITIVE2D:
-            return "POLYPOLYGONSTROKE";
+            return u"POLYPOLYGONSTROKE"_ustr;
         case PRIMITIVE2D_ID_POLYPOLYGONSTROKEARROWPRIMITIVE2D:
-            return "POLYPOLYGONSTROKEARROW";
+            return u"POLYPOLYGONSTROKEARROW"_ustr;
         case PRIMITIVE2D_ID_POLYPOLYGONCOLORPRIMITIVE2D:
-            return "POLYPOLYGONCOLOR";
+            return u"POLYPOLYGONCOLOR"_ustr;
         case PRIMITIVE2D_ID_POLYPOLYGONGRADIENTPRIMITIVE2D:
-            return "POLYPOLYGONGRADIENT";
+            return u"POLYPOLYGONGRADIENT"_ustr;
         case PRIMITIVE2D_ID_POLYPOLYGONHATCHPRIMITIVE2D:
-            return "POLYPOLYGONHATCH";
+            return u"POLYPOLYGONHATCH"_ustr;
         case PRIMITIVE2D_ID_POLYPOLYGONGRAPHICPRIMITIVE2D:
-            return "POLYPOLYGONGRAPHIC";
+            return u"POLYPOLYGONGRAPHIC"_ustr;
         case PRIMITIVE2D_ID_SCENEPRIMITIVE2D:
-            return "SCENE";
+            return u"SCENE"_ustr;
         case PRIMITIVE2D_ID_SHADOWPRIMITIVE2D:
-            return "SHADOW";
+            return u"SHADOW"_ustr;
         case PRIMITIVE2D_ID_TEXTSIMPLEPORTIONPRIMITIVE2D:
-            return "TEXTSIMPLEPORTION";
+            return u"TEXTSIMPLEPORTION"_ustr;
         case PRIMITIVE2D_ID_TEXTDECORATEDPORTIONPRIMITIVE2D:
-            return "TEXTDECORATEDPORTION";
+            return u"TEXTDECORATEDPORTION"_ustr;
         case PRIMITIVE2D_ID_TRANSFORMPRIMITIVE2D:
-            return "TRANSFORM";
+            return u"TRANSFORM"_ustr;
         case PRIMITIVE2D_ID_UNIFIEDTRANSPARENCEPRIMITIVE2D:
-            return "UNIFIEDTRANSPARENCE";
+            return u"UNIFIEDTRANSPARENCE"_ustr;
         case PRIMITIVE2D_ID_POINTARRAYPRIMITIVE2D:
-            return "POINTARRAY";
+            return u"POINTARRAY"_ustr;
         case PRIMITIVE2D_ID_TEXTHIERARCHYFIELDPRIMITIVE2D:
-            return "TEXTHIERARCHYFIELD";
+            return u"TEXTHIERARCHYFIELD"_ustr;
         case PRIMITIVE2D_ID_TEXTHIERARCHYLINEPRIMITIVE2D:
-            return "TEXTHIERARCHYLINE";
+            return u"TEXTHIERARCHYLINE"_ustr;
         case PRIMITIVE2D_ID_TEXTHIERARCHYPARAGRAPHPRIMITIVE2D:
-            return "TEXTHIERARCHYPARAGRAPH";
+            return u"TEXTHIERARCHYPARAGRAPH"_ustr;
         case PRIMITIVE2D_ID_TEXTHIERARCHYBLOCKPRIMITIVE2D:
-            return "TEXTHIERARCHYBLOCK";
+            return u"TEXTHIERARCHYBLOCK"_ustr;
         case PRIMITIVE2D_ID_TEXTHIERARCHYEDITPRIMITIVE2D:
-            return "TEXTHIERARCHYEDIT";
+            return u"TEXTHIERARCHYEDIT"_ustr;
         case PRIMITIVE2D_ID_POLYGONWAVEPRIMITIVE2D:
-            return "POLYGONWAVE";
+            return u"POLYGONWAVE"_ustr;
         case PRIMITIVE2D_ID_WRONGSPELLPRIMITIVE2D:
-            return "WRONGSPELL";
+            return u"WRONGSPELL"_ustr;
         case PRIMITIVE2D_ID_TEXTEFFECTPRIMITIVE2D:
-            return "TEXTEFFECT";
+            return u"TEXTEFFECT"_ustr;
         case PRIMITIVE2D_ID_TEXTHIERARCHYBULLETPRIMITIVE2D:
-            return "TEXTHIERARCHYBULLET";
+            return u"TEXTHIERARCHYBULLET"_ustr;
         case PRIMITIVE2D_ID_POLYPOLYGONHAIRLINEPRIMITIVE2D:
-            return "POLYPOLYGONHAIRLINE";
+            return u"POLYPOLYGONHAIRLINE"_ustr;
         case PRIMITIVE2D_ID_EXECUTEPRIMITIVE2D:
-            return "EXECUTE";
+            return u"EXECUTE"_ustr;
         case PRIMITIVE2D_ID_PAGEPREVIEWPRIMITIVE2D:
-            return "PAGEPREVIEW";
+            return u"PAGEPREVIEW"_ustr;
         case PRIMITIVE2D_ID_STRUCTURETAGPRIMITIVE2D:
-            return "STRUCTURETAG";
+            return u"STRUCTURETAG"_ustr;
         case PRIMITIVE2D_ID_BORDERLINEPRIMITIVE2D:
-            return "BORDERLINE";
+            return u"BORDERLINE"_ustr;
         case PRIMITIVE2D_ID_POLYPOLYGONMARKERPRIMITIVE2D:
-            return "POLYPOLYGONMARKER";
+            return u"POLYPOLYGONMARKER"_ustr;
         case PRIMITIVE2D_ID_HITTESTPRIMITIVE2D:
-            return "HITTEST";
+            return u"HITTEST"_ustr;
         case PRIMITIVE2D_ID_INVERTPRIMITIVE2D:
-            return "INVERT";
+            return u"INVERT"_ustr;
         case PRIMITIVE2D_ID_DISCRETEBITMAPPRIMITIVE2D:
-            return "DISCRETEBITMAP";
+            return u"DISCRETEBITMAP"_ustr;
         case PRIMITIVE2D_ID_WALLPAPERBITMAPPRIMITIVE2D:
-            return "WALLPAPERBITMAP";
+            return u"WALLPAPERBITMAP"_ustr;
         case PRIMITIVE2D_ID_TEXTLINEPRIMITIVE2D:
-            return "TEXTLINE";
+            return u"TEXTLINE"_ustr;
         case PRIMITIVE2D_ID_TEXTCHARACTERSTRIKEOUTPRIMITIVE2D:
-            return "TEXTCHARACTERSTRIKEOUT";
+            return u"TEXTCHARACTERSTRIKEOUT"_ustr;
         case PRIMITIVE2D_ID_TEXTGEOMETRYSTRIKEOUTPRIMITIVE2D:
-            return "TEXTGEOMETRYSTRIKEOUT";
+            return u"TEXTGEOMETRYSTRIKEOUT"_ustr;
         case PRIMITIVE2D_ID_EPSPRIMITIVE2D:
-            return "EPS";
+            return u"EPS"_ustr;
         case PRIMITIVE2D_ID_DISCRETESHADOWPRIMITIVE2D:
-            return "DISCRETESHADOW";
+            return u"DISCRETESHADOW"_ustr;
         case PRIMITIVE2D_ID_HIDDENGEOMETRYPRIMITIVE2D:
-            return "HIDDENGEOMETRY";
+            return u"HIDDENGEOMETRY"_ustr;
         case PRIMITIVE2D_ID_SVGLINEARGRADIENTPRIMITIVE2D:
-            return "SVGLINEARGRADIENT";
+            return u"SVGLINEARGRADIENT"_ustr;
         case PRIMITIVE2D_ID_SVGRADIALGRADIENTPRIMITIVE2D:
-            return "SVGRADIALGRADIENT";
+            return u"SVGRADIALGRADIENT"_ustr;
         case PRIMITIVE2D_ID_SVGLINEARATOMPRIMITIVE2D:
-            return "SVGLINEARATOM";
+            return u"SVGLINEARATOM"_ustr;
         case PRIMITIVE2D_ID_SVGRADIALATOMPRIMITIVE2D:
-            return "SVGRADIALATOM";
+            return u"SVGRADIALATOM"_ustr;
         case PRIMITIVE2D_ID_CROPPRIMITIVE2D:
-            return "CROP";
+            return u"CROP"_ustr;
         case PRIMITIVE2D_ID_PATTERNFILLPRIMITIVE2D:
-            return "PATTERNFILL";
+            return u"PATTERNFILL"_ustr;
         case PRIMITIVE2D_ID_OBJECTINFOPRIMITIVE2D:
-            return "OBJECTINFO";
+            return u"OBJECTINFO"_ustr;
         case PRIMITIVE2D_ID_POLYPOLYGONSELECTIONPRIMITIVE2D:
-            return "POLYPOLYGONSELECTION";
+            return u"POLYPOLYGONSELECTION"_ustr;
         case PRIMITIVE2D_ID_PAGEHIERARCHYPRIMITIVE2D:
-            return "PAGEHIERARCHY";
+            return u"PAGEHIERARCHY"_ustr;
         case PRIMITIVE2D_ID_GLOWPRIMITIVE2D:
-            return "GLOWPRIMITIVE";
+            return u"GLOWPRIMITIVE"_ustr;
         case PRIMITIVE2D_ID_SOFTEDGEPRIMITIVE2D:
-            return "SOFTEDGEPRIMITIVE";
+            return u"SOFTEDGEPRIMITIVE"_ustr;
         case PRIMITIVE2D_ID_LINERECTANGLEPRIMITIVE2D:
-            return "LINERECTANGLEPRIMITIVE";
+            return u"LINERECTANGLEPRIMITIVE"_ustr;
         case PRIMITIVE2D_ID_FILLEDRECTANGLEPRIMITIVE2D:
-            return "FILLEDRECTANGLEPRIMITIVE";
+            return u"FILLEDRECTANGLEPRIMITIVE"_ustr;
         case PRIMITIVE2D_ID_SINGLELINEPRIMITIVE2D:
-            return "SINGLELINEPRIMITIVE";
+            return u"SINGLELINEPRIMITIVE"_ustr;
         case PRIMITIVE2D_ID_EXCLUSIVEEDITVIEWPRIMITIVE2D:
-            return "EXCLUSIVEEDITVIEWPRIMITIVE2D";
+            return u"EXCLUSIVEEDITVIEWPRIMITIVE2D"_ustr;
         default:
             return OUString::number((nId >> 16) & 0xFF) + "|" + OUString::number(nId & 0xFF);
     }
diff --git a/drawinglayer/source/primitive2d/controlprimitive2d.cxx b/drawinglayer/source/primitive2d/controlprimitive2d.cxx
index 730e522dc6f6..66d92c2d60df 100644
--- a/drawinglayer/source/primitive2d/controlprimitive2d.cxx
+++ b/drawinglayer/source/primitive2d/controlprimitive2d.cxx
@@ -56,7 +56,7 @@ namespace drawinglayer::primitive2d
             if(!xSet.is())
                 return;
 
-            uno::Any aValue(xSet->getPropertyValue("DefaultControl"));
+            uno::Any aValue(xSet->getPropertyValue(u"DefaultControl"_ustr));
             OUString aUnoControlTypeName;
 
             if(!(aValue >>= aUnoControlTypeName))
@@ -150,7 +150,7 @@ namespace drawinglayer::primitive2d
                                     if (xWindowPeer)
                                     {
                                         uno::Reference<awt::XVclWindowPeer> xPeerProps(xWindowPeer, uno::UNO_QUERY_THROW);
-                                        uno::Any aAny = xPeerProps->getProperty("ParentIs100thmm"); // see VCLXWindow::getProperty
+                                        uno::Any aAny = xPeerProps->getProperty(u"ParentIs100thmm"_ustr); // see VCLXWindow::getProperty
                                         aAny >>= bUserIs100thmm;
                                     }
                                 }
diff --git a/drawinglayer/source/primitive3d/Tools.cxx b/drawinglayer/source/primitive3d/Tools.cxx
index c27896b043cc..23ecc0851f40 100644
--- a/drawinglayer/source/primitive3d/Tools.cxx
+++ b/drawinglayer/source/primitive3d/Tools.cxx
@@ -20,43 +20,43 @@ OUString idToString(sal_uInt32 nId)
     switch (nId)
     {
         case PRIMITIVE3D_ID_GROUPPRIMITIVE3D:
-            return "GROUPPRIMITIVE3D";
+            return u"GROUPPRIMITIVE3D"_ustr;
         case PRIMITIVE3D_ID_HATCHTEXTUREPRIMITIVE3D:
-            return "HATCHTEXTUREPRIMITIVE3D";
+            return u"HATCHTEXTUREPRIMITIVE3D"_ustr;
         case PRIMITIVE3D_ID_MODIFIEDCOLORPRIMITIVE3D:
-            return "MODIFIEDCOLORPRIMITIVE3D";
+            return u"MODIFIEDCOLORPRIMITIVE3D"_ustr;
         case PRIMITIVE3D_ID_POLYGONHAIRLINEPRIMITIVE3D:
-            return "POLYGONHAIRLINEPRIMITIVE3D";
+            return u"POLYGONHAIRLINEPRIMITIVE3D"_ustr;
         case PRIMITIVE3D_ID_POLYGONSTROKEPRIMITIVE3D:
-            return "POLYGONSTROKEPRIMITIVE3D";
+            return u"POLYGONSTROKEPRIMITIVE3D"_ustr;
         case PRIMITIVE3D_ID_POLYGONTUBEPRIMITIVE3D:
-            return "POLYGONTUBEPRIMITIVE3D";
+            return u"POLYGONTUBEPRIMITIVE3D"_ustr;
         case PRIMITIVE3D_ID_POLYPOLYGONMATERIALPRIMITIVE3D:
-            return "POLYPOLYGONMATERIALPRIMITIVE3D";
+            return u"POLYPOLYGONMATERIALPRIMITIVE3D"_ustr;
         case PRIMITIVE3D_ID_SDRCUBEPRIMITIVE3D:
-            return "SDRCUBEPRIMITIVE3D";
+            return u"SDRCUBEPRIMITIVE3D"_ustr;
         case PRIMITIVE3D_ID_SDREXTRUDEPRIMITIVE3D:
-            return "SDREXTRUDEPRIMITIVE3D";
+            return u"SDREXTRUDEPRIMITIVE3D"_ustr;
         case PRIMITIVE3D_ID_SDRLATHEPRIMITIVE3D:
-            return "SDRLATHEPRIMITIVE3D";
+            return u"SDRLATHEPRIMITIVE3D"_ustr;
         case PRIMITIVE3D_ID_SDRPOLYPOLYGONPRIMITIVE3D:
-            return "SDRPOLYPOLYGONPRIMITIVE3D";
+            return u"SDRPOLYPOLYGONPRIMITIVE3D"_ustr;
         case PRIMITIVE3D_ID_SDRSPHEREPRIMITIVE3D:
-            return "SDRSPHEREPRIMITIVE3D";
+            return u"SDRSPHEREPRIMITIVE3D"_ustr;
         case PRIMITIVE3D_ID_SHADOWPRIMITIVE3D:
-            return "SHADOWPRIMITIVE3D";
+            return u"SHADOWPRIMITIVE3D"_ustr;
         case PRIMITIVE3D_ID_UNIFIEDTRANSPARENCETEXTUREPRIMITIVE3D:
-            return "UNIFIEDTRANSPARENCETEXTUREPRIMITIVE3D";
+            return u"UNIFIEDTRANSPARENCETEXTUREPRIMITIVE3D"_ustr;
         case PRIMITIVE3D_ID_GRADIENTTEXTUREPRIMITIVE3D:
-            return "GRADIENTTEXTUREPRIMITIVE3D";
+            return u"GRADIENTTEXTUREPRIMITIVE3D"_ustr;
         case PRIMITIVE3D_ID_BITMAPTEXTUREPRIMITIVE3D:
-            return "BITMAPTEXTUREPRIMITIVE3D";
+            return u"BITMAPTEXTUREPRIMITIVE3D"_ustr;
         case PRIMITIVE3D_ID_TRANSPARENCETEXTUREPRIMITIVE3D:
-            return "TRANSPARENCETEXTUREPRIMITIVE3D";
+            return u"TRANSPARENCETEXTUREPRIMITIVE3D"_ustr;
         case PRIMITIVE3D_ID_TRANSFORMPRIMITIVE3D:
-            return "TRANSFORMPRIMITIVE3D";
+            return u"TRANSFORMPRIMITIVE3D"_ustr;
         case PRIMITIVE3D_ID_HIDDENGEOMETRYPRIMITIVE3D:
-            return "HIDDENGEOMETRYPRIMITIVE3D";
+            return u"HIDDENGEOMETRYPRIMITIVE3D"_ustr;
         default:
             return OUString::number((nId >> 16) & 0xFF) + "|" + OUString::number(nId & 0xFF);
     }
diff --git a/drawinglayer/source/processor2d/vclmetafileprocessor2d.cxx b/drawinglayer/source/processor2d/vclmetafileprocessor2d.cxx
index d93d98fef51a..f12be451b03a 100644
--- a/drawinglayer/source/processor2d/vclmetafileprocessor2d.cxx
+++ b/drawinglayer/source/processor2d/vclmetafileprocessor2d.cxx
@@ -1274,7 +1274,7 @@ void VclMetafileProcessor2D::processTextHierarchyFieldPrimitive2D(
         }
         case drawinglayer::primitive2d::FIELD_TYPE_URL:
         {
-            aURL = rFieldPrimitive.getValue("URL");
+            aURL = rFieldPrimitive.getValue(u"URL"_ustr);
 
             if (!aURL.isEmpty())
             {
@@ -1306,7 +1306,7 @@ void VclMetafileProcessor2D::processTextHierarchyFieldPrimitive2D(
                                       static_cast<sal_Int32>(ceil(aViewRange.getMaxX())),
                                       static_cast<sal_Int32>(ceil(aViewRange.getMaxY())));
     vcl::PDFExtOutDevBookmarkEntry aBookmark;
-    OUString const content(rFieldPrimitive.getValue("Representation"));
+    OUString const content(rFieldPrimitive.getValue(u"Representation"_ustr));
     aBookmark.nLinkId = mpPDFExtOutDevData->CreateLink(aRectLogic, content);
     aBookmark.aBookmark = aURL;
     std::vector<vcl::PDFExtOutDevBookmarkEntry>& rBookmarks = mpPDFExtOutDevData->GetBookmarks();
diff --git a/drawinglayer/source/tools/emfpbrush.cxx b/drawinglayer/source/tools/emfpbrush.cxx
index c79b0ded0748..786209bb641b 100644
--- a/drawinglayer/source/tools/emfpbrush.cxx
+++ b/drawinglayer/source/tools/emfpbrush.cxx
@@ -52,13 +52,13 @@ namespace emfplushelper
     {
         switch (type)
         {
-            case BrushTypeSolidColor: return "BrushTypeSolidColor";
-            case BrushTypeHatchFill: return "BrushTypeHatchFill";
-            case BrushTypeTextureFill: return "BrushTypeTextureFill";
-            case BrushTypePathGradient: return "BrushTypePathGradient";
-            case BrushTypeLinearGradient: return "BrushTypeLinearGradient";
+            case BrushTypeSolidColor: return u"BrushTypeSolidColor"_ustr;
+            case BrushTypeHatchFill: return u"BrushTypeHatchFill"_ustr;
+            case BrushTypeTextureFill: return u"BrushTypeTextureFill"_ustr;
+            case BrushTypePathGradient: return u"BrushTypePathGradient"_ustr;
+            case BrushTypeLinearGradient: return u"BrushTypeLinearGradient"_ustr;
         }
-        return "";
+        return u""_ustr;
     }
 
     void EMFPBrush::Read(SvStream& s, EmfPlusHelperData const & rR)
diff --git a/drawinglayer/source/tools/emfphelperdata.cxx b/drawinglayer/source/tools/emfphelperdata.cxx
index 1d95f0a8f38a..1dd5149fd102 100644
--- a/drawinglayer/source/tools/emfphelperdata.cxx
+++ b/drawinglayer/source/tools/emfphelperdata.cxx
@@ -127,89 +127,89 @@ namespace emfplushelper
     {
         switch (type)
         {
-            case EmfPlusObjectTypeBrush: return "EmfPlusObjectTypeBrush";
-            case EmfPlusObjectTypePen: return "EmfPlusObjectTypePen";
-            case EmfPlusObjectTypePath: return "EmfPlusObjectTypePath";
-            case EmfPlusObjectTypeRegion: return "EmfPlusObjectTypeRegion";
-            case EmfPlusObjectTypeImage: return "EmfPlusObjectTypeImage";
-            case EmfPlusObjectTypeFont: return "EmfPlusObjectTypeFont";
-            case EmfPlusObjectTypeStringFormat: return "EmfPlusObjectTypeStringFormat";
-            case EmfPlusObjectTypeImageAttributes: return "EmfPlusObjectTypeImageAttributes";
-            case EmfPlusObjectTypeCustomLineCap: return "EmfPlusObjectTypeCustomLineCap";
+            case EmfPlusObjectTypeBrush: return u"EmfPlusObjectTypeBrush"_ustr;
+            case EmfPlusObjectTypePen: return u"EmfPlusObjectTypePen"_ustr;
+            case EmfPlusObjectTypePath: return u"EmfPlusObjectTypePath"_ustr;
+            case EmfPlusObjectTypeRegion: return u"EmfPlusObjectTypeRegion"_ustr;
+            case EmfPlusObjectTypeImage: return u"EmfPlusObjectTypeImage"_ustr;
+            case EmfPlusObjectTypeFont: return u"EmfPlusObjectTypeFont"_ustr;
+            case EmfPlusObjectTypeStringFormat: return u"EmfPlusObjectTypeStringFormat"_ustr;
+            case EmfPlusObjectTypeImageAttributes: return u"EmfPlusObjectTypeImageAttributes"_ustr;
+            case EmfPlusObjectTypeCustomLineCap: return u"EmfPlusObjectTypeCustomLineCap"_ustr;
         }
-        return "";
+        return u""_ustr;
     }
 
     static OUString PixelOffsetModeToString(sal_uInt16 nPixelOffset)
     {
         switch (nPixelOffset)
         {
-            case PixelOffsetMode::PixelOffsetModeDefault: return "PixelOffsetModeDefault";
-            case PixelOffsetMode::PixelOffsetModeHighSpeed: return "PixelOffsetModeHighSpeed";
-            case PixelOffsetMode::PixelOffsetModeHighQuality: return "PixelOffsetModeHighQuality";
-            case PixelOffsetMode::PixelOffsetModeNone: return "PixelOffsetModeNone";
-            case PixelOffsetMode::PixelOffsetModeHalf: return "PixelOffsetModeHalf";
+            case PixelOffsetMode::PixelOffsetModeDefault: return u"PixelOffsetModeDefault"_ustr;
+            case PixelOffsetMode::PixelOffsetModeHighSpeed: return u"PixelOffsetModeHighSpeed"_ustr;
+            case PixelOffsetMode::PixelOffsetModeHighQuality: return u"PixelOffsetModeHighQuality"_ustr;
+            case PixelOffsetMode::PixelOffsetModeNone: return u"PixelOffsetModeNone"_ustr;
+            case PixelOffsetMode::PixelOffsetModeHalf: return u"PixelOffsetModeHalf"_ustr;
         }
-        return "";
+        return u""_ustr;
     }
 
     static OUString SmoothingModeToString(sal_uInt16 nSmoothMode)
     {
         switch (nSmoothMode)
         {
-            case SmoothingMode::SmoothingModeDefault: return "SmoothingModeDefault";
-            case SmoothingMode::SmoothingModeHighSpeed: return "SmoothModeHighSpeed";
-            case SmoothingMode::SmoothingModeHighQuality: return "SmoothingModeHighQuality";
-            case SmoothingMode::SmoothingModeNone: return "SmoothingModeNone";
-            case SmoothingMode::SmoothingModeAntiAlias8x4: return "SmoothingModeAntiAlias8x4";
-            case SmoothingMode::SmoothingModeAntiAlias8x8: return "SmoothingModeAntiAlias8x8";
+            case SmoothingMode::SmoothingModeDefault: return u"SmoothingModeDefault"_ustr;
+            case SmoothingMode::SmoothingModeHighSpeed: return u"SmoothModeHighSpeed"_ustr;
+            case SmoothingMode::SmoothingModeHighQuality: return u"SmoothingModeHighQuality"_ustr;
+            case SmoothingMode::SmoothingModeNone: return u"SmoothingModeNone"_ustr;
+            case SmoothingMode::SmoothingModeAntiAlias8x4: return u"SmoothingModeAntiAlias8x4"_ustr;
+            case SmoothingMode::SmoothingModeAntiAlias8x8: return u"SmoothingModeAntiAlias8x8"_ustr;
         }
-        return "";
+        return u""_ustr;
     }
 
     static OUString TextRenderingHintToString(sal_uInt16 nHint)
     {
         switch (nHint)
         {
-            case TextRenderingHint::TextRenderingHintSystemDefault: return "TextRenderingHintSystemDefault";
-            case TextRenderingHint::TextRenderingHintSingleBitPerPixelGridFit: return "TextRenderingHintSingleBitPerPixelGridFit";
-            case TextRenderingHint::TextRenderingHintSingleBitPerPixel: return "TextRenderingHintSingleBitPerPixel";
-            case TextRenderingHint::TextRenderingHintAntialiasGridFit: return "TextRenderingHintAntialiasGridFit";
-            case TextRenderingHint::TextRenderingHintAntialias: return "TextRenderingHintAntialias";
-            case TextRenderingHint::TextRenderingHintClearTypeGridFit: return "TextRenderingHintClearTypeGridFit";
+            case TextRenderingHint::TextRenderingHintSystemDefault: return u"TextRenderingHintSystemDefault"_ustr;
+            case TextRenderingHint::TextRenderingHintSingleBitPerPixelGridFit: return u"TextRenderingHintSingleBitPerPixelGridFit"_ustr;
+            case TextRenderingHint::TextRenderingHintSingleBitPerPixel: return u"TextRenderingHintSingleBitPerPixel"_ustr;
+            case TextRenderingHint::TextRenderingHintAntialiasGridFit: return u"TextRenderingHintAntialiasGridFit"_ustr;
+            case TextRenderingHint::TextRenderingHintAntialias: return u"TextRenderingHintAntialias"_ustr;
+            case TextRenderingHint::TextRenderingHintClearTypeGridFit: return u"TextRenderingHintClearTypeGridFit"_ustr;
         }
-        return "";
+        return u""_ustr;
     }
 
     static OUString InterpolationModeToString(sal_uInt16 nMode)
     {
         switch (nMode)
         {
-            case InterpolationMode::InterpolationModeDefault: return "InterpolationModeDefault";
-            case InterpolationMode::InterpolationModeLowQuality: return "InterpolationModeLowQuality";
-            case InterpolationMode::InterpolationModeHighQuality: return "InterpolationModeHighQuality";
-            case InterpolationMode::InterpolationModeBilinear: return "InterpolationModeBilinear";
-            case InterpolationMode::InterpolationModeBicubic: return "InterpolationModeBicubic";
-            case InterpolationMode::InterpolationModeNearestNeighbor: return "InterpolationModeNearestNeighbor";
-            case InterpolationMode::InterpolationModeHighQualityBilinear: return "InterpolationModeHighQualityBilinear";
-            case InterpolationMode::InterpolationModeHighQualityBicubic: return "InterpolationModeHighQualityBicubic";
+            case InterpolationMode::InterpolationModeDefault: return u"InterpolationModeDefault"_ustr;
+            case InterpolationMode::InterpolationModeLowQuality: return u"InterpolationModeLowQuality"_ustr;
+            case InterpolationMode::InterpolationModeHighQuality: return u"InterpolationModeHighQuality"_ustr;
+            case InterpolationMode::InterpolationModeBilinear: return u"InterpolationModeBilinear"_ustr;
+            case InterpolationMode::InterpolationModeBicubic: return u"InterpolationModeBicubic"_ustr;
+            case InterpolationMode::InterpolationModeNearestNeighbor: return u"InterpolationModeNearestNeighbor"_ustr;
+            case InterpolationMode::InterpolationModeHighQualityBilinear: return u"InterpolationModeHighQualityBilinear"_ustr;
+            case InterpolationMode::InterpolationModeHighQualityBicubic: return u"InterpolationModeHighQualityBicubic"_ustr;
         }
-        return "";
+        return u""_ustr;
     }
 
     OUString UnitTypeToString(sal_uInt16 nType)
     {
         switch (nType)
         {
-            case UnitTypeWorld: return "UnitTypeWorld";
-            case UnitTypeDisplay: return "UnitTypeDisplay";
-            case UnitTypePixel: return "UnitTypePixel";
-            case UnitTypePoint: return "UnitTypePoint";
-            case UnitTypeInch: return "UnitTypeInch";
-            case UnitTypeDocument: return "UnitTypeDocument";
-            case UnitTypeMillimeter: return "UnitTypeMillimeter";
+            case UnitTypeWorld: return u"UnitTypeWorld"_ustr;
+            case UnitTypeDisplay: return u"UnitTypeDisplay"_ustr;
+            case UnitTypePixel: return u"UnitTypePixel"_ustr;
+            case UnitTypePoint: return u"UnitTypePoint"_ustr;
+            case UnitTypeInch: return u"UnitTypeInch"_ustr;
+            case UnitTypeDocument: return u"UnitTypeDocument"_ustr;
+            case UnitTypeMillimeter: return u"UnitTypeMillimeter"_ustr;
         }
-        return "";
+        return u""_ustr;
     }
 
     static bool IsBrush(sal_uInt16 flags)
@@ -1609,7 +1609,7 @@ namespace emfplushelper
 
                         drawinglayer::attribute::FontAttribute fontAttribute(
                             font->family,                                          // font family
-                            "",                                                    // (no) font style
+                            u""_ustr,                                                    // (no) font style
                             font->Bold() ? 8u : 1u,                                // weight: 8 = bold
                             font->family == "SYMBOL",                              // symbol
                             stringFormat && stringFormat->DirectionVertical(),     // vertical
@@ -2171,7 +2171,7 @@ namespace emfplushelper
 
                             drawinglayer::attribute::FontAttribute fontAttribute(
                                 font->family,                                    // font family
-                                "",                                              // (no) font style
+                                u""_ustr,                                              // (no) font style
                                 font->Bold() ? 8u : 1u,                          // weight: 8 = bold
                                 font->family == "SYMBOL",                        // symbol
                                 optionFlags & 0x2,                               // vertical
diff --git a/drawinglayer/source/tools/emfppen.cxx b/drawinglayer/source/tools/emfppen.cxx
index adfee3bd3706..aaa944660110 100644
--- a/drawinglayer/source/tools/emfppen.cxx
+++ b/drawinglayer/source/tools/emfppen.cxx
@@ -102,43 +102,43 @@ namespace emfplushelper
     {
         switch (linecap)
         {
-            case LineCapTypeFlat: return "LineCapTypeFlat";
-            case LineCapTypeSquare: return "LineCapTypeSquare";
-            case LineCapTypeRound: return "LineCapTypeRound";
-            case LineCapTypeTriangle: return "LineCapTypeTriangle";
-            case LineCapTypeNoAnchor: return "LineCapTypeNoAnchor";
-            case LineCapTypeSquareAnchor: return "LineCapTypeSquareAnchor";
-            case LineCapTypeRoundAnchor: return "LineCapTypeRoundAchor";
-            case LineCapTypeDiamondAnchor: return "LineCapTypeDiamondAnchor";
-            case LineCapTypeArrowAnchor: return "LineCapTypeArrowAnchor";
-            case LineCapTypeAnchorMask: return "LineCapTypeAnchorMask";
-            case LineCapTypeCustom: return "LineCapTypeCustom";
+            case LineCapTypeFlat: return u"LineCapTypeFlat"_ustr;
+            case LineCapTypeSquare: return u"LineCapTypeSquare"_ustr;
+            case LineCapTypeRound: return u"LineCapTypeRound"_ustr;
+            case LineCapTypeTriangle: return u"LineCapTypeTriangle"_ustr;
+            case LineCapTypeNoAnchor: return u"LineCapTypeNoAnchor"_ustr;
+            case LineCapTypeSquareAnchor: return u"LineCapTypeSquareAnchor"_ustr;
+            case LineCapTypeRoundAnchor: return u"LineCapTypeRoundAchor"_ustr;
+            case LineCapTypeDiamondAnchor: return u"LineCapTypeDiamondAnchor"_ustr;
+            case LineCapTypeArrowAnchor: return u"LineCapTypeArrowAnchor"_ustr;
+            case LineCapTypeAnchorMask: return u"LineCapTypeAnchorMask"_ustr;
+            case LineCapTypeCustom: return u"LineCapTypeCustom"_ustr;
         }
-        return "";
+        return u""_ustr;
     }
 
     static OUString DashedLineCapTypeToString(sal_uInt32 dashedlinecaptype)
     {
         switch (dashedlinecaptype)
         {
-            case DashedLineCapTypeFlat: return "DashedLineCapTypeFlat";
-            case DashedLineCapTypeRound: return "DashedLineCapTypeRound";
-            case DashedLineCapTypeTriangle: return "DashedLineCapTypeTriangle";
+            case DashedLineCapTypeFlat: return u"DashedLineCapTypeFlat"_ustr;
+            case DashedLineCapTypeRound: return u"DashedLineCapTypeRound"_ustr;
+            case DashedLineCapTypeTriangle: return u"DashedLineCapTypeTriangle"_ustr;
         }
-        return "";
+        return u""_ustr;
     }
 
     static OUString PenAlignmentToString(sal_uInt32 alignment)
     {
         switch (alignment)
         {
-            case PenAlignmentCenter: return "PenAlignmentCenter";
-            case PenAlignmentInset: return "PenAlignmentInset";
-            case PenAlignmentLeft: return "PenAlignmentLeft";
-            case PenAlignmentOutset: return "PenAlignmentOutset";
-            case PenAlignmentRight: return "PenAlignmentRight";
+            case PenAlignmentCenter: return u"PenAlignmentCenter"_ustr;
+            case PenAlignmentInset: return u"PenAlignmentInset"_ustr;
+            case PenAlignmentLeft: return u"PenAlignmentLeft"_ustr;
+            case PenAlignmentOutset: return u"PenAlignmentOutset"_ustr;
+            case PenAlignmentRight: return u"PenAlignmentRight"_ustr;
         }
-        return "";
+        return u""_ustr;
     }
 
     drawinglayer::attribute::StrokeAttribute
diff --git a/drawinglayer/source/tools/emfpstringformat.cxx b/drawinglayer/source/tools/emfpstringformat.cxx
index 0a053201b4ec..c66aa090f438 100644
--- a/drawinglayer/source/tools/emfpstringformat.cxx
+++ b/drawinglayer/source/tools/emfpstringformat.cxx
@@ -87,14 +87,14 @@ namespace emfplushelper
         switch(nAlignment)
         {
             case StringAlignment::StringAlignmentNear:
-                return "StringAlignmentNear";
+                return u"StringAlignmentNear"_ustr;
             case StringAlignment::StringAlignmentCenter:
-                return "StringAlignmentCenter";
+                return u"StringAlignmentCenter"_ustr;
             case StringAlignment::StringAlignmentFar:
-                return "StringAlignmentFar";
+                return u"StringAlignmentFar"_ustr;
             default:
                 assert(false && nAlignment && "invalid string alignment value");
-                return "INVALID";
+                return u"INVALID"_ustr;
         }
     }
 
@@ -103,16 +103,16 @@ namespace emfplushelper
         switch(nSubst)
         {
             case StringDigitSubstitution::StringDigitSubstitutionUser:
-                return "StringDigitSubstitutionUser";
+                return u"StringDigitSubstitutionUser"_ustr;
             case StringDigitSubstitution::StringDigitSubstitutionNone:
-                return "StringDigitSubstitutionNone";
+                return u"StringDigitSubstitutionNone"_ustr;
             case StringDigitSubstitution::StringDigitSubstitutionNational:
-                return "StringDigitSubstitutionNational";
+                return u"StringDigitSubstitutionNational"_ustr;
             case StringDigitSubstitution::StringDigitSubstitutionTraditional:
-                return "StringDigitSubstitutionTraditional";
+                return u"StringDigitSubstitutionTraditional"_ustr;
             default:
                 assert(false && nSubst && "invalid string digit substitution value");
-                return "INVALID";
+                return u"INVALID"_ustr;
         }
     }
 
@@ -121,14 +121,14 @@ namespace emfplushelper
         switch(nHotkey)
         {
             case HotkeyPrefix::HotkeyPrefixNone:
-                return "HotkeyPrefixNone";
+                return u"HotkeyPrefixNone"_ustr;
             case HotkeyPrefix::HotkeyPrefixShow:
-                return "HotkeyPrefixShow";
+                return u"HotkeyPrefixShow"_ustr;
             case HotkeyPrefix::HotkeyPrefixHide:
-                return "HotkeyPrefixHide";
+                return u"HotkeyPrefixHide"_ustr;
             default:
                 assert(false && nHotkey && "invalid hotkey prefix value");
-                return "INVALID";
+                return u"INVALID"_ustr;
         }
     }
 
@@ -137,20 +137,20 @@ namespace emfplushelper
         switch(nTrimming)
         {
             case StringTrimming::StringTrimmingNone:
-                return "StringTrimmingNone";
+                return u"StringTrimmingNone"_ustr;
             case StringTrimming::StringTrimmingCharacter:
-                return "StringTrimmingCharacter";
+                return u"StringTrimmingCharacter"_ustr;
             case StringTrimming::StringTrimmingWord:
-                return "StringTrimmingWord";
+                return u"StringTrimmingWord"_ustr;
             case StringTrimming::StringTrimmingEllipsisCharacter:
-                return "StringTrimmingEllipsisCharacter";
+                return u"StringTrimmingEllipsisCharacter"_ustr;
             case StringTrimming::StringTrimmingEllipsisWord:
-                return "StringTrimmingEllipsisWord";
+                return u"StringTrimmingEllipsisWord"_ustr;
             case StringTrimming::StringTrimmingEllipsisPath:
-                return "StringTrimmingEllipsisPath";
+                return u"StringTrimmingEllipsisPath"_ustr;
             default:
                 assert(false && nTrimming && "invalid trim value");
-                return "INVALID";
+                return u"INVALID"_ustr;
         }
     }
 
diff --git a/drawinglayer/source/tools/primitive2dxmldump.cxx b/drawinglayer/source/tools/primitive2dxmldump.cxx
index 5658df3312d9..e16e2a5e6e0c 100644
--- a/drawinglayer/source/tools/primitive2dxmldump.cxx
+++ b/drawinglayer/source/tools/primitive2dxmldump.cxx
@@ -704,7 +704,7 @@ void Primitive2dXmlDump::decomposeAndWrite(
                 for (tools::Long y = 0; y < rSizePixel.getHeight(); y++)
                 {
                     rWriter.startElement("data");
-                    OUString aBitmapData = "";
+                    OUString aBitmapData = u""_ustr;
                     for (tools::Long x = 0; x < rSizePixel.getHeight(); x++)
                     {
                         if (x != 0)