LibreOffice Module sc (master) 1
impop.cxx
Go to the documentation of this file.
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 <memory>
21#include <imp_op.hxx>
22
24
25#include <scitems.hxx>
26
27#include <o3tl/safeint.hxx>
28#include <sfx2/docfile.hxx>
29#include <svx/svxids.hrc>
30#include <svl/numformat.hxx>
32#include <sal/log.hxx>
33
34#include <sfx2/objsh.hxx>
35#include <tools/urlobj.hxx>
36#include <docuno.hxx>
37
38#include <formulacell.hxx>
39#include <document.hxx>
40#include <globstr.hrc>
41#include <scresid.hxx>
42#include <global.hxx>
43#include <olinetab.hxx>
44#include <stlpool.hxx>
45#include <viewopti.hxx>
46#include <docoptio.hxx>
47#include <scextopt.hxx>
48#include <unonames.hxx>
49#include <paramisc.hxx>
50#include <colrowst.hxx>
51#include <otlnbuff.hxx>
52#include <xistyle.hxx>
53
54#include <namebuff.hxx>
55#include <xltools.hxx>
56#include <xltable.hxx>
57#include <xltracer.hxx>
58#include <xihelper.hxx>
59#include <xipage.hxx>
60#include <xiview.hxx>
61#include <xiescher.hxx>
62#include <xicontent.hxx>
63
64#include <excform.hxx>
65#include <documentimport.hxx>
66
67#if defined(_WIN32)
68#include <math.h>
69#endif
70
71using namespace ::com::sun::star;
72
73ImportTyp::ImportTyp(ScDocument& rDoc, rtl_TextEncoding eQ)
74 : eQuellChar(eQ)
75 , rD(rDoc)
76
77{
78}
79
81{
82}
83
85 ImportTyp( rImpData.mrDoc, rImpData.meTextEnc ),
86 XclImpRoot( rImpData ),
87 maStrm( rStrm, GetRoot() ),
88 aIn( maStrm ),
89 maScOleSize( ScAddress::INITIALIZE_INVALID ),
90 pColOutlineBuff(nullptr),
91 pRowOutlineBuff(nullptr),
92 pColRowBuff(nullptr),
93 mpLastFormula(nullptr),
94 mnLastRefIdx( 0 ),
95 mnIxfeIndex( 0 ),
96 mnLastRecId(0),
97 mbBiff2HasXfs(false),
98 mbBiff2HasXfsValid(false),
99 mbFuzzing(utl::ConfigManager::IsFuzzing())
100{
101 nBdshtTab = 0;
102
103 // fill in root data - after new's without root as parameter
104 pExcRoot = &GetOldRoot();
105 pExcRoot->pIR = this; // ExcRoot -> XclImpRoot
107 pExcRoot->pExtSheetBuff.reset( new ExtSheetBuffer( pExcRoot ) ); //&aExtSheetBuff;
108 pExcRoot->pShrfmlaBuff.reset( new SharedFormulaBuffer( pExcRoot ) ); //&aShrfrmlaBuff;
109 pExcRoot->pExtNameBuff.reset( new ExtNameBuff ( *this ) );
110
112
113 // from Biff8 on
114 pFormConv.reset(new ExcelToSc( GetRoot() ));
116
117 bTabTruncated = false;
118
119 // Excel document per Default on 31.12.1899, accords to Excel settings with 1.1.1900
121 aOpt.SetDate( 30, 12, 1899 );
122 rD.SetDocOptions( aOpt );
123 rD.GetFormatTable()->ChangeNullDate( 30, 12, 1899 );
124
125 ScDocOptions aDocOpt( rD.GetDocOptions() );
126 aDocOpt.SetIgnoreCase( true ); // always in Excel
127 aDocOpt.SetFormulaRegexEnabled( false ); // regular expressions? what's that?
128 aDocOpt.SetFormulaWildcardsEnabled( true ); // Excel uses wildcard expressions
129 aDocOpt.SetLookUpColRowNames( false ); // default: no natural language refs
130 rD.SetDocOptions( aDocOpt );
131}
132
134{
136
137 pOutlineListBuffer.reset();
138
139 pFormConv.reset();
140}
141
142void ImportExcel::SetLastFormula( SCCOL nCol, SCROW nRow, double fVal, sal_uInt16 nXF, ScFormulaCell* pCell )
143{
144 LastFormulaMapType::iterator it = maLastFormulaCells.find(nCol);
145 if (it == maLastFormulaCells.end())
146 {
147 std::pair<LastFormulaMapType::iterator, bool> r =
148 maLastFormulaCells.emplace(nCol, LastFormula());
149 it = r.first;
150 }
151
152 it->second.mnCol = nCol;
153 it->second.mnRow = nRow;
154 it->second.mpCell = pCell;
155 it->second.mfValue = fVal;
156 it->second.mnXF = nXF;
157
158 mpLastFormula = &it->second;
159}
160
162{
163 sal_uInt16 nRecommendReadOnly, nPasswordHash;
164 nRecommendReadOnly = maStrm.ReaduInt16();
165 nPasswordHash = maStrm.ReaduInt16();
166
167 if((nRecommendReadOnly == 0) && (nPasswordHash == 0))
168 return;
169
170 if( SfxItemSet* pItemSet = GetMedium().GetItemSet() )
171 pItemSet->Put( SfxBoolItem( SID_DOC_READONLY, true ) );
172
173 if( SfxObjectShell* pShell = GetDocShell() )
174 {
175 if( nRecommendReadOnly != 0 )
176 pShell->SetLoadReadonly( true );
177 if( nPasswordHash != 0 )
178 pShell->SetModifyPasswordHash( nPasswordHash );
179 }
180}
181
182sal_uInt16 ImportExcel::ReadXFIndex( const ScAddress& rScPos, bool bBiff2 )
183{
184 sal_uInt16 nXFIdx = 0;
185 if( bBiff2 )
186 {
187 /* #i71453# On first call, check if the file contains XF records (by
188 trying to access the first XF with index 0). If there are no XFs,
189 the explicit formatting information contained in each cell record
190 will be used instead. */
191 if( !mbBiff2HasXfsValid )
192 {
193 mbBiff2HasXfsValid = true;
194 mbBiff2HasXfs = GetXFBuffer().GetXF( 0 ) != nullptr;
195 }
196 // read formatting information (includes the XF identifier)
197 sal_uInt8 nFlags1, nFlags2, nFlags3;
198 nFlags1 = maStrm.ReaduInt8();
199 nFlags2 = maStrm.ReaduInt8();
200 nFlags3 = maStrm.ReaduInt8();
201 /* If the file contains XFs, extract and set the XF identifier,
202 otherwise get the explicit formatting. */
203 if( mbBiff2HasXfs )
204 {
205 nXFIdx = ::extract_value< sal_uInt16 >( nFlags1, 0, 6 );
206 /* If the identifier is equal to 63, then the real identifier is
207 contained in the preceding IXFE record (stored in mnBiff2XfId). */
208 if( nXFIdx == 63 )
209 nXFIdx = mnIxfeIndex;
210 }
211 else
212 {
213 /* Let the XclImpXF class do the conversion of the imported
214 formatting. The XF buffer is empty, therefore will not do any
215 conversion based on the XF index later on. */
216 XclImpXF::ApplyPatternForBiff2CellFormat( GetRoot(), rScPos, nFlags1, nFlags2, nFlags3 );
217 }
218 }
219 else
220 nXFIdx = aIn.ReaduInt16();
221 return nXFIdx;
222}
223
225{
226 XclRange aXclUsedArea;
227 if( (maStrm.GetRecId() == EXC_ID2_DIMENSIONS) || (GetBiff() <= EXC_BIFF5) )
228 {
229 maStrm >> aXclUsedArea;
230 if( (aXclUsedArea.GetColCount() > 1) && (aXclUsedArea.GetRowCount() > 1) )
231 {
232 // Excel stores first unused row/column index
233 --aXclUsedArea.maLast.mnCol;
234 --aXclUsedArea.maLast.mnRow;
235 // create the Calc range
236 SCTAB nScTab = GetCurrScTab();
238 GetAddressConverter().ConvertRange( rScUsedArea, aXclUsedArea, nScTab, nScTab, false );
239 // if any error occurs in ConvertRange(), rScUsedArea keeps untouched
240 }
241 }
242 else
243 {
244 sal_uInt32 nXclRow1 = 0, nXclRow2 = 0;
245 nXclRow1 = maStrm.ReaduInt32();
246 nXclRow2 = maStrm.ReaduInt32();
247 aXclUsedArea.maFirst.mnCol = maStrm.ReaduInt16();
248 aXclUsedArea.maLast.mnCol = maStrm.ReaduInt16();
249 if( (nXclRow1 < nXclRow2) && (aXclUsedArea.GetColCount() > 1) &&
250 (nXclRow1 <= o3tl::make_unsigned( GetScMaxPos().Row() )) )
251 {
252 // Excel stores first unused row/column index
253 --nXclRow2;
254 --aXclUsedArea.maLast.mnCol;
255 // convert row indexes to 16-bit values
256 aXclUsedArea.maFirst.mnRow = static_cast< sal_uInt16 >( nXclRow1 );
257 aXclUsedArea.maLast.mnRow = limit_cast< sal_uInt16 >( nXclRow2, aXclUsedArea.maFirst.mnRow, SAL_MAX_UINT16 );
258 // create the Calc range
259 SCTAB nScTab = GetCurrScTab();
261 GetAddressConverter().ConvertRange( rScUsedArea, aXclUsedArea, nScTab, nScTab, false );
262 // if any error occurs in ConvertRange(), rScUsedArea keeps untouched
263 }
264 }
265}
266
268{
269 XclAddress aXclPos;
270 aIn >> aXclPos;
271
273 if( GetAddressConverter().ConvertAddress( aScPos, aXclPos, GetCurrScTab(), true ) )
274 {
275 sal_uInt16 nXFIdx = ReadXFIndex( aScPos, maStrm.GetRecId() == EXC_ID2_BLANK );
276
277 GetXFRangeBuffer().SetBlankXF( aScPos, nXFIdx );
278 }
279}
280
282{
283 XclAddress aXclPos;
284 maStrm >> aXclPos;
285
287 if( GetAddressConverter().ConvertAddress( aScPos, aXclPos, GetCurrScTab(), true ) )
288 {
289 sal_uInt16 nXFIdx = ReadXFIndex( aScPos, true );
290 sal_uInt16 nValue;
292
293 GetXFRangeBuffer().SetXF( aScPos, nXFIdx );
295 }
296}
297
299{
300 XclAddress aXclPos;
301 maStrm >> aXclPos;
302
304 if( GetAddressConverter().ConvertAddress( aScPos, aXclPos, GetCurrScTab(), true ) )
305 {
306 sal_uInt16 nXFIdx = ReadXFIndex( aScPos, maStrm.GetRecId() == EXC_ID2_NUMBER );
307 double fValue;
308 fValue = maStrm.ReadDouble();
309
310 GetXFRangeBuffer().SetXF( aScPos, nXFIdx );
311 GetDocImport().setNumericCell(aScPos, fValue);
312 }
313}
314
316{
317 XclAddress aXclPos;
318 maStrm >> aXclPos;
319
321 if( !GetAddressConverter().ConvertAddress( aScPos, aXclPos, GetCurrScTab(), true ) )
322 return;
323
324 /* Record ID BIFF XF type String type
325 0x0004 2-7 3 byte 8-bit length, byte string
326 0x0004 8 3 byte 16-bit length, unicode string
327 0x0204 2-7 2 byte 16-bit length, byte string
328 0x0204 8 2 byte 16-bit length, unicode string */
329 bool bBiff2 = maStrm.GetRecId() == EXC_ID2_LABEL;
330 sal_uInt16 nXFIdx = ReadXFIndex( aScPos, bBiff2 );
332 XclImpString aString;
333
334 // #i63105# use text encoding from FONT record
335 rtl_TextEncoding eOldTextEnc = GetTextEncoding();
336 if( const XclImpFont* pFont = GetXFBuffer().GetFont( nXFIdx ) )
337 SetTextEncoding( pFont->GetFontEncoding() );
338 aString.Read( maStrm, nFlags );
339 SetTextEncoding( eOldTextEnc );
340
341 GetXFRangeBuffer().SetXF( aScPos, nXFIdx );
342 XclImpStringHelper::SetToDocument(GetDocImport(), aScPos, GetRoot(), aString, nXFIdx);
343}
344
346{
347 XclAddress aXclPos;
348 maStrm >> aXclPos;
349
351 if( !GetAddressConverter().ConvertAddress( aScPos, aXclPos, GetCurrScTab(), true ) )
352 return;
353
354 sal_uInt16 nXFIdx = ReadXFIndex( aScPos, maStrm.GetRecId() == EXC_ID2_BOOLERR );
358
359 if( nType == EXC_BOOLERR_BOOL )
360 GetXFRangeBuffer().SetBoolXF( aScPos, nXFIdx );
361 else
362 GetXFRangeBuffer().SetXF( aScPos, nXFIdx );
363
364 double fValue;
365 std::unique_ptr<ScTokenArray> pScTokArr = ErrorToFormula( nType != EXC_BOOLERR_BOOL, nValue, fValue );
366 ScFormulaCell* pCell = pScTokArr
367 ? new ScFormulaCell(rD, aScPos, std::move(pScTokArr))
368 : new ScFormulaCell(rD, aScPos);
369 pCell->SetHybridDouble( fValue );
370 GetDocImport().setFormulaCell(aScPos, pCell);
371}
372
374{
375 XclAddress aXclPos;
376 maStrm >> aXclPos;
377
379 if( GetAddressConverter().ConvertAddress( aScPos, aXclPos, GetCurrScTab(), true ) )
380 {
381 sal_uInt16 nXFIdx = ReadXFIndex( aScPos, false );
382 sal_Int32 nRk;
383 nRk = maStrm.ReadInt32();
384
385 GetXFRangeBuffer().SetXF( aScPos, nXFIdx );
387 }
388}
389
391{
393}
394
396{
397 sal_uInt16 nRow, nRowHeight;
398
399 nRow = aIn.ReaduInt16();
400 aIn.Ignore( 4 );
401
402 if( !GetRoot().GetDoc().ValidRow( nRow ) )
403 return;
404
405 nRowHeight = aIn.ReaduInt16(); // specify direct in Twips
406 aIn.Ignore( 2 );
407
408 if( GetBiff() == EXC_BIFF2 )
409 {// -------------------- BIFF2
410 pColRowBuff->SetHeight( nRow, nRowHeight );
411 }
412 else
413 {// -------------------- BIFF5
414 sal_uInt16 nGrbit;
415
416 aIn.Ignore( 2 ); // reserved
417 nGrbit = aIn.ReaduInt16();
418
419 sal_uInt8 nLevel = ::extract_value< sal_uInt8 >( nGrbit, 0, 3 );
420 pRowOutlineBuff->SetLevel( nRow, nLevel, ::get_flag( nGrbit, EXC_ROW_COLLAPSED ) );
421 pColRowBuff->SetRowSettings( nRow, nRowHeight, nGrbit );
422 }
423}
424
426{
427 sal_uInt16 nSubType;
429 maStrm.Ignore( 2 );
430 nSubType = maStrm.ReaduInt16();
431
432 if( nSubType == 0x0020 ) // Chart
434 else if( nSubType == 0x0040 ) // Macro
436 else // #i51490# Excel interprets invalid indexes as worksheet
438}
439
441{
442 // POST: cannot be called after an invalid table!
443 EndSheet();
444 IncCurrScTab();
445}
446
448{
449 if (GetRoot().GetBiff() != EXC_BIFF8)
450 return;
451
453}
454
456{
457 OUString aUrl, aTabName;
458 bool bSameWorkBook;
459 OUString aEncodedUrl( aIn.ReadByteString( false ) );
460 XclImpUrlHelper::DecodeUrl( aUrl, aTabName, bSameWorkBook, *pExcRoot->pIR, aEncodedUrl );
461 mnLastRefIdx = pExcRoot->pExtSheetBuff->Add( aUrl, aTabName, bSameWorkBook );
462}
463
465{
466 if (GetRoot().GetBiff() != EXC_BIFF8)
467 return;
468
470}
471
473{// Default Cell Attributes
474 sal_uInt16 nColMic, nColMac;
475 sal_uInt8 nOpt0;
476
477 nColMic = aIn.ReaduInt16();
478 nColMac = aIn.ReaduInt16();
479
480 OSL_ENSURE( aIn.GetRecLeft() == static_cast<std::size_t>(nColMac - nColMic) * 3 + 2,
481 "ImportExcel::Columndefault - wrong record size" );
482
483 nColMac--;
484
485 if( nColMac > rD.MaxCol() )
486 nColMac = static_cast<sal_uInt16>(rD.MaxCol());
487
488 for( sal_uInt16 nCol = nColMic ; nCol <= nColMac ; nCol++ )
489 {
490 nOpt0 = aIn.ReaduInt8();
491 aIn.Ignore( 2 ); // only 0. Attribute-Byte used
492
493 if( nOpt0 & 0x80 ) // Col hidden?
494 pColRowBuff->HideCol( nCol );
495 }
496}
497
499{
500 sal_uInt16 nFormLen;
501 sal_uInt16 nFirstRow = aIn.ReaduInt16();
502 sal_uInt16 nLastRow = aIn.ReaduInt16();
503 sal_uInt8 nFirstCol = aIn.ReaduInt8();
504 sal_uInt8 nLastCol = aIn.ReaduInt8();
505
506 if( GetBiff() == EXC_BIFF2 )
507 {// BIFF2
508 aIn.Ignore( 1 );
509 nFormLen = aIn.ReaduInt8();
510 }
511 else
512 {// BIFF5
513 aIn.Ignore( 6 );
514 nFormLen = aIn.ReaduInt16();
515 }
516
517 std::unique_ptr<ScTokenArray> pResult;
518
519 if (GetRoot().GetDoc().ValidColRow(nLastCol, nLastRow))
520 {
521 // the read mark is now on the formula, length in nFormLen
522
523 pFormConv->Reset( ScAddress( static_cast<SCCOL>(nFirstCol),
524 static_cast<SCROW>(nFirstRow), GetCurrScTab() ) );
525 pFormConv->Convert(pResult, maStrm, nFormLen, true);
526
527 SAL_WARN_IF(!pResult, "sc", "*ImportExcel::Array25(): ScTokenArray is NULL!");
528 }
529
530 if (pResult)
531 {
533 ScRange aArrayRange(nFirstCol, nFirstRow, GetCurrScTab(), nLastCol, nLastRow, GetCurrScTab());
535 }
536}
537
539{
540 sal_uInt16 n1904;
541
542 n1904 = aIn.ReaduInt16();
543
544 if( n1904 )
545 {// 1904 date system
547 aOpt.SetDate( 1, 1, 1904 );
548 rD.SetDocOptions( aOpt );
549 rD.GetFormatTable()->ChangeNullDate( 1, 1, 1904 );
550 }
551}
552
554{
555 sal_uInt32 nRes;
556 sal_uInt16 nOpt;
557
558 nOpt = aIn.ReaduInt16();
559 nRes = aIn.ReaduInt32();
560
561 aIn.ReadByteString( false ); // name
562
563 if( ( nOpt & 0x0001 ) || ( ( nOpt & 0xFFFE ) == 0x0000 ) )
564 {// external name
566 }
567 else if( nOpt & 0x0010 )
568 {// ole link
569 pExcRoot->pExtNameBuff->AddOLE( mnLastRefIdx, nRes ); // nRes is storage ID
570 }
571 else
572 {// dde link
574 }
575}
576
578{// Column Width
579 sal_uInt8 nColFirst, nColLast;
580 sal_uInt16 nColWidth;
581
582 nColFirst = aIn.ReaduInt8();
583 nColLast = aIn.ReaduInt8();
584 nColWidth = aIn.ReaduInt16();
585
586//TODO: add a check for the unlikely case of changed MAXCOL (-> XclImpAddressConverter)
587// if( nColLast > rD.MaxCol() )
588// nColLast = static_cast<sal_uInt16>(rD.MaxCol());
589
590 sal_uInt16 nScWidth = XclTools::GetScColumnWidth( nColWidth, GetCharWidth() );
591 pColRowBuff->SetWidthRange( nColFirst, nColLast, nScWidth );
592}
593
595{
596 sal_uInt16 nDefHeight;
597 nDefHeight = maStrm.ReaduInt16();
598 nDefHeight &= 0x7FFF;
600}
601
603{
604 if (GetRoot().GetBiff() != EXC_BIFF8)
605 return;
606
608}
609
611{
612 if (GetRoot().GetBiff() != EXC_BIFF8)
613 return;
614
616}
617
619{
620 if (GetRoot().GetBiff() != EXC_BIFF8)
621 return;
622
624}
625
627{
629}
630
632{
634}
635
637{
638 // stored as entire characters -> convert to 1/256 of characters (as in COLINFO)
639 double fDefWidth = 256.0 * maStrm.ReaduInt16();
640
641 if (!pColRowBuff)
642 {
643 SAL_WARN("sc", "*ImportExcel::DefColWidth(): pColRowBuff is NULL!");
644 return;
645 }
646
647 // #i3006# additional space for default width - Excel adds space depending on font size
649 fDefWidth += XclTools::GetXclDefColWidthCorrection( nFontHt );
650
651 sal_uInt16 nScWidth = XclTools::GetScColumnWidth( limit_cast< sal_uInt16 >( fDefWidth ), GetCharWidth() );
652 pColRowBuff->SetDefWidth( nScWidth );
653}
654
656{// Column Formatting Information
657 sal_uInt16 nColFirst, nColLast, nColWidth, nXF;
658 sal_uInt16 nOpt;
659
660 nColFirst = aIn.ReaduInt16();
661 nColLast = aIn.ReaduInt16();
662 nColWidth = aIn.ReaduInt16();
663 nXF = aIn.ReaduInt16();
664 nOpt = aIn.ReaduInt16();
665
666 if( nColFirst > rD.MaxCol() )
667 return;
668
669 if( nColLast > rD.MaxCol() )
670 nColLast = static_cast<sal_uInt16>(rD.MaxCol());
671
672 bool bHidden = ::get_flag( nOpt, EXC_COLINFO_HIDDEN );
673 bool bCollapsed = ::get_flag( nOpt, EXC_COLINFO_COLLAPSED );
674 sal_uInt8 nLevel = ::extract_value< sal_uInt8 >( nOpt, 8, 3 );
675 pColOutlineBuff->SetLevelRange( nColFirst, nColLast, nLevel, bCollapsed );
676
677 if( bHidden )
678 pColRowBuff->HideColRange( nColFirst, nColLast );
679
680 sal_uInt16 nScWidth = XclTools::GetScColumnWidth( nColWidth, GetCharWidth() );
681 pColRowBuff->SetWidthRange( nColFirst, nColLast, nScWidth );
682 pColRowBuff->SetDefaultXF( nColFirst, nColLast, nXF );
683}
684
686{
687 sal_uInt16 nFlags;
688 nFlags = aIn.ReaduInt16();
689
692
694}
695
697{
698 sal_uInt16 nGrbit = 0;
699
700 if( GetBiff() == EXC_BIFF5 )
701 {
703 maSheetOffsets.push_back( aIn.ReaduInt32() );
705 nGrbit = aIn.ReaduInt16();
706 }
707
708 OUString aName( aIn.ReadByteString( false ) );
709
710 SCTAB nScTab = nBdshtTab;
711 if( nScTab > 0 )
712 {
713 OSL_ENSURE( !rD.HasTable( nScTab ), "ImportExcel::Boundsheet - sheet exists already" );
714 rD.MakeTable( nScTab );
715 }
716
717 if( ( nGrbit & 0x0001 ) || ( nGrbit & 0x0002 ) )
718 rD.SetVisible( nScTab, false );
719
720 if( !rD.RenameTab( nScTab, aName ) )
721 {
723 rD.RenameTab( nScTab, aName );
724 }
725
726 nBdshtTab++;
727}
728
730{
731 sal_uInt16 nUICountry, nDocCountry;
732 nUICountry = maStrm.ReaduInt16();
733 nDocCountry = maStrm.ReaduInt16();
734
735 // Store system language in XclRoot
736 LanguageType eLanguage = ::msfilter::ConvertCountryToLanguage( static_cast< ::msfilter::CountryId >( nDocCountry ) );
737 if( eLanguage != LANGUAGE_DONTKNOW )
738 SetDocLanguage( eLanguage );
739
740 // Set Excel UI language in add-in name translator
741 eLanguage = ::msfilter::ConvertCountryToLanguage( static_cast< ::msfilter::CountryId >( nUICountry ) );
742 if( eLanguage != LANGUAGE_DONTKNOW )
743 SetUILanguage( eLanguage );
744}
745
747{
748 if( maStrm.ReaduInt16() != 0 )
749 {
750 ScDocOptions aDocOpt = GetDoc().GetDocOptions();
751 aDocOpt.SetLookUpColRowNames( true );
752 GetDoc().SetDocOptions( aDocOpt );
753 }
754}
755
757{
758 sal_uInt16 nHide;
759 ScVObjMode eOle, eChart, eDraw;
760
761 nHide = aIn.ReaduInt16();
762
764
765 switch( nHide )
766 {
767 case 1: // Placeholders
768 eOle = VOBJ_MODE_SHOW; // in Excel 97 only charts as place holder are displayed
769 eChart = VOBJ_MODE_SHOW; //#i80528# VOBJ_MODE_DUMMY replaced by VOBJ_MODE_SHOW now
770 eDraw = VOBJ_MODE_SHOW;
771 break;
772 case 2: // Hide all
773 eOle = VOBJ_MODE_HIDE;
774 eChart = VOBJ_MODE_HIDE;
775 eDraw = VOBJ_MODE_HIDE;
776 break;
777 default: // Show all
778 eOle = VOBJ_MODE_SHOW;
779 eChart = VOBJ_MODE_SHOW;
780 eDraw = VOBJ_MODE_SHOW;
781 break;
782 }
783
784 aOpts.SetObjMode( VOBJ_TYPE_OLE, eOle );
785 aOpts.SetObjMode( VOBJ_TYPE_CHART, eChart );
786 aOpts.SetObjMode( VOBJ_TYPE_DRAW, eDraw );
787
788 rD.SetViewOptions( aOpts );
789}
790
792{
793 sal_uInt16 nScWidth = XclTools::GetScColumnWidth( maStrm.ReaduInt16(), GetCharWidth() );
794 if (!pColRowBuff)
795 {
796 SAL_WARN("sc", "*ImportExcel::Standardwidth(): pColRowBuff is NULL!");
797 return;
798 }
799 pColRowBuff->SetDefWidth( nScWidth, true );
800}
801
803{
804 switch (mnLastRecId)
805 {
806 case EXC_ID2_FORMULA:
807 case EXC_ID3_FORMULA:
808 case EXC_ID4_FORMULA:
809 // This record MUST immediately follow a FORMULA record.
810 break;
811 default:
812 return;
813 }
814
815 if (!mpLastFormula)
816 // The last FORMULA record should have left this data.
817 return;
818
819 aIn.Ignore( 8 );
820 sal_uInt16 nLenExpr = aIn.ReaduInt16();
821
822 // read mark is now on the formula
823
824 std::unique_ptr<ScTokenArray> pResult;
825
826 // The shared range in this record is erroneous more than half the time.
827 // Don't ever rely on it. Use the one from the formula cell above.
828 SCCOL nCol1 = mpLastFormula->mnCol;
829 SCROW nRow1 = mpLastFormula->mnRow;
830
831 ScAddress aPos(nCol1, nRow1, GetCurrScTab());
832 pFormConv->Reset(aPos);
833 pFormConv->Convert( pResult, maStrm, nLenExpr, true, FT_SharedFormula );
834
835 if (!pResult)
836 {
837 SAL_WARN("sc", "+ImportExcel::Shrfmla(): ScTokenArray is NULL!");
838 return;
839 }
840
841 pExcRoot->pShrfmlaBuff->Store(aPos, *pResult);
842
843 // Create formula cell for the last formula record.
844
846
847 ScFormulaCell* pCell = new ScFormulaCell(rD, aPos, std::move(pResult));
850 rDoc.getDoc().EnsureTable(aPos.Tab());
851 rDoc.setFormulaCell(aPos, pCell);
852 pCell->SetNeedNumberFormat(false);
853 if (std::isfinite(mpLastFormula->mfValue))
855
857 mpLastFormula->mpCell = pCell;
858}
859
861{
862 /* rw (2 bytes): An Rw structure that specifies the row containing the
863 cells with numeric data.
864
865 colFirst (2 bytes): A Col structure that specifies the first column in
866 the series of numeric cells within the sheet. The value of colFirst.col
867 MUST be less than or equal to 254.
868
869 rgrkrec (variable): An array of RkRec structures. Each element in the
870 array specifies an RkRec in the row. The number of entries in the array
871 MUST be equal to the value given by the following formula:
872
873 Number of entries in rgrkrec = (colLast.col – colFirst.col +1)
874
875 colLast (2 bytes): A Col structure that specifies the last column in
876 the set of numeric cells within the sheet. This colLast.col value MUST
877 be greater than the colFirst.col value. */
878
879 XclAddress aXclPos;
880 aIn >> aXclPos;
881
882 XclAddress aCurrXclPos(aXclPos);
883 while (true)
884 {
885 if (aXclPos.mnCol > aCurrXclPos.mnCol)
886 break;
887 if (aIn.GetRecLeft() <= 2)
888 break;
889
890 sal_uInt16 nXF = aIn.ReaduInt16();
891 sal_Int32 nRkNum = aIn.ReadInt32();
892
894 if( GetAddressConverter().ConvertAddress( aScPos, aCurrXclPos, GetCurrScTab(), true ) )
895 {
896 GetXFRangeBuffer().SetXF( aScPos, nXF );
898 }
899 ++aCurrXclPos.mnCol;
900 }
901}
902
904{
905 /* rw (2 bytes): An Rw structure that specifies a row containing the blank
906 cells.
907
908 colFirst (2 bytes): A Col structure that specifies the first column in
909 the series of blank cells within the sheet. The value of colFirst.col
910 MUST be less than or equal to 254.
911
912 rgixfe (variable): An array of IXFCell structures. Each element of this
913 array contains an IXFCell structure corresponding to a blank cell in the
914 series. The number of entries in the array MUST be equal to the value
915 given by the following formula:
916
917 Number of entries in rgixfe = (colLast.col – colFirst.col +1)
918
919 colLast (2 bytes): A Col structure that specifies the last column in
920 the series of blank cells within the sheet. This colLast.col value MUST
921 be greater than colFirst.col value. */
922
923 XclAddress aXclPos;
924 aIn >> aXclPos;
925
926 XclAddress aCurrXclPos(aXclPos);
927 while (true)
928 {
929 if (aXclPos.mnCol > aCurrXclPos.mnCol)
930 break;
931 if (aIn.GetRecLeft() <= 2)
932 break;
933
934 sal_uInt16 nXF = aIn.ReaduInt16();
935
937 if( GetAddressConverter().ConvertAddress( aScPos, aCurrXclPos, GetCurrScTab(), true ) )
938 GetXFRangeBuffer().SetBlankXF( aScPos, nXF );
939 ++aCurrXclPos.mnCol;
940 }
941}
942
944{
945 XclAddress aXclPos;
946 sal_uInt16 nXFIdx;
947 aIn >> aXclPos;
948 nXFIdx = aIn.ReaduInt16();
949
951 if( !GetAddressConverter().ConvertAddress( aScPos, aXclPos, GetCurrScTab(), true ) )
952 return;
953
954 // unformatted Unicode string with separate formatting information
955 XclImpString aString;
956 aString.Read( maStrm );
957
958 // character formatting runs
959 if( !aString.IsRich() )
960 aString.ReadFormats( maStrm );
961
962 GetXFRangeBuffer().SetXF( aScPos, nXFIdx );
963 XclImpStringHelper::SetToDocument(GetDocImport(), aScPos, *this, aString, nXFIdx);
964}
965
967{
969 SCTAB nScTab = GetCurrScTab();
970
971 sal_uInt16 nCount = maStrm.ReaduInt16();
972 sal_uInt16 nIdx = 0;
973 while (true)
974 {
975 if (maStrm.GetRecLeft() < 8)
976 break;
977 if (nIdx >= nCount)
978 break;
979 XclRange aXclRange;
980 maStrm >> aXclRange; // 16-bit rows and columns
982 if( rAddrConv.ConvertRange( aScRange, aXclRange, nScTab, nScTab, true ) )
983 {
984 const bool bTooSlowForFuzzing = mbFuzzing && (aScRange.aEnd.Col() > 512 || aScRange.aEnd.Row() > 512);
985 if (!bTooSlowForFuzzing)
986 GetXFRangeBuffer().SetMerge( aScRange.aStart.Col(), aScRange.aStart.Row(), aScRange.aEnd.Col(), aScRange.aEnd.Row() );
987 }
988 ++nIdx;
989 }
990}
991
993{
994 XclRange aXclOleSize( ScAddress::UNINITIALIZED );
995 maStrm.Ignore( 2 );
996 aXclOleSize.Read( maStrm, false );
997
998 SCTAB nScTab = GetCurrScTab();
999 GetAddressConverter().ConvertRange( maScOleSize, aXclOleSize, nScTab, nScTab, false );
1000}
1001
1003{
1004 sal_uInt16 nRow, nRowHeight, nGrbit, nXF;
1005
1006 nRow = aIn.ReaduInt16();
1007 aIn.Ignore( 4 );
1008
1009 SCROW nScRow = static_cast< SCROW >( nRow );
1010
1011 if( !GetRoot().GetDoc().ValidRow( nScRow ) )
1012 return;
1013
1014 nRowHeight = aIn.ReaduInt16(); // specify direct in Twips
1015 aIn.Ignore( 4 );
1016
1017 nRowHeight = nRowHeight & 0x7FFF; // Bit 15: Row Height not changed manually
1018 if( !nRowHeight )
1019 nRowHeight = (GetBiff() == EXC_BIFF2) ? 0x25 : 0x225;
1020
1021 nGrbit = aIn.ReaduInt16();
1022 nXF = aIn.ReaduInt16();
1023
1024 sal_uInt8 nLevel = ::extract_value< sal_uInt8 >( nGrbit, 0, 3 );
1025 pRowOutlineBuff->SetLevel( nScRow, nLevel, ::get_flag( nGrbit, EXC_ROW_COLLAPSED ) );
1026 pColRowBuff->SetRowSettings( nScRow, nRowHeight, nGrbit );
1027
1028 if( nGrbit & EXC_ROW_USEDEFXF )
1029 GetXFRangeBuffer().SetRowDefXF( nScRow, nXF & EXC_ROW_XFMASK );
1030}
1031
1033{
1034 sal_uInt16 nSubType;
1036 maStrm.Ignore( 2 );
1037 nSubType = maStrm.ReaduInt16();
1038
1039 OSL_ENSURE( nSubType != 0x0100, "*ImportExcel::Bof3(): Biff3 as Workbook?!" );
1040 if( nSubType == 0x0100 ) // Book
1042 else if( nSubType == 0x0020 ) // Chart
1044 else if( nSubType == 0x0040 ) // Macro
1046 else // #i51490# Excel interprets invalid indexes as worksheet
1048}
1049
1051{
1052 sal_uInt16 nFirstRow, nLastRow, nFormLen;
1053 sal_uInt8 nFirstCol, nLastCol;
1054
1055 nFirstRow = aIn.ReaduInt16();
1056 nLastRow = aIn.ReaduInt16();
1057 nFirstCol = aIn.ReaduInt8();
1058 nLastCol = aIn.ReaduInt8();
1059 aIn.Ignore( (GetBiff() >= EXC_BIFF5) ? 6 : 2 );
1060 nFormLen = aIn.ReaduInt16();
1061
1062 std::unique_ptr<ScTokenArray> pResult;
1063
1064 if( GetRoot().GetDoc().ValidColRow( nLastCol, nLastRow ) )
1065 {
1066 // the read mark is now on the formula, length in nFormLen
1067
1068 pFormConv->Reset( ScAddress( static_cast<SCCOL>(nFirstCol),
1069 static_cast<SCROW>(nFirstRow), GetCurrScTab() ) );
1070 pFormConv->Convert( pResult, maStrm, nFormLen, true );
1071
1072 SAL_WARN_IF(!pResult, "sc", "+ImportExcel::Array34(): ScTokenArray is NULL!");
1073 }
1074
1075 if (pResult)
1076 {
1078 ScRange aArrayRange(nFirstCol, nFirstRow, GetCurrScTab(), nLastCol, nLastRow, GetCurrScTab());
1080 }
1081}
1082
1084{
1085 sal_uInt16 nFlags, nDefHeight;
1086 nFlags = maStrm.ReaduInt16();
1087 nDefHeight = maStrm.ReaduInt16();
1088
1089 if (!pColRowBuff)
1090 {
1091 SAL_WARN("sc", "*ImportExcel::Defrowheight345(): pColRowBuff is NULL!");
1092 return;
1093 }
1094
1095 pColRowBuff->SetDefHeight( nDefHeight, nFlags );
1096}
1097
1099{
1100 sal_uInt16 nFirstRow = aIn.ReaduInt16();
1101 sal_uInt16 nLastRow = aIn.ReaduInt16();
1102 sal_uInt8 nFirstCol = aIn.ReaduInt8();
1103 sal_uInt8 nLastCol = aIn.ReaduInt8();
1104 sal_uInt16 nGrbit = aIn.ReaduInt16();
1105 sal_uInt16 nInpRow = aIn.ReaduInt16();
1106 sal_uInt16 nInpCol = aIn.ReaduInt16();
1107 sal_uInt16 nInpRow2 = aIn.ReaduInt16();
1108 sal_uInt16 nInpCol2 = aIn.ReaduInt16();
1109
1110 if (mbFuzzing)
1111 {
1112 //shrink to smallish arbitrary value to not timeout
1113 nLastRow = std::min<sal_uInt16>(nLastRow, MAXROW_30 / 2);
1114 }
1115
1116 if( GetRoot().GetDoc().ValidColRow( nLastCol, nLastRow ) )
1117 {
1118 if( nFirstCol && nFirstRow )
1119 {
1120 ScTabOpParam aTabOpParam;
1122 sal_uInt16 nCol = nFirstCol - 1;
1123 sal_uInt16 nRow = nFirstRow - 1;
1124 SCTAB nTab = GetCurrScTab();
1125 switch (aTabOpParam.meMode)
1126 {
1128 aTabOpParam.aRefFormulaCell.Set(
1129 static_cast<SCCOL>(nFirstCol),
1130 static_cast<SCROW>(nFirstRow - 1), nTab, false,
1131 false, false );
1132 aTabOpParam.aRefFormulaEnd.Set(
1133 static_cast<SCCOL>(nLastCol),
1134 static_cast<SCROW>(nFirstRow - 1), nTab, false,
1135 false, false );
1136 aTabOpParam.aRefColCell.Set( static_cast<SCCOL>(nInpCol),
1137 static_cast<SCROW>(nInpRow), nTab, false, false,
1138 false );
1139 nRow++;
1140 break;
1141 case ScTabOpParam::Row:
1142 aTabOpParam.aRefFormulaCell.Set(
1143 static_cast<SCCOL>(nFirstCol - 1),
1144 static_cast<SCROW>(nFirstRow), nTab, false, false,
1145 false );
1146 aTabOpParam.aRefFormulaEnd.Set(
1147 static_cast<SCCOL>(nFirstCol - 1),
1148 static_cast<SCROW>(nLastRow), nTab, false, false,
1149 false );
1150 aTabOpParam.aRefRowCell.Set( static_cast<SCCOL>(nInpCol),
1151 static_cast<SCROW>(nInpRow), nTab, false, false,
1152 false );
1153 nCol++;
1154 break;
1155 case ScTabOpParam::Both: // TWO-INPUT
1156 aTabOpParam.aRefFormulaCell.Set(
1157 static_cast<SCCOL>(nFirstCol - 1),
1158 static_cast<SCROW>(nFirstRow - 1), nTab, false,
1159 false, false );
1160 aTabOpParam.aRefRowCell.Set( static_cast<SCCOL>(nInpCol),
1161 static_cast<SCROW>(nInpRow), nTab, false, false,
1162 false );
1163 aTabOpParam.aRefColCell.Set( static_cast<SCCOL>(nInpCol2),
1164 static_cast<SCROW>(nInpRow2), nTab, false, false,
1165 false );
1166 break;
1167 }
1168
1170 ScRange aTabOpRange(nCol, nRow, nTab, nLastCol, nLastRow, nTab);
1171 rDoc.setTableOpCells(aTabOpRange, aTabOpParam);
1172 }
1173 }
1174 else
1175 {
1176 bTabTruncated = true;
1177 GetTracer().TraceInvalidRow(nLastRow, rD.MaxRow());
1178 }
1179}
1180
1182{
1183 sal_uInt16 nSubType;
1185 maStrm.Ignore( 2 );
1186 nSubType = maStrm.ReaduInt16();
1187
1188 if( nSubType == 0x0100 ) // Book
1190 else if( nSubType == 0x0020 ) // Chart
1192 else if( nSubType == 0x0040 ) // Macro
1194 else // #i51490# Excel interprets invalid indexes as worksheet
1196}
1197
1199{
1200 //POST: eDateiTyp = Type of the file to be read
1201 sal_uInt16 nSubType, nVers;
1202 BiffTyp eDatei;
1203
1205 nVers = maStrm.ReaduInt16();
1206 nSubType = maStrm.ReaduInt16( );
1207
1208 switch( nSubType )
1209 {
1210 case 0x0005: eDatei = Biff5W; break; // workbook globals
1211 case 0x0006: eDatei = Biff5V; break; // VB module
1212 case 0x0020: eDatei = Biff5C; break; // chart
1213 case 0x0040: eDatei = Biff5M4; break; // macro sheet
1214 case 0x0010: // worksheet
1215 default: eDatei = Biff5; break; // tdf#144732 Excel interprets invalid indexes as worksheet
1216 }
1217
1218 if( nVers == 0x0600 && (GetBiff() == EXC_BIFF8) )
1219 eDatei = static_cast<BiffTyp>( eDatei - Biff5 + Biff8 );
1220
1221 pExcRoot->eDateiTyp = eDatei;
1222}
1223
1225{
1226 pExcRoot->pExtSheetBuff->Reset();
1227
1228 if( GetBiff() <= EXC_BIFF5 )
1229 {
1230 pExcRoot->pExtNameBuff->Reset();
1231 mnLastRefIdx = 0;
1232 }
1233
1234 FinalizeTable();
1235}
1236
1238{
1239 SCTAB nTab = GetCurrScTab();
1240 if( nTab > 0 && !rD.HasTable( nTab ) )
1241 rD.MakeTable( nTab );
1242
1243 if (nTab == 0 && GetBiff() == EXC_BIFF2)
1244 {
1245 // For Excel 2.1 Worksheet file, we need to set the file name as the
1246 // sheet name.
1248 rD.RenameTab(0, aURL.getBase());
1249 }
1250
1251 pExcRoot->pShrfmlaBuff->Clear();
1252 maLastFormulaCells.clear();
1253 mpLastFormula = nullptr;
1254
1255 InitializeTable( nTab );
1256
1257 XclImpOutlineDataBuffer* pNewItem = new XclImpOutlineDataBuffer( GetRoot(), nTab );
1258 pOutlineListBuffer->push_back( std::unique_ptr<XclImpOutlineDataBuffer>(pNewItem) );
1260 pColOutlineBuff = pNewItem->GetColOutline();
1261 pRowOutlineBuff = pNewItem->GetRowOutline();
1262}
1263
1264std::unique_ptr<ScTokenArray> ImportExcel::ErrorToFormula( bool bErrOrVal, sal_uInt8 nError, double& rVal )
1265{
1266 return pFormConv->GetBoolErr( XclTools::ErrorToEnum( rVal, bErrOrVal, nError ) );
1267}
1268
1270{
1271 /* Speed up chart import: import all sheets without charts, then
1272 update row heights (here), last load all charts -> do not any longer
1273 update inside of ScDocShell::ConvertFrom() (causes update of existing
1274 charts during each and every change of row height). */
1275 if( ScModelObj* pDocObj = GetDocModelObj() )
1276 pDocObj->UpdateAllRowHeights();
1277}
1278
1280{
1281 /* Set automatic page numbering in Default page style (default is "page number = 1").
1282 Otherwise hidden tables (i.e. for scenarios) which have Default page style will
1283 break automatic page numbering. */
1284 if( SfxStyleSheetBase* pStyleSheet = GetStyleSheetPool().Find( ScResId( STR_STYLENAME_STANDARD ), SfxStyleFamily::Page ) )
1285 pStyleSheet->GetItemSet().Put( SfxUInt16Item( ATTR_PAGE_FIRSTPAGENO, 0 ) );
1286
1287 // outlines for all sheets, sets hidden rows and columns (#i11776# after filtered ranges)
1288 for (auto& rxBuffer : *pOutlineListBuffer)
1289 rxBuffer->Convert();
1290
1291 // document view settings (before visible OLE area)
1293
1294 // process all drawing objects (including OLE, charts, controls; after hiding rows/columns; before visible OLE area)
1296
1297 // visible area (used if this document is an embedded OLE object)
1298 if( SfxObjectShell* pDocShell = GetDocShell() )
1299 {
1300 // visible area if embedded
1301 const ScExtDocSettings& rDocSett = GetExtDocOptions().GetDocSettings();
1302 SCTAB nDisplScTab = rDocSett.mnDisplTab;
1303
1304 /* #i44077# If a new OLE object is inserted from file, there is no
1305 OLESIZE record in the Excel file. Calculate used area from file
1306 contents (used cells and drawing objects). */
1307 if( !maScOleSize.IsValid() )
1308 {
1309 // used area of displayed sheet (cell contents)
1310 if( const ScExtTabSettings* pTabSett = GetExtDocOptions().GetTabSettings( nDisplScTab ) )
1311 maScOleSize = pTabSett->maUsedArea;
1312 // add all valid drawing objects
1313 ScRange aScObjArea = GetObjectManager().GetUsedArea( nDisplScTab );
1314 if( aScObjArea.IsValid() )
1315 maScOleSize.ExtendTo( aScObjArea );
1316 }
1317
1318 // valid size found - set it at the document
1319 if( maScOleSize.IsValid() )
1320 {
1321 pDocShell->SetVisArea( GetDoc().GetMMRect(
1323 maScOleSize.aEnd.Col(), maScOleSize.aEnd.Row(), nDisplScTab ) );
1324 GetDoc().SetVisibleTab( nDisplScTab );
1325 }
1326 }
1327
1328 // open forms in alive mode (has no effect, if no controls in document)
1329 if( ScModelObj* pDocObj = GetDocModelObj() )
1330 pDocObj->setPropertyValue( SC_UNO_APPLYFMDES, uno::Any( false ) );
1331
1332 // enables extended options to be set to the view after import
1333 GetExtDocOptions().SetChanged( true );
1334
1335 // root data owns the extended document options -> create a new object
1336 GetDoc().SetExtDocOptions( std::make_unique<ScExtDocOptions>( GetExtDocOptions() ) );
1337
1338 const SCTAB nLast = rD.GetTableCount();
1339 const ScRange* p;
1340
1341 if( GetRoot().GetPrintAreaBuffer().HasRanges() )
1342 {
1343 for( SCTAB n = 0 ; n < nLast ; n++ )
1344 {
1346 if( p )
1347 {
1349 while( p )
1350 {
1351 rD.AddPrintRange( n, *p );
1353 }
1354 }
1355 else
1356 {
1357 // #i4063# no print ranges -> print entire sheet
1359 }
1360 }
1362 }
1363
1364 if( !GetRoot().GetTitleAreaBuffer().HasRanges() )
1365 return;
1366
1367 for( SCTAB n = 0 ; n < nLast ; n++ )
1368 {
1370 if( p )
1371 {
1372 bool bRowVirgin = true;
1373 bool bColVirgin = true;
1374
1375 while( p )
1376 {
1377 if( p->aStart.Col() == 0 && p->aEnd.Col() == rD.MaxCol() && bRowVirgin )
1378 {
1379 rD.SetRepeatRowRange( n, *p );
1380 bRowVirgin = false;
1381 }
1382
1383 if( p->aStart.Row() == 0 && p->aEnd.Row() == rD.MaxRow() && bColVirgin )
1384 {
1385 rD.SetRepeatColRange( n, *p );
1386 bColVirgin = false;
1387 }
1388
1390 }
1391 }
1392 }
1393}
1394
1396 XclImpRoot( rRoot ),
1397 mxColOutlineBuff( std::make_shared<XclImpOutlineBuffer>( rRoot.GetXclMaxPos().Col() + 1 ) ),
1398 mxRowOutlineBuff( std::make_shared<XclImpOutlineBuffer>( rRoot.GetXclMaxPos().Row() + 1 ) ),
1399 mxColRowBuff( std::make_shared<XclImpColRowSettings>( rRoot ) ),
1400 mnScTab( nScTab )
1401{
1402}
1403
1405{
1406}
1407
1409{
1410 mxColOutlineBuff->SetOutlineArray( &GetDoc().GetOutlineTable( mnScTab, true )->GetColArray() );
1411 mxColOutlineBuff->MakeScOutline();
1412
1413 mxRowOutlineBuff->SetOutlineArray( &GetDoc().GetOutlineTable( mnScTab, true )->GetRowArray() );
1414 mxRowOutlineBuff->MakeScOutline();
1415
1416 mxColRowBuff->ConvertHiddenFlags( mnScTab );
1417}
1418
1419/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
bool ValidColRow(SCCOL nCol, SCROW nRow, SCCOL nMaxCol, SCROW nMaxRow)
Definition: address.hxx:121
const SCROW MAXROW_30
Definition: address.hxx:97
bool ValidRow(SCROW nRow, SCROW nMaxRow)
Definition: address.hxx:105
bool mbBiff2HasXfs
Definition: imp_op.hxx:116
void ReadUsesElfs()
Definition: impop.cxx:746
LastFormulaMapType maLastFormulaCells
Definition: imp_op.hxx:104
void ReadFileSharing()
Definition: impop.cxx:161
void Shrfmla()
Definition: impop.cxx:802
void Boundsheet()
Definition: impop.cxx:696
void ReadBoolErr()
Definition: impop.cxx:345
void DocPassword()
Definition: impop.cxx:618
void ReadBlank()
Definition: impop.cxx:267
void ReadNumber()
Definition: impop.cxx:298
void DefColWidth()
Definition: impop.cxx:636
virtual void EndSheet()
Definition: impop.cxx:1224
void SheetPassword()
Definition: impop.cxx:447
std::unique_ptr< ScTokenArray > ErrorToFormula(bool bErrOrVal, sal_uInt8 nError, double &rVal)
Definition: impop.cxx:1264
ScRange maScOleSize
Definition: imp_op.hxx:93
sal_uInt16 ReadXFIndex(const ScAddress &rScPos, bool bBiff2)
Definition: impop.cxx:182
void Row25()
Definition: impop.cxx:395
void ReadRk()
Definition: impop.cxx:373
sal_uInt16 mnLastRecId
Current XF identifier from IXFE record.
Definition: imp_op.hxx:109
void Defrowheight2()
Definition: impop.cxx:594
void Hideobj()
Definition: impop.cxx:756
void Colinfo()
Definition: impop.cxx:655
bool bTabTruncated
Definition: imp_op.hxx:113
void Columndefault()
Definition: impop.cxx:472
sal_Int16 mnLastRefIdx
Definition: imp_op.hxx:107
XclImpOutlineBuffer * pRowOutlineBuff
Definition: imp_op.hxx:98
void Ixfe()
Definition: impop.cxx:631
void Standardwidth()
Definition: impop.cxx:791
bool mbBiff2HasXfsValid
Select XF formatting or direct formatting in BIFF2.
Definition: imp_op.hxx:117
void Mulblank()
Definition: impop.cxx:903
sal_uInt16 mnIxfeIndex
Definition: imp_op.hxx:108
SCTAB nBdshtTab
Definition: imp_op.hxx:111
void Country()
Definition: impop.cxx:729
void Bof4()
Definition: impop.cxx:1181
void Row34()
Definition: impop.cxx:1002
void ReadLabel()
Definition: impop.cxx:315
void WinProtection()
Definition: impop.cxx:464
void Wsbool()
Definition: impop.cxx:685
void ReadInteger()
Definition: impop.cxx:281
XclImpStream maStrm
Definition: imp_op.hxx:89
void Rec1904()
Definition: impop.cxx:538
RootData * pExcRoot
Definition: imp_op.hxx:87
ImportExcel(XclImpRootData &rImpData, SvStream &rStrm)
Definition: impop.cxx:84
void Bof2()
Definition: impop.cxx:425
void Cellmerging()
Definition: impop.cxx:966
ScfUInt32Vec maSheetOffsets
Definition: imp_op.hxx:92
void Defrowheight345()
Definition: impop.cxx:1083
void Array34()
Definition: impop.cxx:1050
std::unique_ptr< XclImpOutlineListBuffer > pOutlineListBuffer
Definition: imp_op.hxx:102
bool mbFuzzing
False = mbBiff2HasXfs is undetermined yet.
Definition: imp_op.hxx:118
std::unique_ptr< ExcelToSc > pFormConv
Visible range if embedded.
Definition: imp_op.hxx:95
void Codepage()
Definition: impop.cxx:626
void Bof5()
Definition: impop.cxx:1198
void AdjustRowHeight()
Definition: impop.cxx:1269
void DocProtect()
Definition: impop.cxx:610
void Olesize()
Definition: impop.cxx:992
void Colwidth()
Definition: impop.cxx:577
void Externsheet()
Definition: impop.cxx:455
virtual void PostDocLoad()
Definition: impop.cxx:1279
XclImpOutlineBuffer * pColOutlineBuff
Definition: imp_op.hxx:97
std::vector< std::unique_ptr< XclImpOutlineDataBuffer > > XclImpOutlineListBuffer
Definition: imp_op.hxx:101
void NewTable()
Definition: impop.cxx:1237
void Window1()
Definition: impop.cxx:390
XclImpStream & aIn
Definition: imp_op.hxx:90
XclImpColRowSettings * pColRowBuff
Definition: imp_op.hxx:99
void Mulrk()
Definition: impop.cxx:860
void ReadDimensions()
Definition: impop.cxx:224
void Array25()
Definition: impop.cxx:498
void TableOp()
Definition: impop.cxx:1098
void Bof3()
Definition: impop.cxx:1032
void Eof()
Definition: impop.cxx:440
void Externname25()
Definition: impop.cxx:553
LastFormula * mpLastFormula
Definition: imp_op.hxx:105
void SheetProtect()
Definition: impop.cxx:602
void SetLastFormula(SCCOL nCol, SCROW nRow, double fVal, sal_uInt16 nXF, ScFormulaCell *pCell)
True if fuzzing filter.
Definition: impop.cxx:142
virtual ~ImportExcel() override
Definition: impop.cxx:133
void Rstring()
Definition: impop.cxx:943
ScDocument & rD
Definition: imp_op.hxx:46
ImportTyp(ScDocument &, rtl_TextEncoding eSrc)
Definition: impop.cxx:73
virtual ~ImportTyp()
Definition: impop.cxx:80
@ UNINITIALIZED
Definition: address.hxx:220
SCTAB Tab() const
Definition: address.hxx:283
SCROW Row() const
Definition: address.hxx:274
SCCOL Col() const
Definition: address.hxx:279
void SetFormulaRegexEnabled(bool bVal)
Definition: docoptio.cxx:73
void SetIgnoreCase(bool bVal)
Definition: docoptio.hxx:58
void SetLookUpColRowNames(bool bVal)
Definition: docoptio.hxx:52
void SetFormulaWildcardsEnabled(bool bVal)
Definition: docoptio.cxx:90
void SetDate(sal_uInt16 nD, sal_uInt16 nM, sal_Int16 nY)
Definition: docoptio.hxx:68
Accessor class to ScDocument.
void setMatrixCells(const ScRange &rRange, const ScTokenArray &rArray, formula::FormulaGrammar::Grammar eGrammar)
void setFormulaCell(const ScAddress &rPos, const OUString &rFormula, formula::FormulaGrammar::Grammar eGrammar, const double *pResult=nullptr)
void setTableOpCells(const ScRange &rRange, const ScTabOpParam &rParam)
ScDocument & getDoc()
void setNumericCell(const ScAddress &rPos, double fVal)
bool ValidRow(SCROW nRow) const
Definition: document.hxx:899
SC_DLLPUBLIC SCCOL MaxCol() const
Definition: document.hxx:891
SC_DLLPUBLIC void SetVisibleTab(SCTAB nTab)
Definition: document.hxx:879
SC_DLLPUBLIC bool RenameTab(SCTAB nTab, const OUString &rName, bool bExternalDocument=false)
Definition: document.cxx:865
SC_DLLPUBLIC void AddPrintRange(SCTAB nTab, const ScRange &rNew)
Adds a new print ranges.
Definition: document.cxx:6425
void SetSrcCharSet(rtl_TextEncoding eNew)
Definition: document.hxx:2134
SC_DLLPUBLIC void EnsureTable(SCTAB nTab)
Definition: documen2.cxx:577
SC_DLLPUBLIC SCROW MaxRow() const
Definition: document.hxx:892
SC_DLLPUBLIC void ClearPrintRanges(SCTAB nTab)
Removes all print ranges.
Definition: document.cxx:6419
SC_DLLPUBLIC void CheckLinkFormulaNeedingCheck(const ScTokenArray &rCode)
Check token array and set link check if ocDde/ocWebservice is contained.
Definition: documen8.cxx:1154
SC_DLLPUBLIC void SetPrintEntireSheet(SCTAB nTab)
Marks the specified sheet to be printed completely.
Definition: document.cxx:6431
SC_DLLPUBLIC void SetDocOptions(const ScDocOptions &rOpt)
Definition: documen3.cxx:1958
SC_DLLPUBLIC const ScViewOptions & GetViewOptions() const
Definition: documen3.cxx:1967
SC_DLLPUBLIC void SetViewOptions(const ScViewOptions &rOpt)
Definition: documen3.cxx:1973
SC_DLLPUBLIC void CreateValidTabName(OUString &rName) const
Definition: document.cxx:395
SC_DLLPUBLIC void SetRepeatRowRange(SCTAB nTab, std::optional< ScRange > oNew)
Definition: document.cxx:6443
SC_DLLPUBLIC void MakeTable(SCTAB nTab, bool _bNeedsNameCheck=true)
Definition: document.cxx:172
SC_DLLPUBLIC void SetExtDocOptions(std::unique_ptr< ScExtDocOptions > pNewOptions)
Definition: documen3.cxx:2032
SC_DLLPUBLIC SvNumberFormatter * GetFormatTable() const
Definition: documen2.cxx:467
SC_DLLPUBLIC bool HasTable(SCTAB nTab) const
Definition: document.cxx:195
SC_DLLPUBLIC void SetRepeatColRange(SCTAB nTab, std::optional< ScRange > oNew)
Definition: document.cxx:6437
SC_DLLPUBLIC const ScDocOptions & GetDocOptions() const
Definition: documen3.cxx:1952
SC_DLLPUBLIC void SetVisible(SCTAB nTab, bool bVisible)
Definition: document.cxx:913
SC_DLLPUBLIC SCTAB GetTableCount() const
Definition: document.cxx:317
const ScExtDocSettings & GetDocSettings() const
Definition: scextopt.cxx:170
ScExtTabSettings & GetOrCreateTabSettings(SCTAB nTab)
Definition: scextopt.cxx:190
void SetChanged(bool bChanged)
If set to true, the data will be copied to the view data after import.
Definition: scextopt.cxx:165
void SetResultDouble(double n)
For import only: set a double result.
void SetNeedNumberFormat(bool bVal)
ScTokenArray * GetCode()
void SetHybridDouble(double n)
For import only: set a double result.
const ScRange * First(SCTAB nTab)
Definition: frmbase.cxx:130
const ScRange * Next()
Definition: frmbase.cxx:145
ScAddress aEnd
Definition: address.hxx:498
void ExtendTo(const ScRange &rRange)
Definition: address.cxx:1562
bool IsValid() const
Definition: address.hxx:544
ScAddress aStart
Definition: address.hxx:497
void Set(const ScAddress &rAdr, bool bNewRelCol, bool bNewRelRow, bool bNewRelTab)
Definition: address.hxx:914
void WrapReference(const ScAddress &rPos, SCCOL nMaxCol, SCROW nMaxRow)
Definition: token.cxx:5295
void SetObjMode(ScVObjType eObj, ScVObjMode eMode)
Definition: viewopti.hxx:90
Store and manage shared formula tokens.
Definition: namebuff.hxx:61
void ChangeNullDate(sal_uInt16 nDay, sal_uInt16 nMonth, sal_Int16 nYear)
Provides functions to convert Excel cell addresses to Calc cell addresses.
Definition: xihelper.hxx:42
bool ConvertRange(ScRange &rScRange, const XclRange &rXclRange, SCTAB nScTab1, SCTAB nScTab2, bool bWarn)
Converts the passed Excel cell range to a Calc cell range.
Definition: xihelper.cxx:101
void SetDefWidth(sal_uInt16 nDefWidth, bool bStdWidthRec=false)
Definition: colrowst.cxx:50
void SetHeight(SCROW nRow, sal_uInt16 nHeight)
Definition: colrowst.cxx:112
void SetDefaultXF(SCCOL nScCol1, SCCOL nScCol2, sal_uInt16 nXFIndex)
Definition: colrowst.cxx:166
void HideColRange(SCCOL nCol1, SCCOL nCol2)
Definition: colrowst.cxx:91
void HideCol(SCCOL nCol)
Definition: colrowst.cxx:83
void SetDefHeight(sal_uInt16 nDefHeight, sal_uInt16 nFlags)
Definition: colrowst.cxx:100
void SetRowSettings(SCROW nRow, sal_uInt16 nHeight, sal_uInt16 nFlags)
Definition: colrowst.cxx:133
void SetWidthRange(SCCOL nCol1, SCCOL nCol2, sal_uInt16 nWidth)
Definition: colrowst.cxx:65
void ReadPasswordHash(XclImpStream &rStrm)
Definition: xicontent.cxx:1295
void ReadDocProtect(XclImpStream &rStrm)
document structure protection flag
Definition: xicontent.cxx:1285
void ReadWinProtect(XclImpStream &rStrm)
document windows properties protection flag
Definition: xicontent.cxx:1290
void Finalize()
Sets the view settings at the document.
Definition: xiview.cxx:63
void ReadWindow1(XclImpStream &rStrm)
Reads a WINDOW1 record.
Definition: xiview.cxx:39
const XclFontData & GetAppFontData() const
Returns the application font data of this file, needed i.e.
Definition: xistyle.hxx:168
Stores all data of an Excel font and provides import of FONT records.
Definition: xistyle.hxx:71
ScRange GetUsedArea(SCTAB nScTab) const
Returns the used area in the sheet with the passed index.
Definition: xiescher.cxx:4402
void ConvertObjects()
Inserts all objects into the Calc document.
Definition: xiescher.cxx:4371
void SetButtonMode(bool bRightOrUnder)
Definition: exctools.cxx:142
void SetLevelRange(SCSIZE nF, SCSIZE nL, sal_uInt8 nVal, bool bCollapsed)
Definition: exctools.cxx:130
void SetLevel(SCSIZE nIndex, sal_uInt8 nVal, bool bCollapsed)
Definition: exctools.cxx:70
XclImpOutlineBfrRef mxRowOutlineBuff
Definition: imp_op.hxx:69
XclImpColRowSettings * GetColRowBuff() const
Definition: imp_op.hxx:59
XclImpOutlineDataBuffer(const XclImpRoot &rRoot, SCTAB nScTab)
Definition: impop.cxx:1395
XclImpOutlineBuffer * GetColOutline() const
Definition: imp_op.hxx:60
XclImpOutlineBuffer * GetRowOutline() const
Definition: imp_op.hxx:61
XclImpColRowSettRef mxColRowBuff
Definition: imp_op.hxx:70
XclImpOutlineBfrRef mxColOutlineBuff
Definition: imp_op.hxx:68
virtual ~XclImpOutlineDataBuffer() override
Definition: impop.cxx:1404
void SetFitToPages(bool bFitToPages)
Sets or clears the fit-to-pages setting (contained in WSBOOL record).
Definition: xipage.hxx:60
Access to global data from other classes.
Definition: xiroot.hxx:129
ScRangeListTabs & GetPrintAreaBuffer() const
Returns the buffer that contains all print areas in the document.
Definition: xiroot.cxx:170
XclImpAddressConverter & GetAddressConverter() const
Returns the address converter.
Definition: xiroot.cxx:123
XclImpXFBuffer & GetXFBuffer() const
Returns the cell formatting attributes buffer.
Definition: xiroot.cxx:160
void FinalizeTable()
Is called when import filter stops importing a single sheet (all BIFF versions).
Definition: xiroot.cxx:115
ScRangeListTabs & GetTitleAreaBuffer() const
Returns the buffer that contains all print titles in the document.
Definition: xiroot.cxx:175
XclImpXFRangeBuffer & GetXFRangeBuffer() const
Returns the buffer of XF index ranges for a sheet.
Definition: xiroot.cxx:165
ScDocumentImport & GetDocImport()
Definition: xiroot.cxx:294
XclImpFontBuffer & GetFontBuffer() const
Returns the font buffer.
Definition: xiroot.cxx:150
XclImpDocProtectBuffer & GetDocProtectBuffer() const
Returns the document protection options.
Definition: xiroot.cxx:244
XclImpDocViewSettings & GetDocViewSettings() const
Returns the view settings of the entire document.
Definition: xiroot.cxx:255
void InitializeTable(SCTAB nScTab)
Is called when import filter starts importing a single sheet (all BIFF versions).
Definition: xiroot.cxx:99
const XclImpRoot & GetRoot() const
Returns this root instance - for code readability in derived classes.
Definition: xiroot.hxx:134
XclImpPageSettings & GetPageSettings() const
Returns the page settings of the current sheet.
Definition: xiroot.cxx:250
XclImpSheetProtectBuffer & GetSheetProtectBuffer() const
Returns the sheet protection options of the current sheet.
Definition: xiroot.cxx:238
XclImpObjectManager & GetObjectManager() const
Returns the drawing object manager.
Definition: xiroot.cxx:196
void SetCodePage(sal_uInt16 nCodePage)
Sets a code page read from a CODEPAGE record for byte string import.
Definition: xiroot.cxx:93
void ReadProtect(XclImpStream &rStrm, SCTAB nTab)
Definition: xicontent.cxx:1346
void ReadPasswordHash(XclImpStream &rStrm, SCTAB nTab)
Definition: xicontent.cxx:1382
sal_uInt16 GetRecId() const
Returns the current record ID.
Definition: xistream.hxx:353
void EnableDecryption(bool bEnable=true)
Switches usage of current decryption algorithm on/off.
Definition: xistream.cxx:522
void DisableDecryption()
Switches usage of current decryption algorithm off.
Definition: xistream.hxx:334
std::size_t GetRecLeft()
Returns remaining data size of the whole record without record headers.
Definition: xistream.cxx:582
sal_uInt8 ReaduInt8()
Definition: xistream.cxx:617
sal_uInt32 ReaduInt32()
Definition: xistream.cxx:685
void Ignore(std::size_t nBytes)
Seeks forward inside the current record.
Definition: xistream.cxx:798
sal_uInt16 ReaduInt16()
Definition: xistream.cxx:649
sal_Int32 ReadInt32()
Definition: xistream.cxx:667
OUString ReadByteString(bool b16BitLen)
Reads 8/16 bit string length, character array and returns the string.
Definition: xistream.cxx:959
double ReadDouble()
Definition: xistream.cxx:703
static void SetToDocument(ScDocumentImport &rDoc, const ScAddress &rPos, const XclImpRoot &rRoot, const XclImpString &rString, sal_uInt16 nXFIndex)
Definition: xihelper.cxx:223
This class represents an unformatted or formatted string and provides importing from stream.
Definition: xistring.hxx:31
bool IsRich() const
Returns true, if the string contains formatting information.
Definition: xistring.hxx:56
void Read(XclImpStream &rStrm, XclStrFlags nFlags=XclStrFlags::NONE)
Reads a complete string from the passed stream.
Definition: xistring.cxx:42
void ReadFormats(XclImpStream &rStrm)
Reads and appends the formatting information (run count and runs) from stream.
Definition: xistring.hxx:46
static void DecodeUrl(OUString &rUrl, OUString &rTabName, bool &rbSameWb, const XclImpRoot &rRoot, const OUString &rEncodedUrl)
Decodes an encoded external document URL with optional sheet name.
Definition: xihelper.cxx:603
XclImpXF * GetXF(sal_uInt16 nXFIndex)
Returns the object that stores all contents of an XF record.
Definition: xistyle.hxx:495
void SetBoolXF(const ScAddress &rScPos, sal_uInt16 nXFIndex)
Inserts a new XF index for boolean cells.
Definition: xistyle.cxx:1936
void SetBlankXF(const ScAddress &rScPos, sal_uInt16 nXFIndex)
Inserts a new XF index for blank cells.
Definition: xistyle.cxx:1931
void SetXF(const ScAddress &rScPos, sal_uInt16 nXFIndex)
Inserts a new XF index.
Definition: xistyle.cxx:1926
void SetRowDefXF(SCROW nScRow, sal_uInt16 nXFIndex)
Inserts a new XF index for all cells in a row.
Definition: xistyle.cxx:1941
void SetMerge(SCCOL nScCol1, SCROW nScRow1, SCCOL nScCol2, SCROW nScRow2)
Inserts a complete merged cell range.
Definition: xistyle.cxx:1979
static void ApplyPatternForBiff2CellFormat(const XclImpRoot &rRoot, const ScAddress &rScPos, sal_uInt8 nFlags1, sal_uInt8 nFlags2, sal_uInt8 nFlags3)
Converts formatting information from BIFF2 cell record data directly.
Definition: xistyle.cxx:1427
SfxObjectShell * GetDocShell() const
Returns the object shell of the Calc document.
Definition: xlroot.cxx:291
ScModelObj * GetDocModelObj() const
Returns the object model of the Calc document.
Definition: xlroot.cxx:296
const OUString & GetDocUrl() const
Returns the document URL of the imported/exported file.
Definition: xlroot.hxx:172
ScExtDocOptions & GetExtDocOptions() const
Returns the extended document options.
Definition: xlroot.cxx:429
const ScAddress & GetScMaxPos() const
Returns the highest possible cell address in a Calc document.
Definition: xlroot.hxx:244
rtl_TextEncoding GetTextEncoding() const
Returns the text encoding to import/export byte strings.
Definition: xlroot.hxx:147
void SetDocLanguage(LanguageType eLang)
Sets the document language.
Definition: xlroot.hxx:251
tools::Long GetCharWidth() const
Returns the width of the '0' character (default font) for the current printer (twips).
Definition: xlroot.hxx:157
SfxMedium & GetMedium() const
Returns the medium to import from.
Definition: xlroot.hxx:170
void SetTextEncoding(rtl_TextEncoding eTextEnc)
Sets the text encoding to import/export byte strings.
Definition: xlroot.cxx:202
XclTracer & GetTracer() const
Returns the filter tracer.
Definition: xlroot.cxx:434
void SetUILanguage(LanguageType eLang)
Sets the UI language, i.e.
Definition: xlroot.hxx:253
SCTAB GetCurrScTab() const
Returns the current Calc sheet index.
Definition: xlroot.hxx:162
ScStyleSheetPool & GetStyleSheetPool() const
Returns the style sheet pool of the Calc document.
Definition: xlroot.cxx:307
XclBiff GetBiff() const
Returns the current BIFF version of the importer/exporter.
Definition: xlroot.hxx:141
RootData & GetOldRoot() const
Returns old RootData struct.
Definition: xlroot.hxx:138
void IncCurrScTab()
Increases the current Calc sheet index by 1.
Definition: xlroot.hxx:263
ScDocument & GetDoc() const
Returns reference to the destination document (import) or source document (export).
Definition: xlroot.cxx:286
static double GetDoubleFromRK(sal_Int32 nRKValue)
GUID of file moniker (HLINK record).
Definition: xltools.cxx:98
static XclBoolError ErrorToEnum(double &rfDblValue, bool bErrOrBool, sal_uInt8 nValue)
Gets a translated error code or Boolean value from Excel error codes.
Definition: xltools.cxx:247
static double GetXclDefColWidthCorrection(tools::Long nXclDefFontHeight)
Returns a correction value to convert column widths from/to default column widths.
Definition: xltools.cxx:321
static sal_uInt16 GetScColumnWidth(sal_uInt16 nXclWidth, tools::Long nScCharWidth)
Returns the Calc column width (twips) for the passed Excel width.
Definition: xltools.cxx:307
void TracePrintRange()
Definition: xltracer.cxx:62
void TraceInvalidRow(sal_uInt32 nRow, sal_uInt32 nMaxrow)
Definition: xltracer.cxx:50
int nCount
URL aURL
BiffTyp
Definition: flttypes.hxx:23
@ Biff4C
Definition: flttypes.hxx:27
@ Biff5C
Definition: flttypes.hxx:28
@ Biff5
Definition: flttypes.hxx:28
@ Biff4
Definition: flttypes.hxx:27
@ Biff5M4
Definition: flttypes.hxx:28
@ Biff4W
Definition: flttypes.hxx:27
@ Biff8
Definition: flttypes.hxx:29
@ Biff2C
Definition: flttypes.hxx:25
@ BiffX
Definition: flttypes.hxx:24
@ Biff3C
Definition: flttypes.hxx:26
@ Biff4M
Definition: flttypes.hxx:27
@ Biff3M
Definition: flttypes.hxx:26
@ Biff5V
Definition: flttypes.hxx:28
@ Biff2M
Definition: flttypes.hxx:25
@ Biff2
Definition: flttypes.hxx:25
@ Biff5W
Definition: flttypes.hxx:28
@ Biff3
Definition: flttypes.hxx:26
@ Biff3W
Definition: flttypes.hxx:26
sal_Int16 nValue
@ FT_SharedFormula
Definition: formel.hxx:51
bool get_flag(Type nBitField, Type nMask)
Returns true, if at least one of the bits set in nMask is set in nBitField.
Definition: ftools.hxx:75
ScVObjMode
Definition: global.hxx:367
@ VOBJ_MODE_SHOW
Definition: global.hxx:368
@ VOBJ_MODE_HIDE
Definition: global.hxx:369
OUString aName
void * p
sal_Int64 n
#define LANGUAGE_DONTKNOW
#define SAL_WARN_IF(condition, area, stream)
#define SAL_WARN(area, stream)
const SfxItemSet * GetItemSet(const SfxPoolItem &rAttr)
void SvStream & rStrm
sal_uInt16 CountryId
constexpr std::enable_if_t< std::is_signed_v< T >, std::make_unsigned_t< T > > make_unsigned(T value)
std::shared_ptr< T > make_shared(Args &&... args)
long Long
vcl::Font GetFont(vcl::Font const &rFont, DrawModeFlags nDrawMode, StyleSettings const &rStyleSettings)
QPRO_FUNC_TYPE nType
Definition: qproform.cxx:398
OUString ScResId(TranslateId aId)
Definition: scdll.cxx:90
constexpr TypedWhichId< SfxUInt16Item > ATTR_PAGE_FIRSTPAGENO(177)
ScFormulaCell * mpCell
Definition: imp_op.hxx:83
XclImpRoot * pIR
Definition: root.hxx:59
BiffTyp eDateiTyp
Definition: root.hxx:45
std::unique_ptr< ExtNameBuff > pExtNameBuff
Definition: root.hxx:48
XclImpColRowSettings * pColRowBuff
Definition: root.hxx:50
ExcelToSc * pFmlaConverter
Definition: root.hxx:49
std::unique_ptr< SharedFormulaBuffer > pShrfmlaBuff
Definition: root.hxx:47
std::unique_ptr< ExtSheetBuffer > pExtSheetBuff
Definition: root.hxx:46
Extended settings for the document, used in import/export filters.
Definition: scextopt.hxx:28
SCTAB mnDisplTab
Index of displayed sheet.
Definition: scextopt.hxx:32
Extended settings for a sheet, used in import/export filters.
Definition: scextopt.hxx:48
ScRange maUsedArea
Used area in the sheet (columns/rows only).
Definition: scextopt.hxx:49
Parameter for data table aka multiple operations.
Definition: paramisc.hxx:46
ScRefAddress aRefFormulaEnd
Definition: paramisc.hxx:50
ScRefAddress aRefColCell
Definition: paramisc.hxx:52
ScRefAddress aRefFormulaCell
Definition: paramisc.hxx:49
ScRefAddress aRefRowCell
Definition: paramisc.hxx:51
A 2D cell address struct with Excel column and row indexes.
Definition: xladdress.hxx:30
sal_uInt16 mnCol
Definition: xladdress.hxx:31
sal_uInt32 mnRow
Definition: xladdress.hxx:32
sal_uInt16 mnHeight
Font color.
Definition: xlstyle.hxx:288
Stores global buffers and data needed for Excel import filter.
Definition: xiroot.hxx:64
A 2D cell range address struct with Excel column and row indexes.
Definition: xladdress.hxx:59
XclAddress maFirst
Definition: xladdress.hxx:60
sal_uInt16 GetColCount() const
Definition: xladdress.hxx:72
XclAddress maLast
Definition: xladdress.hxx:61
void Read(XclImpStream &rStrm, bool bCol16Bit=true)
Definition: xladdress.cxx:46
unsigned char sal_uInt8
#define SAL_MAX_UINT16
sal_Int16 SCTAB
Definition: types.hxx:22
sal_Int16 SCCOL
Definition: types.hxx:21
sal_Int32 SCROW
Definition: types.hxx:17
constexpr OUStringLiteral SC_UNO_APPLYFMDES
Definition: unonames.hxx:536
@ VOBJ_TYPE_CHART
Definition: viewopti.hxx:54
@ VOBJ_TYPE_OLE
Definition: viewopti.hxx:53
@ VOBJ_TYPE_DRAW
Definition: viewopti.hxx:55
const SCCOL EXC_MAXCOL8
Definition: xlconst.hxx:64
const SCROW EXC_MAXROW8
Definition: xlconst.hxx:65
@ EXC_BIFF5
MS Excel 4.0.
Definition: xlconst.hxx:34
@ EXC_BIFF2
Definition: xlconst.hxx:31
@ EXC_BIFF8
MS Excel 5.0, MS Excel 7.0 (95)
Definition: xlconst.hxx:35
const sal_uInt16 EXC_WSBOOL_ROWBELOW
Definition: xlconst.hxx:184
const sal_uInt16 EXC_WSBOOL_FITTOPAGE
Definition: xlconst.hxx:186
const sal_uInt16 EXC_WSBOOL_COLBELOW
Definition: xlconst.hxx:185
XclStrFlags
Flags used to specify import/export mode of strings.
Definition: xlstring.hxx:29
@ EightBitLength
Always use UCS-2 characters (default: try to compress). BIFF8 only.
const sal_uInt16 EXC_ROW_USEDEFXF
Definition: xltable.hxx:85
const sal_uInt16 EXC_ID2_LABEL
Definition: xltable.hxx:47
const sal_uInt16 EXC_TABLEOP_ROW
Definition: xltable.hxx:128
const sal_uInt16 EXC_ID4_FORMULA
Definition: xltable.hxx:62
const sal_uInt8 EXC_BOOLERR_BOOL
Definition: xltable.hxx:56
const sal_uInt16 EXC_ROW_COLLAPSED
Definition: xltable.hxx:82
const sal_uInt16 EXC_ROW_XFMASK
Definition: xltable.hxx:88
const sal_uInt16 EXC_ID2_FORMULA
Definition: xltable.hxx:60
const sal_uInt16 EXC_ID2_DIMENSIONS
Definition: xltable.hxx:32
const sal_uInt16 EXC_DEFROW_UNSYNCED
Definition: xltable.hxx:114
const sal_uInt16 EXC_TABLEOP_BOTH
Definition: xltable.hxx:129
const sal_uInt16 EXC_COLINFO_COLLAPSED
Definition: xltable.hxx:144
const sal_uInt16 EXC_ID3_FORMULA
Definition: xltable.hxx:61
const sal_uInt16 EXC_ID2_NUMBER
Definition: xltable.hxx:43
const sal_uInt16 EXC_ID2_BOOLERR
Definition: xltable.hxx:53
const sal_uInt16 EXC_COLINFO_HIDDEN
Definition: xltable.hxx:142
const sal_uInt16 EXC_ID2_BLANK
Definition: xltable.hxx:36