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