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 :
10 : #include <table.hxx>
11 : #include <clipcontext.hxx>
12 : #include <document.hxx>
13 : #include <clipparam.hxx>
14 : #include <bcaslot.hxx>
15 : #include <segmenttree.hxx>
16 : #include <sharedformula.hxx>
17 : #include <cellvalues.hxx>
18 :
19 17 : bool ScTable::IsMerged( SCCOL nCol, SCROW nRow ) const
20 : {
21 17 : if (!ValidCol(nCol))
22 0 : return false;
23 :
24 17 : return aCol[nCol].IsMerged(nRow);
25 : }
26 :
27 2 : void ScTable::DeleteBeforeCopyFromClip(
28 : sc::CopyFromClipContext& rCxt, const ScTable& rClipTab, sc::ColumnSpanSet& rBroadcastSpans )
29 : {
30 2 : sc::CopyFromClipContext::Range aRange = rCxt.getDestRange();
31 2 : if (!ValidCol(aRange.mnCol1) || !ValidCol(aRange.mnCol2))
32 2 : return;
33 :
34 : // Pass some stuff to the columns via context.
35 2 : rCxt.setTableProtected(IsProtected());
36 2 : rCxt.setCondFormatList(mpCondFormatList.get());
37 :
38 2 : ScRange aClipRange = rCxt.getClipDoc()->GetClipParam().getWholeRange();
39 2 : SCCOL nClipCol = aClipRange.aStart.Col();
40 : {
41 6 : for (SCCOL nCol = aRange.mnCol1; nCol <= aRange.mnCol2; ++nCol, ++nClipCol)
42 : {
43 4 : if (nClipCol > aClipRange.aEnd.Col())
44 0 : nClipCol = aClipRange.aStart.Col(); // loop through columns.
45 :
46 4 : const ScColumn& rClipCol = rClipTab.aCol[nClipCol];
47 4 : aCol[nCol].DeleteBeforeCopyFromClip(rCxt, rClipCol, rBroadcastSpans);
48 : }
49 : }
50 :
51 2 : SetStreamValid(false);
52 : }
53 :
54 12 : void ScTable::CopyOneCellFromClip(
55 : sc::CopyFromClipContext& rCxt, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 )
56 : {
57 12 : ScRange aSrcRange = rCxt.getClipDoc()->GetClipParam().getWholeRange();
58 12 : SCCOL nSrcColSize = aSrcRange.aEnd.Col() - aSrcRange.aStart.Col() + 1;
59 :
60 29 : for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
61 : {
62 17 : SCCOL nColOffset = nCol - nCol1;
63 17 : nColOffset = nColOffset % nSrcColSize;
64 : assert(nColOffset >= 0);
65 17 : aCol[nCol].CopyOneCellFromClip(rCxt, nRow1, nRow2, nColOffset);
66 : }
67 12 : }
68 :
69 0 : void ScTable::SetValues( SCCOL nCol, SCROW nRow, const std::vector<double>& rVals )
70 : {
71 0 : if (!ValidCol(nCol))
72 0 : return;
73 :
74 0 : aCol[nCol].SetValues(nRow, rVals);
75 : }
76 :
77 0 : void ScTable::TransferCellValuesTo( SCCOL nCol, SCROW nRow, size_t nLen, sc::CellValues& rDest )
78 : {
79 0 : if (!ValidCol(nCol))
80 0 : return;
81 :
82 0 : aCol[nCol].TransferCellValuesTo(nRow, nLen, rDest);
83 : }
84 :
85 0 : void ScTable::CopyCellValuesFrom( SCCOL nCol, SCROW nRow, const sc::CellValues& rSrc )
86 : {
87 0 : if (!ValidCol(nCol))
88 0 : return;
89 :
90 0 : aCol[nCol].CopyCellValuesFrom(nRow, rSrc);
91 : }
92 :
93 2 : void ScTable::ConvertFormulaToValue(
94 : sc::EndListeningContext& rCxt, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
95 : sc::TableValues* pUndo )
96 : {
97 2 : if (!ValidCol(nCol1) || !ValidCol(nCol2) || nCol1 > nCol2)
98 2 : return;
99 :
100 5 : for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
101 3 : aCol[nCol].ConvertFormulaToValue(rCxt, nRow1, nRow2, pUndo);
102 : }
103 :
104 4 : void ScTable::SwapNonEmpty(
105 : sc::TableValues& rValues, sc::StartListeningContext& rStartCxt, sc::EndListeningContext& rEndCxt )
106 : {
107 4 : const ScRange& rRange = rValues.getRange();
108 : assert(rRange.IsValid());
109 11 : for (SCCOL nCol = rRange.aStart.Col(); nCol <= rRange.aEnd.Col(); ++nCol)
110 7 : aCol[nCol].SwapNonEmpty(rValues, rStartCxt, rEndCxt);
111 4 : }
112 :
113 70 : void ScTable::PreprocessRangeNameUpdate(
114 : sc::EndListeningContext& rEndListenCxt, sc::CompileFormulaContext& rCompileCxt )
115 : {
116 71750 : for (SCCOL i = 0; i <= MAXCOL; ++i)
117 71680 : aCol[i].PreprocessRangeNameUpdate(rEndListenCxt, rCompileCxt);
118 70 : }
119 :
120 11 : void ScTable::PreprocessDBDataUpdate(
121 : sc::EndListeningContext& rEndListenCxt, sc::CompileFormulaContext& rCompileCxt )
122 : {
123 11275 : for (SCCOL i = 0; i <= MAXCOL; ++i)
124 11264 : aCol[i].PreprocessDBDataUpdate(rEndListenCxt, rCompileCxt);
125 11 : }
126 :
127 81 : void ScTable::CompileHybridFormula(
128 : sc::StartListeningContext& rStartListenCxt, sc::CompileFormulaContext& rCompileCxt )
129 : {
130 83025 : for (SCCOL i = 0; i <= MAXCOL; ++i)
131 82944 : aCol[i].CompileHybridFormula(rStartListenCxt, rCompileCxt);
132 81 : }
133 :
134 46 : void ScTable::UpdateScriptTypes( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 )
135 : {
136 46 : if (!ValidCol(nCol1) || !ValidCol(nCol2) || nCol1 > nCol2)
137 46 : return;
138 :
139 17533 : for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
140 17487 : aCol[nCol].UpdateScriptTypes(nRow1, nRow2);
141 : }
142 :
143 29 : bool ScTable::HasUniformRowHeight( SCROW nRow1, SCROW nRow2 ) const
144 : {
145 29 : if (!ValidRow(nRow1) || !ValidRow(nRow2) || nRow1 > nRow2)
146 0 : return false;
147 :
148 : ScFlatUInt16RowSegments::RangeData aData;
149 29 : if (!mpRowHeights->getRangeData(nRow1, aData))
150 : // Search failed.
151 0 : return false;
152 :
153 29 : return nRow2 <= aData.mnRow2;
154 : }
155 :
156 113 : void ScTable::SplitFormulaGroups( SCCOL nCol, std::vector<SCROW>& rRows )
157 : {
158 113 : if (!ValidCol(nCol))
159 113 : return;
160 :
161 113 : sc::SharedFormulaUtil::splitFormulaCellGroups(aCol[nCol].maCells, rRows);
162 : }
163 :
164 5 : void ScTable::UnshareFormulaCells( SCCOL nCol, std::vector<SCROW>& rRows )
165 : {
166 5 : if (!ValidCol(nCol))
167 5 : return;
168 :
169 5 : sc::SharedFormulaUtil::unshareFormulaCells(aCol[nCol].maCells, rRows);
170 : }
171 :
172 5 : void ScTable::RegroupFormulaCells( SCCOL nCol )
173 : {
174 5 : if (!ValidCol(nCol))
175 5 : return;
176 :
177 5 : aCol[nCol].RegroupFormulaCells();
178 : }
179 :
180 6 : void ScTable::CollectListeners(
181 : std::vector<SvtListener*>& rListeners, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 )
182 : {
183 6 : if (nCol2 < nCol1 || !ValidCol(nCol1) || !ValidCol(nCol2))
184 6 : return;
185 :
186 13 : for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
187 7 : aCol[nCol].CollectListeners(rListeners, nRow1, nRow2);
188 : }
189 :
190 0 : bool ScTable::HasFormulaCell( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 ) const
191 : {
192 0 : if (nCol2 < nCol1 || !ValidCol(nCol1) || !ValidCol(nCol2))
193 0 : return false;
194 :
195 0 : for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
196 0 : if (aCol[nCol].HasFormulaCell(nRow1, nRow2))
197 0 : return true;
198 :
199 0 : return false;
200 : }
201 :
202 36 : void ScTable::EndListeningIntersectedGroup(
203 : sc::EndListeningContext& rCxt, SCCOL nCol, SCROW nRow, std::vector<ScAddress>* pGroupPos )
204 : {
205 36 : if (!ValidCol(nCol))
206 36 : return;
207 :
208 36 : aCol[nCol].EndListeningIntersectedGroup(rCxt, nRow, pGroupPos);
209 : }
210 :
211 324 : void ScTable::EndListeningIntersectedGroups(
212 : sc::EndListeningContext& rCxt, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
213 : std::vector<ScAddress>* pGroupPos )
214 : {
215 324 : if (nCol2 < nCol1 || !ValidCol(nCol1) || !ValidCol(nCol2))
216 324 : return;
217 :
218 72945 : for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
219 72621 : aCol[nCol].EndListeningIntersectedGroups(rCxt, nRow1, nRow2, pGroupPos);
220 : }
221 :
222 6 : void ScTable::EndListeningGroup( sc::EndListeningContext& rCxt, SCCOL nCol, SCROW nRow )
223 : {
224 6 : if (!ValidCol(nCol))
225 6 : return;
226 :
227 6 : aCol[nCol].EndListeningGroup(rCxt, nRow);
228 : }
229 :
230 72 : void ScTable::SetNeedsListeningGroup( SCCOL nCol, SCROW nRow )
231 : {
232 72 : if (!ValidCol(nCol))
233 72 : return;
234 :
235 72 : aCol[nCol].SetNeedsListeningGroup(nRow);
236 156 : }
237 :
238 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
