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(rColumns)
43 {
44 }
45 
47 {
48 }
49 
51 {
52  for (auto& rCol : maColumns)
53  {
54  rDoc.DeleteCol(0, 0, rDoc.MaxRow(), 0, rCol, 1);
55  }
56 }
57 
59 {
61 }
62 
63 const std::set<SCCOL> & ColumnRemoveTransformation::getColumns() const
64 {
65  return maColumns;
66 }
67 
69  mnCol(nCol),
70  mcSeparator(cSeparator)
71 {
72 }
73 
75 {
76  rDoc.InsertCol(0, 0, rDoc.MaxRow(), 0, mnCol + 1, 1);
77 
78  SCROW nEndRow = getLastRow(rDoc, mnCol);
79  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
80  {
82  rDoc.GetCellType(mnCol, nRow, 0, eType);
83  if (eType == CELLTYPE_STRING)
84  {
85  OUString aStr = rDoc.GetString(mnCol, nRow, 0);
86  sal_Int32 nIndex = aStr.indexOf(mcSeparator);
87  if (nIndex != -1)
88  {
89  rDoc.SetString(mnCol + 1, nRow, 0, aStr.copy(nIndex + 1));
90  rDoc.SetString(mnCol, nRow, 0, aStr.copy(0, nIndex));
91  }
92  }
93  }
94 }
95 
97 {
99 }
100 
102 {
103  return mnCol;
104 }
105 
107 {
108  return mcSeparator;
109 }
110 
111 MergeColumnTransformation::MergeColumnTransformation(const std::set<SCCOL>& rColumns, const OUString& rMergeString):
112  maColumns(rColumns),
113  maMergeString(rMergeString)
114 {
115 }
116 
118 {
119  if (maColumns.empty())
120  return;
121 
122  SCROW nMaxRow = 0;
123  for (auto& itr : maColumns)
124  {
125  nMaxRow = getLastRow(rDoc, itr);
126  }
127  assert(nMaxRow != -1);
128 
129  SCCOL nTargetCol = *maColumns.begin();
130 
131 
132  for (SCROW nRow = 0; nRow <= nMaxRow; ++nRow)
133  {
134  OUStringBuffer aStr = rDoc.GetString(nTargetCol, nRow, 0);
135  for (auto& itr : maColumns)
136  {
137  if (itr != nTargetCol)
138  {
139  aStr.append(maMergeString + rDoc.GetString(itr, nRow, 0));
140  }
141  }
142  rDoc.SetString(nTargetCol, nRow, 0, aStr.makeStringAndClear());
143  }
144 
145  for (auto& itr : maColumns)
146  {
147  if (itr == nTargetCol)
148  continue;
149 
150  rDoc.DeleteCol(0, 0, rDoc.MaxRow(), 0, itr, 1);
151  }
152 }
153 
155 {
157 }
158 
160 {
161  return maMergeString;
162 }
163 
164 const std::set<SCCOL> & MergeColumnTransformation::getColumns() const
165 {
166  return maColumns;
167 }
168 
170  maSortParam(rSortParam)
171 {
172 }
173 
175 {
176  rDoc.Sort(0, maSortParam, false, false, nullptr, nullptr);
177 }
178 
180 {
182 }
183 
185 {
186  return maSortParam;
187 }
188 
189 TextTransformation::TextTransformation(const std::set<SCCOL>& nCol, const TEXT_TRANSFORM_TYPE rType):
190  mnCol(nCol),
191  maType(rType)
192 {
193 }
194 
196 {
197  SCROW nEndRow = 0;
198  for(auto& rCol : mnCol)
199  {
200  nEndRow = getLastRow(rDoc, rCol);
201  }
202  assert(nEndRow != -1);
203 
204  for(auto& rCol : mnCol)
205  {
206  switch (maType)
207  {
209  {
210  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
211  {
212  CellType eType;
213  rDoc.GetCellType(rCol, nRow, 0, eType);
214  if (eType == CELLTYPE_STRING)
215  {
216  OUString aStr = rDoc.GetString(rCol, nRow, 0);
217  rDoc.SetString(rCol, nRow, 0, ScGlobal::getCharClass().lowercase(aStr));
218  }
219  }
220  }
221  break;
223  {
224  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
225  {
226  CellType eType;
227  rDoc.GetCellType(rCol, nRow, 0, eType);
228  if (eType == CELLTYPE_STRING)
229  {
230  OUString aStr = rDoc.GetString(rCol, nRow, 0);
231  rDoc.SetString(rCol, nRow, 0, ScGlobal::getCharClass().uppercase(aStr));
232  }
233  }
234  }
235  break;
237  {
238  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
239  {
240  CellType eType;
241  rDoc.GetCellType(rCol, nRow, 0, eType);
242  if (eType == CELLTYPE_STRING)
243  {
244  OUString aStr = rDoc.GetString(rCol, nRow, 0);
245 
246  sal_Int32 length = aStr.getLength();
247 
248  if(length != 0)
249  aStr = aStr.replaceAt(0, 1, ScGlobal::getCharClass().uppercase(OUString(aStr[0])));
250 
251  for (sal_Int32 i = 1; i < length; i++){
252  if (aStr[i-1] == sal_Unicode(U' '))
253  {
254  aStr = aStr.replaceAt(i, 1, ScGlobal::getCharClass().uppercase(OUString(aStr[i])));
255  }
256  else
257  {
258  aStr = aStr.replaceAt(i, 1, ScGlobal::getCharClass().lowercase(OUString(aStr[i])));
259  }
260  }
261  rDoc.SetString(rCol, nRow, 0, aStr);
262  }
263  }
264  }
265  break;
267  {
268  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
269  {
270  CellType eType;
271  rDoc.GetCellType(rCol, nRow, 0, eType);
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(const std::set<SCCOL>& rColumns, const AGGREGATE_FUNCTION rType):
302  maColumns(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;
326  rDoc.GetCellType(rCol, nRow, 0, eType);
327  if (eType == CELLTYPE_VALUE)
328  {
329  double nVal = rDoc.GetValue(rCol, nRow, 0);
330  nSum += nVal;
331  }
332  }
333  rDoc.SetValue(rCol, nEndRow + 1, 0, nSum);
334  }
335  break;
337  {
338  double nSum = 0;
339  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
340  {
341  CellType eType;
342  rDoc.GetCellType(rCol, nRow, 0, eType);
343  if (eType == CELLTYPE_VALUE)
344  {
345  double nVal = rDoc.GetValue(rCol, nRow, 0);
346  nSum += nVal;
347  }
348  }
349 
350  double nAvg = nSum / (nEndRow + 1);
351  rDoc.SetValue(rCol, nEndRow + 1, 0, nAvg);
352  }
353  break;
355  {
356  double nMin = std::numeric_limits<double>::max();
357  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
358  {
359  CellType eType;
360  rDoc.GetCellType(rCol, nRow, 0, eType);
361  if (eType == CELLTYPE_VALUE)
362  {
363  double nVal = rDoc.GetValue(rCol, nRow, 0);
364  if(nVal < nMin)
365  nMin = nVal;
366  }
367  }
368  rDoc.SetValue(rCol, nEndRow + 1, 0, nMin);
369  }
370  break;
372  {
373  double nMax = std::numeric_limits<double>::lowest();
374  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
375  {
376  CellType eType;
377  rDoc.GetCellType(rCol, nRow, 0, eType);
378  if (eType == CELLTYPE_VALUE)
379  {
380  double nVal = rDoc.GetValue(rCol, nRow, 0);
381  if(nMax < nVal)
382  nMax = nVal;
383  }
384  }
385  rDoc.SetValue(rCol, nEndRow + 1, 0, nMax);
386  }
387  break;
388  default:
389  break;
390  }
391  }
392 }
393 
395 {
397 }
398 
400 {
401  return maType;
402 }
403 
404 const std::set<SCCOL>& AggregateFunction::getColumns() const
405 {
406  return maColumns;
407 }
408 
409 NumberTransformation::NumberTransformation(const std::set<SCCOL>& nCol,
410  const NUMBER_TRANSFORM_TYPE rType)
411  : mnCol(nCol)
412  , maType(rType)
413  , maPrecision(-1)
414 {
415 }
416 
417 NumberTransformation::NumberTransformation(const std::set<SCCOL>& nCol,
418  const NUMBER_TRANSFORM_TYPE rType, int nPrecision)
419  : mnCol(nCol)
420  , maType(rType)
421  , maPrecision(nPrecision)
422 {
423 }
424 
426 {
427  SCROW nEndRow = 0;
428  for(auto& rCol : mnCol)
429  {
430  nEndRow = getLastRow(rDoc, rCol);
431  }
432  assert(nEndRow != -1);
433 
434  for(auto& rCol : mnCol)
435  {
436  switch (maType)
437  {
439  {
440  if(maPrecision > -1)
441  {
442  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
443  {
444  CellType eType;
445  rDoc.GetCellType(rCol, nRow, 0, eType);
446  if (eType == CELLTYPE_VALUE)
447  {
448  double nVal = rDoc.GetValue(rCol, nRow, 0);
449  rDoc.SetValue(rCol, nRow, 0, rtl::math::round(nVal, maPrecision));
450  }
451  }
452  }
453  }
454  break;
456  {
457  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
458  {
459  CellType eType;
460  rDoc.GetCellType(rCol, nRow, 0, eType);
461  if (eType == CELLTYPE_VALUE)
462  {
463  double nVal = rDoc.GetValue(rCol, nRow, 0);
464  rDoc.SetValue(rCol, nRow, 0, rtl::math::approxCeil(nVal));
465  }
466  }
467  }
468  break;
470  {
471  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
472  {
473  CellType eType;
474  rDoc.GetCellType(rCol, nRow, 0, eType);
475  if (eType == CELLTYPE_VALUE)
476  {
477  double nVal = rDoc.GetValue(rCol, nRow, 0);
478  rDoc.SetValue(rCol, nRow, 0, rtl::math::approxFloor(nVal));
479  }
480  }
481  }
482  break;
484  {
485  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
486  {
487  CellType eType;
488  rDoc.GetCellType(rCol, nRow, 0, eType);
489  if (eType == CELLTYPE_VALUE)
490  {
491  double nVal = rDoc.GetValue(rCol, nRow, 0);
492  if(std::signbit(nVal))
493  rDoc.SetValue(rCol, nRow, 0, -1 * nVal);
494  }
495  }
496  }
497  break;
499  {
500  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
501  {
502  CellType eType;
503  rDoc.GetCellType(rCol, nRow, 0, eType);
504  if (eType == CELLTYPE_VALUE)
505  {
506  double nVal = rDoc.GetValue(rCol, nRow, 0);
507  if (nVal > 0)
508  {
509  rDoc.SetValue(rCol, nRow, 0, rtl::math::log1p(nVal-1));
510  }
511  else
512  {
513  rDoc.SetString(rCol, nRow, 0, OUString());
514  }
515  }
516  }
517  }
518  break;
520  {
521  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
522  {
523  CellType eType;
524  rDoc.GetCellType(rCol, nRow, 0, eType);
525  if (eType == CELLTYPE_VALUE)
526  {
527  double nVal = rDoc.GetValue(rCol, nRow, 0);
528  if (nVal > 0)
529  {
530  rDoc.SetValue(rCol, nRow, 0, log10(nVal));
531  }
532  else
533  {
534  rDoc.SetString(rCol, nRow, 0, OUString());
535  }
536  }
537  }
538  }
539  break;
541  {
542  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
543  {
544  CellType eType;
545  rDoc.GetCellType(rCol, nRow, 0, eType);
546  if (eType == CELLTYPE_VALUE)
547  {
548  double nVal = rDoc.GetValue(rCol, nRow, 0);
549  rDoc.SetValue(rCol, nRow, 0, nVal * nVal * nVal);
550  }
551  }
552  }
553  break;
555  {
556  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
557  {
558  CellType eType;
559  rDoc.GetCellType(rCol, nRow, 0, eType);
560  if (eType == CELLTYPE_VALUE)
561  {
562  double nVal = rDoc.GetValue(rCol, nRow, 0);
563  rDoc.SetValue(rCol, nRow, 0, nVal * nVal);
564  }
565  }
566  }
567  break;
569  {
570  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
571  {
572  CellType eType;
573  rDoc.GetCellType(rCol, nRow, 0, eType);
574  if (eType == CELLTYPE_VALUE)
575  {
576  double nVal = rDoc.GetValue(rCol, nRow, 0);
577  if (!std::signbit(nVal))
578  {
579  rDoc.SetValue(rCol, nRow, 0, sqrt(nVal));
580  }
581  else
582  {
583  rDoc.SetString(rCol, nRow, 0, OUString());
584  }
585  }
586  }
587  }
588  break;
590  {
591  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
592  {
593  CellType eType;
594  rDoc.GetCellType(rCol, nRow, 0, eType);
595  if (eType == CELLTYPE_VALUE)
596  {
597  double nVal = rDoc.GetValue(rCol, nRow, 0);
598  if (fmod(nVal, 1) == 0 && fmod(nVal, 2) == 0)
599  rDoc.SetValue(rCol, nRow, 0, 1);
600  else
601  rDoc.SetValue(rCol, nRow, 0, 0);
602  }
603  }
604  }
605  break;
607  {
608  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
609  {
610  CellType eType;
611  rDoc.GetCellType(rCol, nRow, 0, eType);
612  if (eType == CELLTYPE_VALUE)
613  {
614  double nVal = rDoc.GetValue(rCol, nRow, 0);
615  if (fmod(nVal, 1) == 0 && fmod(nVal, 2) != 0)
616  rDoc.SetValue(rCol, nRow, 0, 1);
617  else
618  rDoc.SetValue(rCol, nRow, 0, 0);
619  }
620  }
621  }
622  break;
624  {
625  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
626  {
627  CellType eType;
628  rDoc.GetCellType(rCol, nRow, 0, eType);
629  if (eType == CELLTYPE_VALUE)
630  {
631  double nVal = rDoc.GetValue(rCol, nRow, 0);
632  if (nVal > 0)
633  rDoc.SetValue(rCol, nRow, 0, 1);
634  else if (nVal < 0)
635  rDoc.SetValue(rCol, nRow, 0, -1);
636  else
637  rDoc.SetValue(rCol, nRow, 0, 0);
638  }
639  }
640  }
641  break;
642  default:
643  break;
644  }
645  }
646 }
647 
649 {
651 }
652 
654 {
655  return maType;
656 }
657 
659 {
660  return maPrecision;
661 }
662 
663 const std::set<SCCOL>& NumberTransformation::getColumn() const
664 {
665  return mnCol;
666 }
667 
669  const OUString& sReplaceWith)
670  : mnCol(nCol)
671  , msReplaceWith(sReplaceWith)
672 {
673 }
674 
676 {
677  if (mnCol.empty())
678  return;
679 
680  for(auto& rCol : mnCol)
681  {
682  SCROW nEndRow = getLastRow(rDoc, rCol);
683  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
684  {
685  CellType eType;
686  rDoc.GetCellType(rCol, nRow, 0, eType);
687  if (eType == CELLTYPE_NONE)
688  {
689  // OUString aStr = rDoc.GetString(rCol, nRow, 0);
690  // if (aStr == "" || aStr.isEmpty())
691  rDoc.SetString(rCol, nRow, 0, msReplaceWith);
692  }
693  }
694  }
695 
696 }
697 
698 const std::set<SCCOL>& ReplaceNullTransformation::getColumn() const
699 {
700  return mnCol;
701 }
702 
704 {
705  return msReplaceWith;
706 }
707 
709 {
711 }
712 
714  const DATETIME_TRANSFORMATION_TYPE rType)
715  : mnCol(nCol)
716  , maType(rType)
717 {
718 }
719 
721 {
722  SCROW nEndRow = 0;
723  for(auto& rCol : mnCol)
724  {
725  nEndRow = getLastRow(rDoc, rCol);
726  }
727  assert(nEndRow != -1);
728 
729  for(auto& rCol : mnCol)
730  {
731  switch (maType)
732  {
734  {
735  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
736  LanguageType eLanguage = ScGlobal::eLnge;
737  sal_uInt32 nFormat = pFormatter->GetStandardFormat( SvNumFormatType::DATE, eLanguage );
738  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
739  {
740  CellType eType;
741  rDoc.GetCellType(rCol, nRow, 0, eType);
742  if (eType == CELLTYPE_VALUE)
743  {
744  ScAddress aAddress(rCol, nRow, 0);
745  rDoc.SetNumberFormat(aAddress, nFormat);
746  }
747  }
748  }
749  break;
751  {
752  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
753  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
754  {
755  CellType eType;
756  rDoc.GetCellType(rCol, nRow, 0, eType);
757  if (eType == CELLTYPE_VALUE)
758  {
759  double nVal = rDoc.GetValue(rCol, nRow, 0);
760  Date aDate = getDate(nVal, pFormatter);
761  rDoc.SetValue(rCol, nRow, 0, aDate.GetYear());
762  }
763  }
764  }
765  break;
767  {
768  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
769  LanguageType eLanguage = ScGlobal::eLnge;
770  sal_uInt32 nFormat = pFormatter->GetStandardFormat( SvNumFormatType::DATE, eLanguage );
771  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
772  {
773  CellType eType;
774  rDoc.GetCellType(rCol, nRow, 0, eType);
775  if (eType == CELLTYPE_VALUE)
776  {
777  double nVal = rDoc.GetValue(rCol, nRow, 0);
778  Date aDate = getDate(nVal, pFormatter);
779  aDate.SetDay(1);
780  aDate.SetMonth(1);
781  nVal = aDate - pFormatter->GetNullDate();
782  ScAddress aAddress(rCol, nRow, 0);
783  rDoc.SetValue(rCol, nRow, 0, nVal);
784  rDoc.SetNumberFormat(aAddress, nFormat);
785  }
786  }
787  }
788  break;
790  {
791  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
792  LanguageType eLanguage = ScGlobal::eLnge;
793  sal_uInt32 nFormat = pFormatter->GetStandardFormat( SvNumFormatType::DATE, eLanguage );
794 
795  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
796  {
797  CellType eType;
798  rDoc.GetCellType(rCol, nRow, 0, eType);
799  if (eType == CELLTYPE_VALUE)
800  {
801  double nVal = rDoc.GetValue(rCol, nRow, 0);
802  Date aDate = getDate(nVal, pFormatter);
803  aDate.SetMonth(12);
804  aDate.SetDay(31);
805  nVal = aDate - pFormatter->GetNullDate();
806  ScAddress aAddress(rCol, nRow, 0);
807  rDoc.SetValue(rCol, nRow, 0, nVal);
808  rDoc.SetNumberFormat(aAddress, nFormat);
809  }
810  }
811  }
812  break;
814  {
815  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
816  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
817  {
818  CellType eType;
819  rDoc.GetCellType(rCol, nRow, 0, eType);
820  if (eType == CELLTYPE_VALUE)
821  {
822  double nVal = rDoc.GetValue(rCol, nRow, 0);
823  Date aDate = getDate(nVal, pFormatter);
824  rDoc.SetValue(rCol, nRow, 0, aDate.GetMonth());
825  }
826  }
827  }
828  break;
830  {
831  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
832  LanguageType eLanguage = ScGlobal::eLnge;
833  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
834  {
835  CellType eType;
836  rDoc.GetCellType(rCol, nRow, 0, eType);
837  if (eType == CELLTYPE_VALUE)
838  {
839  double nVal = rDoc.GetValue(rCol, nRow, 0);
840  const Color* pColor = nullptr;
841  OUString aResult;
842  pFormatter->GetPreviewStringGuess("MMMM", nVal, aResult, &pColor, eLanguage);
843  rDoc.SetString(rCol, nRow, 0, aResult);
844  }
845  }
846  }
847  break;
849  {
850  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
851  LanguageType eLanguage = ScGlobal::eLnge;
852  sal_uInt32 nFormat = pFormatter->GetStandardFormat( SvNumFormatType::DATE, eLanguage );
853  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
854  {
855  CellType eType;
856  rDoc.GetCellType(rCol, nRow, 0, eType);
857  if (eType == CELLTYPE_VALUE)
858  {
859  double nVal = rDoc.GetValue(rCol, nRow, 0);
860  ScAddress aAddress(rCol, nRow, 0);
861  Date aDate = getDate(nVal, pFormatter);
862  aDate.SetDay(1);
863  nVal = aDate - pFormatter->GetNullDate();
864  rDoc.SetValue(rCol, nRow, 0, nVal);
865  rDoc.SetNumberFormat(aAddress, nFormat);
866  }
867  }
868  }
869  break;
871  {
872  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
873  LanguageType eLanguage = ScGlobal::eLnge;
874  sal_uInt32 nFormat = pFormatter->GetStandardFormat( SvNumFormatType::DATE, eLanguage );
875  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
876  {
877  CellType eType;
878  rDoc.GetCellType(rCol, nRow, 0, eType);
879  if (eType == CELLTYPE_VALUE)
880  {
881  double nVal = rDoc.GetValue(rCol, nRow, 0);
882  ScAddress aAddress(rCol, nRow, 0);
883  Date aDate = getDate(nVal, pFormatter);
884  aDate.SetDay(aDate.GetDaysInMonth());
885  nVal = aDate - pFormatter->GetNullDate();
886  rDoc.SetValue(rCol, nRow, 0, nVal);
887  rDoc.SetNumberFormat(aAddress, nFormat);
888  }
889  }
890  }
891  break;
893  {
894  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
895  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
896  {
897  CellType eType;
898  rDoc.GetCellType(rCol, nRow, 0, eType);
899  if (eType == CELLTYPE_VALUE)
900  {
901  double nVal = rDoc.GetValue(rCol, nRow, 0);
902  Date aDate = getDate(nVal, pFormatter);
903  rDoc.SetValue(rCol, nRow, 0, aDate.GetDay());
904  }
905  }
906  }
907  break;
909  {
910  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
911  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
912  {
913  CellType eType;
914  rDoc.GetCellType(rCol, nRow, 0, eType);
915  if (eType == CELLTYPE_VALUE)
916  {
917  double nVal = rDoc.GetValue(rCol, nRow, 0);
918  Date aDate = getDate(nVal, pFormatter);
919  rDoc.SetValue(rCol, nRow, 0, aDate.GetDayOfWeek());
920  }
921  }
922  }
923  break;
925  {
926  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
927  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
928  {
929  CellType eType;
930  rDoc.GetCellType(rCol, nRow, 0, eType);
931  if (eType == CELLTYPE_VALUE)
932  {
933  double nVal = rDoc.GetValue(rCol, nRow, 0);
934  Date aDate = getDate(nVal, pFormatter);
935  rDoc.SetValue(rCol, nRow, 0, aDate.GetDayOfYear());
936  }
937  }
938  }
939  break;
941  {
942  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
943  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
944  {
945  CellType eType;
946  rDoc.GetCellType(rCol, nRow, 0, eType);
947  if (eType == CELLTYPE_VALUE)
948  {
949  double nVal = rDoc.GetValue(rCol, nRow, 0);
950  Date aDate = getDate(nVal, pFormatter);
951 
952  int nMonth = aDate.GetMonth();
953 
954  if(nMonth >= 1 && nMonth <=3)
955  rDoc.SetValue(rCol, nRow, 0, 1);
956 
957  else if(nMonth >= 4 && nMonth <=6)
958  rDoc.SetValue(rCol, nRow, 0, 2);
959 
960  else if(nMonth >= 7 && nMonth <=9)
961  rDoc.SetValue(rCol, nRow, 0, 3);
962 
963  else if(nMonth >= 10 && nMonth <=12)
964  rDoc.SetValue(rCol, nRow, 0, 4);
965  else
966  rDoc.SetValue(rCol, nRow, 0, -1);
967 
968  }
969  }
970  }
971  break;
973  {
974  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
975  LanguageType eLanguage = ScGlobal::eLnge;
976  sal_uInt32 nFormat = pFormatter->GetStandardFormat( SvNumFormatType::DATE, eLanguage );
977  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
978  {
979  CellType eType;
980  rDoc.GetCellType(rCol, nRow, 0, eType);
981  if (eType == CELLTYPE_VALUE)
982  {
983  double nVal = rDoc.GetValue(rCol, nRow, 0);
984  ScAddress aAddress(rCol, nRow, 0);
985  Date aDate = getDate(nVal, pFormatter);
986 
987  int nMonth = aDate.GetMonth();
988 
989  if(nMonth >= 1 && nMonth <=3)
990  {
991  aDate.SetDay(1);
992  aDate.SetMonth(1);
993  nVal = aDate - pFormatter->GetNullDate();
994  rDoc.SetValue(rCol, nRow, 0, nVal);
995  rDoc.SetNumberFormat(aAddress, nFormat);
996  }
997  else if(nMonth >= 4 && nMonth <=6)
998  {
999  aDate.SetDay(1);
1000  aDate.SetMonth(4);
1001  nVal = aDate - pFormatter->GetNullDate();
1002  rDoc.SetValue(rCol, nRow, 0, nVal);
1003  rDoc.SetNumberFormat(aAddress, nFormat);
1004  }
1005  else if(nMonth >= 7 && nMonth <=9)
1006  {
1007  aDate.SetDay(1);
1008  aDate.SetMonth(7);
1009  nVal = aDate - pFormatter->GetNullDate();
1010  rDoc.SetValue(rCol, nRow, 0, nVal);
1011  rDoc.SetNumberFormat(aAddress, nFormat);
1012  }
1013  else if(nMonth >= 10 && nMonth <=12)
1014  {
1015  aDate.SetDay(1);
1016  aDate.SetMonth(10);
1017  nVal = aDate - pFormatter->GetNullDate();
1018  rDoc.SetValue(rCol, nRow, 0, nVal);
1019  rDoc.SetNumberFormat(aAddress, nFormat);
1020  }
1021  else
1022  rDoc.SetValue(rCol, nRow, 0, -1);
1023  }
1024  }
1025  }
1026  break;
1028  {
1029  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
1030  LanguageType eLanguage = ScGlobal::eLnge;
1031  sal_uInt32 nFormat = pFormatter->GetStandardFormat( SvNumFormatType::DATE, eLanguage );
1032  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
1033  {
1034  ScAddress aAddress(rCol, nRow, 0);
1035  CellType eType;
1036  rDoc.GetCellType(rCol, nRow, 0, eType);
1037  if (eType == CELLTYPE_VALUE)
1038  {
1039  double nVal = rDoc.GetValue(rCol, nRow, 0);
1040  Date aDate = getDate(nVal, pFormatter);
1041  int nMonth = aDate.GetMonth();
1042 
1043  if(nMonth >= 1 && nMonth <=3)
1044  {
1045  aDate.SetDay(31);
1046  aDate.SetMonth(3);
1047  nVal = aDate - pFormatter->GetNullDate();
1048  rDoc.SetValue(rCol, nRow, 0, nVal);
1049  rDoc.SetNumberFormat(aAddress, nFormat);
1050  }
1051 
1052  else if(nMonth >= 4 && nMonth <=6)
1053  {
1054  aDate.SetDay(30);
1055  aDate.SetMonth(6);
1056  nVal = aDate - pFormatter->GetNullDate();
1057  rDoc.SetValue(rCol, nRow, 0, nVal);
1058  rDoc.SetNumberFormat(aAddress, nFormat);
1059  }
1060 
1061  else if(nMonth >= 7 && nMonth <=9)
1062  {
1063  aDate.SetDay(30);
1064  aDate.SetMonth(9);
1065  nVal = aDate - pFormatter->GetNullDate();
1066  rDoc.SetValue(rCol, nRow, 0, nVal);
1067  rDoc.SetNumberFormat(aAddress, nFormat);
1068  }
1069 
1070  else if(nMonth >= 10 && nMonth <=12)
1071  {
1072  aDate.SetDay(31);
1073  aDate.SetMonth(12);
1074  nVal = aDate - pFormatter->GetNullDate();
1075  rDoc.SetValue(rCol, nRow, 0, nVal);
1076  rDoc.SetNumberFormat(aAddress, nFormat);
1077  }
1078  else
1079  rDoc.SetValue(rCol, nRow, 0, -1);
1080 
1081  }
1082  }
1083  }
1084  break;
1086  {
1087  SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
1088  LanguageType eLanguage = ScGlobal::eLnge;
1089  sal_uInt32 nFormat = pFormatter->GetStandardFormat(SvNumFormatType::TIME, eLanguage);
1090  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
1091  {
1092  ScAddress aAddress(rCol, nRow, 0);
1093  CellType eType;
1094  rDoc.GetCellType(rCol, nRow, 0, eType);
1095  if (eType == CELLTYPE_VALUE)
1096  {
1097  rDoc.SetNumberFormat(aAddress, nFormat);
1098  }
1099  }
1100  }
1101  break;
1103  {
1104  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
1105  {
1106  CellType eType;
1107  rDoc.GetCellType(rCol, nRow, 0, eType);
1108  if (eType == CELLTYPE_VALUE)
1109  {
1110  double nVal = rDoc.GetValue(rCol, nRow, 0);
1111  sal_uInt16 nHour, nMinute, nSecond;
1112  double fFractionOfSecond;
1113  tools::Time::GetClock( nVal, nHour, nMinute, nSecond, fFractionOfSecond, 0);
1114  rDoc.SetValue(rCol, nRow, 0, nHour);
1115  }
1116  }
1117  }
1118  break;
1120  {
1121  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
1122  {
1123  CellType eType;
1124  rDoc.GetCellType(rCol, nRow, 0, eType);
1125  if (eType == CELLTYPE_VALUE)
1126  {
1127  double nVal = rDoc.GetValue(rCol, nRow, 0);
1128  sal_uInt16 nHour, nMinute, nSecond;
1129  double fFractionOfSecond;
1130  tools::Time::GetClock( nVal, nHour, nMinute, nSecond, fFractionOfSecond, 0);
1131  rDoc.SetValue(rCol, nRow, 0, nMinute);
1132  }
1133  }
1134  }
1135  break;
1137  {
1138  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
1139  {
1140  CellType eType;
1141  rDoc.GetCellType(rCol, nRow, 0, eType);
1142  if (eType == CELLTYPE_VALUE)
1143  {
1144  double nVal = rDoc.GetValue(rCol, nRow, 0);
1145  sal_uInt16 nHour, nMinute, nSecond;
1146  double fFractionOfSecond;
1147  tools::Time::GetClock( nVal, nHour, nMinute, nSecond, fFractionOfSecond, 0);
1148  rDoc.SetValue(rCol, nRow, 0, nSecond);
1149  }
1150  }
1151  }
1152  break;
1153  default:
1154  break;
1155  }
1156  }
1157 }
1158 
1160 {
1162 }
1163 
1165 {
1166  return maType;
1167 }
1168 
1169 const std::set<SCCOL>& DateTimeTransformation::getColumn() const
1170 {
1171  return mnCol;
1172 }
1173 
1174 FindReplaceTransformation::FindReplaceTransformation(SCCOL nCol, const OUString& aFindString, const OUString& aReplaceString)
1175  : mnCol(nCol)
1176  , maFindString(aFindString)
1177  , maReplaceString(aReplaceString)
1178 {
1179 }
1180 
1182 {
1183  if (mnCol == -1)
1184  return;
1185 
1186  SCROW nEndRow = getLastRow(rDoc, mnCol);
1187  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
1188  {
1189  CellType eType;
1190  rDoc.GetCellType(mnCol, nRow, 0, eType);
1191  if (eType != CELLTYPE_NONE)
1192  {
1193  OUString aStr = rDoc.GetString(mnCol, nRow, 0);
1194  if (aStr == maFindString)
1195  rDoc.SetString(mnCol, nRow, 0, maReplaceString);
1196  }
1197  }
1198 }
1199 
1201 {
1203 }
1204 
1206 {
1207  return mnCol;
1208 }
1209 
1211 {
1212  return maFindString;
1213 }
1214 
1216 {
1217  return maReplaceString;
1218 }
1219 
1221  : mnCol(nCol)
1222  , maFindString(aFindString)
1223 {
1224 }
1225 
1227 {
1228  sal_Int32 nIncrementIndex = 0;
1229  if (mnCol == -1)
1230  return;
1231 
1232  SCROW nEndRow = getLastRow(rDoc, mnCol);
1233  for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
1234  {
1235  CellType eType;
1236  rDoc.GetCellType(mnCol, nRow - nIncrementIndex, 0, eType);
1237  if (eType != CELLTYPE_NONE)
1238  {
1239  OUString aStr = rDoc.GetString(mnCol, nRow - nIncrementIndex, 0);
1240  if (aStr == maFindString)
1241  {
1242  rDoc.DeleteRow(0, 0, rDoc.MaxCol(), 0, nRow - nIncrementIndex, 1);
1243  nIncrementIndex++;
1244  }
1245  }
1246  }
1247 }
1248 
1250 {
1252 }
1253 
1255 {
1256  return mnCol;
1257 }
1258 
1260 {
1261  return maFindString;
1262 }
1263 
1265  : mxRow(mRow)
1266  , nxRow(nRow)
1267 {
1268 }
1269 
1271 {
1272  if (mxRow == -1 || nxRow == -1)
1273  return;
1274 
1275  for (SCCOL nCol = 0; nCol <= rDoc.MaxCol(); ++nCol)
1276  {
1277  CellType aType;
1278  rDoc.GetCellType(nCol, mxRow, 0, aType);
1279  if (aType == CELLTYPE_STRING)
1280  {
1281  OUString aStr = rDoc.GetString(nCol, mxRow, 0);
1282  OUString bStr = rDoc.GetString(nCol, nxRow, 0);
1283  rDoc.SetString(nCol, mxRow, 0, bStr);
1284  rDoc.SetString(nCol, nxRow, 0, aStr);
1285  }
1286  else if (aType == CELLTYPE_VALUE)
1287  {
1288  double aVal = rDoc.GetValue(nCol, mxRow, 0);
1289  double bVal = rDoc.GetValue(nCol, nxRow, 0);
1290  rDoc.SetValue(nCol, mxRow, 0, bVal);
1291  rDoc.SetValue(nCol, nxRow, 0, aVal);
1292  }
1293  }
1294 }
1295 
1297 {
1299 }
1300 
1302 {
1303  return mxRow;
1304 }
1305 
1307 {
1308  return nxRow;
1309 }
1310 
1311 }
1312 
1313 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
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:1578
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:1359
const std::set< SCCOL > & getColumns() const
AGGREGATE_FUNCTION maType
sal_Int32 nIndex
DayOfWeek GetDayOfWeek() const
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:1491
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:3489
virtual TransformationType getTransformationType() const override
const ScSortParam & getSortParam() const
ReplaceNullTransformation(const std::set< SCCOL > &nCol, const OUString &sReplaceWith)
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:1434
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:872
MergeColumnTransformation(const std::set< SCCOL > &rColumns, const OUString &rMergeString)
sal_uInt16 GetMonth() const
SC_DLLPUBLIC OUString GetString(SCCOL nCol, SCROW nRow, SCTAB nTab, const ScInterpreterContext *pContext=nullptr) const
Definition: document.cxx:3517
virtual TransformationType getTransformationType() const override
virtual ~ColumnRemoveTransformation() override
SC_DLLPUBLIC double GetValue(const ScAddress &rPos) const
Definition: document.cxx:3659
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:3394
SC_DLLPUBLIC SCCOL MaxCol() const
Definition: document.hxx:871
SC_DLLPUBLIC SvNumberFormatter * GetFormatTable() const
Definition: documen2.cxx:441
sal_uInt16 GetDaysInMonth() const
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:1016
virtual void Transform(ScDocument &rDoc) const override
virtual TransformationType getTransformationType() const override
ColumnRemoveTransformation(const std::set< SCCOL > &rColumns)
virtual void Transform(ScDocument &rDoc) const override
sal_uInt16 GetDay() const
void AddDays(sal_Int32 nAddDays)
static SC_DLLPUBLIC LanguageType eLnge
Definition: global.hxx:553
virtual void Transform(ScDocument &rDoc) const override
DateTimeTransformation(const std::set< SCCOL > &nCol, const DATETIME_TRANSFORMATION_TYPE rType)
NUMBER_TRANSFORM_TYPE getNumberTransformationType() const
NumberTransformation(const std::set< SCCOL > &nCol, const NUMBER_TRANSFORM_TYPE rType)
void SetNumberFormat(const ScAddress &rPos, sal_uInt32 nNumberFormat)
Definition: document.cxx:3720
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)
CellType
Definition: global.hxx:281
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)
AggregateFunction(const std::set< SCCOL > &rColumns, const AGGREGATE_FUNCTION rType)
const OUString & getReplaceString() const
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:1077
DeleteRowTransformation(SCCOL nCol, const OUString &aFindString)
const OUString & getFindString() const
const std::set< SCCOL > & getColumns() const
SortTransformation(const ScSortParam &rParam)
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
TextTransformation(const std::set< SCCOL > &nCol, const TEXT_TRANSFORM_TYPE rType)
aStr
void SetMonth(sal_uInt16 nNewMonth)
SC_DLLPUBLIC void GetCellType(SCCOL nCol, SCROW nRow, SCTAB nTab, CellType &rCellType) const
Definition: document.cxx:3778