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