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