svx/source/items/drawitem.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: drawitem.cxx,v $
  10  * $Revision: 1.11 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_svx.hxx"
  33
  34 // include ---------------------------------------------------------------
  35
  36 #include <svx/svxids.hrc>
  37
  38
  39 #include "drawitem.hxx"
  40 #include <svx/xtable.hxx>
  41
  42 using namespace ::com::sun::star;
  43
  44 // -----------------------------------------------------------------------
  45
  46 TYPEINIT1_FACTORY( SvxColorTableItem, SfxPoolItem , new  SvxColorTableItem);
  47 TYPEINIT1_FACTORY( SvxGradientListItem, SfxPoolItem , new  SvxGradientListItem);
  48 TYPEINIT1_FACTORY( SvxHatchListItem, SfxPoolItem , new  SvxHatchListItem);
  49 TYPEINIT1_FACTORY( SvxBitmapListItem, SfxPoolItem , new  SvxBitmapListItem);
  50 TYPEINIT1_FACTORY( SvxDashListItem, SfxPoolItem , new  SvxDashListItem);
  51 TYPEINIT1_FACTORY( SvxLineEndListItem, SfxPoolItem , new  SvxLineEndListItem);
  52
  53 //==================================================================
  54 //
  55 //      SvxColorTableItem
  56 //
  57 //==================================================================
  58
  59 SvxColorTableItem::SvxColorTableItem()
  60 {
  61 }
  62
  63 // -----------------------------------------------------------------------
  64
  65 SvxColorTableItem::SvxColorTableItem( XColorTable* pTable, sal_uInt16 nW ) :
  66     SfxPoolItem( nW ),
  67     pColorTable( pTable )
  68 {
  69 }
  70
  71 // -----------------------------------------------------------------------
  72
  73 SvxColorTableItem::SvxColorTableItem( const SvxColorTableItem& rItem ) :
  74     SfxPoolItem( rItem ),
  75     pColorTable( rItem.pColorTable )
  76 {
  77 }
  78
  79 //------------------------------------------------------------------------
  80
  81 SfxItemPresentation SvxColorTableItem::GetPresentation
  82 (
  83     SfxItemPresentation /*ePres*/,
  84     SfxMapUnit          /*eCoreUnit*/,
  85     SfxMapUnit          /*ePresUnit*/,
  86     XubString&          rText, const IntlWrapper *
  87 )       const
  88 {
  89     rText.Erase();
  90     return SFX_ITEM_PRESENTATION_NONE;
  91 }
  92
  93 // -----------------------------------------------------------------------
  94
  95 int SvxColorTableItem::operator==( const SfxPoolItem& rItem ) const
  96 {
  97     DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal type" );
  98     return ( ( SvxColorTableItem& ) rItem).pColorTable == pColorTable;
  99 }
 100
 101 // -----------------------------------------------------------------------
 102
 103 SfxPoolItem* SvxColorTableItem::Clone( SfxItemPool * ) const
 104 {
 105     return new SvxColorTableItem( *this );
 106 }
 107
 108 // -----------------------------------------------------------------------
 109
 110 sal_Bool SvxColorTableItem::QueryValue( com::sun::star::uno::Any& rVal, BYTE /*nMemberId*/ ) const
 111 {
 112     // This is only a quick helper to have UI support for these list items. Don't use
 113     // this method to query for a valid UNO representation.
 114     // Please ask CD if you want to change this.
 115     sal_Int64 aValue = sal_Int64( (ULONG)pColorTable );
 116     rVal = uno::makeAny( aValue );
 117     return sal_True;
 118 }
 119
 120 // -----------------------------------------------------------------------
 121
 122 sal_Bool SvxColorTableItem::PutValue( const com::sun::star::uno::Any& rVal, BYTE /*nMemberId*/ )
 123 {
 124     // This is only a quick helper to have UI support for these list items. Don't use
 125     // this method to query for a valid UNO representation.
 126     // Please ask CD if you want to change this.
 127     sal_Int64 aValue = 0;
 128     if ( rVal >>= aValue )
 129     {
 130         pColorTable = (XColorTable *)(ULONG)aValue;
 131         return sal_True;
 132     }
 133
 134     return sal_False;
 135 }
 136
 137 //==================================================================
 138 //
 139 //      SvxGradientListItem
 140 //
 141 //==================================================================
 142
 143 SvxGradientListItem::SvxGradientListItem()
 144 {
 145 }
 146
 147 // -----------------------------------------------------------------------
 148
 149 SvxGradientListItem::SvxGradientListItem( XGradientList* pList, sal_uInt16 nW ) :
 150     SfxPoolItem( nW ),
 151     pGradientList( pList )
 152 {
 153 }
 154
 155 // -----------------------------------------------------------------------
 156
 157 SvxGradientListItem::SvxGradientListItem( const SvxGradientListItem& rItem ) :
 158     SfxPoolItem( rItem ),
 159     pGradientList( rItem.pGradientList )
 160 {
 161 }
 162
 163 //------------------------------------------------------------------------
 164
 165 SfxItemPresentation SvxGradientListItem::GetPresentation
 166 (
 167     SfxItemPresentation /*ePres*/,
 168     SfxMapUnit          /*eCoreUnit*/,
 169     SfxMapUnit          /*ePresUnit*/,
 170     XubString&          rText, const IntlWrapper *
 171 )       const
 172 {
 173     rText.Erase();
 174     return SFX_ITEM_PRESENTATION_NONE;
 175 }
 176
 177 // -----------------------------------------------------------------------
 178
 179 int SvxGradientListItem::operator==( const SfxPoolItem& rItem ) const
 180 {
 181     DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal type" );
 182     return ( ( SvxGradientListItem& ) rItem).pGradientList == pGradientList;
 183 }
 184
 185 // -----------------------------------------------------------------------
 186
 187 SfxPoolItem* SvxGradientListItem::Clone( SfxItemPool * ) const
 188 {
 189     return new SvxGradientListItem( *this );
 190 }
 191
 192 // -----------------------------------------------------------------------
 193
 194 sal_Bool SvxGradientListItem::QueryValue( com::sun::star::uno::Any& rVal, BYTE /*nMemberId*/ ) const
 195 {
 196     // This is only a quick helper to have UI support for these list items. Don't use
 197     // this method to query for a valid UNO representation.
 198     // Please ask CD if you want to change this.
 199     sal_Int64 aValue = sal_Int64( (ULONG)pGradientList );
 200     rVal = uno::makeAny( aValue );
 201     return sal_True;
 202 }
 203
 204 // -----------------------------------------------------------------------
 205
 206 sal_Bool SvxGradientListItem::PutValue( const com::sun::star::uno::Any& rVal, BYTE /*nMemberId*/ )
 207 {
 208     // This is only a quick helper to have UI support for these list items. Don't use
 209     // this method to query for a valid UNO representation.
 210     // Please ask CD if you want to change this.
 211     sal_Int64 aValue = 0;
 212     if ( rVal >>= aValue )
 213     {
 214         pGradientList = (XGradientList *)(ULONG)aValue;
 215         return sal_True;
 216     }
 217
 218     return sal_False;
 219 }
 220
 221 //==================================================================
 222 //
 223 //      SvxHatchListItem
 224 //
 225 //==================================================================
 226
 227 SvxHatchListItem::SvxHatchListItem()
 228 {
 229 }
 230
 231 // -----------------------------------------------------------------------
 232
 233 SvxHatchListItem::SvxHatchListItem( XHatchList* pList, sal_uInt16 nW ) :
 234     SfxPoolItem( nW ),
 235     pHatchList( pList )
 236 {
 237 }
 238
 239 // -----------------------------------------------------------------------
 240
 241 SvxHatchListItem::SvxHatchListItem( const SvxHatchListItem& rItem ) :
 242     SfxPoolItem( rItem ),
 243     pHatchList( rItem.pHatchList )
 244 {
 245 }
 246
 247 //------------------------------------------------------------------------
 248
 249 SfxItemPresentation SvxHatchListItem::GetPresentation
 250 (
 251     SfxItemPresentation /*ePres*/,
 252     SfxMapUnit          /*eCoreUnit*/,
 253     SfxMapUnit          /*ePresUnit*/,
 254     XubString&          rText, const IntlWrapper *
 255 )       const
 256 {
 257     rText.Erase();
 258     return SFX_ITEM_PRESENTATION_NONE;
 259 }
 260
 261 // -----------------------------------------------------------------------
 262
 263 int SvxHatchListItem::operator==( const SfxPoolItem& rItem ) const
 264 {
 265     DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal type" );
 266     return ( ( SvxHatchListItem& ) rItem).pHatchList == pHatchList;
 267 }
 268
 269 // -----------------------------------------------------------------------
 270
 271 SfxPoolItem* SvxHatchListItem::Clone( SfxItemPool * ) const
 272 {
 273     return new SvxHatchListItem( *this );
 274 }
 275
 276 // -----------------------------------------------------------------------
 277
 278 sal_Bool SvxHatchListItem::QueryValue( com::sun::star::uno::Any& rVal, BYTE /*nMemberId*/ ) const
 279 {
 280     // This is only a quick helper to have UI support for these list items. Don't use
 281     // this method to query for a valid UNO representation.
 282     // Please ask CD if you want to change this.
 283     sal_Int64 aValue = sal_Int64( (ULONG)pHatchList );
 284     rVal = uno::makeAny( aValue );
 285     return sal_True;
 286 }
 287
 288 // -----------------------------------------------------------------------
 289
 290 sal_Bool SvxHatchListItem::PutValue( const com::sun::star::uno::Any& rVal, BYTE /*nMemberId*/ )
 291 {
 292     // This is only a quick helper to have UI support for these list items. Don't use
 293     // this method to query for a valid UNO representation.
 294     // Please ask CD if you want to change this.
 295     sal_Int64 aValue = 0;
 296     if ( rVal >>= aValue )
 297     {
 298         pHatchList = (XHatchList *)(ULONG)aValue;
 299         return sal_True;
 300     }
 301
 302     return sal_False;
 303 }
 304
 305 //==================================================================
 306 //
 307 //      SvxBitmapListItem
 308 //
 309 //==================================================================
 310
 311 SvxBitmapListItem::SvxBitmapListItem()
 312 {
 313 }
 314
 315 // -----------------------------------------------------------------------
 316
 317 SvxBitmapListItem::SvxBitmapListItem( XBitmapList* pList, sal_uInt16 nW ) :
 318     SfxPoolItem( nW ),
 319     pBitmapList( pList )
 320 {
 321 }
 322
 323 // -----------------------------------------------------------------------
 324
 325 SvxBitmapListItem::SvxBitmapListItem( const SvxBitmapListItem& rItem ) :
 326     SfxPoolItem( rItem ),
 327     pBitmapList( rItem.pBitmapList )
 328 {
 329 }
 330
 331 //------------------------------------------------------------------------
 332
 333 SfxItemPresentation SvxBitmapListItem::GetPresentation
 334 (
 335     SfxItemPresentation /*ePres*/,
 336     SfxMapUnit          /*eCoreUnit*/,
 337     SfxMapUnit          /*ePresUnit*/,
 338     XubString&          rText, const IntlWrapper *
 339 )       const
 340 {
 341     rText.Erase();
 342     return SFX_ITEM_PRESENTATION_NONE;
 343 }
 344
 345 // -----------------------------------------------------------------------
 346
 347 int SvxBitmapListItem::operator==( const SfxPoolItem& rItem ) const
 348 {
 349     DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal type" );
 350     return ( ( SvxBitmapListItem& ) rItem).pBitmapList == pBitmapList;
 351 }
 352
 353 // -----------------------------------------------------------------------
 354
 355 SfxPoolItem* SvxBitmapListItem::Clone( SfxItemPool * ) const
 356 {
 357     return new SvxBitmapListItem( *this );
 358 }
 359
 360 // -----------------------------------------------------------------------
 361
 362 sal_Bool SvxBitmapListItem::QueryValue( com::sun::star::uno::Any& rVal, BYTE /*nMemberId*/ ) const
 363 {
 364     // This is only a quick helper to have UI support for these list items. Don't use
 365     // this method to query for a valid UNO representation.
 366     // Please ask CD if you want to change this.
 367     sal_Int64 aValue = sal_Int64( (ULONG)pBitmapList );
 368     rVal = uno::makeAny( aValue );
 369     return sal_True;
 370 }
 371
 372 // -----------------------------------------------------------------------
 373
 374 sal_Bool SvxBitmapListItem::PutValue( const com::sun::star::uno::Any& rVal, BYTE /*nMemberId*/ )
 375 {
 376     // This is only a quick helper to have UI support for these list items. Don't use
 377     // this method to query for a valid UNO representation.
 378     // Please ask CD if you want to change this.
 379     sal_Int64 aValue = 0;
 380     if ( rVal >>= aValue )
 381     {
 382         pBitmapList = (XBitmapList *)(ULONG)aValue;
 383         return sal_True;
 384     }
 385
 386     return sal_False;
 387 }
 388
 389
 390 //==================================================================
 391 //
 392 //      SvxDashListItem
 393 //
 394 //==================================================================
 395
 396 SvxDashListItem::SvxDashListItem() :
 397     pDashList( 0 )
 398 {
 399 }
 400
 401 // -----------------------------------------------------------------------
 402
 403 SvxDashListItem::SvxDashListItem( XDashList* pList, sal_uInt16 nW ) :
 404     SfxPoolItem( nW ),
 405     pDashList( pList )
 406 {
 407 }
 408
 409 // -----------------------------------------------------------------------
 410
 411 SvxDashListItem::SvxDashListItem( const SvxDashListItem& rItem ) :
 412     SfxPoolItem( rItem ),
 413     pDashList( rItem.pDashList )
 414 {
 415 }
 416
 417 //------------------------------------------------------------------------
 418
 419 SfxItemPresentation SvxDashListItem::GetPresentation
 420 (
 421     SfxItemPresentation /*ePres*/,
 422     SfxMapUnit          /*eCoreUnit*/,
 423     SfxMapUnit          /*ePresUnit*/,
 424     XubString&          rText, const IntlWrapper *
 425 )       const
 426 {
 427     rText.Erase();
 428     return SFX_ITEM_PRESENTATION_NONE;
 429 }
 430
 431 // -----------------------------------------------------------------------
 432
 433 int SvxDashListItem::operator==( const SfxPoolItem& rItem ) const
 434 {
 435     DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal type" );
 436     return ( ( SvxDashListItem& ) rItem).pDashList == pDashList;
 437 }
 438
 439 // -----------------------------------------------------------------------
 440
 441 SfxPoolItem* SvxDashListItem::Clone( SfxItemPool * ) const
 442 {
 443     return new SvxDashListItem( *this );
 444 }
 445
 446 // -----------------------------------------------------------------------
 447
 448 sal_Bool SvxDashListItem::QueryValue( com::sun::star::uno::Any& rVal, BYTE /*nMemberId*/ ) const
 449 {
 450     // This is only a quick helper to have UI support for these list items. Don't use
 451     // this method to query for a valid UNO representation.
 452     sal_Int64 aValue = sal_Int64( (ULONG)pDashList );
 453     rVal = uno::makeAny( aValue );
 454     return sal_True;
 455 }
 456
 457 // -----------------------------------------------------------------------
 458
 459 sal_Bool SvxDashListItem::PutValue( const com::sun::star::uno::Any& rVal, BYTE /*nMemberId*/ )
 460 {
 461     // This is only a quick helper to have UI support for these list items. Don't use
 462     // this method to query for a valid UNO representation.
 463     sal_Int64 aValue = 0;
 464     if ( rVal >>= aValue )
 465     {
 466         pDashList = (XDashList *)(ULONG)aValue;
 467         return sal_True;
 468     }
 469
 470     return sal_False;
 471 }
 472
 473 // -----------------------------------------------------------------------
 474
 475 void SvxDashListItem::SetDashList( XDashList* pList )
 476 {
 477     pDashList = pList;
 478 }
 479
 480 //==================================================================
 481 //
 482 //      SvxLineEndListItem
 483 //
 484 //==================================================================
 485
 486 SvxLineEndListItem::SvxLineEndListItem()
 487 {
 488 }
 489
 490 // -----------------------------------------------------------------------
 491
 492 SvxLineEndListItem::SvxLineEndListItem( XLineEndList* pList, sal_uInt16 nW ) :
 493     SfxPoolItem( nW ),
 494     pLineEndList( pList )
 495 {
 496 }
 497
 498 // -----------------------------------------------------------------------
 499
 500 SvxLineEndListItem::SvxLineEndListItem( const SvxLineEndListItem& rItem ) :
 501     SfxPoolItem( rItem ),
 502     pLineEndList( rItem.pLineEndList )
 503 {
 504 }
 505
 506 //------------------------------------------------------------------------
 507
 508 SfxItemPresentation SvxLineEndListItem::GetPresentation
 509 (
 510     SfxItemPresentation /*ePres*/,
 511     SfxMapUnit          /*eCoreUnit*/,
 512     SfxMapUnit          /*ePresUnit*/,
 513     XubString&          rText, const IntlWrapper *
 514 )       const
 515 {
 516     rText.Erase();
 517     return SFX_ITEM_PRESENTATION_NONE;
 518 }
 519
 520 // -----------------------------------------------------------------------
 521
 522 int SvxLineEndListItem::operator==( const SfxPoolItem& rItem ) const
 523 {
 524     DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal type" );
 525     return ( ( SvxLineEndListItem& ) rItem).pLineEndList == pLineEndList;
 526 }
 527
 528 // -----------------------------------------------------------------------
 529
 530 SfxPoolItem* SvxLineEndListItem::Clone( SfxItemPool * ) const
 531 {
 532     return new SvxLineEndListItem( *this );
 533 }
 534
 535 // -----------------------------------------------------------------------
 536
 537 sal_Bool SvxLineEndListItem::QueryValue( com::sun::star::uno::Any& rVal, BYTE /*nMemberId*/ ) const
 538 {
 539     // This is only a quick helper to have UI support for these list items. Don't use
 540     // this method to query for a valid UNO representation.
 541     sal_Int64 aValue = sal_Int64( (ULONG)pLineEndList );
 542     rVal = uno::makeAny( aValue );
 543     return sal_True;
 544 }
 545
 546 // -----------------------------------------------------------------------
 547
 548 sal_Bool SvxLineEndListItem::PutValue( const com::sun::star::uno::Any& rVal, BYTE /*nMemberId*/ )
 549 {
 550     // This is only a quick helper to have UI support for these list items. Don't use
 551     // this method to query for a valid UNO representation.
 552     sal_Int64 aValue = 0;
 553     if ( rVal >>= aValue )
 554     {
 555         pLineEndList = (XLineEndList *)(ULONG)aValue;
 556         return sal_True;
 557     }
 558
 559     return sal_False;
 560 }