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 <osl/diagnose.h>
  27 #include <editeng/editobj.hxx>
  28
  29 // STATIC DATA -----------------------------------------------------------
  30
  31 TYPEINIT1(ScInputStatusItem,    SfxPoolItem);
  32 TYPEINIT1(ScSortItem,           SfxPoolItem);
  33 TYPEINIT1(ScQueryItem,          SfxPoolItem);
  34 TYPEINIT1(ScSubTotalItem,       SfxPoolItem);
  35 TYPEINIT1(ScUserListItem,       SfxPoolItem);
  36 TYPEINIT1(ScConsolidateItem,    SfxPoolItem);
  37 TYPEINIT1(ScPivotItem,          SfxPoolItem);
  38 TYPEINIT1(ScSolveItem,          SfxPoolItem);
  39 TYPEINIT1(ScTabOpItem,          SfxPoolItem);
  40
  41
  42 /**
  43  * Status update for entry field
  44  */
  45 ScInputStatusItem::ScInputStatusItem(
  46     sal_uInt16 nWhichP, const ScAddress& rCurPos, const ScAddress& rStartPos,
  47     const ScAddress& rEndPos, const OUString& rString, const EditTextObject* pData ) :
  48     SfxPoolItem ( nWhichP ),
  49     aCursorPos  ( rCurPos ),
  50     aStartPos   ( rStartPos ),
  51     aEndPos     ( rEndPos ),
  52     aString     ( rString ),
  53     pEditData   ( pData ? pData->Clone() : NULL ),
  54     mpMisspellRanges(NULL)
  55 {
  56 }
  57
  58 ScInputStatusItem::ScInputStatusItem( const ScInputStatusItem& rItem ) :
  59     SfxPoolItem ( rItem ),
  60     aCursorPos  ( rItem.aCursorPos ),
  61     aStartPos   ( rItem.aStartPos ),
  62     aEndPos     ( rItem.aEndPos ),
  63     aString     ( rItem.aString ),
  64     pEditData   ( rItem.pEditData ? rItem.pEditData->Clone() : NULL ),
  65     mpMisspellRanges(rItem.mpMisspellRanges)
  66 {
  67 }
  68
  69 ScInputStatusItem::~ScInputStatusItem()
  70 {
  71     delete pEditData;
  72 }
  73
  74 bool ScInputStatusItem::operator==( const SfxPoolItem& rItem ) const
  75 {
  76     assert(SfxPoolItem::operator==(rItem));
  77
  78     return (aStartPos  == static_cast<const ScInputStatusItem&>(rItem).aStartPos)
  79              && (aEndPos    == static_cast<const ScInputStatusItem&>(rItem).aEndPos)
  80              && (aCursorPos == static_cast<const ScInputStatusItem&>(rItem).aCursorPos)
  81              && (aString    == static_cast<const ScInputStatusItem&>(rItem).aString);
  82              //TODO: Compare Edit data!
  83 }
  84
  85 SfxPoolItem* ScInputStatusItem::Clone( SfxItemPool * ) const
  86 {
  87     return new ScInputStatusItem( *this );
  88 }
  89
  90 void ScInputStatusItem::SetMisspellRanges( const std::vector<editeng::MisspellRanges>* pRanges )
  91 {
  92     mpMisspellRanges = pRanges;
  93 }
  94
  95 // ScPaintHint was moved to schints.cxx
  96
  97 /**
  98  * Adapt Views when inserting/deleting a table
  99  */
 100 ScTablesHint::ScTablesHint(sal_uInt16 nNewId, SCTAB nTable1, SCTAB nTable2) :
 101     nId( nNewId ),
 102     nTab1( nTable1 ),
 103     nTab2( nTable2 )
 104 {
 105 }
 106
 107 ScTablesHint::~ScTablesHint()
 108 {
 109 }
 110
 111 ScIndexHint::ScIndexHint(sal_uInt16 nNewId, sal_uInt16 nIdx) :
 112     nId( nNewId ),
 113     nIndex( nIdx )
 114 {
 115 }
 116
 117 ScIndexHint::~ScIndexHint()
 118 {
 119 }
 120
 121 /**
 122  * Create new EditView for Cursorposition
 123  */
 124 ScEditViewHint::ScEditViewHint( ScEditEngineDefaulter* pEngine, const ScAddress& rCurPos ) :
 125     pEditEngine( pEngine ),
 126     aCursorPos( rCurPos )
 127 {
 128 }
 129
 130 ScEditViewHint::~ScEditViewHint()
 131 {
 132 }
 133
 134 /**
 135  * Data for the sorting dialog
 136  */
 137 ScSortItem::ScSortItem( sal_uInt16              nWhichP,
 138                         ScViewData*         ptrViewData,
 139                         const ScSortParam*  pSortData ) :
 140         SfxPoolItem ( nWhichP ),
 141         pViewData   ( ptrViewData )
 142 {
 143     if ( pSortData ) theSortData = *pSortData;
 144 }
 145
 146 ScSortItem::ScSortItem( sal_uInt16              nWhichP,
 147                         const ScSortParam*  pSortData ) :
 148         SfxPoolItem ( nWhichP ),
 149         pViewData   ( NULL )
 150 {
 151     if ( pSortData ) theSortData = *pSortData;
 152 }
 153
 154 ScSortItem::ScSortItem( const ScSortItem& rItem ) :
 155         SfxPoolItem ( rItem ),
 156         pViewData   ( rItem.pViewData ),
 157         theSortData ( rItem.theSortData )
 158 {
 159 }
 160
 161 ScSortItem::~ScSortItem()
 162 {
 163 }
 164
 165 bool ScSortItem::operator==( const SfxPoolItem& rItem ) const
 166 {
 167     assert(SfxPoolItem::operator==(rItem));
 168
 169     const ScSortItem& rOther = static_cast<const ScSortItem&>(rItem);
 170
 171     return (   (pViewData   == rOther.pViewData)
 172             && (theSortData == rOther.theSortData) );
 173 }
 174
 175 SfxPoolItem* ScSortItem::Clone( SfxItemPool * ) const
 176 {
 177     return new ScSortItem( *this );
 178 }
 179
 180 bool ScSortItem::QueryValue( com::sun::star::uno::Any& rVal, sal_uInt8 /* nMemberUd */ ) const
 181 {
 182     // Return empty value as there is no useful conversion
 183     rVal = com::sun::star::uno::Any();
 184     return true;
 185 }
 186
 187 /**
 188  * Data for the Filter dialog
 189  */
 190 ScQueryItem::ScQueryItem( sal_uInt16                nWhichP,
 191                           ScViewData*           ptrViewData,
 192                           const ScQueryParam*   pQueryData ) :
 193         SfxPoolItem ( nWhichP ),
 194         mpQueryData(NULL),
 195         pViewData   ( ptrViewData ),
 196         bIsAdvanced ( false )
 197 {
 198     if (pQueryData)
 199         mpQueryData.reset(new ScQueryParam(*pQueryData));
 200     else
 201         mpQueryData.reset(new ScQueryParam);
 202 }
 203
 204 ScQueryItem::ScQueryItem( sal_uInt16                nWhichP,
 205                           const ScQueryParam*   pQueryData ) :
 206         SfxPoolItem ( nWhichP ),
 207         mpQueryData(NULL),
 208         pViewData   ( NULL ),
 209         bIsAdvanced ( false )
 210 {
 211     if (pQueryData)
 212         mpQueryData.reset(new ScQueryParam(*pQueryData));
 213     else
 214         mpQueryData.reset(new ScQueryParam);
 215 }
 216
 217 ScQueryItem::ScQueryItem( const ScQueryItem& rItem ) :
 218         SfxPoolItem ( rItem ),
 219         mpQueryData(new ScQueryParam(*rItem.mpQueryData)),
 220         pViewData   ( rItem.pViewData ),
 221         aAdvSource  ( rItem.aAdvSource ),
 222         bIsAdvanced ( rItem.bIsAdvanced )
 223 {
 224 }
 225
 226 ScQueryItem::~ScQueryItem()
 227 {
 228 }
 229
 230 void ScQueryItem::SetAdvancedQuerySource(const ScRange* pSource)
 231 {
 232     if (pSource)
 233     {
 234         aAdvSource = *pSource;
 235         bIsAdvanced = true;
 236     }
 237     else
 238         bIsAdvanced = false;
 239 }
 240
 241 const ScQueryParam& ScQueryItem::GetQueryData() const
 242 {
 243     return *mpQueryData;
 244 }
 245
 246 bool ScQueryItem::GetAdvancedQuerySource(ScRange& rSource) const
 247 {
 248     rSource = aAdvSource;
 249     return bIsAdvanced;
 250 }
 251
 252 bool ScQueryItem::operator==( const SfxPoolItem& rItem ) const
 253 {
 254     assert(SfxPoolItem::operator==(rItem));
 255
 256     const ScQueryItem& rQueryItem = static_cast<const ScQueryItem&>(rItem);
 257
 258     return (   (pViewData    == rQueryItem.pViewData)
 259             && (bIsAdvanced  == rQueryItem.bIsAdvanced)
 260             && (aAdvSource   == rQueryItem.aAdvSource)
 261             && (*mpQueryData == *rQueryItem.mpQueryData) );
 262 }
 263
 264 SfxPoolItem* ScQueryItem::Clone( SfxItemPool * ) const
 265 {
 266     return new ScQueryItem( *this );
 267 }
 268
 269 /**
 270  * Data for the SubTotal dialog
 271  */
 272 ScSubTotalItem::ScSubTotalItem( sal_uInt16                  nWhichP,
 273                                 ScViewData*             ptrViewData,
 274                                 const ScSubTotalParam*  pSubTotalData ) :
 275         SfxPoolItem ( nWhichP ),
 276         pViewData   ( ptrViewData )
 277 {
 278     if ( pSubTotalData ) theSubTotalData = *pSubTotalData;
 279 }
 280
 281 ScSubTotalItem::ScSubTotalItem( sal_uInt16                  nWhichP,
 282                                 const ScSubTotalParam*  pSubTotalData ) :
 283         SfxPoolItem ( nWhichP ),
 284         pViewData   ( NULL )
 285 {
 286     if ( pSubTotalData ) theSubTotalData = *pSubTotalData;
 287 }
 288
 289 ScSubTotalItem::ScSubTotalItem( const ScSubTotalItem& rItem ) :
 290         SfxPoolItem     ( rItem ),
 291         pViewData       ( rItem.pViewData ),
 292         theSubTotalData ( rItem.theSubTotalData )
 293 {
 294 }
 295
 296 ScSubTotalItem::~ScSubTotalItem()
 297 {
 298 }
 299
 300 bool ScSubTotalItem::operator==( const SfxPoolItem& rItem ) const
 301 {
 302     assert(SfxPoolItem::operator==(rItem));
 303
 304     const ScSubTotalItem& rSTItem = static_cast<const ScSubTotalItem&>(rItem);
 305
 306     return (   (pViewData       == rSTItem.pViewData)
 307             && (theSubTotalData == rSTItem.theSubTotalData) );
 308 }
 309
 310 SfxPoolItem* ScSubTotalItem::Clone( SfxItemPool * ) const
 311 {
 312     return new ScSubTotalItem( *this );
 313 }
 314
 315 bool ScSubTotalItem::QueryValue( com::sun::star::uno::Any& rVal, sal_uInt8 /* nMemberUd */ ) const
 316 {
 317     // Return empty value as there is no useful conversion
 318     rVal = com::sun::star::uno::Any();
 319     return true;
 320 }
 321
 322 /**
 323  * Transporter for the UserLIst dialog
 324  */
 325 ScUserListItem::ScUserListItem( sal_uInt16 nWhichP )
 326     :   SfxPoolItem ( nWhichP ),
 327         pUserList   ( NULL )
 328 {
 329 }
 330
 331 ScUserListItem::ScUserListItem( const ScUserListItem& rItem )
 332     :   SfxPoolItem ( rItem )
 333 {
 334     if ( rItem.pUserList )
 335         pUserList = new ScUserList( *(rItem.pUserList) );
 336     else
 337         pUserList = NULL;
 338 }
 339
 340 ScUserListItem::~ScUserListItem()
 341 {
 342     delete pUserList;
 343 }
 344
 345 bool ScUserListItem::operator==( const SfxPoolItem& rItem ) const
 346 {
 347     assert(SfxPoolItem::operator==(rItem));
 348
 349     const ScUserListItem& r = static_cast<const ScUserListItem&>(rItem);
 350     bool bEqual = false;
 351
 352     if ( !pUserList || !(r.pUserList) )
 353         bEqual = ( !pUserList && !(r.pUserList) );
 354     else
 355         bEqual = ( *pUserList == *(r.pUserList) );
 356
 357     return bEqual;
 358 }
 359
 360 SfxPoolItem* ScUserListItem::Clone( SfxItemPool * ) const
 361 {
 362     return new ScUserListItem( *this );
 363 }
 364
 365 void ScUserListItem::SetUserList( const ScUserList& rUserList )
 366 {
 367     delete pUserList;
 368     pUserList = new ScUserList( rUserList );
 369 }
 370
 371 /**
 372  * Data for the Consolidate dialog
 373  */
 374 ScConsolidateItem::ScConsolidateItem(
 375                             sal_uInt16                      nWhichP,
 376                             const ScConsolidateParam*   pConsolidateData ) :
 377         SfxPoolItem ( nWhichP )
 378 {
 379     if ( pConsolidateData ) theConsData = *pConsolidateData;
 380 }
 381
 382 ScConsolidateItem::ScConsolidateItem( const ScConsolidateItem& rItem ) :
 383         SfxPoolItem ( rItem ),
 384         theConsData ( rItem.theConsData )
 385 {
 386 }
 387
 388 ScConsolidateItem::~ScConsolidateItem()
 389 {
 390 }
 391
 392 bool ScConsolidateItem::operator==( const SfxPoolItem& rItem ) const
 393 {
 394     assert(SfxPoolItem::operator==(rItem));
 395
 396     const ScConsolidateItem& rCItem = static_cast<const ScConsolidateItem&>(rItem);
 397
 398     return ( theConsData == rCItem.theConsData);
 399 }
 400
 401 SfxPoolItem* ScConsolidateItem::Clone( SfxItemPool * ) const
 402 {
 403     return new ScConsolidateItem( *this );
 404 }
 405
 406 /**
 407  * Data for the Pivot dialog
 408  */
 409 ScPivotItem::ScPivotItem( sal_uInt16 nWhichP, const ScDPSaveData* pData,
 410                              const ScRange* pRange, bool bNew ) :
 411         SfxPoolItem ( nWhichP )
 412 {
 413     // pSaveData must always exist
 414     if ( pData )
 415         pSaveData = new ScDPSaveData(*pData);
 416     else
 417         pSaveData = new ScDPSaveData;
 418     if ( pRange ) aDestRange = *pRange;
 419     bNewSheet = bNew;
 420 }
 421
 422 ScPivotItem::ScPivotItem( const ScPivotItem& rItem ) :
 423         SfxPoolItem ( rItem ),
 424         aDestRange  ( rItem.aDestRange ),
 425         bNewSheet   ( rItem.bNewSheet )
 426 {
 427     assert(rItem.pSaveData && "pSaveData");
 428     pSaveData = new ScDPSaveData(*rItem.pSaveData);
 429 }
 430
 431 ScPivotItem::~ScPivotItem()
 432 {
 433     delete pSaveData;
 434 }
 435
 436 bool ScPivotItem::operator==( const SfxPoolItem& rItem ) const
 437 {
 438     assert(SfxPoolItem::operator==(rItem));
 439
 440     const ScPivotItem& rPItem = static_cast<const ScPivotItem&>(rItem);
 441     OSL_ENSURE( pSaveData && rPItem.pSaveData, "pSaveData" );
 442     return ( *pSaveData == *rPItem.pSaveData &&
 443              aDestRange == rPItem.aDestRange &&
 444              bNewSheet  == rPItem.bNewSheet );
 445 }
 446
 447 SfxPoolItem* ScPivotItem::Clone( SfxItemPool * ) const
 448 {
 449     return new ScPivotItem( *this );
 450 }
 451
 452 /**
 453  * Data for the Solver dialog
 454  */
 455 ScSolveItem::ScSolveItem( sal_uInt16                nWhichP,
 456                           const ScSolveParam*   pSolveData )
 457     :   SfxPoolItem ( nWhichP )
 458 {
 459     if ( pSolveData ) theSolveData = *pSolveData;
 460 }
 461
 462 ScSolveItem::ScSolveItem( const ScSolveItem& rItem )
 463     :   SfxPoolItem     ( rItem ),
 464         theSolveData    ( rItem.theSolveData )
 465 {
 466 }
 467
 468 ScSolveItem::~ScSolveItem()
 469 {
 470 }
 471
 472 bool ScSolveItem::operator==( const SfxPoolItem& rItem ) const
 473 {
 474     assert(SfxPoolItem::operator==(rItem));
 475
 476     const ScSolveItem& rPItem = static_cast<const ScSolveItem&>(rItem);
 477
 478     return ( theSolveData == rPItem.theSolveData );
 479 }
 480
 481 SfxPoolItem* ScSolveItem::Clone( SfxItemPool * ) const
 482 {
 483     return new ScSolveItem( *this );
 484 }
 485
 486 /**
 487  * Data for the TabOp dialog
 488  */
 489 ScTabOpItem::ScTabOpItem( sal_uInt16                nWhichP,
 490                           const ScTabOpParam*   pTabOpData )
 491     :   SfxPoolItem ( nWhichP )
 492 {
 493     if ( pTabOpData ) theTabOpData = *pTabOpData;
 494 }
 495
 496 ScTabOpItem::ScTabOpItem( const ScTabOpItem& rItem )
 497     :   SfxPoolItem     ( rItem ),
 498         theTabOpData    ( rItem.theTabOpData )
 499 {
 500 }
 501
 502 ScTabOpItem::~ScTabOpItem()
 503 {
 504 }
 505
 506 bool ScTabOpItem::operator==( const SfxPoolItem& rItem ) const
 507 {
 508     assert(SfxPoolItem::operator==(rItem));
 509
 510     const ScTabOpItem& rPItem = static_cast<const ScTabOpItem&>(rItem);
 511
 512     return ( theTabOpData == rPItem.theTabOpData );
 513 }
 514
 515 SfxPoolItem* ScTabOpItem::Clone( SfxItemPool * ) const
 516 {
 517     return new ScTabOpItem( *this );
 518 }
 519
 520 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */