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());
renderer->setTransformation(basegfx::B2DHomMatrix(14548, 0, -2, 0, 3350, 3431));
CPPUNIT_ASSERT(renderer->draw());
exportDevice("test-tdf136957", mVclDevice);
exportDevice(u"test-tdf136957"_ustr, mVclDevice);
Bitmap bitmap = mVclDevice->GetBitmap(Point(), Size(1920, 1080));
BitmapScopedReadAccess access(bitmap);
// There should be a dotted line, without the fix it wouldn't be there, so check

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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