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