mir/libreoffice
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

loplugin:ostr in drawinglayer

Browse Source 
Change-Id: I80d424ca042371f4d2e0a1d6be68683c7bad1784
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/167271
Reviewed-by: Noel Grandin <noel.grandin@collabora.co.uk>
Tested-by: Jenkins
This commit is contained in:
Noel Grandin 2024-05-07 12:56:18 +02:00
parent 92815f3a46
commit 8c67e94cf7
14 changed files with 380 additions and 380 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
drawinglayer/qa/unit/vclmetafileprocessor2d.cxx
View File

@ -131,7 +131,7 @@ public:
cppCanvas, metafile, cppcanvas::Renderer::Parameters()); cppCanvas, metafile, cppcanvas::Renderer::Parameters());
renderer->setTransformation(basegfx::B2DHomMatrix(14548, 0, -2, 0, 3350, 3431)); renderer->setTransformation(basegfx::B2DHomMatrix(14548, 0, -2, 0, 3350, 3431));
CPPUNIT_ASSERT(renderer->draw()); CPPUNIT_ASSERT(renderer->draw());
exportDevice("test-tdf136957", mVclDevice); exportDevice(u"test-tdf136957"_ustr, mVclDevice);
Bitmap bitmap = mVclDevice->GetBitmap(Point(), Size(1920, 1080)); Bitmap bitmap = mVclDevice->GetBitmap(Point(), Size(1920, 1080));
BitmapScopedReadAccess access(bitmap); BitmapScopedReadAccess access(bitmap);
// There should be a dotted line, without the fix it wouldn't be there, so check // There should be a dotted line, without the fix it wouldn't be there, so check

2
drawinglayer/qa/unit/vclpixelprocessor2d.cxx
View File

@ -115,7 +115,7 @@ public:
}; };
processor->process(primitives); processor->process(primitives);
exportDevice("test-tdf139000.png", device); exportDevice(u"test-tdf139000.png"_ustr, device);
Bitmap bitmap = device->GetBitmap(Point(), device->GetOutputSizePixel()); Bitmap bitmap = device->GetBitmap(Point(), device->GetOutputSizePixel());
BitmapScopedReadAccess access(bitmap); BitmapScopedReadAccess access(bitmap);
// The upper half should keep its red background color. // The upper half should keep its red background color.

6
drawinglayer/source/drawinglayeruno/xprimitive2drenderer.cxx
View File

@ -83,7 +83,7 @@ namespace drawinglayer::unorenderer
{ {
o3tl::Length eRangeUnit = o3tl::Length::mm100; o3tl::Length eRangeUnit = o3tl::Length::mm100;
comphelper::SequenceAsHashMap aViewInformationMap(aViewInformationSequence); comphelper::SequenceAsHashMap aViewInformationMap(aViewInformationSequence);
auto it = aViewInformationMap.find("RangeUnit"); auto it = aViewInformationMap.find(u"RangeUnit"_ustr);
if (it != aViewInformationMap.end()) if (it != aViewInformationMap.end())
{ {
sal_Int32 nVal{}; sal_Int32 nVal{};
@ -165,7 +165,7 @@ namespace drawinglayer::unorenderer
OUString SAL_CALL XPrimitive2DRenderer::getImplementationName() OUString SAL_CALL XPrimitive2DRenderer::getImplementationName()
{ {
return "drawinglayer::unorenderer::XPrimitive2DRenderer"; return u"drawinglayer::unorenderer::XPrimitive2DRenderer"_ustr;
} }
sal_Bool SAL_CALL XPrimitive2DRenderer::supportsService(const OUString& rServiceName) sal_Bool SAL_CALL XPrimitive2DRenderer::supportsService(const OUString& rServiceName)
@ -175,7 +175,7 @@ namespace drawinglayer::unorenderer
uno::Sequence< OUString > SAL_CALL XPrimitive2DRenderer::getSupportedServiceNames() uno::Sequence< OUString > SAL_CALL XPrimitive2DRenderer::getSupportedServiceNames()
{ {
return { "com.sun.star.graphic.Primitive2DTools" }; return { u"com.sun.star.graphic.Primitive2DTools"_ustr };
} }
} // end of namespace } // end of namespace

128
drawinglayer/source/dumper/EnhancedShapeDumper.cxx
View File

@ -19,139 +19,139 @@ using namespace com::sun::star;
void EnhancedShapeDumper::dumpEnhancedCustomShapeExtrusionService(const uno::Reference< beans::XPropertySet >& xPropSet) 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; bool bExtrusion;
if(anotherAny >>= bExtrusion) if(anotherAny >>= bExtrusion)
dumpExtrusionAsAttribute(bExtrusion); dumpExtrusionAsAttribute(bExtrusion);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("Brightness"); uno::Any anotherAny = xPropSet->getPropertyValue(u"Brightness"_ustr);
double aBrightness = double(); double aBrightness = double();
if(anotherAny >>= aBrightness) if(anotherAny >>= aBrightness)
dumpBrightnessAsAttribute(aBrightness); dumpBrightnessAsAttribute(aBrightness);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("Depth"); uno::Any anotherAny = xPropSet->getPropertyValue(u"Depth"_ustr);
drawing::EnhancedCustomShapeParameterPair aDepth; drawing::EnhancedCustomShapeParameterPair aDepth;
if(anotherAny >>= aDepth) if(anotherAny >>= aDepth)
dumpDepthAsElement(aDepth); dumpDepthAsElement(aDepth);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("Diffusion"); uno::Any anotherAny = xPropSet->getPropertyValue(u"Diffusion"_ustr);
double aDiffusion = double(); double aDiffusion = double();
if(anotherAny >>= aDiffusion) if(anotherAny >>= aDiffusion)
dumpDiffusionAsAttribute(aDiffusion); dumpDiffusionAsAttribute(aDiffusion);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("NumberOfLineSegments"); uno::Any anotherAny = xPropSet->getPropertyValue(u"NumberOfLineSegments"_ustr);
sal_Int32 aNumberOfLineSegments = sal_Int32(); sal_Int32 aNumberOfLineSegments = sal_Int32();
if(anotherAny >>= aNumberOfLineSegments) if(anotherAny >>= aNumberOfLineSegments)
dumpNumberOfLineSegmentsAsAttribute(aNumberOfLineSegments); dumpNumberOfLineSegmentsAsAttribute(aNumberOfLineSegments);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("LightFace"); uno::Any anotherAny = xPropSet->getPropertyValue(u"LightFace"_ustr);
bool bLightFace; bool bLightFace;
if(anotherAny >>= bLightFace) if(anotherAny >>= bLightFace)
dumpLightFaceAsAttribute(bLightFace); dumpLightFaceAsAttribute(bLightFace);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("FirstLightHarsh"); uno::Any anotherAny = xPropSet->getPropertyValue(u"FirstLightHarsh"_ustr);
bool bFirstLightHarsh; bool bFirstLightHarsh;
if(anotherAny >>= bFirstLightHarsh) if(anotherAny >>= bFirstLightHarsh)
dumpFirstLightHarshAsAttribute(bFirstLightHarsh); dumpFirstLightHarshAsAttribute(bFirstLightHarsh);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("SecondLightHarsh"); uno::Any anotherAny = xPropSet->getPropertyValue(u"SecondLightHarsh"_ustr);
bool bSecondLightHarsh; bool bSecondLightHarsh;
if(anotherAny >>= bSecondLightHarsh) if(anotherAny >>= bSecondLightHarsh)
dumpSecondLightHarshAsAttribute(bSecondLightHarsh); dumpSecondLightHarshAsAttribute(bSecondLightHarsh);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("FirstLightLevel"); uno::Any anotherAny = xPropSet->getPropertyValue(u"FirstLightLevel"_ustr);
double aFirstLightLevel = double(); double aFirstLightLevel = double();
if(anotherAny >>= aFirstLightLevel) if(anotherAny >>= aFirstLightLevel)
dumpFirstLightLevelAsAttribute(aFirstLightLevel); dumpFirstLightLevelAsAttribute(aFirstLightLevel);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("SecondLightLevel"); uno::Any anotherAny = xPropSet->getPropertyValue(u"SecondLightLevel"_ustr);
double aSecondLightLevel = double(); double aSecondLightLevel = double();
if(anotherAny >>= aSecondLightLevel) if(anotherAny >>= aSecondLightLevel)
dumpSecondLightLevelAsAttribute(aSecondLightLevel); dumpSecondLightLevelAsAttribute(aSecondLightLevel);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("FirstLightDirection"); uno::Any anotherAny = xPropSet->getPropertyValue(u"FirstLightDirection"_ustr);
drawing::Direction3D aFirstLightDirection; drawing::Direction3D aFirstLightDirection;
if(anotherAny >>= aFirstLightDirection) if(anotherAny >>= aFirstLightDirection)
dumpFirstLightDirectionAsElement(aFirstLightDirection); dumpFirstLightDirectionAsElement(aFirstLightDirection);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("SecondLightDirection"); uno::Any anotherAny = xPropSet->getPropertyValue(u"SecondLightDirection"_ustr);
drawing::Direction3D aSecondLightDirection; drawing::Direction3D aSecondLightDirection;
if(anotherAny >>= aSecondLightDirection) if(anotherAny >>= aSecondLightDirection)
dumpSecondLightDirectionAsElement(aSecondLightDirection); dumpSecondLightDirectionAsElement(aSecondLightDirection);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("Metal"); uno::Any anotherAny = xPropSet->getPropertyValue(u"Metal"_ustr);
bool bMetal; bool bMetal;
if(anotherAny >>= bMetal) if(anotherAny >>= bMetal)
dumpMetalAsAttribute(bMetal); dumpMetalAsAttribute(bMetal);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("ShadeMode"); uno::Any anotherAny = xPropSet->getPropertyValue(u"ShadeMode"_ustr);
drawing::ShadeMode eShadeMode; drawing::ShadeMode eShadeMode;
if(anotherAny >>= eShadeMode) if(anotherAny >>= eShadeMode)
dumpShadeModeAsAttribute(eShadeMode); dumpShadeModeAsAttribute(eShadeMode);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("RotateAngle"); uno::Any anotherAny = xPropSet->getPropertyValue(u"RotateAngle"_ustr);
drawing::EnhancedCustomShapeParameterPair aRotateAngle; drawing::EnhancedCustomShapeParameterPair aRotateAngle;
if(anotherAny >>= aRotateAngle) if(anotherAny >>= aRotateAngle)
dumpRotateAngleAsElement(aRotateAngle); dumpRotateAngleAsElement(aRotateAngle);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("RotationCenter"); uno::Any anotherAny = xPropSet->getPropertyValue(u"RotationCenter"_ustr);
drawing::Direction3D aRotationCenter; drawing::Direction3D aRotationCenter;
if(anotherAny >>= aRotationCenter) if(anotherAny >>= aRotationCenter)
dumpRotationCenterAsElement(aRotationCenter); dumpRotationCenterAsElement(aRotationCenter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("Shininess"); uno::Any anotherAny = xPropSet->getPropertyValue(u"Shininess"_ustr);
double aShininess = double(); double aShininess = double();
if(anotherAny >>= aShininess) if(anotherAny >>= aShininess)
dumpShininessAsAttribute(aShininess); dumpShininessAsAttribute(aShininess);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("Skew"); uno::Any anotherAny = xPropSet->getPropertyValue(u"Skew"_ustr);
drawing::EnhancedCustomShapeParameterPair aSkew; drawing::EnhancedCustomShapeParameterPair aSkew;
if(anotherAny >>= aSkew) if(anotherAny >>= aSkew)
dumpSkewAsElement(aSkew); dumpSkewAsElement(aSkew);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("Specularity"); uno::Any anotherAny = xPropSet->getPropertyValue(u"Specularity"_ustr);
double aSpecularity = double(); double aSpecularity = double();
if(anotherAny >>= aSpecularity) if(anotherAny >>= aSpecularity)
dumpSpecularityAsAttribute(aSpecularity); dumpSpecularityAsAttribute(aSpecularity);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("ProjectionMode"); uno::Any anotherAny = xPropSet->getPropertyValue(u"ProjectionMode"_ustr);
drawing::ProjectionMode eProjectionMode; drawing::ProjectionMode eProjectionMode;
if(anotherAny >>= eProjectionMode) if(anotherAny >>= eProjectionMode)
dumpProjectionModeAsAttribute(eProjectionMode); dumpProjectionModeAsAttribute(eProjectionMode);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("ViewPoint"); uno::Any anotherAny = xPropSet->getPropertyValue(u"ViewPoint"_ustr);
drawing::Position3D aViewPoint; drawing::Position3D aViewPoint;
if(anotherAny >>= aViewPoint) if(anotherAny >>= aViewPoint)
dumpViewPointAsElement(aViewPoint); dumpViewPointAsElement(aViewPoint);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("Origin"); uno::Any anotherAny = xPropSet->getPropertyValue(u"Origin"_ustr);
drawing::EnhancedCustomShapeParameterPair aOrigin; drawing::EnhancedCustomShapeParameterPair aOrigin;
if(anotherAny >>= aOrigin) if(anotherAny >>= aOrigin)
dumpOriginAsElement(aOrigin); dumpOriginAsElement(aOrigin);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("ExtrusionColor"); uno::Any anotherAny = xPropSet->getPropertyValue(u"ExtrusionColor"_ustr);
bool bExtrusionColor; bool bExtrusionColor;
if(anotherAny >>= bExtrusionColor) if(anotherAny >>= bExtrusionColor)
dumpExtrusionColorAsAttribute(bExtrusionColor); dumpExtrusionColorAsAttribute(bExtrusionColor);
@ -363,67 +363,67 @@ void EnhancedShapeDumper::dumpExtrusionColorAsAttribute(bool bExtrusionColor)
void EnhancedShapeDumper::dumpEnhancedCustomShapeGeometryService(const uno::Reference< beans::XPropertySet >& xPropSet) 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; OUString sType;
if(anotherAny >>= sType) if(anotherAny >>= sType)
dumpTypeAsAttribute(sType); dumpTypeAsAttribute(sType);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("ViewBox"); uno::Any anotherAny = xPropSet->getPropertyValue(u"ViewBox"_ustr);
awt::Rectangle aViewBox; awt::Rectangle aViewBox;
if(anotherAny >>= aViewBox) if(anotherAny >>= aViewBox)
dumpViewBoxAsElement(aViewBox); dumpViewBoxAsElement(aViewBox);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("MirroredX"); uno::Any anotherAny = xPropSet->getPropertyValue(u"MirroredX"_ustr);
bool bMirroredX; bool bMirroredX;
if(anotherAny >>= bMirroredX) if(anotherAny >>= bMirroredX)
dumpMirroredXAsAttribute(bMirroredX); dumpMirroredXAsAttribute(bMirroredX);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("MirroredY"); uno::Any anotherAny = xPropSet->getPropertyValue(u"MirroredY"_ustr);
bool bMirroredY; bool bMirroredY;
if(anotherAny >>= bMirroredY) if(anotherAny >>= bMirroredY)
dumpMirroredYAsAttribute(bMirroredY); dumpMirroredYAsAttribute(bMirroredY);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("TextRotateAngle"); uno::Any anotherAny = xPropSet->getPropertyValue(u"TextRotateAngle"_ustr);
double aTextRotateAngle = double(); double aTextRotateAngle = double();
if(anotherAny >>= aTextRotateAngle) if(anotherAny >>= aTextRotateAngle)
dumpTextRotateAngleAsAttribute(aTextRotateAngle); dumpTextRotateAngleAsAttribute(aTextRotateAngle);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("AdjustmentValues"); uno::Any anotherAny = xPropSet->getPropertyValue(u"AdjustmentValues"_ustr);
uno::Sequence< drawing::EnhancedCustomShapeAdjustmentValue> aAdjustmentValues; uno::Sequence< drawing::EnhancedCustomShapeAdjustmentValue> aAdjustmentValues;
if(anotherAny >>= aAdjustmentValues) if(anotherAny >>= aAdjustmentValues)
dumpAdjustmentValuesAsElement(aAdjustmentValues); dumpAdjustmentValuesAsElement(aAdjustmentValues);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("Extrusion"); uno::Any anotherAny = xPropSet->getPropertyValue(u"Extrusion"_ustr);
uno::Sequence< beans::PropertyValue > aExtrusion; uno::Sequence< beans::PropertyValue > aExtrusion;
if(anotherAny >>= aExtrusion) if(anotherAny >>= aExtrusion)
dumpExtrusionAsElement(aExtrusion); dumpExtrusionAsElement(aExtrusion);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("Path"); uno::Any anotherAny = xPropSet->getPropertyValue(u"Path"_ustr);
uno::Sequence< beans::PropertyValue > aPath; uno::Sequence< beans::PropertyValue > aPath;
if(anotherAny >>= aPath) if(anotherAny >>= aPath)
dumpPathAsElement(aPath); dumpPathAsElement(aPath);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("TextPath"); uno::Any anotherAny = xPropSet->getPropertyValue(u"TextPath"_ustr);
uno::Sequence< beans::PropertyValue > aTextPath; uno::Sequence< beans::PropertyValue > aTextPath;
if(anotherAny >>= aTextPath) if(anotherAny >>= aTextPath)
dumpTextPathAsElement(aTextPath); dumpTextPathAsElement(aTextPath);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("Equations"); uno::Any anotherAny = xPropSet->getPropertyValue(u"Equations"_ustr);
uno::Sequence< OUString > aEquations; uno::Sequence< OUString > aEquations;
if(anotherAny >>= aEquations) if(anotherAny >>= aEquations)
dumpEquationsAsElement(aEquations); dumpEquationsAsElement(aEquations);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("Handles"); uno::Any anotherAny = xPropSet->getPropertyValue(u"Handles"_ustr);
uno::Sequence< beans::PropertyValues > aHandles; uno::Sequence< beans::PropertyValues > aHandles;
if(anotherAny >>= aHandles) if(anotherAny >>= aHandles)
dumpHandlesAsElement(aHandles); dumpHandlesAsElement(aHandles);
@ -613,91 +613,91 @@ void EnhancedShapeDumper::dumpHandlesAsElement(const uno::Sequence< beans::Prope
void EnhancedShapeDumper::dumpEnhancedCustomShapeHandleService(const uno::Reference< beans::XPropertySet >& xPropSet) 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; bool bMirroredX;
if(anotherAny >>= bMirroredX) if(anotherAny >>= bMirroredX)
dumpMirroredXAsAttribute(bMirroredX); dumpMirroredXAsAttribute(bMirroredX);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("MirroredY"); uno::Any anotherAny = xPropSet->getPropertyValue(u"MirroredY"_ustr);
bool bMirroredY; bool bMirroredY;
if(anotherAny >>= bMirroredY) if(anotherAny >>= bMirroredY)
dumpMirroredYAsAttribute(bMirroredY); dumpMirroredYAsAttribute(bMirroredY);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("Switched"); uno::Any anotherAny = xPropSet->getPropertyValue(u"Switched"_ustr);
bool bSwitched; bool bSwitched;
if(anotherAny >>= bSwitched) if(anotherAny >>= bSwitched)
dumpSwitchedAsAttribute(bSwitched); dumpSwitchedAsAttribute(bSwitched);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("Position"); uno::Any anotherAny = xPropSet->getPropertyValue(u"Position"_ustr);
drawing::EnhancedCustomShapeParameterPair aPosition; drawing::EnhancedCustomShapeParameterPair aPosition;
if(anotherAny >>= aPosition) if(anotherAny >>= aPosition)
dumpPositionAsElement(aPosition); dumpPositionAsElement(aPosition);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("Polar"); uno::Any anotherAny = xPropSet->getPropertyValue(u"Polar"_ustr);
drawing::EnhancedCustomShapeParameterPair aPolar; drawing::EnhancedCustomShapeParameterPair aPolar;
if(anotherAny >>= aPolar) if(anotherAny >>= aPolar)
dumpPolarAsElement(aPolar); dumpPolarAsElement(aPolar);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("RefX"); uno::Any anotherAny = xPropSet->getPropertyValue(u"RefX"_ustr);
sal_Int32 aRefX = sal_Int32(); sal_Int32 aRefX = sal_Int32();
if(anotherAny >>= aRefX) if(anotherAny >>= aRefX)
dumpRefXAsAttribute(aRefX); dumpRefXAsAttribute(aRefX);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("RefY"); uno::Any anotherAny = xPropSet->getPropertyValue(u"RefY"_ustr);
sal_Int32 aRefY = sal_Int32(); sal_Int32 aRefY = sal_Int32();
if(anotherAny >>= aRefY) if(anotherAny >>= aRefY)
dumpRefYAsAttribute(aRefY); dumpRefYAsAttribute(aRefY);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("RefAngle"); uno::Any anotherAny = xPropSet->getPropertyValue(u"RefAngle"_ustr);
sal_Int32 aRefAngle = sal_Int32(); sal_Int32 aRefAngle = sal_Int32();
if(anotherAny >>= aRefAngle) if(anotherAny >>= aRefAngle)
dumpRefAngleAsAttribute(aRefAngle); dumpRefAngleAsAttribute(aRefAngle);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("RefR"); uno::Any anotherAny = xPropSet->getPropertyValue(u"RefR"_ustr);
sal_Int32 aRefR = sal_Int32(); sal_Int32 aRefR = sal_Int32();
if(anotherAny >>= aRefR) if(anotherAny >>= aRefR)
dumpRefRAsAttribute(aRefR); dumpRefRAsAttribute(aRefR);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("RangeXMinimum"); uno::Any anotherAny = xPropSet->getPropertyValue(u"RangeXMinimum"_ustr);
drawing::EnhancedCustomShapeParameter aRangeXMinimum; drawing::EnhancedCustomShapeParameter aRangeXMinimum;
if(anotherAny >>= aRangeXMinimum) if(anotherAny >>= aRangeXMinimum)
dumpRangeXMinimumAsElement(aRangeXMinimum); dumpRangeXMinimumAsElement(aRangeXMinimum);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("RangeXMaximum"); uno::Any anotherAny = xPropSet->getPropertyValue(u"RangeXMaximum"_ustr);
drawing::EnhancedCustomShapeParameter aRangeXMaximum; drawing::EnhancedCustomShapeParameter aRangeXMaximum;
if(anotherAny >>= aRangeXMaximum) if(anotherAny >>= aRangeXMaximum)
dumpRangeXMaximumAsElement(aRangeXMaximum); dumpRangeXMaximumAsElement(aRangeXMaximum);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("RangeYMinimum"); uno::Any anotherAny = xPropSet->getPropertyValue(u"RangeYMinimum"_ustr);
drawing::EnhancedCustomShapeParameter aRangeYMinimum; drawing::EnhancedCustomShapeParameter aRangeYMinimum;
if(anotherAny >>= aRangeYMinimum) if(anotherAny >>= aRangeYMinimum)
dumpRangeYMinimumAsElement(aRangeYMinimum); dumpRangeYMinimumAsElement(aRangeYMinimum);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("RangeYMaximum"); uno::Any anotherAny = xPropSet->getPropertyValue(u"RangeYMaximum"_ustr);
drawing::EnhancedCustomShapeParameter aRangeYMaximum; drawing::EnhancedCustomShapeParameter aRangeYMaximum;
if(anotherAny >>= aRangeYMaximum) if(anotherAny >>= aRangeYMaximum)
dumpRangeYMaximumAsElement(aRangeYMaximum); dumpRangeYMaximumAsElement(aRangeYMaximum);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("RadiusRangeMinimum"); uno::Any anotherAny = xPropSet->getPropertyValue(u"RadiusRangeMinimum"_ustr);
drawing::EnhancedCustomShapeParameter aRadiusRangeMinimum; drawing::EnhancedCustomShapeParameter aRadiusRangeMinimum;
if(anotherAny >>= aRadiusRangeMinimum) if(anotherAny >>= aRadiusRangeMinimum)
dumpRadiusRangeMinimumAsElement(aRadiusRangeMinimum); dumpRadiusRangeMinimumAsElement(aRadiusRangeMinimum);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("RadiusRangeMaximum"); uno::Any anotherAny = xPropSet->getPropertyValue(u"RadiusRangeMaximum"_ustr);
drawing::EnhancedCustomShapeParameter aRadiusRangeMaximum; drawing::EnhancedCustomShapeParameter aRadiusRangeMaximum;
if(anotherAny >>= aRadiusRangeMaximum) if(anotherAny >>= aRadiusRangeMaximum)
dumpRadiusRangeMaximumAsElement(aRadiusRangeMaximum); dumpRadiusRangeMaximumAsElement(aRadiusRangeMaximum);
@ -824,73 +824,73 @@ void EnhancedShapeDumper::dumpRadiusRangeMaximumAsElement(const drawing::Enhance
void EnhancedShapeDumper::dumpEnhancedCustomShapePathService(const uno::Reference< beans::XPropertySet >& xPropSet) 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; uno::Sequence< drawing::EnhancedCustomShapeParameterPair > aCoordinates;
if(anotherAny >>= aCoordinates) if(anotherAny >>= aCoordinates)
dumpCoordinatesAsElement(aCoordinates); dumpCoordinatesAsElement(aCoordinates);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("Segments"); uno::Any anotherAny = xPropSet->getPropertyValue(u"Segments"_ustr);
uno::Sequence< drawing::EnhancedCustomShapeSegment > aSegments; uno::Sequence< drawing::EnhancedCustomShapeSegment > aSegments;
if(anotherAny >>= aSegments) if(anotherAny >>= aSegments)
dumpSegmentsAsElement(aSegments); dumpSegmentsAsElement(aSegments);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("StretchX"); uno::Any anotherAny = xPropSet->getPropertyValue(u"StretchX"_ustr);
sal_Int32 aStretchX = sal_Int32(); sal_Int32 aStretchX = sal_Int32();
if(anotherAny >>= aStretchX) if(anotherAny >>= aStretchX)
dumpStretchXAsAttribute(aStretchX); dumpStretchXAsAttribute(aStretchX);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("StretchY"); uno::Any anotherAny = xPropSet->getPropertyValue(u"StretchY"_ustr);
sal_Int32 aStretchY = sal_Int32(); sal_Int32 aStretchY = sal_Int32();
if(anotherAny >>= aStretchY) if(anotherAny >>= aStretchY)
dumpStretchYAsAttribute(aStretchY); dumpStretchYAsAttribute(aStretchY);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("TextFrames"); uno::Any anotherAny = xPropSet->getPropertyValue(u"TextFrames"_ustr);
uno::Sequence< drawing::EnhancedCustomShapeTextFrame > aTextFrames; uno::Sequence< drawing::EnhancedCustomShapeTextFrame > aTextFrames;
if(anotherAny >>= aTextFrames) if(anotherAny >>= aTextFrames)
dumpTextFramesAsElement(aTextFrames); dumpTextFramesAsElement(aTextFrames);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("GluePoints"); uno::Any anotherAny = xPropSet->getPropertyValue(u"GluePoints"_ustr);
uno::Sequence< drawing::EnhancedCustomShapeParameterPair > aGluePoints; uno::Sequence< drawing::EnhancedCustomShapeParameterPair > aGluePoints;
if(anotherAny >>= aGluePoints) if(anotherAny >>= aGluePoints)
dumpGluePointsAsElement(aGluePoints); dumpGluePointsAsElement(aGluePoints);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("GluePointLeavingDirections"); uno::Any anotherAny = xPropSet->getPropertyValue(u"GluePointLeavingDirections"_ustr);
uno::Sequence< double > aGluePointLeavingDirections; uno::Sequence< double > aGluePointLeavingDirections;
if(anotherAny >>= aGluePointLeavingDirections) if(anotherAny >>= aGluePointLeavingDirections)
dumpGluePointLeavingDirectionsAsElement(aGluePointLeavingDirections); dumpGluePointLeavingDirectionsAsElement(aGluePointLeavingDirections);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("GluePointType"); uno::Any anotherAny = xPropSet->getPropertyValue(u"GluePointType"_ustr);
sal_Int32 aGluePointType = sal_Int32(); sal_Int32 aGluePointType = sal_Int32();
if(anotherAny >>= aGluePointType) if(anotherAny >>= aGluePointType)
dumpGluePointTypeAsAttribute(aGluePointType); dumpGluePointTypeAsAttribute(aGluePointType);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("ExtrusionAllowed"); uno::Any anotherAny = xPropSet->getPropertyValue(u"ExtrusionAllowed"_ustr);
bool bExtrusionAllowed; bool bExtrusionAllowed;
if(anotherAny >>= bExtrusionAllowed) if(anotherAny >>= bExtrusionAllowed)
dumpExtrusionAllowedAsAttribute(bExtrusionAllowed); dumpExtrusionAllowedAsAttribute(bExtrusionAllowed);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("ConcentricGradientFillAllowed"); uno::Any anotherAny = xPropSet->getPropertyValue(u"ConcentricGradientFillAllowed"_ustr);
bool bConcentricGradientFillAllowed; bool bConcentricGradientFillAllowed;
if(anotherAny >>= bConcentricGradientFillAllowed) if(anotherAny >>= bConcentricGradientFillAllowed)
dumpConcentricGradientFillAllowedAsAttribute(bConcentricGradientFillAllowed); dumpConcentricGradientFillAllowedAsAttribute(bConcentricGradientFillAllowed);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("TextPathAllowed"); uno::Any anotherAny = xPropSet->getPropertyValue(u"TextPathAllowed"_ustr);
bool bTextPathAllowed; bool bTextPathAllowed;
if(anotherAny >>= bTextPathAllowed) if(anotherAny >>= bTextPathAllowed)
dumpTextPathAllowedAsAttribute(bTextPathAllowed); dumpTextPathAllowedAsAttribute(bTextPathAllowed);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("SubViewSize"); uno::Any anotherAny = xPropSet->getPropertyValue(u"SubViewSize"_ustr);
uno::Sequence< awt::Size > aSubViewSize; uno::Sequence< awt::Size > aSubViewSize;
if(anotherAny >>= aSubViewSize) if(anotherAny >>= aSubViewSize)
dumpSubViewSizeAsElement(aSubViewSize); dumpSubViewSizeAsElement(aSubViewSize);
@ -1025,19 +1025,19 @@ void EnhancedShapeDumper::dumpSubViewSizeAsElement(const uno::Sequence< awt::Siz
void EnhancedShapeDumper::dumpEnhancedCustomShapeTextPathService(const uno::Reference< beans::XPropertySet >& xPropSet) 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; bool bTextPath;
if(anotherAny >>= bTextPath) if(anotherAny >>= bTextPath)
dumpTextPathAsAttribute(bTextPath); dumpTextPathAsAttribute(bTextPath);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("TextPathMode"); uno::Any anotherAny = xPropSet->getPropertyValue(u"TextPathMode"_ustr);
drawing::EnhancedCustomShapeTextPathMode eTextPathMode; drawing::EnhancedCustomShapeTextPathMode eTextPathMode;
if(anotherAny >>= eTextPathMode) if(anotherAny >>= eTextPathMode)
dumpTextPathModeAsAttribute(eTextPathMode); dumpTextPathModeAsAttribute(eTextPathMode);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("ScaleX"); uno::Any anotherAny = xPropSet->getPropertyValue(u"ScaleX"_ustr);
bool bScaleX; bool bScaleX;
if(anotherAny >>= bScaleX) if(anotherAny >>= bScaleX)
dumpScaleXAsAttribute(bScaleX); dumpScaleXAsAttribute(bScaleX);

226
drawinglayer/source/dumper/XShapeDumper.cxx
View File

@ -1228,157 +1228,157 @@ void dumpCustomShapeReplacementURLAsAttribute(std::u16string_view sCustomShapeRe
void dumpTextPropertiesService(const uno::Reference< beans::XPropertySet >& xPropSet, xmlTextWriterPtr xmlWriter) void dumpTextPropertiesService(const uno::Reference< beans::XPropertySet >& xPropSet, xmlTextWriterPtr xmlWriter)
{ {
uno::Reference< beans::XPropertySetInfo> xInfo = xPropSet->getPropertySetInfo(); 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; float fHeight;
if(anotherAny >>= fHeight) if(anotherAny >>= fHeight)
dumpCharHeightAsAttribute(fHeight, xmlWriter); 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(); sal_Int32 aColor = sal_Int32();
if(anotherAny >>= aColor) if(anotherAny >>= aColor)
dumpCharColorAsAttribute(aColor, xmlWriter); dumpCharColorAsAttribute(aColor, xmlWriter);
} }
// TODO - more properties from CharacterProperties.idl (similar to above) // 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; bool bIsNumbering;
if(anotherAny >>= bIsNumbering) if(anotherAny >>= bIsNumbering)
dumpIsNumberingAsAttribute(bIsNumbering, xmlWriter); dumpIsNumberingAsAttribute(bIsNumbering, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("TextAutoGrowHeight"); uno::Any anotherAny = xPropSet->getPropertyValue(u"TextAutoGrowHeight"_ustr);
bool bTextAutoGrowHeight; bool bTextAutoGrowHeight;
if(anotherAny >>= bTextAutoGrowHeight) if(anotherAny >>= bTextAutoGrowHeight)
dumpTextAutoGrowHeightAsAttribute(bTextAutoGrowHeight, xmlWriter); dumpTextAutoGrowHeightAsAttribute(bTextAutoGrowHeight, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("TextAutoGrowWidth"); uno::Any anotherAny = xPropSet->getPropertyValue(u"TextAutoGrowWidth"_ustr);
bool bTextAutoGrowWidth; bool bTextAutoGrowWidth;
if(anotherAny >>= bTextAutoGrowWidth) if(anotherAny >>= bTextAutoGrowWidth)
dumpTextAutoGrowWidthAsAttribute(bTextAutoGrowWidth, xmlWriter); dumpTextAutoGrowWidthAsAttribute(bTextAutoGrowWidth, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("TextContourFrame"); uno::Any anotherAny = xPropSet->getPropertyValue(u"TextContourFrame"_ustr);
bool bTextContourFrame; bool bTextContourFrame;
if(anotherAny >>= bTextContourFrame) if(anotherAny >>= bTextContourFrame)
dumpTextContourFrameAsAttribute(bTextContourFrame, xmlWriter); dumpTextContourFrameAsAttribute(bTextContourFrame, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("TextFitToSize"); uno::Any anotherAny = xPropSet->getPropertyValue(u"TextFitToSize"_ustr);
drawing::TextFitToSizeType eTextFitToSize; drawing::TextFitToSizeType eTextFitToSize;
if(anotherAny >>= eTextFitToSize) if(anotherAny >>= eTextFitToSize)
dumpTextFitToSizeAsAttribute(eTextFitToSize, xmlWriter); dumpTextFitToSizeAsAttribute(eTextFitToSize, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("TextHorizontalAdjust"); uno::Any anotherAny = xPropSet->getPropertyValue(u"TextHorizontalAdjust"_ustr);
drawing::TextHorizontalAdjust eTextHorizontalAdjust; drawing::TextHorizontalAdjust eTextHorizontalAdjust;
if(anotherAny >>= eTextHorizontalAdjust) if(anotherAny >>= eTextHorizontalAdjust)
dumpTextHorizontalAdjustAsAttribute(eTextHorizontalAdjust, xmlWriter); dumpTextHorizontalAdjustAsAttribute(eTextHorizontalAdjust, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("TextVerticalAdjust"); uno::Any anotherAny = xPropSet->getPropertyValue(u"TextVerticalAdjust"_ustr);
drawing::TextVerticalAdjust eTextVerticalAdjust; drawing::TextVerticalAdjust eTextVerticalAdjust;
if(anotherAny >>= eTextVerticalAdjust) if(anotherAny >>= eTextVerticalAdjust)
dumpTextVerticalAdjustAsAttribute(eTextVerticalAdjust, xmlWriter); dumpTextVerticalAdjustAsAttribute(eTextVerticalAdjust, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("TextLeftDistance"); uno::Any anotherAny = xPropSet->getPropertyValue(u"TextLeftDistance"_ustr);
sal_Int32 aTextLeftDistance = sal_Int32(); sal_Int32 aTextLeftDistance = sal_Int32();
if(anotherAny >>= aTextLeftDistance) if(anotherAny >>= aTextLeftDistance)
dumpTextLeftDistanceAsAttribute(aTextLeftDistance, xmlWriter); dumpTextLeftDistanceAsAttribute(aTextLeftDistance, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("TextRightDistance"); uno::Any anotherAny = xPropSet->getPropertyValue(u"TextRightDistance"_ustr);
sal_Int32 aTextRightDistance = sal_Int32(); sal_Int32 aTextRightDistance = sal_Int32();
if(anotherAny >>= aTextRightDistance) if(anotherAny >>= aTextRightDistance)
dumpTextRightDistanceAsAttribute(aTextRightDistance, xmlWriter); dumpTextRightDistanceAsAttribute(aTextRightDistance, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("TextUpperDistance"); uno::Any anotherAny = xPropSet->getPropertyValue(u"TextUpperDistance"_ustr);
sal_Int32 aTextUpperDistance = sal_Int32(); sal_Int32 aTextUpperDistance = sal_Int32();
if(anotherAny >>= aTextUpperDistance) if(anotherAny >>= aTextUpperDistance)
dumpTextUpperDistanceAsAttribute(aTextUpperDistance, xmlWriter); dumpTextUpperDistanceAsAttribute(aTextUpperDistance, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("TextLowerDistance"); uno::Any anotherAny = xPropSet->getPropertyValue(u"TextLowerDistance"_ustr);
sal_Int32 aTextLowerDistance = sal_Int32(); sal_Int32 aTextLowerDistance = sal_Int32();
if(anotherAny >>= aTextLowerDistance) if(anotherAny >>= aTextLowerDistance)
dumpTextLowerDistanceAsAttribute(aTextLowerDistance, xmlWriter); dumpTextLowerDistanceAsAttribute(aTextLowerDistance, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("TextMaximumFrameHeight"); uno::Any anotherAny = xPropSet->getPropertyValue(u"TextMaximumFrameHeight"_ustr);
sal_Int32 aTextMaximumFrameHeight = sal_Int32(); sal_Int32 aTextMaximumFrameHeight = sal_Int32();
if(anotherAny >>= aTextMaximumFrameHeight) if(anotherAny >>= aTextMaximumFrameHeight)
dumpTextMaximumFrameHeightAsAttribute(aTextMaximumFrameHeight, xmlWriter); dumpTextMaximumFrameHeightAsAttribute(aTextMaximumFrameHeight, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("TextMaximumFrameWidth"); uno::Any anotherAny = xPropSet->getPropertyValue(u"TextMaximumFrameWidth"_ustr);
sal_Int32 aTextMaximumFrameWidth = sal_Int32(); sal_Int32 aTextMaximumFrameWidth = sal_Int32();
if(anotherAny >>= aTextMaximumFrameWidth) if(anotherAny >>= aTextMaximumFrameWidth)
dumpTextMaximumFrameWidthAsAttribute(aTextMaximumFrameWidth, xmlWriter); dumpTextMaximumFrameWidthAsAttribute(aTextMaximumFrameWidth, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("TextMinimumFrameHeight"); uno::Any anotherAny = xPropSet->getPropertyValue(u"TextMinimumFrameHeight"_ustr);
sal_Int32 aTextMinimumFrameHeight = sal_Int32(); sal_Int32 aTextMinimumFrameHeight = sal_Int32();
if(anotherAny >>= aTextMinimumFrameHeight) if(anotherAny >>= aTextMinimumFrameHeight)
dumpTextMinimumFrameHeightAsAttribute(aTextMinimumFrameHeight, xmlWriter); dumpTextMinimumFrameHeightAsAttribute(aTextMinimumFrameHeight, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("TextMinimumFrameWidth"); uno::Any anotherAny = xPropSet->getPropertyValue(u"TextMinimumFrameWidth"_ustr);
sal_Int32 aTextMinimumFrameWidth = sal_Int32(); sal_Int32 aTextMinimumFrameWidth = sal_Int32();
if(anotherAny >>= aTextMinimumFrameWidth) if(anotherAny >>= aTextMinimumFrameWidth)
dumpTextMinimumFrameWidthAsAttribute(aTextMinimumFrameWidth, xmlWriter); dumpTextMinimumFrameWidthAsAttribute(aTextMinimumFrameWidth, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("TextAnimationAmount"); uno::Any anotherAny = xPropSet->getPropertyValue(u"TextAnimationAmount"_ustr);
sal_Int32 aTextAnimationAmount = sal_Int32(); sal_Int32 aTextAnimationAmount = sal_Int32();
if(anotherAny >>= aTextAnimationAmount) if(anotherAny >>= aTextAnimationAmount)
dumpTextAnimationAmountAsAttribute(aTextAnimationAmount, xmlWriter); dumpTextAnimationAmountAsAttribute(aTextAnimationAmount, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("TextAnimationCount"); uno::Any anotherAny = xPropSet->getPropertyValue(u"TextAnimationCount"_ustr);
sal_Int32 aTextAnimationCount = sal_Int32(); sal_Int32 aTextAnimationCount = sal_Int32();
if(anotherAny >>= aTextAnimationCount) if(anotherAny >>= aTextAnimationCount)
dumpTextAnimationCountAsAttribute(aTextAnimationCount, xmlWriter); dumpTextAnimationCountAsAttribute(aTextAnimationCount, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("TextAnimationDelay"); uno::Any anotherAny = xPropSet->getPropertyValue(u"TextAnimationDelay"_ustr);
sal_Int32 aTextAnimationDelay = sal_Int32(); sal_Int32 aTextAnimationDelay = sal_Int32();
if(anotherAny >>= aTextAnimationDelay) if(anotherAny >>= aTextAnimationDelay)
dumpTextAnimationDelayAsAttribute(aTextAnimationDelay, xmlWriter); dumpTextAnimationDelayAsAttribute(aTextAnimationDelay, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("TextAnimationDirection"); uno::Any anotherAny = xPropSet->getPropertyValue(u"TextAnimationDirection"_ustr);
drawing::TextAnimationDirection eTextAnimationDirection; drawing::TextAnimationDirection eTextAnimationDirection;
if(anotherAny >>= eTextAnimationDirection) if(anotherAny >>= eTextAnimationDirection)
dumpTextAnimationDirectionAsAttribute(eTextAnimationDirection, xmlWriter); dumpTextAnimationDirectionAsAttribute(eTextAnimationDirection, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("TextAnimationKind"); uno::Any anotherAny = xPropSet->getPropertyValue(u"TextAnimationKind"_ustr);
drawing::TextAnimationKind eTextAnimationKind; drawing::TextAnimationKind eTextAnimationKind;
if(anotherAny >>= eTextAnimationKind) if(anotherAny >>= eTextAnimationKind)
dumpTextAnimationKindAsAttribute(eTextAnimationKind, xmlWriter); dumpTextAnimationKindAsAttribute(eTextAnimationKind, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("TextAnimationStartInside"); uno::Any anotherAny = xPropSet->getPropertyValue(u"TextAnimationStartInside"_ustr);
bool bTextAnimationStartInside; bool bTextAnimationStartInside;
if(anotherAny >>= bTextAnimationStartInside) if(anotherAny >>= bTextAnimationStartInside)
dumpTextAnimationStartInsideAsAttribute(bTextAnimationStartInside, xmlWriter); dumpTextAnimationStartInsideAsAttribute(bTextAnimationStartInside, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("TextAnimationStopInside"); uno::Any anotherAny = xPropSet->getPropertyValue(u"TextAnimationStopInside"_ustr);
bool bTextAnimationStopInside; bool bTextAnimationStopInside;
if(anotherAny >>= bTextAnimationStopInside) if(anotherAny >>= bTextAnimationStopInside)
dumpTextAnimationStopInsideAsAttribute(bTextAnimationStopInside, xmlWriter); dumpTextAnimationStopInsideAsAttribute(bTextAnimationStopInside, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("TextWritingMode"); uno::Any anotherAny = xPropSet->getPropertyValue(u"TextWritingMode"_ustr);
text::WritingMode eTextWritingMode; text::WritingMode eTextWritingMode;
if(anotherAny >>= eTextWritingMode) if(anotherAny >>= eTextWritingMode)
dumpTextWritingModeAsAttribute(eTextWritingMode, xmlWriter); 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) 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; drawing::FillStyle eFillStyle;
if(anotherAny >>= eFillStyle) if(anotherAny >>= eFillStyle)
dumpFillStyleAsAttribute(eFillStyle, xmlWriter); dumpFillStyleAsAttribute(eFillStyle, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("FillColor"); uno::Any anotherAny = xPropSet->getPropertyValue(u"FillColor"_ustr);
sal_Int32 aColor = sal_Int32(); sal_Int32 aColor = sal_Int32();
if(anotherAny >>= aColor) if(anotherAny >>= aColor)
dumpFillColorAsAttribute(aColor, xmlWriter); dumpFillColorAsAttribute(aColor, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("FillTransparence"); uno::Any anotherAny = xPropSet->getPropertyValue(u"FillTransparence"_ustr);
sal_Int32 aTransparence = sal_Int32(); sal_Int32 aTransparence = sal_Int32();
if(anotherAny >>= aTransparence) if(anotherAny >>= aTransparence)
dumpFillTransparenceAsAttribute(aTransparence, xmlWriter); dumpFillTransparenceAsAttribute(aTransparence, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("FillTransparenceGradientName"); uno::Any anotherAny = xPropSet->getPropertyValue(u"FillTransparenceGradientName"_ustr);
OUString sTranspGradName; OUString sTranspGradName;
if(anotherAny >>= sTranspGradName) if(anotherAny >>= sTranspGradName)
dumpFillTransparenceGradientNameAsAttribute(sTranspGradName, xmlWriter); dumpFillTransparenceGradientNameAsAttribute(sTranspGradName, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("FillTransparenceGradient"); uno::Any anotherAny = xPropSet->getPropertyValue(u"FillTransparenceGradient"_ustr);
awt::Gradient aTranspGrad; awt::Gradient aTranspGrad;
if(anotherAny >>= aTranspGrad) if(anotherAny >>= aTranspGrad)
dumpFillTransparenceGradientAsElement(aTranspGrad, xmlWriter); dumpFillTransparenceGradientAsElement(aTranspGrad, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("FillGradientName"); uno::Any anotherAny = xPropSet->getPropertyValue(u"FillGradientName"_ustr);
OUString sGradName; OUString sGradName;
if(anotherAny >>= sGradName) if(anotherAny >>= sGradName)
dumpFillGradientNameAsAttribute(sGradName, xmlWriter); dumpFillGradientNameAsAttribute(sGradName, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("FillGradient"); uno::Any anotherAny = xPropSet->getPropertyValue(u"FillGradient"_ustr);
awt::Gradient aGradient; awt::Gradient aGradient;
if(anotherAny >>= aGradient) if(anotherAny >>= aGradient)
dumpFillGradientAsElement(aGradient, xmlWriter); dumpFillGradientAsElement(aGradient, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("FillHatchName"); uno::Any anotherAny = xPropSet->getPropertyValue(u"FillHatchName"_ustr);
OUString sHatchName; OUString sHatchName;
if(anotherAny >>= sHatchName) if(anotherAny >>= sHatchName)
dumpFillGradientNameAsAttribute(sHatchName, xmlWriter); dumpFillGradientNameAsAttribute(sHatchName, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("FillHatch"); uno::Any anotherAny = xPropSet->getPropertyValue(u"FillHatch"_ustr);
drawing::Hatch aHatch; drawing::Hatch aHatch;
if(anotherAny >>= aHatch) if(anotherAny >>= aHatch)
dumpFillHatchAsElement(aHatch, xmlWriter); dumpFillHatchAsElement(aHatch, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("FillBackground"); uno::Any anotherAny = xPropSet->getPropertyValue(u"FillBackground"_ustr);
bool bFillBackground; bool bFillBackground;
if(anotherAny >>= bFillBackground) if(anotherAny >>= bFillBackground)
dumpFillBackgroundAsAttribute(bFillBackground, xmlWriter); dumpFillBackgroundAsAttribute(bFillBackground, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("FillBitmapName"); uno::Any anotherAny = xPropSet->getPropertyValue(u"FillBitmapName"_ustr);
OUString sBitmapName; OUString sBitmapName;
if(anotherAny >>= sBitmapName) if(anotherAny >>= sBitmapName)
dumpFillGradientNameAsAttribute(sBitmapName, xmlWriter); dumpFillGradientNameAsAttribute(sBitmapName, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("FillBitmap"); uno::Any anotherAny = xPropSet->getPropertyValue(u"FillBitmap"_ustr);
uno::Reference<awt::XBitmap> xBitmap; uno::Reference<awt::XBitmap> xBitmap;
if(anotherAny >>= xBitmap) if(anotherAny >>= xBitmap)
dumpFillBitmapAsElement(xBitmap, xmlWriter); dumpFillBitmapAsElement(xBitmap, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("FillBitmapPositionOffsetX"); uno::Any anotherAny = xPropSet->getPropertyValue(u"FillBitmapPositionOffsetX"_ustr);
sal_Int32 aBitmapPositionOffsetX = sal_Int32(); sal_Int32 aBitmapPositionOffsetX = sal_Int32();
if(anotherAny >>= aBitmapPositionOffsetX) if(anotherAny >>= aBitmapPositionOffsetX)
dumpFillBitmapPositionOffsetXAsAttribute(aBitmapPositionOffsetX, xmlWriter); dumpFillBitmapPositionOffsetXAsAttribute(aBitmapPositionOffsetX, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("FillBitmapPositionOffsetY"); uno::Any anotherAny = xPropSet->getPropertyValue(u"FillBitmapPositionOffsetY"_ustr);
sal_Int32 aBitmapPositionOffsetY = sal_Int32(); sal_Int32 aBitmapPositionOffsetY = sal_Int32();
if(anotherAny >>= aBitmapPositionOffsetY) if(anotherAny >>= aBitmapPositionOffsetY)
dumpFillBitmapPositionOffsetYAsAttribute(aBitmapPositionOffsetY, xmlWriter); dumpFillBitmapPositionOffsetYAsAttribute(aBitmapPositionOffsetY, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("FillBitmapOffsetX"); uno::Any anotherAny = xPropSet->getPropertyValue(u"FillBitmapOffsetX"_ustr);
sal_Int32 aBitmapOffsetX = sal_Int32(); sal_Int32 aBitmapOffsetX = sal_Int32();
if(anotherAny >>= aBitmapOffsetX) if(anotherAny >>= aBitmapOffsetX)
dumpFillBitmapOffsetXAsAttribute(aBitmapOffsetX, xmlWriter); dumpFillBitmapOffsetXAsAttribute(aBitmapOffsetX, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("FillBitmapOffsetY"); uno::Any anotherAny = xPropSet->getPropertyValue(u"FillBitmapOffsetY"_ustr);
sal_Int32 aBitmapOffsetY = sal_Int32(); sal_Int32 aBitmapOffsetY = sal_Int32();
if(anotherAny >>= aBitmapOffsetY) if(anotherAny >>= aBitmapOffsetY)
dumpFillBitmapOffsetYAsAttribute(aBitmapOffsetY, xmlWriter); dumpFillBitmapOffsetYAsAttribute(aBitmapOffsetY, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("FillBitmapRectanglePoint"); uno::Any anotherAny = xPropSet->getPropertyValue(u"FillBitmapRectanglePoint"_ustr);
drawing::RectanglePoint eBitmapRectanglePoint; drawing::RectanglePoint eBitmapRectanglePoint;
if(anotherAny >>= eBitmapRectanglePoint) if(anotherAny >>= eBitmapRectanglePoint)
dumpFillBitmapRectanglePointAsAttribute(eBitmapRectanglePoint, xmlWriter); dumpFillBitmapRectanglePointAsAttribute(eBitmapRectanglePoint, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("FillBitmapLogicalSize"); uno::Any anotherAny = xPropSet->getPropertyValue(u"FillBitmapLogicalSize"_ustr);
bool bBitmapLogicalSize; bool bBitmapLogicalSize;
if(anotherAny >>= bBitmapLogicalSize) if(anotherAny >>= bBitmapLogicalSize)
dumpFillBitmapLogicalSizeAsAttribute(bBitmapLogicalSize, xmlWriter); dumpFillBitmapLogicalSizeAsAttribute(bBitmapLogicalSize, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("FillBitmapSizeX"); uno::Any anotherAny = xPropSet->getPropertyValue(u"FillBitmapSizeX"_ustr);
sal_Int32 aBitmapSizeX = sal_Int32(); sal_Int32 aBitmapSizeX = sal_Int32();
if(anotherAny >>= aBitmapSizeX) if(anotherAny >>= aBitmapSizeX)
dumpFillBitmapSizeXAsAttribute(aBitmapSizeX, xmlWriter); dumpFillBitmapSizeXAsAttribute(aBitmapSizeX, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("FillBitmapSizeY"); uno::Any anotherAny = xPropSet->getPropertyValue(u"FillBitmapSizeY"_ustr);
sal_Int32 aBitmapSizeY = sal_Int32(); sal_Int32 aBitmapSizeY = sal_Int32();
if(anotherAny >>= aBitmapSizeY) if(anotherAny >>= aBitmapSizeY)
dumpFillBitmapSizeYAsAttribute(aBitmapSizeY, xmlWriter); dumpFillBitmapSizeYAsAttribute(aBitmapSizeY, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("FillBitmapMode"); uno::Any anotherAny = xPropSet->getPropertyValue(u"FillBitmapMode"_ustr);
drawing::BitmapMode eBitmapMode; drawing::BitmapMode eBitmapMode;
if(anotherAny >>= eBitmapMode) if(anotherAny >>= eBitmapMode)
dumpFillBitmapModeAsAttribute(eBitmapMode, xmlWriter); dumpFillBitmapModeAsAttribute(eBitmapMode, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("FillBitmapStretch"); uno::Any anotherAny = xPropSet->getPropertyValue(u"FillBitmapStretch"_ustr);
bool bBitmapStretch; bool bBitmapStretch;
if(anotherAny >>= bBitmapStretch) if(anotherAny >>= bBitmapStretch)
dumpFillBitmapStretchAsAttribute(bBitmapStretch, xmlWriter); dumpFillBitmapStretchAsAttribute(bBitmapStretch, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("FillBitmapTile"); uno::Any anotherAny = xPropSet->getPropertyValue(u"FillBitmapTile"_ustr);
bool bBitmapTile; bool bBitmapTile;
if(anotherAny >>= bBitmapTile) if(anotherAny >>= bBitmapTile)
dumpFillBitmapTileAsAttribute(bBitmapTile, xmlWriter); 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) 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; drawing::LineStyle eLineStyle;
if(anotherAny >>= eLineStyle) if(anotherAny >>= eLineStyle)
dumpLineStyleAsAttribute(eLineStyle, xmlWriter); dumpLineStyleAsAttribute(eLineStyle, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("LineDash"); uno::Any anotherAny = xPropSet->getPropertyValue(u"LineDash"_ustr);
drawing::LineDash aLineDash; drawing::LineDash aLineDash;
if(anotherAny >>= aLineDash) if(anotherAny >>= aLineDash)
dumpLineDashAsElement(aLineDash, xmlWriter); dumpLineDashAsElement(aLineDash, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("LineDashName"); uno::Any anotherAny = xPropSet->getPropertyValue(u"LineDashName"_ustr);
OUString sLineDashName; OUString sLineDashName;
if(anotherAny >>= sLineDashName) if(anotherAny >>= sLineDashName)
dumpLineDashNameAsAttribute(sLineDashName, xmlWriter); dumpLineDashNameAsAttribute(sLineDashName, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("LineColor"); uno::Any anotherAny = xPropSet->getPropertyValue(u"LineColor"_ustr);
sal_Int32 aLineColor = sal_Int32(); sal_Int32 aLineColor = sal_Int32();
if(anotherAny >>= aLineColor) if(anotherAny >>= aLineColor)
dumpLineColorAsAttribute(aLineColor, xmlWriter); dumpLineColorAsAttribute(aLineColor, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("LineTransparence"); uno::Any anotherAny = xPropSet->getPropertyValue(u"LineTransparence"_ustr);
sal_Int32 aLineTransparence = sal_Int32(); sal_Int32 aLineTransparence = sal_Int32();
if(anotherAny >>= aLineTransparence) if(anotherAny >>= aLineTransparence)
dumpLineTransparenceAsAttribute(aLineTransparence, xmlWriter); dumpLineTransparenceAsAttribute(aLineTransparence, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("LineWidth"); uno::Any anotherAny = xPropSet->getPropertyValue(u"LineWidth"_ustr);
sal_Int32 aLineWidth = sal_Int32(); sal_Int32 aLineWidth = sal_Int32();
if(anotherAny >>= aLineWidth) if(anotherAny >>= aLineWidth)
dumpLineWidthAsAttribute(aLineWidth, xmlWriter); dumpLineWidthAsAttribute(aLineWidth, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("LineJoint"); uno::Any anotherAny = xPropSet->getPropertyValue(u"LineJoint"_ustr);
drawing::LineJoint eLineJoint; drawing::LineJoint eLineJoint;
if(anotherAny >>= eLineJoint) if(anotherAny >>= eLineJoint)
dumpLineJointAsAttribute(eLineJoint, xmlWriter); dumpLineJointAsAttribute(eLineJoint, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("LineStartName"); uno::Any anotherAny = xPropSet->getPropertyValue(u"LineStartName"_ustr);
OUString sLineStartName; OUString sLineStartName;
if(anotherAny >>= sLineStartName) if(anotherAny >>= sLineStartName)
dumpLineStartNameAsAttribute(sLineStartName, xmlWriter); dumpLineStartNameAsAttribute(sLineStartName, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("LineEndName"); uno::Any anotherAny = xPropSet->getPropertyValue(u"LineEndName"_ustr);
OUString sLineEndName; OUString sLineEndName;
if(anotherAny >>= sLineEndName) if(anotherAny >>= sLineEndName)
dumpLineEndNameAsAttribute(sLineEndName, xmlWriter); dumpLineEndNameAsAttribute(sLineEndName, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("LineStart"); uno::Any anotherAny = xPropSet->getPropertyValue(u"LineStart"_ustr);
drawing::PolyPolygonBezierCoords aLineStart; drawing::PolyPolygonBezierCoords aLineStart;
if(anotherAny >>= aLineStart) if(anotherAny >>= aLineStart)
dumpLineStartAsElement(aLineStart, xmlWriter); dumpLineStartAsElement(aLineStart, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("LineEnd"); uno::Any anotherAny = xPropSet->getPropertyValue(u"LineEnd"_ustr);
drawing::PolyPolygonBezierCoords aLineEnd; drawing::PolyPolygonBezierCoords aLineEnd;
if(anotherAny >>= aLineEnd) if(anotherAny >>= aLineEnd)
dumpLineEndAsElement(aLineEnd, xmlWriter); dumpLineEndAsElement(aLineEnd, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("LineStartCenter"); uno::Any anotherAny = xPropSet->getPropertyValue(u"LineStartCenter"_ustr);
bool bLineStartCenter; bool bLineStartCenter;
if(anotherAny >>= bLineStartCenter) if(anotherAny >>= bLineStartCenter)
dumpLineStartCenterAsAttribute(bLineStartCenter, xmlWriter); dumpLineStartCenterAsAttribute(bLineStartCenter, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("LineStartWidth"); uno::Any anotherAny = xPropSet->getPropertyValue(u"LineStartWidth"_ustr);
sal_Int32 aLineStartWidth = sal_Int32(); sal_Int32 aLineStartWidth = sal_Int32();
if(anotherAny >>= aLineStartWidth) if(anotherAny >>= aLineStartWidth)
dumpLineStartWidthAsAttribute(aLineStartWidth, xmlWriter); dumpLineStartWidthAsAttribute(aLineStartWidth, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("LineEndCenter"); uno::Any anotherAny = xPropSet->getPropertyValue(u"LineEndCenter"_ustr);
bool bLineEndCenter; bool bLineEndCenter;
if(anotherAny >>= bLineEndCenter) if(anotherAny >>= bLineEndCenter)
dumpLineEndCenterAsAttribute(bLineEndCenter, xmlWriter); dumpLineEndCenterAsAttribute(bLineEndCenter, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("LineEndWidth"); uno::Any anotherAny = xPropSet->getPropertyValue(u"LineEndWidth"_ustr);
sal_Int32 aLineEndWidth = sal_Int32(); sal_Int32 aLineEndWidth = sal_Int32();
if(anotherAny >>= aLineEndWidth) if(anotherAny >>= aLineEndWidth)
dumpLineEndWidthAsAttribute(aLineEndWidth, xmlWriter); 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) 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; bool bShadow;
if(anotherAny >>= bShadow) if(anotherAny >>= bShadow)
dumpShadowAsAttribute(bShadow, xmlWriter); dumpShadowAsAttribute(bShadow, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("ShadowColor"); uno::Any anotherAny = xPropSet->getPropertyValue(u"ShadowColor"_ustr);
sal_Int32 aShadowColor = sal_Int32(); sal_Int32 aShadowColor = sal_Int32();
if(anotherAny >>= aShadowColor) if(anotherAny >>= aShadowColor)
dumpShadowColorAsAttribute(aShadowColor, xmlWriter); dumpShadowColorAsAttribute(aShadowColor, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("ShadowTransparence"); uno::Any anotherAny = xPropSet->getPropertyValue(u"ShadowTransparence"_ustr);
sal_Int32 aShadowTransparence = sal_Int32(); sal_Int32 aShadowTransparence = sal_Int32();
if(anotherAny >>= aShadowTransparence) if(anotherAny >>= aShadowTransparence)
dumpShadowTransparenceAsAttribute(aShadowTransparence, xmlWriter); dumpShadowTransparenceAsAttribute(aShadowTransparence, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("ShadowXDistance"); uno::Any anotherAny = xPropSet->getPropertyValue(u"ShadowXDistance"_ustr);
sal_Int32 aShadowXDistance = sal_Int32(); sal_Int32 aShadowXDistance = sal_Int32();
if(anotherAny >>= aShadowXDistance) if(anotherAny >>= aShadowXDistance)
dumpShadowXDistanceAsAttribute(aShadowXDistance, xmlWriter); dumpShadowXDistanceAsAttribute(aShadowXDistance, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("ShadowYDistance"); uno::Any anotherAny = xPropSet->getPropertyValue(u"ShadowYDistance"_ustr);
sal_Int32 aShadowYDistance = sal_Int32(); sal_Int32 aShadowYDistance = sal_Int32();
if(anotherAny >>= aShadowYDistance) if(anotherAny >>= aShadowYDistance)
dumpShadowYDistanceAsAttribute(aShadowYDistance, xmlWriter); 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) 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; drawing::PolygonKind ePolygonKind;
if(anotherAny >>= ePolygonKind) if(anotherAny >>= ePolygonKind)
dumpPolygonKindAsAttribute(ePolygonKind, xmlWriter); dumpPolygonKindAsAttribute(ePolygonKind, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("PolyPolygon"); uno::Any anotherAny = xPropSet->getPropertyValue(u"PolyPolygon"_ustr);
drawing::PointSequenceSequence aPolyPolygon; drawing::PointSequenceSequence aPolyPolygon;
if(anotherAny >>= aPolyPolygon) if(anotherAny >>= aPolyPolygon)
dumpPolyPolygonAsElement(aPolyPolygon, xmlWriter); dumpPolyPolygonAsElement(aPolyPolygon, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("Geometry"); uno::Any anotherAny = xPropSet->getPropertyValue(u"Geometry"_ustr);
drawing::PointSequenceSequence aGeometry; drawing::PointSequenceSequence aGeometry;
if(anotherAny >>= aGeometry) if(anotherAny >>= aGeometry)
dumpGeometryAsElement(aGeometry, xmlWriter); dumpGeometryAsElement(aGeometry, xmlWriter);
@ -1681,75 +1681,75 @@ void dumpShapeService(const uno::Reference< beans::XPropertySet >& xPropSet, xml
{ {
uno::Reference< beans::XPropertySetInfo> xInfo = xPropSet->getPropertySetInfo(); 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(); sal_Int32 aZOrder = sal_Int32();
if(anotherAny >>= aZOrder) if(anotherAny >>= aZOrder)
dumpZOrderAsAttribute(aZOrder, xmlWriter); dumpZOrderAsAttribute(aZOrder, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("LayerID"); uno::Any anotherAny = xPropSet->getPropertyValue(u"LayerID"_ustr);
sal_Int32 aLayerID = sal_Int32(); sal_Int32 aLayerID = sal_Int32();
if(anotherAny >>= aLayerID) if(anotherAny >>= aLayerID)
dumpLayerIDAsAttribute(aLayerID, xmlWriter); dumpLayerIDAsAttribute(aLayerID, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("LayerName"); uno::Any anotherAny = xPropSet->getPropertyValue(u"LayerName"_ustr);
OUString sLayerName; OUString sLayerName;
if(anotherAny >>= sLayerName) if(anotherAny >>= sLayerName)
dumpLayerNameAsAttribute(sLayerName, xmlWriter); dumpLayerNameAsAttribute(sLayerName, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("Visible"); uno::Any anotherAny = xPropSet->getPropertyValue(u"Visible"_ustr);
bool bVisible; bool bVisible;
if(anotherAny >>= bVisible) if(anotherAny >>= bVisible)
dumpVisibleAsAttribute(bVisible, xmlWriter); dumpVisibleAsAttribute(bVisible, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("Printable"); uno::Any anotherAny = xPropSet->getPropertyValue(u"Printable"_ustr);
bool bPrintable; bool bPrintable;
if(anotherAny >>= bPrintable) if(anotherAny >>= bPrintable)
dumpPrintableAsAttribute(bPrintable, xmlWriter); dumpPrintableAsAttribute(bPrintable, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("MoveProtect"); uno::Any anotherAny = xPropSet->getPropertyValue(u"MoveProtect"_ustr);
bool bMoveProtect; bool bMoveProtect;
if(anotherAny >>= bMoveProtect) if(anotherAny >>= bMoveProtect)
dumpMoveProtectAsAttribute(bMoveProtect, xmlWriter); dumpMoveProtectAsAttribute(bMoveProtect, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("Name"); uno::Any anotherAny = xPropSet->getPropertyValue(u"Name"_ustr);
OUString sName; OUString sName;
if(anotherAny >>= sName) if(anotherAny >>= sName)
dumpNameAsAttribute(sName, xmlWriter); dumpNameAsAttribute(sName, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("SizeProtect"); uno::Any anotherAny = xPropSet->getPropertyValue(u"SizeProtect"_ustr);
bool bSizeProtect; bool bSizeProtect;
if(anotherAny >>= bSizeProtect) if(anotherAny >>= bSizeProtect)
dumpSizeProtectAsAttribute(bSizeProtect, xmlWriter); dumpSizeProtectAsAttribute(bSizeProtect, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("Transformation"); uno::Any anotherAny = xPropSet->getPropertyValue(u"Transformation"_ustr);
drawing::HomogenMatrix3 aTransformation; drawing::HomogenMatrix3 aTransformation;
if(anotherAny >>= aTransformation) if(anotherAny >>= aTransformation)
dumpTransformationAsElement(aTransformation, xmlWriter); dumpTransformationAsElement(aTransformation, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("NavigationOrder"); uno::Any anotherAny = xPropSet->getPropertyValue(u"NavigationOrder"_ustr);
sal_Int32 aNavigationOrder = sal_Int32(); sal_Int32 aNavigationOrder = sal_Int32();
if(anotherAny >>= aNavigationOrder) if(anotherAny >>= aNavigationOrder)
dumpNavigationOrderAsAttribute(aNavigationOrder, xmlWriter); 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; OUString sHyperlink;
if(anotherAny >>= sHyperlink) if(anotherAny >>= sHyperlink)
dumpHyperlinkAsAttribute(sHyperlink, xmlWriter); 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; uno::Sequence< beans::PropertyValue> aInteropGrabBag;
if(anotherAny >>= aInteropGrabBag) if(anotherAny >>= aInteropGrabBag)
dumpInteropGrabBagAsElement(aInteropGrabBag, xmlWriter); 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) 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; drawing::PolygonKind ePolygonKind;
if(anotherAny >>= ePolygonKind) if(anotherAny >>= ePolygonKind)
dumpPolygonKindAsAttribute(ePolygonKind, xmlWriter); dumpPolygonKindAsAttribute(ePolygonKind, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("PolyPolygonBezier"); uno::Any anotherAny = xPropSet->getPropertyValue(u"PolyPolygonBezier"_ustr);
drawing::PolyPolygonBezierCoords aPolyPolygonBezier; drawing::PolyPolygonBezierCoords aPolyPolygonBezier;
if(anotherAny >>= aPolyPolygonBezier) if(anotherAny >>= aPolyPolygonBezier)
dumpPolyPolygonBezierCoords(aPolyPolygonBezier, xmlWriter); dumpPolyPolygonBezierCoords(aPolyPolygonBezier, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("Geometry"); uno::Any anotherAny = xPropSet->getPropertyValue(u"Geometry"_ustr);
drawing::PolyPolygonBezierCoords aGeometry; drawing::PolyPolygonBezierCoords aGeometry;
if(anotherAny >>= aGeometry) if(anotherAny >>= aGeometry)
dumpPolyPolygonBezierCoords(aGeometry, xmlWriter); dumpPolyPolygonBezierCoords(aGeometry, xmlWriter);
@ -1782,26 +1782,26 @@ void dumpCustomShapeService(const uno::Reference< beans::XPropertySet >& xPropSe
{ {
uno::Reference< beans::XPropertySetInfo> xInfo = xPropSet->getPropertySetInfo(); uno::Reference< beans::XPropertySetInfo> xInfo = xPropSet->getPropertySetInfo();
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("CustomShapeEngine"); uno::Any anotherAny = xPropSet->getPropertyValue(u"CustomShapeEngine"_ustr);
OUString sCustomShapeEngine; OUString sCustomShapeEngine;
if(anotherAny >>= sCustomShapeEngine) if(anotherAny >>= sCustomShapeEngine)
dumpCustomShapeEngineAsAttribute(sCustomShapeEngine, xmlWriter); dumpCustomShapeEngineAsAttribute(sCustomShapeEngine, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("CustomShapeData"); uno::Any anotherAny = xPropSet->getPropertyValue(u"CustomShapeData"_ustr);
OUString sCustomShapeData; OUString sCustomShapeData;
if(anotherAny >>= sCustomShapeData) if(anotherAny >>= sCustomShapeData)
dumpCustomShapeDataAsAttribute(sCustomShapeData, xmlWriter); dumpCustomShapeDataAsAttribute(sCustomShapeData, xmlWriter);
} }
{ {
uno::Any anotherAny = xPropSet->getPropertyValue("CustomShapeGeometry"); uno::Any anotherAny = xPropSet->getPropertyValue(u"CustomShapeGeometry"_ustr);
uno::Sequence< beans::PropertyValue> aCustomShapeGeometry; uno::Sequence< beans::PropertyValue> aCustomShapeGeometry;
if(anotherAny >>= aCustomShapeGeometry) if(anotherAny >>= aCustomShapeGeometry)
dumpCustomShapeGeometryAsElement(aCustomShapeGeometry, xmlWriter); 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; OUString sCustomShapeReplacementURL;
if(anotherAny >>= sCustomShapeReplacementURL) if(anotherAny >>= sCustomShapeReplacementURL)
dumpCustomShapeReplacementURLAsAttribute(sCustomShapeReplacementURL, xmlWriter); 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< lang::XServiceInfo > xServiceInfo( xShape, uno::UNO_QUERY_THROW );
uno::Reference< beans::XPropertySetInfo> xInfo = xPropSet->getPropertySetInfo(); 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()) if ((aAny >>= aName) && !aName.isEmpty())
{ {
(void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("name"), "%s", OUStringToOString(aName, RTL_TEXTENCODING_UTF8).getStr()); (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 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); uno::Reference< text::XText > xText(xShape, uno::UNO_QUERY_THROW);
OUString aText = xText->getString(); OUString aText = xText->getString();
if(!aText.isEmpty()) if(!aText.isEmpty())
(void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("text"), "%s", OUStringToOString(aText, RTL_TEXTENCODING_UTF8).getStr()); (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); 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); uno::Reference< drawing::XShapes > xShapes(xShape, uno::UNO_QUERY_THROW);
dumpXShapes(xShapes, xmlWriter, bDumpInteropProperties); 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); dumpFillPropertiesService(xPropSet, xmlWriter);
if(xServiceInfo->supportsService("com.sun.star.drawing.LineProperties")) if(xServiceInfo->supportsService(u"com.sun.star.drawing.LineProperties"_ustr))
dumpLinePropertiesService(xPropSet, xmlWriter); dumpLinePropertiesService(xPropSet, xmlWriter);
if(xServiceInfo->supportsService("com.sun.star.drawing.PolyPolygonDescriptor")) if(xServiceInfo->supportsService(u"com.sun.star.drawing.PolyPolygonDescriptor"_ustr))
dumpPolyPolygonDescriptorService(xPropSet, xmlWriter); dumpPolyPolygonDescriptorService(xPropSet, xmlWriter);
if(xServiceInfo->supportsService("com.sun.star.drawing.ShadowProperties")) if(xServiceInfo->supportsService(u"com.sun.star.drawing.ShadowProperties"_ustr))
dumpShadowPropertiesService(xPropSet, xmlWriter); 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); 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); dumpPolyPolygonBezierDescriptorService(xPropSet, xmlWriter);
if(xServiceInfo->supportsService("com.sun.star.drawing.CustomShape")) if(xServiceInfo->supportsService(u"com.sun.star.drawing.CustomShape"_ustr))
dumpCustomShapeService(xPropSet, xmlWriter); dumpCustomShapeService(xPropSet, xmlWriter);
// EnhancedShapeDumper used // EnhancedShapeDumper used
if(xServiceInfo->supportsService("com.sun.star.drawing.EnhancedCustomShapeExtrusion")) if(xServiceInfo->supportsService(u"com.sun.star.drawing.EnhancedCustomShapeExtrusion"_ustr))
{ {
EnhancedShapeDumper enhancedDumper(xmlWriter); EnhancedShapeDumper enhancedDumper(xmlWriter);
enhancedDumper.dumpEnhancedCustomShapeExtrusionService(xPropSet); enhancedDumper.dumpEnhancedCustomShapeExtrusionService(xPropSet);
} }
if(xServiceInfo->supportsService("com.sun.star.drawing.EnhancedCustomShapeGeometry")) if(xServiceInfo->supportsService(u"com.sun.star.drawing.EnhancedCustomShapeGeometry"_ustr))
{ {
EnhancedShapeDumper enhancedDumper(xmlWriter); EnhancedShapeDumper enhancedDumper(xmlWriter);
enhancedDumper.dumpEnhancedCustomShapeGeometryService(xPropSet); enhancedDumper.dumpEnhancedCustomShapeGeometryService(xPropSet);
} }
if(xServiceInfo->supportsService("com.sun.star.drawing.EnhancedCustomShapeHandle")) if(xServiceInfo->supportsService(u"com.sun.star.drawing.EnhancedCustomShapeHandle"_ustr))
{ {
EnhancedShapeDumper enhancedDumper(xmlWriter); EnhancedShapeDumper enhancedDumper(xmlWriter);
enhancedDumper.dumpEnhancedCustomShapeHandleService(xPropSet); enhancedDumper.dumpEnhancedCustomShapeHandleService(xPropSet);
} }
if(xServiceInfo->supportsService("com.sun.star.drawing.EnhancedCustomShapePath")) if(xServiceInfo->supportsService(u"com.sun.star.drawing.EnhancedCustomShapePath"_ustr))
{ {
EnhancedShapeDumper enhancedDumper(xmlWriter); EnhancedShapeDumper enhancedDumper(xmlWriter);
enhancedDumper.dumpEnhancedCustomShapePathService(xPropSet); enhancedDumper.dumpEnhancedCustomShapePathService(xPropSet);
} }
if(xServiceInfo->supportsService("com.sun.star.drawing.EnhancedCustomShapeTextPath")) if(xServiceInfo->supportsService(u"com.sun.star.drawing.EnhancedCustomShapeTextPath"_ustr))
{ {
EnhancedShapeDumper enhancedDumper(xmlWriter); EnhancedShapeDumper enhancedDumper(xmlWriter);
enhancedDumper.dumpEnhancedCustomShapeTextPathService(xPropSet); enhancedDumper.dumpEnhancedCustomShapeTextPathService(xPropSet);

154
drawinglayer/source/primitive2d/Tools.cxx
View File

@ -80,159 +80,159 @@ OUString idToString(sal_uInt32 nId)
switch (nId) switch (nId)
{ {
case PRIMITIVE2D_ID_TRANSPARENCEPRIMITIVE2D: case PRIMITIVE2D_ID_TRANSPARENCEPRIMITIVE2D:
return "TRANSPARENCE"; return u"TRANSPARENCE"_ustr;
case PRIMITIVE2D_ID_ANIMATEDSWITCHPRIMITIVE2D: case PRIMITIVE2D_ID_ANIMATEDSWITCHPRIMITIVE2D:
return "ANIMATEDSWITCH"; return u"ANIMATEDSWITCH"_ustr;
case PRIMITIVE2D_ID_ANIMATEDBLINKPRIMITIVE2D: case PRIMITIVE2D_ID_ANIMATEDBLINKPRIMITIVE2D:
return "ANIMATEDBLINK"; return u"ANIMATEDBLINK"_ustr;
case PRIMITIVE2D_ID_ANIMATEDINTERPOLATEPRIMITIVE2D: case PRIMITIVE2D_ID_ANIMATEDINTERPOLATEPRIMITIVE2D:
return "ANIMATEDINTERPOLATE"; return u"ANIMATEDINTERPOLATE"_ustr;
case PRIMITIVE2D_ID_BACKGROUNDCOLORPRIMITIVE2D: case PRIMITIVE2D_ID_BACKGROUNDCOLORPRIMITIVE2D:
return "BACKGROUNDCOLOR"; return u"BACKGROUNDCOLOR"_ustr;
case PRIMITIVE2D_ID_BITMAPPRIMITIVE2D: case PRIMITIVE2D_ID_BITMAPPRIMITIVE2D:
return "BITMAP"; return u"BITMAP"_ustr;
case PRIMITIVE2D_ID_CONTROLPRIMITIVE2D: case PRIMITIVE2D_ID_CONTROLPRIMITIVE2D:
return "CONTROL"; return u"CONTROL"_ustr;
case PRIMITIVE2D_ID_EMBEDDED3DPRIMITIVE2D: case PRIMITIVE2D_ID_EMBEDDED3DPRIMITIVE2D:
return "EMBEDDED3D"; return u"EMBEDDED3D"_ustr;
case PRIMITIVE2D_ID_FILLGRAPHICPRIMITIVE2D: case PRIMITIVE2D_ID_FILLGRAPHICPRIMITIVE2D:
return "FILLGRAPHIC"; return u"FILLGRAPHIC"_ustr;
case PRIMITIVE2D_ID_FILLGRADIENTPRIMITIVE2D: case PRIMITIVE2D_ID_FILLGRADIENTPRIMITIVE2D:
return "FILLGRADIENT"; return u"FILLGRADIENT"_ustr;
case PRIMITIVE2D_ID_FILLHATCHPRIMITIVE2D: case PRIMITIVE2D_ID_FILLHATCHPRIMITIVE2D:
return "FILLHATCH"; return u"FILLHATCH"_ustr;
case PRIMITIVE2D_ID_GRAPHICPRIMITIVE2D: case PRIMITIVE2D_ID_GRAPHICPRIMITIVE2D:
return "GRAPHIC"; return u"GRAPHIC"_ustr;
case PRIMITIVE2D_ID_GRIDPRIMITIVE2D: case PRIMITIVE2D_ID_GRIDPRIMITIVE2D:
return "GRID"; return u"GRID"_ustr;
case PRIMITIVE2D_ID_GROUPPRIMITIVE2D: case PRIMITIVE2D_ID_GROUPPRIMITIVE2D:
return "GROUP"; return u"GROUP"_ustr;
case PRIMITIVE2D_ID_HELPLINEPRIMITIVE2D: case PRIMITIVE2D_ID_HELPLINEPRIMITIVE2D:
return "HELPLINE"; return u"HELPLINE"_ustr;
case PRIMITIVE2D_ID_MARKERARRAYPRIMITIVE2D: case PRIMITIVE2D_ID_MARKERARRAYPRIMITIVE2D:
return "MARKERARRAY"; return u"MARKERARRAY"_ustr;
case PRIMITIVE2D_ID_MASKPRIMITIVE2D: case PRIMITIVE2D_ID_MASKPRIMITIVE2D:
return "MASK"; return u"MASK"_ustr;
case PRIMITIVE2D_ID_MEDIAPRIMITIVE2D: case PRIMITIVE2D_ID_MEDIAPRIMITIVE2D:
return "MEDIA"; return u"MEDIA"_ustr;
case PRIMITIVE2D_ID_METAFILEPRIMITIVE2D: case PRIMITIVE2D_ID_METAFILEPRIMITIVE2D:
return "METAFILE"; return u"METAFILE"_ustr;
case PRIMITIVE2D_ID_MODIFIEDCOLORPRIMITIVE2D: case PRIMITIVE2D_ID_MODIFIEDCOLORPRIMITIVE2D:
return "MODIFIEDCOLOR"; return u"MODIFIEDCOLOR"_ustr;
case PRIMITIVE2D_ID_POLYGONHAIRLINEPRIMITIVE2D: case PRIMITIVE2D_ID_POLYGONHAIRLINEPRIMITIVE2D:
return "POLYGONHAIRLINE"; return u"POLYGONHAIRLINE"_ustr;
case PRIMITIVE2D_ID_POLYGONMARKERPRIMITIVE2D: case PRIMITIVE2D_ID_POLYGONMARKERPRIMITIVE2D:
return "POLYGONMARKER"; return u"POLYGONMARKER"_ustr;
case PRIMITIVE2D_ID_POLYGONSTROKEPRIMITIVE2D: case PRIMITIVE2D_ID_POLYGONSTROKEPRIMITIVE2D:
return "POLYGONSTROKE"; return u"POLYGONSTROKE"_ustr;
case PRIMITIVE2D_ID_POLYGONSTROKEARROWPRIMITIVE2D: case PRIMITIVE2D_ID_POLYGONSTROKEARROWPRIMITIVE2D:
return "POLYGONSTROKEARROW"; return u"POLYGONSTROKEARROW"_ustr;
case PRIMITIVE2D_ID_POLYPOLYGONSTROKEPRIMITIVE2D: case PRIMITIVE2D_ID_POLYPOLYGONSTROKEPRIMITIVE2D:
return "POLYPOLYGONSTROKE"; return u"POLYPOLYGONSTROKE"_ustr;
case PRIMITIVE2D_ID_POLYPOLYGONSTROKEARROWPRIMITIVE2D: case PRIMITIVE2D_ID_POLYPOLYGONSTROKEARROWPRIMITIVE2D:
return "POLYPOLYGONSTROKEARROW"; return u"POLYPOLYGONSTROKEARROW"_ustr;
case PRIMITIVE2D_ID_POLYPOLYGONCOLORPRIMITIVE2D: case PRIMITIVE2D_ID_POLYPOLYGONCOLORPRIMITIVE2D:
return "POLYPOLYGONCOLOR"; return u"POLYPOLYGONCOLOR"_ustr;
case PRIMITIVE2D_ID_POLYPOLYGONGRADIENTPRIMITIVE2D: case PRIMITIVE2D_ID_POLYPOLYGONGRADIENTPRIMITIVE2D:
return "POLYPOLYGONGRADIENT"; return u"POLYPOLYGONGRADIENT"_ustr;
case PRIMITIVE2D_ID_POLYPOLYGONHATCHPRIMITIVE2D: case PRIMITIVE2D_ID_POLYPOLYGONHATCHPRIMITIVE2D:
return "POLYPOLYGONHATCH"; return u"POLYPOLYGONHATCH"_ustr;
case PRIMITIVE2D_ID_POLYPOLYGONGRAPHICPRIMITIVE2D: case PRIMITIVE2D_ID_POLYPOLYGONGRAPHICPRIMITIVE2D:
return "POLYPOLYGONGRAPHIC"; return u"POLYPOLYGONGRAPHIC"_ustr;
case PRIMITIVE2D_ID_SCENEPRIMITIVE2D: case PRIMITIVE2D_ID_SCENEPRIMITIVE2D:
return "SCENE"; return u"SCENE"_ustr;
case PRIMITIVE2D_ID_SHADOWPRIMITIVE2D: case PRIMITIVE2D_ID_SHADOWPRIMITIVE2D:
return "SHADOW"; return u"SHADOW"_ustr;
case PRIMITIVE2D_ID_TEXTSIMPLEPORTIONPRIMITIVE2D: case PRIMITIVE2D_ID_TEXTSIMPLEPORTIONPRIMITIVE2D:
return "TEXTSIMPLEPORTION"; return u"TEXTSIMPLEPORTION"_ustr;
case PRIMITIVE2D_ID_TEXTDECORATEDPORTIONPRIMITIVE2D: case PRIMITIVE2D_ID_TEXTDECORATEDPORTIONPRIMITIVE2D:
return "TEXTDECORATEDPORTION"; return u"TEXTDECORATEDPORTION"_ustr;
case PRIMITIVE2D_ID_TRANSFORMPRIMITIVE2D: case PRIMITIVE2D_ID_TRANSFORMPRIMITIVE2D:
return "TRANSFORM"; return u"TRANSFORM"_ustr;
case PRIMITIVE2D_ID_UNIFIEDTRANSPARENCEPRIMITIVE2D: case PRIMITIVE2D_ID_UNIFIEDTRANSPARENCEPRIMITIVE2D:
return "UNIFIEDTRANSPARENCE"; return u"UNIFIEDTRANSPARENCE"_ustr;
case PRIMITIVE2D_ID_POINTARRAYPRIMITIVE2D: case PRIMITIVE2D_ID_POINTARRAYPRIMITIVE2D:
return "POINTARRAY"; return u"POINTARRAY"_ustr;
case PRIMITIVE2D_ID_TEXTHIERARCHYFIELDPRIMITIVE2D: case PRIMITIVE2D_ID_TEXTHIERARCHYFIELDPRIMITIVE2D:
return "TEXTHIERARCHYFIELD"; return u"TEXTHIERARCHYFIELD"_ustr;
case PRIMITIVE2D_ID_TEXTHIERARCHYLINEPRIMITIVE2D: case PRIMITIVE2D_ID_TEXTHIERARCHYLINEPRIMITIVE2D:
return "TEXTHIERARCHYLINE"; return u"TEXTHIERARCHYLINE"_ustr;
case PRIMITIVE2D_ID_TEXTHIERARCHYPARAGRAPHPRIMITIVE2D: case PRIMITIVE2D_ID_TEXTHIERARCHYPARAGRAPHPRIMITIVE2D:
return "TEXTHIERARCHYPARAGRAPH"; return u"TEXTHIERARCHYPARAGRAPH"_ustr;
case PRIMITIVE2D_ID_TEXTHIERARCHYBLOCKPRIMITIVE2D: case PRIMITIVE2D_ID_TEXTHIERARCHYBLOCKPRIMITIVE2D:
return "TEXTHIERARCHYBLOCK"; return u"TEXTHIERARCHYBLOCK"_ustr;
case PRIMITIVE2D_ID_TEXTHIERARCHYEDITPRIMITIVE2D: case PRIMITIVE2D_ID_TEXTHIERARCHYEDITPRIMITIVE2D:
return "TEXTHIERARCHYEDIT"; return u"TEXTHIERARCHYEDIT"_ustr;
case PRIMITIVE2D_ID_POLYGONWAVEPRIMITIVE2D: case PRIMITIVE2D_ID_POLYGONWAVEPRIMITIVE2D:
return "POLYGONWAVE"; return u"POLYGONWAVE"_ustr;
case PRIMITIVE2D_ID_WRONGSPELLPRIMITIVE2D: case PRIMITIVE2D_ID_WRONGSPELLPRIMITIVE2D:
return "WRONGSPELL"; return u"WRONGSPELL"_ustr;
case PRIMITIVE2D_ID_TEXTEFFECTPRIMITIVE2D: case PRIMITIVE2D_ID_TEXTEFFECTPRIMITIVE2D:
return "TEXTEFFECT"; return u"TEXTEFFECT"_ustr;
case PRIMITIVE2D_ID_TEXTHIERARCHYBULLETPRIMITIVE2D: case PRIMITIVE2D_ID_TEXTHIERARCHYBULLETPRIMITIVE2D:
return "TEXTHIERARCHYBULLET"; return u"TEXTHIERARCHYBULLET"_ustr;
case PRIMITIVE2D_ID_POLYPOLYGONHAIRLINEPRIMITIVE2D: case PRIMITIVE2D_ID_POLYPOLYGONHAIRLINEPRIMITIVE2D:
return "POLYPOLYGONHAIRLINE"; return u"POLYPOLYGONHAIRLINE"_ustr;
case PRIMITIVE2D_ID_EXECUTEPRIMITIVE2D: case PRIMITIVE2D_ID_EXECUTEPRIMITIVE2D:
return "EXECUTE"; return u"EXECUTE"_ustr;
case PRIMITIVE2D_ID_PAGEPREVIEWPRIMITIVE2D: case PRIMITIVE2D_ID_PAGEPREVIEWPRIMITIVE2D:
return "PAGEPREVIEW"; return u"PAGEPREVIEW"_ustr;
case PRIMITIVE2D_ID_STRUCTURETAGPRIMITIVE2D: case PRIMITIVE2D_ID_STRUCTURETAGPRIMITIVE2D:
return "STRUCTURETAG"; return u"STRUCTURETAG"_ustr;
case PRIMITIVE2D_ID_BORDERLINEPRIMITIVE2D: case PRIMITIVE2D_ID_BORDERLINEPRIMITIVE2D:
return "BORDERLINE"; return u"BORDERLINE"_ustr;
case PRIMITIVE2D_ID_POLYPOLYGONMARKERPRIMITIVE2D: case PRIMITIVE2D_ID_POLYPOLYGONMARKERPRIMITIVE2D:
return "POLYPOLYGONMARKER"; return u"POLYPOLYGONMARKER"_ustr;
case PRIMITIVE2D_ID_HITTESTPRIMITIVE2D: case PRIMITIVE2D_ID_HITTESTPRIMITIVE2D:
return "HITTEST"; return u"HITTEST"_ustr;
case PRIMITIVE2D_ID_INVERTPRIMITIVE2D: case PRIMITIVE2D_ID_INVERTPRIMITIVE2D:
return "INVERT"; return u"INVERT"_ustr;
case PRIMITIVE2D_ID_DISCRETEBITMAPPRIMITIVE2D: case PRIMITIVE2D_ID_DISCRETEBITMAPPRIMITIVE2D:
return "DISCRETEBITMAP"; return u"DISCRETEBITMAP"_ustr;
case PRIMITIVE2D_ID_WALLPAPERBITMAPPRIMITIVE2D: case PRIMITIVE2D_ID_WALLPAPERBITMAPPRIMITIVE2D:
return "WALLPAPERBITMAP"; return u"WALLPAPERBITMAP"_ustr;
case PRIMITIVE2D_ID_TEXTLINEPRIMITIVE2D: case PRIMITIVE2D_ID_TEXTLINEPRIMITIVE2D:
return "TEXTLINE"; return u"TEXTLINE"_ustr;
case PRIMITIVE2D_ID_TEXTCHARACTERSTRIKEOUTPRIMITIVE2D: case PRIMITIVE2D_ID_TEXTCHARACTERSTRIKEOUTPRIMITIVE2D:
return "TEXTCHARACTERSTRIKEOUT"; return u"TEXTCHARACTERSTRIKEOUT"_ustr;
case PRIMITIVE2D_ID_TEXTGEOMETRYSTRIKEOUTPRIMITIVE2D: case PRIMITIVE2D_ID_TEXTGEOMETRYSTRIKEOUTPRIMITIVE2D:
return "TEXTGEOMETRYSTRIKEOUT"; return u"TEXTGEOMETRYSTRIKEOUT"_ustr;
case PRIMITIVE2D_ID_EPSPRIMITIVE2D: case PRIMITIVE2D_ID_EPSPRIMITIVE2D:
return "EPS"; return u"EPS"_ustr;
case PRIMITIVE2D_ID_DISCRETESHADOWPRIMITIVE2D: case PRIMITIVE2D_ID_DISCRETESHADOWPRIMITIVE2D:
return "DISCRETESHADOW"; return u"DISCRETESHADOW"_ustr;
case PRIMITIVE2D_ID_HIDDENGEOMETRYPRIMITIVE2D: case PRIMITIVE2D_ID_HIDDENGEOMETRYPRIMITIVE2D:
return "HIDDENGEOMETRY"; return u"HIDDENGEOMETRY"_ustr;
case PRIMITIVE2D_ID_SVGLINEARGRADIENTPRIMITIVE2D: case PRIMITIVE2D_ID_SVGLINEARGRADIENTPRIMITIVE2D:
return "SVGLINEARGRADIENT"; return u"SVGLINEARGRADIENT"_ustr;
case PRIMITIVE2D_ID_SVGRADIALGRADIENTPRIMITIVE2D: case PRIMITIVE2D_ID_SVGRADIALGRADIENTPRIMITIVE2D:
return "SVGRADIALGRADIENT"; return u"SVGRADIALGRADIENT"_ustr;
case PRIMITIVE2D_ID_SVGLINEARATOMPRIMITIVE2D: case PRIMITIVE2D_ID_SVGLINEARATOMPRIMITIVE2D:
return "SVGLINEARATOM"; return u"SVGLINEARATOM"_ustr;
case PRIMITIVE2D_ID_SVGRADIALATOMPRIMITIVE2D: case PRIMITIVE2D_ID_SVGRADIALATOMPRIMITIVE2D:
return "SVGRADIALATOM"; return u"SVGRADIALATOM"_ustr;
case PRIMITIVE2D_ID_CROPPRIMITIVE2D: case PRIMITIVE2D_ID_CROPPRIMITIVE2D:
return "CROP"; return u"CROP"_ustr;
case PRIMITIVE2D_ID_PATTERNFILLPRIMITIVE2D: case PRIMITIVE2D_ID_PATTERNFILLPRIMITIVE2D:
return "PATTERNFILL"; return u"PATTERNFILL"_ustr;
case PRIMITIVE2D_ID_OBJECTINFOPRIMITIVE2D: case PRIMITIVE2D_ID_OBJECTINFOPRIMITIVE2D:
return "OBJECTINFO"; return u"OBJECTINFO"_ustr;
case PRIMITIVE2D_ID_POLYPOLYGONSELECTIONPRIMITIVE2D: case PRIMITIVE2D_ID_POLYPOLYGONSELECTIONPRIMITIVE2D:
return "POLYPOLYGONSELECTION"; return u"POLYPOLYGONSELECTION"_ustr;
case PRIMITIVE2D_ID_PAGEHIERARCHYPRIMITIVE2D: case PRIMITIVE2D_ID_PAGEHIERARCHYPRIMITIVE2D:
return "PAGEHIERARCHY"; return u"PAGEHIERARCHY"_ustr;
case PRIMITIVE2D_ID_GLOWPRIMITIVE2D: case PRIMITIVE2D_ID_GLOWPRIMITIVE2D:
return "GLOWPRIMITIVE"; return u"GLOWPRIMITIVE"_ustr;
case PRIMITIVE2D_ID_SOFTEDGEPRIMITIVE2D: case PRIMITIVE2D_ID_SOFTEDGEPRIMITIVE2D:
return "SOFTEDGEPRIMITIVE"; return u"SOFTEDGEPRIMITIVE"_ustr;
case PRIMITIVE2D_ID_LINERECTANGLEPRIMITIVE2D: case PRIMITIVE2D_ID_LINERECTANGLEPRIMITIVE2D:
return "LINERECTANGLEPRIMITIVE"; return u"LINERECTANGLEPRIMITIVE"_ustr;
case PRIMITIVE2D_ID_FILLEDRECTANGLEPRIMITIVE2D: case PRIMITIVE2D_ID_FILLEDRECTANGLEPRIMITIVE2D:
return "FILLEDRECTANGLEPRIMITIVE"; return u"FILLEDRECTANGLEPRIMITIVE"_ustr;
case PRIMITIVE2D_ID_SINGLELINEPRIMITIVE2D: case PRIMITIVE2D_ID_SINGLELINEPRIMITIVE2D:
return "SINGLELINEPRIMITIVE"; return u"SINGLELINEPRIMITIVE"_ustr;
case PRIMITIVE2D_ID_EXCLUSIVEEDITVIEWPRIMITIVE2D: case PRIMITIVE2D_ID_EXCLUSIVEEDITVIEWPRIMITIVE2D:
return "EXCLUSIVEEDITVIEWPRIMITIVE2D"; return u"EXCLUSIVEEDITVIEWPRIMITIVE2D"_ustr;
default: default:
return OUString::number((nId >> 16) & 0xFF) + "|" + OUString::number(nId & 0xFF); return OUString::number((nId >> 16) & 0xFF) + "|" + OUString::number(nId & 0xFF);
} }

4
drawinglayer/source/primitive2d/controlprimitive2d.cxx
View File

@ -56,7 +56,7 @@ namespace drawinglayer::primitive2d
if(!xSet.is()) if(!xSet.is())
return; return;
uno::Any aValue(xSet->getPropertyValue("DefaultControl")); uno::Any aValue(xSet->getPropertyValue(u"DefaultControl"_ustr));
OUString aUnoControlTypeName; OUString aUnoControlTypeName;
if(!(aValue >>= aUnoControlTypeName)) if(!(aValue >>= aUnoControlTypeName))
@ -150,7 +150,7 @@ namespace drawinglayer::primitive2d
if (xWindowPeer) if (xWindowPeer)
{ {
uno::Reference<awt::XVclWindowPeer> xPeerProps(xWindowPeer, uno::UNO_QUERY_THROW); 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; aAny >>= bUserIs100thmm;
} }
} }

38
drawinglayer/source/primitive3d/Tools.cxx
View File

@ -20,43 +20,43 @@ OUString idToString(sal_uInt32 nId)
switch (nId) switch (nId)
{ {
case PRIMITIVE3D_ID_GROUPPRIMITIVE3D: case PRIMITIVE3D_ID_GROUPPRIMITIVE3D:
return "GROUPPRIMITIVE3D"; return u"GROUPPRIMITIVE3D"_ustr;
case PRIMITIVE3D_ID_HATCHTEXTUREPRIMITIVE3D: case PRIMITIVE3D_ID_HATCHTEXTUREPRIMITIVE3D:
return "HATCHTEXTUREPRIMITIVE3D"; return u"HATCHTEXTUREPRIMITIVE3D"_ustr;
case PRIMITIVE3D_ID_MODIFIEDCOLORPRIMITIVE3D: case PRIMITIVE3D_ID_MODIFIEDCOLORPRIMITIVE3D:
return "MODIFIEDCOLORPRIMITIVE3D"; return u"MODIFIEDCOLORPRIMITIVE3D"_ustr;
case PRIMITIVE3D_ID_POLYGONHAIRLINEPRIMITIVE3D: case PRIMITIVE3D_ID_POLYGONHAIRLINEPRIMITIVE3D:
return "POLYGONHAIRLINEPRIMITIVE3D"; return u"POLYGONHAIRLINEPRIMITIVE3D"_ustr;
case PRIMITIVE3D_ID_POLYGONSTROKEPRIMITIVE3D: case PRIMITIVE3D_ID_POLYGONSTROKEPRIMITIVE3D:
return "POLYGONSTROKEPRIMITIVE3D"; return u"POLYGONSTROKEPRIMITIVE3D"_ustr;
case PRIMITIVE3D_ID_POLYGONTUBEPRIMITIVE3D: case PRIMITIVE3D_ID_POLYGONTUBEPRIMITIVE3D:
return "POLYGONTUBEPRIMITIVE3D"; return u"POLYGONTUBEPRIMITIVE3D"_ustr;
case PRIMITIVE3D_ID_POLYPOLYGONMATERIALPRIMITIVE3D: case PRIMITIVE3D_ID_POLYPOLYGONMATERIALPRIMITIVE3D:
return "POLYPOLYGONMATERIALPRIMITIVE3D"; return u"POLYPOLYGONMATERIALPRIMITIVE3D"_ustr;
case PRIMITIVE3D_ID_SDRCUBEPRIMITIVE3D: case PRIMITIVE3D_ID_SDRCUBEPRIMITIVE3D:
return "SDRCUBEPRIMITIVE3D"; return u"SDRCUBEPRIMITIVE3D"_ustr;
case PRIMITIVE3D_ID_SDREXTRUDEPRIMITIVE3D: case PRIMITIVE3D_ID_SDREXTRUDEPRIMITIVE3D:
return "SDREXTRUDEPRIMITIVE3D"; return u"SDREXTRUDEPRIMITIVE3D"_ustr;
case PRIMITIVE3D_ID_SDRLATHEPRIMITIVE3D: case PRIMITIVE3D_ID_SDRLATHEPRIMITIVE3D:
return "SDRLATHEPRIMITIVE3D"; return u"SDRLATHEPRIMITIVE3D"_ustr;
case PRIMITIVE3D_ID_SDRPOLYPOLYGONPRIMITIVE3D: case PRIMITIVE3D_ID_SDRPOLYPOLYGONPRIMITIVE3D:
return "SDRPOLYPOLYGONPRIMITIVE3D"; return u"SDRPOLYPOLYGONPRIMITIVE3D"_ustr;
case PRIMITIVE3D_ID_SDRSPHEREPRIMITIVE3D: case PRIMITIVE3D_ID_SDRSPHEREPRIMITIVE3D:
return "SDRSPHEREPRIMITIVE3D"; return u"SDRSPHEREPRIMITIVE3D"_ustr;
case PRIMITIVE3D_ID_SHADOWPRIMITIVE3D: case PRIMITIVE3D_ID_SHADOWPRIMITIVE3D:
return "SHADOWPRIMITIVE3D"; return u"SHADOWPRIMITIVE3D"_ustr;
case PRIMITIVE3D_ID_UNIFIEDTRANSPARENCETEXTUREPRIMITIVE3D: case PRIMITIVE3D_ID_UNIFIEDTRANSPARENCETEXTUREPRIMITIVE3D:
return "UNIFIEDTRANSPARENCETEXTUREPRIMITIVE3D"; return u"UNIFIEDTRANSPARENCETEXTUREPRIMITIVE3D"_ustr;
case PRIMITIVE3D_ID_GRADIENTTEXTUREPRIMITIVE3D: case PRIMITIVE3D_ID_GRADIENTTEXTUREPRIMITIVE3D:
return "GRADIENTTEXTUREPRIMITIVE3D"; return u"GRADIENTTEXTUREPRIMITIVE3D"_ustr;
case PRIMITIVE3D_ID_BITMAPTEXTUREPRIMITIVE3D: case PRIMITIVE3D_ID_BITMAPTEXTUREPRIMITIVE3D:
return "BITMAPTEXTUREPRIMITIVE3D"; return u"BITMAPTEXTUREPRIMITIVE3D"_ustr;
case PRIMITIVE3D_ID_TRANSPARENCETEXTUREPRIMITIVE3D: case PRIMITIVE3D_ID_TRANSPARENCETEXTUREPRIMITIVE3D:
return "TRANSPARENCETEXTUREPRIMITIVE3D"; return u"TRANSPARENCETEXTUREPRIMITIVE3D"_ustr;
case PRIMITIVE3D_ID_TRANSFORMPRIMITIVE3D: case PRIMITIVE3D_ID_TRANSFORMPRIMITIVE3D:
return "TRANSFORMPRIMITIVE3D"; return u"TRANSFORMPRIMITIVE3D"_ustr;
case PRIMITIVE3D_ID_HIDDENGEOMETRYPRIMITIVE3D: case PRIMITIVE3D_ID_HIDDENGEOMETRYPRIMITIVE3D:
return "HIDDENGEOMETRYPRIMITIVE3D"; return u"HIDDENGEOMETRYPRIMITIVE3D"_ustr;
default: default:
return OUString::number((nId >> 16) & 0xFF) + "|" + OUString::number(nId & 0xFF); return OUString::number((nId >> 16) & 0xFF) + "|" + OUString::number(nId & 0xFF);
} }

4
drawinglayer/source/processor2d/vclmetafileprocessor2d.cxx
View File

@ -1274,7 +1274,7 @@ void VclMetafileProcessor2D::processTextHierarchyFieldPrimitive2D(
} }
case drawinglayer::primitive2d::FIELD_TYPE_URL: case drawinglayer::primitive2d::FIELD_TYPE_URL:
{ {
aURL = rFieldPrimitive.getValue("URL"); aURL = rFieldPrimitive.getValue(u"URL"_ustr);
if (!aURL.isEmpty()) if (!aURL.isEmpty())
{ {
@ -1306,7 +1306,7 @@ void VclMetafileProcessor2D::processTextHierarchyFieldPrimitive2D(
static_cast<sal_Int32>(ceil(aViewRange.getMaxX())), static_cast<sal_Int32>(ceil(aViewRange.getMaxX())),
static_cast<sal_Int32>(ceil(aViewRange.getMaxY()))); static_cast<sal_Int32>(ceil(aViewRange.getMaxY())));
vcl::PDFExtOutDevBookmarkEntry aBookmark; vcl::PDFExtOutDevBookmarkEntry aBookmark;
OUString const content(rFieldPrimitive.getValue("Representation")); OUString const content(rFieldPrimitive.getValue(u"Representation"_ustr));
aBookmark.nLinkId = mpPDFExtOutDevData->CreateLink(aRectLogic, content); aBookmark.nLinkId = mpPDFExtOutDevData->CreateLink(aRectLogic, content);
aBookmark.aBookmark = aURL; aBookmark.aBookmark = aURL;
std::vector<vcl::PDFExtOutDevBookmarkEntry>& rBookmarks = mpPDFExtOutDevData->GetBookmarks(); std::vector<vcl::PDFExtOutDevBookmarkEntry>& rBookmarks = mpPDFExtOutDevData->GetBookmarks();

12
drawinglayer/source/tools/emfpbrush.cxx
View File

@ -52,13 +52,13 @@ namespace emfplushelper
{ {
switch (type) switch (type)
{ {
case BrushTypeSolidColor: return "BrushTypeSolidColor"; case BrushTypeSolidColor: return u"BrushTypeSolidColor"_ustr;
case BrushTypeHatchFill: return "BrushTypeHatchFill"; case BrushTypeHatchFill: return u"BrushTypeHatchFill"_ustr;
case BrushTypeTextureFill: return "BrushTypeTextureFill"; case BrushTypeTextureFill: return u"BrushTypeTextureFill"_ustr;
case BrushTypePathGradient: return "BrushTypePathGradient"; case BrushTypePathGradient: return u"BrushTypePathGradient"_ustr;
case BrushTypeLinearGradient: return "BrushTypeLinearGradient"; case BrushTypeLinearGradient: return u"BrushTypeLinearGradient"_ustr;
} }
return ""; return u""_ustr;
} }
void EMFPBrush::Read(SvStream& s, EmfPlusHelperData const & rR) void EMFPBrush::Read(SvStream& s, EmfPlusHelperData const & rR)

98
drawinglayer/source/tools/emfphelperdata.cxx
View File

@ -127,89 +127,89 @@ namespace emfplushelper
{ {
switch (type) switch (type)
{ {
case EmfPlusObjectTypeBrush: return "EmfPlusObjectTypeBrush"; case EmfPlusObjectTypeBrush: return u"EmfPlusObjectTypeBrush"_ustr;
case EmfPlusObjectTypePen: return "EmfPlusObjectTypePen"; case EmfPlusObjectTypePen: return u"EmfPlusObjectTypePen"_ustr;
case EmfPlusObjectTypePath: return "EmfPlusObjectTypePath"; case EmfPlusObjectTypePath: return u"EmfPlusObjectTypePath"_ustr;
case EmfPlusObjectTypeRegion: return "EmfPlusObjectTypeRegion"; case EmfPlusObjectTypeRegion: return u"EmfPlusObjectTypeRegion"_ustr;
case EmfPlusObjectTypeImage: return "EmfPlusObjectTypeImage"; case EmfPlusObjectTypeImage: return u"EmfPlusObjectTypeImage"_ustr;
case EmfPlusObjectTypeFont: return "EmfPlusObjectTypeFont"; case EmfPlusObjectTypeFont: return u"EmfPlusObjectTypeFont"_ustr;
case EmfPlusObjectTypeStringFormat: return "EmfPlusObjectTypeStringFormat"; case EmfPlusObjectTypeStringFormat: return u"EmfPlusObjectTypeStringFormat"_ustr;
case EmfPlusObjectTypeImageAttributes: return "EmfPlusObjectTypeImageAttributes"; case EmfPlusObjectTypeImageAttributes: return u"EmfPlusObjectTypeImageAttributes"_ustr;
case EmfPlusObjectTypeCustomLineCap: return "EmfPlusObjectTypeCustomLineCap"; case EmfPlusObjectTypeCustomLineCap: return u"EmfPlusObjectTypeCustomLineCap"_ustr;
} }
return ""; return u""_ustr;
} }
static OUString PixelOffsetModeToString(sal_uInt16 nPixelOffset) static OUString PixelOffsetModeToString(sal_uInt16 nPixelOffset)
{ {
switch (nPixelOffset) switch (nPixelOffset)
{ {
case PixelOffsetMode::PixelOffsetModeDefault: return "PixelOffsetModeDefault"; case PixelOffsetMode::PixelOffsetModeDefault: return u"PixelOffsetModeDefault"_ustr;
case PixelOffsetMode::PixelOffsetModeHighSpeed: return "PixelOffsetModeHighSpeed"; case PixelOffsetMode::PixelOffsetModeHighSpeed: return u"PixelOffsetModeHighSpeed"_ustr;
case PixelOffsetMode::PixelOffsetModeHighQuality: return "PixelOffsetModeHighQuality"; case PixelOffsetMode::PixelOffsetModeHighQuality: return u"PixelOffsetModeHighQuality"_ustr;
case PixelOffsetMode::PixelOffsetModeNone: return "PixelOffsetModeNone"; case PixelOffsetMode::PixelOffsetModeNone: return u"PixelOffsetModeNone"_ustr;
case PixelOffsetMode::PixelOffsetModeHalf: return "PixelOffsetModeHalf"; case PixelOffsetMode::PixelOffsetModeHalf: return u"PixelOffsetModeHalf"_ustr;
} }
return ""; return u""_ustr;
} }
static OUString SmoothingModeToString(sal_uInt16 nSmoothMode) static OUString SmoothingModeToString(sal_uInt16 nSmoothMode)
{ {
switch (nSmoothMode) switch (nSmoothMode)
{ {
case SmoothingMode::SmoothingModeDefault: return "SmoothingModeDefault"; case SmoothingMode::SmoothingModeDefault: return u"SmoothingModeDefault"_ustr;
case SmoothingMode::SmoothingModeHighSpeed: return "SmoothModeHighSpeed"; case SmoothingMode::SmoothingModeHighSpeed: return u"SmoothModeHighSpeed"_ustr;
case SmoothingMode::SmoothingModeHighQuality: return "SmoothingModeHighQuality"; case SmoothingMode::SmoothingModeHighQuality: return u"SmoothingModeHighQuality"_ustr;
case SmoothingMode::SmoothingModeNone: return "SmoothingModeNone"; case SmoothingMode::SmoothingModeNone: return u"SmoothingModeNone"_ustr;
case SmoothingMode::SmoothingModeAntiAlias8x4: return "SmoothingModeAntiAlias8x4"; case SmoothingMode::SmoothingModeAntiAlias8x4: return u"SmoothingModeAntiAlias8x4"_ustr;
case SmoothingMode::SmoothingModeAntiAlias8x8: return "SmoothingModeAntiAlias8x8"; case SmoothingMode::SmoothingModeAntiAlias8x8: return u"SmoothingModeAntiAlias8x8"_ustr;
} }
return ""; return u""_ustr;
} }
static OUString TextRenderingHintToString(sal_uInt16 nHint) static OUString TextRenderingHintToString(sal_uInt16 nHint)
{ {
switch (nHint) switch (nHint)
{ {
case TextRenderingHint::TextRenderingHintSystemDefault: return "TextRenderingHintSystemDefault"; case TextRenderingHint::TextRenderingHintSystemDefault: return u"TextRenderingHintSystemDefault"_ustr;
case TextRenderingHint::TextRenderingHintSingleBitPerPixelGridFit: return "TextRenderingHintSingleBitPerPixelGridFit"; case TextRenderingHint::TextRenderingHintSingleBitPerPixelGridFit: return u"TextRenderingHintSingleBitPerPixelGridFit"_ustr;
case TextRenderingHint::TextRenderingHintSingleBitPerPixel: return "TextRenderingHintSingleBitPerPixel"; case TextRenderingHint::TextRenderingHintSingleBitPerPixel: return u"TextRenderingHintSingleBitPerPixel"_ustr;
case TextRenderingHint::TextRenderingHintAntialiasGridFit: return "TextRenderingHintAntialiasGridFit"; case TextRenderingHint::TextRenderingHintAntialiasGridFit: return u"TextRenderingHintAntialiasGridFit"_ustr;
case TextRenderingHint::TextRenderingHintAntialias: return "TextRenderingHintAntialias"; case TextRenderingHint::TextRenderingHintAntialias: return u"TextRenderingHintAntialias"_ustr;
case TextRenderingHint::TextRenderingHintClearTypeGridFit: return "TextRenderingHintClearTypeGridFit"; case TextRenderingHint::TextRenderingHintClearTypeGridFit: return u"TextRenderingHintClearTypeGridFit"_ustr;
} }
return ""; return u""_ustr;
} }
static OUString InterpolationModeToString(sal_uInt16 nMode) static OUString InterpolationModeToString(sal_uInt16 nMode)
{ {
switch (nMode) switch (nMode)
{ {
case InterpolationMode::InterpolationModeDefault: return "InterpolationModeDefault"; case InterpolationMode::InterpolationModeDefault: return u"InterpolationModeDefault"_ustr;
case InterpolationMode::InterpolationModeLowQuality: return "InterpolationModeLowQuality"; case InterpolationMode::InterpolationModeLowQuality: return u"InterpolationModeLowQuality"_ustr;
case InterpolationMode::InterpolationModeHighQuality: return "InterpolationModeHighQuality"; case InterpolationMode::InterpolationModeHighQuality: return u"InterpolationModeHighQuality"_ustr;
case InterpolationMode::InterpolationModeBilinear: return "InterpolationModeBilinear"; case InterpolationMode::InterpolationModeBilinear: return u"InterpolationModeBilinear"_ustr;
case InterpolationMode::InterpolationModeBicubic: return "InterpolationModeBicubic"; case InterpolationMode::InterpolationModeBicubic: return u"InterpolationModeBicubic"_ustr;
case InterpolationMode::InterpolationModeNearestNeighbor: return "InterpolationModeNearestNeighbor"; case InterpolationMode::InterpolationModeNearestNeighbor: return u"InterpolationModeNearestNeighbor"_ustr;
case InterpolationMode::InterpolationModeHighQualityBilinear: return "InterpolationModeHighQualityBilinear"; case InterpolationMode::InterpolationModeHighQualityBilinear: return u"InterpolationModeHighQualityBilinear"_ustr;
case InterpolationMode::InterpolationModeHighQualityBicubic: return "InterpolationModeHighQualityBicubic"; case InterpolationMode::InterpolationModeHighQualityBicubic: return u"InterpolationModeHighQualityBicubic"_ustr;
} }
return ""; return u""_ustr;
} }
OUString UnitTypeToString(sal_uInt16 nType) OUString UnitTypeToString(sal_uInt16 nType)
{ {
switch (nType) switch (nType)
{ {
case UnitTypeWorld: return "UnitTypeWorld"; case UnitTypeWorld: return u"UnitTypeWorld"_ustr;
case UnitTypeDisplay: return "UnitTypeDisplay"; case UnitTypeDisplay: return u"UnitTypeDisplay"_ustr;
case UnitTypePixel: return "UnitTypePixel"; case UnitTypePixel: return u"UnitTypePixel"_ustr;
case UnitTypePoint: return "UnitTypePoint"; case UnitTypePoint: return u"UnitTypePoint"_ustr;
case UnitTypeInch: return "UnitTypeInch"; case UnitTypeInch: return u"UnitTypeInch"_ustr;
case UnitTypeDocument: return "UnitTypeDocument"; case UnitTypeDocument: return u"UnitTypeDocument"_ustr;
case UnitTypeMillimeter: return "UnitTypeMillimeter"; case UnitTypeMillimeter: return u"UnitTypeMillimeter"_ustr;
} }
return ""; return u""_ustr;
} }
static bool IsBrush(sal_uInt16 flags) static bool IsBrush(sal_uInt16 flags)
@ -1609,7 +1609,7 @@ namespace emfplushelper
drawinglayer::attribute::FontAttribute fontAttribute( drawinglayer::attribute::FontAttribute fontAttribute(
font->family, // font family font->family, // font family
"", // (no) font style u""_ustr, // (no) font style
font->Bold() ? 8u : 1u, // weight: 8 = bold font->Bold() ? 8u : 1u, // weight: 8 = bold
font->family == "SYMBOL", // symbol font->family == "SYMBOL", // symbol
stringFormat && stringFormat->DirectionVertical(), // vertical stringFormat && stringFormat->DirectionVertical(), // vertical
@ -2171,7 +2171,7 @@ namespace emfplushelper
drawinglayer::attribute::FontAttribute fontAttribute( drawinglayer::attribute::FontAttribute fontAttribute(
font->family, // font family font->family, // font family
"", // (no) font style u""_ustr, // (no) font style
font->Bold() ? 8u : 1u, // weight: 8 = bold font->Bold() ? 8u : 1u, // weight: 8 = bold
font->family == "SYMBOL", // symbol font->family == "SYMBOL", // symbol
optionFlags & 0x2, // vertical optionFlags & 0x2, // vertical

44
drawinglayer/source/tools/emfppen.cxx
View File

@ -102,43 +102,43 @@ namespace emfplushelper
{ {
switch (linecap) switch (linecap)
{ {
case LineCapTypeFlat: return "LineCapTypeFlat"; case LineCapTypeFlat: return u"LineCapTypeFlat"_ustr;
case LineCapTypeSquare: return "LineCapTypeSquare"; case LineCapTypeSquare: return u"LineCapTypeSquare"_ustr;
case LineCapTypeRound: return "LineCapTypeRound"; case LineCapTypeRound: return u"LineCapTypeRound"_ustr;
case LineCapTypeTriangle: return "LineCapTypeTriangle"; case LineCapTypeTriangle: return u"LineCapTypeTriangle"_ustr;
case LineCapTypeNoAnchor: return "LineCapTypeNoAnchor"; case LineCapTypeNoAnchor: return u"LineCapTypeNoAnchor"_ustr;
case LineCapTypeSquareAnchor: return "LineCapTypeSquareAnchor"; case LineCapTypeSquareAnchor: return u"LineCapTypeSquareAnchor"_ustr;
case LineCapTypeRoundAnchor: return "LineCapTypeRoundAchor"; case LineCapTypeRoundAnchor: return u"LineCapTypeRoundAchor"_ustr;
case LineCapTypeDiamondAnchor: return "LineCapTypeDiamondAnchor"; case LineCapTypeDiamondAnchor: return u"LineCapTypeDiamondAnchor"_ustr;
case LineCapTypeArrowAnchor: return "LineCapTypeArrowAnchor"; case LineCapTypeArrowAnchor: return u"LineCapTypeArrowAnchor"_ustr;
case LineCapTypeAnchorMask: return "LineCapTypeAnchorMask"; case LineCapTypeAnchorMask: return u"LineCapTypeAnchorMask"_ustr;
case LineCapTypeCustom: return "LineCapTypeCustom"; case LineCapTypeCustom: return u"LineCapTypeCustom"_ustr;
} }
return ""; return u""_ustr;
} }
static OUString DashedLineCapTypeToString(sal_uInt32 dashedlinecaptype) static OUString DashedLineCapTypeToString(sal_uInt32 dashedlinecaptype)
{ {
switch (dashedlinecaptype) switch (dashedlinecaptype)
{ {
case DashedLineCapTypeFlat: return "DashedLineCapTypeFlat"; case DashedLineCapTypeFlat: return u"DashedLineCapTypeFlat"_ustr;
case DashedLineCapTypeRound: return "DashedLineCapTypeRound"; case DashedLineCapTypeRound: return u"DashedLineCapTypeRound"_ustr;
case DashedLineCapTypeTriangle: return "DashedLineCapTypeTriangle"; case DashedLineCapTypeTriangle: return u"DashedLineCapTypeTriangle"_ustr;
} }
return ""; return u""_ustr;
} }
static OUString PenAlignmentToString(sal_uInt32 alignment) static OUString PenAlignmentToString(sal_uInt32 alignment)
{ {
switch (alignment) switch (alignment)
{ {
case PenAlignmentCenter: return "PenAlignmentCenter"; case PenAlignmentCenter: return u"PenAlignmentCenter"_ustr;
case PenAlignmentInset: return "PenAlignmentInset"; case PenAlignmentInset: return u"PenAlignmentInset"_ustr;
case PenAlignmentLeft: return "PenAlignmentLeft"; case PenAlignmentLeft: return u"PenAlignmentLeft"_ustr;
case PenAlignmentOutset: return "PenAlignmentOutset"; case PenAlignmentOutset: return u"PenAlignmentOutset"_ustr;
case PenAlignmentRight: return "PenAlignmentRight"; case PenAlignmentRight: return u"PenAlignmentRight"_ustr;
} }
return ""; return u""_ustr;
} }
drawinglayer::attribute::StrokeAttribute drawinglayer::attribute::StrokeAttribute

40
drawinglayer/source/tools/emfpstringformat.cxx
View File

@ -87,14 +87,14 @@ namespace emfplushelper
switch(nAlignment) switch(nAlignment)
{ {
case StringAlignment::StringAlignmentNear: case StringAlignment::StringAlignmentNear:
return "StringAlignmentNear"; return u"StringAlignmentNear"_ustr;
case StringAlignment::StringAlignmentCenter: case StringAlignment::StringAlignmentCenter:
return "StringAlignmentCenter"; return u"StringAlignmentCenter"_ustr;
case StringAlignment::StringAlignmentFar: case StringAlignment::StringAlignmentFar:
return "StringAlignmentFar"; return u"StringAlignmentFar"_ustr;
default: default:
assert(false && nAlignment && "invalid string alignment value"); assert(false && nAlignment && "invalid string alignment value");
return "INVALID"; return u"INVALID"_ustr;
} }
} }
@ -103,16 +103,16 @@ namespace emfplushelper
switch(nSubst) switch(nSubst)
{ {
case StringDigitSubstitution::StringDigitSubstitutionUser: case StringDigitSubstitution::StringDigitSubstitutionUser:
return "StringDigitSubstitutionUser"; return u"StringDigitSubstitutionUser"_ustr;
case StringDigitSubstitution::StringDigitSubstitutionNone: case StringDigitSubstitution::StringDigitSubstitutionNone:
return "StringDigitSubstitutionNone"; return u"StringDigitSubstitutionNone"_ustr;
case StringDigitSubstitution::StringDigitSubstitutionNational: case StringDigitSubstitution::StringDigitSubstitutionNational:
return "StringDigitSubstitutionNational"; return u"StringDigitSubstitutionNational"_ustr;
case StringDigitSubstitution::StringDigitSubstitutionTraditional: case StringDigitSubstitution::StringDigitSubstitutionTraditional:
return "StringDigitSubstitutionTraditional"; return u"StringDigitSubstitutionTraditional"_ustr;
default: default:
assert(false && nSubst && "invalid string digit substitution value"); assert(false && nSubst && "invalid string digit substitution value");
return "INVALID"; return u"INVALID"_ustr;
} }
} }
@ -121,14 +121,14 @@ namespace emfplushelper
switch(nHotkey) switch(nHotkey)
{ {
case HotkeyPrefix::HotkeyPrefixNone: case HotkeyPrefix::HotkeyPrefixNone:
return "HotkeyPrefixNone"; return u"HotkeyPrefixNone"_ustr;
case HotkeyPrefix::HotkeyPrefixShow: case HotkeyPrefix::HotkeyPrefixShow:
return "HotkeyPrefixShow"; return u"HotkeyPrefixShow"_ustr;
case HotkeyPrefix::HotkeyPrefixHide: case HotkeyPrefix::HotkeyPrefixHide:
return "HotkeyPrefixHide"; return u"HotkeyPrefixHide"_ustr;
default: default:
assert(false && nHotkey && "invalid hotkey prefix value"); assert(false && nHotkey && "invalid hotkey prefix value");
return "INVALID"; return u"INVALID"_ustr;
} }
} }
@ -137,20 +137,20 @@ namespace emfplushelper
switch(nTrimming) switch(nTrimming)
{ {
case StringTrimming::StringTrimmingNone: case StringTrimming::StringTrimmingNone:
return "StringTrimmingNone"; return u"StringTrimmingNone"_ustr;
case StringTrimming::StringTrimmingCharacter: case StringTrimming::StringTrimmingCharacter:
return "StringTrimmingCharacter"; return u"StringTrimmingCharacter"_ustr;
case StringTrimming::StringTrimmingWord: case StringTrimming::StringTrimmingWord:
return "StringTrimmingWord"; return u"StringTrimmingWord"_ustr;
case StringTrimming::StringTrimmingEllipsisCharacter: case StringTrimming::StringTrimmingEllipsisCharacter:
return "StringTrimmingEllipsisCharacter"; return u"StringTrimmingEllipsisCharacter"_ustr;
case StringTrimming::StringTrimmingEllipsisWord: case StringTrimming::StringTrimmingEllipsisWord:
return "StringTrimmingEllipsisWord"; return u"StringTrimmingEllipsisWord"_ustr;
case StringTrimming::StringTrimmingEllipsisPath: case StringTrimming::StringTrimmingEllipsisPath:
return "StringTrimmingEllipsisPath"; return u"StringTrimmingEllipsisPath"_ustr;
default: default:
assert(false && nTrimming && "invalid trim value"); assert(false && nTrimming && "invalid trim value");
return "INVALID"; return u"INVALID"_ustr;
} }
} }

2
drawinglayer/source/tools/primitive2dxmldump.cxx
View File

@ -704,7 +704,7 @@ void Primitive2dXmlDump::decomposeAndWrite(
for (tools::Long y = 0; y < rSizePixel.getHeight(); y++) for (tools::Long y = 0; y < rSizePixel.getHeight(); y++)
{ {
rWriter.startElement("data"); rWriter.startElement("data");
OUString aBitmapData = ""; OUString aBitmapData = u""_ustr;
for (tools::Long x = 0; x < rSizePixel.getHeight(); x++) for (tools::Long x = 0; x < rSizePixel.getHeight(); x++)
{ {
if (x != 0) if (x != 0)