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