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>
21 #include <editeng/justifyitem.hxx>
22 #include <svl/zforlist.hxx>
23 #include <sal/log.hxx>
24 
25 #include <attrib.hxx>
26 #include <document.hxx>
27 
28 #include <tool.h>
29 #include <root.hxx>
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 
38 void 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.pAttrRight;
54  pString++;
55  break;
56  case '\'': // align-left
57  pJustify = rContext.pAttrLeft;
58  pString++;
59  break;
60  case '^': // centered
61  pJustify = rContext.pAttrCenter;
62  pString++;
63  break;
64  case '|': // printer command
65  pString = nullptr;
66  break;
67  case '\\': // repetition
68  pJustify = rContext.pAttrRepeat;
69  pString++;
70  break;
71  default: // undefined case!
72  pJustify = rContext.pAttrStandard;
73  }
74 
75  if (!pString)
76  return;
77 
78  nCol = rContext.pDoc->SanitizeCol(nCol);
79  nRow = rContext.pDoc->SanitizeRow(nRow);
80  nTab = SanitizeTab(nTab);
81 
82  rContext.pDoc->ApplyAttr( nCol, nRow, nTab, *pJustify );
83  ScSetStringParam aParam;
84  aParam.setTextInput();
85  rContext.pDoc->SetString(ScAddress(nCol,nRow,nTab), OUString(pString, strlen(pString), rContext.eCharset), &aParam);
86 }
87 
88 void SetFormat(LotusContext& rContext, SCCOL nCol, SCROW nRow, SCTAB nTab, sal_uInt8 nFormat, sal_uInt8 nSt)
89 {
90  nCol = rContext.pDoc->SanitizeCol(nCol);
91  nRow = rContext.pDoc->SanitizeRow(nRow);
92  nTab = SanitizeTab(nTab);
93 
94  // PREC: nSt = default number of decimal places
95  rContext.pDoc->ApplyAttr(nCol, nRow, nTab, *(rContext.pValueFormCache->GetAttr(nFormat, nSt)));
96 
97  ScProtectionAttr aAttr;
98 
99  aAttr.SetProtection( nFormat & 0x80 );
100 
101  rContext.pDoc->ApplyAttr( nCol, nRow, nTab, aAttr );
102 }
103 
104 double 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 
129 double 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 
327  return new SfxUInt32Item( ATTR_VALUE_FORMAT, nHandle );
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 
401 void 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(pDoc) )
431 {
432  nIntCount = 1;
433 }
434 
436 {
437 }
438 
439 void RangeNameBufferWK3::Add( const ScDocument* pDoc, 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(pDoc, ScAddress());
448  ScAddress aAbs2 = rRef2.toAbs(pDoc, 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 
466 bool 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 
481 bool RangeNameBufferWK3::FindAbs( const OUString& rRef, sal_uInt16& rIndex )
482 {
483  if (rRef.isEmpty())
484  return false;
485  StringHashEntry aRef(rRef.copy(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: */
rtl_TextEncoding eCharset
Definition: lotfilter.hxx:44
FormCache * pValueFormCache
Definition: lotfilter.hxx:50
formula::FormulaToken * AddDoubleReference(const ScComplexRefData &rRef)
Definition: token.cxx:2212
SCCOL SanitizeCol(SCCOL nCol) const
Definition: document.hxx:884
sal_Int32 nIndex
LR_ID nId
Definition: lotrange.hxx:39
Store parameters used in the ScDocument::SetString() method.
Definition: stringutil.hxx:35
SvxHorJustifyItem * pAttrCenter
Definition: lotfilter.hxx:48
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
std::vector< std::unique_ptr< LotusRange > > maRanges
Definition: lotrange.hxx:90
sal_uInt32 GetFormatIndex(NfIndexTableOffset, LanguageType eLnge=LANGUAGE_DONTKNOW)
void Copy(const LotusRange &)
Definition: lotrange.hxx:52
void InitFlags()
Definition: refdata.hxx:128
sal_uInt16 LR_ID
Definition: lotrange.hxx:26
SCROW nRowStart
Definition: lotrange.hxx:36
void MakeHash()
Definition: tool.cxx:330
void SetRelTab(SCTAB nVal)
Definition: refdata.cxx:99
LR_ID GetIndex(SCCOL nCol, SCROW nRow)
Definition: lotrange.hxx:101
ScComplexRefData aComplRef
Definition: lotrange.hxx:89
formula::FormulaToken * AddSingleReference(const ScSingleRefData &rRef)
ScSingleRefToken with ocPush.
Definition: token.cxx:2202
void SetAbsRow(SCROW nVal)
Definition: refdata.cxx:76
sal_uInt16 nIntCount
Definition: namebuff.hxx:96
const SfxUInt32Item * GetAttr(sal_uInt8 nFormat, sal_uInt8 nSt)
Definition: tool.h:105
RangeNameBufferWK3(const ScDocument *pDoc)
Definition: tool.cxx:429
void SetRowRel(bool bVal)
Definition: refdata.hxx:67
SC_DLLPUBLIC void ApplyAttr(SCCOL nCol, SCROW nRow, SCTAB nTab, const SfxPoolItem &rAttr)
Definition: document.cxx:4759
NF_KEY_DD
NF_TIME_HHMM
LotusRangeList()
Definition: tool.cxx:367
void SetProtection(bool bProtect)
Definition: attrib.cxx:349
FormCache(const ScDocument *)
Definition: tool.cxx:148
sal_uInt32 nHash
Definition: lotrange.hxx:34
void Append(const ScDocument *pDoc, std::unique_ptr< LotusRange > pLR)
Definition: tool.cxx:401
SCCOL nColEnd
Definition: lotrange.hxx:37
NF_KEY_MMMM
const BorderLinePrimitive2D *pCandidateB assert(pCandidateA)
NfIndexTableOffset
void SetTabRel(bool bVal)
Definition: refdata.hxx:69
void PutFormString(LotusContext &rContext, SCCOL nCol, SCROW nRow, SCTAB nTab, char *pString)
Definition: tool.cxx:38
NF_TIME_HHMMSS
sal_Int32 nHandle
bool PutEntry(OUString &rString, sal_Int32 &nCheckPos, SvNumFormatType &nType, sal_uInt32 &nKey, LanguageType eLnge=LANGUAGE_DONTKNOW)
~LotusRangeList()
Definition: tool.cxx:387
DocumentType eType
bool FindAbs(const OUString &rRef, sal_uInt16 &rIndex)
Definition: tool.cxx:481
double SnumToDouble(sal_Int16 nVal)
Definition: tool.cxx:104
SC_DLLPUBLIC bool SetString(SCCOL nCol, SCROW nRow, SCTAB nTab, const OUString &rString, const ScSetStringParam *pParam=nullptr)
Definition: document.cxx:3365
SC_DLLPUBLIC SvNumberFormatter * GetFormatTable() const
Definition: documen2.cxx:438
NF_KEY_MM
SvxHorJustifyItem * pAttrLeft
Definition: lotfilter.hxx:48
void SetFlag3D(bool bVal)
Definition: refdata.hxx:90
sal_Int16 SCCOL
Definition: types.hxx:22
void SetAbsCol(SCCOL nVal)
Definition: refdata.cxx:59
ScSingleRefData Ref1
Definition: refdata.hxx:125
ScSingleRefData Ref2
Definition: refdata.hxx:126
NF_TEXT
constexpr TypedWhichId< SfxUInt32Item > ATTR_VALUE_FORMAT(146)
SvNumFormatType
bool bValid[nSize_]
Definition: tool.h:90
NF_DATE_SYS_DDMMYYYY
SvxHorJustifyItem * pAttrRight
Definition: lotfilter.hxx:48
static SC_DLLPUBLIC LanguageType eLnge
Definition: global.hxx:551
SvNumberFormatter * pFormTable
Definition: tool.h:92
double Snum32ToDouble(sal_uInt32 nValue)
Definition: tool.cxx:129
SfxUInt32Item * NewAttr(sal_uInt8 nFormat, sal_uInt8 nSt)
Definition: tool.cxx:161
LotusRange(SCCOL nCol, SCROW nRow)
Definition: tool.cxx:344
SCROW SanitizeRow(SCROW nRow) const
Definition: document.hxx:885
ScAddress toAbs(ScSheetLimits &rLimits, const ScAddress &rPos) const
Definition: refdata.cxx:193
OUString GenerateFormat(sal_uInt32 nIndex, LanguageType eLnge=LANGUAGE_DONTKNOW, bool bThousand=false, bool IsRed=false, sal_uInt16 nPrecision=0, sal_uInt16 nLeadingCnt=1)
SCTAB SanitizeTab(SCTAB nTab)
Definition: address.hxx:139
sal_Int32 SCROW
Definition: types.hxx:18
SCROW nRowEnd
Definition: lotrange.hxx:38
NF_KEY_YYYY
#define SAL_WARN_IF(condition, area, stream)
unsigned char sal_uInt8
sal_uInt32 GetStandardFormat(SvNumFormatType eType, LanguageType eLnge=LANGUAGE_DONTKNOW)
ScDocument * pDoc
Definition: lotfilter.hxx:45
bool FindRel(const OUString &rRef, sal_uInt16 &rIndex)
Definition: tool.cxx:466
std::vector< Entry > maEntries
Definition: namebuff.hxx:97
LanguageType eLanguage
Definition: tool.h:94
Complex reference (a range) into the sheet.
Definition: refdata.hxx:123
#define ID_FAIL
Definition: lotrange.hxx:28
SvxHorJustifyItem * pAttrStandard
Definition: lotfilter.hxx:48
~FormCache()
Definition: tool.cxx:157
const OUString & GetDateSep() const
OUString GetKeyword(LanguageType eLnge, sal_uInt16 nIndex)
SvxHorJustifyItem * pAttrRepeat
Definition: lotfilter.hxx:48
void Add(const ScDocument *pDoc, const OUString &rName, const ScComplexRefData &rCRD)
Definition: tool.cxx:439
NF_NUMERIC_START
void SetColRel(bool bVal)
Definition: refdata.hxx:65
SCCOL nColStart
Definition: lotrange.hxx:35
sal_Int16 SCTAB
Definition: types.hxx:23
void SetFormat(LotusContext &rContext, SCCOL nCol, SCROW nRow, SCTAB nTab, sal_uInt8 nFormat, sal_uInt8 nSt)
Definition: tool.cxx:88
std::unique_ptr< ScTokenArray > pScTokenArray
Definition: namebuff.hxx:95