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