LibreOffice Module sc (master)  1
datatransformation.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 
10 #include <datatransformation.hxx>
11 #include <limits>
12 #include <document.hxx>
13 #include <rtl/math.hxx>
14 #include <cmath>
15 #include <svl/zforlist.hxx>
16 #include <unotools/charclass.hxx>
17 
18 namespace {
19 
20 Date getDate(double nDateTime, const SvNumberFormatter* pFormatter)
21 {
22  Date aDate = pFormatter->GetNullDate();
23  aDate.AddDays(static_cast<sal_Int32>(::rtl::math::approxFloor(nDateTime)));
24  return aDate;
25 }
26 }
27 
28 namespace sc {
29 DataTransformation::~DataTransformation()
30 {
31 }
32 
33 SCROW DataTransformation::getLastRow(const ScDocument& rDoc, SCCOL nCol)
34 {
35  SCROW nEndRow = MAXROW;
36 
37  return rDoc.GetLastDataRow(0, nCol, nCol, nEndRow);
38 }
39 
40 ColumnRemoveTransformation::ColumnRemoveTransformation(const std::set<SCCOL>& rColumns):
41  maColumns(rColumns)
42 {
43 }
44 
45 ColumnRemoveTransformation::~ColumnRemoveTransformation()
46 {
47 }
48 
49 void ColumnRemoveTransformation::Transform(ScDocument& rDoc) const
50 {
51  for (auto& rCol : maColumns)
52  {
53  rDoc.DeleteCol(0, 0, MAXROW, 0, rCol, 1);
54  }
55 }
56 
57 TransformationType ColumnRemoveTransformation::getTransformationType() const
58 {
59  return TransformationType::DELETE_TRANSFORMATION;
60 }
61 
62 const std::set<SCCOL> & ColumnRemoveTransformation::getColumns() const
63 {
64  return maColumns;
65 }
66 
67 SplitColumnTransformation::SplitColumnTransformation(SCCOL nCol, sal_Unicode cSeparator):
68  mnCol(nCol),
69  mcSeparator(cSeparator)
70 {
71 }
72 
73 void SplitColumnTransformation::Transform(ScDocument& rDoc) const
74 {
75  rDoc.InsertCol(0, 0, MAXROW, 0, mnCol + 1, 1);
76 
77  SCROW nEndRow = getLastRow(rDoc, mnCol);
78  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
79  {
80  CellType eType;
81  rDoc.GetCellType(mnCol, nRow, 0, eType);
82  if (eType == CELLTYPE_STRING)
83  {
84  OUString aStr = rDoc.GetString(mnCol, nRow, 0);
85  sal_Int32 nIndex = aStr.indexOf(mcSeparator);
86  if (nIndex != -1)
87  {
88  rDoc.SetString(mnCol + 1, nRow, 0, aStr.copy(nIndex + 1));
89  rDoc.SetString(mnCol, nRow, 0, aStr.copy(0, nIndex));
90  }
91  }
92  }
93 }
94 
95 TransformationType SplitColumnTransformation::getTransformationType() const
96 {
97  return TransformationType::SPLIT_TRANSFORMATION;
98 }
99 
100 SCCOL SplitColumnTransformation::getColumn() const
101 {
102  return mnCol;
103 }
104 
105 sal_Unicode SplitColumnTransformation::getSeparator() const
106 {
107  return mcSeparator;
108 }
109 
110 MergeColumnTransformation::MergeColumnTransformation(const std::set<SCCOL>& rColumns, const OUString& rMergeString):
111  maColumns(rColumns),
112  maMergeString(rMergeString)
113 {
114 }
115 
116 void MergeColumnTransformation::Transform(ScDocument& rDoc) const
117 {
118  if (maColumns.empty())
119  return;
120 
121  SCROW nMaxRow = 0;
122  for (auto& itr : maColumns)
123  {
124  nMaxRow = getLastRow(rDoc, itr);
125  }
126  assert(nMaxRow != -1);
127 
128  SCCOL nTargetCol = *maColumns.begin();
129 
130 
131  for (SCROW nRow = 0; nRow <= nMaxRow; ++nRow)
132  {
133  OUStringBuffer aStr = rDoc.GetString(nTargetCol, nRow, 0);
134  for (auto& itr : maColumns)
135  {
136  if (itr != nTargetCol)
137  {
138  aStr.append(maMergeString).append(rDoc.GetString(itr, nRow, 0));
139  }
140  }
141  rDoc.SetString(nTargetCol, nRow, 0, aStr.makeStringAndClear());
142  }
143 
144  for (auto& itr : maColumns)
145  {
146  if (itr == nTargetCol)
147  continue;
148 
149  rDoc.DeleteCol(0, 0, MAXROW, 0, itr, 1);
150  }
151 }
152 
153 TransformationType MergeColumnTransformation::getTransformationType() const
154 {
155  return TransformationType::MERGE_TRANSFORMATION;
156 }
157 
158 const OUString & MergeColumnTransformation::getMergeString() const
159 {
160  return maMergeString;
161 }
162 
163 const std::set<SCCOL> & MergeColumnTransformation::getColumns() const
164 {
165  return maColumns;
166 }
167 
168 SortTransformation::SortTransformation(const ScSortParam& rSortParam):
169  maSortParam(rSortParam)
170 {
171 }
172 
173 void SortTransformation::Transform(ScDocument& rDoc) const
174 {
175  rDoc.Sort(0, maSortParam, false, false, nullptr, nullptr);
176 }
177 
178 TransformationType SortTransformation::getTransformationType() const
179 {
180  return TransformationType::SORT_TRANSFORMATION;
181 }
182 
183 const ScSortParam & SortTransformation::getSortParam() const
184 {
185  return maSortParam;
186 }
187 
188 TextTransformation::TextTransformation(const std::set<SCCOL>& nCol, const TEXT_TRANSFORM_TYPE rType):
189  mnCol(nCol),
190  maType(rType)
191 {
192 }
193 
194 void TextTransformation::Transform(ScDocument& rDoc) const
195 {
196  SCROW nEndRow = 0;
197  for(auto& rCol : mnCol)
198  {
199  nEndRow = getLastRow(rDoc, rCol);
200  }
201  assert(nEndRow != -1);
202 
203  for(auto& rCol : mnCol)
204  {
205  switch (maType)
206  {
207  case TEXT_TRANSFORM_TYPE::TO_LOWER:
208  {
209  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
210  {
211  CellType eType;
212  rDoc.GetCellType(rCol, nRow, 0, eType);
213  if (eType == CELLTYPE_STRING)
214  {
215  OUString aStr = rDoc.GetString(rCol, nRow, 0);
216  rDoc.SetString(rCol, nRow, 0, ScGlobal::getCharClassPtr()->lowercase(aStr));
217  }
218  }
219  }
220  break;
221  case TEXT_TRANSFORM_TYPE::TO_UPPER:
222  {
223  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
224  {
225  CellType eType;
226  rDoc.GetCellType(rCol, nRow, 0, eType);
227  if (eType == CELLTYPE_STRING)
228  {
229  OUString aStr = rDoc.GetString(rCol, nRow, 0);
230  rDoc.SetString(rCol, nRow, 0, ScGlobal::getCharClassPtr()->uppercase(aStr));
231  }
232  }
233  }
234  break;
235  case TEXT_TRANSFORM_TYPE::CAPITALIZE:
236  {
237  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
238  {
239  CellType eType;
240  rDoc.GetCellType(rCol, nRow, 0, eType);
241  if (eType == CELLTYPE_STRING)
242  {
243  OUString aStr = rDoc.GetString(rCol, nRow, 0);
244 
245  sal_Int32 length = aStr.getLength();
246 
247  if(length != 0)
248  aStr = aStr.replaceAt(0, 1, ScGlobal::getCharClassPtr()->uppercase(OUString(aStr[0])));
249 
250  for (sal_Int32 i = 1; i < length; i++){
251  if (aStr[i-1] == sal_Unicode(U' '))
252  {
253  aStr = aStr.replaceAt(i, 1, ScGlobal::getCharClassPtr()->uppercase(OUString(aStr[i])));
254  }
255  else
256  {
257  aStr = aStr.replaceAt(i, 1, ScGlobal::getCharClassPtr()->lowercase(OUString(aStr[i])));
258  }
259  }
260  rDoc.SetString(rCol, nRow, 0, aStr);
261  }
262  }
263  }
264  break;
265  case TEXT_TRANSFORM_TYPE::TRIM:
266  {
267  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
268  {
269  CellType eType;
270  rDoc.GetCellType(rCol, nRow, 0, eType);
271  if (eType == CELLTYPE_STRING)
272  {
273  OUString aStr = rDoc.GetString(rCol, nRow, 0);
274  rDoc.SetString(rCol, nRow, 0, aStr.trim());
275  }
276  }
277  }
278  break;
279  default:
280  break;
281  }
282  }
283 }
284 
285 TransformationType TextTransformation::getTransformationType() const
286 {
287  return TransformationType::TEXT_TRANSFORMATION;
288 }
289 
290 TEXT_TRANSFORM_TYPE TextTransformation::getTextTransformationType() const
291 {
292  return maType;
293 }
294 
295 const std::set<SCCOL>& TextTransformation::getColumns() const
296 {
297  return mnCol;
298 }
299 
300 AggregateFunction::AggregateFunction(const std::set<SCCOL>& rColumns, const AGGREGATE_FUNCTION rType):
301  maColumns(rColumns),
302  maType(rType)
303 {
304 }
305 
306 void AggregateFunction::Transform(ScDocument& rDoc) const
307 {
308  SCROW nEndRow = 0;
309  for (auto& itr : maColumns)
310  {
311  nEndRow = getLastRow(rDoc, itr);
312  }
313  assert(nEndRow != -1);
314 
315  for (auto& rCol : maColumns)
316  {
317  switch (maType)
318  {
319  case AGGREGATE_FUNCTION::SUM:
320  {
321  double nSum = 0;
322  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
323  {
324  CellType eType;
325  rDoc.GetCellType(rCol, nRow, 0, eType);
326  if (eType == CELLTYPE_VALUE)
327  {
328  double nVal = rDoc.GetValue(rCol, nRow, 0);
329  nSum += nVal;
330  }
331  }
332  rDoc.SetValue(rCol, nEndRow + 1, 0, nSum);
333  }
334  break;
335  case AGGREGATE_FUNCTION::AVERAGE:
336  {
337  double nSum = 0;
338  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
339  {
340  CellType eType;
341  rDoc.GetCellType(rCol, nRow, 0, eType);
342  if (eType == CELLTYPE_VALUE)
343  {
344  double nVal = rDoc.GetValue(rCol, nRow, 0);
345  nSum += nVal;
346  }
347  }
348 
349  double nAvg = nSum / (nEndRow + 1);
350  rDoc.SetValue(rCol, nEndRow + 1, 0, nAvg);
351  }
352  break;
353  case AGGREGATE_FUNCTION::MIN:
354  {
355  double nMin = std::numeric_limits<double>::max();
356  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
357  {
358  CellType eType;
359  rDoc.GetCellType(rCol, nRow, 0, eType);
360  if (eType == CELLTYPE_VALUE)
361  {
362  double nVal = rDoc.GetValue(rCol, nRow, 0);
363  if(nVal < nMin)
364  nMin = nVal;
365  }
366  }
367  rDoc.SetValue(rCol, nEndRow + 1, 0, nMin);
368  }
369  break;
370  case AGGREGATE_FUNCTION::MAX:
371  {
372  double nMax = std::numeric_limits<double>::lowest();
373  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
374  {
375  CellType eType;
376  rDoc.GetCellType(rCol, nRow, 0, eType);
377  if (eType == CELLTYPE_VALUE)
378  {
379  double nVal = rDoc.GetValue(rCol, nRow, 0);
380  if(nMax < nVal)
381  nMax = nVal;
382  }
383  }
384  rDoc.SetValue(rCol, nEndRow + 1, 0, nMax);
385  }
386  break;
387  default:
388  break;
389  }
390  }
391 }
392 
393 TransformationType AggregateFunction::getTransformationType() const
394 {
395  return TransformationType::AGGREGATE_FUNCTION;
396 }
397 
398 AGGREGATE_FUNCTION AggregateFunction::getAggregateType() const
399 {
400  return maType;
401 }
402 
403 const std::set<SCCOL>& AggregateFunction::getColumns() const
404 {
405  return maColumns;
406 }
407 
408 NumberTransformation::NumberTransformation(const std::set<SCCOL>& nCol,
409  const NUMBER_TRANSFORM_TYPE rType)
410  : mnCol(nCol)
411  , maType(rType)
412  , maPrecision(-1)
413 {
414 }
415 
416 NumberTransformation::NumberTransformation(const std::set<SCCOL>& nCol,
417  const NUMBER_TRANSFORM_TYPE rType, int nPrecision)
418  : mnCol(nCol)
419  , maType(rType)
420  , maPrecision(nPrecision)
421 {
422 }
423 
424 void NumberTransformation::Transform(ScDocument& rDoc) const
425 {
426  SCROW nEndRow = 0;
427  for(auto& rCol : mnCol)
428  {
429  nEndRow = getLastRow(rDoc, rCol);
430  }
431  assert(nEndRow != -1);
432 
433  for(auto& rCol : mnCol)
434  {
435  switch (maType)
436  {
437  case NUMBER_TRANSFORM_TYPE::ROUND:
438  {
439  if(maPrecision > -1)
440  {
441  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
442  {
443  CellType eType;
444  rDoc.GetCellType(rCol, nRow, 0, eType);
445  if (eType == CELLTYPE_VALUE)
446  {
447  double nVal = rDoc.GetValue(rCol, nRow, 0);
448  rDoc.SetValue(rCol, nRow, 0, rtl::math::round(nVal, maPrecision));
449  }
450  }
451  }
452  }
453  break;
454  case NUMBER_TRANSFORM_TYPE::ROUND_UP:
455  {
456  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
457  {
458  CellType eType;
459  rDoc.GetCellType(rCol, nRow, 0, eType);
460  if (eType == CELLTYPE_VALUE)
461  {
462  double nVal = rDoc.GetValue(rCol, nRow, 0);
463  rDoc.SetValue(rCol, nRow, 0, rtl::math::approxCeil(nVal));
464  }
465  }
466  }
467  break;
468  case NUMBER_TRANSFORM_TYPE::ROUND_DOWN:
469  {
470  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
471  {
472  CellType eType;
473  rDoc.GetCellType(rCol, nRow, 0, eType);
474  if (eType == CELLTYPE_VALUE)
475  {
476  double nVal = rDoc.GetValue(rCol, nRow, 0);
477  rDoc.SetValue(rCol, nRow, 0, rtl::math::approxFloor(nVal));
478  }
479  }
480  }
481  break;
482  case NUMBER_TRANSFORM_TYPE::ABSOLUTE:
483  {
484  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
485  {
486  CellType eType;
487  rDoc.GetCellType(rCol, nRow, 0, eType);
488  if (eType == CELLTYPE_VALUE)
489  {
490  double nVal = rDoc.GetValue(rCol, nRow, 0);
491  if(std::signbit(nVal))
492  rDoc.SetValue(rCol, nRow, 0, -1 * nVal);
493  }
494  }
495  }
496  break;
497  case NUMBER_TRANSFORM_TYPE::LOG_E:
498  {
499  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
500  {
501  CellType eType;
502  rDoc.GetCellType(rCol, nRow, 0, eType);
503  if (eType == CELLTYPE_VALUE)
504  {
505  double nVal = rDoc.GetValue(rCol, nRow, 0);
506  if (nVal > 0)
507  {
508  rDoc.SetValue(rCol, nRow, 0, rtl::math::log1p(nVal-1));
509  }
510  else
511  {
512  rDoc.SetString(rCol, nRow, 0, OUString());
513  }
514  }
515  }
516  }
517  break;
518  case NUMBER_TRANSFORM_TYPE::LOG_10:
519  {
520  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
521  {
522  CellType eType;
523  rDoc.GetCellType(rCol, nRow, 0, eType);
524  if (eType == CELLTYPE_VALUE)
525  {
526  double nVal = rDoc.GetValue(rCol, nRow, 0);
527  if (nVal > 0)
528  {
529  rDoc.SetValue(rCol, nRow, 0, log10(nVal));
530  }
531  else
532  {
533  rDoc.SetString(rCol, nRow, 0, OUString());
534  }
535  }
536  }
537  }
538  break;
539  case NUMBER_TRANSFORM_TYPE::CUBE:
540  {
541  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
542  {
543  CellType eType;
544  rDoc.GetCellType(rCol, nRow, 0, eType);
545  if (eType == CELLTYPE_VALUE)
546  {
547  double nVal = rDoc.GetValue(rCol, nRow, 0);
548  rDoc.SetValue(rCol, nRow, 0, nVal * nVal * nVal);
549  }
550  }
551  }
552  break;
553  case NUMBER_TRANSFORM_TYPE::SQUARE:
554  {
555  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
556  {
557  CellType eType;
558  rDoc.GetCellType(rCol, nRow, 0, eType);
559  if (eType == CELLTYPE_VALUE)
560  {
561  double nVal = rDoc.GetValue(rCol, nRow, 0);
562  rDoc.SetValue(rCol, nRow, 0, nVal * nVal);
563  }
564  }
565  }
566  break;
567  case NUMBER_TRANSFORM_TYPE::SQUARE_ROOT:
568  {
569  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
570  {
571  CellType eType;
572  rDoc.GetCellType(rCol, nRow, 0, eType);
573  if (eType == CELLTYPE_VALUE)
574  {
575  double nVal = rDoc.GetValue(rCol, nRow, 0);
576  if (!std::signbit(nVal))
577  {
578  rDoc.SetValue(rCol, nRow, 0, sqrt(nVal));
579  }
580  else
581  {
582  rDoc.SetString(rCol, nRow, 0, OUString());
583  }
584  }
585  }
586  }
587  break;
588  case NUMBER_TRANSFORM_TYPE::IS_EVEN:
589  {
590  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
591  {
592  CellType eType;
593  rDoc.GetCellType(rCol, nRow, 0, eType);
594  if (eType == CELLTYPE_VALUE)
595  {
596  double nVal = rDoc.GetValue(rCol, nRow, 0);
597  if (fmod(nVal, 1) == 0 && fmod(nVal, 2) == 0)
598  rDoc.SetValue(rCol, nRow, 0, 1);
599  else
600  rDoc.SetValue(rCol, nRow, 0, 0);
601  }
602  }
603  }
604  break;
605  case NUMBER_TRANSFORM_TYPE::IS_ODD:
606  {
607  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
608  {
609  CellType eType;
610  rDoc.GetCellType(rCol, nRow, 0, eType);
611  if (eType == CELLTYPE_VALUE)
612  {
613  double nVal = rDoc.GetValue(rCol, nRow, 0);
614  if (fmod(nVal, 1) == 0 && fmod(nVal, 2) != 0)
615  rDoc.SetValue(rCol, nRow, 0, 1);
616  else
617  rDoc.SetValue(rCol, nRow, 0, 0);
618  }
619  }
620  }
621  break;
622  case NUMBER_TRANSFORM_TYPE::SIGN:
623  {
624  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
625  {
626  CellType eType;
627  rDoc.GetCellType(rCol, nRow, 0, eType);
628  if (eType == CELLTYPE_VALUE)
629  {
630  double nVal = rDoc.GetValue(rCol, nRow, 0);
631  if (nVal > 0)
632  rDoc.SetValue(rCol, nRow, 0, 1);
633  else if (nVal < 0)
634  rDoc.SetValue(rCol, nRow, 0, -1);
635  else
636  rDoc.SetValue(rCol, nRow, 0, 0);
637  }
638  }
639  }
640  break;
641  default:
642  break;
643  }
644  }
645 }
646 
647 TransformationType NumberTransformation::getTransformationType() const
648 {
649  return TransformationType::NUMBER_TRANSFORMATION;
650 }
651 
652 NUMBER_TRANSFORM_TYPE NumberTransformation::getNumberTransformationType() const
653 {
654  return maType;
655 }
656 
657 int NumberTransformation::getPrecision() const
658 {
659  return maPrecision;
660 }
661 
662 const std::set<SCCOL>& NumberTransformation::getColumn() const
663 {
664  return mnCol;
665 }
666 
667 ReplaceNullTransformation::ReplaceNullTransformation(const std::set<SCCOL>& nCol,
668  const OUString& sReplaceWith)
669  : mnCol(nCol)
670  , msReplaceWith(sReplaceWith)
671 {
672 }
673 
674 void ReplaceNullTransformation::Transform(ScDocument& rDoc) const
675 {
676  if (mnCol.empty())
677  return;
678 
679  for(auto& rCol : mnCol)
680  {
681  SCROW nEndRow = getLastRow(rDoc, rCol);
682  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
683  {
684  CellType eType;
685  rDoc.GetCellType(rCol, nRow, 0, eType);
686  if (eType == CELLTYPE_NONE)
687  {
688  // OUString aStr = rDoc.GetString(rCol, nRow, 0);
689  // if (aStr == "" || aStr.isEmpty())
690  rDoc.SetString(rCol, nRow, 0, msReplaceWith);
691  }
692  }
693  }
694 
695 }
696 
697 const std::set<SCCOL>& ReplaceNullTransformation::getColumn() const
698 {
699  return mnCol;
700 }
701 
702 const OUString& ReplaceNullTransformation::getReplaceString() const
703 {
704  return msReplaceWith;
705 }
706 
707 TransformationType ReplaceNullTransformation::getTransformationType() const
708 {
709  return TransformationType::REMOVE_NULL_TRANSFORMATION;
710 }
711 
712 DateTimeTransformation::DateTimeTransformation(const std::set<SCCOL>& nCol,
713  const DATETIME_TRANSFORMATION_TYPE rType)
714  : mnCol(nCol)
715  , maType(rType)
716 {
717 }
718 
719 void DateTimeTransformation::Transform(ScDocument& rDoc) const
720 {
721  SCROW nEndRow = 0;
722  for(auto& rCol : mnCol)
723  {
724  nEndRow = getLastRow(rDoc, rCol);
725  }
726  assert(nEndRow != -1);
727 
728  for(auto& rCol : mnCol)
729  {
730  switch (maType)
731  {
732  case DATETIME_TRANSFORMATION_TYPE::DATE_STRING:
733  {
734  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
735  LanguageType eLanguage = ScGlobal::eLnge;
736  sal_uInt32 nFormat = pFormatter->GetStandardFormat( SvNumFormatType::DATE, eLanguage );
737  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
738  {
739  CellType eType;
740  rDoc.GetCellType(rCol, nRow, 0, eType);
741  if (eType == CELLTYPE_VALUE)
742  {
743  ScAddress aAddress(rCol, nRow, 0);
744  rDoc.SetNumberFormat(aAddress, nFormat);
745  }
746  }
747  }
748  break;
749  case DATETIME_TRANSFORMATION_TYPE::YEAR:
750  {
751  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
752  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
753  {
754  CellType eType;
755  rDoc.GetCellType(rCol, nRow, 0, eType);
756  if (eType == CELLTYPE_VALUE)
757  {
758  double nVal = rDoc.GetValue(rCol, nRow, 0);
759  Date aDate = getDate(nVal, pFormatter);
760  rDoc.SetValue(rCol, nRow, 0, aDate.GetYear());
761  }
762  }
763  }
764  break;
765  case DATETIME_TRANSFORMATION_TYPE::START_OF_YEAR:
766  {
767  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
768  LanguageType eLanguage = ScGlobal::eLnge;
769  sal_uInt32 nFormat = pFormatter->GetStandardFormat( SvNumFormatType::DATE, eLanguage );
770  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
771  {
772  CellType eType;
773  rDoc.GetCellType(rCol, nRow, 0, eType);
774  if (eType == CELLTYPE_VALUE)
775  {
776  double nVal = rDoc.GetValue(rCol, nRow, 0);
777  Date aDate = getDate(nVal, pFormatter);
778  aDate.SetDay(1);
779  aDate.SetMonth(1);
780  nVal = aDate - pFormatter->GetNullDate();
781  ScAddress aAddress(rCol, nRow, 0);
782  rDoc.SetValue(rCol, nRow, 0, nVal);
783  rDoc.SetNumberFormat(aAddress, nFormat);
784  }
785  }
786  }
787  break;
788  case DATETIME_TRANSFORMATION_TYPE::END_OF_YEAR:
789  {
790  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
791  LanguageType eLanguage = ScGlobal::eLnge;
792  sal_uInt32 nFormat = pFormatter->GetStandardFormat( SvNumFormatType::DATE, eLanguage );
793 
794  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
795  {
796  CellType eType;
797  rDoc.GetCellType(rCol, nRow, 0, eType);
798  if (eType == CELLTYPE_VALUE)
799  {
800  double nVal = rDoc.GetValue(rCol, nRow, 0);
801  Date aDate = getDate(nVal, pFormatter);
802  aDate.SetMonth(12);
803  aDate.SetDay(31);
804  nVal = aDate - pFormatter->GetNullDate();
805  ScAddress aAddress(rCol, nRow, 0);
806  rDoc.SetValue(rCol, nRow, 0, nVal);
807  rDoc.SetNumberFormat(aAddress, nFormat);
808  }
809  }
810  }
811  break;
812  case DATETIME_TRANSFORMATION_TYPE::MONTH:
813  {
814  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
815  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
816  {
817  CellType eType;
818  rDoc.GetCellType(rCol, nRow, 0, eType);
819  if (eType == CELLTYPE_VALUE)
820  {
821  double nVal = rDoc.GetValue(rCol, nRow, 0);
822  Date aDate = getDate(nVal, pFormatter);
823  rDoc.SetValue(rCol, nRow, 0, aDate.GetMonth());
824  }
825  }
826  }
827  break;
828  case DATETIME_TRANSFORMATION_TYPE::MONTH_NAME:
829  {
830  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
831  LanguageType eLanguage = ScGlobal::eLnge;
832  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
833  {
834  CellType eType;
835  rDoc.GetCellType(rCol, nRow, 0, eType);
836  if (eType == CELLTYPE_VALUE)
837  {
838  double nVal = rDoc.GetValue(rCol, nRow, 0);
839  const Color* pColor = nullptr;
840  OUString aResult;
841  pFormatter->GetPreviewStringGuess("MMMM", nVal, aResult, &pColor, eLanguage);
842  rDoc.SetString(rCol, nRow, 0, aResult);
843  }
844  }
845  }
846  break;
847  case DATETIME_TRANSFORMATION_TYPE::START_OF_MONTH:
848  {
849  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
850  LanguageType eLanguage = ScGlobal::eLnge;
851  sal_uInt32 nFormat = pFormatter->GetStandardFormat( SvNumFormatType::DATE, eLanguage );
852  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
853  {
854  CellType eType;
855  rDoc.GetCellType(rCol, nRow, 0, eType);
856  if (eType == CELLTYPE_VALUE)
857  {
858  double nVal = rDoc.GetValue(rCol, nRow, 0);
859  ScAddress aAddress(rCol, nRow, 0);
860  Date aDate = getDate(nVal, pFormatter);
861  aDate.SetDay(1);
862  nVal = aDate - pFormatter->GetNullDate();
863  rDoc.SetValue(rCol, nRow, 0, nVal);
864  rDoc.SetNumberFormat(aAddress, nFormat);
865  }
866  }
867  }
868  break;
869  case DATETIME_TRANSFORMATION_TYPE::END_OF_MONTH:
870  {
871  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
872  LanguageType eLanguage = ScGlobal::eLnge;
873  sal_uInt32 nFormat = pFormatter->GetStandardFormat( SvNumFormatType::DATE, eLanguage );
874  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
875  {
876  CellType eType;
877  rDoc.GetCellType(rCol, nRow, 0, eType);
878  if (eType == CELLTYPE_VALUE)
879  {
880  double nVal = rDoc.GetValue(rCol, nRow, 0);
881  ScAddress aAddress(rCol, nRow, 0);
882  Date aDate = getDate(nVal, pFormatter);
883  aDate.SetDay(aDate.GetDaysInMonth());
884  nVal = aDate - pFormatter->GetNullDate();
885  rDoc.SetValue(rCol, nRow, 0, nVal);
886  rDoc.SetNumberFormat(aAddress, nFormat);
887  }
888  }
889  }
890  break;
891  case DATETIME_TRANSFORMATION_TYPE::DAY:
892  {
893  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
894  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
895  {
896  CellType eType;
897  rDoc.GetCellType(rCol, nRow, 0, eType);
898  if (eType == CELLTYPE_VALUE)
899  {
900  double nVal = rDoc.GetValue(rCol, nRow, 0);
901  Date aDate = getDate(nVal, pFormatter);
902  rDoc.SetValue(rCol, nRow, 0, aDate.GetDay());
903  }
904  }
905  }
906  break;
907  case DATETIME_TRANSFORMATION_TYPE::DAY_OF_WEEK:
908  {
909  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
910  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
911  {
912  CellType eType;
913  rDoc.GetCellType(rCol, nRow, 0, eType);
914  if (eType == CELLTYPE_VALUE)
915  {
916  double nVal = rDoc.GetValue(rCol, nRow, 0);
917  Date aDate = getDate(nVal, pFormatter);
918  rDoc.SetValue(rCol, nRow, 0, aDate.GetDayOfWeek());
919  }
920  }
921  }
922  break;
923  case DATETIME_TRANSFORMATION_TYPE::DAY_OF_YEAR:
924  {
925  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
926  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
927  {
928  CellType eType;
929  rDoc.GetCellType(rCol, nRow, 0, eType);
930  if (eType == CELLTYPE_VALUE)
931  {
932  double nVal = rDoc.GetValue(rCol, nRow, 0);
933  Date aDate = getDate(nVal, pFormatter);
934  rDoc.SetValue(rCol, nRow, 0, aDate.GetDayOfYear());
935  }
936  }
937  }
938  break;
939  case DATETIME_TRANSFORMATION_TYPE::QUARTER:
940  {
941  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
942  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
943  {
944  CellType eType;
945  rDoc.GetCellType(rCol, nRow, 0, eType);
946  if (eType == CELLTYPE_VALUE)
947  {
948  double nVal = rDoc.GetValue(rCol, nRow, 0);
949  Date aDate = getDate(nVal, pFormatter);
950 
951  int nMonth = aDate.GetMonth();
952 
953  if(nMonth >= 1 && nMonth <=3)
954  rDoc.SetValue(rCol, nRow, 0, 1);
955 
956  else if(nMonth >= 4 && nMonth <=6)
957  rDoc.SetValue(rCol, nRow, 0, 2);
958 
959  else if(nMonth >= 7 && nMonth <=9)
960  rDoc.SetValue(rCol, nRow, 0, 3);
961 
962  else if(nMonth >= 10 && nMonth <=12)
963  rDoc.SetValue(rCol, nRow, 0, 4);
964  else
965  rDoc.SetValue(rCol, nRow, 0, -1);
966 
967  }
968  }
969  }
970  break;
971  case DATETIME_TRANSFORMATION_TYPE::START_OF_QUARTER:
972  {
973  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
974  LanguageType eLanguage = ScGlobal::eLnge;
975  sal_uInt32 nFormat = pFormatter->GetStandardFormat( SvNumFormatType::DATE, eLanguage );
976  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
977  {
978  CellType eType;
979  rDoc.GetCellType(rCol, nRow, 0, eType);
980  if (eType == CELLTYPE_VALUE)
981  {
982  double nVal = rDoc.GetValue(rCol, nRow, 0);
983  ScAddress aAddress(rCol, nRow, 0);
984  Date aDate = getDate(nVal, pFormatter);
985 
986  int nMonth = aDate.GetMonth();
987 
988  if(nMonth >= 1 && nMonth <=3)
989  {
990  aDate.SetDay(1);
991  aDate.SetMonth(1);
992  nVal = aDate - pFormatter->GetNullDate();
993  rDoc.SetValue(rCol, nRow, 0, nVal);
994  rDoc.SetNumberFormat(aAddress, nFormat);
995  }
996  else if(nMonth >= 4 && nMonth <=6)
997  {
998  aDate.SetDay(1);
999  aDate.SetMonth(4);
1000  nVal = aDate - pFormatter->GetNullDate();
1001  rDoc.SetValue(rCol, nRow, 0, nVal);
1002  rDoc.SetNumberFormat(aAddress, nFormat);
1003  }
1004  else if(nMonth >= 7 && nMonth <=9)
1005  {
1006  aDate.SetDay(1);
1007  aDate.SetMonth(7);
1008  nVal = aDate - pFormatter->GetNullDate();
1009  rDoc.SetValue(rCol, nRow, 0, nVal);
1010  rDoc.SetNumberFormat(aAddress, nFormat);
1011  }
1012  else if(nMonth >= 10 && nMonth <=12)
1013  {
1014  aDate.SetDay(1);
1015  aDate.SetMonth(10);
1016  nVal = aDate - pFormatter->GetNullDate();
1017  rDoc.SetValue(rCol, nRow, 0, nVal);
1018  rDoc.SetNumberFormat(aAddress, nFormat);
1019  }
1020  else
1021  rDoc.SetValue(rCol, nRow, 0, -1);
1022  }
1023  }
1024  }
1025  break;
1026  case DATETIME_TRANSFORMATION_TYPE::END_OF_QUARTER:
1027  {
1028  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
1029  LanguageType eLanguage = ScGlobal::eLnge;
1030  sal_uInt32 nFormat = pFormatter->GetStandardFormat( SvNumFormatType::DATE, eLanguage );
1031  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
1032  {
1033  ScAddress aAddress(rCol, nRow, 0);
1034  CellType eType;
1035  rDoc.GetCellType(rCol, nRow, 0, eType);
1036  if (eType == CELLTYPE_VALUE)
1037  {
1038  double nVal = rDoc.GetValue(rCol, nRow, 0);
1039  Date aDate = getDate(nVal, pFormatter);
1040  int nMonth = aDate.GetMonth();
1041 
1042  if(nMonth >= 1 && nMonth <=3)
1043  {
1044  aDate.SetDay(31);
1045  aDate.SetMonth(3);
1046  nVal = aDate - pFormatter->GetNullDate();
1047  rDoc.SetValue(rCol, nRow, 0, nVal);
1048  rDoc.SetNumberFormat(aAddress, nFormat);
1049  }
1050 
1051  else if(nMonth >= 4 && nMonth <=6)
1052  {
1053  aDate.SetDay(30);
1054  aDate.SetMonth(6);
1055  nVal = aDate - pFormatter->GetNullDate();
1056  rDoc.SetValue(rCol, nRow, 0, nVal);
1057  rDoc.SetNumberFormat(aAddress, nFormat);
1058  }
1059 
1060  else if(nMonth >= 7 && nMonth <=9)
1061  {
1062  aDate.SetDay(30);
1063  aDate.SetMonth(9);
1064  nVal = aDate - pFormatter->GetNullDate();
1065  rDoc.SetValue(rCol, nRow, 0, nVal);
1066  rDoc.SetNumberFormat(aAddress, nFormat);
1067  }
1068 
1069  else if(nMonth >= 10 && nMonth <=12)
1070  {
1071  aDate.SetDay(31);
1072  aDate.SetMonth(12);
1073  nVal = aDate - pFormatter->GetNullDate();
1074  rDoc.SetValue(rCol, nRow, 0, nVal);
1075  rDoc.SetNumberFormat(aAddress, nFormat);
1076  }
1077  else
1078  rDoc.SetValue(rCol, nRow, 0, -1);
1079 
1080  }
1081  }
1082  }
1083  break;
1084  case DATETIME_TRANSFORMATION_TYPE::TIME:
1085  {
1086  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
1087  LanguageType eLanguage = ScGlobal::eLnge;
1088  sal_uInt32 nFormat = pFormatter->GetStandardFormat(SvNumFormatType::TIME, eLanguage);
1089  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
1090  {
1091  ScAddress aAddress(rCol, nRow, 0);
1092  CellType eType;
1093  rDoc.GetCellType(rCol, nRow, 0, eType);
1094  if (eType == CELLTYPE_VALUE)
1095  {
1096  rDoc.SetNumberFormat(aAddress, nFormat);
1097  }
1098  }
1099  }
1100  break;
1101  case DATETIME_TRANSFORMATION_TYPE::HOUR:
1102  {
1103  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
1104  {
1105  CellType eType;
1106  rDoc.GetCellType(rCol, nRow, 0, eType);
1107  if (eType == CELLTYPE_VALUE)
1108  {
1109  double nVal = rDoc.GetValue(rCol, nRow, 0);
1110  sal_uInt16 nHour, nMinute, nSecond;
1111  double fFractionOfSecond;
1112  tools::Time::GetClock( nVal, nHour, nMinute, nSecond, fFractionOfSecond, 0);
1113  rDoc.SetValue(rCol, nRow, 0, nHour);
1114  }
1115  }
1116  }
1117  break;
1118  case DATETIME_TRANSFORMATION_TYPE::MINUTE:
1119  {
1120  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
1121  {
1122  CellType eType;
1123  rDoc.GetCellType(rCol, nRow, 0, eType);
1124  if (eType == CELLTYPE_VALUE)
1125  {
1126  double nVal = rDoc.GetValue(rCol, nRow, 0);
1127  sal_uInt16 nHour, nMinute, nSecond;
1128  double fFractionOfSecond;
1129  tools::Time::GetClock( nVal, nHour, nMinute, nSecond, fFractionOfSecond, 0);
1130  rDoc.SetValue(rCol, nRow, 0, nMinute);
1131  }
1132  }
1133  }
1134  break;
1135  case DATETIME_TRANSFORMATION_TYPE::SECOND:
1136  {
1137  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
1138  {
1139  CellType eType;
1140  rDoc.GetCellType(rCol, nRow, 0, eType);
1141  if (eType == CELLTYPE_VALUE)
1142  {
1143  double nVal = rDoc.GetValue(rCol, nRow, 0);
1144  sal_uInt16 nHour, nMinute, nSecond;
1145  double fFractionOfSecond;
1146  tools::Time::GetClock( nVal, nHour, nMinute, nSecond, fFractionOfSecond, 0);
1147  rDoc.SetValue(rCol, nRow, 0, nSecond);
1148  }
1149  }
1150  }
1151  break;
1152  default:
1153  break;
1154  }
1155  }
1156 }
1157 
1158 TransformationType DateTimeTransformation::getTransformationType() const
1159 {
1160  return TransformationType::DATETIME_TRANSFORMATION;
1161 }
1162 
1163 DATETIME_TRANSFORMATION_TYPE DateTimeTransformation::getDateTimeTransformationType() const
1164 {
1165  return maType;
1166 }
1167 
1168 const std::set<SCCOL>& DateTimeTransformation::getColumn() const
1169 {
1170  return mnCol;
1171 }
1172 
1173 }
1174 
1175 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
sc::DateTimeTransformation::Transform
virtual void Transform(ScDocument &rDoc) const override
Definition: datatransformation.cxx:719
ScDocument::DeleteCol
void DeleteCol(SCROW nStartRow, SCTAB nStartTab, SCROW nEndRow, SCTAB nEndTab, SCCOL nStartCol, SCSIZE nSize, ScDocument *pRefUndoDoc=nullptr, bool *pUndoOutline=nullptr, const ScMarkData *pTabMark=nullptr)
Definition: document.cxx:1584
sc::DateTimeTransformation::getDateTimeTransformationType
DATETIME_TRANSFORMATION_TYPE getDateTimeTransformationType() const
Definition: datatransformation.cxx:1163
sc::AggregateFunction::Transform
virtual void Transform(ScDocument &rDoc) const override
Definition: datatransformation.cxx:306
maType
OUString maType
sc::ColumnRemoveTransformation::getColumns
const std::set< SCCOL > & getColumns() const
Definition: datatransformation.cxx:62
sc::AggregateFunction::maType
AGGREGATE_FUNCTION maType
Definition: datatransformation.hxx:131
nIndex
sal_Int32 nIndex
Date::GetDayOfWeek
DayOfWeek GetDayOfWeek() const
sc::TextTransformation::getTextTransformationType
TEXT_TRANSFORM_TYPE getTextTransformationType() const
Definition: datatransformation.cxx:290
sc::DataTransformation::getLastRow
static SCROW getLastRow(const ScDocument &rDoc, SCCOL nCol)
Definition: datatransformation.cxx:33
sc::SplitColumnTransformation::Transform
virtual void Transform(ScDocument &rDoc) const override
Definition: datatransformation.cxx:73
sc::ReplaceNullTransformation::getColumn
const std::set< SCCOL > & getColumn() const
Definition: datatransformation.cxx:697
sc::AggregateFunction::getTransformationType
virtual TransformationType getTransformationType() const override
Definition: datatransformation.cxx:393
sc::NumberTransformation::maType
NUMBER_TRANSFORM_TYPE maType
Definition: datatransformation.hxx:144
mnCol
sal_Int32 mnCol
Definition: drawingfragment.cxx:351
sc::MergeColumnTransformation::Transform
virtual void Transform(ScDocument &rDoc) const override
Definition: datatransformation.cxx:116
sc::NumberTransformation::getColumn
const std::set< SCCOL > & getColumn() const
Definition: datatransformation.cxx:662
sc::SortTransformation::getTransformationType
virtual TransformationType getTransformationType() const override
Definition: datatransformation.cxx:178
sc::AggregateFunction::getColumns
const std::set< SCCOL > & getColumns() const
Definition: datatransformation.cxx:403
ScDocument::InsertCol
bool InsertCol(SCROW nStartRow, SCTAB nStartTab, SCROW nEndRow, SCTAB nEndTab, SCCOL nStartCol, SCSIZE nSize, ScDocument *pRefUndoDoc=nullptr, const ScMarkData *pTabMark=nullptr)
Definition: document.cxx:1497
sc::TextTransformation::Transform
virtual void Transform(ScDocument &rDoc) const override
Definition: datatransformation.cxx:194
sc::MergeColumnTransformation::getMergeString
const OUString & getMergeString() const
Definition: datatransformation.cxx:158
ScDocument::SetValue
SC_DLLPUBLIC void SetValue(SCCOL nCol, SCROW nRow, SCTAB nTab, const double &rVal)
Definition: document.cxx:3456
sc::SortTransformation::getSortParam
const ScSortParam & getSortParam() const
Definition: datatransformation.cxx:183
sc::ReplaceNullTransformation::ReplaceNullTransformation
ReplaceNullTransformation(const std::set< SCCOL > &nCol, const OUString &sReplaceWith)
Definition: datatransformation.cxx:667
sc::NumberTransformation::Transform
virtual void Transform(ScDocument &rDoc) const override
Definition: datatransformation.cxx:424
ScDocument::Sort
void Sort(SCTAB nTab, const ScSortParam &rSortParam, bool bKeepQuery, bool bUpdateRefs, ScProgress *pProgress, sc::ReorderParam *pUndo)
Sort a range of data.
Definition: documen3.cxx:1420
sc::AggregateFunction::getAggregateType
AGGREGATE_FUNCTION getAggregateType() const
Definition: datatransformation.cxx:398
sc::TextTransformation::maType
TEXT_TRANSFORM_TYPE maType
Definition: datatransformation.hxx:118
sal_Unicode
sal_uInt16 sal_Unicode
sc::DateTimeTransformation::getTransformationType
virtual TransformationType getTransformationType() const override
Definition: datatransformation.cxx:1158
assert
const BorderLinePrimitive2D *pCandidateB assert(pCandidateA)
sc::MergeColumnTransformation::MergeColumnTransformation
MergeColumnTransformation(const std::set< SCCOL > &rColumns, const OUString &rMergeString)
Definition: datatransformation.cxx:110
Date::GetMonth
sal_uInt16 GetMonth() const
length
length
MAXROW
const SCROW MAXROW
Definition: address.hxx:69
ScDocument::GetString
SC_DLLPUBLIC OUString GetString(SCCOL nCol, SCROW nRow, SCTAB nTab, const ScInterpreterContext *pContext=nullptr) const
Definition: document.cxx:3484
sc::ColumnRemoveTransformation::getTransformationType
virtual TransformationType getTransformationType() const override
Definition: datatransformation.cxx:57
sc::ColumnRemoveTransformation::~ColumnRemoveTransformation
virtual ~ColumnRemoveTransformation() override
Definition: datatransformation.cxx:45
o3tl::strong_int< sal_uInt16, struct LanguageTypeTag >
ScDocument::GetValue
SC_DLLPUBLIC double GetValue(const ScAddress &rPos) const
Definition: document.cxx:3626
eType
DocumentType eType
sc::DATETIME_TRANSFORMATION_TYPE
DATETIME_TRANSFORMATION_TYPE
Definition: datatransformation.hxx:44
Date::GetYear
sal_Int16 GetYear() const
sc::ColumnRemoveTransformation::Transform
virtual void Transform(ScDocument &rDoc) const override
Definition: datatransformation.cxx:49
sc::DateTimeTransformation::getColumn
const std::set< SCCOL > & getColumn() const
Definition: datatransformation.cxx:1168
ScDocument::SetString
SC_DLLPUBLIC bool SetString(SCCOL nCol, SCROW nRow, SCTAB nTab, const OUString &rString, const ScSetStringParam *pParam=nullptr)
Definition: document.cxx:3361
ScDocument::GetFormatTable
SC_DLLPUBLIC SvNumberFormatter * GetFormatTable() const
Definition: documen2.cxx:437
Date::GetDaysInMonth
sal_uInt16 GetDaysInMonth() const
i
int i
Date::SetDay
void SetDay(sal_uInt16 nNewDay)
sc::SplitColumnTransformation::SplitColumnTransformation
SplitColumnTransformation(SCCOL nCol, sal_Unicode cSeparator)
Definition: datatransformation.cxx:67
sc::SplitColumnTransformation::getTransformationType
virtual TransformationType getTransformationType() const override
Definition: datatransformation.cxx:95
SCCOL
sal_Int16 SCCOL
Definition: types.hxx:22
sc::SortTransformation::Transform
virtual void Transform(ScDocument &rDoc) const override
Definition: datatransformation.cxx:173
sc::NumberTransformation::getTransformationType
virtual TransformationType getTransformationType() const override
Definition: datatransformation.cxx:647
sc::ColumnRemoveTransformation::ColumnRemoveTransformation
ColumnRemoveTransformation(const std::set< SCCOL > &rColumns)
Definition: datatransformation.cxx:40
sc::ReplaceNullTransformation::Transform
virtual void Transform(ScDocument &rDoc) const override
Definition: datatransformation.cxx:674
Date::GetDay
sal_uInt16 GetDay() const
Date::AddDays
void AddDays(sal_Int32 nAddDays)
ScGlobal::eLnge
static SC_DLLPUBLIC LanguageType eLnge
Definition: global.hxx:548
sc::DateTimeTransformation::DateTimeTransformation
DateTimeTransformation(const std::set< SCCOL > &nCol, const DATETIME_TRANSFORMATION_TYPE rType)
Definition: datatransformation.cxx:712
sc::NumberTransformation::getNumberTransformationType
NUMBER_TRANSFORM_TYPE getNumberTransformationType() const
Definition: datatransformation.cxx:652
sc::NumberTransformation::NumberTransformation
NumberTransformation(const std::set< SCCOL > &nCol, const NUMBER_TRANSFORM_TYPE rType)
Definition: datatransformation.cxx:408
ScDocument::SetNumberFormat
void SetNumberFormat(const ScAddress &rPos, sal_uInt32 nNumberFormat)
Definition: document.cxx:3687
sc::AggregateFunction::maColumns
std::set< SCCOL > maColumns
Definition: datatransformation.hxx:130
SCROW
sal_Int32 SCROW
Definition: types.hxx:18
tools::Time::GetClock
static void GetClock(double fTimeInDays, sal_uInt16 &nHour, sal_uInt16 &nMinute, sal_uInt16 &nSecond, double &fFractionOfSecond, int nFractionDecimals)
CellType
CellType
Definition: global.hxx:282
sc::DateTimeTransformation::maType
DATETIME_TRANSFORMATION_TYPE maType
Definition: datatransformation.hxx:174
SvNumberFormatter::GetStandardFormat
sal_uInt32 GetStandardFormat(SvNumFormatType eType, LanguageType eLnge=LANGUAGE_DONTKNOW)
SvNumberFormatter::GetPreviewStringGuess
bool GetPreviewStringGuess(const OUString &sFormatString, double fPreviewNumber, OUString &sOutString, const Color **ppColor, LanguageType eLnge=LANGUAGE_DONTKNOW)
ScGlobal::getCharClassPtr
static SC_DLLPUBLIC const CharClass * getCharClassPtr()
Definition: global.cxx:1011
sc::AggregateFunction::AggregateFunction
AggregateFunction(const std::set< SCCOL > &rColumns, const AGGREGATE_FUNCTION rType)
Definition: datatransformation.cxx:300
ScDocument::GetLastDataRow
SCROW GetLastDataRow(SCTAB nTab, SCCOL nCol1, SCCOL nCol2, SCROW nLastRow) const
Return the last non-empty row position in given columns that's no greater than the initial last row p...
Definition: document.cxx:1083
sc::TextTransformation::getColumns
const std::set< SCCOL > & getColumns() const
Definition: datatransformation.cxx:295
sc::SortTransformation::SortTransformation
SortTransformation(const ScSortParam &rParam)
Definition: datatransformation.cxx:168
sc::ReplaceNullTransformation::getTransformationType
virtual TransformationType getTransformationType() const override
Definition: datatransformation.cxx:707
sc::ReplaceNullTransformation::getReplaceString
const OUString & getReplaceString() const
Definition: datatransformation.cxx:702
Date::GetDayOfYear
sal_uInt16 GetDayOfYear() const
sc::MergeColumnTransformation::getColumns
const std::set< SCCOL > & getColumns() const
Definition: datatransformation.cxx:163
sc::MergeColumnTransformation::getTransformationType
virtual TransformationType getTransformationType() const override
Definition: datatransformation.cxx:153
SvNumberFormatter::GetNullDate
const Date & GetNullDate() const
sc::TextTransformation::getTransformationType
virtual TransformationType getTransformationType() const override
Definition: datatransformation.cxx:285
sc::TextTransformation::TextTransformation
TextTransformation(const std::set< SCCOL > &nCol, const TEXT_TRANSFORM_TYPE rType)
Definition: datatransformation.cxx:188
aStr
aStr
Date::SetMonth
void SetMonth(sal_uInt16 nNewMonth)
ScDocument::GetCellType
SC_DLLPUBLIC void GetCellType(SCCOL nCol, SCROW nRow, SCTAB nTab, CellType &rCellType) const
Definition: document.cxx:3745
Generated on Tue Dec 1 2020 07:43:24 for LibreOffice Module sc (master) by   doxygen 1.8.10