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/numformat.hxx>
16 #include <svl/zforlist.hxx>
17 #include <unotools/charclass.hxx>
18 
19 namespace {
20 
21 Date getDate(double nDateTime, const SvNumberFormatter* pFormatter)
22 {
23  Date aDate = pFormatter->GetNullDate();
24  aDate.AddDays(static_cast<sal_Int32>(::rtl::math::approxFloor(nDateTime)));
25  return aDate;
26 }
27 }
28 
29 namespace sc {
31 {
32 }
33 
35 {
36  SCROW nEndRow = rDoc.MaxRow();
37 
38  return rDoc.GetLastDataRow(0, nCol, nCol, nEndRow);
39 }
40 
42  maColumns(std::move(rColumns))
43 {
44 }
45 
47 {
48 }
49 
51 {
52  sal_Int32 nIncrementIndex = 0;
53  for (auto& rCol : maColumns)
54  {
55  rDoc.DeleteCol(0, 0, rDoc.MaxRow(), 0, rCol - nIncrementIndex, 1);
56  nIncrementIndex++;
57  }
58 }
59 
61 {
63 }
64 
65 const std::set<SCCOL> & ColumnRemoveTransformation::getColumns() const
66 {
67  return maColumns;
68 }
69 
71  mnCol(nCol),
72  mcSeparator(cSeparator)
73 {
74 }
75 
77 {
78  if (mnCol == -1)
79  return;
80 
81  rDoc.InsertCol(0, 0, rDoc.MaxRow(), 0, mnCol + 1, 1);
82 
83  SCROW nEndRow = getLastRow(rDoc, mnCol);
84  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
85  {
86  CellType eType = rDoc.GetCellType(mnCol, nRow, 0);
87  if (eType == CELLTYPE_STRING)
88  {
89  OUString aStr = rDoc.GetString(mnCol, nRow, 0);
90  sal_Int32 nIndex = aStr.indexOf(mcSeparator);
91  if (nIndex != -1)
92  {
93  rDoc.SetString(mnCol + 1, nRow, 0, aStr.copy(nIndex + 1));
94  rDoc.SetString(mnCol, nRow, 0, aStr.copy(0, nIndex));
95  }
96  }
97  }
98 }
99 
101 {
103 }
104 
106 {
107  return mnCol;
108 }
109 
111 {
112  return mcSeparator;
113 }
114 
115 MergeColumnTransformation::MergeColumnTransformation( std::set<SCCOL>&& rColumns, const OUString& rMergeString):
116  maColumns(std::move(rColumns)),
117  maMergeString(rMergeString)
118 {
119 }
120 
122 {
123  if (maColumns.empty())
124  return;
125 
126  SCROW nMaxRow = 0;
127  for (auto& itr : maColumns)
128  {
129  nMaxRow = getLastRow(rDoc, itr);
130  }
131  assert(nMaxRow != -1);
132 
133  SCCOL nTargetCol = *maColumns.begin();
134 
135 
136  for (SCROW nRow = 0; nRow <= nMaxRow; ++nRow)
137  {
138  OUStringBuffer aStr(rDoc.GetString(nTargetCol, nRow, 0));
139  for (auto& itr : maColumns)
140  {
141  if (itr != nTargetCol)
142  {
143  aStr.append(maMergeString + rDoc.GetString(itr, nRow, 0));
144  }
145  }
146  rDoc.SetString(nTargetCol, nRow, 0, aStr.makeStringAndClear());
147  }
148 
149  for (auto& itr : maColumns)
150  {
151  if (itr == nTargetCol)
152  continue;
153 
154  rDoc.DeleteCol(0, 0, rDoc.MaxRow(), 0, itr, 1);
155  }
156 }
157 
159 {
161 }
162 
164 {
165  return maMergeString;
166 }
167 
168 const std::set<SCCOL> & MergeColumnTransformation::getColumns() const
169 {
170  return maColumns;
171 }
172 
174  maSortParam(rSortParam)
175 {
176 }
177 
179 {
180  rDoc.Sort(0, maSortParam, false, false, nullptr, nullptr);
181 }
182 
184 {
186 }
187 
189 {
190  return maSortParam;
191 }
192 
193 TextTransformation::TextTransformation( std::set<SCCOL>&& nCol, const TEXT_TRANSFORM_TYPE rType):
194  mnCol(std::move(nCol)),
195  maType(rType)
196 {
197 }
198 
200 {
201  SCROW nEndRow = 0;
202  for(auto& rCol : mnCol)
203  {
204  nEndRow = getLastRow(rDoc, rCol);
205  }
206  assert(nEndRow != -1);
207 
208  for(auto& rCol : mnCol)
209  {
210  switch (maType)
211  {
213  {
214  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
215  {
216  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
217  if (eType == CELLTYPE_STRING)
218  {
219  OUString aStr = rDoc.GetString(rCol, nRow, 0);
220  rDoc.SetString(rCol, nRow, 0, ScGlobal::getCharClass().lowercase(aStr));
221  }
222  }
223  }
224  break;
226  {
227  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
228  {
229  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
230  if (eType == CELLTYPE_STRING)
231  {
232  OUString aStr = rDoc.GetString(rCol, nRow, 0);
233  rDoc.SetString(rCol, nRow, 0, ScGlobal::getCharClass().uppercase(aStr));
234  }
235  }
236  }
237  break;
239  {
240  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
241  {
242  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
243  if (eType == CELLTYPE_STRING)
244  {
245  OUString aStr = rDoc.GetString(rCol, nRow, 0);
246 
247  sal_Int32 length = aStr.getLength();
248 
249  if(length != 0)
250  aStr = aStr.replaceAt(0, 1, ScGlobal::getCharClass().uppercase(OUString(aStr[0])));
251 
252  for (sal_Int32 i = 1; i < length; i++){
253  if (aStr[i-1] == sal_Unicode(U' '))
254  {
255  aStr = aStr.replaceAt(i, 1, ScGlobal::getCharClass().uppercase(OUString(aStr[i])));
256  }
257  else
258  {
259  aStr = aStr.replaceAt(i, 1, ScGlobal::getCharClass().lowercase(OUString(aStr[i])));
260  }
261  }
262  rDoc.SetString(rCol, nRow, 0, aStr);
263  }
264  }
265  }
266  break;
268  {
269  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
270  {
271  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
272  if (eType == CELLTYPE_STRING)
273  {
274  OUString aStr = rDoc.GetString(rCol, nRow, 0);
275  rDoc.SetString(rCol, nRow, 0, aStr.trim());
276  }
277  }
278  }
279  break;
280  default:
281  break;
282  }
283  }
284 }
285 
287 {
289 }
290 
292 {
293  return maType;
294 }
295 
296 const std::set<SCCOL>& TextTransformation::getColumns() const
297 {
298  return mnCol;
299 }
300 
301 AggregateFunction::AggregateFunction(std::set<SCCOL>&& rColumns, const AGGREGATE_FUNCTION rType):
302  maColumns(std::move(rColumns)),
303  maType(rType)
304 {
305 }
306 
308 {
309  SCROW nEndRow = 0;
310  for (auto& itr : maColumns)
311  {
312  nEndRow = getLastRow(rDoc, itr);
313  }
314  assert(nEndRow != -1);
315 
316  for (auto& rCol : maColumns)
317  {
318  switch (maType)
319  {
321  {
322  double nSum = 0;
323  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
324  {
325  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
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;
336  {
337  double nSum = 0;
338  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
339  {
340  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
341  if (eType == CELLTYPE_VALUE)
342  {
343  double nVal = rDoc.GetValue(rCol, nRow, 0);
344  nSum += nVal;
345  }
346  }
347 
348  double nAvg = nSum / (nEndRow + 1);
349  rDoc.SetValue(rCol, nEndRow + 1, 0, nAvg);
350  }
351  break;
353  {
354  double nMin = std::numeric_limits<double>::max();
355  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
356  {
357  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
358  if (eType == CELLTYPE_VALUE)
359  {
360  double nVal = rDoc.GetValue(rCol, nRow, 0);
361  if(nVal < nMin)
362  nMin = nVal;
363  }
364  }
365  rDoc.SetValue(rCol, nEndRow + 1, 0, nMin);
366  }
367  break;
369  {
370  double nMax = std::numeric_limits<double>::lowest();
371  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
372  {
373  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
374  if (eType == CELLTYPE_VALUE)
375  {
376  double nVal = rDoc.GetValue(rCol, nRow, 0);
377  if(nMax < nVal)
378  nMax = nVal;
379  }
380  }
381  rDoc.SetValue(rCol, nEndRow + 1, 0, nMax);
382  }
383  break;
384  default:
385  break;
386  }
387  }
388 }
389 
391 {
393 }
394 
396 {
397  return maType;
398 }
399 
400 const std::set<SCCOL>& AggregateFunction::getColumns() const
401 {
402  return maColumns;
403 }
404 
406  const NUMBER_TRANSFORM_TYPE rType)
407  : mnCol(std::move(nCol))
408  , maType(rType)
409  , maPrecision(-1)
410 {
411 }
412 
414  const NUMBER_TRANSFORM_TYPE rType, int nPrecision)
415  : mnCol(std::move(nCol))
416  , maType(rType)
417  , maPrecision(nPrecision)
418 {
419 }
420 
422 {
423  SCROW nEndRow = 0;
424  for(auto& rCol : mnCol)
425  {
426  nEndRow = getLastRow(rDoc, rCol);
427  }
428  assert(nEndRow != -1);
429 
430  for(auto& rCol : mnCol)
431  {
432  switch (maType)
433  {
435  {
436  if(maPrecision > -1)
437  {
438  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
439  {
440  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
441  if (eType == CELLTYPE_VALUE)
442  {
443  double nVal = rDoc.GetValue(rCol, nRow, 0);
444  rDoc.SetValue(rCol, nRow, 0, rtl::math::round(nVal, maPrecision));
445  }
446  }
447  }
448  }
449  break;
451  {
452  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
453  {
454  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
455  if (eType == CELLTYPE_VALUE)
456  {
457  double nVal = rDoc.GetValue(rCol, nRow, 0);
458  rDoc.SetValue(rCol, nRow, 0, rtl::math::approxCeil(nVal));
459  }
460  }
461  }
462  break;
464  {
465  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
466  {
467  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
468  if (eType == CELLTYPE_VALUE)
469  {
470  double nVal = rDoc.GetValue(rCol, nRow, 0);
471  rDoc.SetValue(rCol, nRow, 0, rtl::math::approxFloor(nVal));
472  }
473  }
474  }
475  break;
477  {
478  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
479  {
480  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
481  if (eType == CELLTYPE_VALUE)
482  {
483  double nVal = rDoc.GetValue(rCol, nRow, 0);
484  if(std::signbit(nVal))
485  rDoc.SetValue(rCol, nRow, 0, -1 * nVal);
486  }
487  }
488  }
489  break;
491  {
492  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
493  {
494  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
495  if (eType == CELLTYPE_VALUE)
496  {
497  double nVal = rDoc.GetValue(rCol, nRow, 0);
498  if (nVal > 0)
499  {
500  rDoc.SetValue(rCol, nRow, 0, rtl::math::log1p(nVal-1));
501  }
502  else
503  {
504  rDoc.SetString(rCol, nRow, 0, OUString());
505  }
506  }
507  }
508  }
509  break;
511  {
512  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
513  {
514  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
515  if (eType == CELLTYPE_VALUE)
516  {
517  double nVal = rDoc.GetValue(rCol, nRow, 0);
518  if (nVal > 0)
519  {
520  rDoc.SetValue(rCol, nRow, 0, log10(nVal));
521  }
522  else
523  {
524  rDoc.SetString(rCol, nRow, 0, OUString());
525  }
526  }
527  }
528  }
529  break;
531  {
532  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
533  {
534  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
535  if (eType == CELLTYPE_VALUE)
536  {
537  double nVal = rDoc.GetValue(rCol, nRow, 0);
538  rDoc.SetValue(rCol, nRow, 0, nVal * nVal * nVal);
539  }
540  }
541  }
542  break;
544  {
545  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
546  {
547  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
548  if (eType == CELLTYPE_VALUE)
549  {
550  double nVal = rDoc.GetValue(rCol, nRow, 0);
551  rDoc.SetValue(rCol, nRow, 0, nVal * nVal);
552  }
553  }
554  }
555  break;
557  {
558  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
559  {
560  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
561  if (eType == CELLTYPE_VALUE)
562  {
563  double nVal = rDoc.GetValue(rCol, nRow, 0);
564  if (!std::signbit(nVal))
565  {
566  rDoc.SetValue(rCol, nRow, 0, sqrt(nVal));
567  }
568  else
569  {
570  rDoc.SetString(rCol, nRow, 0, OUString());
571  }
572  }
573  }
574  }
575  break;
577  {
578  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
579  {
580  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
581  if (eType == CELLTYPE_VALUE)
582  {
583  double nVal = rDoc.GetValue(rCol, nRow, 0);
584  if (fmod(nVal, 1) == 0 && fmod(nVal, 2) == 0)
585  rDoc.SetValue(rCol, nRow, 0, 1);
586  else
587  rDoc.SetValue(rCol, nRow, 0, 0);
588  }
589  }
590  }
591  break;
593  {
594  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
595  {
596  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
597  if (eType == CELLTYPE_VALUE)
598  {
599  double nVal = rDoc.GetValue(rCol, nRow, 0);
600  if (fmod(nVal, 1) == 0 && fmod(nVal, 2) != 0)
601  rDoc.SetValue(rCol, nRow, 0, 1);
602  else
603  rDoc.SetValue(rCol, nRow, 0, 0);
604  }
605  }
606  }
607  break;
609  {
610  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
611  {
612  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
613  if (eType == CELLTYPE_VALUE)
614  {
615  double nVal = rDoc.GetValue(rCol, nRow, 0);
616  if (nVal > 0)
617  rDoc.SetValue(rCol, nRow, 0, 1);
618  else if (nVal < 0)
619  rDoc.SetValue(rCol, nRow, 0, -1);
620  else
621  rDoc.SetValue(rCol, nRow, 0, 0);
622  }
623  }
624  }
625  break;
626  default:
627  break;
628  }
629  }
630 }
631 
633 {
635 }
636 
638 {
639  return maType;
640 }
641 
643 {
644  return maPrecision;
645 }
646 
647 const std::set<SCCOL>& NumberTransformation::getColumn() const
648 {
649  return mnCol;
650 }
651 
653  const OUString& sReplaceWith)
654  : mnCol(std::move(nCol))
655  , msReplaceWith(sReplaceWith)
656 {
657 }
658 
660 {
661  if (mnCol.empty())
662  return;
663 
664  for(auto& rCol : mnCol)
665  {
666  SCROW nEndRow = getLastRow(rDoc, rCol);
667  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
668  {
669  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
670  if (eType == CELLTYPE_NONE)
671  {
672  // OUString aStr = rDoc.GetString(rCol, nRow, 0);
673  // if (aStr == "" || aStr.isEmpty())
674  rDoc.SetString(rCol, nRow, 0, msReplaceWith);
675  }
676  }
677  }
678 
679 }
680 
681 const std::set<SCCOL>& ReplaceNullTransformation::getColumn() const
682 {
683  return mnCol;
684 }
685 
687 {
688  return msReplaceWith;
689 }
690 
692 {
694 }
695 
697  const DATETIME_TRANSFORMATION_TYPE rType)
698  : mnCol(std::move(nCol))
699  , maType(rType)
700 {
701 }
702 
704 {
705  SCROW nEndRow = 0;
706  for(auto& rCol : mnCol)
707  {
708  nEndRow = getLastRow(rDoc, rCol);
709  }
710  assert(nEndRow != -1);
711 
712  for(auto& rCol : mnCol)
713  {
714  switch (maType)
715  {
717  {
718  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
719  LanguageType eLanguage = ScGlobal::eLnge;
720  sal_uInt32 nFormat = pFormatter->GetStandardFormat( SvNumFormatType::DATE, eLanguage );
721  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
722  {
723  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
724  if (eType == CELLTYPE_VALUE)
725  {
726  ScAddress aAddress(rCol, nRow, 0);
727  rDoc.SetNumberFormat(aAddress, nFormat);
728  }
729  }
730  }
731  break;
733  {
734  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
735  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
736  {
737  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
738  if (eType == CELLTYPE_VALUE)
739  {
740  double nVal = rDoc.GetValue(rCol, nRow, 0);
741  Date aDate = getDate(nVal, pFormatter);
742  rDoc.SetValue(rCol, nRow, 0, aDate.GetYear());
743  }
744  }
745  }
746  break;
748  {
749  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
750  LanguageType eLanguage = ScGlobal::eLnge;
751  sal_uInt32 nFormat = pFormatter->GetStandardFormat( SvNumFormatType::DATE, eLanguage );
752  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
753  {
754  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
755  if (eType == CELLTYPE_VALUE)
756  {
757  double nVal = rDoc.GetValue(rCol, nRow, 0);
758  Date aDate = getDate(nVal, pFormatter);
759  aDate.SetDay(1);
760  aDate.SetMonth(1);
761  nVal = aDate - pFormatter->GetNullDate();
762  ScAddress aAddress(rCol, nRow, 0);
763  rDoc.SetValue(rCol, nRow, 0, nVal);
764  rDoc.SetNumberFormat(aAddress, nFormat);
765  }
766  }
767  }
768  break;
770  {
771  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
772  LanguageType eLanguage = ScGlobal::eLnge;
773  sal_uInt32 nFormat = pFormatter->GetStandardFormat( SvNumFormatType::DATE, eLanguage );
774 
775  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
776  {
777  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
778  if (eType == CELLTYPE_VALUE)
779  {
780  double nVal = rDoc.GetValue(rCol, nRow, 0);
781  Date aDate = getDate(nVal, pFormatter);
782  aDate.SetMonth(12);
783  aDate.SetDay(31);
784  nVal = aDate - pFormatter->GetNullDate();
785  ScAddress aAddress(rCol, nRow, 0);
786  rDoc.SetValue(rCol, nRow, 0, nVal);
787  rDoc.SetNumberFormat(aAddress, nFormat);
788  }
789  }
790  }
791  break;
793  {
794  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
795  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
796  {
797  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
798  if (eType == CELLTYPE_VALUE)
799  {
800  double nVal = rDoc.GetValue(rCol, nRow, 0);
801  Date aDate = getDate(nVal, pFormatter);
802  rDoc.SetValue(rCol, nRow, 0, aDate.GetMonth());
803  }
804  }
805  }
806  break;
808  {
809  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
810  LanguageType eLanguage = ScGlobal::eLnge;
811  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
812  {
813  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
814  if (eType == CELLTYPE_VALUE)
815  {
816  double nVal = rDoc.GetValue(rCol, nRow, 0);
817  const Color* pColor = nullptr;
818  OUString aResult;
819  pFormatter->GetPreviewStringGuess("MMMM", nVal, aResult, &pColor, eLanguage);
820  rDoc.SetString(rCol, nRow, 0, aResult);
821  }
822  }
823  }
824  break;
826  {
827  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
828  LanguageType eLanguage = ScGlobal::eLnge;
829  sal_uInt32 nFormat = pFormatter->GetStandardFormat( SvNumFormatType::DATE, eLanguage );
830  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
831  {
832  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
833  if (eType == CELLTYPE_VALUE)
834  {
835  double nVal = rDoc.GetValue(rCol, nRow, 0);
836  ScAddress aAddress(rCol, nRow, 0);
837  Date aDate = getDate(nVal, pFormatter);
838  aDate.SetDay(1);
839  nVal = aDate - pFormatter->GetNullDate();
840  rDoc.SetValue(rCol, nRow, 0, nVal);
841  rDoc.SetNumberFormat(aAddress, nFormat);
842  }
843  }
844  }
845  break;
847  {
848  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
849  LanguageType eLanguage = ScGlobal::eLnge;
850  sal_uInt32 nFormat = pFormatter->GetStandardFormat( SvNumFormatType::DATE, eLanguage );
851  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
852  {
853  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
854  if (eType == CELLTYPE_VALUE)
855  {
856  double nVal = rDoc.GetValue(rCol, nRow, 0);
857  ScAddress aAddress(rCol, nRow, 0);
858  Date aDate = getDate(nVal, pFormatter);
859  aDate.SetDay(aDate.GetDaysInMonth());
860  nVal = aDate - pFormatter->GetNullDate();
861  rDoc.SetValue(rCol, nRow, 0, nVal);
862  rDoc.SetNumberFormat(aAddress, nFormat);
863  }
864  }
865  }
866  break;
868  {
869  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
870  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
871  {
872  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
873  if (eType == CELLTYPE_VALUE)
874  {
875  double nVal = rDoc.GetValue(rCol, nRow, 0);
876  Date aDate = getDate(nVal, pFormatter);
877  rDoc.SetValue(rCol, nRow, 0, aDate.GetDay());
878  }
879  }
880  }
881  break;
883  {
884  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
885  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
886  {
887  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
888  if (eType == CELLTYPE_VALUE)
889  {
890  double nVal = rDoc.GetValue(rCol, nRow, 0);
891  Date aDate = getDate(nVal, pFormatter);
892  rDoc.SetValue(rCol, nRow, 0, aDate.GetDayOfWeek());
893  }
894  }
895  }
896  break;
898  {
899  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
900  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
901  {
902  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
903  if (eType == CELLTYPE_VALUE)
904  {
905  double nVal = rDoc.GetValue(rCol, nRow, 0);
906  Date aDate = getDate(nVal, pFormatter);
907  rDoc.SetValue(rCol, nRow, 0, aDate.GetDayOfYear());
908  }
909  }
910  }
911  break;
913  {
914  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
915  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
916  {
917  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
918  if (eType == CELLTYPE_VALUE)
919  {
920  double nVal = rDoc.GetValue(rCol, nRow, 0);
921  Date aDate = getDate(nVal, pFormatter);
922 
923  int nMonth = aDate.GetMonth();
924 
925  if(nMonth >= 1 && nMonth <=3)
926  rDoc.SetValue(rCol, nRow, 0, 1);
927 
928  else if(nMonth >= 4 && nMonth <=6)
929  rDoc.SetValue(rCol, nRow, 0, 2);
930 
931  else if(nMonth >= 7 && nMonth <=9)
932  rDoc.SetValue(rCol, nRow, 0, 3);
933 
934  else if(nMonth >= 10 && nMonth <=12)
935  rDoc.SetValue(rCol, nRow, 0, 4);
936  else
937  rDoc.SetValue(rCol, nRow, 0, -1);
938 
939  }
940  }
941  }
942  break;
944  {
945  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
946  LanguageType eLanguage = ScGlobal::eLnge;
947  sal_uInt32 nFormat = pFormatter->GetStandardFormat( SvNumFormatType::DATE, eLanguage );
948  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
949  {
950  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
951  if (eType == CELLTYPE_VALUE)
952  {
953  double nVal = rDoc.GetValue(rCol, nRow, 0);
954  ScAddress aAddress(rCol, nRow, 0);
955  Date aDate = getDate(nVal, pFormatter);
956 
957  int nMonth = aDate.GetMonth();
958 
959  if(nMonth >= 1 && nMonth <=3)
960  {
961  aDate.SetDay(1);
962  aDate.SetMonth(1);
963  nVal = aDate - pFormatter->GetNullDate();
964  rDoc.SetValue(rCol, nRow, 0, nVal);
965  rDoc.SetNumberFormat(aAddress, nFormat);
966  }
967  else if(nMonth >= 4 && nMonth <=6)
968  {
969  aDate.SetDay(1);
970  aDate.SetMonth(4);
971  nVal = aDate - pFormatter->GetNullDate();
972  rDoc.SetValue(rCol, nRow, 0, nVal);
973  rDoc.SetNumberFormat(aAddress, nFormat);
974  }
975  else if(nMonth >= 7 && nMonth <=9)
976  {
977  aDate.SetDay(1);
978  aDate.SetMonth(7);
979  nVal = aDate - pFormatter->GetNullDate();
980  rDoc.SetValue(rCol, nRow, 0, nVal);
981  rDoc.SetNumberFormat(aAddress, nFormat);
982  }
983  else if(nMonth >= 10 && nMonth <=12)
984  {
985  aDate.SetDay(1);
986  aDate.SetMonth(10);
987  nVal = aDate - pFormatter->GetNullDate();
988  rDoc.SetValue(rCol, nRow, 0, nVal);
989  rDoc.SetNumberFormat(aAddress, nFormat);
990  }
991  else
992  rDoc.SetValue(rCol, nRow, 0, -1);
993  }
994  }
995  }
996  break;
998  {
999  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
1000  LanguageType eLanguage = ScGlobal::eLnge;
1001  sal_uInt32 nFormat = pFormatter->GetStandardFormat( SvNumFormatType::DATE, eLanguage );
1002  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
1003  {
1004  ScAddress aAddress(rCol, nRow, 0);
1005  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
1006  if (eType == CELLTYPE_VALUE)
1007  {
1008  double nVal = rDoc.GetValue(rCol, nRow, 0);
1009  Date aDate = getDate(nVal, pFormatter);
1010  int nMonth = aDate.GetMonth();
1011 
1012  if(nMonth >= 1 && nMonth <=3)
1013  {
1014  aDate.SetDay(31);
1015  aDate.SetMonth(3);
1016  nVal = aDate - pFormatter->GetNullDate();
1017  rDoc.SetValue(rCol, nRow, 0, nVal);
1018  rDoc.SetNumberFormat(aAddress, nFormat);
1019  }
1020 
1021  else if(nMonth >= 4 && nMonth <=6)
1022  {
1023  aDate.SetDay(30);
1024  aDate.SetMonth(6);
1025  nVal = aDate - pFormatter->GetNullDate();
1026  rDoc.SetValue(rCol, nRow, 0, nVal);
1027  rDoc.SetNumberFormat(aAddress, nFormat);
1028  }
1029 
1030  else if(nMonth >= 7 && nMonth <=9)
1031  {
1032  aDate.SetDay(30);
1033  aDate.SetMonth(9);
1034  nVal = aDate - pFormatter->GetNullDate();
1035  rDoc.SetValue(rCol, nRow, 0, nVal);
1036  rDoc.SetNumberFormat(aAddress, nFormat);
1037  }
1038 
1039  else if(nMonth >= 10 && nMonth <=12)
1040  {
1041  aDate.SetDay(31);
1042  aDate.SetMonth(12);
1043  nVal = aDate - pFormatter->GetNullDate();
1044  rDoc.SetValue(rCol, nRow, 0, nVal);
1045  rDoc.SetNumberFormat(aAddress, nFormat);
1046  }
1047  else
1048  rDoc.SetValue(rCol, nRow, 0, -1);
1049 
1050  }
1051  }
1052  }
1053  break;
1055  {
1056  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
1057  LanguageType eLanguage = ScGlobal::eLnge;
1058  sal_uInt32 nFormat = pFormatter->GetStandardFormat(SvNumFormatType::TIME, eLanguage);
1059  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
1060  {
1061  ScAddress aAddress(rCol, nRow, 0);
1062  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
1063  if (eType == CELLTYPE_VALUE)
1064  {
1065  rDoc.SetNumberFormat(aAddress, nFormat);
1066  }
1067  }
1068  }
1069  break;
1071  {
1072  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
1073  {
1074  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
1075  if (eType == CELLTYPE_VALUE)
1076  {
1077  double nVal = rDoc.GetValue(rCol, nRow, 0);
1078  sal_uInt16 nHour, nMinute, nSecond;
1079  double fFractionOfSecond;
1080  tools::Time::GetClock( nVal, nHour, nMinute, nSecond, fFractionOfSecond, 0);
1081  rDoc.SetValue(rCol, nRow, 0, nHour);
1082  }
1083  }
1084  }
1085  break;
1087  {
1088  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
1089  {
1090  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
1091  if (eType == CELLTYPE_VALUE)
1092  {
1093  double nVal = rDoc.GetValue(rCol, nRow, 0);
1094  sal_uInt16 nHour, nMinute, nSecond;
1095  double fFractionOfSecond;
1096  tools::Time::GetClock( nVal, nHour, nMinute, nSecond, fFractionOfSecond, 0);
1097  rDoc.SetValue(rCol, nRow, 0, nMinute);
1098  }
1099  }
1100  }
1101  break;
1103  {
1104  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
1105  {
1106  CellType eType = rDoc.GetCellType(rCol, nRow, 0);
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, nSecond);
1114  }
1115  }
1116  }
1117  break;
1118  default:
1119  break;
1120  }
1121  }
1122 }
1123 
1125 {
1127 }
1128 
1130 {
1131  return maType;
1132 }
1133 
1134 const std::set<SCCOL>& DateTimeTransformation::getColumn() const
1135 {
1136  return mnCol;
1137 }
1138 
1139 FindReplaceTransformation::FindReplaceTransformation(SCCOL nCol, const OUString& aFindString, const OUString& aReplaceString)
1140  : mnCol(nCol)
1141  , maFindString(aFindString)
1142  , maReplaceString(aReplaceString)
1143 {
1144 }
1145 
1147 {
1148  if (mnCol == -1)
1149  return;
1150 
1151  SCROW nEndRow = getLastRow(rDoc, mnCol);
1152  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
1153  {
1154  CellType eType = rDoc.GetCellType(mnCol, nRow, 0);
1155  if (eType != CELLTYPE_NONE)
1156  {
1157  OUString aStr = rDoc.GetString(mnCol, nRow, 0);
1158  if (aStr == maFindString)
1159  rDoc.SetString(mnCol, nRow, 0, maReplaceString);
1160  }
1161  }
1162 }
1163 
1165 {
1167 }
1168 
1170 {
1171  return mnCol;
1172 }
1173 
1175 {
1176  return maFindString;
1177 }
1178 
1180 {
1181  return maReplaceString;
1182 }
1183 
1185  : mnCol(nCol)
1186  , maFindString(aFindString)
1187 {
1188 }
1189 
1191 {
1192  sal_Int32 nIncrementIndex = 0;
1193  if (mnCol == -1)
1194  return;
1195 
1196  SCROW nEndRow = getLastRow(rDoc, mnCol);
1197  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
1198  {
1199  CellType eType = rDoc.GetCellType(mnCol, nRow - nIncrementIndex, 0);
1200  if (eType != CELLTYPE_NONE)
1201  {
1202  OUString aStr = rDoc.GetString(mnCol, nRow - nIncrementIndex, 0);
1203  if (aStr == maFindString)
1204  {
1205  rDoc.DeleteRow(0, 0, rDoc.MaxCol(), 0, nRow - nIncrementIndex, 1);
1206  nIncrementIndex++;
1207  }
1208  }
1209  }
1210 }
1211 
1213 {
1215 }
1216 
1218 {
1219  return mnCol;
1220 }
1221 
1223 {
1224  return maFindString;
1225 }
1226 
1228  : mxRow(mRow)
1229  , nxRow(nRow)
1230 {
1231 }
1232 
1234 {
1235  if (mxRow == -1 || nxRow == -1)
1236  return;
1237 
1238  for (SCCOL nCol = 0; nCol <= rDoc.MaxCol(); ++nCol)
1239  {
1240  CellType aType = rDoc.GetCellType(nCol, mxRow, 0);
1241  if (aType == CELLTYPE_STRING)
1242  {
1243  OUString aStr = rDoc.GetString(nCol, mxRow, 0);
1244  OUString bStr = rDoc.GetString(nCol, nxRow, 0);
1245  rDoc.SetString(nCol, mxRow, 0, bStr);
1246  rDoc.SetString(nCol, nxRow, 0, aStr);
1247  }
1248  else if (aType == CELLTYPE_VALUE)
1249  {
1250  double aVal = rDoc.GetValue(nCol, mxRow, 0);
1251  double bVal = rDoc.GetValue(nCol, nxRow, 0);
1252  rDoc.SetValue(nCol, mxRow, 0, bVal);
1253  rDoc.SetValue(nCol, nxRow, 0, aVal);
1254  }
1255  }
1256 }
1257 
1259 {
1261 }
1262 
1264 {
1265  return mxRow;
1266 }
1267 
1269 {
1270  return nxRow;
1271 }
1272 
1273 }
1274 
1275 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
ReplaceNullTransformation(std::set< SCCOL > &&nCol, const OUString &sReplaceWith)
virtual void Transform(ScDocument &rDoc) const override
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:1590
DATETIME_TRANSFORMATION_TYPE getDateTimeTransformationType() const
virtual void Transform(ScDocument &rDoc) const override
OUString maType
void DeleteRow(SCCOL nStartCol, SCTAB nStartTab, SCCOL nEndCol, SCTAB nEndTab, SCROW nStartRow, SCSIZE nSize, ScDocument *pRefUndoDoc=nullptr, bool *pUndoOutline=nullptr, const ScMarkData *pTabMark=nullptr)
Definition: document.cxx:1365
const std::set< SCCOL > & getColumns() const
AGGREGATE_FUNCTION maType
sal_Int32 nIndex
AggregateFunction(std::set< SCCOL > &&rColumns, const AGGREGATE_FUNCTION rType)
DayOfWeek GetDayOfWeek() const
TextTransformation(std::set< SCCOL > &&nCol, const TEXT_TRANSFORM_TYPE rType)
TEXT_TRANSFORM_TYPE getTextTransformationType() const
static SCROW getLastRow(const ScDocument &rDoc, SCCOL nCol)
virtual void Transform(ScDocument &rDoc) const override
const std::set< SCCOL > & getColumn() const
virtual TransformationType getTransformationType() const override
FindReplaceTransformation(SCCOL nCol, const OUString &aFindString, const OUString &aReplaceString)
NUMBER_TRANSFORM_TYPE maType
sal_Int32 mnCol
virtual void Transform(ScDocument &rDoc) const override
virtual TransformationType getTransformationType() const override
SwapRowsTransformation(SCROW mRow, SCROW nRow)
const std::set< SCCOL > & getColumn() const
virtual TransformationType getTransformationType() const override
const std::set< SCCOL > & getColumns() const
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
virtual void Transform(ScDocument &rDoc) const override
const OUString & getMergeString() const
SC_DLLPUBLIC void SetValue(SCCOL nCol, SCROW nRow, SCTAB nTab, const double &rVal)
Definition: document.cxx:3508
MergeColumnTransformation(std::set< SCCOL > &&rColumns, const OUString &rMergeString)
virtual TransformationType getTransformationType() const override
const ScSortParam & getSortParam() const
virtual void Transform(ScDocument &rDoc) const override
void Sort(SCTAB nTab, const ScSortParam &rSortParam, bool bKeepQuery, bool bUpdateRefs, ScProgress *pProgress, sc::ReorderParam *pUndo)
Sort a range of data.
Definition: documen3.cxx:1436
DateTimeTransformation(std::set< SCCOL > &&nCol, const DATETIME_TRANSFORMATION_TYPE rType)
AGGREGATE_FUNCTION getAggregateType() const
TEXT_TRANSFORM_TYPE maType
sal_uInt16 sal_Unicode
virtual TransformationType getTransformationType() const override
SC_DLLPUBLIC SCROW MaxRow() const
Definition: document.hxx:891
sal_uInt16 GetMonth() const
SC_DLLPUBLIC OUString GetString(SCCOL nCol, SCROW nRow, SCTAB nTab, const ScInterpreterContext *pContext=nullptr) const
Definition: document.cxx:3536
virtual TransformationType getTransformationType() const override
virtual ~ColumnRemoveTransformation() override
SC_DLLPUBLIC double GetValue(const ScAddress &rPos) const
Definition: document.cxx:3663
DocumentType eType
DATETIME_TRANSFORMATION_TYPE
sal_Int16 GetYear() const
virtual void Transform(ScDocument &rDoc) const override
const std::set< SCCOL > & getColumn() const
SC_DLLPUBLIC bool SetString(SCCOL nCol, SCROW nRow, SCTAB nTab, const OUString &rString, const ScSetStringParam *pParam=nullptr)
Definition: document.cxx:3413
SC_DLLPUBLIC SCCOL MaxCol() const
Definition: document.hxx:890
SC_DLLPUBLIC SvNumberFormatter * GetFormatTable() const
Definition: documen2.cxx:459
sal_uInt16 GetDaysInMonth() const
SC_DLLPUBLIC CellType GetCellType(SCCOL nCol, SCROW nRow, SCTAB nTab) const
Definition: document.cxx:3781
int i
void SetDay(sal_uInt16 nNewDay)
SplitColumnTransformation(SCCOL nCol, sal_Unicode cSeparator)
virtual TransformationType getTransformationType() const override
sal_Int16 SCCOL
Definition: types.hxx:21
static SC_DLLPUBLIC const CharClass & getCharClass()
Definition: global.cxx:1024
CAUTION! The following defines must be in the same namespace as the respective type.
virtual void Transform(ScDocument &rDoc) const override
virtual TransformationType getTransformationType() const override
virtual void Transform(ScDocument &rDoc) const override
sal_uInt16 GetDay() const
void AddDays(sal_Int32 nAddDays)
static SC_DLLPUBLIC LanguageType eLnge
Definition: global.hxx:545
virtual void Transform(ScDocument &rDoc) const override
NUMBER_TRANSFORM_TYPE getNumberTransformationType() const
void SetNumberFormat(const ScAddress &rPos, sal_uInt32 nNumberFormat)
Definition: document.cxx:3723
std::set< SCCOL > maColumns
sal_Int32 SCROW
Definition: types.hxx:17
const OUString & getFindString() const
static void GetClock(double fTimeInDays, sal_uInt16 &nHour, sal_uInt16 &nMinute, sal_uInt16 &nSecond, double &fFractionOfSecond, int nFractionDecimals)
NumberTransformation(std::set< SCCOL > &&nCol, const NUMBER_TRANSFORM_TYPE rType)
CellType
Definition: global.hxx:269
DATETIME_TRANSFORMATION_TYPE maType
sal_uInt32 GetStandardFormat(SvNumFormatType eType, LanguageType eLnge=LANGUAGE_DONTKNOW)
virtual void Transform(ScDocument &rDoc) const override
bool GetPreviewStringGuess(const OUString &sFormatString, double fPreviewNumber, OUString &sOutString, const Color **ppColor, LanguageType eLnge=LANGUAGE_DONTKNOW)
const OUString & getReplaceString() const
SC_DLLPUBLIC 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:1080
DeleteRowTransformation(SCCOL nCol, const OUString &aFindString)
const OUString & getFindString() const
const std::set< SCCOL > & getColumns() const
SortTransformation(const ScSortParam &rParam)
ColumnRemoveTransformation(std::set< SCCOL > &&rColumns)
virtual TransformationType getTransformationType() const override
virtual void Transform(ScDocument &rDoc) const override
const OUString & getReplaceString() const
sal_uInt16 GetDayOfYear() const
const std::set< SCCOL > & getColumns() const
virtual TransformationType getTransformationType() const override
const Date & GetNullDate() const
virtual TransformationType getTransformationType() const override
virtual TransformationType getTransformationType() const override
aStr
void SetMonth(sal_uInt16 nNewMonth)