1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2000, 2010 Oracle and/or its affiliates.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
#ifndef SC_TABLE_HXX
#define SC_TABLE_HXX
#include <vector>
#include <utility>
#include <tools/gen.hxx>
#include <tools/color.hxx>
#include <com/sun/star/uno/Sequence.hxx>
#include "column.hxx"
#include "sortparam.hxx"
#include "compressedarray.hxx"
#include "postit.hxx"
#include <set>
#include <map>
#include <boost/scoped_ptr.hpp>
#include <boost/noncopyable.hpp>
namespace utl {
class TextSearch;
}
namespace com { namespace sun { namespace star {
namespace sheet {
struct TablePageBreakData;
}
} } }
class SfxItemSet;
class SfxStyleSheetBase;
class SvxBoxInfoItem;
class SvxBoxItem;
class SvxSearchItem;
class ScAutoFormat;
class ScAutoFormatData;
class ScBaseCell;
class ScDocument;
class ScDrawLayer;
class ScEditDataArray;
class ScFormulaCell;
class ScOutlineTable;
class ScPrintSaverTab;
class ScProgress;
class ScRangeList;
class ScSheetEvents;
class ScSortInfoArray;
class ScStyleSheet;
class ScTableLink;
class ScTableProtection;
class ScUserListData;
struct RowInfo;
struct ScFunctionData;
struct ScLineFlags;
class CollatorWrapper;
class ScFlatUInt16RowSegments;
class ScFlatBoolRowSegments;
class ScFlatBoolColSegments;
struct ScSetStringParam;
struct ScColWidthParam;
struct ScColWidthParam;
class ScRangeName;
class ScDBData;
class ScTable : boost::noncopyable
{
private:
typedef ::std::vector< ScRange > ScRangeVec;
typedef ::std::pair< SCCOL, SCROW > ScAddress2D;
typedef ::std::vector< ScAddress2D > ScAddress2DVec;
ScColumn aCol[MAXCOLCOUNT];
rtl::OUString aName;
rtl::OUString aCodeName;
rtl::OUString aComment;
rtl::OUString aLinkDoc;
rtl::OUString aLinkFlt;
rtl::OUString aLinkOpt;
rtl::OUString aLinkTab;
sal_uLong nLinkRefreshDelay;
sal_uInt8 nLinkMode;
// page style template
rtl::OUString aPageStyle;
Size aPageSizeTwips; // size of the print-page
SCCOL nRepeatStartX; // repeating rows/columns
SCCOL nRepeatEndX; // REPEAT_NONE, if not used
SCROW nRepeatStartY;
SCROW nRepeatEndY;
boost::scoped_ptr<ScTableProtection> pTabProtection;
sal_uInt16* pColWidth;
boost::scoped_ptr<ScFlatUInt16RowSegments> mpRowHeights;
sal_uInt8* pColFlags;
ScBitMaskCompressedArray< SCROW, sal_uInt8>* pRowFlags;
boost::scoped_ptr<ScFlatBoolColSegments> mpHiddenCols;
boost::scoped_ptr<ScFlatBoolRowSegments> mpHiddenRows;
boost::scoped_ptr<ScFlatBoolColSegments> mpFilteredCols;
boost::scoped_ptr<ScFlatBoolRowSegments> mpFilteredRows;
::std::set<SCROW> maRowPageBreaks;
::std::set<SCROW> maRowManualBreaks;
::std::set<SCCOL> maColPageBreaks;
::std::set<SCCOL> maColManualBreaks;
ScOutlineTable* pOutlineTable;
ScSheetEvents* pSheetEvents;
mutable SCCOL nTableAreaX;
mutable SCROW nTableAreaY;
SCTAB nTab;
sal_uInt16 nRecalcLvl; // recursion level Size-Recalc
ScDocument* pDocument;
utl::TextSearch* pSearchText;
mutable rtl::OUString aUpperName; // #i62977# filled only on demand, reset in SetName
boost::scoped_ptr<ScAddress2DVec> mxUninitNotes;
// sort parameter to minimize stack size of quicksort
ScSortParam aSortParam;
CollatorWrapper* pSortCollator;
ScRangeVec aPrintRanges;
ScRange* pRepeatColRange;
ScRange* pRepeatRowRange;
sal_uInt16 nLockCount;
ScRangeList* pScenarioRanges;
Color aScenarioColor;
Color aTabBgColor;
sal_uInt16 nScenarioFlags;
ScDBData* pDBDataNoName;
mutable ScRangeName* mpRangeName;
ScNotes maNotes;
bool bScenario:1;
bool bLayoutRTL:1;
bool bLoadingRTL:1;
bool bPageSizeValid:1;
mutable bool bTableAreaValid:1;
bool bVisible:1;
bool bStreamValid:1;
bool bPendingRowHeights:1;
bool bCalcNotification:1;
bool bGlobalKeepQuery:1;
bool bPrintEntireSheet:1;
bool bActiveScenario:1;
bool mbPageBreaksValid:1;
friend class ScDocument; // for FillInfo
friend class ScDocumentIterator;
friend class ScValueIterator;
friend class ScHorizontalValueIterator;
friend class ScDBQueryDataIterator;
friend class ScCellIterator;
friend class ScQueryCellIterator;
friend class ScHorizontalCellIterator;
friend class ScHorizontalAttrIterator;
friend class ScDocAttrIterator;
friend class ScAttrRectIterator;
public:
ScTable( ScDocument* pDoc, SCTAB nNewTab, const rtl::OUString& rNewName,
bool bColInfo = true, bool bRowInfo = true );
~ScTable();
ScOutlineTable* GetOutlineTable() { return pOutlineTable; }
SCSIZE GetCellCount(SCCOL nCol) const;
sal_uLong GetCellCount() const;
sal_uLong GetWeightedCount() const;
sal_uLong GetCodeCount() const; // RPN code in formula
bool SetOutlineTable( const ScOutlineTable* pNewOutline );
void StartOutlineTable();
void DoAutoOutline( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow );
bool TestRemoveSubTotals( const ScSubTotalParam& rParam );
void RemoveSubTotals( ScSubTotalParam& rParam );
bool DoSubTotals( ScSubTotalParam& rParam );
const ScSheetEvents* GetSheetEvents() const { return pSheetEvents; }
void SetSheetEvents( const ScSheetEvents* pNew );
bool IsVisible() const { return bVisible; }
void SetVisible( bool bVis );
bool IsStreamValid() const { return bStreamValid; }
void SetStreamValid( bool bSet, bool bIgnoreLock = false );
bool IsPendingRowHeights() const { return bPendingRowHeights; }
void SetPendingRowHeights( bool bSet );
bool GetCalcNotification() const { return bCalcNotification; }
void SetCalcNotification( bool bSet );
bool IsLayoutRTL() const { return bLayoutRTL; }
bool IsLoadingRTL() const { return bLoadingRTL; }
void SetLayoutRTL( bool bSet );
void SetLoadingRTL( bool bSet );
bool IsScenario() const { return bScenario; }
void SetScenario( bool bFlag );
void GetScenarioComment( rtl::OUString& rComment) const { rComment = aComment; }
void SetScenarioComment( const rtl::OUString& rComment ) { aComment = rComment; }
const Color& GetScenarioColor() const { return aScenarioColor; }
void SetScenarioColor(const Color& rNew) { aScenarioColor = rNew; }
const Color& GetTabBgColor() const;
void SetTabBgColor(const Color& rColor);
sal_uInt16 GetScenarioFlags() const { return nScenarioFlags; }
void SetScenarioFlags(sal_uInt16 nNew) { nScenarioFlags = nNew; }
void SetActiveScenario(bool bSet) { bActiveScenario = bSet; }
bool IsActiveScenario() const { return bActiveScenario; }
sal_uInt8 GetLinkMode() const { return nLinkMode; }
bool IsLinked() const { return nLinkMode != SC_LINK_NONE; }
const rtl::OUString& GetLinkDoc() const { return aLinkDoc; }
const rtl::OUString& GetLinkFlt() const { return aLinkFlt; }
const rtl::OUString& GetLinkOpt() const { return aLinkOpt; }
const rtl::OUString& GetLinkTab() const { return aLinkTab; }
sal_uLong GetLinkRefreshDelay() const { return nLinkRefreshDelay; }
void SetLink( sal_uInt8 nMode, const String& rDoc, const String& rFlt,
const String& rOpt, const String& rTab, sal_uLong nRefreshDelay );
void GetName( rtl::OUString& rName ) const;
void SetName( const rtl::OUString& rNewName );
void SetAnonymousDBData(ScDBData* pDBData);
ScDBData* GetAnonymousDBData();
void GetCodeName( rtl::OUString& rName ) const { rName = aCodeName; }
void SetCodeName( const rtl::OUString& rNewName ) { aCodeName = rNewName; }
const rtl::OUString& GetUpperName() const;
const rtl::OUString& GetPageStyle() const { return aPageStyle; }
void SetPageStyle( const rtl::OUString& rName );
void PageStyleModified( const String& rNewName );
bool IsProtected() const;
void SetProtection(const ScTableProtection* pProtect);
ScTableProtection* GetProtection();
Size GetPageSize() const;
void SetPageSize( const Size& rSize );
void SetRepeatArea( SCCOL nStartCol, SCCOL nEndCol, SCROW nStartRow, SCROW nEndRow );
void RemoveAutoSpellObj();
void LockTable();
void UnlockTable();
bool IsBlockEditable( SCCOL nCol1, SCROW nRow1, SCCOL nCol2,
SCROW nRow2, bool* pOnlyNotBecauseOfMatrix = NULL ) const;
bool IsSelectionEditable( const ScMarkData& rMark,
bool* pOnlyNotBecauseOfMatrix = NULL ) const;
bool HasBlockMatrixFragment( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 ) const;
bool HasSelectionMatrixFragment( const ScMarkData& rMark ) const;
bool IsBlockEmpty( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, bool bIgnoreNotes = false ) const;
void PutCell( const ScAddress&, ScBaseCell* pCell );
void PutCell( SCCOL nCol, SCROW nRow, ScBaseCell* pCell );
void PutCell(SCCOL nCol, SCROW nRow, sal_uLong nFormatIndex, ScBaseCell* pCell);
// TRUE = numberformat set
bool SetString( SCCOL nCol, SCROW nRow, SCTAB nTab, const String& rString,
ScSetStringParam* pParam = NULL );
void SetValue( SCCOL nCol, SCROW nRow, const double& rVal );
void SetError( SCCOL nCol, SCROW nRow, sal_uInt16 nError);
void GetString( SCCOL nCol, SCROW nRow, rtl::OUString& rString );
void GetInputString( SCCOL nCol, SCROW nRow, rtl::OUString& rString ) const;
double GetValue( const ScAddress& rPos ) const
{
return ValidColRow(rPos.Col(),rPos.Row()) ?
aCol[rPos.Col()].GetValue( rPos.Row() ) :
0.0;
}
double GetValue( SCCOL nCol, SCROW nRow ) const;
void GetFormula( SCCOL nCol, SCROW nRow, rtl::OUString& rFormula );
CellType GetCellType( const ScAddress& rPos ) const
{
return ValidColRow(rPos.Col(),rPos.Row()) ?
aCol[rPos.Col()].GetCellType( rPos.Row() ) :
CELLTYPE_NONE;
}
CellType GetCellType( SCCOL nCol, SCROW nRow ) const;
ScBaseCell* GetCell( const ScAddress& rPos ) const
{
return ValidColRow(rPos.Col(),rPos.Row()) ?
aCol[rPos.Col()].GetCell( rPos.Row() ) :
NULL;
}
ScBaseCell* GetCell( SCCOL nCol, SCROW nRow ) const;
void GetFirstDataPos(SCCOL& rCol, SCROW& rRow) const;
void GetLastDataPos(SCCOL& rCol, SCROW& rRow) const;
ScNotes* GetNotes();
/** Creates the captions of all uninitialized cell notes.
@param bForced True = always create all captions, false = skip when Undo is disabled. */
void InitializeNoteCaptions( bool bForced = false );
bool TestInsertRow( SCCOL nStartCol, SCCOL nEndCol, SCSIZE nSize );
void InsertRow( SCCOL nStartCol, SCCOL nEndCol, SCROW nStartRow, SCSIZE nSize );
void DeleteRow( SCCOL nStartCol, SCCOL nEndCol, SCROW nStartRow, SCSIZE nSize,
bool* pUndoOutline = NULL );
bool TestInsertCol( SCROW nStartRow, SCROW nEndRow, SCSIZE nSize );
void InsertCol( SCCOL nStartCol, SCROW nStartRow, SCROW nEndRow, SCSIZE nSize );
void DeleteCol( SCCOL nStartCol, SCROW nStartRow, SCROW nEndRow, SCSIZE nSize,
bool* pUndoOutline = NULL );
void DeleteArea(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, sal_uInt16 nDelFlag);
void CopyToClip(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, ScTable* pTable,
bool bKeepScenarioFlags, bool bCloneNoteCaptions);
void CopyToClip(const ScRangeList& rRanges, ScTable* pTable,
bool bKeepScenarioFlags, bool bCloneNoteCaptions);
void CopyFromClip(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, SCsCOL nDx, SCsROW nDy,
sal_uInt16 nInsFlag, bool bAsLink, bool bSkipAttrForEmpty, ScTable* pTable);
void StartListeningInArea( SCCOL nCol1, SCROW nRow1,
SCCOL nCol2, SCROW nRow2 );
void BroadcastInArea( SCCOL nCol1, SCROW nRow1,
SCCOL nCol2, SCROW nRow2 );
void CopyToTable(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
sal_uInt16 nFlags, bool bMarked, ScTable* pDestTab,
const ScMarkData* pMarkData = NULL,
bool bAsLink = false, bool bColRowFlags = true);
void UndoToTable(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
sal_uInt16 nFlags, bool bMarked, ScTable* pDestTab,
const ScMarkData* pMarkData = NULL);
void TransposeClip( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
ScTable* pTransClip, sal_uInt16 nFlags, bool bAsLink );
// mark of this document
void MixMarked( const ScMarkData& rMark, sal_uInt16 nFunction,
bool bSkipEmpty, ScTable* pSrcTab );
void MixData( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
sal_uInt16 nFunction, bool bSkipEmpty, ScTable* pSrcTab );
void CopyData( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow,
SCCOL nDestCol, SCROW nDestRow, SCTAB nDestTab );
void CopyScenarioFrom( const ScTable* pSrcTab );
void CopyScenarioTo( ScTable* pDestTab ) const;
bool TestCopyScenarioTo( const ScTable* pDestTab ) const;
void MarkScenarioIn( ScMarkData& rMark, sal_uInt16 nNeededBits ) const;
bool HasScenarioRange( const ScRange& rRange ) const;
void InvalidateScenarioRanges();
const ScRangeList* GetScenarioRanges() const;
void CopyUpdated( const ScTable* pPosTab, ScTable* pDestTab ) const;
void InvalidateTableArea();
void InvalidatePageBreaks();
bool GetCellArea( SCCOL& rEndCol, SCROW& rEndRow ) const; // FALSE = empty
bool GetTableArea( SCCOL& rEndCol, SCROW& rEndRow ) const;
bool GetPrintArea( SCCOL& rEndCol, SCROW& rEndRow, bool bNotes, bool bFullFormattedArea = false ) const;
bool GetPrintAreaHor( SCROW nStartRow, SCROW nEndRow,
SCCOL& rEndCol, bool bNotes ) const;
bool GetPrintAreaVer( SCCOL nStartCol, SCCOL nEndCol,
SCROW& rEndRow, bool bNotes ) const;
bool GetDataStart( SCCOL& rStartCol, SCROW& rStartRow ) const;
void ExtendPrintArea( OutputDevice* pDev,
SCCOL nStartCol, SCROW nStartRow, SCCOL& rEndCol, SCROW nEndRow );
void GetDataArea( SCCOL& rStartCol, SCROW& rStartRow, SCCOL& rEndCol, SCROW& rEndRow,
bool bIncludeOld, bool bOnlyDown ) const;
bool ShrinkToUsedDataArea( bool& o_bShrunk, SCCOL& rStartCol, SCROW& rStartRow,
SCCOL& rEndCol, SCROW& rEndRow, bool bColumnsOnly ) const;
SCSIZE GetEmptyLinesInBlock( SCCOL nStartCol, SCROW nStartRow,
SCCOL nEndCol, SCROW nEndRow, ScDirection eDir );
void FindAreaPos( SCCOL& rCol, SCROW& rRow, SCsCOL nMovX, SCsROW nMovY );
void GetNextPos( SCCOL& rCol, SCROW& rRow, SCsCOL nMovX, SCsROW nMovY,
bool bMarked, bool bUnprotected, const ScMarkData& rMark );
void LimitChartArea( SCCOL& rStartCol, SCROW& rStartRow, SCCOL& rEndCol, SCROW& rEndRow );
bool HasData( SCCOL nCol, SCROW nRow ) const;
bool HasStringData( SCCOL nCol, SCROW nRow ) const;
bool HasValueData( SCCOL nCol, SCROW nRow ) const;
bool HasStringCells( SCCOL nStartCol, SCROW nStartRow,
SCCOL nEndCol, SCROW nEndRow ) const;
sal_uInt16 GetErrCode( const ScAddress& rPos ) const
{
return ValidColRow(rPos.Col(),rPos.Row()) ?
aCol[rPos.Col()].GetErrCode( rPos.Row() ) :
0;
}
void ResetChanged( const ScRange& rRange );
void SetDirty();
void SetDirty( const ScRange& );
void SetDirtyAfterLoad();
void SetDirtyVar();
void SetTableOpDirty( const ScRange& );
void CalcAll();
void CalcAfterLoad();
void CompileAll();
void CompileXML( ScProgress& rProgress );
void UpdateReference( UpdateRefMode eUpdateRefMode, SCCOL nCol1, SCROW nRow1, SCTAB nTab1,
SCCOL nCol2, SCROW nRow2, SCTAB nTab2,
SCsCOL nDx, SCsROW nDy, SCsTAB nDz,
ScDocument* pUndoDoc = NULL, bool bIncludeDraw = true, bool bUpdateNoteCaptionPos = true );
void UpdateDrawRef( UpdateRefMode eUpdateRefMode, SCCOL nCol1, SCROW nRow1, SCTAB nTab1,
SCCOL nCol2, SCROW nRow2, SCTAB nTab2,
SCsCOL nDx, SCsROW nDy, SCsTAB nDz, bool bUpdateNoteCaptionPos = true );
void UpdateTranspose( const ScRange& rSource, const ScAddress& rDest,
ScDocument* pUndoDoc );
void UpdateGrow( const ScRange& rArea, SCCOL nGrowX, SCROW nGrowY );
void UpdateInsertTab(SCTAB nTable, SCTAB nNewSheets = 1);
void UpdateDeleteTab( SCTAB nTable, bool bIsMove, ScTable* pRefUndo = NULL, SCTAB nSheets = 1 );
void UpdateMoveTab(SCTAB nOldPos, SCTAB nNewPos, SCTAB nTabNo, ScProgress* pProgress );
void UpdateCompile( bool bForceIfNameInUse = false );
void SetTabNo(SCTAB nNewTab);
void FindRangeNamesInUse(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
std::set<sal_uInt16>& rIndexes) const;
void ReplaceRangeNamesInUse(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
const ScRangeData::IndexMap& rMap );
void Fill( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
sal_uLong nFillCount, FillDir eFillDir, FillCmd eFillCmd, FillDateCmd eFillDateCmd,
double nStepValue, double nMaxValue);
String GetAutoFillPreview( const ScRange& rSource, SCCOL nEndX, SCROW nEndY );
void UpdateSelectionFunction( ScFunctionData& rData,
SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow,
const ScMarkData& rMark );
void AutoFormat( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow,
sal_uInt16 nFormatNo );
void GetAutoFormatData(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, ScAutoFormatData& rData);
void ScReplaceTabsStr( String& rStr, const String& rSrch, const String& rRepl ); // from sw
bool SearchAndReplace(
const SvxSearchItem& rSearchItem, SCCOL& rCol, SCROW& rRow, const ScMarkData& rMark,
ScRangeList& rMatchedRanges, rtl::OUString& rUndoStr, ScDocument* pUndoDoc);
void FindMaxRotCol( RowInfo* pRowInfo, SCSIZE nArrCount, SCCOL nX1, SCCOL nX2 );
void GetBorderLines( SCCOL nCol, SCROW nRow,
const ::editeng::SvxBorderLine** ppLeft, const ::editeng::SvxBorderLine** ppTop,
const ::editeng::SvxBorderLine** ppRight, const ::editeng::SvxBorderLine** ppBottom ) const;
bool HasAttrib( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, sal_uInt16 nMask ) const;
bool HasAttribSelection( const ScMarkData& rMark, sal_uInt16 nMask ) const;
bool ExtendMerge( SCCOL nStartCol, SCROW nStartRow,
SCCOL& rEndCol, SCROW& rEndRow,
bool bRefresh );
const SfxPoolItem* GetAttr( SCCOL nCol, SCROW nRow, sal_uInt16 nWhich ) const;
const ScPatternAttr* GetPattern( SCCOL nCol, SCROW nRow ) const;
const ScPatternAttr* GetMostUsedPattern( SCCOL nCol, SCROW nStartRow, SCROW nEndRow ) const;
sal_uLong GetNumberFormat( const ScAddress& rPos ) const
{
return ValidColRow(rPos.Col(),rPos.Row()) ?
aCol[rPos.Col()].GetNumberFormat( rPos.Row() ) :
0;
}
sal_uLong GetNumberFormat( SCCOL nCol, SCROW nRow ) const;
sal_uInt32 GetNumberFormat( SCCOL nCol, SCROW nStartRow, SCROW nEndRow ) const;
void MergeSelectionPattern( ScMergePatternState& rState,
const ScMarkData& rMark, bool bDeep ) const;
void MergePatternArea( ScMergePatternState& rState, SCCOL nCol1, SCROW nRow1,
SCCOL nCol2, SCROW nRow2, bool bDeep ) const;
void MergeBlockFrame( SvxBoxItem* pLineOuter, SvxBoxInfoItem* pLineInner,
ScLineFlags& rFlags,
SCCOL nStartCol, SCROW nStartRow,
SCCOL nEndCol, SCROW nEndRow ) const;
void ApplyBlockFrame( const SvxBoxItem* pLineOuter,
const SvxBoxInfoItem* pLineInner,
SCCOL nStartCol, SCROW nStartRow,
SCCOL nEndCol, SCROW nEndRow );
void ApplyAttr( SCCOL nCol, SCROW nRow, const SfxPoolItem& rAttr );
void ApplyPattern( SCCOL nCol, SCROW nRow, const ScPatternAttr& rAttr );
void ApplyPatternArea( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow,
const ScPatternAttr& rAttr, ScEditDataArray* pDataArray = NULL );
bool SetAttrEntries(SCCOL nCol, ScAttrEntry* pData, SCSIZE nSize);
void SetPattern( const ScAddress& rPos, const ScPatternAttr& rAttr, bool bPutToPool = false )
{
if (ValidColRow(rPos.Col(),rPos.Row()))
aCol[rPos.Col()].SetPattern( rPos.Row(), rAttr, bPutToPool );
}
void SetPattern( SCCOL nCol, SCROW nRow, const ScPatternAttr& rAttr, bool bPutToPool = false );
void ApplyPatternIfNumberformatIncompatible( const ScRange& rRange,
const ScPatternAttr& rPattern, short nNewType );
void ApplyStyle( SCCOL nCol, SCROW nRow, const ScStyleSheet& rStyle );
void ApplyStyleArea( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, const ScStyleSheet& rStyle );
void ApplySelectionStyle(const ScStyleSheet& rStyle, const ScMarkData& rMark);
void ApplySelectionLineStyle( const ScMarkData& rMark,
const ::editeng::SvxBorderLine* pLine, bool bColorOnly );
const ScStyleSheet* GetStyle( SCCOL nCol, SCROW nRow ) const;
const ScStyleSheet* GetSelectionStyle( const ScMarkData& rMark, bool& rFound ) const;
const ScStyleSheet* GetAreaStyle( bool& rFound, SCCOL nCol1, SCROW nRow1,
SCCOL nCol2, SCROW nRow2 ) const;
void StyleSheetChanged( const SfxStyleSheetBase* pStyleSheet, bool bRemoved,
OutputDevice* pDev,
double nPPTX, double nPPTY,
const Fraction& rZoomX, const Fraction& rZoomY );
bool IsStyleSheetUsed( const ScStyleSheet& rStyle, bool bGatherAllStyles ) const;
bool ApplyFlags( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, sal_Int16 nFlags );
bool RemoveFlags( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, sal_Int16 nFlags );
void ApplySelectionCache( SfxItemPoolCache* pCache, const ScMarkData& rMark, ScEditDataArray* pDataArray = NULL );
void DeleteSelection( sal_uInt16 nDelFlag, const ScMarkData& rMark );
void ClearSelectionItems( const sal_uInt16* pWhich, const ScMarkData& rMark );
void ChangeSelectionIndent( bool bIncrement, const ScMarkData& rMark );
const ScRange* GetRepeatColRange() const { return pRepeatColRange; }
const ScRange* GetRepeatRowRange() const { return pRepeatRowRange; }
void SetRepeatColRange( const ScRange* pNew );
void SetRepeatRowRange( const ScRange* pNew );
sal_uInt16 GetPrintRangeCount() const { return static_cast< sal_uInt16 >( aPrintRanges.size() ); }
const ScRange* GetPrintRange(sal_uInt16 nPos) const;
/** Returns true, if the sheet is always printed. */
bool IsPrintEntireSheet() const { return bPrintEntireSheet; }
/** Removes all print ranges. */
void ClearPrintRanges();
/** Adds a new print ranges. */
void AddPrintRange( const ScRange& rNew );
/** Marks the specified sheet to be printed completely. Deletes old print ranges! */
void SetPrintEntireSheet();
void FillPrintSaver( ScPrintSaverTab& rSaveTab ) const;
void RestorePrintRanges( const ScPrintSaverTab& rSaveTab );
sal_uInt16 GetOptimalColWidth( SCCOL nCol, OutputDevice* pDev,
double nPPTX, double nPPTY,
const Fraction& rZoomX, const Fraction& rZoomY,
bool bFormula, const ScMarkData* pMarkData,
const ScColWidthParam* pParam );
bool SetOptimalHeight( SCROW nStartRow, SCROW nEndRow, sal_uInt16 nExtra,
OutputDevice* pDev,
double nPPTX, double nPPTY,
const Fraction& rZoomX, const Fraction& rZoomY,
bool bForce,
ScProgress* pOuterProgress = NULL, sal_uLong nProgressStart = 0 );
void SetOptimalHeightOnly(SCROW nStartRow, SCROW nEndRow, sal_uInt16 nExtra,
OutputDevice* pDev,
double nPPTX, double nPPTY,
const Fraction& rZoomX, const Fraction& rZoomY,
bool bForce,
ScProgress* pOuterProgress = NULL, sal_uLong nProgressStart = 0 );
long GetNeededSize( SCCOL nCol, SCROW nRow,
OutputDevice* pDev,
double nPPTX, double nPPTY,
const Fraction& rZoomX, const Fraction& rZoomY,
bool bWidth, bool bTotalSize );
void SetColWidth( SCCOL nCol, sal_uInt16 nNewWidth );
void SetColWidthOnly( SCCOL nCol, sal_uInt16 nNewWidth );
void SetRowHeight( SCROW nRow, sal_uInt16 nNewHeight );
bool SetRowHeightRange( SCROW nStartRow, SCROW nEndRow, sal_uInt16 nNewHeight,
double nPPTX, double nPPTY );
/**
* Set specified row height to specified ranges. Don't check for drawing
* objects etc. Just set the row height. Nothing else.
*
* Note that setting a new row height via this function will not
* invalidate page breaks.
*/
void SetRowHeightOnly( SCROW nStartRow, SCROW nEndRow, sal_uInt16 nNewHeight );
// nPPT to test for modification
void SetManualHeight( SCROW nStartRow, SCROW nEndRow, bool bManual );
sal_uInt16 GetColWidth( SCCOL nCol ) const;
SC_DLLPUBLIC sal_uInt16 GetRowHeight( SCROW nRow, SCROW* pStartRow = NULL, SCROW* pEndRow = NULL, bool bHiddenAsZero = true ) const;
sal_uLong GetRowHeight( SCROW nStartRow, SCROW nEndRow ) const;
sal_uLong GetScaledRowHeight( SCROW nStartRow, SCROW nEndRow, double fScale ) const;
sal_uLong GetColOffset( SCCOL nCol ) const;
sal_uLong GetRowOffset( SCROW nRow ) const;
/**
* Get the last row such that the height of row 0 to the end row is as
* high as possible without exceeding the specified height value.
*
* @param nHeight maximum desired height
*
* @return SCROW last row of the range within specified height.
*/
SCROW GetRowForHeight(sal_uLong nHeight) const;
sal_uInt16 GetOriginalWidth( SCCOL nCol ) const;
sal_uInt16 GetOriginalHeight( SCROW nRow ) const;
sal_uInt16 GetCommonWidth( SCCOL nEndCol );
SCROW GetHiddenRowCount( SCROW nRow );
void ShowCol(SCCOL nCol, bool bShow);
void ShowRow(SCROW nRow, bool bShow);
void DBShowRow(SCROW nRow, bool bShow);
void ShowRows(SCROW nRow1, SCROW nRow2, bool bShow);
void DBShowRows(SCROW nRow1, SCROW nRow2, bool bShow);
void SetRowFlags( SCROW nRow, sal_uInt8 nNewFlags );
void SetRowFlags( SCROW nStartRow, SCROW nEndRow, sal_uInt8 nNewFlags );
/// @return the index of the last row with any set flags (auto-pagebreak is ignored).
SCROW GetLastFlaggedRow() const;
/// @return the index of the last changed column (flags and column width, auto pagebreak is ignored).
SCCOL GetLastChangedCol() const;
/// @return the index of the last changed row (flags and row height, auto pagebreak is ignored).
SCROW GetLastChangedRow() const;
bool IsDataFiltered() const;
sal_uInt8 GetColFlags( SCCOL nCol ) const;
sal_uInt8 GetRowFlags( SCROW nRow ) const;
const ScBitMaskCompressedArray< SCROW, sal_uInt8> * GetRowFlagsArray() const
{ return pRowFlags; }
bool UpdateOutlineCol( SCCOL nStartCol, SCCOL nEndCol, bool bShow );
bool UpdateOutlineRow( SCROW nStartRow, SCROW nEndRow, bool bShow );
void UpdatePageBreaks( const ScRange* pUserArea );
void RemoveManualBreaks();
bool HasManualBreaks() const;
void SetRowManualBreaks( const ::std::set<SCROW>& rBreaks );
void SetColManualBreaks( const ::std::set<SCCOL>& rBreaks );
void GetAllRowBreaks(::std::set<SCROW>& rBreaks, bool bPage, bool bManual) const;
void GetAllColBreaks(::std::set<SCCOL>& rBreaks, bool bPage, bool bManual) const;
bool HasRowPageBreak(SCROW nRow) const;
bool HasColPageBreak(SCCOL nCol) const;
bool HasRowManualBreak(SCROW nRow) const;
bool HasColManualBreak(SCCOL nCol) const;
/**
* Get the row position of the next manual break that occurs at or below
* specified row. When no more manual breaks are present at or below
* the specified row, -1 is returned.
*
* @param nRow row at which the search begins.
*
* @return SCROW next row position with manual page break, or -1 if no
* more manual breaks are present.
*/
SCROW GetNextManualBreak(SCROW nRow) const;
void RemoveRowPageBreaks(SCROW nStartRow, SCROW nEndRow);
void RemoveRowBreak(SCROW nRow, bool bPage, bool bManual);
void RemoveColBreak(SCCOL nCol, bool bPage, bool bManual);
void SetRowBreak(SCROW nRow, bool bPage, bool bManual);
void SetColBreak(SCCOL nCol, bool bPage, bool bManual);
::com::sun::star::uno::Sequence<
::com::sun::star::sheet::TablePageBreakData> GetRowBreakData() const;
bool RowHidden(SCROW nRow, SCROW* pFirstRow = NULL, SCROW* pLastRow = NULL) const;
bool RowHiddenLeaf(SCROW nRow, SCROW* pFirstRow = NULL, SCROW* pLastRow = NULL) const;
bool HasHiddenRows(SCROW nStartRow, SCROW nEndRow) const;
bool ColHidden(SCCOL nCol, SCCOL* pFirstCol = NULL, SCCOL* pLastCol = NULL) const;
bool SetRowHidden(SCROW nStartRow, SCROW nEndRow, bool bHidden);
bool SetColHidden(SCCOL nStartCol, SCCOL nEndCol, bool bHidden);
void CopyColHidden(ScTable& rTable, SCCOL nStartCol, SCCOL nEndCol);
void CopyRowHidden(ScTable& rTable, SCROW nStartRow, SCROW nEndRow);
void CopyRowHeight(ScTable& rSrcTable, SCROW nStartRow, SCROW nEndRow, SCROW nSrcOffset);
SCROW FirstVisibleRow(SCROW nStartRow, SCROW nEndRow) const;
SCROW LastVisibleRow(SCROW nStartRow, SCROW nEndRow) const;
SCROW CountVisibleRows(SCROW nStartRow, SCROW nEndRow) const;
sal_uInt32 GetTotalRowHeight(SCROW nStartRow, SCROW nEndRow) const;
SCCOLROW LastHiddenColRow(SCCOLROW nPos, bool bCol) const;
bool RowFiltered(SCROW nRow, SCROW* pFirstRow = NULL, SCROW* pLastRow = NULL) const;
bool ColFiltered(SCCOL nCol, SCCOL* pFirstCol = NULL, SCCOL* pLastCol = NULL) const;
bool HasFilteredRows(SCROW nStartRow, SCROW nEndRow) const;
void CopyColFiltered(ScTable& rTable, SCCOL nStartCol, SCCOL nEndCol);
void CopyRowFiltered(ScTable& rTable, SCROW nStartRow, SCROW nEndRow);
void SetRowFiltered(SCROW nStartRow, SCROW nEndRow, bool bFiltered);
void SetColFiltered(SCCOL nStartCol, SCCOL nEndCol, bool bFiltered);
SCROW FirstNonFilteredRow(SCROW nStartRow, SCROW nEndRow) const;
SCROW LastNonFilteredRow(SCROW nStartRow, SCROW nEndRow) const;
SCROW CountNonFilteredRows(SCROW nStartRow, SCROW nEndRow) const;
void SyncColRowFlags();
void StripHidden( SCCOL& rX1, SCROW& rY1, SCCOL& rX2, SCROW& rY2 );
void ExtendHidden( SCCOL& rX1, SCROW& rY1, SCCOL& rX2, SCROW& rY2 );
void Sort(const ScSortParam& rSortParam, bool bKeepQuery);
bool ValidQuery(
SCROW nRow, const ScQueryParam& rQueryParam, ScBaseCell* pCell = NULL,
bool* pbTestEqualCondition = NULL);
void TopTenQuery( ScQueryParam& );
SCSIZE Query(ScQueryParam& rQueryParam, bool bKeepSub);
bool CreateQueryParam(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, ScQueryParam& rQueryParam);
void GetFilterEntries(SCCOL nCol, SCROW nRow1, SCROW nRow2, std::vector<ScTypedStrData>& rStrings, bool& rHasDates);
void GetFilteredFilterEntries(SCCOL nCol, SCROW nRow1, SCROW nRow2, const ScQueryParam& rParam, std::vector<ScTypedStrData>& rStrings, bool& rHasDates );
bool GetDataEntries(SCCOL nCol, SCROW nRow, std::set<ScTypedStrData>& rStrings, bool bLimit);
bool HasColHeader( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow );
bool HasRowHeader( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow );
void DoColResize( SCCOL nCol1, SCCOL nCol2, SCSIZE nAdd );
sal_Int32 GetMaxStringLen( SCCOL nCol,
SCROW nRowStart, SCROW nRowEnd, CharSet eCharSet ) const;
xub_StrLen GetMaxNumberStringLen( sal_uInt16& nPrecision,
SCCOL nCol,
SCROW nRowStart, SCROW nRowEnd ) const;
void FindConditionalFormat( sal_uLong nKey, ScRangeList& rRanges );
void IncRecalcLevel();
void DecRecalcLevel( bool bUpdateNoteCaptionPos = true );
bool IsSortCollatorGlobal() const;
void InitSortCollator( const ScSortParam& rPar );
void DestroySortCollator();
void SetDrawPageSize( bool bResetStreamValid = true, bool bUpdateNoteCaptionPos = true );
void SetRangeName(ScRangeName* pNew);
ScRangeName* GetRangeName() const;
void UpdateMoveTab(SCTAB nOldPos,SCTAB nNewPos);
private:
void FillSeries( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
sal_uLong nFillCount, FillDir eFillDir, FillCmd eFillCmd,
FillDateCmd eFillDateCmd,
double nStepValue, double nMaxValue, sal_uInt16 nMinDigits,
bool bAttribs, ScProgress& rProgress );
void FillAnalyse( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
FillCmd& rCmd, FillDateCmd& rDateCmd,
double& rInc, sal_uInt16& rMinDigits,
ScUserListData*& rListData, sal_uInt16& rListIndex);
void FillAuto( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
sal_uLong nFillCount, FillDir eFillDir, ScProgress& rProgress );
bool ValidNextPos( SCCOL nCol, SCROW nRow, const ScMarkData& rMark,
bool bMarked, bool bUnprotected );
void AutoFormatArea(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow,
const ScPatternAttr& rAttr, sal_uInt16 nFormatNo);
void GetAutoFormatAttr(SCCOL nCol, SCROW nRow, sal_uInt16 nIndex, ScAutoFormatData& rData);
void GetAutoFormatFrame(SCCOL nCol, SCROW nRow, sal_uInt16 nFlags, sal_uInt16 nIndex, ScAutoFormatData& rData);
bool SearchCell(const SvxSearchItem& rSearchItem, SCCOL nCol, SCROW nRow,
const ScMarkData& rMark, rtl::OUString& rUndoStr, ScDocument* pUndoDoc);
bool Search(const SvxSearchItem& rSearchItem, SCCOL& rCol, SCROW& rRow,
const ScMarkData& rMark, rtl::OUString& rUndoStr, ScDocument* pUndoDoc);
bool SearchAll(const SvxSearchItem& rSearchItem, const ScMarkData& rMark,
ScRangeList& rMatchedRanges, rtl::OUString& rUndoStr, ScDocument* pUndoDoc);
bool Replace(const SvxSearchItem& rSearchItem, SCCOL& rCol, SCROW& rRow,
const ScMarkData& rMark, rtl::OUString& rUndoStr, ScDocument* pUndoDoc);
bool ReplaceAll(
const SvxSearchItem& rSearchItem, const ScMarkData& rMark, ScRangeList& rMatchedRanges,
rtl::OUString& rUndoStr, ScDocument* pUndoDoc);
bool SearchStyle(const SvxSearchItem& rSearchItem, SCCOL& rCol, SCROW& rRow,
const ScMarkData& rMark);
bool ReplaceStyle(const SvxSearchItem& rSearchItem, SCCOL& rCol, SCROW& rRow,
const ScMarkData& rMark, bool bIsUndo);
bool SearchAllStyle(
const SvxSearchItem& rSearchItem, const ScMarkData& rMark, ScRangeList& rMatchedRanges);
bool ReplaceAllStyle(
const SvxSearchItem& rSearchItem, const ScMarkData& rMark, ScRangeList& rMatchedRanges,
ScDocument* pUndoDoc);
bool SearchAndReplaceEmptyCells(
const SvxSearchItem& rSearchItem,
SCCOL& rCol, SCROW& rRow, const ScMarkData& rMark, ScRangeList& rMatchedRanges,
rtl::OUString& rUndoStr, ScDocument* pUndoDoc);
bool SearchRangeForEmptyCell(const ScRange& rRange,
const SvxSearchItem& rSearchItem, SCCOL& rCol, SCROW& rRow,
rtl::OUString& rUndoStr);
bool SearchRangeForAllEmptyCells(
const ScRange& rRange, const SvxSearchItem& rSearchItem,
ScRangeList& rMatchedRanges, rtl::OUString& rUndoStr, ScDocument* pUndoDoc);
// use the global sort parameter:
bool IsSorted(SCCOLROW nStart, SCCOLROW nEnd);
void DecoladeRow( ScSortInfoArray*, SCROW nRow1, SCROW nRow2 );
void SwapCol(SCCOL nCol1, SCCOL nCol2);
void SwapRow(SCROW nRow1, SCROW nRow2);
short CompareCell( sal_uInt16 nSort,
ScBaseCell* pCell1, SCCOL nCell1Col, SCROW nCell1Row,
ScBaseCell* pCell2, SCCOL nCell2Col, SCROW nCell2Row );
short Compare(SCCOLROW nIndex1, SCCOLROW nIndex2);
short Compare( ScSortInfoArray*, SCCOLROW nIndex1, SCCOLROW nIndex2);
ScSortInfoArray* CreateSortInfoArray( SCCOLROW nInd1, SCCOLROW nInd2 );
void QuickSort( ScSortInfoArray*, SCsCOLROW nLo, SCsCOLROW nHi);
void SortReorder( ScSortInfoArray*, ScProgress& );
bool CreateExcelQuery(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, ScQueryParam& rQueryParam);
bool CreateStarQuery(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, ScQueryParam& rQueryParam);
void GetUpperCellString(SCCOL nCol, SCROW nRow, rtl::OUString& rStr);
bool RefVisible(ScFormulaCell* pCell);
bool IsEmptyLine(SCROW nRow, SCCOL nStartCol, SCCOL nEndCol);
void IncDate(double& rVal, sal_uInt16& nDayOfMonth, double nStep, FillDateCmd eCmd);
void FillFormula(sal_uLong& nFormulaCounter, bool bFirst, ScFormulaCell* pSrcCell,
SCCOL nDestCol, SCROW nDestRow, bool bLast );
void UpdateInsertTabAbs(SCTAB nNewPos);
bool GetNextSpellingCell(SCCOL& rCol, SCROW& rRow, bool bInSel,
const ScMarkData& rMark) const;
bool GetNextMarkedCell( SCCOL& rCol, SCROW& rRow, const ScMarkData& rMark );
bool TestTabRefAbs(SCTAB nTable);
void CompileDBFormula();
void CompileDBFormula( bool bCreateFormulaString );
void CompileNameFormula( bool bCreateFormulaString );
void CompileColRowNameFormula();
void StartListening( const ScAddress& rAddress, SvtListener* pListener );
void EndListening( const ScAddress& rAddress, SvtListener* pListener );
void StartAllListeners();
void StartNeededListeners(); // only for cells where NeedsListening()==TRUE
void SetRelNameDirty();
void SetLoadingMedium(bool bLoading);
SCSIZE FillMaxRot( RowInfo* pRowInfo, SCSIZE nArrCount, SCCOL nX1, SCCOL nX2,
SCCOL nCol, SCROW nAttrRow1, SCROW nAttrRow2, SCSIZE nArrY,
const ScPatternAttr* pPattern, const SfxItemSet* pCondSet );
// idle calculation of OutputDevice text width for cell
// also invalidates script type, broadcasts for "calc as shown"
void InvalidateTextWidth( const ScAddress* pAdrFrom, const ScAddress* pAdrTo,
bool bNumFormatChanged, bool bBroadcast );
void SkipFilteredRows(SCROW& rRow, SCROW& rLastNonFilteredRow, bool bForward);
/**
* In case the cell text goes beyond the column width, move the max column
* position to the right. This is called from ExtendPrintArea.
*/
void MaybeAddExtraColumn(SCCOL& rCol, SCROW nRow, OutputDevice* pDev, double nPPTX, double nPPTY);
void CopyPrintRange(const ScTable& rTable);
/**
* Use this to iterate through non-empty visible cells in a single column.
*/
class VisibleDataCellIterator
{
public:
static SCROW ROW_NOT_FOUND;
explicit VisibleDataCellIterator(ScFlatBoolRowSegments& rRowSegs, ScColumn& rColumn);
~VisibleDataCellIterator();
/**
* Set the start row position. In case there is not visible data cell
* at the specified row position, it will move to the position of the
* first visible data cell below that point.
*
* @return First visible data cell if found, or NULL otherwise.
*/
ScBaseCell* reset(SCROW nRow);
/**
* Find the next visible data cell position.
*
* @return Next visible data cell if found, or NULL otherwise.
*/
ScBaseCell* next();
/**
* Get the current row position.
*
* @return Current row position, or ROW_NOT_FOUND if the iterator
* doesn't point to a valid data cell position.
*/
SCROW getRow() const;
private:
ScFlatBoolRowSegments& mrRowSegs;
ScColumn& mrColumn;
ScBaseCell* mpCell;
SCROW mnCurRow;
SCROW mnUBound;
};
};
#endif
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */