LibreOffice Module sc (master) 1
XclImpChangeTrack.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 <XclImpChangeTrack.hxx>
21#include <sot/storage.hxx>
22#include <svl/numformat.hxx>
23#include <svl/zforlist.hxx>
25#include <sal/log.hxx>
26#include <chgviset.hxx>
27#include <formulacell.hxx>
28#include <chgtrack.hxx>
29#include <xihelper.hxx>
30#include <xilink.hxx>
31#include <externalrefmgr.hxx>
32#include <document.hxx>
33#include <documentimport.hxx>
34#include <excdefs.hxx>
35
36
38 XclImpRoot( rRoot ),
39 aRecHeader(),
40 nTabIdCount( 0 ),
41 bGlobExit( false ),
42 eNestedMode( nmBase )
43{
44 // Verify that the User Names stream exists before going any further. Excel adds both
45 // "Revision Log" and "User Names" streams when Change Tracking is active but the Revision log
46 // remains if Change Tracking is turned off.
48 if( !xUserStrm.is() )
49 return;
50
52 if( !xInStrm.is() )
53 return;
54
55 sal_uInt64 const nStreamLen = xInStrm->TellEnd();
56 if( (xInStrm->GetErrorCode() == ERRCODE_NONE) && (nStreamLen != STREAM_SEEK_TO_END) )
57 {
59 pStrm.reset( new XclImpStream( *xInStrm, GetRoot() ) );
60 pStrm->CopyDecrypterFrom( rBookStrm );
61 pChangeTrack.reset(new ScChangeTrack( GetDoc() ));
62
63 sOldUsername = pChangeTrack->GetUser();
64 pChangeTrack->SetUseFixDateTime( true );
65
67 }
68}
69
71{
72 pChangeTrack.reset();
73 pStrm.reset();
74}
75
77{
78 if( !pAction ) return;
79 switch( aRecHeader.nAccept )
80 {
81 case EXC_CHTR_ACCEPT:
82 pChangeTrack->Accept( pAction );
83 break;
84 case EXC_CHTR_REJECT:
85 break;
86 }
87}
88
89void XclImpChangeTrack::DoAcceptRejectAction( sal_uInt32 nFirst, sal_uInt32 nLast )
90{
91 for( sal_uInt32 nIndex = nFirst; nIndex <= nLast; nIndex++ )
93}
94
95void XclImpChangeTrack::DoInsertRange( const ScRange& rRange, bool bEndOfList )
96{
97 sal_uInt32 nFirst = pChangeTrack->GetActionMax() + 1;
98 pChangeTrack->AppendInsert(rRange, bEndOfList);
99 sal_uInt32 nLast = pChangeTrack->GetActionMax();
100 DoAcceptRejectAction( nFirst, nLast );
101}
102
104{
105 sal_uLong nFirst, nLast;
106 pChangeTrack->AppendDeleteRange( rRange, &GetDoc() , nFirst, nLast );
107 DoAcceptRejectAction( nFirst, nLast );
108}
109
111{
112 return static_cast<SCTAB>(GetTabInfo().GetCurrentIndex(
113 pStrm->ReaduInt16(), nTabIdCount ));
114}
115
117{
118 sal_uInt16 nYear;
119 sal_uInt8 nMonth, nDay, nHour, nMin, nSec;
120
121 nYear = pStrm->ReaduInt16();
122 nMonth = pStrm->ReaduInt8();
123 nDay = pStrm->ReaduInt8();
124 nHour = pStrm->ReaduInt8();
125 nMin = pStrm->ReaduInt8();
126 nSec = pStrm->ReaduInt8();
127
128 rDateTime.SetYear( nYear );
129 rDateTime.SetMonth( nMonth );
130 rDateTime.SetDay( nDay );
131 rDateTime.SetHour( nHour );
132 rDateTime.SetMin( nMin );
133 rDateTime.SetSec( nSec );
134 rDateTime.SetNanoSec( 0 );
135}
136
137bool XclImpChangeTrack::CheckRecord( sal_uInt16 nOpCode )
138{
139 if( (nOpCode != EXC_CHTR_OP_UNKNOWN) && (aRecHeader.nOpCode != nOpCode) )
140 {
141 OSL_FAIL( "XclImpChangeTrack::CheckRecord - unknown action" );
142 return false;
143 }
144 return aRecHeader.nIndex != 0;
145}
146
148{
149 if( LookAtuInt8() == 0x01 )
150 {
151 rExtInfo.mbExternal = false;
152 // internal ref - read tab num and return sc tab num (position in TABID list)
153 pStrm->Ignore( 3 );
154 rFirstTab = static_cast< SCTAB >( GetTabInfo().GetCurrentIndex( pStrm->ReaduInt16(), nTabIdCount ) );
155 sal_uInt8 nFillByte = pStrm->ReaduInt8();
156 rLastTab = (nFillByte == 0x00) ?
157 static_cast< SCTAB >( GetTabInfo().GetCurrentIndex( pStrm->ReaduInt16(), nTabIdCount ) ) : rFirstTab;
158 }
159 else
160 {
161 // external ref - read doc and tab name and find sc tab num
162 // - URL
163 OUString aEncUrl( pStrm->ReadUniString() );
164 OUString aUrl;
165 bool bSelf;
166 XclImpUrlHelper::DecodeUrl( aUrl, bSelf, GetRoot(), aEncUrl );
167 pStrm->Ignore( 1 );
168 // - sheet name, always separated from URL
169 OUString aTabName( pStrm->ReadUniString() );
170 pStrm->Ignore( 1 );
171
172 rExtInfo.mbExternal = true;
174 pRefMgr->convertToAbsName(aUrl);
175 rExtInfo.mnFileId = pRefMgr->getExternalFileId(aUrl);
176 rExtInfo.maTabName = aTabName;
177 rFirstTab = rLastTab = 0;
178 }
179}
180
181void XclImpChangeTrack::ReadFormula( std::unique_ptr<ScTokenArray>& rpTokenArray, const ScAddress& rPosition )
182{
183 sal_uInt16 nFmlSize = pStrm->ReaduInt16();
184
185 // create a memory stream and copy the formula to be able to read simultaneously
186 // the formula and the additional 3D tab ref data following the formula
187 // here we have to simulate an Excel record to be able to use an XclImpStream...
188 // 2do: remove the stream member from formula converter and add it as a parameter
189 // to the Convert() routine (to prevent the construction/destruction of the
190 // converter in each formula)
191 SvMemoryStream aMemStrm;
192 aMemStrm.WriteUInt16( 0x0001 ).WriteUInt16( nFmlSize );
193 size_t nRead = pStrm->CopyToStream( aMemStrm, nFmlSize );
194
195 // survive reading invalid streams!
196 // if we can't read as many bytes as required just don't use them and
197 // assume that this part is broken
198 if(nRead != nFmlSize)
199 {
200 rpTokenArray = nullptr;
201 pStrm->Ignore(1);
202 return;
203 }
204
205 XclImpStream aFmlaStrm( aMemStrm, GetRoot() );
206 aFmlaStrm.StartNextRecord();
207 XclImpChTrFmlConverter aFmlConv( GetRoot(), *this );
208
209 // read the formula, 3D tab refs from extended data
210 std::unique_ptr<ScTokenArray> pArray;
211 aFmlConv.Reset( rPosition );
212 bool bOK = (aFmlConv.Convert( pArray, aFmlaStrm, nFmlSize, false ) == ConvErr::OK); // JEG : Check This
213 rpTokenArray = (bOK && pArray) ? std::move( pArray ) : nullptr;
214 pStrm->Ignore( 1 );
215}
216
218 ScCellValue& rCell, sal_uInt32& rFormat, sal_uInt16 nFlags, const ScAddress& rPosition )
219{
220 rCell.clear();
221 rFormat = 0;
222 switch( nFlags & EXC_CHTR_TYPE_MASK )
223 {
225 break;
226 case EXC_CHTR_TYPE_RK:
227 {
228 double fValue = XclTools::GetDoubleFromRK( pStrm->ReadInt32() );
229 if( pStrm->IsValid() )
230 {
231 rCell.set(fValue);
232 }
233 }
234 break;
236 {
237 double fValue = pStrm->ReadDouble();
238 if( pStrm->IsValid() )
239 {
240 rCell.set(fValue);
241 }
242 }
243 break;
245 {
246 OUString sString = pStrm->ReadUniString();
247 if( pStrm->IsValid() )
248 {
249 rCell.set(GetDoc().GetSharedStringPool().intern(sString));
250 }
251 }
252 break;
254 {
255 double fValue = static_cast<double>(pStrm->ReaduInt16() != 0);
256 if( pStrm->IsValid() )
257 {
258 rCell.set(fValue);
259 rFormat = GetFormatter().GetStandardFormat( SvNumFormatType::LOGICAL, ScGlobal::eLnge );
260 }
261 }
262 break;
264 {
265 std::unique_ptr<ScTokenArray> pTokenArray;
266 ReadFormula( pTokenArray, rPosition );
267 if( pStrm->IsValid() && pTokenArray )
268 {
269 rCell.set(new ScFormulaCell(GetDoc(), rPosition, std::move(pTokenArray)));
270 }
271 }
272 break;
273 default:
274 OSL_FAIL( "XclImpChangeTrack::ReadCell - unknown data type" );
275 }
276}
277
279{
280 *pStrm >> aRecHeader;
282 return;
283
288 {
289 OSL_FAIL( "XclImpChangeTrack::ReadChTrInsert - unknown action" );
290 return;
291 }
292
293 ScRange aRange;
294 aRange.aStart.SetTab( ReadTabNum() );
295 aRange.aEnd.SetTab( aRange.aStart.Tab() );
296 sal_uInt16 nFlags = pStrm->ReaduInt16();
297 bool bEndOfList = (nFlags & 0x0001); // row auto-inserted at the bottom.
298 Read2DRange( aRange );
299
301 aRange.aEnd.SetRow( GetDocImport().getDoc().MaxRow() );
302 else
303 aRange.aEnd.SetCol( GetDocImport().getDoc().MaxCol() );
304
305 bool bValid = pStrm->IsValid();
306 if( FoundNestedMode() )
308
309 if( bValid )
310 {
312 DoDeleteRange( aRange );
313 else
314 DoInsertRange(aRange, bEndOfList);
315 }
316}
317
319{
320 pStrm->DisableDecryption();
321 pStrm->Ignore( 32 );
322 OUString sUsername( pStrm->ReadUniString() );
323 if( !pStrm->IsValid() ) return;
324
325 if( !sUsername.isEmpty() )
326 pChangeTrack->SetUser( sUsername );
327 pStrm->Seek( 148 );
328 if( !pStrm->IsValid() ) return;
329
330 DateTime aDateTime( DateTime::EMPTY );
331 ReadDateTime( aDateTime );
332 if( pStrm->IsValid() )
333 pChangeTrack->SetFixDateTimeLocal( aDateTime );
334}
335
337{
338 *pStrm >> aRecHeader;
340 return;
341
342 ScAddress aPosition;
343 SCTAB nTab = ReadTabNum();
344 aPosition.SetTab( nTab );
345 sal_uInt16 nValueType;
346 nValueType = pStrm->ReaduInt16();
347 sal_uInt16 nOldValueType = (nValueType >> 3) & EXC_CHTR_TYPE_MASK;
348 sal_uInt16 nNewValueType = nValueType & EXC_CHTR_TYPE_MASK;
349 pStrm->Ignore( 2 );
350 Read2DAddress( aPosition );
351 sal_uInt16 nOldSize;
352 nOldSize = pStrm->ReaduInt16();
353 SAL_WARN_IF( (nOldSize == 0) != (nOldValueType == EXC_CHTR_TYPE_EMPTY),
354 "sc.filter",
355 "XclImpChangeTrack::ReadChTrCellContent - old value mismatch" );
356 pStrm->Ignore( 4 );
357 switch( nValueType & EXC_CHTR_TYPE_FORMATMASK )
358 {
359 case 0x0000: break;
360 case 0x1100: pStrm->Ignore( 16 ); break;
361 case 0x1300: pStrm->Ignore( 8 ); break;
362 default: OSL_FAIL( "XclImpChangeTrack::ReadChTrCellContent - unknown format info" );
363 }
364
365 ScCellValue aOldCell;
366 ScCellValue aNewCell;
367 sal_uInt32 nOldFormat;
368 sal_uInt32 nNewFormat;
369 ReadCell(aOldCell, nOldFormat, nOldValueType, aPosition);
370 ReadCell(aNewCell, nNewFormat, nNewValueType, aPosition);
371 if( !pStrm->IsValid() || (pStrm->GetRecLeft() > 0) )
372 {
373 OSL_FAIL( "XclImpChangeTrack::ReadChTrCellContent - bytes left, action ignored" );
374 aOldCell.clear();
375 aNewCell.clear();
376 }
377 else
378 {
379 ScChangeActionContent* pNewAction =
380 pChangeTrack->AppendContentOnTheFly(aPosition, aOldCell, aNewCell, nOldFormat, nNewFormat);
381 DoAcceptRejectAction( pNewAction );
382 }
383}
384
386{
387 if( nTabIdCount == 0 ) // read only 1st time, otherwise calculated by <ReadChTrInsertTab()>
388 nTabIdCount = static_cast< sal_uInt16 >( pStrm->GetRecLeft() >> 1 );
389}
390
392{
393 *pStrm >> aRecHeader;
395 return;
396
397 ScRange aSourceRange;
398 ScRange aDestRange;
399 aDestRange.aStart.SetTab( ReadTabNum() );
400 aDestRange.aEnd.SetTab( aDestRange.aStart.Tab() );
401 Read2DRange( aSourceRange );
402 Read2DRange( aDestRange );
403 aSourceRange.aStart.SetTab( ReadTabNum() );
404 aSourceRange.aEnd.SetTab( aSourceRange.aStart.Tab() );
405
406 bool bValid = pStrm->IsValid();
407 if( FoundNestedMode() )
409
410 if( bValid )
411 {
412 pChangeTrack->AppendMove( aSourceRange, aDestRange, nullptr );
414 }
415}
416
418{
419 *pStrm >> aRecHeader;
421 {
422 SCTAB nTab = ReadTabNum();
423 if( pStrm->IsValid() )
424 {
425 nTabIdCount++;
426 DoInsertRange(ScRange(0, 0, nTab, GetDocImport().getDoc().MaxCol(), GetDocImport().getDoc().MaxRow(), nTab), false);
427 }
428 }
429}
430
432{
433 OSL_ENSURE( eNestedMode == nmBase, "XclImpChangeTrack::InitNestedMode - unexpected nested mode" );
434 if( eNestedMode == nmBase )
436}
437
439{
440 OSL_ENSURE( eNestedMode == nmFound, "XclImpChangeTrack::StartNestedMode - missing nested mode" );
441 if( eNestedMode == nmFound )
442 {
444 ReadRecords();
445 }
446}
447
449{
450 OSL_ENSURE( eNestedMode != nmBase, "XclImpChangeTrack::EndNestedMode - missing nested mode" );
451 bool bReturn = (eNestedMode == nmNested);
453 return bReturn;
454}
455
457{
458 bool bExitLoop = false;
459
460 while( !bExitLoop && !bGlobExit && pStrm->StartNextRecord() )
461 {
462 switch( pStrm->GetRecId() )
463 {
464 case 0x000A: bGlobExit = true; break;
465 case 0x0137: ReadChTrInsert(); break;
466 case 0x0138: ReadChTrInfo(); break;
467 case 0x013B: ReadChTrCellContent(); break;
468 case 0x013D: ReadChTrTabId(); break;
469 case 0x0140: ReadChTrMoveRange(); break;
470 case 0x014D: ReadChTrInsertTab(); break;
471 case 0x014E:
472 case 0x0150: InitNestedMode(); break;
473 case 0x014F:
474 case 0x0151: bExitLoop = EndNestedMode(); break;
475 }
476 }
477}
478
480{
481 if( pChangeTrack )
482 {
483 pChangeTrack->SetUser( sOldUsername );
484 pChangeTrack->SetUseFixDateTime( false );
485
486 GetDoc().SetChangeTrack( std::move(pChangeTrack) );
487
488 ScChangeViewSettings aSettings;
489 aSettings.SetShowChanges( true );
490 GetDoc().SetChangeViewSettings( aSettings );
491 }
492}
493
494
496 XclImpRoot& rRoot, XclImpChangeTrack& rXclChTr ) :
497 ExcelToSc8( rRoot ),
498 rChangeTrack( rXclChTr ) {}
499
501{
502}
503
504// virtual, called from ExcToSc8::Convert()
505bool XclImpChTrFmlConverter::Read3DTabReference( sal_uInt16 /*nIxti*/, SCTAB& rFirstTab, SCTAB& rLastTab,
506 ExternalTabInfo& rExtInfo )
507{
508 rChangeTrack.Read3DTabRefInfo( rFirstTab, rLastTab, rExtInfo );
509 return true;
510}
511
512/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
void SetMonth(sal_uInt16 nNewMonth)
void SetYear(sal_Int16 nNewYear)
void SetDay(sal_uInt16 nNewDay)
virtual ConvErr Convert(std::unique_ptr< ScTokenArray > &rpTokArray, XclImpStream &rStrm, std::size_t nFormulaLen, bool bAllowArrays, const FORMULA_TYPE eFT=FT_CellFormula) override
Definition: excform8.cxx:138
SCTAB Tab() const
Definition: address.hxx:283
void SetCol(SCCOL nColP)
Definition: address.hxx:291
void SetRow(SCROW nRowP)
Definition: address.hxx:287
void SetTab(SCTAB nTabP)
Definition: address.hxx:295
void SetShowChanges(bool bFlag)
Definition: chgviset.hxx:78
SC_DLLPUBLIC void SetChangeTrack(std::unique_ptr< ScChangeTrack > pTrack)
only for import filter, deletes any existing ChangeTrack via EndChangeTracking() and takes ownership ...
Definition: documen2.cxx:294
SC_DLLPUBLIC ScExternalRefManager * GetExternalRefManager() const
Definition: documen3.cxx:633
SC_DLLPUBLIC void SetChangeViewSettings(const ScChangeViewSettings &rNew)
Definition: documen2.cxx:1142
sal_uInt16 getExternalFileId(const OUString &rFile)
void convertToAbsName(OUString &rFile) const
Takes a flat file name, and convert it to an absolute URL path.
static SC_DLLPUBLIC LanguageType eLnge
Definition: global.hxx:559
ScAddress aEnd
Definition: address.hxx:498
ScAddress aStart
Definition: address.hxx:497
sal_uInt32 GetStandardFormat(SvNumFormatType eType, LanguageType eLnge=LANGUAGE_DONTKNOW)
SvStream & WriteUInt16(sal_uInt16 nUInt16)
virtual bool Read3DTabReference(sal_uInt16 nIxti, SCTAB &rFirstTab, SCTAB &rLastTab, ExternalTabInfo &rExtInfo) override
XclImpChTrFmlConverter(XclImpRoot &rRoot, XclImpChangeTrack &rXclChTr)
virtual ~XclImpChTrFmlConverter() override
XclImpChangeTrack & rChangeTrack
std::unique_ptr< XclImpStream > pStrm
XclImpChangeTrack(const XclImpRoot &rRoot, const XclImpStream &rBookStrm)
void ReadDateTime(DateTime &rDateTime)
virtual ~XclImpChangeTrack() override
void ReadFormula(std::unique_ptr< ScTokenArray > &rpTokenArray, const ScAddress &rPosition)
void DoInsertRange(const ScRange &rRange, bool bEndOfList)
tools::SvRef< SotStorageStream > xInStrm
XclImpChTrRecHeader aRecHeader
void DoDeleteRange(const ScRange &rRange)
std::unique_ptr< ScChangeTrack > pChangeTrack
void Read3DTabRefInfo(SCTAB &rFirstTab, SCTAB &rLastTab, ExcelToSc8::ExternalTabInfo &rExtInfo)
enum XclImpChangeTrack::@3 eNestedMode
void DoAcceptRejectAction(ScChangeAction *pAction)
void Read2DAddress(ScAddress &rAddress)
bool CheckRecord(sal_uInt16 nOpCode)
void ReadCell(ScCellValue &rCell, sal_uInt32 &rFormat, sal_uInt16 nFlags, const ScAddress &rPosition)
void Read2DRange(ScRange &rRange)
Access to global data from other classes.
Definition: xiroot.hxx:129
ScDocumentImport & GetDocImport()
Definition: xiroot.cxx:294
const XclImpRoot & GetRoot() const
Returns this root instance - for code readability in derived classes.
Definition: xiroot.hxx:134
XclImpTabInfo & GetTabInfo() const
Returns the buffer that contains the sheet creation order.
Definition: xiroot.cxx:180
This class is used to import record oriented streams.
Definition: xistream.hxx:278
bool StartNextRecord()
Sets stream pointer to the start of the next record content.
Definition: xistream.cxx:456
sal_uInt16 GetCurrentIndex(sal_uInt16 nCreatedId, sal_uInt16 nMaxTabId) const
Returns the current sheet index calculated from creation index.
Definition: xilink.cxx:263
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
SvNumberFormatter & GetFormatter() const
Returns the number formatter of the Calc document.
Definition: xlroot.cxx:323
tools::SvRef< SotStorageStream > OpenStream(tools::SvRef< SotStorage > const &xStrg, const OUString &rStrmName) const
Tries to open a new stream in the specified storage for reading or writing.
Definition: xlroot.cxx:274
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
bool is() const
void SetMin(sal_uInt16 nNewMin)
void SetNanoSec(sal_uInt32 nNewNanoSec)
void SetSec(sal_uInt16 nNewSec)
void SetHour(sal_uInt16 nNewHour)
#define ERRCODE_NONE
#define EXC_CHTR_TYPE_STRING
Definition: excdefs.hxx:84
constexpr OUStringLiteral EXC_STREAM_REVLOG
Definition: excdefs.hxx:63
#define EXC_CHTR_TYPE_FORMATMASK
Definition: excdefs.hxx:80
constexpr OUStringLiteral EXC_STREAM_USERNAMES
Definition: excdefs.hxx:62
#define EXC_CHTR_TYPE_DOUBLE
Definition: excdefs.hxx:83
#define EXC_CHTR_OP_DELCOL
Definition: excdefs.hxx:71
#define EXC_CHTR_ACCEPT
Definition: excdefs.hxx:90
#define EXC_CHTR_TYPE_RK
Definition: excdefs.hxx:82
#define EXC_CHTR_TYPE_MASK
Definition: excdefs.hxx:79
#define EXC_CHTR_OP_DELFLAG
Definition: excdefs.hxx:67
#define EXC_CHTR_OP_DELROW
Definition: excdefs.hxx:70
#define EXC_CHTR_OP_INSCOL
Definition: excdefs.hxx:69
#define EXC_CHTR_TYPE_FORMULA
Definition: excdefs.hxx:86
#define EXC_CHTR_OP_CELL
Definition: excdefs.hxx:74
#define EXC_CHTR_OP_COLFLAG
Definition: excdefs.hxx:66
#define EXC_CHTR_REJECT
Definition: excdefs.hxx:91
#define EXC_CHTR_OP_INSROW
Definition: excdefs.hxx:68
#define EXC_CHTR_TYPE_EMPTY
Definition: excdefs.hxx:81
#define EXC_CHTR_OP_INSTAB
Definition: excdefs.hxx:73
#define EXC_CHTR_TYPE_BOOL
Definition: excdefs.hxx:85
#define EXC_CHTR_OP_UNKNOWN
Definition: excdefs.hxx:76
#define EXC_CHTR_OP_MOVE
Definition: excdefs.hxx:72
sal_Int32 nIndex
#define SAL_WARN_IF(condition, area, stream)
sal_uIntPtr sal_uLong
#define STREAM_SEEK_TO_END
#define STREAM_SEEK_TO_BEGIN
Store arbitrary cell value of any kind.
Definition: cellvalue.hxx:32
void set(double fValue)
Definition: cellvalue.cxx:329
void clear() noexcept
Definition: cellvalue.cxx:311
unsigned char sal_uInt8
sal_Int16 SCTAB
Definition: types.hxx:22