sc/source/ui/app/uiitems.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: uiitems.cxx,v $
  10  * $Revision: 1.9.32.2 $
  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_sc.hxx"
  33
  34
  35
  36 #include <svx/editobj.hxx>
  37
  38 #include "userlist.hxx"
  39 #include "uiitems.hxx"
  40 #include "dpsave.hxx"
  41
  42 // STATIC DATA -----------------------------------------------------------
  43
  44 TYPEINIT1(ScInputStatusItem,    SfxPoolItem);
  45 TYPEINIT1(ScSortItem,           SfxPoolItem);
  46 TYPEINIT1(ScQueryItem,          SfxPoolItem);
  47 TYPEINIT1(ScSubTotalItem,       SfxPoolItem);
  48 TYPEINIT1(ScUserListItem,       SfxPoolItem);
  49 TYPEINIT1(ScConsolidateItem,    SfxPoolItem);
  50 TYPEINIT1(ScPivotItem,              SfxPoolItem);
  51 TYPEINIT1(ScSolveItem,              SfxPoolItem);
  52 TYPEINIT1(ScTabOpItem,              SfxPoolItem);
  53 TYPEINIT1(ScCondFrmtItem,           SfxPoolItem);
  54
  55 TYPEINIT1(ScTablesHint,                 SfxHint);
  56 TYPEINIT1(ScEditViewHint,               SfxHint);
  57 TYPEINIT1(ScIndexHint,                  SfxHint);
  58
  59 // -----------------------------------------------------------------------
  60 //      ScInputStatusItem - Status-Update fuer Eingabezeile
  61 // -----------------------------------------------------------------------
  62
  63 //UNUSED2008-05  ScInputStatusItem::ScInputStatusItem( USHORT nWhichP,
  64 //UNUSED2008-05                                        SCTAB nTab,
  65 //UNUSED2008-05                                        SCCOL nCol, SCROW nRow,
  66 //UNUSED2008-05                                        SCCOL nStartCol, SCROW nStartRow,
  67 //UNUSED2008-05                                        SCCOL nEndCol,   SCROW nEndRow,
  68 //UNUSED2008-05                                        const String& rString, const EditTextObject* pData )
  69 //UNUSED2008-05
  70 //UNUSED2008-05      :   SfxPoolItem ( nWhichP ),
  71 //UNUSED2008-05          aCursorPos  ( nCol, nRow, nTab ),
  72 //UNUSED2008-05          aStartPos   ( nStartCol, nStartRow, nTab ),
  73 //UNUSED2008-05          aEndPos     ( nEndCol,   nEndRow,   nTab ),
  74 //UNUSED2008-05          aString     ( rString ),
  75 //UNUSED2008-05          pEditData   ( pData ? pData->Clone() : NULL )
  76 //UNUSED2008-05  {
  77 //UNUSED2008-05  }
  78
  79 ScInputStatusItem::ScInputStatusItem( USHORT nWhichP,
  80                                       const ScAddress& rCurPos,
  81                                       const ScAddress& rStartPos,
  82                                       const ScAddress& rEndPos,
  83                                       const String& rString,
  84                                       const EditTextObject* pData )
  85     :   SfxPoolItem ( nWhichP ),
  86         aCursorPos      ( rCurPos ),
  87         aStartPos       ( rStartPos ),
  88         aEndPos         ( rEndPos ),
  89         aString         ( rString ),
  90         pEditData       ( pData ? pData->Clone() : NULL )
  91 {
  92 }
  93
  94 ScInputStatusItem::ScInputStatusItem( const ScInputStatusItem& rItem )
  95     :   SfxPoolItem     ( rItem ),
  96         aCursorPos      ( rItem.aCursorPos ),
  97         aStartPos       ( rItem.aStartPos ),
  98         aEndPos         ( rItem.aEndPos ),
  99         aString         ( rItem.aString ),
 100         pEditData       ( rItem.pEditData ? rItem.pEditData->Clone() : NULL )
 101 {
 102 }
 103
 104 __EXPORT ScInputStatusItem::~ScInputStatusItem()
 105 {
 106     delete pEditData;
 107 }
 108
 109 String __EXPORT ScInputStatusItem::GetValueText() const
 110 {
 111     return String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("InputStatus"));
 112 }
 113
 114 int __EXPORT ScInputStatusItem::operator==( const SfxPoolItem& rItem ) const
 115 {
 116     DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal Which or Type" );
 117
 118     return (    (aStartPos      == ((ScInputStatusItem&)rItem).aStartPos)
 119              && (aEndPos        == ((ScInputStatusItem&)rItem).aEndPos)
 120              && (aCursorPos == ((ScInputStatusItem&)rItem).aCursorPos)
 121              && (aString        == ((ScInputStatusItem&)rItem).aString) );
 122                                                         //!     Edit-Daten vergleichen!
 123 }
 124
 125 SfxPoolItem* __EXPORT ScInputStatusItem::Clone( SfxItemPool * ) const
 126 {
 127     return new ScInputStatusItem( *this );
 128 }
 129
 130 //
 131 //      ScPaintHint ist nach schints.cxx verschoben
 132 //
 133
 134 // -----------------------------------------------------------------------
 135 //      ScTablesHint - Views anpassen, wenn Tabellen eingefuegt / geloescht
 136 // -----------------------------------------------------------------------
 137
 138 ScTablesHint::ScTablesHint(USHORT nNewId, SCTAB nTable1, SCTAB nTable2) :
 139     nId( nNewId ),
 140     nTab1( nTable1 ),
 141     nTab2( nTable2 )
 142 {
 143 }
 144
 145 ScTablesHint::~ScTablesHint()
 146 {
 147 }
 148
 149
 150 // -----------------------------------------------------------------------
 151 //      ScIndexHint
 152 // -----------------------------------------------------------------------
 153
 154 ScIndexHint::ScIndexHint(USHORT nNewId, USHORT nIdx) :
 155     nId( nNewId ),
 156     nIndex( nIdx )
 157 {
 158 }
 159
 160 ScIndexHint::~ScIndexHint()
 161 {
 162 }
 163
 164
 165 // -----------------------------------------------------------------------
 166 //      ScEditViewHint - neue EditView fuer Cursorposition anlegen
 167 // -----------------------------------------------------------------------
 168
 169 ScEditViewHint::ScEditViewHint( ScEditEngineDefaulter* pEngine, const ScAddress& rCurPos ) :
 170     pEditEngine( pEngine ),
 171     aCursorPos( rCurPos )
 172 {
 173 }
 174
 175 ScEditViewHint::~ScEditViewHint()
 176 {
 177 }
 178
 179 // -----------------------------------------------------------------------
 180 //      ScSortItem - Daten fuer den Sortierdialog
 181 // -----------------------------------------------------------------------
 182
 183 ScSortItem::ScSortItem( USHORT              nWhichP,
 184                         ScViewData*         ptrViewData,
 185                         const ScSortParam*  pSortData ) :
 186         SfxPoolItem ( nWhichP ),
 187         pViewData   ( ptrViewData )
 188 {
 189     if ( pSortData ) theSortData = *pSortData;
 190 }
 191
 192 //------------------------------------------------------------------------
 193
 194 ScSortItem::ScSortItem( USHORT              nWhichP,
 195                         const ScSortParam*  pSortData ) :
 196         SfxPoolItem ( nWhichP ),
 197         pViewData   ( NULL )
 198 {
 199     if ( pSortData ) theSortData = *pSortData;
 200 }
 201
 202 //------------------------------------------------------------------------
 203
 204 ScSortItem::ScSortItem( const ScSortItem& rItem ) :
 205         SfxPoolItem ( rItem ),
 206         pViewData   ( rItem.pViewData ),
 207         theSortData ( rItem.theSortData )
 208 {
 209 }
 210
 211 __EXPORT ScSortItem::~ScSortItem()
 212 {
 213 }
 214
 215 //------------------------------------------------------------------------
 216
 217 String __EXPORT ScSortItem::GetValueText() const
 218 {
 219     return String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("SortItem"));
 220 }
 221
 222 //------------------------------------------------------------------------
 223
 224 int __EXPORT ScSortItem::operator==( const SfxPoolItem& rItem ) const
 225 {
 226     DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal Which or Type" );
 227
 228     const ScSortItem& rOther = (const ScSortItem&)rItem;
 229
 230     return (   (pViewData   == rOther.pViewData)
 231             && (theSortData == rOther.theSortData) );
 232 }
 233
 234 //------------------------------------------------------------------------
 235
 236 SfxPoolItem* __EXPORT ScSortItem::Clone( SfxItemPool * ) const
 237 {
 238     return new ScSortItem( *this );
 239 }
 240
 241 //------------------------------------------------------------------------
 242
 243 sal_Bool ScSortItem::QueryValue( com::sun::star::uno::Any& rVal, BYTE /* nMemberUd */ ) const
 244 {
 245     // Return empty value as there is no useful conversion
 246     rVal = com::sun::star::uno::Any();
 247     return sal_True;
 248 }
 249
 250 // -----------------------------------------------------------------------
 251 //      ScQueryItem - Daten fuer den Filterdialog
 252 // -----------------------------------------------------------------------
 253
 254 ScQueryItem::ScQueryItem( USHORT                nWhichP,
 255                           ScViewData*           ptrViewData,
 256                           const ScQueryParam*   pQueryData ) :
 257         SfxPoolItem ( nWhichP ),
 258         pViewData   ( ptrViewData ),
 259         bIsAdvanced     ( FALSE )
 260 {
 261     if ( pQueryData ) theQueryData = *pQueryData;
 262 }
 263
 264 //------------------------------------------------------------------------
 265
 266 ScQueryItem::ScQueryItem( USHORT                nWhichP,
 267                           const ScQueryParam*   pQueryData ) :
 268         SfxPoolItem ( nWhichP ),
 269         pViewData   ( NULL ),
 270         bIsAdvanced     ( FALSE )
 271 {
 272     if ( pQueryData ) theQueryData = *pQueryData;
 273 }
 274
 275 //------------------------------------------------------------------------
 276
 277 ScQueryItem::ScQueryItem( const ScQueryItem& rItem ) :
 278         SfxPoolItem ( rItem ),
 279         pViewData   ( rItem.pViewData ),
 280         theQueryData( rItem.theQueryData ),
 281         bIsAdvanced     ( rItem.bIsAdvanced ),
 282         aAdvSource      ( rItem.aAdvSource )
 283 {
 284 }
 285
 286 __EXPORT ScQueryItem::~ScQueryItem()
 287 {
 288 }
 289
 290 //------------------------------------------------------------------------
 291
 292 void ScQueryItem::SetAdvancedQuerySource(const ScRange* pSource)
 293 {
 294     if (pSource)
 295     {
 296         aAdvSource = *pSource;
 297         bIsAdvanced = TRUE;
 298     }
 299     else
 300         bIsAdvanced = FALSE;
 301 }
 302
 303 BOOL ScQueryItem::GetAdvancedQuerySource(ScRange& rSource) const
 304 {
 305     rSource = aAdvSource;
 306     return bIsAdvanced;
 307 }
 308
 309 //------------------------------------------------------------------------
 310
 311 String __EXPORT ScQueryItem::GetValueText() const
 312 {
 313     return String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("QueryItem"));
 314 }
 315
 316 //------------------------------------------------------------------------
 317
 318 int __EXPORT ScQueryItem::operator==( const SfxPoolItem& rItem ) const
 319 {
 320     DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal Which or Type" );
 321
 322     const ScQueryItem& rQueryItem = (const ScQueryItem&)rItem;
 323
 324     return (   (pViewData    == rQueryItem.pViewData)
 325             && (bIsAdvanced  == rQueryItem.bIsAdvanced)
 326             && (aAdvSource   == rQueryItem.aAdvSource)
 327             && (theQueryData == rQueryItem.theQueryData) );
 328 }
 329
 330 //------------------------------------------------------------------------
 331
 332 SfxPoolItem* __EXPORT ScQueryItem::Clone( SfxItemPool * ) const
 333 {
 334     return new ScQueryItem( *this );
 335 }
 336
 337 // -----------------------------------------------------------------------
 338 //      ScSubTotalItem - Daten fuer den Zwischenergebnisdialog
 339 // -----------------------------------------------------------------------
 340
 341 ScSubTotalItem::ScSubTotalItem( USHORT                  nWhichP,
 342                                 ScViewData*             ptrViewData,
 343                                 const ScSubTotalParam*  pSubTotalData ) :
 344         SfxPoolItem ( nWhichP ),
 345         pViewData   ( ptrViewData )
 346 {
 347     if ( pSubTotalData ) theSubTotalData = *pSubTotalData;
 348 }
 349
 350 //------------------------------------------------------------------------
 351
 352 ScSubTotalItem::ScSubTotalItem( USHORT                  nWhichP,
 353                                 const ScSubTotalParam*  pSubTotalData ) :
 354         SfxPoolItem ( nWhichP ),
 355         pViewData   ( NULL )
 356 {
 357     if ( pSubTotalData ) theSubTotalData = *pSubTotalData;
 358 }
 359
 360 //------------------------------------------------------------------------
 361
 362 ScSubTotalItem::ScSubTotalItem( const ScSubTotalItem& rItem ) :
 363         SfxPoolItem             ( rItem ),
 364         pViewData               ( rItem.pViewData ),
 365         theSubTotalData ( rItem.theSubTotalData )
 366 {
 367 }
 368
 369 __EXPORT ScSubTotalItem::~ScSubTotalItem()
 370 {
 371 }
 372
 373 //------------------------------------------------------------------------
 374
 375 String __EXPORT ScSubTotalItem::GetValueText() const
 376 {
 377     return String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("SubTotalItem"));
 378 }
 379
 380 //------------------------------------------------------------------------
 381
 382 int __EXPORT ScSubTotalItem::operator==( const SfxPoolItem& rItem ) const
 383 {
 384     DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal Which or Type" );
 385
 386     const ScSubTotalItem& rSTItem = (const ScSubTotalItem&)rItem;
 387
 388     return (   (pViewData       == rSTItem.pViewData)
 389             && (theSubTotalData == rSTItem.theSubTotalData) );
 390 }
 391
 392 //------------------------------------------------------------------------
 393
 394 SfxPoolItem* __EXPORT ScSubTotalItem::Clone( SfxItemPool * ) const
 395 {
 396     return new ScSubTotalItem( *this );
 397 }
 398
 399 //------------------------------------------------------------------------
 400
 401 sal_Bool ScSubTotalItem::QueryValue( com::sun::star::uno::Any& rVal, BYTE /* nMemberUd */ ) const
 402 {
 403     // Return empty value as there is no useful conversion
 404     rVal = com::sun::star::uno::Any();
 405     return sal_True;
 406 }
 407
 408 // -----------------------------------------------------------------------
 409 //      ScUserListItem - Transporter fuer den Benutzerlisten-TabPage
 410 // -----------------------------------------------------------------------
 411
 412 ScUserListItem::ScUserListItem( USHORT nWhichP )
 413     :   SfxPoolItem ( nWhichP ),
 414         pUserList       ( NULL )
 415 {
 416 }
 417
 418 //------------------------------------------------------------------------
 419
 420 ScUserListItem::ScUserListItem( const ScUserListItem& rItem )
 421     :   SfxPoolItem     ( rItem )
 422 {
 423     if ( rItem.pUserList )
 424         pUserList = new ScUserList( *(rItem.pUserList) );
 425     else
 426         pUserList = NULL;
 427 }
 428
 429 __EXPORT ScUserListItem::~ScUserListItem()
 430 {
 431     delete pUserList;
 432 }
 433
 434 //------------------------------------------------------------------------
 435
 436 String __EXPORT ScUserListItem::GetValueText() const
 437 {
 438     return String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("ScUserListItem"));
 439 }
 440
 441 //------------------------------------------------------------------------
 442
 443 int __EXPORT ScUserListItem::operator==( const SfxPoolItem& rItem ) const
 444 {
 445     DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal Which or Type" );
 446
 447     const ScUserListItem& r = (const ScUserListItem&)rItem;
 448     BOOL bEqual = FALSE;
 449
 450     if ( !pUserList || !(r.pUserList) )
 451         bEqual = ( !pUserList && !(r.pUserList) );
 452     else
 453         bEqual = ( *pUserList == *(r.pUserList) );
 454
 455     return bEqual;
 456 }
 457
 458
 459 //------------------------------------------------------------------------
 460
 461 SfxPoolItem* __EXPORT ScUserListItem::Clone( SfxItemPool * ) const
 462 {
 463     return new ScUserListItem( *this );
 464 }
 465
 466 //------------------------------------------------------------------------
 467
 468 void ScUserListItem::SetUserList( const ScUserList& rUserList )
 469 {
 470     delete pUserList;
 471     pUserList = new ScUserList( rUserList );
 472 }
 473
 474 // -----------------------------------------------------------------------
 475 //      ScConsolidateItem - Daten fuer den Konsolidieren-Dialog
 476 // -----------------------------------------------------------------------
 477
 478 ScConsolidateItem::ScConsolidateItem(
 479                             USHORT                      nWhichP,
 480                             const ScConsolidateParam*   pConsolidateData ) :
 481         SfxPoolItem ( nWhichP )
 482 {
 483     if ( pConsolidateData ) theConsData = *pConsolidateData;
 484 }
 485
 486 //------------------------------------------------------------------------
 487
 488 ScConsolidateItem::ScConsolidateItem( const ScConsolidateItem& rItem ) :
 489         SfxPoolItem     ( rItem ),
 490         theConsData     ( rItem.theConsData )
 491 {
 492 }
 493
 494 //------------------------------------------------------------------------
 495
 496 __EXPORT ScConsolidateItem::~ScConsolidateItem()
 497 {
 498 }
 499
 500 //------------------------------------------------------------------------
 501
 502 String __EXPORT ScConsolidateItem::GetValueText() const
 503 {
 504     return String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("ScConsolidateItem"));
 505 }
 506
 507 //------------------------------------------------------------------------
 508
 509 int __EXPORT ScConsolidateItem::operator==( const SfxPoolItem& rItem ) const
 510 {
 511     DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal Which or Type" );
 512
 513     const ScConsolidateItem& rCItem = (const ScConsolidateItem&)rItem;
 514
 515     return ( theConsData == rCItem.theConsData);
 516 }
 517
 518 //------------------------------------------------------------------------
 519
 520 SfxPoolItem* __EXPORT ScConsolidateItem::Clone( SfxItemPool * ) const
 521 {
 522     return new ScConsolidateItem( *this );
 523 }
 524
 525
 526 // -----------------------------------------------------------------------
 527 //      ScPivotItem - Daten fuer den Pivot-Dialog
 528 // -----------------------------------------------------------------------
 529
 530 ScPivotItem::ScPivotItem( USHORT nWhichP, const ScDPSaveData* pData,
 531                              const ScRange* pRange, BOOL bNew ) :
 532         SfxPoolItem ( nWhichP )
 533 {
 534     //  pSaveData must always exist
 535     if ( pData )
 536         pSaveData = new ScDPSaveData(*pData);
 537     else
 538         pSaveData = new ScDPSaveData;
 539     if ( pRange ) aDestRange = *pRange;
 540     bNewSheet = bNew;
 541 }
 542
 543 //------------------------------------------------------------------------
 544
 545 ScPivotItem::ScPivotItem( const ScPivotItem& rItem ) :
 546         SfxPoolItem     ( rItem ),
 547         aDestRange      ( rItem.aDestRange ),
 548         bNewSheet       ( rItem.bNewSheet )
 549 {
 550     DBG_ASSERT(rItem.pSaveData, "pSaveData");
 551     pSaveData = new ScDPSaveData(*rItem.pSaveData);
 552 }
 553
 554 //------------------------------------------------------------------------
 555
 556 __EXPORT ScPivotItem::~ScPivotItem()
 557 {
 558     delete pSaveData;
 559 }
 560
 561 //------------------------------------------------------------------------
 562
 563 String __EXPORT ScPivotItem::GetValueText() const
 564 {
 565     return String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("ScPivotItem"));
 566 }
 567
 568 //------------------------------------------------------------------------
 569
 570 int __EXPORT ScPivotItem::operator==( const SfxPoolItem& rItem ) const
 571 {
 572     DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal Which or Type" );
 573
 574     const ScPivotItem& rPItem = (const ScPivotItem&)rItem;
 575     DBG_ASSERT( pSaveData && rPItem.pSaveData, "pSaveData" );
 576     return ( *pSaveData == *rPItem.pSaveData &&
 577              aDestRange == rPItem.aDestRange &&
 578              bNewSheet  == rPItem.bNewSheet );
 579 }
 580
 581 //------------------------------------------------------------------------
 582
 583 SfxPoolItem* __EXPORT ScPivotItem::Clone( SfxItemPool * ) const
 584 {
 585     return new ScPivotItem( *this );
 586 }
 587
 588
 589 // -----------------------------------------------------------------------
 590 //      ScSolveItem - Daten fuer den Solver-Dialog
 591 // -----------------------------------------------------------------------
 592
 593 ScSolveItem::ScSolveItem( USHORT                nWhichP,
 594                           const ScSolveParam*   pSolveData )
 595     :   SfxPoolItem ( nWhichP )
 596 {
 597     if ( pSolveData ) theSolveData = *pSolveData;
 598 }
 599
 600 //------------------------------------------------------------------------
 601
 602 ScSolveItem::ScSolveItem( const ScSolveItem& rItem )
 603     :   SfxPoolItem             ( rItem ),
 604         theSolveData    ( rItem.theSolveData )
 605 {
 606 }
 607
 608 //------------------------------------------------------------------------
 609
 610 __EXPORT ScSolveItem::~ScSolveItem()
 611 {
 612 }
 613
 614 //------------------------------------------------------------------------
 615
 616 String __EXPORT ScSolveItem::GetValueText() const
 617 {
 618     return String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("ScSolveItem"));
 619 }
 620
 621 //------------------------------------------------------------------------
 622
 623 int __EXPORT ScSolveItem::operator==( const SfxPoolItem& rItem ) const
 624 {
 625     DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal Which or Type" );
 626
 627     const ScSolveItem& rPItem = (const ScSolveItem&)rItem;
 628
 629     return ( theSolveData == rPItem.theSolveData );
 630 }
 631
 632 //------------------------------------------------------------------------
 633
 634 SfxPoolItem* __EXPORT ScSolveItem::Clone( SfxItemPool * ) const
 635 {
 636     return new ScSolveItem( *this );
 637 }
 638
 639 // -----------------------------------------------------------------------
 640 //      ScTabOpItem - Daten fuer den TabOp-Dialog
 641 // -----------------------------------------------------------------------
 642
 643 ScTabOpItem::ScTabOpItem( USHORT                nWhichP,
 644                           const ScTabOpParam*   pTabOpData )
 645     :   SfxPoolItem ( nWhichP )
 646 {
 647     if ( pTabOpData ) theTabOpData = *pTabOpData;
 648 }
 649
 650 //------------------------------------------------------------------------
 651
 652 ScTabOpItem::ScTabOpItem( const ScTabOpItem& rItem )
 653     :   SfxPoolItem             ( rItem ),
 654         theTabOpData    ( rItem.theTabOpData )
 655 {
 656 }
 657
 658 //------------------------------------------------------------------------
 659
 660 __EXPORT ScTabOpItem::~ScTabOpItem()
 661 {
 662 }
 663
 664 //------------------------------------------------------------------------
 665
 666 String __EXPORT ScTabOpItem::GetValueText() const
 667 {
 668     return String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("ScTabOpItem"));
 669 }
 670
 671 //------------------------------------------------------------------------
 672
 673 int __EXPORT ScTabOpItem::operator==( const SfxPoolItem& rItem ) const
 674 {
 675     DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal Which or Type" );
 676
 677     const ScTabOpItem& rPItem = (const ScTabOpItem&)rItem;
 678
 679     return ( theTabOpData == rPItem.theTabOpData );
 680 }
 681
 682 //------------------------------------------------------------------------
 683
 684 SfxPoolItem* __EXPORT ScTabOpItem::Clone( SfxItemPool * ) const
 685 {
 686     return new ScTabOpItem( *this );
 687 }
 688
 689
 690 // -----------------------------------------------------------------------
 691 //      ScCondFrmtItem - Daten fuer den Dialog bedingte Formatierung
 692 // -----------------------------------------------------------------------
 693
 694 ScCondFrmtItem::ScCondFrmtItem( USHORT nWhichP,
 695 //!                                                             const ScConditionalFormat* pCondFrmt )
 696                                 const ScConditionalFormat& rCondFrmt )
 697     :   SfxPoolItem ( nWhichP ),
 698         theCondFrmtData ( rCondFrmt )   //!
 699 {
 700 //!     if ( pCondFrmt ) theCondFrmtData = *pCondFrmt;
 701 }
 702
 703 //------------------------------------------------------------------------
 704
 705 ScCondFrmtItem::ScCondFrmtItem( const ScCondFrmtItem& rItem )
 706     :   SfxPoolItem             ( rItem ),
 707         theCondFrmtData ( rItem.theCondFrmtData )
 708 {
 709 }
 710
 711 //------------------------------------------------------------------------
 712
 713 __EXPORT ScCondFrmtItem::~ScCondFrmtItem()
 714 {
 715 }
 716
 717 //------------------------------------------------------------------------
 718
 719 String __EXPORT ScCondFrmtItem::GetValueText() const
 720 {
 721     return String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("ScCondFrmtItem"));
 722 }
 723
 724 //------------------------------------------------------------------------
 725
 726 int __EXPORT ScCondFrmtItem::operator==( const SfxPoolItem& rItem ) const
 727 {
 728     DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal Which or Type" );
 729
 730     const ScCondFrmtItem& rPItem = (const ScCondFrmtItem&)rItem;
 731
 732     return ( theCondFrmtData == rPItem.theCondFrmtData );
 733 }
 734
 735 //------------------------------------------------------------------------
 736
 737 SfxPoolItem* __EXPORT ScCondFrmtItem::Clone( SfxItemPool * ) const
 738 {
 739     return new ScCondFrmtItem( *this );
 740 }