svx/source/unodraw/XPropertyTable.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  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include "svx/XPropertyTable.hxx"
  22 #include <com/sun/star/drawing/PolyPolygonBezierCoords.hpp>
  23 #include <com/sun/star/drawing/LineDash.hpp>
  24 #include <com/sun/star/awt/Gradient.hpp>
  25 #include <com/sun/star/drawing/Hatch.hpp>
  26 #include <com/sun/star/lang/XServiceInfo.hpp>
  27 #include <com/sun/star/container/XNameContainer.hpp>
  28 #include <osl/mutex.hxx>
  29 #include <vcl/svapp.hxx>
  30
  31 #include <cppuhelper/implbase2.hxx>
  32 #include <cppuhelper/supportsservice.hxx>
  33 #include <svx/xdef.hxx>
  34
  35 #include "svx/unoapi.hxx"
  36 #include <editeng/unoprnms.hxx>
  37 #include <basegfx/polygon/b2dpolygon.hxx>
  38 #include <basegfx/tools/unotools.hxx>
  39
  40 using namespace com::sun::star;
  41 using namespace ::cppu;
  42
  43 class SvxUnoXPropertyTable : public WeakImplHelper2< container::XNameContainer, lang::XServiceInfo >
  44 {
  45 private:
  46     XPropertyList*  mpList;
  47     sal_Int16 mnWhich;
  48
  49     long getCount() const { return mpList ? mpList->Count() : 0; }
  50     XPropertyEntry* get( long index ) const;
  51 public:
  52     SvxUnoXPropertyTable( sal_Int16 nWhich, XPropertyList* pList ) throw();
  53
  54     virtual ~SvxUnoXPropertyTable() throw();
  55
  56     virtual uno::Any getAny( const XPropertyEntry* pEntry ) const throw(uno::RuntimeException) = 0;
  57     virtual XPropertyEntry* getEntry( const OUString& rName, const uno::Any& rAny ) const throw(uno::RuntimeException, lang::IllegalArgumentException) = 0;
  58
  59     // XServiceInfo
  60     virtual sal_Bool SAL_CALL supportsService( const  OUString& ServiceName ) throw( uno::RuntimeException, std::exception) SAL_OVERRIDE;
  61
  62     // XNameContainer
  63     virtual void SAL_CALL insertByName( const  OUString& aName, const  uno::Any& aElement ) throw( lang::IllegalArgumentException, container::ElementExistException, lang::WrappedTargetException, uno::RuntimeException, std::exception) SAL_OVERRIDE;
  64     virtual void SAL_CALL removeByName( const  OUString& Name ) throw( container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException, std::exception) SAL_OVERRIDE;
  65
  66     // XNameReplace
  67     virtual void SAL_CALL replaceByName( const  OUString& aName, const  uno::Any& aElement ) throw( lang::IllegalArgumentException, container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException, std::exception) SAL_OVERRIDE;
  68
  69     // XNameAccess
  70     virtual uno::Any SAL_CALL getByName( const  OUString& aName ) throw( container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException, std::exception) SAL_OVERRIDE;
  71     virtual uno::Sequence<  OUString > SAL_CALL getElementNames(  ) throw( uno::RuntimeException, std::exception) SAL_OVERRIDE;
  72     virtual sal_Bool SAL_CALL hasByName( const  OUString& aName ) throw( uno::RuntimeException, std::exception) SAL_OVERRIDE;
  73
  74     // XElementAccess
  75     virtual sal_Bool SAL_CALL hasElements(  ) throw( uno::RuntimeException, std::exception) SAL_OVERRIDE;
  76 };
  77
  78 SvxUnoXPropertyTable::SvxUnoXPropertyTable( sal_Int16 nWhich, XPropertyList* pList ) throw()
  79 : mpList( pList ), mnWhich( nWhich )
  80 {
  81 }
  82
  83 SvxUnoXPropertyTable::~SvxUnoXPropertyTable() throw()
  84 {
  85 }
  86
  87 XPropertyEntry* SvxUnoXPropertyTable::get( long index ) const
  88 {
  89     if( mpList )
  90         return mpList->Get(index);
  91     else
  92         return NULL;
  93 }
  94
  95 // XServiceInfo
  96 sal_Bool SAL_CALL SvxUnoXPropertyTable::supportsService( const  OUString& ServiceName )
  97     throw( uno::RuntimeException, std::exception)
  98 {
  99     return cppu::supportsService(this, ServiceName);
 100 }
 101
 102 // XNameContainer
 103 void SAL_CALL SvxUnoXPropertyTable::insertByName( const  OUString& aName, const  uno::Any& aElement )
 104     throw( lang::IllegalArgumentException, container::ElementExistException, lang::WrappedTargetException, uno::RuntimeException, std::exception)
 105 {
 106     SolarMutexGuard aGuard;
 107
 108     if( NULL == mpList )
 109         throw lang::IllegalArgumentException();
 110
 111     if( hasByName( aName ) )
 112         throw container::ElementExistException();
 113
 114     OUString aInternalName = SvxUnogetInternalNameForItem(mnWhich, aName);
 115
 116     XPropertyEntry* pNewEntry = getEntry( aInternalName, aElement );
 117     if( NULL == pNewEntry )
 118         throw lang::IllegalArgumentException();
 119
 120     if( mpList )
 121         mpList->Insert( pNewEntry );
 122 }
 123
 124 void SAL_CALL SvxUnoXPropertyTable::removeByName( const  OUString& Name )
 125     throw( container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException, std::exception)
 126 {
 127     SolarMutexGuard aGuard;
 128
 129     OUString aInternalName = SvxUnogetInternalNameForItem(mnWhich, Name);
 130
 131     const long nCount = getCount();
 132     long i;
 133     for( i = 0; i < nCount; i++ )
 134     {
 135         XPropertyEntry* pEntry = get( i );
 136         if (pEntry && aInternalName.equals(pEntry->GetName()))
 137         {
 138             if( mpList )
 139                 delete mpList->Remove( i );
 140             return;
 141         }
 142     }
 143
 144     throw container::NoSuchElementException();
 145 }
 146
 147 // XNameReplace
 148 void SAL_CALL SvxUnoXPropertyTable::replaceByName( const  OUString& aName, const  uno::Any& aElement )
 149     throw( lang::IllegalArgumentException, container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException, std::exception)
 150 {
 151     SolarMutexGuard aGuard;
 152
 153     OUString aInternalName = SvxUnogetInternalNameForItem(mnWhich, aName);
 154
 155     const long nCount = getCount();
 156     long i;
 157     for( i = 0; i < nCount; i++ )
 158     {
 159         XPropertyEntry* pEntry = get( i );
 160         if (pEntry && aInternalName.equals(pEntry->GetName()))
 161         {
 162             XPropertyEntry* pNewEntry = getEntry( aInternalName, aElement );
 163             if( NULL == pNewEntry )
 164                 throw lang::IllegalArgumentException();
 165
 166             if( mpList )
 167                 delete mpList->Replace( pNewEntry, i );
 168             return;
 169         }
 170     }
 171
 172     throw container::NoSuchElementException();
 173 }
 174
 175 // XNameAccess
 176 uno::Any SAL_CALL SvxUnoXPropertyTable::getByName( const  OUString& aName )
 177     throw( container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException, std::exception)
 178 {
 179     SolarMutexGuard aGuard;
 180
 181     OUString aInternalName = SvxUnogetInternalNameForItem(mnWhich, aName);
 182
 183     const long nCount = getCount();
 184     long i;
 185     for( i = 0; i < nCount; i++ )
 186     {
 187         XPropertyEntry* pEntry = get( i );
 188
 189         if (pEntry && aInternalName.equals(pEntry->GetName()))
 190             return getAny( pEntry );
 191     }
 192
 193     throw container::NoSuchElementException();
 194 }
 195
 196 uno::Sequence<  OUString > SAL_CALL SvxUnoXPropertyTable::getElementNames()
 197     throw( uno::RuntimeException, std::exception)
 198 {
 199     SolarMutexGuard aGuard;
 200
 201     const long nCount = getCount();
 202     uno::Sequence< OUString > aNames( nCount );
 203     OUString* pNames = aNames.getArray();
 204     long i;
 205     for( i = 0; i < nCount; i++ )
 206     {
 207         XPropertyEntry* pEntry = get( i );
 208
 209         if (pEntry)
 210             *pNames++ = SvxUnogetApiNameForItem(mnWhich, pEntry->GetName());
 211     }
 212
 213     return aNames;
 214 }
 215
 216 sal_Bool SAL_CALL SvxUnoXPropertyTable::hasByName( const  OUString& aName )
 217     throw( uno::RuntimeException, std::exception)
 218 {
 219     SolarMutexGuard aGuard;
 220
 221     OUString aInternalName = SvxUnogetInternalNameForItem(mnWhich, aName);
 222
 223     const long nCount = mpList?mpList->Count():0;
 224     long i;
 225     for( i = 0; i < nCount; i++ )
 226     {
 227         XPropertyEntry* pEntry = get( i );
 228         if (pEntry && aInternalName.equals(pEntry->GetName()))
 229             return sal_True;
 230     }
 231
 232     return sal_False;
 233 }
 234
 235 // XElementAccess
 236 sal_Bool SAL_CALL SvxUnoXPropertyTable::hasElements(  )
 237     throw( uno::RuntimeException, std::exception)
 238 {
 239     SolarMutexGuard aGuard;
 240
 241     return getCount() != 0;
 242 }
 243
 244
 245
 246 class SvxUnoXColorTable : public SvxUnoXPropertyTable
 247 {
 248 public:
 249     SvxUnoXColorTable( XPropertyList* pList ) throw() : SvxUnoXPropertyTable( XATTR_LINECOLOR, pList ) {};
 250
 251     // SvxUnoXPropertyTable
 252     virtual uno::Any getAny( const XPropertyEntry* pEntry ) const throw() SAL_OVERRIDE;
 253     virtual XPropertyEntry* getEntry( const OUString& rName, const uno::Any& rAny ) const throw() SAL_OVERRIDE;
 254
 255     // XElementAccess
 256     virtual uno::Type SAL_CALL getElementType() throw( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
 257
 258     // XServiceInfo
 259     virtual OUString SAL_CALL getImplementationName(  ) throw( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
 260     virtual uno::Sequence<  OUString > SAL_CALL getSupportedServiceNames(  ) throw( uno::RuntimeException, std::exception) SAL_OVERRIDE;
 261 };
 262
 263 uno::Reference< uno::XInterface > SAL_CALL SvxUnoXColorTable_createInstance( XPropertyList* pList ) throw()
 264 {
 265     return (OWeakObject*) new SvxUnoXColorTable( pList );
 266 }
 267
 268 // SvxUnoXPropertyTable
 269 uno::Any SvxUnoXColorTable::getAny( const XPropertyEntry* pEntry ) const throw()
 270 {
 271     uno::Any aAny;
 272     aAny <<= (sal_Int32)static_cast<const XColorEntry*>(pEntry)->GetColor().GetColor();
 273     return aAny;
 274 }
 275
 276 XPropertyEntry* SvxUnoXColorTable::getEntry( const OUString& rName, const uno::Any& rAny ) const throw()
 277 {
 278     sal_Int32 nColor = 0;
 279     if( !(rAny >>= nColor) )
 280         return NULL;
 281
 282     const Color aColor( (ColorData)nColor );
 283     return new XColorEntry( aColor, rName );
 284 }
 285
 286 // XElementAccess
 287 uno::Type SAL_CALL SvxUnoXColorTable::getElementType()
 288     throw( uno::RuntimeException, std::exception )
 289 {
 290     return ::cppu::UnoType<sal_Int32>::get();
 291 }
 292
 293 // XServiceInfo
 294 OUString SAL_CALL SvxUnoXColorTable::getImplementationName(  ) throw( uno::RuntimeException, std::exception )
 295 {
 296     return OUString( "SvxUnoXColorTable" );
 297 }
 298
 299 uno::Sequence<  OUString > SAL_CALL SvxUnoXColorTable::getSupportedServiceNames(  ) throw( uno::RuntimeException, std::exception)
 300 {
 301     const OUString aServiceName( "com.sun.star.drawing.ColorTable" );
 302     uno::Sequence< OUString > aServices( &aServiceName, 1 );
 303     return aServices;
 304 }
 305
 306
 307
 308 class SvxUnoXLineEndTable : public SvxUnoXPropertyTable
 309 {
 310 public:
 311     SvxUnoXLineEndTable( XPropertyList* pTable ) throw() : SvxUnoXPropertyTable( XATTR_LINEEND, pTable ) {};
 312
 313     // SvxUnoXPropertyTable
 314     virtual uno::Any getAny( const XPropertyEntry* pEntry ) const throw() SAL_OVERRIDE;
 315     virtual XPropertyEntry* getEntry( const OUString& rName, const uno::Any& rAny ) const throw(lang::IllegalArgumentException) SAL_OVERRIDE;
 316
 317     // XElementAccess
 318     virtual uno::Type SAL_CALL getElementType() throw( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
 319
 320     // XServiceInfo
 321     virtual OUString SAL_CALL getImplementationName(  ) throw( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
 322     virtual uno::Sequence<  OUString > SAL_CALL getSupportedServiceNames(  ) throw( uno::RuntimeException, std::exception) SAL_OVERRIDE;
 323 };
 324
 325 uno::Reference< uno::XInterface > SAL_CALL SvxUnoXLineEndTable_createInstance( XPropertyList* pTable ) throw()
 326 {
 327     return (OWeakObject*)new SvxUnoXLineEndTable( pTable );
 328 }
 329
 330 // SvxUnoXPropertyTable
 331 uno::Any SvxUnoXLineEndTable::getAny( const XPropertyEntry* pEntry ) const throw()
 332 {
 333
 334     uno::Any aAny;
 335     drawing::PolyPolygonBezierCoords aBezier;
 336     basegfx::unotools::b2DPolyPolygonToPolyPolygonBezier( static_cast<const XLineEndEntry*>(pEntry)->GetLineEnd(),
 337                                                           aBezier );
 338     aAny <<= aBezier;
 339     return aAny;
 340 }
 341
 342 XPropertyEntry* SvxUnoXLineEndTable::getEntry( const OUString& rName, const uno::Any& rAny ) const throw(lang::IllegalArgumentException)
 343 {
 344
 345     if( !rAny.getValue() || rAny.getValueType() != cppu::UnoType<drawing::PolyPolygonBezierCoords>::get())
 346         return NULL;
 347
 348     basegfx::B2DPolyPolygon aPolyPolygon;
 349     drawing::PolyPolygonBezierCoords const * pCoords = static_cast<drawing::PolyPolygonBezierCoords const *>(rAny.getValue());
 350     if( pCoords->Coordinates.getLength() > 0 )
 351         aPolyPolygon = basegfx::unotools::polyPolygonBezierToB2DPolyPolygon( *pCoords );
 352
 353     // #86265# make sure polygon is closed
 354     aPolyPolygon.setClosed(true);
 355
 356     return new XLineEndEntry( aPolyPolygon, rName );
 357 }
 358
 359 // XElementAccess
 360 uno::Type SAL_CALL SvxUnoXLineEndTable::getElementType()
 361     throw( uno::RuntimeException, std::exception )
 362 {
 363     return cppu::UnoType<drawing::PolyPolygonBezierCoords>::get();
 364 }
 365
 366 // XServiceInfo
 367 OUString SAL_CALL SvxUnoXLineEndTable::getImplementationName(  ) throw( uno::RuntimeException, std::exception )
 368 {
 369     return OUString( "SvxUnoXLineEndTable" );
 370 }
 371
 372 uno::Sequence<  OUString > SAL_CALL SvxUnoXLineEndTable::getSupportedServiceNames(  ) throw( uno::RuntimeException, std::exception)
 373 {
 374     const OUString aServiceName( "com.sun.star.drawing.LineEndTable" );
 375     uno::Sequence< OUString > aServices( &aServiceName, 1 );
 376     return aServices;
 377 }
 378
 379
 380
 381 class SvxUnoXDashTable : public SvxUnoXPropertyTable
 382 {
 383 public:
 384     SvxUnoXDashTable( XPropertyList* pTable ) throw() : SvxUnoXPropertyTable( XATTR_LINEDASH, pTable ) {};
 385
 386     // SvxUnoXPropertyTable
 387     virtual uno::Any getAny( const XPropertyEntry* pEntry ) const throw() SAL_OVERRIDE;
 388     virtual XPropertyEntry* getEntry( const OUString& rName, const uno::Any& rAny ) const throw() SAL_OVERRIDE;
 389
 390     // XElementAccess
 391     virtual uno::Type SAL_CALL getElementType() throw( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
 392
 393     // XServiceInfo
 394     virtual OUString SAL_CALL getImplementationName(  ) throw( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
 395     virtual uno::Sequence<  OUString > SAL_CALL getSupportedServiceNames(  ) throw( uno::RuntimeException, std::exception) SAL_OVERRIDE;
 396 };
 397
 398 uno::Reference< uno::XInterface > SAL_CALL SvxUnoXDashTable_createInstance( XPropertyList* pTable ) throw()
 399 {
 400     return (OWeakObject*)new SvxUnoXDashTable( pTable );
 401 }
 402
 403 // SvxUnoXPropertyTable
 404 uno::Any SvxUnoXDashTable::getAny( const XPropertyEntry* pEntry ) const throw()
 405 {
 406     const XDash& rXD = static_cast<const XDashEntry*>(pEntry)->GetDash();
 407
 408     drawing::LineDash aLineDash;
 409
 410     aLineDash.Style = (::com::sun::star::drawing::DashStyle)((sal_uInt16)rXD.GetDashStyle());
 411     aLineDash.Dots = rXD.GetDots();
 412     aLineDash.DotLen = rXD.GetDotLen();
 413     aLineDash.Dashes = rXD.GetDashes();
 414     aLineDash.DashLen = rXD.GetDashLen();
 415     aLineDash.Distance = rXD.GetDistance();
 416
 417     uno::Any aAny;
 418     aAny <<= aLineDash;
 419     return aAny;
 420 }
 421
 422 XPropertyEntry* SvxUnoXDashTable::getEntry( const OUString& rName, const uno::Any& rAny ) const throw()
 423 {
 424     drawing::LineDash aLineDash;
 425     if(!(rAny >>= aLineDash))
 426         return NULL;
 427
 428     XDash aXDash;
 429
 430     aXDash.SetDashStyle((css::drawing::DashStyle)((sal_uInt16)(aLineDash.Style)));
 431     aXDash.SetDots(aLineDash.Dots);
 432     aXDash.SetDotLen(aLineDash.DotLen);
 433     aXDash.SetDashes(aLineDash.Dashes);
 434     aXDash.SetDashLen(aLineDash.DashLen);
 435     aXDash.SetDistance(aLineDash.Distance);
 436
 437     return new XDashEntry( aXDash, rName );
 438 }
 439
 440 // XElementAccess
 441 uno::Type SAL_CALL SvxUnoXDashTable::getElementType()
 442     throw( uno::RuntimeException, std::exception )
 443 {
 444     return cppu::UnoType<drawing::LineDash>::get();
 445 }
 446
 447 // XServiceInfo
 448 OUString SAL_CALL SvxUnoXDashTable::getImplementationName(  ) throw( uno::RuntimeException, std::exception )
 449 {
 450     return OUString( "SvxUnoXDashTable" );
 451 }
 452
 453 uno::Sequence<  OUString > SAL_CALL SvxUnoXDashTable::getSupportedServiceNames(  ) throw( uno::RuntimeException, std::exception)
 454 {
 455     const OUString aServiceName( "com.sun.star.drawing.DashTable" );
 456     uno::Sequence< OUString > aServices( &aServiceName, 1 );
 457     return aServices;
 458 }
 459
 460
 461
 462 class SvxUnoXHatchTable : public SvxUnoXPropertyTable
 463 {
 464 public:
 465     SvxUnoXHatchTable( XPropertyList* pTable ) throw() : SvxUnoXPropertyTable( XATTR_FILLHATCH, pTable ) {};
 466
 467     // SvxUnoXPropertyTable
 468     virtual uno::Any getAny( const XPropertyEntry* pEntry ) const throw() SAL_OVERRIDE;
 469     virtual XPropertyEntry* getEntry( const OUString& rName, const uno::Any& rAny ) const throw() SAL_OVERRIDE;
 470
 471     // XElementAccess
 472     virtual uno::Type SAL_CALL getElementType() throw( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
 473
 474     // XServiceInfo
 475     virtual OUString SAL_CALL getImplementationName(  ) throw( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
 476     virtual uno::Sequence<  OUString > SAL_CALL getSupportedServiceNames(  ) throw( uno::RuntimeException, std::exception) SAL_OVERRIDE;
 477 };
 478
 479 uno::Reference< uno::XInterface > SAL_CALL SvxUnoXHatchTable_createInstance( XPropertyList* pTable ) throw()
 480 {
 481     return (OWeakObject*)new SvxUnoXHatchTable( pTable );
 482 }
 483
 484 // SvxUnoXPropertyTable
 485 uno::Any SvxUnoXHatchTable::getAny( const XPropertyEntry* pEntry ) const throw()
 486 {
 487     const XHatch& aHatch = static_cast<const XHatchEntry*>(pEntry)->GetHatch();
 488
 489     drawing::Hatch aUnoHatch;
 490
 491     aUnoHatch.Style = (drawing::HatchStyle)aHatch.GetHatchStyle();
 492     aUnoHatch.Color = aHatch.GetColor().GetColor();
 493     aUnoHatch.Distance = aHatch.GetDistance();
 494     aUnoHatch.Angle = aHatch.GetAngle();
 495
 496     uno::Any aAny;
 497     aAny <<= aUnoHatch;
 498     return aAny;
 499 }
 500
 501 XPropertyEntry* SvxUnoXHatchTable::getEntry( const OUString& rName, const uno::Any& rAny ) const throw()
 502 {
 503     drawing::Hatch aUnoHatch;
 504     if(!(rAny >>= aUnoHatch))
 505         return NULL;
 506
 507     XHatch aXHatch;
 508     aXHatch.SetHatchStyle( (css::drawing::HatchStyle)aUnoHatch.Style );
 509     aXHatch.SetColor( aUnoHatch.Color );
 510     aXHatch.SetDistance( aUnoHatch.Distance );
 511     aXHatch.SetAngle( aUnoHatch.Angle );
 512
 513     return new XHatchEntry( aXHatch, rName );
 514 }
 515
 516 // XElementAccess
 517 uno::Type SAL_CALL SvxUnoXHatchTable::getElementType()
 518     throw( uno::RuntimeException, std::exception )
 519 {
 520     return cppu::UnoType<drawing::Hatch>::get();
 521 }
 522
 523 // XServiceInfo
 524 OUString SAL_CALL SvxUnoXHatchTable::getImplementationName(  ) throw( uno::RuntimeException, std::exception )
 525 {
 526     return OUString( "SvxUnoXHatchTable" );
 527 }
 528
 529 uno::Sequence<  OUString > SAL_CALL SvxUnoXHatchTable::getSupportedServiceNames(  ) throw( uno::RuntimeException, std::exception)
 530 {
 531     const OUString aServiceName( "com.sun.star.drawing.HatchTable" );
 532     uno::Sequence< OUString > aServices( &aServiceName, 1 );
 533     return aServices;
 534 }
 535
 536
 537
 538 class SvxUnoXGradientTable : public SvxUnoXPropertyTable
 539 {
 540 public:
 541     SvxUnoXGradientTable( XPropertyList* pTable ) throw() : SvxUnoXPropertyTable( XATTR_FILLGRADIENT, pTable ) {};
 542
 543     // SvxUnoXPropertyTable
 544     virtual uno::Any getAny( const XPropertyEntry* pEntry ) const throw() SAL_OVERRIDE;
 545     virtual XPropertyEntry* getEntry( const OUString& rName, const uno::Any& rAny ) const throw() SAL_OVERRIDE;
 546
 547     // XElementAccess
 548     virtual uno::Type SAL_CALL getElementType() throw( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
 549
 550     // XServiceInfo
 551     virtual OUString SAL_CALL getImplementationName(  ) throw( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
 552     virtual uno::Sequence<  OUString > SAL_CALL getSupportedServiceNames(  ) throw( uno::RuntimeException, std::exception) SAL_OVERRIDE;
 553 };
 554
 555 uno::Reference< uno::XInterface > SAL_CALL SvxUnoXGradientTable_createInstance( XPropertyList* pTable ) throw()
 556 {
 557     return (OWeakObject*)new SvxUnoXGradientTable( pTable );
 558 }
 559
 560 // SvxUnoXPropertyTable
 561 uno::Any SvxUnoXGradientTable::getAny( const XPropertyEntry* pEntry ) const throw()
 562 {
 563     const XGradient& aXGradient = static_cast<const XGradientEntry*>(pEntry)->GetGradient();
 564     awt::Gradient aGradient;
 565
 566     aGradient.Style = (awt::GradientStyle) aXGradient.GetGradientStyle();
 567     aGradient.StartColor = (sal_Int32)aXGradient.GetStartColor().GetColor();
 568     aGradient.EndColor = (sal_Int32)aXGradient.GetEndColor().GetColor();
 569     aGradient.Angle = (short)aXGradient.GetAngle();
 570     aGradient.Border = aXGradient.GetBorder();
 571     aGradient.XOffset = aXGradient.GetXOffset();
 572     aGradient.YOffset = aXGradient.GetYOffset();
 573     aGradient.StartIntensity = aXGradient.GetStartIntens();
 574     aGradient.EndIntensity = aXGradient.GetEndIntens();
 575     aGradient.StepCount = aXGradient.GetSteps();
 576
 577     uno::Any aAny;
 578     aAny <<= aGradient;
 579     return aAny;
 580 }
 581
 582 XPropertyEntry* SvxUnoXGradientTable::getEntry( const OUString& rName, const uno::Any& rAny ) const throw()
 583 {
 584     awt::Gradient aGradient;
 585     if(!(rAny >>= aGradient))
 586         return NULL;
 587
 588     XGradient aXGradient;
 589
 590     aXGradient.SetGradientStyle( (css::awt::GradientStyle) aGradient.Style );
 591     aXGradient.SetStartColor( aGradient.StartColor );
 592     aXGradient.SetEndColor( aGradient.EndColor );
 593     aXGradient.SetAngle( aGradient.Angle );
 594     aXGradient.SetBorder( aGradient.Border );
 595     aXGradient.SetXOffset( aGradient.XOffset );
 596     aXGradient.SetYOffset( aGradient.YOffset );
 597     aXGradient.SetStartIntens( aGradient.StartIntensity );
 598     aXGradient.SetEndIntens( aGradient.EndIntensity );
 599     aXGradient.SetSteps( aGradient.StepCount );
 600
 601     return new XGradientEntry( aXGradient, rName );
 602 }
 603
 604 // XElementAccess
 605 uno::Type SAL_CALL SvxUnoXGradientTable::getElementType()
 606     throw( uno::RuntimeException, std::exception )
 607 {
 608     return cppu::UnoType<awt::Gradient>::get();
 609 }
 610
 611 // XServiceInfo
 612 OUString SAL_CALL SvxUnoXGradientTable::getImplementationName(  ) throw( uno::RuntimeException, std::exception )
 613 {
 614     return OUString( "SvxUnoXGradientTable" );
 615 }
 616
 617 uno::Sequence<  OUString > SAL_CALL SvxUnoXGradientTable::getSupportedServiceNames(  ) throw( uno::RuntimeException, std::exception)
 618 {
 619     const OUString aServiceName( "com.sun.star.drawing.GradientTable" );
 620     uno::Sequence< OUString > aServices( &aServiceName, 1 );
 621     return aServices;
 622 }
 623
 624
 625
 626 class SvxUnoXBitmapTable : public SvxUnoXPropertyTable
 627 {
 628 public:
 629     SvxUnoXBitmapTable( XPropertyList* pTable ) throw() : SvxUnoXPropertyTable( XATTR_FILLBITMAP, pTable ) {};
 630
 631     // SvxUnoXPropertyTable
 632     virtual uno::Any getAny( const XPropertyEntry* pEntry ) const throw(uno::RuntimeException) SAL_OVERRIDE;
 633     virtual XPropertyEntry* getEntry( const OUString& rName, const uno::Any& rAny ) const throw(uno::RuntimeException) SAL_OVERRIDE;
 634
 635     // XElementAccess
 636     virtual uno::Type SAL_CALL getElementType() throw( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
 637
 638     // XServiceInfo
 639     virtual OUString SAL_CALL getImplementationName(  ) throw( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
 640     virtual uno::Sequence<  OUString > SAL_CALL getSupportedServiceNames(  ) throw( uno::RuntimeException, std::exception) SAL_OVERRIDE;
 641 };
 642
 643 uno::Reference< uno::XInterface > SAL_CALL SvxUnoXBitmapTable_createInstance( XPropertyList* pTable ) throw()
 644 {
 645     return (OWeakObject*)new SvxUnoXBitmapTable( pTable );
 646 }
 647
 648 // SvxUnoXPropertyTable
 649 uno::Any SvxUnoXBitmapTable::getAny( const XPropertyEntry* pEntry ) const throw(uno::RuntimeException)
 650 {
 651     OUString aURL( UNO_NAME_GRAPHOBJ_URLPREFIX);
 652     const GraphicObject& rGraphicObject(static_cast<const XBitmapEntry*>(pEntry)->GetGraphicObject());
 653     aURL += OStringToOUString(rGraphicObject.GetUniqueID(), RTL_TEXTENCODING_ASCII_US);
 654
 655     uno::Any aAny;
 656     aAny <<= aURL;
 657     return aAny;
 658 }
 659
 660 XPropertyEntry* SvxUnoXBitmapTable::getEntry( const OUString& rName, const uno::Any& rAny ) const throw(uno::RuntimeException)
 661 {
 662     OUString aURL;
 663     if(!(rAny >>= aURL))
 664         return NULL;
 665
 666     const GraphicObject aGrafObj(GraphicObject::CreateGraphicObjectFromURL(aURL));
 667
 668     return new XBitmapEntry(aGrafObj, rName);
 669 }
 670
 671 // XElementAccess
 672 uno::Type SAL_CALL SvxUnoXBitmapTable::getElementType()
 673     throw( uno::RuntimeException, std::exception )
 674 {
 675     return ::cppu::UnoType<OUString>::get();
 676 }
 677
 678 // XServiceInfo
 679 OUString SAL_CALL SvxUnoXBitmapTable::getImplementationName(  ) throw( uno::RuntimeException, std::exception )
 680 {
 681     return OUString( "SvxUnoXBitmapTable" );
 682 }
 683
 684 uno::Sequence<  OUString > SAL_CALL SvxUnoXBitmapTable::getSupportedServiceNames(  ) throw( uno::RuntimeException, std::exception)
 685 {
 686     const OUString aServiceName( "com.sun.star.drawing.BitmapTable" );
 687     uno::Sequence< OUString > aServices( &aServiceName, 1 );
 688     return aServices;
 689 }
 690
 691 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */