LibreOffice Module sc (master) 1
tool.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 <scitems.hxx>
22#include <svl/numformat.hxx>
23#include <svl/zforlist.hxx>
24#include <sal/log.hxx>
25
26#include <attrib.hxx>
27#include <document.hxx>
28
29#include <tool.h>
30#include <lotrange.hxx>
31#include <namebuff.hxx>
32#include <stringutil.hxx>
33#include <tokenarray.hxx>
34#include "lotfilter.hxx"
35
36#include <math.h>
37
38void PutFormString(LotusContext& rContext, SCCOL nCol, SCROW nRow, SCTAB nTab, char* pString)
39{
40 // evaluate Label-Format
41 SAL_WARN_IF( pString == nullptr, "sc.filter", "PutFormString(): pString == NULL" );
42 if (!pString)
43 return;
44
45 char cForm;
46 SvxHorJustifyItem* pJustify = nullptr;
47
48 cForm = *pString;
49
50 switch( cForm )
51 {
52 case '"': // align-right
53 pJustify = rContext.xAttrRight.get();
54 pString++;
55 break;
56 case '\'': // align-left
57 pJustify = rContext.xAttrLeft.get();
58 pString++;
59 break;
60 case '^': // centered
61 pJustify = rContext.xAttrCenter.get();
62 pString++;
63 break;
64 case '|': // printer command
65 pString = nullptr;
66 break;
67 case '\\': // repetition
68 pJustify = rContext.xAttrRepeat.get();
69 pString++;
70 break;
71 default: // undefined case!
72 pJustify = rContext.xAttrStandard.get();
73 }
74
75 if (!pString)
76 return;
77
78 nCol = rContext.rDoc.SanitizeCol(nCol);
79 nRow = rContext.rDoc.SanitizeRow(nRow);
80 nTab = SanitizeTab(nTab);
81
82 rContext.rDoc.ApplyAttr( nCol, nRow, nTab, *pJustify );
83 ScSetStringParam aParam;
84 aParam.setTextInput();
85 rContext.rDoc.SetString(ScAddress(nCol,nRow,nTab), OUString(pString, strlen(pString), rContext.eCharset), &aParam);
86}
87
88void SetFormat(LotusContext& rContext, SCCOL nCol, SCROW nRow, SCTAB nTab, sal_uInt8 nFormat, sal_uInt8 nSt)
89{
90 nCol = rContext.rDoc.SanitizeCol(nCol);
91 nRow = rContext.rDoc.SanitizeRow(nRow);
92 nTab = SanitizeTab(nTab);
93
94 // PREC: nSt = default number of decimal places
95 rContext.rDoc.ApplyAttr(nCol, nRow, nTab, *(rContext.xValueFormCache->GetAttr(nFormat, nSt)));
96
97 ScProtectionAttr aAttr;
98
99 aAttr.SetProtection( nFormat & 0x80 );
100
101 rContext.rDoc.ApplyAttr( nCol, nRow, nTab, aAttr );
102}
103
104double SnumToDouble( sal_Int16 nVal )
105{
106 const double pFacts[ 8 ] = {
107 5000.0,
108 500.0,
109 0.05,
110 0.005,
111 0.0005,
112 0.00005,
113 0.0625,
114 0.015625 };
115
116 double fVal;
117
118 if( nVal & 0x0001 )
119 {
120 fVal = pFacts[ ( nVal >> 1 ) & 0x0007 ];
121 fVal *= static_cast<sal_Int16>( nVal >> 4 );
122 }
123 else
124 fVal = static_cast<sal_Int16>( nVal >> 1 );
125
126 return fVal;
127}
128
129double Snum32ToDouble( sal_uInt32 nValue )
130{
131 double fValue, temp;
132
133 fValue = nValue >> 6;
134 temp = nValue & 0x0f;
135 if (temp)
136 {
137 if (nValue & 0x00000010)
138 fValue /= pow(double(10), temp);
139 else
140 fValue *= pow(double(10), temp);
141 }
142
143 if (nValue & 0x00000020)
144 fValue = -fValue;
145 return fValue;
146}
147
149 : nIndex(0)
150{
151 pFormTable = pDoc1->GetFormatTable();
152 for(bool & rb : bValid)
153 rb = false;
155}
156
158{
159}
160
162{
163 // setup new Format
164 sal_uInt8 nL, nH; // Low-/High-Nibble
165 OUString aFormString;
166 SvNumFormatType eType = SvNumFormatType::ALL;
167 sal_uInt32 nIndex1;
168 sal_uInt32 nHandle;
169 NfIndexTableOffset eIndexTableOffset = NF_NUMERIC_START;
170 bool bDefault = false;
171
172 // split into Low and High byte
173 nL = nFormat & 0x0F;
174 nH = ( nFormat & 0xF0 ) / 16;
175
176 nH &= 0x07; // extract bits 4-6
177 switch( nH )
178 {
179 case 0x00: // fixed-point number
180 //fStandard;nL;
181 nIndex1 = pFormTable->GetStandardFormat(
182 SvNumFormatType::NUMBER, eLanguage );
183 aFormString = pFormTable->GenerateFormat(nIndex1,
184 eLanguage, false, false, nL);
185 break;
186 case 0x01: // scientific notation
187 //fExponent;nL;
188 nIndex1 = pFormTable->GetStandardFormat(
189 SvNumFormatType::SCIENTIFIC, eLanguage );
190 aFormString = pFormTable->GenerateFormat(nIndex1,
191 eLanguage, false, false, nL);
192 break;
193 case 0x02: // currency
194 //fMoney;nL;
195 nIndex1 = pFormTable->GetStandardFormat(
196 SvNumFormatType::CURRENCY, eLanguage );
197 aFormString = pFormTable->GenerateFormat(nIndex1,
198 eLanguage, false, false, nL);
199 break;
200 case 0x03: // percentage
201 //fPercent;nL;
202 nIndex1 = pFormTable->GetStandardFormat(
203 SvNumFormatType::PERCENT, eLanguage );
204 aFormString = pFormTable->GenerateFormat(nIndex1,
205 eLanguage, false, false, nL);
206 break;
207 case 0x04: // Decimal
208 //fStandard;nL;
209 nIndex1 = pFormTable->GetStandardFormat(
210 SvNumFormatType::NUMBER, eLanguage );
211 aFormString = pFormTable->GenerateFormat(nIndex1,
212 eLanguage, true, false, nL);
213 break;
214 case 0x05: // unspecified
215 //fStandard;nL;
216 nIndex1 = pFormTable->GetStandardFormat(
217 SvNumFormatType::NUMBER, eLanguage );
218 aFormString = pFormTable->GenerateFormat(nIndex1,
219 eLanguage, false, false, nL);
220 break;
221 case 0x06: // unspecified
222 //fStandard;nL;
223 nIndex1 = pFormTable->GetStandardFormat(
224 SvNumFormatType::NUMBER, eLanguage );
225 aFormString = pFormTable->GenerateFormat(nIndex1,
226 eLanguage, false, false, nL);
227 break;
228 case 0x07: // Special format
229 switch( nL )
230 {
231 case 0x00: // +/-
232 //fStandard;nSt;
233 nIndex1 = pFormTable->GetStandardFormat(
234 SvNumFormatType::NUMBER, eLanguage );
235 aFormString = pFormTable->GenerateFormat(nIndex1,
236 eLanguage, false, true, nSt);
237 break;
238 case 0x01: // general Format
239 //fStandard;nSt;
240 nIndex1 = pFormTable->GetStandardFormat(
241 SvNumFormatType::NUMBER, eLanguage );
242 aFormString = pFormTable->GenerateFormat(nIndex1,
243 eLanguage, false, false, nSt);
244 break;
245 case 0x02: // Date: Day, Month, Year
246 //fDate;dfDayMonthYearLong;
247 eType = SvNumFormatType::DATE;
248 eIndexTableOffset = NF_DATE_SYS_DDMMYYYY;
249 break;
250 case 0x03: // Date: Day, Month
251 //fDate;dfDayMonthLong;
252 eType = SvNumFormatType::DATE;
253 aFormString = pFormTable->GetKeyword( eLanguage, NF_KEY_DD) +
254 pFormTable->GetDateSep() + // matches last eLanguage
256 break;
257 case 0x04: // Date: Month, Year
258 //fDate;dfMonthYearLong;
259 eType = SvNumFormatType::DATE;
260 aFormString = pFormTable->GetKeyword( eLanguage, NF_KEY_MM) +
261 pFormTable->GetDateSep() + // matches last eLanguage
263 break;
264 case 0x05: // Text formats
265 //fString;nSt;
266 eType = SvNumFormatType::TEXT;
267 eIndexTableOffset = NF_TEXT;
268 break;
269 case 0x06: // hidden
270 //wFlag |= paHideAll;bSetFormat = sal_False;
271 eType = SvNumFormatType::NUMBER;
272 aFormString = "\"\"";
273 break;
274 case 0x07: // Time: hour, min, sec
275 //fTime;tfHourMinSec24;
276 eType = SvNumFormatType::TIME;
277 eIndexTableOffset = NF_TIME_HHMMSS;
278 break;
279 case 0x08: // Time: hour, min
280 //fTime;tfHourMin24;
281 eType = SvNumFormatType::TIME;
282 eIndexTableOffset = NF_TIME_HHMM;
283 break;
284 case 0x09: // Date, intern sal_Int32 1
285 //fDate;dfDayMonthYearLong;
286 eType = SvNumFormatType::DATE;
287 eIndexTableOffset = NF_DATE_SYS_DDMMYYYY;
288 break;
289 case 0x0A: // Date, intern sal_Int32 2
290 //fDate;dfDayMonthYearLong;
291 eType = SvNumFormatType::DATE;
292 eIndexTableOffset = NF_DATE_SYS_DDMMYYYY;
293 break;
294 case 0x0B: // Time, intern sal_Int32 1
295 //fTime;tfHourMinSec24;
296 eType = SvNumFormatType::TIME;
297 eIndexTableOffset = NF_TIME_HHMMSS;
298 break;
299 case 0x0C: // Time, intern sal_Int32 2
300 //fTime;tfHourMinSec24;
301 eType = SvNumFormatType::TIME;
302 eIndexTableOffset = NF_TIME_HHMMSS;
303 break;
304 case 0x0F: // Default
305 //fStandard;nSt;
306 bDefault = true;
307 break;
308 default:
309 //fStandard;nSt;
310 bDefault = true;
311 break;
312 }
313 break;
314 }
315
316 // push Format into table
317 if( bDefault )
318 nHandle = 0;
319 else if (eIndexTableOffset != NF_NUMERIC_START)
320 nHandle = pFormTable->GetFormatIndex( eIndexTableOffset, eLanguage);
321 else
322 {
323 sal_Int32 nDummy;
324 pFormTable->PutEntry( aFormString, nDummy, eType, nHandle, eLanguage );
325 }
326
328}
329
331{
332 // 33222222222211111111110000000000
333 // 10987654321098765432109876543210
334 // ******** nColS
335 // ******** nColE
336 // **************** nRowS
337 // **************** nRowE
338 nHash = static_cast<sal_uInt32>(nColStart);
339 nHash += static_cast<sal_uInt32>(nColEnd) << 6;
340 nHash += static_cast<sal_uInt32>(nRowStart) << 12;
341 nHash += static_cast<sal_uInt32>(nRowEnd ) << 16;
342}
343
345{
346 nColStart = nColEnd = nCol;
347 nRowStart = nRowEnd = nRow;
348 nId = ID_FAIL;
349 MakeHash();
350}
351
353{
354 nColStart = nCS;
355 nColEnd = nCE;
356 nRowStart = nRS;
357 nRowEnd = nRE;
358 nId = ID_FAIL;
359 MakeHash();
360}
361
363{
364 Copy( rCpy );
365}
366
368{
370
371 ScSingleRefData* pSingRef;
372 nIdCnt = 1;
373
374 pSingRef = &aComplRef.Ref1;
375 pSingRef->SetRelTab(0);
376 pSingRef->SetColRel( false );
377 pSingRef->SetRowRel( false );
378 pSingRef->SetFlag3D( false );
379
380 pSingRef = &aComplRef.Ref2;
381 pSingRef->SetRelTab(0);
382 pSingRef->SetColRel( false );
383 pSingRef->SetRowRel( false );
384 pSingRef->SetFlag3D( false );
385}
386
388{
389}
390
392{
393 auto pIter = std::find_if(maRanges.begin(), maRanges.end(),
394 [&rRef](const std::unique_ptr<LotusRange>& pRange) { return rRef == *pRange; });
395 if (pIter != maRanges.end())
396 return (*pIter)->nId;
397
398 return ID_FAIL;
399}
400
401void LotusRangeList::Append( const ScDocument* pDoc, std::unique_ptr<LotusRange> pLR )
402{
403 assert( pLR );
404 auto pLRTmp = pLR.get();
405 maRanges.push_back(std::move(pLR));
406
407 ScTokenArray aTokArray(*pDoc);
408
409 ScSingleRefData* pSingRef = &aComplRef.Ref1;
410
411 pSingRef->SetAbsCol(pLRTmp->nColStart);
412 pSingRef->SetAbsRow(pLRTmp->nRowStart);
413
414 if( pLRTmp->IsSingle() )
415 aTokArray.AddSingleReference( *pSingRef );
416 else
417 {
418 pSingRef = &aComplRef.Ref2;
419 pSingRef->SetAbsCol(pLRTmp->nColEnd);
420 pSingRef->SetAbsRow(pLRTmp->nRowEnd);
421 aTokArray.AddDoubleReference( aComplRef );
422 }
423
424 pLRTmp->SetId( nIdCnt );
425
426 nIdCnt++;
427}
428
430 : pScTokenArray( new ScTokenArray(rDoc) )
431{
432 nIntCount = 1;
433}
434
436{
437}
438
439void RangeNameBufferWK3::Add( const ScDocument& rDoc, const OUString& rOrgName, const ScComplexRefData& rCRD )
440{
441 Entry aInsert( rOrgName, rCRD );
442
443 pScTokenArray->Clear();
444
445 const ScSingleRefData& rRef1 = rCRD.Ref1;
446 const ScSingleRefData& rRef2 = rCRD.Ref2;
447 ScAddress aAbs1 = rRef1.toAbs(rDoc, ScAddress());
448 ScAddress aAbs2 = rRef2.toAbs(rDoc, ScAddress());
449 if (aAbs1 == aAbs2)
450 {
451 pScTokenArray->AddSingleReference( rCRD.Ref1 );
452 aInsert.bSingleRef = true;
453 }
454 else
455 {
456 pScTokenArray->AddDoubleReference( rCRD );
457 aInsert.bSingleRef = false;
458 }
459
460 aInsert.nRelInd = nIntCount;
461 nIntCount++;
462
463 maEntries.push_back( aInsert );
464}
465
466bool RangeNameBufferWK3::FindRel( const OUString& rRef, sal_uInt16& rIndex )
467{
468 StringHashEntry aRef( rRef );
469
470 std::vector<Entry>::const_iterator itr = std::find_if(maEntries.begin(), maEntries.end(),
471 [&aRef](const Entry& rEntry) { return aRef == rEntry.aStrHashEntry; });
472 if (itr != maEntries.end())
473 {
474 rIndex = itr->nRelInd;
475 return true;
476 }
477
478 return false;
479}
480
481bool RangeNameBufferWK3::FindAbs( std::u16string_view rRef, sal_uInt16& rIndex )
482{
483 if (rRef.empty())
484 return false;
485 StringHashEntry aRef(OUString(rRef.substr(1))); // search w/o '$'!
486
487 std::vector<Entry>::iterator itr = std::find_if(maEntries.begin(), maEntries.end(),
488 [&aRef](const Entry& rEntry) { return aRef == rEntry.aStrHashEntry; });
489 if (itr != maEntries.end())
490 {
491 // setup new range if needed
492 if( itr->nAbsInd )
493 rIndex = itr->nAbsInd;
494 else
495 {
496 ScSingleRefData* pRef = &itr->aScComplexRefDataRel.Ref1;
497 pScTokenArray->Clear();
498
499 pRef->SetColRel( false );
500 pRef->SetRowRel( false );
501 pRef->SetTabRel( true );
502
503 if( itr->bSingleRef )
504 pScTokenArray->AddSingleReference( *pRef );
505 else
506 {
507 pRef = &itr->aScComplexRefDataRel.Ref2;
508 pRef->SetColRel( false );
509 pRef->SetRowRel( false );
510 pRef->SetTabRel( true );
511 pScTokenArray->AddDoubleReference( itr->aScComplexRefDataRel );
512 }
513
514 rIndex = itr->nAbsInd = nIntCount;
515 nIntCount++;
516 }
517
518 return true;
519 }
520
521 return false;
522}
523
524/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
SCTAB SanitizeTab(SCTAB nTab)
Definition: address.hxx:145
LanguageType eLanguage
Definition: tool.h:95
~FormCache()
Definition: tool.cxx:157
bool bValid[nSize_]
Definition: tool.h:91
SfxUInt32Item * NewAttr(sal_uInt8 nFormat, sal_uInt8 nSt)
Definition: tool.cxx:161
FormCache(const ScDocument *)
Definition: tool.cxx:148
SvNumberFormatter * pFormTable
Definition: tool.h:93
ScComplexRefData aComplRef
Definition: lotrange.hxx:90
LotusRangeList()
Definition: tool.cxx:367
~LotusRangeList()
Definition: tool.cxx:387
void Append(const ScDocument *pDoc, std::unique_ptr< LotusRange > pLR)
Definition: tool.cxx:401
LR_ID GetIndex(SCCOL nCol, SCROW nRow)
Definition: lotrange.hxx:102
std::vector< std::unique_ptr< LotusRange > > maRanges
Definition: lotrange.hxx:91
sal_uInt32 nHash
Definition: lotrange.hxx:35
SCROW nRowEnd
Definition: lotrange.hxx:39
LR_ID nId
Definition: lotrange.hxx:40
SCCOL nColStart
Definition: lotrange.hxx:36
LotusRange(SCCOL nCol, SCROW nRow)
Definition: tool.cxx:344
void Copy(const LotusRange &)
Definition: lotrange.hxx:53
SCCOL nColEnd
Definition: lotrange.hxx:38
SCROW nRowStart
Definition: lotrange.hxx:37
void MakeHash()
Definition: tool.cxx:330
void Add(const ScDocument &rDoc, const OUString &rName, const ScComplexRefData &rCRD)
Definition: tool.cxx:439
std::unique_ptr< ScTokenArray > pScTokenArray
Definition: namebuff.hxx:94
std::vector< Entry > maEntries
Definition: namebuff.hxx:96
sal_uInt16 nIntCount
Definition: namebuff.hxx:95
bool FindAbs(std::u16string_view rRef, sal_uInt16 &rIndex)
Definition: tool.cxx:481
bool FindRel(const OUString &rRef, sal_uInt16 &rIndex)
Definition: tool.cxx:466
RangeNameBufferWK3(const ScDocument &rDoc)
Definition: tool.cxx:429
SCROW SanitizeRow(SCROW nRow) const
Definition: document.hxx:905
SC_DLLPUBLIC bool SetString(SCCOL nCol, SCROW nRow, SCTAB nTab, const OUString &rString, const ScSetStringParam *pParam=nullptr)
Definition: document.cxx:3422
SC_DLLPUBLIC void ApplyAttr(SCCOL nCol, SCROW nRow, SCTAB nTab, const SfxPoolItem &rAttr)
Definition: document.cxx:4835
SCCOL SanitizeCol(SCCOL nCol) const
Definition: document.hxx:904
SC_DLLPUBLIC SvNumberFormatter * GetFormatTable() const
Definition: documen2.cxx:467
static SC_DLLPUBLIC LanguageType eLnge
Definition: global.hxx:559
void SetProtection(bool bProtect)
Definition: attrib.cxx:350
formula::FormulaToken * AddDoubleReference(const ScComplexRefData &rRef)
Definition: token.cxx:2282
formula::FormulaToken * AddSingleReference(const ScSingleRefData &rRef)
ScSingleRefToken with ocPush.
Definition: token.cxx:2272
const OUString & GetDateSep() const
sal_uInt32 GetStandardFormat(SvNumFormatType eType, LanguageType eLnge=LANGUAGE_DONTKNOW)
bool PutEntry(OUString &rString, sal_Int32 &nCheckPos, SvNumFormatType &nType, sal_uInt32 &nKey, LanguageType eLnge=LANGUAGE_DONTKNOW, bool bReplaceBooleanEquivalent=true)
OUString GenerateFormat(sal_uInt32 nIndex, LanguageType eLnge=LANGUAGE_DONTKNOW, bool bThousand=false, bool IsRed=false, sal_uInt16 nPrecision=0, sal_uInt16 nLeadingCnt=1)
OUString GetKeyword(LanguageType eLnge, sal_uInt16 nIndex)
sal_uInt32 GetFormatIndex(NfIndexTableOffset, LanguageType eLnge=LANGUAGE_DONTKNOW)
DocumentType eType
sal_Int16 nValue
sal_Int32 nIndex
#define SAL_WARN_IF(condition, area, stream)
#define ID_FAIL
Definition: lotrange.hxx:29
sal_uInt16 LR_ID
Definition: lotrange.hxx:27
NF_KEY_DD
NF_KEY_YYYY
NF_KEY_MMMM
NF_KEY_MM
sal_Int32 nHandle
constexpr TypedWhichId< SfxUInt32Item > ATTR_VALUE_FORMAT(146)
std::unique_ptr< SvxHorJustifyItem > xAttrLeft
Definition: lotfilter.hxx:47
std::unique_ptr< SvxHorJustifyItem > xAttrCenter
Definition: lotfilter.hxx:47
std::unique_ptr< FormCache > xValueFormCache
Definition: lotfilter.hxx:49
std::unique_ptr< SvxHorJustifyItem > xAttrStandard
Definition: lotfilter.hxx:47
std::unique_ptr< SvxHorJustifyItem > xAttrRepeat
Definition: lotfilter.hxx:47
std::unique_ptr< SvxHorJustifyItem > xAttrRight
Definition: lotfilter.hxx:47
ScDocument & rDoc
Definition: lotfilter.hxx:44
rtl_TextEncoding eCharset
Definition: lotfilter.hxx:43
Complex reference (a range) into the sheet.
Definition: refdata.hxx:123
void InitFlags()
Definition: refdata.hxx:128
ScSingleRefData Ref2
Definition: refdata.hxx:125
ScSingleRefData Ref1
Definition: refdata.hxx:124
Store parameters used in the ScDocument::SetString() method.
Definition: stringutil.hxx:35
void setTextInput()
Call this whenever you need to unconditionally set input as text, no matter what the input is.
Definition: stringutil.cxx:38
Single reference (one address) into the sheet.
Definition: refdata.hxx:30
void SetAbsCol(SCCOL nVal)
Definition: refdata.cxx:59
void SetRowRel(bool bVal)
Definition: refdata.hxx:66
void SetTabRel(bool bVal)
Definition: refdata.hxx:68
void SetRelTab(SCTAB nVal)
Definition: refdata.cxx:99
ScAddress toAbs(const ScSheetLimits &rLimits, const ScAddress &rPos) const
Definition: refdata.cxx:193
void SetAbsRow(SCROW nVal)
Definition: refdata.cxx:76
void SetFlag3D(bool bVal)
Definition: refdata.hxx:89
void SetColRel(bool bVal)
Definition: refdata.hxx:64
double SnumToDouble(sal_Int16 nVal)
Definition: tool.cxx:104
void PutFormString(LotusContext &rContext, SCCOL nCol, SCROW nRow, SCTAB nTab, char *pString)
Definition: tool.cxx:38
void SetFormat(LotusContext &rContext, SCCOL nCol, SCROW nRow, SCTAB nTab, sal_uInt8 nFormat, sal_uInt8 nSt)
Definition: tool.cxx:88
double Snum32ToDouble(sal_uInt32 nValue)
Definition: tool.cxx:129
unsigned char sal_uInt8
sal_Int16 SCTAB
Definition: types.hxx:22
sal_Int16 SCCOL
Definition: types.hxx:21
sal_Int32 SCROW
Definition: types.hxx:17
SvNumFormatType
NfIndexTableOffset
NF_TEXT
NF_TIME_HHMM
NF_TIME_HHMMSS
NF_DATE_SYS_DDMMYYYY
NF_NUMERIC_START