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 "addressconverter.hxx"
21 :
22 : #include <com/sun/star/container/XIndexAccess.hpp>
23 : #include <com/sun/star/sheet/XCellRangeAddressable.hpp>
24 : #include <com/sun/star/sheet/XSpreadsheetDocument.hpp>
25 : #include <osl/diagnose.h>
26 : #include <rtl/strbuf.hxx>
27 : #include <rtl/ustrbuf.hxx>
28 : #include <oox/core/filterbase.hxx>
29 : #include <oox/helper/containerhelper.hxx>
30 : #include "biffinputstream.hxx"
31 :
32 : namespace oox {
33 : namespace xls {
34 :
35 : using namespace ::com::sun::star::container;
36 : using namespace ::com::sun::star::sheet;
37 : using namespace ::com::sun::star::table;
38 : using namespace ::com::sun::star::uno;
39 :
40 : namespace {
41 :
42 : //! TODO: this limit may change, is there a way to obtain it via API?
43 : const sal_Int16 API_MAXTAB = MAXTAB;
44 :
45 : const sal_Int32 OOX_MAXCOL = static_cast< sal_Int32 >( (1 << 14) - 1 );
46 : const sal_Int32 OOX_MAXROW = static_cast< sal_Int32 >( (1 << 20) - 1 );
47 : const sal_Int16 OOX_MAXTAB = static_cast< sal_Int16 >( (1 << 15) - 1 );
48 :
49 : const sal_Int32 BIFF2_MAXCOL = 255;
50 : const sal_Int32 BIFF2_MAXROW = 16383;
51 : const sal_Int16 BIFF2_MAXTAB = 0;
52 :
53 : const sal_Int32 BIFF3_MAXCOL = BIFF2_MAXCOL;
54 : const sal_Int32 BIFF3_MAXROW = BIFF2_MAXROW;
55 : const sal_Int16 BIFF3_MAXTAB = BIFF2_MAXTAB;
56 :
57 : const sal_Int32 BIFF4_MAXCOL = BIFF3_MAXCOL;
58 : const sal_Int32 BIFF4_MAXROW = BIFF3_MAXROW;
59 : const sal_Int16 BIFF4_MAXTAB = 32767;
60 :
61 : const sal_Int32 BIFF5_MAXCOL = BIFF4_MAXCOL;
62 : const sal_Int32 BIFF5_MAXROW = BIFF4_MAXROW;
63 : const sal_Int16 BIFF5_MAXTAB = BIFF4_MAXTAB;
64 :
65 : const sal_Int32 BIFF8_MAXCOL = BIFF5_MAXCOL;
66 : const sal_Int32 BIFF8_MAXROW = 65535;
67 : const sal_Int16 BIFF8_MAXTAB = BIFF5_MAXTAB;
68 :
69 : } // namespace
70 :
71 145 : CellAddress ApiCellRangeList::getBaseAddress() const
72 : {
73 145 : if( mvAddresses.empty() )
74 0 : return CellAddress();
75 145 : return CellAddress( mvAddresses.front().Sheet, mvAddresses.front().StartColumn, mvAddresses.front().StartRow );
76 : }
77 :
78 0 : com::sun::star::uno::Sequence< CellRangeAddress > ApiCellRangeList::toSequence() const
79 : {
80 0 : return ContainerHelper::vectorToSequence( mvAddresses );
81 : }
82 :
83 6 : void BinAddress::read( SequenceInputStream& rStrm )
84 : {
85 6 : mnRow = rStrm.readInt32();
86 6 : mnCol = rStrm.readInt32();
87 6 : }
88 :
89 0 : void BinAddress::read( BiffInputStream& rStrm, bool bCol16Bit, bool bRow32Bit )
90 : {
91 0 : mnRow = bRow32Bit ? rStrm.readInt32() : rStrm.readuInt16();
92 0 : mnCol = bCol16Bit ? rStrm.readuInt16() : rStrm.readuInt8();
93 0 : }
94 :
95 9 : void BinRange::read( SequenceInputStream& rStrm )
96 : {
97 9 : maFirst.mnRow = rStrm.readInt32();
98 9 : maLast.mnRow = rStrm.readInt32();
99 9 : maFirst.mnCol = rStrm.readInt32();
100 9 : maLast.mnCol = rStrm.readInt32();
101 9 : }
102 :
103 0 : void BinRange::read( BiffInputStream& rStrm, bool bCol16Bit, bool bRow32Bit )
104 : {
105 0 : maFirst.mnRow = bRow32Bit ? rStrm.readInt32() : rStrm.readuInt16();
106 0 : maLast.mnRow = bRow32Bit ? rStrm.readInt32() : rStrm.readuInt16();
107 0 : maFirst.mnCol = bCol16Bit ? rStrm.readuInt16() : rStrm.readuInt8();
108 0 : maLast.mnCol = bCol16Bit ? rStrm.readuInt16() : rStrm.readuInt8();
109 0 : }
110 :
111 3 : void BinRangeList::read( SequenceInputStream& rStrm )
112 : {
113 3 : sal_Int32 nCount = rStrm.readInt32();
114 3 : mvRanges.resize( getLimitedValue< size_t, sal_Int64 >( nCount, 0, rStrm.getRemaining() / 16 ) );
115 6 : for( ::std::vector< BinRange >::iterator aIt = mvRanges.begin(), aEnd = mvRanges.end(); aIt != aEnd; ++aIt )
116 3 : aIt->read( rStrm );
117 3 : }
118 :
119 145 : AddressConverter::AddressConverter( const WorkbookHelper& rHelper ) :
120 : WorkbookHelper( rHelper ),
121 : mbColOverflow( false ),
122 : mbRowOverflow( false ),
123 145 : mbTabOverflow( false )
124 : {
125 145 : maDConChars.set( 0xFFFF, '\x01', 0xFFFF, '\x02', 0xFFFF );
126 145 : switch( getFilterType() )
127 : {
128 : case FILTER_OOXML:
129 145 : initializeMaxPos( OOX_MAXTAB, OOX_MAXCOL, OOX_MAXROW );
130 145 : maLinkChars.set( 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF );
131 145 : break;
132 0 : case FILTER_BIFF: switch( getBiff() )
133 : {
134 : case BIFF2:
135 0 : initializeMaxPos( BIFF2_MAXTAB, BIFF2_MAXCOL, BIFF2_MAXROW );
136 0 : maLinkChars.set( 0xFFFF, '\x01', '\x02', 0xFFFF, 0xFFFF );
137 0 : break;
138 : case BIFF3:
139 0 : initializeMaxPos( BIFF3_MAXTAB, BIFF3_MAXCOL, BIFF3_MAXROW );
140 0 : maLinkChars.set( 0xFFFF, '\x01', '\x02', 0xFFFF, 0xFFFF );
141 0 : break;
142 : case BIFF4:
143 0 : initializeMaxPos( BIFF4_MAXTAB, BIFF4_MAXCOL, BIFF4_MAXROW );
144 0 : maLinkChars.set( 0xFFFF, '\x01', '\x02', 0xFFFF, '\x00' );
145 0 : break;
146 : case BIFF5:
147 0 : initializeMaxPos( BIFF5_MAXTAB, BIFF5_MAXCOL, BIFF5_MAXROW );
148 0 : maLinkChars.set( '\x04', '\x01', '\x02', '\x03', '\x00' );
149 0 : break;
150 : case BIFF8:
151 0 : initializeMaxPos( BIFF8_MAXTAB, BIFF8_MAXCOL, BIFF8_MAXROW );
152 0 : maLinkChars.set( '\x04', '\x01', 0xFFFF, '\x02', '\x00' );
153 0 : break;
154 : case BIFF_UNKNOWN:
155 0 : initializeMaxPos( 0, 0, 0 );
156 0 : maLinkChars.set( 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF );
157 0 : break;
158 : }
159 0 : break;
160 : case FILTER_UNKNOWN:
161 0 : initializeMaxPos( 0, 0, 0 );
162 0 : maLinkChars.set( 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF );
163 0 : break;
164 : }
165 145 : }
166 :
167 1389 : bool AddressConverter::parseOoxAddress2d(
168 : sal_Int32& ornColumn, sal_Int32& ornRow,
169 : const OUString& rString, sal_Int32 nStart, sal_Int32 nLength )
170 : {
171 1389 : ornColumn = ornRow = 0;
172 1389 : if( (nStart < 0) || (nStart >= rString.getLength()) || (nLength < 2) )
173 165 : return false;
174 :
175 1224 : const sal_Unicode* pcChar = rString.getStr() + nStart;
176 1224 : const sal_Unicode* pcEndChar = pcChar + ::std::min( nLength, rString.getLength() - nStart );
177 :
178 1224 : enum { STATE_COL, STATE_ROW } eState = STATE_COL;
179 6445 : while( pcChar < pcEndChar )
180 : {
181 3997 : sal_Unicode cChar = *pcChar;
182 3997 : switch( eState )
183 : {
184 : case STATE_COL:
185 : {
186 2448 : if( ('a' <= cChar) && (cChar <= 'z') )
187 0 : (cChar -= 'a') += 'A';
188 2448 : if( ('A' <= cChar) && (cChar <= 'Z') )
189 : {
190 : /* Return, if 1-based column index is already 6 characters
191 : long (12356631 is column index for column AAAAAA). */
192 1224 : if( ornColumn >= 12356631 )
193 0 : return false;
194 1224 : (ornColumn *= 26) += (cChar - 'A' + 1);
195 : }
196 1224 : else if( ornColumn > 0 )
197 : {
198 1224 : --pcChar;
199 1224 : eState = STATE_ROW;
200 : }
201 : else
202 0 : return false;
203 : }
204 2448 : break;
205 :
206 : case STATE_ROW:
207 : {
208 1549 : if( ('0' <= cChar) && (cChar <= '9') )
209 : {
210 : // return, if 1-based row is already 9 digits long
211 1549 : if( ornRow >= 100000000 )
212 0 : return false;
213 1549 : (ornRow *= 10) += (cChar - '0');
214 : }
215 : else
216 0 : return false;
217 : }
218 1549 : break;
219 : }
220 3997 : ++pcChar;
221 : }
222 :
223 1224 : --ornColumn;
224 1224 : --ornRow;
225 1224 : return (ornColumn >= 0) && (ornRow >= 0);
226 : }
227 :
228 7124 : bool AddressConverter::parseOoxAddress2d( sal_Int32& ornColumn, sal_Int32& ornRow, const char* pStr )
229 : {
230 7124 : ornColumn = ornRow = 0;
231 :
232 7124 : enum { STATE_COL, STATE_ROW } eState = STATE_COL;
233 :
234 40654 : while (*pStr)
235 : {
236 26406 : char cChar = *pStr;
237 26406 : switch( eState )
238 : {
239 : case STATE_COL:
240 : {
241 14246 : if( ('a' <= cChar) && (cChar <= 'z') )
242 0 : (cChar -= 'a') += 'A';
243 14246 : if( ('A' <= cChar) && (cChar <= 'Z') )
244 : {
245 : /* Return, if 1-based column index is already 6 characters
246 : long (12356631 is column index for column AAAAAA). */
247 7123 : if( ornColumn >= 12356631 )
248 0 : return false;
249 7123 : (ornColumn *= 26) += (cChar - 'A' + 1);
250 : }
251 7123 : else if( ornColumn > 0 )
252 : {
253 7123 : --pStr;
254 7123 : eState = STATE_ROW;
255 : }
256 : else
257 0 : return false;
258 : }
259 14246 : break;
260 :
261 : case STATE_ROW:
262 : {
263 12162 : if( ('0' <= cChar) && (cChar <= '9') )
264 : {
265 : // return, if 1-based row is already 9 digits long
266 12162 : if( ornRow >= 100000000 )
267 0 : return false;
268 12162 : (ornRow *= 10) += (cChar - '0');
269 : }
270 : else
271 0 : return false;
272 : }
273 12162 : break;
274 : }
275 26406 : ++pStr;
276 : }
277 :
278 7124 : --ornColumn;
279 7124 : --ornRow;
280 7124 : return (ornColumn >= 0) && (ornRow >= 0);
281 : }
282 :
283 2748 : bool AddressConverter::parseOoxRange2d(
284 : sal_Int32& ornStartColumn, sal_Int32& ornStartRow,
285 : sal_Int32& ornEndColumn, sal_Int32& ornEndRow,
286 : const OUString& rString, sal_Int32 nStart, sal_Int32 nLength )
287 : {
288 2748 : ornStartColumn = ornStartRow = ornEndColumn = ornEndRow = 0;
289 2748 : if( (nStart < 0) || (nStart >= rString.getLength()) || (nLength < 2) )
290 2124 : return false;
291 :
292 624 : sal_Int32 nEnd = nStart + ::std::min( nLength, rString.getLength() - nStart );
293 624 : sal_Int32 nColonPos = rString.indexOf( ':', nStart );
294 624 : if( (nStart < nColonPos) && (nColonPos + 1 < nEnd) )
295 : {
296 : return
297 598 : parseOoxAddress2d( ornStartColumn, ornStartRow, rString, nStart, nColonPos - nStart ) &&
298 598 : parseOoxAddress2d( ornEndColumn, ornEndRow, rString, nColonPos + 1, nLength - nColonPos - 1 );
299 : }
300 :
301 325 : if( parseOoxAddress2d( ornStartColumn, ornStartRow, rString, nStart, nLength ) )
302 : {
303 325 : ornEndColumn = ornStartColumn;
304 325 : ornEndRow = ornStartRow;
305 325 : return true;
306 : }
307 :
308 0 : return false;
309 : }
310 :
311 9249 : bool AddressConverter::checkCol( sal_Int32 nCol, bool bTrackOverflow )
312 : {
313 9249 : bool bValid = (0 <= nCol) && (nCol <= maMaxPos.Column);
314 9249 : if( !bValid && bTrackOverflow )
315 113 : mbColOverflow = true;
316 9249 : return bValid;
317 : }
318 :
319 10231 : bool AddressConverter::checkRow( sal_Int32 nRow, bool bTrackOverflow )
320 : {
321 10231 : bool bValid = (0 <= nRow) && (nRow <= maMaxPos.Row);
322 10231 : if( !bValid && bTrackOverflow )
323 0 : mbRowOverflow = true;
324 10231 : return bValid;
325 : }
326 :
327 8153 : bool AddressConverter::checkTab( sal_Int16 nSheet, bool bTrackOverflow )
328 : {
329 8153 : bool bValid = (0 <= nSheet) && (nSheet <= maMaxPos.Sheet);
330 8153 : if( !bValid && bTrackOverflow )
331 0 : mbTabOverflow |= (nSheet > maMaxPos.Sheet); // do not warn for deleted refs (-1)
332 8153 : return bValid;
333 : }
334 :
335 7580 : bool AddressConverter::checkCellAddress( const CellAddress& rAddress, bool bTrackOverflow )
336 : {
337 : return
338 15160 : checkTab( rAddress.Sheet, bTrackOverflow ) &&
339 15160 : checkCol( rAddress.Column, bTrackOverflow ) &&
340 15160 : checkRow( rAddress.Row, bTrackOverflow );
341 : }
342 :
343 466 : bool AddressConverter::convertToCellAddressUnchecked( CellAddress& orAddress,
344 : const OUString& rString, sal_Int16 nSheet )
345 : {
346 466 : orAddress.Sheet = nSheet;
347 466 : return parseOoxAddress2d( orAddress.Column, orAddress.Row, rString );
348 : }
349 :
350 7123 : bool AddressConverter::convertToCellAddressUnchecked(
351 : com::sun::star::table::CellAddress& orAddress, const char* pStr, sal_Int16 nSheet )
352 : {
353 7123 : orAddress.Sheet = nSheet;
354 7123 : return parseOoxAddress2d(orAddress.Column, orAddress.Row, pStr);
355 : }
356 :
357 466 : bool AddressConverter::convertToCellAddress( CellAddress& orAddress,
358 : const OUString& rString, sal_Int16 nSheet, bool bTrackOverflow )
359 : {
360 : return
361 767 : convertToCellAddressUnchecked( orAddress, rString, nSheet ) &&
362 767 : checkCellAddress( orAddress, bTrackOverflow );
363 : }
364 :
365 7123 : bool AddressConverter::convertToCellAddress(
366 : com::sun::star::table::CellAddress& rAddress,
367 : const char* pStr, sal_Int16 nSheet, bool bTrackOverflow )
368 : {
369 7123 : if (!convertToCellAddressUnchecked(rAddress, pStr, nSheet))
370 0 : return false;
371 :
372 7124 : return checkCellAddress(rAddress, bTrackOverflow);
373 : }
374 :
375 458 : CellAddress AddressConverter::createValidCellAddress(
376 : const OUString& rString, sal_Int16 nSheet, bool bTrackOverflow )
377 : {
378 458 : CellAddress aAddress;
379 458 : if( !convertToCellAddress( aAddress, rString, nSheet, bTrackOverflow ) )
380 : {
381 165 : aAddress.Sheet = getLimitedValue< sal_Int16, sal_Int16 >( nSheet, 0, maMaxPos.Sheet );
382 165 : aAddress.Column = ::std::min( aAddress.Column, maMaxPos.Column );
383 165 : aAddress.Row = ::std::min( aAddress.Row, maMaxPos.Row );
384 : }
385 458 : return aAddress;
386 : }
387 :
388 148 : void AddressConverter::convertToCellAddressUnchecked( CellAddress& orAddress,
389 : const BinAddress& rBinAddress, sal_Int16 nSheet )
390 : {
391 148 : orAddress.Sheet = nSheet;
392 148 : orAddress.Column = rBinAddress.mnCol;
393 148 : orAddress.Row = rBinAddress.mnRow;
394 148 : }
395 :
396 148 : bool AddressConverter::convertToCellAddress( CellAddress& orAddress,
397 : const BinAddress& rBinAddress, sal_Int16 nSheet, bool bTrackOverflow )
398 : {
399 148 : convertToCellAddressUnchecked( orAddress, rBinAddress, nSheet );
400 148 : return checkCellAddress( orAddress, bTrackOverflow );
401 : }
402 :
403 106 : CellAddress AddressConverter::createValidCellAddress(
404 : const BinAddress& rBinAddress, sal_Int16 nSheet, bool bTrackOverflow )
405 : {
406 106 : CellAddress aAddress;
407 106 : if( !convertToCellAddress( aAddress, rBinAddress, nSheet, bTrackOverflow ) )
408 : {
409 0 : aAddress.Sheet = getLimitedValue< sal_Int16, sal_Int16 >( nSheet, 0, maMaxPos.Sheet );
410 0 : aAddress.Column = getLimitedValue< sal_Int32, sal_Int32 >( rBinAddress.mnCol, 0, maMaxPos.Column );
411 0 : aAddress.Row = getLimitedValue< sal_Int32, sal_Int32 >( rBinAddress.mnRow, 0, maMaxPos.Row );
412 : }
413 106 : return aAddress;
414 : }
415 :
416 573 : bool AddressConverter::checkCellRange( const CellRangeAddress& rRange, bool bAllowOverflow, bool bTrackOverflow )
417 : {
418 : return
419 1146 : (checkCol( rRange.EndColumn, bTrackOverflow ) || bAllowOverflow) && // bAllowOverflow after checkCol to track overflow!
420 1146 : (checkRow( rRange.EndRow, bTrackOverflow ) || bAllowOverflow) && // bAllowOverflow after checkRow to track overflow!
421 1146 : checkTab( rRange.Sheet, bTrackOverflow ) &&
422 1719 : checkCol( rRange.StartColumn, bTrackOverflow ) &&
423 1146 : checkRow( rRange.StartRow, bTrackOverflow );
424 : }
425 :
426 569 : bool AddressConverter::validateCellRange( CellRangeAddress& orRange, bool bAllowOverflow, bool bTrackOverflow )
427 : {
428 569 : if( orRange.StartColumn > orRange.EndColumn )
429 0 : ::std::swap( orRange.StartColumn, orRange.EndColumn );
430 569 : if( orRange.StartRow > orRange.EndRow )
431 0 : ::std::swap( orRange.StartRow, orRange.EndRow );
432 569 : if( !checkCellRange( orRange, bAllowOverflow, bTrackOverflow ) )
433 0 : return false;
434 569 : if( orRange.EndColumn > maMaxPos.Column )
435 0 : orRange.EndColumn = maMaxPos.Column;
436 569 : if( orRange.EndRow > maMaxPos.Row )
437 0 : orRange.EndRow = maMaxPos.Row;
438 569 : return true;
439 : }
440 :
441 2748 : bool AddressConverter::convertToCellRangeUnchecked( CellRangeAddress& orRange,
442 : const OUString& rString, sal_Int16 nSheet )
443 : {
444 2748 : orRange.Sheet = nSheet;
445 2748 : return parseOoxRange2d( orRange.StartColumn, orRange.StartRow, orRange.EndColumn, orRange.EndRow, rString );
446 : }
447 :
448 2471 : bool AddressConverter::convertToCellRange( CellRangeAddress& orRange,
449 : const OUString& rString, sal_Int16 nSheet, bool bAllowOverflow, bool bTrackOverflow )
450 : {
451 : return
452 2818 : convertToCellRangeUnchecked( orRange, rString, nSheet ) &&
453 2818 : validateCellRange( orRange, bAllowOverflow, bTrackOverflow );
454 : }
455 :
456 9 : void AddressConverter::convertToCellRangeUnchecked( CellRangeAddress& orRange,
457 : const BinRange& rBinRange, sal_Int16 nSheet )
458 : {
459 9 : orRange.Sheet = nSheet;
460 9 : orRange.StartColumn = rBinRange.maFirst.mnCol;
461 9 : orRange.StartRow = rBinRange.maFirst.mnRow;
462 9 : orRange.EndColumn = rBinRange.maLast.mnCol;
463 9 : orRange.EndRow = rBinRange.maLast.mnRow;
464 9 : }
465 :
466 5 : bool AddressConverter::convertToCellRange( CellRangeAddress& orRange,
467 : const BinRange& rBinRange, sal_Int16 nSheet, bool bAllowOverflow, bool bTrackOverflow )
468 : {
469 5 : convertToCellRangeUnchecked( orRange, rBinRange, nSheet );
470 5 : return validateCellRange( orRange, bAllowOverflow, bTrackOverflow );
471 : }
472 :
473 0 : void AddressConverter::validateCellRangeList( ApiCellRangeList& orRanges, bool bTrackOverflow )
474 : {
475 0 : for( size_t nIndex = orRanges.size(); nIndex > 0; --nIndex )
476 0 : if( !validateCellRange( orRanges[ nIndex - 1 ], true, bTrackOverflow ) )
477 0 : orRanges.erase( orRanges.begin() + nIndex - 1 );
478 0 : }
479 :
480 264 : void AddressConverter::convertToCellRangeList( ApiCellRangeList& orRanges,
481 : const OUString& rString, sal_Int16 nSheet, bool bTrackOverflow )
482 : {
483 264 : sal_Int32 nPos = 0;
484 264 : sal_Int32 nLen = rString.getLength();
485 264 : CellRangeAddress aRange;
486 792 : while( (0 <= nPos) && (nPos < nLen) )
487 : {
488 264 : OUString aToken = rString.getToken( 0, ' ', nPos );
489 264 : if( !aToken.isEmpty() && convertToCellRange( aRange, aToken, nSheet, true, bTrackOverflow ) )
490 264 : orRanges.push_back( aRange );
491 264 : }
492 264 : }
493 :
494 3 : void AddressConverter::convertToCellRangeList( ApiCellRangeList& orRanges,
495 : const BinRangeList& rBinRanges, sal_Int16 nSheet, bool bTrackOverflow )
496 : {
497 3 : CellRangeAddress aRange;
498 6 : for( ::std::vector< BinRange >::const_iterator aIt = rBinRanges.begin(), aEnd = rBinRanges.end(); aIt != aEnd; ++aIt )
499 3 : if( convertToCellRange( aRange, *aIt, nSheet, true, bTrackOverflow ) )
500 3 : orRanges.push_back( aRange );
501 3 : }
502 :
503 : // private --------------------------------------------------------------------
504 :
505 290 : void AddressConverter::ControlCharacters::set(
506 : sal_Unicode cThisWorkbook, sal_Unicode cExternal,
507 : sal_Unicode cThisSheet, sal_Unicode cInternal, sal_Unicode cSameSheet )
508 : {
509 290 : mcThisWorkbook = cThisWorkbook;
510 290 : mcExternal = cExternal;
511 290 : mcThisSheet = cThisSheet;
512 290 : mcInternal = cInternal;
513 290 : mcSameSheet = cSameSheet;
514 290 : }
515 :
516 145 : void AddressConverter::initializeMaxPos(
517 : sal_Int16 nMaxXlsTab, sal_Int32 nMaxXlsCol, sal_Int32 nMaxXlsRow )
518 : {
519 145 : maMaxXlsPos.Sheet = nMaxXlsTab;
520 145 : maMaxXlsPos.Column = nMaxXlsCol;
521 145 : maMaxXlsPos.Row = nMaxXlsRow;
522 :
523 : // maximum cell position in Calc
524 : try
525 : {
526 145 : Reference< XIndexAccess > xSheetsIA( getDocument()->getSheets(), UNO_QUERY_THROW );
527 290 : Reference< XCellRangeAddressable > xAddressable( xSheetsIA->getByIndex( 0 ), UNO_QUERY_THROW );
528 145 : CellRangeAddress aRange = xAddressable->getRangeAddress();
529 145 : maMaxApiPos = CellAddress( API_MAXTAB, aRange.EndColumn, aRange.EndRow );
530 290 : maMaxPos = getBaseFilter().isImportFilter() ? maMaxApiPos : maMaxXlsPos;
531 : }
532 0 : catch( Exception& )
533 : {
534 : OSL_FAIL( "AddressConverter::AddressConverter - cannot get sheet limits" );
535 : }
536 145 : }
537 :
538 : } // namespace xls
539 30 : } // namespace oox
540 :
541 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
