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{
100 nBdshtTab = 0;
101
102 // fill in root data - after new's without root as parameter
103 pExcRoot = &GetOldRoot();
104 pExcRoot->pIR = this; // ExcRoot -> XclImpRoot
106 pExcRoot->pExtSheetBuff.reset( new ExtSheetBuffer( pExcRoot ) ); //&aExtSheetBuff;
107 pExcRoot->pShrfmlaBuff.reset( new SharedFormulaBuffer( pExcRoot ) ); //&aShrfrmlaBuff;
108 pExcRoot->pExtNameBuff.reset( new ExtNameBuff ( *this ) );
109
111
112 // from Biff8 on
113 pFormConv.reset(new ExcelToSc( GetRoot() ));
115
116 bTabTruncated = false;
117
118 // Excel document per Default on 31.12.1899, accords to Excel settings with 1.1.1900
120 aOpt.SetDate( 30, 12, 1899 );
121 rD.SetDocOptions( aOpt );
122 rD.GetFormatTable()->ChangeNullDate( 30, 12, 1899 );
123
124 ScDocOptions aDocOpt( rD.GetDocOptions() );
125 aDocOpt.SetIgnoreCase( true ); // always in Excel
126 aDocOpt.SetFormulaRegexEnabled( false ); // regular expressions? what's that?
127 aDocOpt.SetFormulaWildcardsEnabled( true ); // Excel uses wildcard expressions
128 aDocOpt.SetLookUpColRowNames( false ); // default: no natural language refs
129 rD.SetDocOptions( aDocOpt );
130}
131
133{
135
136 pOutlineListBuffer.reset();
137
138 pFormConv.reset();
139}
140
141void ImportExcel::SetLastFormula( SCCOL nCol, SCROW nRow, double fVal, sal_uInt16 nXF, ScFormulaCell* pCell )
142{
143 LastFormulaMapType::iterator it = maLastFormulaCells.find(nCol);
144 if (it == maLastFormulaCells.end())
145 {
146 std::pair<LastFormulaMapType::iterator, bool> r =
147 maLastFormulaCells.emplace(nCol, LastFormula());
148 it = r.first;
149 }
150
151 it->second.mnCol = nCol;
152 it->second.mnRow = nRow;
153 it->second.mpCell = pCell;
154 it->second.mfValue = fVal;
155 it->second.mnXF = nXF;
156
157 mpLastFormula = &it->second;
158}
159
161{
162 sal_uInt16 nRecommendReadOnly, nPasswordHash;
163 nRecommendReadOnly = maStrm.ReaduInt16();
164 nPasswordHash = maStrm.ReaduInt16();
165
166 if((nRecommendReadOnly == 0) && (nPasswordHash == 0))
167 return;
168
169 if( SfxItemSet* pItemSet = GetMedium().GetItemSet() )
170 pItemSet->Put( SfxBoolItem( SID_DOC_READONLY, true ) );
171
172 if( SfxObjectShell* pShell = GetDocShell() )
173 {
174 if( nRecommendReadOnly != 0 )
175 pShell->SetLoadReadonly( true );
176 if( nPasswordHash != 0 )
177 pShell->SetModifyPasswordHash( nPasswordHash );
178 }
179}
180
181sal_uInt16 ImportExcel::ReadXFIndex( const ScAddress& rScPos, bool bBiff2 )
182{
183 sal_uInt16 nXFIdx = 0;
184 if( bBiff2 )
185 {
186 /* #i71453# On first call, check if the file contains XF records (by
187 trying to access the first XF with index 0). If there are no XFs,
188 the explicit formatting information contained in each cell record
189 will be used instead. */
190 if( !mbBiff2HasXfsValid )
191 {
192 mbBiff2HasXfsValid = true;
193 mbBiff2HasXfs = GetXFBuffer().GetXF( 0 ) != nullptr;
194 }
195 // read formatting information (includes the XF identifier)
196 sal_uInt8 nFlags1, nFlags2, nFlags3;
197 nFlags1 = maStrm.ReaduInt8();
198 nFlags2 = maStrm.ReaduInt8();
199 nFlags3 = maStrm.ReaduInt8();
200 /* If the file contains XFs, extract and set the XF identifier,
201 otherwise get the explicit formatting. */
202 if( mbBiff2HasXfs )
203 {
204 nXFIdx = ::extract_value< sal_uInt16 >( nFlags1, 0, 6 );
205 /* If the identifier is equal to 63, then the real identifier is
206 contained in the preceding IXFE record (stored in mnBiff2XfId). */
207 if( nXFIdx == 63 )
208 nXFIdx = mnIxfeIndex;
209 }
210 else
211 {
212 /* Let the XclImpXF class do the conversion of the imported
213 formatting. The XF buffer is empty, therefore will not do any
214 conversion based on the XF index later on. */
215 XclImpXF::ApplyPatternForBiff2CellFormat( GetRoot(), rScPos, nFlags1, nFlags2, nFlags3 );
216 }
217 }
218 else
219 nXFIdx = aIn.ReaduInt16();
220 return nXFIdx;
221}
222
224{
225 XclRange aXclUsedArea;
226 if( (maStrm.GetRecId() == EXC_ID2_DIMENSIONS) || (GetBiff() <= EXC_BIFF5) )
227 {
228 maStrm >> aXclUsedArea;
229 if( (aXclUsedArea.GetColCount() > 1) && (aXclUsedArea.GetRowCount() > 1) )
230 {
231 // Excel stores first unused row/column index
232 --aXclUsedArea.maLast.mnCol;
233 --aXclUsedArea.maLast.mnRow;
234 // create the Calc range
235 SCTAB nScTab = GetCurrScTab();
237 GetAddressConverter().ConvertRange( rScUsedArea, aXclUsedArea, nScTab, nScTab, false );
238 // if any error occurs in ConvertRange(), rScUsedArea keeps untouched
239 }
240 }
241 else
242 {
243 sal_uInt32 nXclRow1 = 0, nXclRow2 = 0;
244 nXclRow1 = maStrm.ReaduInt32();
245 nXclRow2 = maStrm.ReaduInt32();
246 aXclUsedArea.maFirst.mnCol = maStrm.ReaduInt16();
247 aXclUsedArea.maLast.mnCol = maStrm.ReaduInt16();
248 if( (nXclRow1 < nXclRow2) && (aXclUsedArea.GetColCount() > 1) &&
249 (nXclRow1 <= o3tl::make_unsigned( GetScMaxPos().Row() )) )
250 {
251 // Excel stores first unused row/column index
252 --nXclRow2;
253 --aXclUsedArea.maLast.mnCol;
254 // convert row indexes to 16-bit values
255 aXclUsedArea.maFirst.mnRow = static_cast< sal_uInt16 >( nXclRow1 );
256 aXclUsedArea.maLast.mnRow = limit_cast< sal_uInt16 >( nXclRow2, aXclUsedArea.maFirst.mnRow, SAL_MAX_UINT16 );
257 // create the Calc range
258 SCTAB nScTab = GetCurrScTab();
260 GetAddressConverter().ConvertRange( rScUsedArea, aXclUsedArea, nScTab, nScTab, false );
261 // if any error occurs in ConvertRange(), rScUsedArea keeps untouched
262 }
263 }
264}
265
267{
268 XclAddress aXclPos;
269 aIn >> aXclPos;
270
272 if( GetAddressConverter().ConvertAddress( aScPos, aXclPos, GetCurrScTab(), true ) )
273 {
274 sal_uInt16 nXFIdx = ReadXFIndex( aScPos, maStrm.GetRecId() == EXC_ID2_BLANK );
275
276 GetXFRangeBuffer().SetBlankXF( aScPos, nXFIdx );
277 }
278}
279
281{
282 XclAddress aXclPos;
283 maStrm >> aXclPos;
284
286 if( GetAddressConverter().ConvertAddress( aScPos, aXclPos, GetCurrScTab(), true ) )
287 {
288 sal_uInt16 nXFIdx = ReadXFIndex( aScPos, true );
289 sal_uInt16 nValue;
291
292 GetXFRangeBuffer().SetXF( aScPos, nXFIdx );
294 }
295}
296
298{
299 XclAddress aXclPos;
300 maStrm >> aXclPos;
301
303 if( GetAddressConverter().ConvertAddress( aScPos, aXclPos, GetCurrScTab(), true ) )
304 {
305 sal_uInt16 nXFIdx = ReadXFIndex( aScPos, maStrm.GetRecId() == EXC_ID2_NUMBER );
306 double fValue;
307 fValue = maStrm.ReadDouble();
308
309 GetXFRangeBuffer().SetXF( aScPos, nXFIdx );
310 GetDocImport().setNumericCell(aScPos, fValue);
311 }
312}
313
315{
316 XclAddress aXclPos;
317 maStrm >> aXclPos;
318
320 if( !GetAddressConverter().ConvertAddress( aScPos, aXclPos, GetCurrScTab(), true ) )
321 return;
322
323 /* Record ID BIFF XF type String type
324 0x0004 2-7 3 byte 8-bit length, byte string
325 0x0004 8 3 byte 16-bit length, unicode string
326 0x0204 2-7 2 byte 16-bit length, byte string
327 0x0204 8 2 byte 16-bit length, unicode string */
328 bool bBiff2 = maStrm.GetRecId() == EXC_ID2_LABEL;
329 sal_uInt16 nXFIdx = ReadXFIndex( aScPos, bBiff2 );
331 XclImpString aString;
332
333 // #i63105# use text encoding from FONT record
334 rtl_TextEncoding eOldTextEnc = GetTextEncoding();
335 if( const XclImpFont* pFont = GetXFBuffer().GetFont( nXFIdx ) )
336 SetTextEncoding( pFont->GetFontEncoding() );
337 aString.Read( maStrm, nFlags );
338 SetTextEncoding( eOldTextEnc );
339
340 GetXFRangeBuffer().SetXF( aScPos, nXFIdx );
341 XclImpStringHelper::SetToDocument(GetDocImport(), aScPos, GetRoot(), aString, nXFIdx);
342}
343
345{
346 XclAddress aXclPos;
347 maStrm >> aXclPos;
348
350 if( !GetAddressConverter().ConvertAddress( aScPos, aXclPos, GetCurrScTab(), true ) )
351 return;
352
353 sal_uInt16 nXFIdx = ReadXFIndex( aScPos, maStrm.GetRecId() == EXC_ID2_BOOLERR );
357
358 if( nType == EXC_BOOLERR_BOOL )
359 GetXFRangeBuffer().SetBoolXF( aScPos, nXFIdx );
360 else
361 GetXFRangeBuffer().SetXF( aScPos, nXFIdx );
362
363 double fValue;
364 std::unique_ptr<ScTokenArray> pScTokArr = ErrorToFormula( nType != EXC_BOOLERR_BOOL, nValue, fValue );
365 ScFormulaCell* pCell = pScTokArr
366 ? new ScFormulaCell(rD, aScPos, std::move(pScTokArr))
367 : new ScFormulaCell(rD, aScPos);
368 pCell->SetHybridDouble( fValue );
369 GetDocImport().setFormulaCell(aScPos, pCell);
370}
371
373{
374 XclAddress aXclPos;
375 maStrm >> aXclPos;
376
378 if( GetAddressConverter().ConvertAddress( aScPos, aXclPos, GetCurrScTab(), true ) )
379 {
380 sal_uInt16 nXFIdx = ReadXFIndex( aScPos, false );
381 sal_Int32 nRk;
382 nRk = maStrm.ReadInt32();
383
384 GetXFRangeBuffer().SetXF( aScPos, nXFIdx );
386 }
387}
388
390{
392}
393
395{
396 sal_uInt16 nRow, nRowHeight;
397
398 nRow = aIn.ReaduInt16();
399 aIn.Ignore( 4 );
400
401 if( !GetRoot().GetDoc().ValidRow( nRow ) )
402 return;
403
404 nRowHeight = aIn.ReaduInt16(); // specify direct in Twips
405 aIn.Ignore( 2 );
406
407 if( GetBiff() == EXC_BIFF2 )
408 {// -------------------- BIFF2
409 pColRowBuff->SetHeight( nRow, nRowHeight );
410 }
411 else
412 {// -------------------- BIFF5
413 sal_uInt16 nGrbit;
414
415 aIn.Ignore( 2 ); // reserved
416 nGrbit = aIn.ReaduInt16();
417
418 sal_uInt8 nLevel = ::extract_value< sal_uInt8 >( nGrbit, 0, 3 );
419 pRowOutlineBuff->SetLevel( nRow, nLevel, ::get_flag( nGrbit, EXC_ROW_COLLAPSED ) );
420 pColRowBuff->SetRowSettings( nRow, nRowHeight, nGrbit );
421 }
422}
423
425{
426 sal_uInt16 nSubType;
428 maStrm.Ignore( 2 );
429 nSubType = maStrm.ReaduInt16();
430
431 if( nSubType == 0x0020 ) // Chart
433 else if( nSubType == 0x0040 ) // Macro
435 else // #i51490# Excel interprets invalid indexes as worksheet
437}
438
440{
441 // POST: cannot be called after an invalid table!
442 EndSheet();
443 IncCurrScTab();
444}
445
447{
448 if (GetRoot().GetBiff() != EXC_BIFF8)
449 return;
450
452}
453
455{
456 OUString aUrl, aTabName;
457 bool bSameWorkBook;
458 OUString aEncodedUrl( aIn.ReadByteString( false ) );
459 XclImpUrlHelper::DecodeUrl( aUrl, aTabName, bSameWorkBook, *pExcRoot->pIR, aEncodedUrl );
460 mnLastRefIdx = pExcRoot->pExtSheetBuff->Add( aUrl, aTabName, bSameWorkBook );
461}
462
464{
465 if (GetRoot().GetBiff() != EXC_BIFF8)
466 return;
467
469}
470
472{// Default Cell Attributes
473 sal_uInt16 nColMic, nColMac;
474 sal_uInt8 nOpt0;
475
476 nColMic = aIn.ReaduInt16();
477 nColMac = aIn.ReaduInt16();
478
479 OSL_ENSURE( aIn.GetRecLeft() == static_cast<std::size_t>(nColMac - nColMic) * 3 + 2,
480 "ImportExcel::Columndefault - wrong record size" );
481
482 nColMac--;
483
484 if( nColMac > rD.MaxCol() )
485 nColMac = static_cast<sal_uInt16>(rD.MaxCol());
486
487 for( sal_uInt16 nCol = nColMic ; nCol <= nColMac ; nCol++ )
488 {
489 nOpt0 = aIn.ReaduInt8();
490 aIn.Ignore( 2 ); // only 0. Attribute-Byte used
491
492 if( nOpt0 & 0x80 ) // Col hidden?
493 pColRowBuff->HideCol( nCol );
494 }
495}
496
498{
499 sal_uInt16 nFormLen;
500 sal_uInt16 nFirstRow = aIn.ReaduInt16();
501 sal_uInt16 nLastRow = aIn.ReaduInt16();
502 sal_uInt8 nFirstCol = aIn.ReaduInt8();
503 sal_uInt8 nLastCol = aIn.ReaduInt8();
504
505 if( GetBiff() == EXC_BIFF2 )
506 {// BIFF2
507 aIn.Ignore( 1 );
508 nFormLen = aIn.ReaduInt8();
509 }
510 else
511 {// BIFF5
512 aIn.Ignore( 6 );
513 nFormLen = aIn.ReaduInt16();
514 }
515
516 std::unique_ptr<ScTokenArray> pResult;
517
518 if (GetRoot().GetDoc().ValidColRow(nLastCol, nLastRow))
519 {
520 // the read mark is now on the formula, length in nFormLen
521
522 pFormConv->Reset( ScAddress( static_cast<SCCOL>(nFirstCol),
523 static_cast<SCROW>(nFirstRow), GetCurrScTab() ) );
524 pFormConv->Convert(pResult, maStrm, nFormLen, true);
525
526 SAL_WARN_IF(!pResult, "sc", "*ImportExcel::Array25(): ScTokenArray is NULL!");
527 }
528
529 if (pResult)
530 {
532 ScRange aArrayRange(nFirstCol, nFirstRow, GetCurrScTab(), nLastCol, nLastRow, GetCurrScTab());
534 }
535}
536
538{
539 sal_uInt16 n1904;
540
541 n1904 = aIn.ReaduInt16();
542
543 if( n1904 )
544 {// 1904 date system
546 aOpt.SetDate( 1, 1, 1904 );
547 rD.SetDocOptions( aOpt );
548 rD.GetFormatTable()->ChangeNullDate( 1, 1, 1904 );
549 }
550}
551
553{
554 sal_uInt32 nRes;
555 sal_uInt16 nOpt;
556
557 nOpt = aIn.ReaduInt16();
558 nRes = aIn.ReaduInt32();
559
560 aIn.ReadByteString( false ); // name
561
562 if( ( nOpt & 0x0001 ) || ( ( nOpt & 0xFFFE ) == 0x0000 ) )
563 {// external name
565 }
566 else if( nOpt & 0x0010 )
567 {// ole link
568 pExcRoot->pExtNameBuff->AddOLE( mnLastRefIdx, nRes ); // nRes is storage ID
569 }
570 else
571 {// dde link
573 }
574}
575
577{// Column Width
578 sal_uInt8 nColFirst, nColLast;
579 sal_uInt16 nColWidth;
580
581 nColFirst = aIn.ReaduInt8();
582 nColLast = aIn.ReaduInt8();
583 nColWidth = aIn.ReaduInt16();
584
585//TODO: add a check for the unlikely case of changed MAXCOL (-> XclImpAddressConverter)
586// if( nColLast > rD.MaxCol() )
587// nColLast = static_cast<sal_uInt16>(rD.MaxCol());
588
589 sal_uInt16 nScWidth = XclTools::GetScColumnWidth( nColWidth, GetCharWidth() );
590 pColRowBuff->SetWidthRange( nColFirst, nColLast, nScWidth );
591}
592
594{
595 sal_uInt16 nDefHeight;
596 nDefHeight = maStrm.ReaduInt16();
597 nDefHeight &= 0x7FFF;
599}
600
602{
603 if (GetRoot().GetBiff() != EXC_BIFF8)
604 return;
605
607}
608
610{
611 if (GetRoot().GetBiff() != EXC_BIFF8)
612 return;
613
615}
616
618{
619 if (GetRoot().GetBiff() != EXC_BIFF8)
620 return;
621
623}
624
626{
628}
629
631{
633}
634
636{
637 // stored as entire characters -> convert to 1/256 of characters (as in COLINFO)
638 double fDefWidth = 256.0 * maStrm.ReaduInt16();
639
640 if (!pColRowBuff)
641 {
642 SAL_WARN("sc", "*ImportExcel::DefColWidth(): pColRowBuff is NULL!");
643 return;
644 }
645
646 // #i3006# additional space for default width - Excel adds space depending on font size
648 fDefWidth += XclTools::GetXclDefColWidthCorrection( nFontHt );
649
650 sal_uInt16 nScWidth = XclTools::GetScColumnWidth( limit_cast< sal_uInt16 >( fDefWidth ), GetCharWidth() );
651 pColRowBuff->SetDefWidth( nScWidth );
652}
653
655{// Column Formatting Information
656 sal_uInt16 nColFirst, nColLast, nColWidth, nXF;
657 sal_uInt16 nOpt;
658
659 nColFirst = aIn.ReaduInt16();
660 nColLast = aIn.ReaduInt16();
661 nColWidth = aIn.ReaduInt16();
662 nXF = aIn.ReaduInt16();
663 nOpt = aIn.ReaduInt16();
664
665 if( nColFirst > rD.MaxCol() )
666 return;
667
668 if( nColLast > rD.MaxCol() )
669 nColLast = static_cast<sal_uInt16>(rD.MaxCol());
670
671 bool bHidden = ::get_flag( nOpt, EXC_COLINFO_HIDDEN );
672 bool bCollapsed = ::get_flag( nOpt, EXC_COLINFO_COLLAPSED );
673 sal_uInt8 nLevel = ::extract_value< sal_uInt8 >( nOpt, 8, 3 );
674 pColOutlineBuff->SetLevelRange( nColFirst, nColLast, nLevel, bCollapsed );
675
676 if( bHidden )
677 pColRowBuff->HideColRange( nColFirst, nColLast );
678
679 sal_uInt16 nScWidth = XclTools::GetScColumnWidth( nColWidth, GetCharWidth() );
680 pColRowBuff->SetWidthRange( nColFirst, nColLast, nScWidth );
681 pColRowBuff->SetDefaultXF( nColFirst, nColLast, nXF );
682}
683
685{
686 sal_uInt16 nFlags;
687 nFlags = aIn.ReaduInt16();
688
691
693}
694
696{
697 sal_uInt16 nGrbit = 0;
698
699 if( GetBiff() == EXC_BIFF5 )
700 {
702 maSheetOffsets.push_back( aIn.ReaduInt32() );
704 nGrbit = aIn.ReaduInt16();
705 }
706
707 OUString aName( aIn.ReadByteString( false ) );
708
709 SCTAB nScTab = nBdshtTab;
710 if( nScTab > 0 )
711 {
712 OSL_ENSURE( !rD.HasTable( nScTab ), "ImportExcel::Boundsheet - sheet exists already" );
713 rD.MakeTable( nScTab );
714 }
715
716 if( ( nGrbit & 0x0001 ) || ( nGrbit & 0x0002 ) )
717 rD.SetVisible( nScTab, false );
718
719 if( !rD.RenameTab( nScTab, aName ) )
720 {
722 rD.RenameTab( nScTab, aName );
723 }
724
725 nBdshtTab++;
726}
727
729{
730 sal_uInt16 nUICountry, nDocCountry;
731 nUICountry = maStrm.ReaduInt16();
732 nDocCountry = maStrm.ReaduInt16();
733
734 // Store system language in XclRoot
735 LanguageType eLanguage = ::msfilter::ConvertCountryToLanguage( static_cast< ::msfilter::CountryId >( nDocCountry ) );
736 if( eLanguage != LANGUAGE_DONTKNOW )
737 SetDocLanguage( eLanguage );
738
739 // Set Excel UI language in add-in name translator
740 eLanguage = ::msfilter::ConvertCountryToLanguage( static_cast< ::msfilter::CountryId >( nUICountry ) );
741 if( eLanguage != LANGUAGE_DONTKNOW )
742 SetUILanguage( eLanguage );
743}
744
746{
747 if( maStrm.ReaduInt16() != 0 )
748 {
749 ScDocOptions aDocOpt = GetDoc().GetDocOptions();
750 aDocOpt.SetLookUpColRowNames( true );
751 GetDoc().SetDocOptions( aDocOpt );
752 }
753}
754
756{
757 sal_uInt16 nHide;
758 ScVObjMode eOle, eChart, eDraw;
759
760 nHide = aIn.ReaduInt16();
761
763
764 switch( nHide )
765 {
766 case 1: // Placeholders
767 eOle = VOBJ_MODE_SHOW; // in Excel 97 only charts as place holder are displayed
768 eChart = VOBJ_MODE_SHOW; //#i80528# VOBJ_MODE_DUMMY replaced by VOBJ_MODE_SHOW now
769 eDraw = VOBJ_MODE_SHOW;
770 break;
771 case 2: // Hide all
772 eOle = VOBJ_MODE_HIDE;
773 eChart = VOBJ_MODE_HIDE;
774 eDraw = VOBJ_MODE_HIDE;
775 break;
776 default: // Show all
777 eOle = VOBJ_MODE_SHOW;
778 eChart = VOBJ_MODE_SHOW;
779 eDraw = VOBJ_MODE_SHOW;
780 break;
781 }
782
783 aOpts.SetObjMode( VOBJ_TYPE_OLE, eOle );
784 aOpts.SetObjMode( VOBJ_TYPE_CHART, eChart );
785 aOpts.SetObjMode( VOBJ_TYPE_DRAW, eDraw );
786
787 rD.SetViewOptions( aOpts );
788}
789
791{
792 sal_uInt16 nScWidth = XclTools::GetScColumnWidth( maStrm.ReaduInt16(), GetCharWidth() );
793 if (!pColRowBuff)
794 {
795 SAL_WARN("sc", "*ImportExcel::Standardwidth(): pColRowBuff is NULL!");
796 return;
797 }
798 pColRowBuff->SetDefWidth( nScWidth, true );
799}
800
802{
803 switch (mnLastRecId)
804 {
805 case EXC_ID2_FORMULA:
806 case EXC_ID3_FORMULA:
807 case EXC_ID4_FORMULA:
808 // This record MUST immediately follow a FORMULA record.
809 break;
810 default:
811 return;
812 }
813
814 if (!mpLastFormula)
815 // The last FORMULA record should have left this data.
816 return;
817
818 aIn.Ignore( 8 );
819 sal_uInt16 nLenExpr = aIn.ReaduInt16();
820
821 // read mark is now on the formula
822
823 std::unique_ptr<ScTokenArray> pResult;
824
825 // The shared range in this record is erroneous more than half the time.
826 // Don't ever rely on it. Use the one from the formula cell above.
827 SCCOL nCol1 = mpLastFormula->mnCol;
828 SCROW nRow1 = mpLastFormula->mnRow;
829
830 ScAddress aPos(nCol1, nRow1, GetCurrScTab());
831 pFormConv->Reset(aPos);
832 pFormConv->Convert( pResult, maStrm, nLenExpr, true, FT_SharedFormula );
833
834 if (!pResult)
835 {
836 SAL_WARN("sc", "+ImportExcel::Shrfmla(): ScTokenArray is NULL!");
837 return;
838 }
839
840 pExcRoot->pShrfmlaBuff->Store(aPos, *pResult);
841
842 // Create formula cell for the last formula record.
843
845
846 ScFormulaCell* pCell = new ScFormulaCell(rD, aPos, std::move(pResult));
849 rDoc.getDoc().EnsureTable(aPos.Tab());
850 rDoc.setFormulaCell(aPos, pCell);
851 pCell->SetNeedNumberFormat(false);
852 if (std::isfinite(mpLastFormula->mfValue))
854
856 mpLastFormula->mpCell = pCell;
857}
858
860{
861 /* rw (2 bytes): An Rw structure that specifies the row containing the
862 cells with numeric data.
863
864 colFirst (2 bytes): A Col structure that specifies the first column in
865 the series of numeric cells within the sheet. The value of colFirst.col
866 MUST be less than or equal to 254.
867
868 rgrkrec (variable): An array of RkRec structures. Each element in the
869 array specifies an RkRec in the row. The number of entries in the array
870 MUST be equal to the value given by the following formula:
871
872 Number of entries in rgrkrec = (colLast.col – colFirst.col +1)
873
874 colLast (2 bytes): A Col structure that specifies the last column in
875 the set of numeric cells within the sheet. This colLast.col value MUST
876 be greater than the colFirst.col value. */
877
878 XclAddress aXclPos;
879 aIn >> aXclPos;
880
881 XclAddress aCurrXclPos(aXclPos);
882 while (true)
883 {
884 if (aXclPos.mnCol > aCurrXclPos.mnCol)
885 break;
886 if (aIn.GetRecLeft() <= 2)
887 break;
888
889 sal_uInt16 nXF = aIn.ReaduInt16();
890 sal_Int32 nRkNum = aIn.ReadInt32();
891
893 if( GetAddressConverter().ConvertAddress( aScPos, aCurrXclPos, GetCurrScTab(), true ) )
894 {
895 GetXFRangeBuffer().SetXF( aScPos, nXF );
897 }
898 ++aCurrXclPos.mnCol;
899 }
900}
901
903{
904 /* rw (2 bytes): An Rw structure that specifies a row containing the blank
905 cells.
906
907 colFirst (2 bytes): A Col structure that specifies the first column in
908 the series of blank cells within the sheet. The value of colFirst.col
909 MUST be less than or equal to 254.
910
911 rgixfe (variable): An array of IXFCell structures. Each element of this
912 array contains an IXFCell structure corresponding to a blank cell in the
913 series. The number of entries in the array MUST be equal to the value
914 given by the following formula:
915
916 Number of entries in rgixfe = (colLast.col – colFirst.col +1)
917
918 colLast (2 bytes): A Col structure that specifies the last column in
919 the series of blank cells within the sheet. This colLast.col value MUST
920 be greater than colFirst.col value. */
921
922 XclAddress aXclPos;
923 aIn >> aXclPos;
924
925 XclAddress aCurrXclPos(aXclPos);
926 while (true)
927 {
928 if (aXclPos.mnCol > aCurrXclPos.mnCol)
929 break;
930 if (aIn.GetRecLeft() <= 2)
931 break;
932
933 sal_uInt16 nXF = aIn.ReaduInt16();
934
936 if( GetAddressConverter().ConvertAddress( aScPos, aCurrXclPos, GetCurrScTab(), true ) )
937 GetXFRangeBuffer().SetBlankXF( aScPos, nXF );
938 ++aCurrXclPos.mnCol;
939 }
940}
941
943{
944 XclAddress aXclPos;
945 sal_uInt16 nXFIdx;
946 aIn >> aXclPos;
947 nXFIdx = aIn.ReaduInt16();
948
950 if( !GetAddressConverter().ConvertAddress( aScPos, aXclPos, GetCurrScTab(), true ) )
951 return;
952
953 // unformatted Unicode string with separate formatting information
954 XclImpString aString;
955 aString.Read( maStrm );
956
957 // character formatting runs
958 if( !aString.IsRich() )
959 aString.ReadFormats( maStrm );
960
961 GetXFRangeBuffer().SetXF( aScPos, nXFIdx );
962 XclImpStringHelper::SetToDocument(GetDocImport(), aScPos, *this, aString, nXFIdx);
963}
964
966{
968 SCTAB nScTab = GetCurrScTab();
969
970 sal_uInt16 nCount = maStrm.ReaduInt16();
971 sal_uInt16 nIdx = 0;
972 while (true)
973 {
974 if (maStrm.GetRecLeft() < 8)
975 break;
976 if (nIdx >= nCount)
977 break;
978 XclRange aXclRange;
979 maStrm >> aXclRange; // 16-bit rows and columns
981 if( rAddrConv.ConvertRange( aScRange, aXclRange, nScTab, nScTab, true ) )
982 GetXFRangeBuffer().SetMerge( aScRange.aStart.Col(), aScRange.aStart.Row(), aScRange.aEnd.Col(), aScRange.aEnd.Row() );
983 ++nIdx;
984 }
985}
986
988{
989 XclRange aXclOleSize( ScAddress::UNINITIALIZED );
990 maStrm.Ignore( 2 );
991 aXclOleSize.Read( maStrm, false );
992
993 SCTAB nScTab = GetCurrScTab();
994 GetAddressConverter().ConvertRange( maScOleSize, aXclOleSize, nScTab, nScTab, false );
995}
996
998{
999 sal_uInt16 nRow, nRowHeight, nGrbit, nXF;
1000
1001 nRow = aIn.ReaduInt16();
1002 aIn.Ignore( 4 );
1003
1004 SCROW nScRow = static_cast< SCROW >( nRow );
1005
1006 if( !GetRoot().GetDoc().ValidRow( nScRow ) )
1007 return;
1008
1009 nRowHeight = aIn.ReaduInt16(); // specify direct in Twips
1010 aIn.Ignore( 4 );
1011
1012 nRowHeight = nRowHeight & 0x7FFF; // Bit 15: Row Height not changed manually
1013 if( !nRowHeight )
1014 nRowHeight = (GetBiff() == EXC_BIFF2) ? 0x25 : 0x225;
1015
1016 nGrbit = aIn.ReaduInt16();
1017 nXF = aIn.ReaduInt16();
1018
1019 sal_uInt8 nLevel = ::extract_value< sal_uInt8 >( nGrbit, 0, 3 );
1020 pRowOutlineBuff->SetLevel( nScRow, nLevel, ::get_flag( nGrbit, EXC_ROW_COLLAPSED ) );
1021 pColRowBuff->SetRowSettings( nScRow, nRowHeight, nGrbit );
1022
1023 if( nGrbit & EXC_ROW_USEDEFXF )
1024 GetXFRangeBuffer().SetRowDefXF( nScRow, nXF & EXC_ROW_XFMASK );
1025}
1026
1028{
1029 sal_uInt16 nSubType;
1031 maStrm.Ignore( 2 );
1032 nSubType = maStrm.ReaduInt16();
1033
1034 OSL_ENSURE( nSubType != 0x0100, "*ImportExcel::Bof3(): Biff3 as Workbook?!" );
1035 if( nSubType == 0x0100 ) // Book
1037 else if( nSubType == 0x0020 ) // Chart
1039 else if( nSubType == 0x0040 ) // Macro
1041 else // #i51490# Excel interprets invalid indexes as worksheet
1043}
1044
1046{
1047 sal_uInt16 nFirstRow, nLastRow, nFormLen;
1048 sal_uInt8 nFirstCol, nLastCol;
1049
1050 nFirstRow = aIn.ReaduInt16();
1051 nLastRow = aIn.ReaduInt16();
1052 nFirstCol = aIn.ReaduInt8();
1053 nLastCol = aIn.ReaduInt8();
1054 aIn.Ignore( (GetBiff() >= EXC_BIFF5) ? 6 : 2 );
1055 nFormLen = aIn.ReaduInt16();
1056
1057 std::unique_ptr<ScTokenArray> pResult;
1058
1059 if( GetRoot().GetDoc().ValidColRow( nLastCol, nLastRow ) )
1060 {
1061 // the read mark is now on the formula, length in nFormLen
1062
1063 pFormConv->Reset( ScAddress( static_cast<SCCOL>(nFirstCol),
1064 static_cast<SCROW>(nFirstRow), GetCurrScTab() ) );
1065 pFormConv->Convert( pResult, maStrm, nFormLen, true );
1066
1067 SAL_WARN_IF(!pResult, "sc", "+ImportExcel::Array34(): ScTokenArray is NULL!");
1068 }
1069
1070 if (pResult)
1071 {
1073 ScRange aArrayRange(nFirstCol, nFirstRow, GetCurrScTab(), nLastCol, nLastRow, GetCurrScTab());
1075 }
1076}
1077
1079{
1080 sal_uInt16 nFlags, nDefHeight;
1081 nFlags = maStrm.ReaduInt16();
1082 nDefHeight = maStrm.ReaduInt16();
1083
1084 if (!pColRowBuff)
1085 {
1086 SAL_WARN("sc", "*ImportExcel::Defrowheight345(): pColRowBuff is NULL!");
1087 return;
1088 }
1089
1090 pColRowBuff->SetDefHeight( nDefHeight, nFlags );
1091}
1092
1094{
1095 sal_uInt16 nFirstRow = aIn.ReaduInt16();
1096 sal_uInt16 nLastRow = aIn.ReaduInt16();
1097 sal_uInt8 nFirstCol = aIn.ReaduInt8();
1098 sal_uInt8 nLastCol = aIn.ReaduInt8();
1099 sal_uInt16 nGrbit = aIn.ReaduInt16();
1100 sal_uInt16 nInpRow = aIn.ReaduInt16();
1101 sal_uInt16 nInpCol = aIn.ReaduInt16();
1102 sal_uInt16 nInpRow2 = aIn.ReaduInt16();
1103 sal_uInt16 nInpCol2 = aIn.ReaduInt16();
1104
1106 {
1107 //shrink to smallish arbitrary value to not timeout
1108 nLastRow = std::min<sal_uInt16>(nLastRow, MAXROW_30 / 2);
1109 }
1110
1111 if( GetRoot().GetDoc().ValidColRow( nLastCol, nLastRow ) )
1112 {
1113 if( nFirstCol && nFirstRow )
1114 {
1115 ScTabOpParam aTabOpParam;
1117 sal_uInt16 nCol = nFirstCol - 1;
1118 sal_uInt16 nRow = nFirstRow - 1;
1119 SCTAB nTab = GetCurrScTab();
1120 switch (aTabOpParam.meMode)
1121 {
1123 aTabOpParam.aRefFormulaCell.Set(
1124 static_cast<SCCOL>(nFirstCol),
1125 static_cast<SCROW>(nFirstRow - 1), nTab, false,
1126 false, false );
1127 aTabOpParam.aRefFormulaEnd.Set(
1128 static_cast<SCCOL>(nLastCol),
1129 static_cast<SCROW>(nFirstRow - 1), nTab, false,
1130 false, false );
1131 aTabOpParam.aRefColCell.Set( static_cast<SCCOL>(nInpCol),
1132 static_cast<SCROW>(nInpRow), nTab, false, false,
1133 false );
1134 nRow++;
1135 break;
1136 case ScTabOpParam::Row:
1137 aTabOpParam.aRefFormulaCell.Set(
1138 static_cast<SCCOL>(nFirstCol - 1),
1139 static_cast<SCROW>(nFirstRow), nTab, false, false,
1140 false );
1141 aTabOpParam.aRefFormulaEnd.Set(
1142 static_cast<SCCOL>(nFirstCol - 1),
1143 static_cast<SCROW>(nLastRow), nTab, false, false,
1144 false );
1145 aTabOpParam.aRefRowCell.Set( static_cast<SCCOL>(nInpCol),
1146 static_cast<SCROW>(nInpRow), nTab, false, false,
1147 false );
1148 nCol++;
1149 break;
1150 case ScTabOpParam::Both: // TWO-INPUT
1151 aTabOpParam.aRefFormulaCell.Set(
1152 static_cast<SCCOL>(nFirstCol - 1),
1153 static_cast<SCROW>(nFirstRow - 1), nTab, false,
1154 false, false );
1155 aTabOpParam.aRefRowCell.Set( static_cast<SCCOL>(nInpCol),
1156 static_cast<SCROW>(nInpRow), nTab, false, false,
1157 false );
1158 aTabOpParam.aRefColCell.Set( static_cast<SCCOL>(nInpCol2),
1159 static_cast<SCROW>(nInpRow2), nTab, false, false,
1160 false );
1161 break;
1162 }
1163
1165 ScRange aTabOpRange(nCol, nRow, nTab, nLastCol, nLastRow, nTab);
1166 rDoc.setTableOpCells(aTabOpRange, aTabOpParam);
1167 }
1168 }
1169 else
1170 {
1171 bTabTruncated = true;
1172 GetTracer().TraceInvalidRow(nLastRow, rD.MaxRow());
1173 }
1174}
1175
1177{
1178 sal_uInt16 nSubType;
1180 maStrm.Ignore( 2 );
1181 nSubType = maStrm.ReaduInt16();
1182
1183 if( nSubType == 0x0100 ) // Book
1185 else if( nSubType == 0x0020 ) // Chart
1187 else if( nSubType == 0x0040 ) // Macro
1189 else // #i51490# Excel interprets invalid indexes as worksheet
1191}
1192
1194{
1195 //POST: eDateiTyp = Type of the file to be read
1196 sal_uInt16 nSubType, nVers;
1197 BiffTyp eDatei;
1198
1200 nVers = maStrm.ReaduInt16();
1201 nSubType = maStrm.ReaduInt16( );
1202
1203 switch( nSubType )
1204 {
1205 case 0x0005: eDatei = Biff5W; break; // workbook globals
1206 case 0x0006: eDatei = Biff5V; break; // VB module
1207 case 0x0020: eDatei = Biff5C; break; // chart
1208 case 0x0040: eDatei = Biff5M4; break; // macro sheet
1209 case 0x0010: // worksheet
1210 default: eDatei = Biff5; break; // tdf#144732 Excel interprets invalid indexes as worksheet
1211 }
1212
1213 if( nVers == 0x0600 && (GetBiff() == EXC_BIFF8) )
1214 eDatei = static_cast<BiffTyp>( eDatei - Biff5 + Biff8 );
1215
1216 pExcRoot->eDateiTyp = eDatei;
1217}
1218
1220{
1221 pExcRoot->pExtSheetBuff->Reset();
1222
1223 if( GetBiff() <= EXC_BIFF5 )
1224 {
1225 pExcRoot->pExtNameBuff->Reset();
1226 mnLastRefIdx = 0;
1227 }
1228
1229 FinalizeTable();
1230}
1231
1233{
1234 SCTAB nTab = GetCurrScTab();
1235 if( nTab > 0 && !rD.HasTable( nTab ) )
1236 rD.MakeTable( nTab );
1237
1238 if (nTab == 0 && GetBiff() == EXC_BIFF2)
1239 {
1240 // For Excel 2.1 Worksheet file, we need to set the file name as the
1241 // sheet name.
1243 rD.RenameTab(0, aURL.getBase());
1244 }
1245
1246 pExcRoot->pShrfmlaBuff->Clear();
1247 maLastFormulaCells.clear();
1248 mpLastFormula = nullptr;
1249
1250 InitializeTable( nTab );
1251
1252 XclImpOutlineDataBuffer* pNewItem = new XclImpOutlineDataBuffer( GetRoot(), nTab );
1253 pOutlineListBuffer->push_back( std::unique_ptr<XclImpOutlineDataBuffer>(pNewItem) );
1255 pColOutlineBuff = pNewItem->GetColOutline();
1256 pRowOutlineBuff = pNewItem->GetRowOutline();
1257}
1258
1259std::unique_ptr<ScTokenArray> ImportExcel::ErrorToFormula( bool bErrOrVal, sal_uInt8 nError, double& rVal )
1260{
1261 return pFormConv->GetBoolErr( XclTools::ErrorToEnum( rVal, bErrOrVal, nError ) );
1262}
1263
1265{
1266 /* Speed up chart import: import all sheets without charts, then
1267 update row heights (here), last load all charts -> do not any longer
1268 update inside of ScDocShell::ConvertFrom() (causes update of existing
1269 charts during each and every change of row height). */
1270 if( ScModelObj* pDocObj = GetDocModelObj() )
1271 pDocObj->UpdateAllRowHeights();
1272}
1273
1275{
1276 /* Set automatic page numbering in Default page style (default is "page number = 1").
1277 Otherwise hidden tables (i.e. for scenarios) which have Default page style will
1278 break automatic page numbering. */
1279 if( SfxStyleSheetBase* pStyleSheet = GetStyleSheetPool().Find( ScResId( STR_STYLENAME_STANDARD ), SfxStyleFamily::Page ) )
1280 pStyleSheet->GetItemSet().Put( SfxUInt16Item( ATTR_PAGE_FIRSTPAGENO, 0 ) );
1281
1282 // outlines for all sheets, sets hidden rows and columns (#i11776# after filtered ranges)
1283 for (auto& rxBuffer : *pOutlineListBuffer)
1284 rxBuffer->Convert();
1285
1286 // document view settings (before visible OLE area)
1288
1289 // process all drawing objects (including OLE, charts, controls; after hiding rows/columns; before visible OLE area)
1291
1292 // visible area (used if this document is an embedded OLE object)
1293 if( SfxObjectShell* pDocShell = GetDocShell() )
1294 {
1295 // visible area if embedded
1296 const ScExtDocSettings& rDocSett = GetExtDocOptions().GetDocSettings();
1297 SCTAB nDisplScTab = rDocSett.mnDisplTab;
1298
1299 /* #i44077# If a new OLE object is inserted from file, there is no
1300 OLESIZE record in the Excel file. Calculate used area from file
1301 contents (used cells and drawing objects). */
1302 if( !maScOleSize.IsValid() )
1303 {
1304 // used area of displayed sheet (cell contents)
1305 if( const ScExtTabSettings* pTabSett = GetExtDocOptions().GetTabSettings( nDisplScTab ) )
1306 maScOleSize = pTabSett->maUsedArea;
1307 // add all valid drawing objects
1308 ScRange aScObjArea = GetObjectManager().GetUsedArea( nDisplScTab );
1309 if( aScObjArea.IsValid() )
1310 maScOleSize.ExtendTo( aScObjArea );
1311 }
1312
1313 // valid size found - set it at the document
1314 if( maScOleSize.IsValid() )
1315 {
1316 pDocShell->SetVisArea( GetDoc().GetMMRect(
1318 maScOleSize.aEnd.Col(), maScOleSize.aEnd.Row(), nDisplScTab ) );
1319 GetDoc().SetVisibleTab( nDisplScTab );
1320 }
1321 }
1322
1323 // open forms in alive mode (has no effect, if no controls in document)
1324 if( ScModelObj* pDocObj = GetDocModelObj() )
1325 pDocObj->setPropertyValue( SC_UNO_APPLYFMDES, uno::Any( false ) );
1326
1327 // enables extended options to be set to the view after import
1328 GetExtDocOptions().SetChanged( true );
1329
1330 // root data owns the extended document options -> create a new object
1331 GetDoc().SetExtDocOptions( std::make_unique<ScExtDocOptions>( GetExtDocOptions() ) );
1332
1333 const SCTAB nLast = rD.GetTableCount();
1334 const ScRange* p;
1335
1336 if( GetRoot().GetPrintAreaBuffer().HasRanges() )
1337 {
1338 for( SCTAB n = 0 ; n < nLast ; n++ )
1339 {
1341 if( p )
1342 {
1344 while( p )
1345 {
1346 rD.AddPrintRange( n, *p );
1348 }
1349 }
1350 else
1351 {
1352 // #i4063# no print ranges -> print entire sheet
1354 }
1355 }
1357 }
1358
1359 if( !GetRoot().GetTitleAreaBuffer().HasRanges() )
1360 return;
1361
1362 for( SCTAB n = 0 ; n < nLast ; n++ )
1363 {
1365 if( p )
1366 {
1367 bool bRowVirgin = true;
1368 bool bColVirgin = true;
1369
1370 while( p )
1371 {
1372 if( p->aStart.Col() == 0 && p->aEnd.Col() == rD.MaxCol() && bRowVirgin )
1373 {
1374 rD.SetRepeatRowRange( n, *p );
1375 bRowVirgin = false;
1376 }
1377
1378 if( p->aStart.Row() == 0 && p->aEnd.Row() == rD.MaxRow() && bColVirgin )
1379 {
1380 rD.SetRepeatColRange( n, *p );
1381 bColVirgin = false;
1382 }
1383
1385 }
1386 }
1387 }
1388}
1389
1391 XclImpRoot( rRoot ),
1392 mxColOutlineBuff( std::make_shared<XclImpOutlineBuffer>( rRoot.GetXclMaxPos().Col() + 1 ) ),
1393 mxRowOutlineBuff( std::make_shared<XclImpOutlineBuffer>( rRoot.GetXclMaxPos().Row() + 1 ) ),
1394 mxColRowBuff( std::make_shared<XclImpColRowSettings>( rRoot ) ),
1395 mnScTab( nScTab )
1396{
1397}
1398
1400{
1401}
1402
1404{
1405 mxColOutlineBuff->SetOutlineArray( &GetDoc().GetOutlineTable( mnScTab, true )->GetColArray() );
1406 mxColOutlineBuff->MakeScOutline();
1407
1408 mxRowOutlineBuff->SetOutlineArray( &GetDoc().GetOutlineTable( mnScTab, true )->GetRowArray() );
1409 mxRowOutlineBuff->MakeScOutline();
1410
1411 mxColRowBuff->ConvertHiddenFlags( mnScTab );
1412}
1413
1414/* 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:745
LastFormulaMapType maLastFormulaCells
Definition: imp_op.hxx:104
void ReadFileSharing()
Definition: impop.cxx:160
void Shrfmla()
Definition: impop.cxx:801
void Boundsheet()
Definition: impop.cxx:695
void ReadBoolErr()
Definition: impop.cxx:344
void DocPassword()
Definition: impop.cxx:617
void ReadBlank()
Definition: impop.cxx:266
void ReadNumber()
Definition: impop.cxx:297
void DefColWidth()
Definition: impop.cxx:635
virtual void EndSheet()
Definition: impop.cxx:1219
void SheetPassword()
Definition: impop.cxx:446
std::unique_ptr< ScTokenArray > ErrorToFormula(bool bErrOrVal, sal_uInt8 nError, double &rVal)
Definition: impop.cxx:1259
ScRange maScOleSize
Definition: imp_op.hxx:93
sal_uInt16 ReadXFIndex(const ScAddress &rScPos, bool bBiff2)
Definition: impop.cxx:181
void Row25()
Definition: impop.cxx:394
void ReadRk()
Definition: impop.cxx:372
sal_uInt16 mnLastRecId
Current XF identifier from IXFE record.
Definition: imp_op.hxx:109
void Defrowheight2()
Definition: impop.cxx:593
void Hideobj()
Definition: impop.cxx:755
void Colinfo()
Definition: impop.cxx:654
bool bTabTruncated
Definition: imp_op.hxx:113
void Columndefault()
Definition: impop.cxx:471
sal_Int16 mnLastRefIdx
Definition: imp_op.hxx:107
XclImpOutlineBuffer * pRowOutlineBuff
Definition: imp_op.hxx:98
void Ixfe()
Definition: impop.cxx:630
void Standardwidth()
Definition: impop.cxx:790
bool mbBiff2HasXfsValid
Select XF formatting or direct formatting in BIFF2.
Definition: imp_op.hxx:117
void Mulblank()
Definition: impop.cxx:902
sal_uInt16 mnIxfeIndex
Definition: imp_op.hxx:108
SCTAB nBdshtTab
Definition: imp_op.hxx:111
void Country()
Definition: impop.cxx:728
void Bof4()
Definition: impop.cxx:1176
void Row34()
Definition: impop.cxx:997
void ReadLabel()
Definition: impop.cxx:314
void WinProtection()
Definition: impop.cxx:463
void Wsbool()
Definition: impop.cxx:684
void ReadInteger()
Definition: impop.cxx:280
XclImpStream maStrm
Definition: imp_op.hxx:89
void Rec1904()
Definition: impop.cxx:537
RootData * pExcRoot
Definition: imp_op.hxx:87
ImportExcel(XclImpRootData &rImpData, SvStream &rStrm)
Definition: impop.cxx:84
void Bof2()
Definition: impop.cxx:424
void Cellmerging()
Definition: impop.cxx:965
ScfUInt32Vec maSheetOffsets
Definition: imp_op.hxx:92
void Defrowheight345()
Definition: impop.cxx:1078
void Array34()
Definition: impop.cxx:1045
std::unique_ptr< XclImpOutlineListBuffer > pOutlineListBuffer
Definition: imp_op.hxx:102
std::unique_ptr< ExcelToSc > pFormConv
Visible range if embedded.
Definition: imp_op.hxx:95
void Codepage()
Definition: impop.cxx:625
void Bof5()
Definition: impop.cxx:1193
void AdjustRowHeight()
Definition: impop.cxx:1264
void DocProtect()
Definition: impop.cxx:609
void Olesize()
Definition: impop.cxx:987
void Colwidth()
Definition: impop.cxx:576
void Externsheet()
Definition: impop.cxx:454
virtual void PostDocLoad()
Definition: impop.cxx:1274
XclImpOutlineBuffer * pColOutlineBuff
Definition: imp_op.hxx:97
std::vector< std::unique_ptr< XclImpOutlineDataBuffer > > XclImpOutlineListBuffer
Definition: imp_op.hxx:101
void NewTable()
Definition: impop.cxx:1232
void Window1()
Definition: impop.cxx:389
XclImpStream & aIn
Definition: imp_op.hxx:90
XclImpColRowSettings * pColRowBuff
Definition: imp_op.hxx:99
void Mulrk()
Definition: impop.cxx:859
void ReadDimensions()
Definition: impop.cxx:223
void Array25()
Definition: impop.cxx:497
void TableOp()
Definition: impop.cxx:1093
void Bof3()
Definition: impop.cxx:1027
void Eof()
Definition: impop.cxx:439
void Externname25()
Definition: impop.cxx:552
LastFormula * mpLastFormula
Definition: imp_op.hxx:105
void SheetProtect()
Definition: impop.cxx:601
void SetLastFormula(SCCOL nCol, SCROW nRow, double fVal, sal_uInt16 nXF, ScFormulaCell *pCell)
False = mbBiff2HasXfs is undetermined yet.
Definition: impop.cxx:141
virtual ~ImportExcel() override
Definition: impop.cxx:132
void Rstring()
Definition: impop.cxx:942
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:864
SC_DLLPUBLIC void AddPrintRange(SCTAB nTab, const ScRange &rNew)
Adds a new print ranges.
Definition: document.cxx:6424
void SetSrcCharSet(rtl_TextEncoding eNew)
Definition: document.hxx:2134
SC_DLLPUBLIC void EnsureTable(SCTAB nTab)
Definition: documen2.cxx:566
SC_DLLPUBLIC SCROW MaxRow() const
Definition: document.hxx:892
SC_DLLPUBLIC void ClearPrintRanges(SCTAB nTab)
Removes all print ranges.
Definition: document.cxx:6418
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:6430
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:394
SC_DLLPUBLIC void SetRepeatRowRange(SCTAB nTab, std::optional< ScRange > oNew)
Definition: document.cxx:6442
SC_DLLPUBLIC void MakeTable(SCTAB nTab, bool _bNeedsNameCheck=true)
Definition: document.cxx:171
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:194
SC_DLLPUBLIC void SetRepeatColRange(SCTAB nTab, std::optional< ScRange > oNew)
Definition: document.cxx:6436
SC_DLLPUBLIC const ScDocOptions & GetDocOptions() const
Definition: documen3.cxx:1952
SC_DLLPUBLIC void SetVisible(SCTAB nTab, bool bVisible)
Definition: document.cxx:912
SC_DLLPUBLIC SCTAB GetTableCount() const
Definition: document.cxx:316
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:1390
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:1399
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
static bool IsFuzzing()
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:290
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
#define 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