drawinglayer/source/dumper/EnhancedShapeDumper.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9
  10 #include "EnhancedShapeDumper.hxx"
  11 #include <rtl/strbuf.hxx>
  12 #include <com/sun/star/beans/XPropertySet.hpp>
  13
  14 using namespace com::sun::star;
  15
  16
  17 // ---------- EnhancedCustomShapeExtrusion.idl ----------
  18
  19
  20 void EnhancedShapeDumper::dumpEnhancedCustomShapeExtrusionService(const uno::Reference< beans::XPropertySet >& xPropSet)
  21 {
  22     {
  23         uno::Any anotherAny = xPropSet->getPropertyValue("Extrusion");
  24         bool bExtrusion;
  25         if(anotherAny >>= bExtrusion)
  26             dumpExtrusionAsAttribute(bExtrusion);
  27     }
  28     {
  29         uno::Any anotherAny = xPropSet->getPropertyValue("Brightness");
  30         double aBrightness = double();
  31         if(anotherAny >>= aBrightness)
  32             dumpBrightnessAsAttribute(aBrightness);
  33     }
  34     {
  35         uno::Any anotherAny = xPropSet->getPropertyValue("Depth");
  36         drawing::EnhancedCustomShapeParameterPair aDepth;
  37         if(anotherAny >>= aDepth)
  38             dumpDepthAsElement(aDepth);
  39     }
  40     {
  41         uno::Any anotherAny = xPropSet->getPropertyValue("Diffusion");
  42         double aDiffusion = double();
  43         if(anotherAny >>= aDiffusion)
  44             dumpDiffusionAsAttribute(aDiffusion);
  45     }
  46     {
  47         uno::Any anotherAny = xPropSet->getPropertyValue("NumberOfLineSegments");
  48         sal_Int32 aNumberOfLineSegments = sal_Int32();
  49         if(anotherAny >>= aNumberOfLineSegments)
  50             dumpNumberOfLineSegmentsAsAttribute(aNumberOfLineSegments);
  51     }
  52     {
  53         uno::Any anotherAny = xPropSet->getPropertyValue("LightFace");
  54         bool bLightFace;
  55         if(anotherAny >>= bLightFace)
  56             dumpLightFaceAsAttribute(bLightFace);
  57     }
  58     {
  59         uno::Any anotherAny = xPropSet->getPropertyValue("FirstLightHarsh");
  60         bool bFirstLightHarsh;
  61         if(anotherAny >>= bFirstLightHarsh)
  62             dumpFirstLightHarshAsAttribute(bFirstLightHarsh);
  63     }
  64     {
  65         uno::Any anotherAny = xPropSet->getPropertyValue("SecondLightHarsh");
  66         bool bSecondLightHarsh;
  67         if(anotherAny >>= bSecondLightHarsh)
  68             dumpSecondLightHarshAsAttribute(bSecondLightHarsh);
  69     }
  70     {
  71         uno::Any anotherAny = xPropSet->getPropertyValue("FirstLightLevel");
  72         double aFirstLightLevel = double();
  73         if(anotherAny >>= aFirstLightLevel)
  74             dumpFirstLightLevelAsAttribute(aFirstLightLevel);
  75     }
  76     {
  77         uno::Any anotherAny = xPropSet->getPropertyValue("SecondLightLevel");
  78         double aSecondLightLevel = double();
  79         if(anotherAny >>= aSecondLightLevel)
  80             dumpSecondLightLevelAsAttribute(aSecondLightLevel);
  81     }
  82     {
  83         uno::Any anotherAny = xPropSet->getPropertyValue("FirstLightDirection");
  84         drawing::Direction3D aFirstLightDirection;
  85         if(anotherAny >>= aFirstLightDirection)
  86             dumpFirstLightDirectionAsElement(aFirstLightDirection);
  87     }
  88     {
  89         uno::Any anotherAny = xPropSet->getPropertyValue("SecondLightDirection");
  90         drawing::Direction3D aSecondLightDirection;
  91         if(anotherAny >>= aSecondLightDirection)
  92             dumpSecondLightDirectionAsElement(aSecondLightDirection);
  93     }
  94     {
  95         uno::Any anotherAny = xPropSet->getPropertyValue("Metal");
  96         bool bMetal;
  97         if(anotherAny >>= bMetal)
  98             dumpMetalAsAttribute(bMetal);
  99     }
 100     {
 101         uno::Any anotherAny = xPropSet->getPropertyValue("ShadeMode");
 102         drawing::ShadeMode eShadeMode;
 103         if(anotherAny >>= eShadeMode)
 104             dumpShadeModeAsAttribute(eShadeMode);
 105     }
 106     {
 107         uno::Any anotherAny = xPropSet->getPropertyValue("RotateAngle");
 108         drawing::EnhancedCustomShapeParameterPair aRotateAngle;
 109         if(anotherAny >>= aRotateAngle)
 110             dumpRotateAngleAsElement(aRotateAngle);
 111     }
 112     {
 113         uno::Any anotherAny = xPropSet->getPropertyValue("RotationCenter");
 114         drawing::Direction3D aRotationCenter;
 115         if(anotherAny >>= aRotationCenter)
 116             dumpRotationCenterAsElement(aRotationCenter);
 117     }
 118     {
 119         uno::Any anotherAny = xPropSet->getPropertyValue("Shininess");
 120         double aShininess = double();
 121         if(anotherAny >>= aShininess)
 122             dumpShininessAsAttribute(aShininess);
 123     }
 124     {
 125         uno::Any anotherAny = xPropSet->getPropertyValue("Skew");
 126         drawing::EnhancedCustomShapeParameterPair aSkew;
 127         if(anotherAny >>= aSkew)
 128             dumpSkewAsElement(aSkew);
 129     }
 130     {
 131         uno::Any anotherAny = xPropSet->getPropertyValue("Specularity");
 132         double aSpecularity = double();
 133         if(anotherAny >>= aSpecularity)
 134             dumpSpecularityAsAttribute(aSpecularity);
 135     }
 136     {
 137         uno::Any anotherAny = xPropSet->getPropertyValue("ProjectionMode");
 138         drawing::ProjectionMode eProjectionMode;
 139         if(anotherAny >>= eProjectionMode)
 140             dumpProjectionModeAsAttribute(eProjectionMode);
 141     }
 142     {
 143         uno::Any anotherAny = xPropSet->getPropertyValue("ViewPoint");
 144         drawing::Position3D aViewPoint;
 145         if(anotherAny >>= aViewPoint)
 146             dumpViewPointAsElement(aViewPoint);
 147     }
 148     {
 149         uno::Any anotherAny = xPropSet->getPropertyValue("Origin");
 150         drawing::EnhancedCustomShapeParameterPair aOrigin;
 151         if(anotherAny >>= aOrigin)
 152             dumpOriginAsElement(aOrigin);
 153     }
 154     {
 155         uno::Any anotherAny = xPropSet->getPropertyValue("ExtrusionColor");
 156         bool bExtrusionColor;
 157         if(anotherAny >>= bExtrusionColor)
 158             dumpExtrusionColorAsAttribute(bExtrusionColor);
 159     }
 160 }
 161 void EnhancedShapeDumper::dumpExtrusionAsAttribute(bool bExtrusion)
 162 {
 163     if(bExtrusion)
 164         xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("extrusion"), "%s", "true");
 165     else
 166         xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("extrusion"), "%s", "false");
 167 }
 168
 169 void EnhancedShapeDumper::dumpBrightnessAsAttribute(double aBrightness)
 170 {
 171     xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("brightness"), "%f", aBrightness);
 172 }
 173
 174 void EnhancedShapeDumper::dumpEnhancedCustomShapeParameterPair(
 175     const drawing::EnhancedCustomShapeParameterPair& aParameterPair)
 176 {
 177     {
 178         xmlTextWriterStartElement(xmlWriter, BAD_CAST( "First" ));
 179         dumpEnhancedCustomShapeParameter(aParameterPair.First);
 180         xmlTextWriterEndElement( xmlWriter );
 181     }
 182     {
 183         xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Second" ));
 184         dumpEnhancedCustomShapeParameter(aParameterPair.Second);
 185         xmlTextWriterEndElement( xmlWriter );
 186     }
 187 }
 188
 189 void EnhancedShapeDumper::dumpDepthAsElement(const drawing::EnhancedCustomShapeParameterPair& aDepth)
 190 {
 191     xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Depth" ));
 192     dumpEnhancedCustomShapeParameterPair(aDepth);
 193     xmlTextWriterEndElement( xmlWriter );
 194 }
 195
 196 void EnhancedShapeDumper::dumpDiffusionAsAttribute(double aDiffusion)
 197 {
 198     xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("diffusion"), "%f", aDiffusion);
 199 }
 200
 201 void EnhancedShapeDumper::dumpNumberOfLineSegmentsAsAttribute(sal_Int32 aNumberOfLineSegments)
 202 {
 203     xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("numberOfLineSegments"), "%" SAL_PRIdINT32, aNumberOfLineSegments);
 204 }
 205
 206 void EnhancedShapeDumper::dumpLightFaceAsAttribute(bool bLightFace)
 207 {
 208     if(bLightFace)
 209         xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("lightFace"), "%s", "true");
 210     else
 211         xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("lightFace"), "%s", "false");
 212 }
 213
 214 void EnhancedShapeDumper::dumpFirstLightHarshAsAttribute(bool bFirstLightHarsh)
 215 {
 216     if(bFirstLightHarsh)
 217         xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("firstLightHarsh"), "%s", "true");
 218     else
 219         xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("firstLightHarsh"), "%s", "false");
 220 }
 221
 222 void EnhancedShapeDumper::dumpSecondLightHarshAsAttribute(bool bSecondLightHarsh)
 223 {
 224     if(bSecondLightHarsh)
 225         xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("secondLightHarsh"), "%s", "true");
 226     else
 227         xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("secondLightHarsh"), "%s", "false");
 228 }
 229
 230 void EnhancedShapeDumper::dumpFirstLightLevelAsAttribute(double aFirstLightLevel)
 231 {
 232     xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("firstLightLevel"), "%f", aFirstLightLevel);
 233 }
 234
 235 void EnhancedShapeDumper::dumpSecondLightLevelAsAttribute(double aSecondLightLevel)
 236 {
 237     xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("secondLightLevel"), "%f", aSecondLightLevel);
 238 }
 239
 240 void EnhancedShapeDumper::dumpDirection3D(drawing::Direction3D aDirection3D)
 241 {
 242     xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("directionX"), "%f", aDirection3D.DirectionX);
 243     xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("directionY"), "%f", aDirection3D.DirectionY);
 244     xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("directionZ"), "%f", aDirection3D.DirectionZ);
 245 }
 246
 247 void EnhancedShapeDumper::dumpFirstLightDirectionAsElement(drawing::Direction3D aFirstLightDirection)
 248 {
 249     xmlTextWriterStartElement(xmlWriter, BAD_CAST( "FirstLightDirection" ));
 250     dumpDirection3D(aFirstLightDirection);
 251     xmlTextWriterEndElement( xmlWriter );
 252 }
 253
 254 void EnhancedShapeDumper::dumpSecondLightDirectionAsElement(drawing::Direction3D aSecondLightDirection)
 255 {
 256     xmlTextWriterStartElement(xmlWriter, BAD_CAST( "SecondLightDirection" ));
 257     dumpDirection3D(aSecondLightDirection);
 258     xmlTextWriterEndElement( xmlWriter );
 259 }
 260
 261 void EnhancedShapeDumper::dumpMetalAsAttribute(bool bMetal)
 262 {
 263     if(bMetal)
 264         xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("metal"), "%s", "true");
 265     else
 266         xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("metal"), "%s", "false");
 267 }
 268
 269 void EnhancedShapeDumper::dumpShadeModeAsAttribute(drawing::ShadeMode eShadeMode)
 270 {
 271     switch(eShadeMode)
 272     {
 273         case drawing::ShadeMode_FLAT:
 274             xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("shadeMode"), "%s", "FLAT");
 275             break;
 276         case drawing::ShadeMode_PHONG:
 277             xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("shadeMode"), "%s", "PHONG");
 278             break;
 279         case drawing::ShadeMode_SMOOTH:
 280             xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("shadeMode"), "%s", "SMOOTH");
 281             break;
 282         case drawing::ShadeMode_DRAFT:
 283             xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("shadeMode"), "%s", "DRAFT");
 284             break;
 285         default:
 286             break;
 287     }
 288 }
 289
 290 void EnhancedShapeDumper::dumpRotateAngleAsElement(const drawing::EnhancedCustomShapeParameterPair& aRotateAngle)
 291 {
 292     xmlTextWriterStartElement(xmlWriter, BAD_CAST( "RotateAngle" ));
 293     dumpEnhancedCustomShapeParameterPair(aRotateAngle);
 294     xmlTextWriterEndElement( xmlWriter );
 295 }
 296
 297 void EnhancedShapeDumper::dumpRotationCenterAsElement(drawing::Direction3D aRotationCenter)
 298 {
 299     xmlTextWriterStartElement(xmlWriter, BAD_CAST( "RotationCenter" ));
 300     dumpDirection3D(aRotationCenter);
 301     xmlTextWriterEndElement( xmlWriter );
 302 }
 303
 304 void EnhancedShapeDumper::dumpShininessAsAttribute(double aShininess)
 305 {
 306     xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("shininess"), "%f", aShininess);
 307 }
 308
 309 void EnhancedShapeDumper::dumpSkewAsElement(const drawing::EnhancedCustomShapeParameterPair& aSkew)
 310 {
 311     xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Skew" ));
 312     dumpEnhancedCustomShapeParameterPair(aSkew);
 313     xmlTextWriterEndElement( xmlWriter );
 314 }
 315
 316 void EnhancedShapeDumper::dumpSpecularityAsAttribute(double aSpecularity)
 317 {
 318     xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("specularity"), "%f", aSpecularity);
 319 }
 320
 321 void EnhancedShapeDumper::dumpProjectionModeAsAttribute(drawing::ProjectionMode eProjectionMode)
 322 {
 323     switch(eProjectionMode)
 324     {
 325         case drawing::ProjectionMode_PARALLEL:
 326             xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("projectionMode"), "%s", "PARALLEL");
 327             break;
 328         case drawing::ProjectionMode_PERSPECTIVE:
 329             xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("projectionMode"), "%s", "PERSPECTIVE");
 330             break;
 331         default:
 332             break;
 333     }
 334 }
 335
 336 void EnhancedShapeDumper::dumpViewPointAsElement(drawing::Position3D aViewPoint)
 337 {
 338     xmlTextWriterStartElement(xmlWriter, BAD_CAST( "ViewPoint" ));
 339     xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("positionX"), "%f", aViewPoint.PositionX);
 340     xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("positionY"), "%f", aViewPoint.PositionY);
 341     xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("positionZ"), "%f", aViewPoint.PositionZ);
 342     xmlTextWriterEndElement( xmlWriter );
 343 }
 344
 345 void EnhancedShapeDumper::dumpOriginAsElement(const drawing::EnhancedCustomShapeParameterPair& aOrigin)
 346 {
 347     xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Origin" ));
 348     dumpEnhancedCustomShapeParameterPair(aOrigin);
 349     xmlTextWriterEndElement( xmlWriter );
 350 }
 351
 352 void EnhancedShapeDumper::dumpExtrusionColorAsAttribute(bool bExtrusionColor)
 353 {
 354     if(bExtrusionColor)
 355         xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("extrusionColor"), "%s", "true");
 356     else
 357         xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("extrusionColor"), "%s", "false");
 358 }
 359
 360
 361 // ---------- EnhancedCustomShapeGeometry.idl -----------
 362
 363
 364 void EnhancedShapeDumper::dumpEnhancedCustomShapeGeometryService(const uno::Reference< beans::XPropertySet >& xPropSet)
 365 {
 366     {
 367         uno::Any anotherAny = xPropSet->getPropertyValue("Type");
 368         OUString sType;
 369         if(anotherAny >>= sType)
 370             dumpTypeAsAttribute(sType);
 371     }
 372     {
 373         uno::Any anotherAny = xPropSet->getPropertyValue("ViewBox");
 374         awt::Rectangle aViewBox;
 375         if(anotherAny >>= aViewBox)
 376             dumpViewBoxAsElement(aViewBox);
 377     }
 378     {
 379         uno::Any anotherAny = xPropSet->getPropertyValue("MirroredX");
 380         bool bMirroredX;
 381         if(anotherAny >>= bMirroredX)
 382             dumpMirroredXAsAttribute(bMirroredX);
 383     }
 384     {
 385         uno::Any anotherAny = xPropSet->getPropertyValue("MirroredY");
 386         bool bMirroredY;
 387         if(anotherAny >>= bMirroredY)
 388             dumpMirroredYAsAttribute(bMirroredY);
 389     }
 390     {
 391         uno::Any anotherAny = xPropSet->getPropertyValue("TextRotateAngle");
 392         double aTextRotateAngle = double();
 393         if(anotherAny >>= aTextRotateAngle)
 394             dumpTextRotateAngleAsAttribute(aTextRotateAngle);
 395     }
 396     {
 397         uno::Any anotherAny = xPropSet->getPropertyValue("AdjustmentValues");
 398         uno::Sequence< drawing::EnhancedCustomShapeAdjustmentValue> aAdjustmentValues;
 399         if(anotherAny >>= aAdjustmentValues)
 400             dumpAdjustmentValuesAsElement(aAdjustmentValues);
 401     }
 402     {
 403         uno::Any anotherAny = xPropSet->getPropertyValue("Extrusion");
 404         uno::Sequence< beans::PropertyValue > aExtrusion;
 405         if(anotherAny >>= aExtrusion)
 406             dumpExtrusionAsElement(aExtrusion);
 407     }
 408     {
 409         uno::Any anotherAny = xPropSet->getPropertyValue("Path");
 410         uno::Sequence< beans::PropertyValue > aPath;
 411         if(anotherAny >>= aPath)
 412             dumpPathAsElement(aPath);
 413     }
 414     {
 415         uno::Any anotherAny = xPropSet->getPropertyValue("TextPath");
 416         uno::Sequence< beans::PropertyValue > aTextPath;
 417         if(anotherAny >>= aTextPath)
 418             dumpTextPathAsElement(aTextPath);
 419     }
 420     {
 421         uno::Any anotherAny = xPropSet->getPropertyValue("Equations");
 422         uno::Sequence< OUString > aEquations;
 423         if(anotherAny >>= aEquations)
 424             dumpEquationsAsElement(aEquations);
 425     }
 426     {
 427         uno::Any anotherAny = xPropSet->getPropertyValue("Handles");
 428         uno::Sequence< beans::PropertyValues > aHandles;
 429         if(anotherAny >>= aHandles)
 430             dumpHandlesAsElement(aHandles);
 431     }
 432 }
 433 void EnhancedShapeDumper::dumpTypeAsAttribute(const OUString& sType)
 434 {
 435     xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("type"), "%s",
 436         OUStringToOString(sType, RTL_TEXTENCODING_UTF8).getStr());
 437 }
 438
 439 void EnhancedShapeDumper::dumpViewBoxAsElement(awt::Rectangle aViewBox)
 440 {
 441     xmlTextWriterStartElement(xmlWriter, BAD_CAST( "ViewBox" ));
 442     xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("x"), "%" SAL_PRIdINT32, aViewBox.X);
 443     xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("y"), "%" SAL_PRIdINT32, aViewBox.Y);
 444     xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("width"), "%" SAL_PRIdINT32, aViewBox.Width);
 445     xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("height"), "%" SAL_PRIdINT32, aViewBox.Height);
 446     xmlTextWriterEndElement( xmlWriter );
 447 }
 448
 449 void EnhancedShapeDumper::dumpMirroredXAsAttribute(bool bMirroredX)
 450 {
 451     if(bMirroredX)
 452         xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("mirroredX"), "%s", "true");
 453     else
 454         xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("mirroredX"), "%s", "false");
 455 }
 456
 457 void EnhancedShapeDumper::dumpMirroredYAsAttribute(bool bMirroredY)
 458 {
 459     if(bMirroredY)
 460         xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("mirroredY"), "%s", "true");
 461     else
 462         xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("mirroredY"), "%s", "false");
 463 }
 464
 465 void EnhancedShapeDumper::dumpTextRotateAngleAsAttribute(double aTextRotateAngle)
 466 {
 467     xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textRotateAngle"), "%f", aTextRotateAngle);
 468 }
 469
 470 void EnhancedShapeDumper::dumpAdjustmentValuesAsElement(const uno::Sequence< drawing::EnhancedCustomShapeAdjustmentValue>& aAdjustmentValues)
 471 {
 472     xmlTextWriterStartElement(xmlWriter, BAD_CAST( "AdjustmentValues" ));
 473     sal_Int32 nLength = aAdjustmentValues.getLength();
 474     for (sal_Int32 i = 0; i < nLength; ++i)
 475     {
 476         xmlTextWriterStartElement(xmlWriter, BAD_CAST( "EnhancedCustomShapeAdjustmentValue" ));
 477         uno::Any aAny = aAdjustmentValues[i].Value;
 478         OUString sValue;
 479         float fValue;
 480         sal_Int32 nValue;
 481         bool bValue;
 482         if(aAny >>= sValue)
 483         {
 484             xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("value"), "%s",
 485                 OUStringToOString(sValue, RTL_TEXTENCODING_UTF8).getStr());
 486         }
 487         else if(aAny >>= nValue)
 488         {
 489             xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("value"), "%" SAL_PRIdINT32, nValue);
 490         }
 491         else if(aAny >>= fValue)
 492         {
 493             xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("value"), "%f", fValue);
 494         }
 495         else if(aAny >>= bValue)
 496         {
 497             xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("value"), "%s", (bValue? "true": "false"));
 498         }
 499
 500         switch(aAdjustmentValues[i].State)
 501         {
 502             case beans::PropertyState_DIRECT_VALUE:
 503                 xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("propertyState"), "%s", "DIRECT_VALUE");
 504                 break;
 505             case beans::PropertyState_DEFAULT_VALUE:
 506                 xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("propertyState"), "%s", "DEFAULT_VALUE");
 507                 break;
 508             case beans::PropertyState_AMBIGUOUS_VALUE:
 509                 xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("propertyState"), "%s", "AMBIGUOUS_VALUE");
 510                 break;
 511             default:
 512                 break;
 513         }
 514         xmlTextWriterEndElement( xmlWriter );
 515     }
 516     xmlTextWriterEndElement( xmlWriter );
 517 }
 518
 519 void EnhancedShapeDumper::dumpPropertyValueAsElement(const beans::PropertyValue& aPropertyValue)
 520 {
 521     xmlTextWriterStartElement(xmlWriter, BAD_CAST( "PropertyValue" ));
 522
 523     xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("name"), "%s",
 524         OUStringToOString(aPropertyValue.Name, RTL_TEXTENCODING_UTF8).getStr());
 525     xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("handle"), "%" SAL_PRIdINT32, aPropertyValue.Handle);
 526
 527     uno::Any aAny = aPropertyValue.Value;
 528     OUString sValue;
 529     if(aAny >>= sValue)
 530     {
 531         xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("value"), "%s",
 532             OUStringToOString(sValue, RTL_TEXTENCODING_UTF8).getStr());
 533     }
 534     switch(aPropertyValue.State)
 535     {
 536         case beans::PropertyState_DIRECT_VALUE:
 537             xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("propertyState"), "%s", "DIRECT_VALUE");
 538             break;
 539         case beans::PropertyState_DEFAULT_VALUE:
 540             xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("propertyState"), "%s", "DEFAULT_VALUE");
 541             break;
 542         case beans::PropertyState_AMBIGUOUS_VALUE:
 543             xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("propertyState"), "%s", "AMBIGUOUS_VALUE");
 544             break;
 545         default:
 546             break;
 547     }
 548     xmlTextWriterEndElement( xmlWriter );
 549 }
 550
 551 void EnhancedShapeDumper::dumpExtrusionAsElement(const uno::Sequence< beans::PropertyValue >& aExtrusion)
 552 {
 553     xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Extrusion" ));
 554     sal_Int32 nLength = aExtrusion.getLength();
 555     for (sal_Int32 i = 0; i < nLength; ++i)
 556     {
 557         dumpPropertyValueAsElement(aExtrusion[i]);
 558     }
 559     xmlTextWriterEndElement( xmlWriter );
 560 }
 561
 562 void EnhancedShapeDumper::dumpPathAsElement(const uno::Sequence< beans::PropertyValue >& aPath)
 563 {
 564     xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Path" ));
 565     sal_Int32 nLength = aPath.getLength();
 566     for (sal_Int32 i = 0; i < nLength; ++i)
 567     {
 568         dumpPropertyValueAsElement(aPath[i]);
 569     }
 570     xmlTextWriterEndElement( xmlWriter );
 571 }
 572
 573 void EnhancedShapeDumper::dumpTextPathAsElement(const uno::Sequence< beans::PropertyValue >& aTextPath)
 574 {
 575     xmlTextWriterStartElement(xmlWriter, BAD_CAST( "TextPath" ));
 576     sal_Int32 nLength = aTextPath.getLength();
 577     for (sal_Int32 i = 0; i < nLength; ++i)
 578     {
 579         dumpPropertyValueAsElement(aTextPath[i]);
 580     }
 581     xmlTextWriterEndElement( xmlWriter );
 582 }
 583
 584 void EnhancedShapeDumper::dumpEquationsAsElement(const uno::Sequence< OUString >& aEquations)
 585 {
 586     xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Equations" ));
 587     sal_Int32 nLength = aEquations.getLength();
 588     for (sal_Int32 i = 0; i < nLength; ++i)
 589     {
 590         xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("name"), "%s",
 591             OUStringToOString(aEquations[i], RTL_TEXTENCODING_UTF8).getStr());
 592     }
 593     xmlTextWriterEndElement( xmlWriter );
 594 }
 595
 596 // PropertyValues specifies a sequence of PropertyValue instances.
 597 // so in this case it's a Sequence of a Sequence of a PropertyValue instances.
 598 // Welcome to Sequenception again.
 599 void EnhancedShapeDumper::dumpHandlesAsElement(const uno::Sequence< beans::PropertyValues >& aHandles)
 600 {
 601     xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Handles" ));
 602     sal_Int32 nSequenceLength = aHandles.getLength();
 603     for (sal_Int32 i = 0; i < nSequenceLength; ++i)
 604     {
 605         xmlTextWriterStartElement(xmlWriter, BAD_CAST( "PropertyValues" ));
 606         uno::Sequence< beans::PropertyValue > propertyValueSequence = aHandles[i];
 607         sal_Int32 nLength = propertyValueSequence.getLength();
 608         for (sal_Int32 j = 0; j < nLength; ++j)
 609         {
 610             dumpPropertyValueAsElement(propertyValueSequence[j]);
 611         }
 612         xmlTextWriterEndElement( xmlWriter );
 613     }
 614     xmlTextWriterEndElement( xmlWriter );
 615 }
 616
 617
 618 // ---------- EnhancedCustomShapeHandle.idl -----------
 619
 620
 621 void EnhancedShapeDumper::dumpEnhancedCustomShapeHandleService(const uno::Reference< beans::XPropertySet >& xPropSet)
 622 {
 623     {
 624         uno::Any anotherAny = xPropSet->getPropertyValue("MirroredX");
 625         bool bMirroredX;
 626         if(anotherAny >>= bMirroredX)
 627             dumpMirroredXAsAttribute(bMirroredX);
 628     }
 629     {
 630         uno::Any anotherAny = xPropSet->getPropertyValue("MirroredY");
 631         bool bMirroredY;
 632         if(anotherAny >>= bMirroredY)
 633             dumpMirroredYAsAttribute(bMirroredY);
 634     }
 635     {
 636         uno::Any anotherAny = xPropSet->getPropertyValue("Switched");
 637         bool bSwitched;
 638         if(anotherAny >>= bSwitched)
 639             dumpSwitchedAsAttribute(bSwitched);
 640     }
 641     {
 642         uno::Any anotherAny = xPropSet->getPropertyValue("Position");
 643         drawing::EnhancedCustomShapeParameterPair aPosition;
 644         if(anotherAny >>= aPosition)
 645             dumpPositionAsElement(aPosition);
 646     }
 647     {
 648         uno::Any anotherAny = xPropSet->getPropertyValue("Polar");
 649         drawing::EnhancedCustomShapeParameterPair aPolar;
 650         if(anotherAny >>= aPolar)
 651             dumpPolarAsElement(aPolar);
 652     }
 653     {
 654         uno::Any anotherAny = xPropSet->getPropertyValue("RefX");
 655         sal_Int32 aRefX = sal_Int32();
 656         if(anotherAny >>= aRefX)
 657             dumpRefXAsAttribute(aRefX);
 658     }
 659     {
 660         uno::Any anotherAny = xPropSet->getPropertyValue("RefY");
 661         sal_Int32 aRefY = sal_Int32();
 662         if(anotherAny >>= aRefY)
 663             dumpRefYAsAttribute(aRefY);
 664     }
 665     {
 666         uno::Any anotherAny = xPropSet->getPropertyValue("RefAngle");
 667         sal_Int32 aRefAngle = sal_Int32();
 668         if(anotherAny >>= aRefAngle)
 669             dumpRefAngleAsAttribute(aRefAngle);
 670     }
 671     {
 672         uno::Any anotherAny = xPropSet->getPropertyValue("RefR");
 673         sal_Int32 aRefR = sal_Int32();
 674         if(anotherAny >>= aRefR)
 675             dumpRefRAsAttribute(aRefR);
 676     }
 677     {
 678         uno::Any anotherAny = xPropSet->getPropertyValue("RangeXMinimum");
 679         drawing::EnhancedCustomShapeParameter aRangeXMinimum;
 680         if(anotherAny >>= aRangeXMinimum)
 681             dumpRangeXMinimumAsElement(aRangeXMinimum);
 682     }
 683     {
 684         uno::Any anotherAny = xPropSet->getPropertyValue("RangeXMaximum");
 685         drawing::EnhancedCustomShapeParameter aRangeXMaximum;
 686         if(anotherAny >>= aRangeXMaximum)
 687             dumpRangeXMaximumAsElement(aRangeXMaximum);
 688     }
 689     {
 690         uno::Any anotherAny = xPropSet->getPropertyValue("RangeYMinimum");
 691         drawing::EnhancedCustomShapeParameter aRangeYMinimum;
 692         if(anotherAny >>= aRangeYMinimum)
 693             dumpRangeYMinimumAsElement(aRangeYMinimum);
 694     }
 695     {
 696         uno::Any anotherAny = xPropSet->getPropertyValue("RangeYMaximum");
 697         drawing::EnhancedCustomShapeParameter aRangeYMaximum;
 698         if(anotherAny >>= aRangeYMaximum)
 699             dumpRangeYMaximumAsElement(aRangeYMaximum);
 700     }
 701     {
 702         uno::Any anotherAny = xPropSet->getPropertyValue("RadiusRangeMinimum");
 703         drawing::EnhancedCustomShapeParameter aRadiusRangeMinimum;
 704         if(anotherAny >>= aRadiusRangeMinimum)
 705             dumpRadiusRangeMinimumAsElement(aRadiusRangeMinimum);
 706     }
 707     {
 708         uno::Any anotherAny = xPropSet->getPropertyValue("RadiusRangeMaximum");
 709         drawing::EnhancedCustomShapeParameter aRadiusRangeMaximum;
 710         if(anotherAny >>= aRadiusRangeMaximum)
 711             dumpRadiusRangeMaximumAsElement(aRadiusRangeMaximum);
 712     }
 713 }
 714
 715 void EnhancedShapeDumper::dumpSwitchedAsAttribute(bool bSwitched)
 716 {
 717     if(bSwitched)
 718         xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("switched"), "%s", "true");
 719     else
 720         xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("switched"), "%s", "false");
 721 }
 722
 723 void EnhancedShapeDumper::dumpPositionAsElement(const drawing::EnhancedCustomShapeParameterPair& aPosition)
 724 {
 725     xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Position" ));
 726     dumpEnhancedCustomShapeParameterPair(aPosition);
 727     xmlTextWriterEndElement( xmlWriter );
 728 }
 729
 730 void EnhancedShapeDumper::dumpPolarAsElement(const drawing::EnhancedCustomShapeParameterPair& aPolar)
 731 {
 732     xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Polar" ));
 733     dumpEnhancedCustomShapeParameterPair(aPolar);
 734     xmlTextWriterEndElement( xmlWriter );
 735 }
 736
 737 void EnhancedShapeDumper::dumpRefXAsAttribute(sal_Int32 aRefX)
 738 {
 739     xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("refX"), "%" SAL_PRIdINT32, aRefX);
 740 }
 741
 742 void EnhancedShapeDumper::dumpRefYAsAttribute(sal_Int32 aRefY)
 743 {
 744     xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("refY"), "%" SAL_PRIdINT32, aRefY);
 745 }
 746
 747 void EnhancedShapeDumper::dumpRefAngleAsAttribute(sal_Int32 aRefAngle)
 748 {
 749     xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("refAngle"), "%" SAL_PRIdINT32, aRefAngle);
 750 }
 751
 752 void EnhancedShapeDumper::dumpRefRAsAttribute(sal_Int32 aRefR)
 753 {
 754     xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("refR"), "%" SAL_PRIdINT32, aRefR);
 755 }
 756
 757 void EnhancedShapeDumper::dumpEnhancedCustomShapeParameter(
 758     const drawing::EnhancedCustomShapeParameter& aParameter)
 759 {
 760     uno::Any aAny = aParameter.Value;
 761     OUString sValue;
 762     float fValue;
 763     sal_Int32 nValue;
 764     bool bValue;
 765     if(aAny >>= sValue)
 766     {
 767         xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("value"), "%s",
 768             OUStringToOString(sValue, RTL_TEXTENCODING_UTF8).getStr());
 769     }
 770     else if(aAny >>= nValue)
 771     {
 772         xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("value"), "%" SAL_PRIdINT32, nValue);
 773     }
 774     else if(aAny >>= fValue)
 775     {
 776         xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("value"), "%f", fValue);
 777     }
 778     else if(aAny >>= bValue)
 779     {
 780         xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("value"), "%s", (bValue? "true": "false"));
 781     }
 782     sal_Int32 aType = aParameter.Type;
 783     xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("type"), "%" SAL_PRIdINT32, aType);
 784 }
 785
 786 void EnhancedShapeDumper::dumpRangeXMinimumAsElement(const drawing::EnhancedCustomShapeParameter& aRangeXMinimum)
 787 {
 788     xmlTextWriterStartElement(xmlWriter, BAD_CAST( "RangeXMinimum" ));
 789     dumpEnhancedCustomShapeParameter(aRangeXMinimum);
 790     xmlTextWriterEndElement( xmlWriter );
 791 }
 792
 793 void EnhancedShapeDumper::dumpRangeXMaximumAsElement(const drawing::EnhancedCustomShapeParameter& aRangeXMaximum)
 794 {
 795     xmlTextWriterStartElement(xmlWriter, BAD_CAST( "RangeXMaximum" ));
 796     dumpEnhancedCustomShapeParameter(aRangeXMaximum);
 797     xmlTextWriterEndElement( xmlWriter );
 798 }
 799
 800 void EnhancedShapeDumper::dumpRangeYMinimumAsElement(const drawing::EnhancedCustomShapeParameter& aRangeYMinimum)
 801 {
 802     xmlTextWriterStartElement(xmlWriter, BAD_CAST( "RangeYMinimum" ));
 803     dumpEnhancedCustomShapeParameter(aRangeYMinimum);
 804     xmlTextWriterEndElement( xmlWriter );
 805 }
 806
 807 void EnhancedShapeDumper::dumpRangeYMaximumAsElement(const drawing::EnhancedCustomShapeParameter& aRangeYMaximum)
 808 {
 809     xmlTextWriterStartElement(xmlWriter, BAD_CAST( "RangeYMaximum" ));
 810     dumpEnhancedCustomShapeParameter(aRangeYMaximum);
 811     xmlTextWriterEndElement( xmlWriter );
 812 }
 813
 814 void EnhancedShapeDumper::dumpRadiusRangeMinimumAsElement(const drawing::EnhancedCustomShapeParameter& aRadiusRangeMinimum)
 815 {
 816     xmlTextWriterStartElement(xmlWriter, BAD_CAST( "RadiusRangeMinimum" ));
 817     dumpEnhancedCustomShapeParameter(aRadiusRangeMinimum);
 818     xmlTextWriterEndElement( xmlWriter );
 819 }
 820
 821 void EnhancedShapeDumper::dumpRadiusRangeMaximumAsElement(const drawing::EnhancedCustomShapeParameter& aRadiusRangeMaximum)
 822 {
 823     xmlTextWriterStartElement(xmlWriter, BAD_CAST( "RadiusRangeMaximum" ));
 824     dumpEnhancedCustomShapeParameter(aRadiusRangeMaximum);
 825     xmlTextWriterEndElement( xmlWriter );
 826 }
 827
 828
 829 // ---------- EnhancedCustomShapePath.idl ---------------
 830
 831
 832 void EnhancedShapeDumper::dumpEnhancedCustomShapePathService(const uno::Reference< beans::XPropertySet >& xPropSet)
 833 {
 834     {
 835         uno::Any anotherAny = xPropSet->getPropertyValue("Coordinates");
 836         uno::Sequence< drawing::EnhancedCustomShapeParameterPair > aCoordinates;
 837         if(anotherAny >>= aCoordinates)
 838             dumpCoordinatesAsElement(aCoordinates);
 839     }
 840     {
 841         uno::Any anotherAny = xPropSet->getPropertyValue("Segments");
 842         uno::Sequence< drawing::EnhancedCustomShapeSegment > aSegments;
 843         if(anotherAny >>= aSegments)
 844             dumpSegmentsAsElement(aSegments);
 845     }
 846     {
 847         uno::Any anotherAny = xPropSet->getPropertyValue("StretchX");
 848         sal_Int32 aStretchX = sal_Int32();
 849         if(anotherAny >>= aStretchX)
 850             dumpStretchXAsAttribute(aStretchX);
 851     }
 852     {
 853         uno::Any anotherAny = xPropSet->getPropertyValue("StretchY");
 854         sal_Int32 aStretchY = sal_Int32();
 855         if(anotherAny >>= aStretchY)
 856             dumpStretchYAsAttribute(aStretchY);
 857     }
 858     {
 859         uno::Any anotherAny = xPropSet->getPropertyValue("TextFrames");
 860         uno::Sequence< drawing::EnhancedCustomShapeTextFrame > aTextFrames;
 861         if(anotherAny >>= aTextFrames)
 862             dumpTextFramesAsElement(aTextFrames);
 863     }
 864     {
 865         uno::Any anotherAny = xPropSet->getPropertyValue("GluePoints");
 866         uno::Sequence< drawing::EnhancedCustomShapeParameterPair > aGluePoints;
 867         if(anotherAny >>= aGluePoints)
 868             dumpGluePointsAsElement(aGluePoints);
 869     }
 870     {
 871         uno::Any anotherAny = xPropSet->getPropertyValue("GluePointLeavingDirections");
 872         uno::Sequence< double > aGluePointLeavingDirections;
 873         if(anotherAny >>= aGluePointLeavingDirections)
 874             dumpGluePointLeavingDirectionsAsElement(aGluePointLeavingDirections);
 875     }
 876     {
 877         uno::Any anotherAny = xPropSet->getPropertyValue("GluePointType");
 878         sal_Int32 aGluePointType = sal_Int32();
 879         if(anotherAny >>= aGluePointType)
 880             dumpGluePointTypeAsAttribute(aGluePointType);
 881     }
 882     {
 883         uno::Any anotherAny = xPropSet->getPropertyValue("ExtrusionAllowed");
 884         bool bExtrusionAllowed;
 885         if(anotherAny >>= bExtrusionAllowed)
 886             dumpExtrusionAllowedAsAttribute(bExtrusionAllowed);
 887     }
 888     {
 889         uno::Any anotherAny = xPropSet->getPropertyValue("ConcentricGradientFillAllowed");
 890         bool bConcentricGradientFillAllowed;
 891         if(anotherAny >>= bConcentricGradientFillAllowed)
 892             dumpConcentricGradientFillAllowedAsAttribute(bConcentricGradientFillAllowed);
 893     }
 894     {
 895         uno::Any anotherAny = xPropSet->getPropertyValue("TextPathAllowed");
 896         bool bTextPathAllowed;
 897         if(anotherAny >>= bTextPathAllowed)
 898             dumpTextPathAllowedAsAttribute(bTextPathAllowed);
 899     }
 900     {
 901         uno::Any anotherAny = xPropSet->getPropertyValue("SubViewSize");
 902         uno::Sequence< awt::Size > aSubViewSize;
 903         if(anotherAny >>= aSubViewSize)
 904             dumpSubViewSizeAsElement(aSubViewSize);
 905     }
 906 }
 907
 908 void EnhancedShapeDumper::dumpCoordinatesAsElement(const uno::Sequence< drawing::EnhancedCustomShapeParameterPair >& aCoordinates)
 909 {
 910     xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Coordinates" ));
 911     sal_Int32 nLength = aCoordinates.getLength();
 912     for (sal_Int32 i = 0; i < nLength; ++i)
 913     {
 914         xmlTextWriterStartElement(xmlWriter, BAD_CAST( "EnhancedCustomShapeParameterPair" ));
 915         dumpEnhancedCustomShapeParameterPair(aCoordinates[i]);
 916         xmlTextWriterEndElement( xmlWriter );
 917     }
 918     xmlTextWriterEndElement( xmlWriter );
 919 }
 920
 921 void EnhancedShapeDumper::dumpSegmentsAsElement(const uno::Sequence< drawing::EnhancedCustomShapeSegment >& aSegments)
 922 {
 923     xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Segments" ));
 924     sal_Int32 nLength = aSegments.getLength();
 925     for (sal_Int32 i = 0; i < nLength; ++i)
 926     {
 927         xmlTextWriterStartElement(xmlWriter, BAD_CAST( "EnhancedCustomShapeSegment" ));
 928         sal_Int32 aCommand = aSegments[i].Command;
 929         sal_Int32 aCount = aSegments[i].Count;
 930         xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("command"), "%" SAL_PRIdINT32, aCommand);
 931         xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("count"), "%" SAL_PRIdINT32, aCount);
 932         xmlTextWriterEndElement( xmlWriter );
 933     }
 934     xmlTextWriterEndElement( xmlWriter );
 935 }
 936
 937 void EnhancedShapeDumper::dumpStretchXAsAttribute(sal_Int32 aStretchX)
 938 {
 939     xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("stretchX"), "%" SAL_PRIdINT32, aStretchX);
 940 }
 941
 942 void EnhancedShapeDumper::dumpStretchYAsAttribute(sal_Int32 aStretchY)
 943 {
 944     xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("stretchY"), "%" SAL_PRIdINT32, aStretchY);
 945 }
 946
 947 void EnhancedShapeDumper::dumpTextFramesAsElement(const uno::Sequence< drawing::EnhancedCustomShapeTextFrame >& aTextFrames)
 948 {
 949     xmlTextWriterStartElement(xmlWriter, BAD_CAST( "TextFrames" ));
 950     sal_Int32 nLength = aTextFrames.getLength();
 951     for (sal_Int32 i = 0; i < nLength; ++i)
 952     {
 953         xmlTextWriterStartElement(xmlWriter, BAD_CAST( "EnhancedCustomShapeTextFrame" ));
 954         {
 955         xmlTextWriterStartElement(xmlWriter, BAD_CAST( "TopLeft" ));
 956         dumpEnhancedCustomShapeParameterPair(aTextFrames[i].TopLeft);
 957         xmlTextWriterEndElement( xmlWriter );
 958
 959         xmlTextWriterStartElement(xmlWriter, BAD_CAST( "BottomRight" ));
 960         dumpEnhancedCustomShapeParameterPair(aTextFrames[i].BottomRight);
 961         xmlTextWriterEndElement( xmlWriter );
 962         }
 963         xmlTextWriterEndElement( xmlWriter );
 964     }
 965     xmlTextWriterEndElement( xmlWriter );
 966 }
 967
 968 void EnhancedShapeDumper::dumpGluePointsAsElement(const uno::Sequence< drawing::EnhancedCustomShapeParameterPair >& aGluePoints)
 969 {
 970     xmlTextWriterStartElement(xmlWriter, BAD_CAST( "GluePoints" ));
 971     sal_Int32 nLength = aGluePoints.getLength();
 972     for (sal_Int32 i = 0; i < nLength; ++i)
 973     {
 974         xmlTextWriterStartElement(xmlWriter, BAD_CAST( "EnhancedCustomShapeParameterPair" ));
 975         dumpEnhancedCustomShapeParameterPair(aGluePoints[i]);
 976         xmlTextWriterEndElement( xmlWriter );
 977     }
 978     xmlTextWriterEndElement( xmlWriter );
 979 }
 980
 981 void EnhancedShapeDumper::dumpGluePointLeavingDirectionsAsElement(const uno::Sequence< double >& aGluePointLeavingDirections)
 982 {
 983     xmlTextWriterStartElement(xmlWriter, BAD_CAST( "GluePointLeavingDirections" ));
 984     sal_Int32 nLength = aGluePointLeavingDirections.getLength();
 985     for (sal_Int32 i = 0; i < nLength; ++i)
 986     {
 987         xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("value"), "%f", aGluePointLeavingDirections[i]);
 988     }
 989     xmlTextWriterEndElement( xmlWriter );
 990 }
 991
 992 void EnhancedShapeDumper::dumpGluePointTypeAsAttribute(sal_Int32 aGluePointType)
 993 {
 994     xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("gluePointType"), "%" SAL_PRIdINT32, aGluePointType);
 995 }
 996
 997 void EnhancedShapeDumper::dumpExtrusionAllowedAsAttribute(bool bExtrusionAllowed)
 998 {
 999     if(bExtrusionAllowed)
1000         xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("extrusionAllowed"), "%s", "true");
1001     else
1002         xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("extrusionAllowed"), "%s", "false");
1003 }
1004
1005 void EnhancedShapeDumper::dumpConcentricGradientFillAllowedAsAttribute(bool bConcentricGradientFillAllowed)
1006 {
1007     if(bConcentricGradientFillAllowed)
1008         xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("concentricGradientFillAllowed"), "%s", "true");
1009     else
1010         xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("concentricGradientFillAllowed"), "%s", "false");
1011 }
1012
1013 void EnhancedShapeDumper::dumpTextPathAllowedAsAttribute(bool bTextPathAllowed)
1014 {
1015     if(bTextPathAllowed)
1016         xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textPathAllowed"), "%s", "true");
1017     else
1018         xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textPathAllowed"), "%s", "false");
1019 }
1020
1021 void EnhancedShapeDumper::dumpSubViewSizeAsElement(const uno::Sequence< awt::Size >& aSubViewSize)
1022 {
1023     xmlTextWriterStartElement(xmlWriter, BAD_CAST( "SubViewSize" ));
1024     sal_Int32 nLength = aSubViewSize.getLength();
1025     for (sal_Int32 i = 0; i < nLength; ++i)
1026     {
1027         xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Size" ));
1028         xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("width"), "%" SAL_PRIdINT32, aSubViewSize[i].Width);
1029         xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("height"), "%" SAL_PRIdINT32, aSubViewSize[i].Height);
1030         xmlTextWriterEndElement( xmlWriter );
1031     }
1032     xmlTextWriterEndElement( xmlWriter );
1033 }
1034
1035
1036 // ---------- EnhancedCustomShapeTextPath.idl ---------------
1037
1038
1039 void EnhancedShapeDumper::dumpEnhancedCustomShapeTextPathService(const uno::Reference< beans::XPropertySet >& xPropSet)
1040 {
1041     {
1042         uno::Any anotherAny = xPropSet->getPropertyValue("TextPath");
1043         bool bTextPath;
1044         if(anotherAny >>= bTextPath)
1045             dumpTextPathAsAttribute(bTextPath);
1046     }
1047     {
1048         uno::Any anotherAny = xPropSet->getPropertyValue("TextPathMode");
1049         drawing::EnhancedCustomShapeTextPathMode eTextPathMode;
1050         if(anotherAny >>= eTextPathMode)
1051             dumpTextPathModeAsAttribute(eTextPathMode);
1052     }
1053     {
1054         uno::Any anotherAny = xPropSet->getPropertyValue("ScaleX");
1055         bool bScaleX;
1056         if(anotherAny >>= bScaleX)
1057             dumpScaleXAsAttribute(bScaleX);
1058     }
1059 }
1060
1061 void EnhancedShapeDumper::dumpTextPathAsAttribute(bool bTextPath)
1062 {
1063     if(bTextPath)
1064         xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textPath"), "%s", "true");
1065     else
1066         xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textPath"), "%s", "false");
1067 }
1068
1069 void EnhancedShapeDumper::dumpTextPathModeAsAttribute(drawing::EnhancedCustomShapeTextPathMode eTextPathMode)
1070 {
1071     switch(eTextPathMode)
1072     {
1073         case drawing::EnhancedCustomShapeTextPathMode_NORMAL:
1074             xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textPathMode"), "%s", "NORMAL");
1075             break;
1076         case drawing::EnhancedCustomShapeTextPathMode_PATH:
1077             xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textPathMode"), "%s", "PATH");
1078             break;
1079         case drawing::EnhancedCustomShapeTextPathMode_SHAPE:
1080             xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textPathMode"), "%s", "SHAPE");
1081             break;
1082         default:
1083             break;
1084     }
1085 }
1086
1087 void EnhancedShapeDumper::dumpScaleXAsAttribute(bool bScaleX)
1088 {
1089     if(bScaleX)
1090         xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("scaleX"), "%s", "true");
1091     else
1092         xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("scaleX"), "%s", "false");
1093 }
1094
1095 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */