?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
bump product version to 4.1.6.2
[LibreOffice.git] / sc / source / ui / view / dbfunc3.cxx
blob96a08ce284f558bfeed92491592503c4af2a290a
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20 #include "dbfunc.hxx"
21 #include "scitems.hxx"
22 #include <sfx2/bindings.hxx>
23 #include <vcl/svapp.hxx>
24 #include <vcl/msgbox.hxx>
25 #include <vcl/waitobj.hxx>
26 #include <svl/zforlist.hxx>
27 #include <sfx2/app.hxx>
28 #include <com/sun/star/beans/XPropertySet.hpp>
29 #include <com/sun/star/container/XNameAccess.hpp>
30 #include <com/sun/star/sheet/DataPilotFieldFilter.hpp>
31 #include <com/sun/star/sheet/DataPilotFieldGroupBy.hpp>
32 #include <com/sun/star/sheet/DataPilotFieldOrientation.hpp>
33 #include <com/sun/star/sheet/DataPilotFieldSortMode.hpp>
34 #include <com/sun/star/sheet/DataPilotTableHeaderData.hpp>
35 #include <com/sun/star/sheet/GeneralFunction.hpp>
36 #include <com/sun/star/sheet/MemberResultFlags.hpp>
37 #include <com/sun/star/sheet/XDimensionsSupplier.hpp>
38 #include <com/sun/star/sheet/XDrillDownDataSupplier.hpp>
39
40 #include "global.hxx"
41 #include "globstr.hrc"
42 #include "sc.hrc"
43 #include "undotab.hxx"
44 #include "undodat.hxx"
45 #include "dbdata.hxx"
46 #include "rangenam.hxx"
47 #include "rangeutl.hxx"
48 #include "docsh.hxx"
49 #include "olinetab.hxx"
50 #include "consoli.hxx"
51 #include "olinefun.hxx"
52 #include "dpobject.hxx"
53 #include "dpsave.hxx"
54 #include "dpdimsave.hxx"
55 #include "dbdocfun.hxx"
56 #include "dpoutput.hxx"
57 #include "dptabsrc.hxx"
58 #include "dpshttab.hxx"
59 #include "dpsdbtab.hxx"
60 #include "editable.hxx"
61 #include "docpool.hxx"
62 #include "patattr.hxx"
63 #include "unonames.hxx"
64 #include "formulacell.hxx"
65 #include "userlist.hxx"
66 #include "queryentry.hxx"
67 #include "markdata.hxx"
68 #include "stringutil.hxx"
69
70 #include <boost/unordered_set.hpp>
71 #include <boost/unordered_map.hpp>
72 #include <memory>
73 #include <list>
74 #include <vector>
75
76 using namespace com::sun::star;
77 using ::com::sun::star::uno::Any;
78 using ::com::sun::star::uno::Sequence;
79 using ::com::sun::star::uno::Reference;
80 using ::com::sun::star::uno::UNO_QUERY;
81 using ::com::sun::star::beans::XPropertySet;
82 using ::com::sun::star::container::XNameAccess;
83 using ::com::sun::star::sheet::XDimensionsSupplier;
84 using ::std::auto_ptr;
85 using ::std::list;
86 using ::std::vector;
87
88 // STATIC DATA -----------------------------------------------------------
89
90
91 //==================================================================
92
93 //
94 // Outliner
95 //
96
97 // Outline-Gruppierung erzeugen
98
99 void ScDBFunc::MakeOutline( sal_Bool bColumns, sal_Bool bRecord )
100 {
101 ScRange aRange;
102 if (GetViewData()->GetSimpleArea(aRange) == SC_MARK_SIMPLE)
103 {
104 ScDocShell* pDocSh = GetViewData()->GetDocShell();
105 ScOutlineDocFunc aFunc(*pDocSh);
106 aFunc.MakeOutline( aRange, bColumns, bRecord, false );
107 }
108 else
109 ErrorMessage(STR_NOMULTISELECT);
110 }
111
112 // Outline-Gruppierung loeschen
113
114 void ScDBFunc::RemoveOutline( sal_Bool bColumns, sal_Bool bRecord )
115 {
116 ScRange aRange;
117 if (GetViewData()->GetSimpleArea(aRange) == SC_MARK_SIMPLE)
118 {
119 ScDocShell* pDocSh = GetViewData()->GetDocShell();
120 ScOutlineDocFunc aFunc(*pDocSh);
121 aFunc.RemoveOutline( aRange, bColumns, bRecord, false );
122 }
123 else
124 ErrorMessage(STR_NOMULTISELECT);
125 }
126
127 // Menue-Status: Outlines loeschen
128
129 void ScDBFunc::TestRemoveOutline( sal_Bool& rCol, sal_Bool& rRow )
130 {
131 sal_Bool bColFound = false;
132 sal_Bool bRowFound = false;
133
134 SCCOL nStartCol, nEndCol;
135 SCROW nStartRow, nEndRow;
136 SCTAB nStartTab, nEndTab;
137 if (GetViewData()->GetSimpleArea(nStartCol,nStartRow,nStartTab,nEndCol,nEndRow,nEndTab) == SC_MARK_SIMPLE)
138 {
139 SCTAB nTab = nStartTab;
140 ScDocument* pDoc = GetViewData()->GetDocument();
141 ScOutlineTable* pTable = pDoc->GetOutlineTable( nTab );
142 if (pTable)
143 {
144 ScOutlineArray* pArray;
145 ScOutlineEntry* pEntry;
146 SCCOLROW nStart;
147 SCCOLROW nEnd;
148 sal_Bool bColMarked = ( nStartRow == 0 && nEndRow == MAXROW );
149 sal_Bool bRowMarked = ( nStartCol == 0 && nEndCol == MAXCOL );
150
151 // Spalten
152
153 if ( !bRowMarked || bColMarked ) // nicht wenn ganze Zeilen markiert
154 {
155 pArray = pTable->GetColArray();
156 ScSubOutlineIterator aColIter( pArray );
157 while ((pEntry=aColIter.GetNext()) != NULL && !bColFound)
158 {
159 nStart = pEntry->GetStart();
160 nEnd = pEntry->GetEnd();
161 if ( nStartCol<=static_cast<SCCOL>(nEnd) && nEndCol>=static_cast<SCCOL>(nStart) )
162 bColFound = sal_True;
163 }
164 }
165
166 // Zeilen
167
168 if ( !bColMarked || bRowMarked ) // nicht wenn ganze Spalten markiert
169 {
170 pArray = pTable->GetRowArray();
171 ScSubOutlineIterator aRowIter( pArray );
172 while ((pEntry=aRowIter.GetNext()) != NULL && !bRowFound)
173 {
174 nStart = pEntry->GetStart();
175 nEnd = pEntry->GetEnd();
176 if ( nStartRow<=nEnd && nEndRow>=nStart )
177 bRowFound = sal_True;
178 }
179 }
180 }
181 }
182
183 rCol = bColFound;
184 rRow = bRowFound;
185 }
186
187 void ScDBFunc::RemoveAllOutlines( sal_Bool bRecord )
188 {
189 SCTAB nTab = GetViewData()->GetTabNo();
190 ScDocShell* pDocSh = GetViewData()->GetDocShell();
191 ScOutlineDocFunc aFunc(*pDocSh);
192
193 sal_Bool bOk = aFunc.RemoveAllOutlines( nTab, bRecord, false );
194
195 if (bOk)
196 UpdateScrollBars();
197 }
198
199 // Auto-Outlines
200
201 void ScDBFunc::AutoOutline( sal_Bool bRecord )
202 {
203 SCTAB nTab = GetViewData()->GetTabNo();
204 ScRange aRange( 0,0,nTab, MAXCOL,MAXROW,nTab ); // ganze Tabelle, wenn nichts markiert
205 ScMarkData& rMark = GetViewData()->GetMarkData();
206 if ( rMark.IsMarked() || rMark.IsMultiMarked() )
207 {
208 rMark.MarkToMulti();
209 rMark.GetMultiMarkArea( aRange );
210 }
211
212 ScDocShell* pDocSh = GetViewData()->GetDocShell();
213 ScOutlineDocFunc aFunc(*pDocSh);
214 aFunc.AutoOutline( aRange, bRecord, false );
215 }
216
217 // Outline-Ebene auswaehlen
218
219 void ScDBFunc::SelectLevel( sal_Bool bColumns, sal_uInt16 nLevel, sal_Bool bRecord, sal_Bool bPaint )
220 {
221 SCTAB nTab = GetViewData()->GetTabNo();
222 ScDocShell* pDocSh = GetViewData()->GetDocShell();
223 ScOutlineDocFunc aFunc(*pDocSh);
224
225 sal_Bool bOk = aFunc.SelectLevel( nTab, bColumns, nLevel, bRecord, bPaint, false );
226
227 if (bOk)
228 UpdateScrollBars();
229 }
230
231 // einzelne Outline-Gruppe einblenden
232
233 void ScDBFunc::ShowOutline( sal_Bool bColumns, sal_uInt16 nLevel, sal_uInt16 nEntry, sal_Bool bRecord, sal_Bool bPaint )
234 {
235 SCTAB nTab = GetViewData()->GetTabNo();
236 ScDocShell* pDocSh = GetViewData()->GetDocShell();
237 ScOutlineDocFunc aFunc(*pDocSh);
238
239 sal_Bool bOk = aFunc.ShowOutline( nTab, bColumns, nLevel, nEntry, bRecord, bPaint, false );
240
241 if ( bOk && bPaint )
242 UpdateScrollBars();
243 }
244
245 // einzelne Outline-Gruppe ausblenden
246
247 void ScDBFunc::HideOutline( sal_Bool bColumns, sal_uInt16 nLevel, sal_uInt16 nEntry, sal_Bool bRecord, sal_Bool bPaint )
248 {
249 SCTAB nTab = GetViewData()->GetTabNo();
250 ScDocShell* pDocSh = GetViewData()->GetDocShell();
251 ScOutlineDocFunc aFunc(*pDocSh);
252
253 sal_Bool bOk = aFunc.HideOutline( nTab, bColumns, nLevel, nEntry, bRecord, bPaint, false );
254
255 if ( bOk && bPaint )
256 UpdateScrollBars();
257 }
258
259 // Menue-Status: markierten Bereich ein-/ausblenden
260
261 sal_Bool ScDBFunc::OutlinePossible(sal_Bool bHide)
262 {
263 sal_Bool bEnable = false;
264
265 SCCOL nStartCol;
266 SCROW nStartRow;
267 SCTAB nStartTab;
268 SCCOL nEndCol;
269 SCROW nEndRow;
270 SCTAB nEndTab;
271
272 if (GetViewData()->GetSimpleArea(nStartCol,nStartRow,nStartTab,nEndCol,nEndRow,nEndTab) == SC_MARK_SIMPLE)
273 {
274 ScDocument* pDoc = GetViewData()->GetDocument();
275 SCTAB nTab = GetViewData()->GetTabNo();
276 ScOutlineTable* pTable = pDoc->GetOutlineTable( nTab );
277 if (pTable)
278 {
279 ScOutlineArray* pArray;
280 ScOutlineEntry* pEntry;
281 SCCOLROW nStart;
282 SCCOLROW nEnd;
283
284 // Spalten
285
286 pArray = pTable->GetColArray();
287 ScSubOutlineIterator aColIter( pArray );
288 while ((pEntry=aColIter.GetNext()) != NULL && !bEnable)
289 {
290 nStart = pEntry->GetStart();
291 nEnd = pEntry->GetEnd();
292 if ( bHide )
293 {
294 if ( nStartCol<=static_cast<SCCOL>(nEnd) && nEndCol>=static_cast<SCCOL>(nStart) )
295 if (!pEntry->IsHidden())
296 bEnable = sal_True;
297 }
298 else
299 {
300 if ( nStart>=nStartCol && nEnd<=nEndCol )
301 if (pEntry->IsHidden())
302 bEnable = sal_True;
303 }
304 }
305
306 // Zeilen
307
308 pArray = pTable->GetRowArray();
309 ScSubOutlineIterator aRowIter( pArray );
310 while ((pEntry=aRowIter.GetNext()) != NULL)
311 {
312 nStart = pEntry->GetStart();
313 nEnd = pEntry->GetEnd();
314 if ( bHide )
315 {
316 if ( nStartRow<=nEnd && nEndRow>=nStart )
317 if (!pEntry->IsHidden())
318 bEnable = sal_True;
319 }
320 else
321 {
322 if ( nStart>=nStartRow && nEnd<=nEndRow )
323 if (pEntry->IsHidden())
324 bEnable = sal_True;
325 }
326 }
327 }
328 }
329
330 return bEnable;
331 }
332
333 // markierten Bereich einblenden
334
335 void ScDBFunc::ShowMarkedOutlines( sal_Bool bRecord )
336 {
337 ScRange aRange;
338 if (GetViewData()->GetSimpleArea(aRange) == SC_MARK_SIMPLE)
339 {
340 ScDocShell* pDocSh = GetViewData()->GetDocShell();
341 ScOutlineDocFunc aFunc(*pDocSh);
342 sal_Bool bDone = aFunc.ShowMarkedOutlines( aRange, bRecord );
343 if (bDone)
344 UpdateScrollBars();
345 }
346 else
347 ErrorMessage(STR_NOMULTISELECT);
348 }
349
350 // markierten Bereich ausblenden
351
352 void ScDBFunc::HideMarkedOutlines( sal_Bool bRecord )
353 {
354 ScRange aRange;
355 if (GetViewData()->GetSimpleArea(aRange) == SC_MARK_SIMPLE)
356 {
357 ScDocShell* pDocSh = GetViewData()->GetDocShell();
358 ScOutlineDocFunc aFunc(*pDocSh);
359 sal_Bool bDone = aFunc.HideMarkedOutlines( aRange, bRecord, false );
360 if (bDone)
361 UpdateScrollBars();
362 }
363 else
364 ErrorMessage(STR_NOMULTISELECT);
365 }
366
367 // --------------------------------------------------------------------------
368
369 //
370 // Teilergebnisse
371 //
372
373 void ScDBFunc::DoSubTotals( const ScSubTotalParam& rParam, sal_Bool bRecord,
374 const ScSortParam* pForceNewSort )
375 {
376 sal_Bool bDo = !rParam.bRemoveOnly; // sal_False = nur loeschen
377
378 ScDocShell* pDocSh = GetViewData()->GetDocShell();
379 ScDocument* pDoc = pDocSh->GetDocument();
380 ScMarkData& rMark = GetViewData()->GetMarkData();
381 SCTAB nTab = GetViewData()->GetTabNo();
382 if (bRecord && !pDoc->IsUndoEnabled())
383 bRecord = false;
384
385 ScDBData* pDBData = pDoc->GetDBAtArea( nTab, rParam.nCol1, rParam.nRow1,
386 rParam.nCol2, rParam.nRow2 );
387 if (!pDBData)
388 {
389 OSL_FAIL( "SubTotals: keine DBData" );
390 return;
391 }
392
393 ScEditableTester aTester( pDoc, nTab, 0,rParam.nRow1+1, MAXCOL,MAXROW );
394 if (!aTester.IsEditable())
395 {
396 ErrorMessage(aTester.GetMessageId());
397 return;
398 }
399
400 if (pDoc->HasAttrib( rParam.nCol1, rParam.nRow1+1, nTab,
401 rParam.nCol2, rParam.nRow2, nTab, HASATTR_MERGED | HASATTR_OVERLAPPED ))
402 {
403 ErrorMessage(STR_MSSG_INSERTCELLS_0); // nicht in zusammengefasste einfuegen
404 return;
405 }
406
407 WaitObject aWait( GetViewData()->GetDialogParent() );
408 sal_Bool bOk = true;
409 if (rParam.bReplace)
410 if (pDoc->TestRemoveSubTotals( nTab, rParam ))
411 {
412 bOk = ( MessBox( GetViewData()->GetDialogParent(), WinBits(WB_YES_NO | WB_DEF_YES),
413 // "StarCalc" "Daten loeschen?"
414 ScGlobal::GetRscString( STR_MSSG_DOSUBTOTALS_0 ),
415 ScGlobal::GetRscString( STR_MSSG_DOSUBTOTALS_1 ) ).Execute()
416 == RET_YES );
417 }
418
419 if (bOk)
420 {
421 ScDocShellModificator aModificator( *pDocSh );
422
423 ScSubTotalParam aNewParam( rParam ); // Bereichsende wird veraendert
424 ScDocument* pUndoDoc = NULL;
425 ScOutlineTable* pUndoTab = NULL;
426 ScRangeName* pUndoRange = NULL;
427 ScDBCollection* pUndoDB = NULL;
428
429 if (bRecord) // alte Daten sichern
430 {
431 sal_Bool bOldFilter = bDo && rParam.bDoSort;
432 SCTAB nTabCount = pDoc->GetTableCount();
433 pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
434 ScOutlineTable* pTable = pDoc->GetOutlineTable( nTab );
435 if (pTable)
436 {
437 pUndoTab = new ScOutlineTable( *pTable );
438
439 SCCOLROW nOutStartCol; // Zeilen/Spaltenstatus
440 SCCOLROW nOutStartRow;
441 SCCOLROW nOutEndCol;
442 SCCOLROW nOutEndRow;
443 pTable->GetColArray()->GetRange( nOutStartCol, nOutEndCol );
444 pTable->GetRowArray()->GetRange( nOutStartRow, nOutEndRow );
445
446 pUndoDoc->InitUndo( pDoc, nTab, nTab, sal_True, sal_True );
447 pDoc->CopyToDocument( static_cast<SCCOL>(nOutStartCol), 0, nTab, static_cast<SCCOL>(nOutEndCol), MAXROW, nTab, IDF_NONE, false, pUndoDoc );
448 pDoc->CopyToDocument( 0, nOutStartRow, nTab, MAXCOL, nOutEndRow, nTab, IDF_NONE, false, pUndoDoc );
449 }
450 else
451 pUndoDoc->InitUndo( pDoc, nTab, nTab, false, bOldFilter );
452
453 // Datenbereich sichern - incl. Filter-Ergebnis
454 pDoc->CopyToDocument( 0,rParam.nRow1+1,nTab, MAXCOL,rParam.nRow2,nTab,
455 IDF_ALL, false, pUndoDoc );
456
457 // alle Formeln wegen Referenzen
458 pDoc->CopyToDocument( 0,0,0, MAXCOL,MAXROW,nTabCount-1,
459 IDF_FORMULA, false, pUndoDoc );
460
461 // DB- und andere Bereiche
462 ScRangeName* pDocRange = pDoc->GetRangeName();
463 if (!pDocRange->empty())
464 pUndoRange = new ScRangeName( *pDocRange );
465 ScDBCollection* pDocDB = pDoc->GetDBCollection();
466 if (!pDocDB->empty())
467 pUndoDB = new ScDBCollection( *pDocDB );
468 }
469
470 ScOutlineTable* pOut = pDoc->GetOutlineTable( nTab );
471 if (pOut)
472 {
473 // Remove all existing outlines in the specified range.
474 ScOutlineArray* pRowArray = pOut->GetRowArray();
475 sal_uInt16 nDepth = pRowArray->GetDepth();
476 for (sal_uInt16 i = 0; i < nDepth; ++i)
477 {
478 bool bSize;
479 pRowArray->Remove(aNewParam.nRow1, aNewParam.nRow2, bSize);
480 }
481 }
482
483 if (rParam.bReplace)
484 pDoc->RemoveSubTotals( nTab, aNewParam );
485 sal_Bool bSuccess = sal_True;
486 if (bDo)
487 {
488 // Sortieren
489 if ( rParam.bDoSort || pForceNewSort )
490 {
491 pDBData->SetArea( nTab, aNewParam.nCol1,aNewParam.nRow1, aNewParam.nCol2,aNewParam.nRow2 );
492
493 // Teilergebnis-Felder vor die Sortierung setzen
494 // (doppelte werden weggelassen, kann darum auch wieder aufgerufen werden)
495
496 ScSortParam aOldSort;
497 pDBData->GetSortParam( aOldSort );
498 ScSortParam aSortParam( aNewParam, pForceNewSort ? *pForceNewSort : aOldSort );
499 Sort( aSortParam, false, false );
500 }
501
502 bSuccess = pDoc->DoSubTotals( nTab, aNewParam );
503 }
504 ScRange aDirtyRange( aNewParam.nCol1, aNewParam.nRow1, nTab,
505 aNewParam.nCol2, aNewParam.nRow2, nTab );
506 pDoc->SetDirty( aDirtyRange );
507
508 if (bRecord)
509 {
510 pDocSh->GetUndoManager()->AddUndoAction(
511 new ScUndoSubTotals( pDocSh, nTab,
512 rParam, aNewParam.nRow2,
513 pUndoDoc, pUndoTab, // pUndoDBData,
514 pUndoRange, pUndoDB ) );
515 }
516
517 if (!bSuccess)
518 {
519 // "Kann keine Zeilen einfuegen"
520 ErrorMessage(STR_MSSG_DOSUBTOTALS_2);
521 }
522
523 // merken
524 pDBData->SetSubTotalParam( aNewParam );
525 pDBData->SetArea( nTab, aNewParam.nCol1,aNewParam.nRow1, aNewParam.nCol2,aNewParam.nRow2 );
526 pDoc->CompileDBFormula();
527
528 DoneBlockMode();
529 InitOwnBlockMode();
530 rMark.SetMarkArea( ScRange( aNewParam.nCol1,aNewParam.nRow1,nTab,
531 aNewParam.nCol2,aNewParam.nRow2,nTab ) );
532 MarkDataChanged();
533
534 pDocSh->PostPaint(ScRange(0, 0, nTab, MAXCOL, MAXROW, nTab),
535 PAINT_GRID | PAINT_LEFT | PAINT_TOP | PAINT_SIZE);
536
537 aModificator.SetDocumentModified();
538
539 SelectionChanged();
540 }
541 }
542
543 //
544 // Consolidate
545 //
546
547 void ScDBFunc::Consolidate( const ScConsolidateParam& rParam, sal_Bool bRecord )
548 {
549 ScDocShell* pDocShell = GetViewData()->GetDocShell();
550 pDocShell->DoConsolidate( rParam, bRecord );
551 SetTabNo( rParam.nTab, sal_True );
552 }
553
554 //
555 // Pivot
556 //
557
558 static OUString lcl_MakePivotTabName( const String& rPrefix, SCTAB nNumber )
559 {
560 OUString aName = rPrefix + OUString::number( nNumber );
561 return aName;
562 }
563
564 bool ScDBFunc::MakePivotTable(
565 const ScDPSaveData& rData, const ScRange& rDest, bool bNewTable,
566 const ScDPObject& rSource, bool bApi )
567 {
568 // error message if no fields are set
569 // this must be removed when drag&drop of fields from a toolbox is available
570
571 if ( rData.IsEmpty() && !bApi )
572 {
573 ErrorMessage(STR_PIVOT_NODATA);
574 return false;
575 }
576
577 ScDocShell* pDocSh = GetViewData()->GetDocShell();
578 ScDocument* pDoc = GetViewData()->GetDocument();
579 bool bUndo = pDoc->IsUndoEnabled();
580
581 ScRange aDestRange = rDest;
582 if ( bNewTable )
583 {
584 SCTAB nSrcTab = GetViewData()->GetTabNo();
585
586 String aName( ScGlobal::GetRscString(STR_PIVOT_TABLE) );
587 OUString aStr;
588
589 pDoc->GetName( nSrcTab, aStr );
590 aName += '_';
591 aName += String(aStr);
592 aName += '_';
593
594 SCTAB nNewTab = nSrcTab+1;
595
596 SCTAB i=1;
597 while ( !pDoc->InsertTab( nNewTab, lcl_MakePivotTabName( aName, i ) ) && i <= MAXTAB )
598 i++;
599
600 bool bAppend = ( nNewTab+1 == pDoc->GetTableCount() );
601 if (bUndo)
602 {
603 pDocSh->GetUndoManager()->AddUndoAction(
604 new ScUndoInsertTab( pDocSh, nNewTab, bAppend, lcl_MakePivotTabName( aName, i ) ));
605 }
606
607 GetViewData()->InsertTab( nNewTab );
608 SetTabNo(nNewTab, true);
609
610 aDestRange = ScRange( 0, 0, nNewTab );
611 }
612
613 ScDPObject* pDPObj = pDoc->GetDPAtCursor(
614 aDestRange.aStart.Col(), aDestRange.aStart.Row(), aDestRange.aStart.Tab() );
615
616 ScDPObject aObj( rSource );
617 aObj.SetOutRange( aDestRange );
618 if ( pDPObj && !rData.GetExistingDimensionData() )
619 {
620 // copy dimension data from old object - lost in the dialog
621 //! change the dialog to keep the dimension data
622
623 ScDPSaveData aNewData( rData );
624 const ScDPSaveData* pOldData = pDPObj->GetSaveData();
625 if ( pOldData )
626 {
627 const ScDPDimensionSaveData* pDimSave = pOldData->GetExistingDimensionData();
628 aNewData.SetDimensionData( pDimSave );
629 }
630 aObj.SetSaveData( aNewData );
631 }
632 else
633 aObj.SetSaveData( rData );
634
635 bool bAllowMove = (pDPObj != NULL); // allow re-positioning when editing existing table
636
637 ScDBDocFunc aFunc( *pDocSh );
638 bool bSuccess = aFunc.DataPilotUpdate(pDPObj, &aObj, true, false, bAllowMove);
639
640 CursorPosChanged(); // shells may be switched
641
642 if ( bNewTable )
643 {
644 pDocSh->PostPaintExtras();
645 SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );
646 }
647
648 return bSuccess;
649 }
650
651 void ScDBFunc::DeletePivotTable()
652 {
653 ScDocShell* pDocSh = GetViewData()->GetDocShell();
654 ScDocument* pDoc = pDocSh->GetDocument();
655 ScDPObject* pDPObj = pDoc->GetDPAtCursor( GetViewData()->GetCurX(),
656 GetViewData()->GetCurY(),
657 GetViewData()->GetTabNo() );
658 if ( pDPObj )
659 {
660 ScDBDocFunc aFunc( *pDocSh );
661 aFunc.RemovePivotTable(*pDPObj, true, false);
662 CursorPosChanged(); // shells may be switched
663 }
664 else
665 ErrorMessage(STR_PIVOT_NOTFOUND);
666 }
667
668 void ScDBFunc::RecalcPivotTable()
669 {
670 ScDocShell* pDocSh = GetViewData()->GetDocShell();
671 ScDocument* pDoc = GetViewData()->GetDocument();
672
673 ScDPObject* pDPObj = pDoc->GetDPAtCursor( GetViewData()->GetCurX(),
674 GetViewData()->GetCurY(),
675 GetViewData()->GetTabNo() );
676 if (pDPObj)
677 {
678 // Remove existing data cache for the data that this datapilot uses,
679 // to force re-build data cache.
680 ScDBDocFunc aFunc(*pDocSh);
681 aFunc.RefreshPivotTables(pDPObj, false);
682
683 CursorPosChanged(); // shells may be switched
684 }
685 else
686 ErrorMessage(STR_PIVOT_NOTFOUND);
687 }
688
689 void ScDBFunc::GetSelectedMemberList(ScDPUniqueStringSet& rEntries, long& rDimension)
690 {
691 ScDPObject* pDPObj = GetViewData()->GetDocument()->GetDPAtCursor( GetViewData()->GetCurX(),
692 GetViewData()->GetCurY(), GetViewData()->GetTabNo() );
693 if ( !pDPObj )
694 return;
695
696 long nStartDimension = -1;
697 long nStartHierarchy = -1;
698 long nStartLevel = -1;
699
700 ScRangeListRef xRanges;
701 GetViewData()->GetMultiArea( xRanges ); // incl. cursor if nothing is selected
702 size_t nRangeCount = xRanges->size();
703 sal_Bool bContinue = true;
704
705 for (size_t nRangePos=0; nRangePos < nRangeCount && bContinue; nRangePos++)
706 {
707 ScRange aRange = *(*xRanges)[nRangePos];
708 SCCOL nStartCol = aRange.aStart.Col();
709 SCROW nStartRow = aRange.aStart.Row();
710 SCCOL nEndCol = aRange.aEnd.Col();
711 SCROW nEndRow = aRange.aEnd.Row();
712 SCTAB nTab = aRange.aStart.Tab();
713
714 for (SCROW nRow=nStartRow; nRow<=nEndRow && bContinue; nRow++)
715 for (SCCOL nCol=nStartCol; nCol<=nEndCol && bContinue; nCol++)
716 {
717 sheet::DataPilotTableHeaderData aData;
718 pDPObj->GetHeaderPositionData(ScAddress(nCol, nRow, nTab), aData);
719 if ( aData.Dimension < 0 )
720 bContinue = false; // not part of any dimension
721 else
722 {
723 if ( nStartDimension < 0 ) // first member?
724 {
725 nStartDimension = aData.Dimension;
726 nStartHierarchy = aData.Hierarchy;
727 nStartLevel = aData.Level;
728 }
729 if ( aData.Dimension != nStartDimension ||
730 aData.Hierarchy != nStartHierarchy ||
731 aData.Level != nStartLevel )
732 {
733 bContinue = false; // cannot mix dimensions
734 }
735 }
736 if ( bContinue )
737 {
738 // accept any part of a member description, also subtotals,
739 // but don't stop if empty parts are contained
740 if ( aData.Flags & sheet::MemberResultFlags::HASMEMBER )
741 rEntries.insert(aData.MemberName);
742 }
743 }
744 }
745
746 rDimension = nStartDimension; // dimension from which the found members came
747 if (!bContinue)
748 rEntries.clear(); // remove all if not valid
749 }
750
751 bool ScDBFunc::HasSelectionForDateGroup( ScDPNumGroupInfo& rOldInfo, sal_Int32& rParts )
752 {
753 // determine if the date group dialog has to be shown for the current selection
754
755 bool bFound = false;
756
757 SCCOL nCurX = GetViewData()->GetCurX();
758 SCROW nCurY = GetViewData()->GetCurY();
759 SCTAB nTab = GetViewData()->GetTabNo();
760 ScDocument* pDoc = GetViewData()->GetDocument();
761
762 ScDPObject* pDPObj = pDoc->GetDPAtCursor( nCurX, nCurY, nTab );
763 if ( pDPObj )
764 {
765 ScDPUniqueStringSet aEntries;
766 long nSelectDimension = -1;
767 GetSelectedMemberList( aEntries, nSelectDimension );
768
769 if (!aEntries.empty())
770 {
771 bool bIsDataLayout;
772 OUString aDimName = pDPObj->GetDimName( nSelectDimension, bIsDataLayout );
773 String aBaseDimName( aDimName );
774
775 sal_Bool bInGroupDim = false;
776 sal_Bool bFoundParts = false;
777
778 ScDPDimensionSaveData* pDimData =
779 const_cast<ScDPDimensionSaveData*>( pDPObj->GetSaveData()->GetExistingDimensionData() );
780 if ( pDimData )
781 {
782 const ScDPSaveNumGroupDimension* pNumGroupDim = pDimData->GetNumGroupDim( aDimName );
783 const ScDPSaveGroupDimension* pGroupDim = pDimData->GetNamedGroupDim( aDimName );
784 if ( pNumGroupDim )
785 {
786 // existing num group dimension
787
788 if ( pNumGroupDim->GetDatePart() != 0 )
789 {
790 // dimension has date info -> edit settings of this dimension
791 // (parts are collected below)
792
793 rOldInfo = pNumGroupDim->GetDateInfo();
794 bFound = sal_True;
795 }
796 else if ( pNumGroupDim->GetInfo().mbDateValues )
797 {
798 // Numerical grouping with DateValues flag is used for grouping
799 // of days with a "Number of days" value.
800
801 rOldInfo = pNumGroupDim->GetInfo();
802 rParts = com::sun::star::sheet::DataPilotFieldGroupBy::DAYS; // not found in CollectDateParts
803 bFoundParts = sal_True;
804 bFound = sal_True;
805 }
806 bInGroupDim = sal_True;
807 }
808 else if ( pGroupDim )
809 {
810 // existing additional group dimension
811
812 if ( pGroupDim->GetDatePart() != 0 )
813 {
814 // dimension has date info -> edit settings of this dimension
815 // (parts are collected below)
816
817 rOldInfo = pGroupDim->GetDateInfo();
818 aBaseDimName = pGroupDim->GetSourceDimName();
819 bFound = sal_True;
820 }
821 bInGroupDim = sal_True;
822 }
823 }
824 if ( bFound && !bFoundParts )
825 {
826 // collect date parts from all group dimensions
827 rParts = pDimData->CollectDateParts( aBaseDimName );
828 }
829 if ( !bFound && !bInGroupDim )
830 {
831 // create new date group dimensions if the selection is a single cell
832 // in a normal dimension with date content
833
834 ScRange aSelRange;
835 if ( (GetViewData()->GetSimpleArea( aSelRange ) == SC_MARK_SIMPLE) &&
836 aSelRange.aStart == aSelRange.aEnd )
837 {
838 SCCOL nSelCol = aSelRange.aStart.Col();
839 SCROW nSelRow = aSelRange.aStart.Row();
840 SCTAB nSelTab = aSelRange.aStart.Tab();
841 if ( pDoc->HasValueData( nSelCol, nSelRow, nSelTab ) )
842 {
843 sal_uLong nIndex = static_cast<const SfxUInt32Item*>(pDoc->GetAttr(
844 nSelCol, nSelRow, nSelTab, ATTR_VALUE_FORMAT))->GetValue();
845 short nType = pDoc->GetFormatTable()->GetType(nIndex);
846 if ( nType == NUMBERFORMAT_DATE || nType == NUMBERFORMAT_TIME || nType == NUMBERFORMAT_DATETIME )
847 {
848 bFound = sal_True;
849 // use currently selected value for automatic limits
850 if( rOldInfo.mbAutoStart )
851 rOldInfo.mfStart = pDoc->GetValue( aSelRange.aStart );
852 if( rOldInfo.mbAutoEnd )
853 rOldInfo.mfEnd = pDoc->GetValue( aSelRange.aStart );
854 }
855 }
856 }
857 }
858 }
859 }
860
861 return bFound;
862 }
863
864 bool ScDBFunc::HasSelectionForNumGroup( ScDPNumGroupInfo& rOldInfo )
865 {
866 // determine if the numeric group dialog has to be shown for the current selection
867
868 bool bFound = false;
869
870 SCCOL nCurX = GetViewData()->GetCurX();
871 SCROW nCurY = GetViewData()->GetCurY();
872 SCTAB nTab = GetViewData()->GetTabNo();
873 ScDocument* pDoc = GetViewData()->GetDocument();
874
875 ScDPObject* pDPObj = pDoc->GetDPAtCursor( nCurX, nCurY, nTab );
876 if ( pDPObj )
877 {
878 ScDPUniqueStringSet aEntries;
879 long nSelectDimension = -1;
880 GetSelectedMemberList( aEntries, nSelectDimension );
881
882 if (!aEntries.empty())
883 {
884 bool bIsDataLayout;
885 OUString aDimName = pDPObj->GetDimName( nSelectDimension, bIsDataLayout );
886
887 sal_Bool bInGroupDim = false;
888
889 ScDPDimensionSaveData* pDimData =
890 const_cast<ScDPDimensionSaveData*>( pDPObj->GetSaveData()->GetExistingDimensionData() );
891 if ( pDimData )
892 {
893 const ScDPSaveNumGroupDimension* pNumGroupDim = pDimData->GetNumGroupDim( aDimName );
894 if ( pNumGroupDim )
895 {
896 // existing num group dimension
897 // -> edit settings of this dimension
898
899 rOldInfo = pNumGroupDim->GetInfo();
900 bFound = sal_True;
901 }
902 else if ( pDimData->GetNamedGroupDim( aDimName ) )
903 bInGroupDim = sal_True; // in a group dimension
904 }
905 if ( !bFound && !bInGroupDim )
906 {
907 // create a new num group dimension if the selection is a single cell
908 // in a normal dimension with numeric content
909
910 ScRange aSelRange;
911 if ( (GetViewData()->GetSimpleArea( aSelRange ) == SC_MARK_SIMPLE) &&
912 aSelRange.aStart == aSelRange.aEnd )
913 {
914 if ( pDoc->HasValueData( aSelRange.aStart.Col(), aSelRange.aStart.Row(),
915 aSelRange.aStart.Tab() ) )
916 {
917 bFound = sal_True;
918 // use currently selected value for automatic limits
919 if( rOldInfo.mbAutoStart )
920 rOldInfo.mfStart = pDoc->GetValue( aSelRange.aStart );
921 if( rOldInfo.mbAutoEnd )
922 rOldInfo.mfEnd = pDoc->GetValue( aSelRange.aStart );
923 }
924 }
925 }
926 }
927 }
928
929 return bFound;
930 }
931
932 void ScDBFunc::DateGroupDataPilot( const ScDPNumGroupInfo& rInfo, sal_Int32 nParts )
933 {
934 ScDPObject* pDPObj = GetViewData()->GetDocument()->GetDPAtCursor( GetViewData()->GetCurX(),
935 GetViewData()->GetCurY(), GetViewData()->GetTabNo() );
936 if (!pDPObj)
937 return;
938
939 ScDPUniqueStringSet aEntries;
940 long nSelectDimension = -1;
941 GetSelectedMemberList( aEntries, nSelectDimension );
942
943 if (aEntries.empty())
944 return;
945
946 std::vector<OUString> aDeletedNames;
947 bool bIsDataLayout;
948 OUString aDimName = pDPObj->GetDimName( nSelectDimension, bIsDataLayout );
949
950 ScDPSaveData aData( *pDPObj->GetSaveData() );
951 ScDPDimensionSaveData* pDimData = aData.GetDimensionData(); // created if not there
952
953 // find the source dimension name.
954 OUString aBaseDimName = aDimName;
955 if( const ScDPSaveGroupDimension* pBaseGroupDim = pDimData->GetNamedGroupDim( aDimName ) )
956 aBaseDimName = pBaseGroupDim->GetSourceDimName();
957
958 // Remove all group dimensions associated with this source dimension. For
959 // date grouping, we need to remove all existing groups for the affected
960 // source dimension and build new one(s) from scratch. Keep the deleted
961 // names so that they can be reused during re-construction.
962 aData.RemoveAllGroupDimensions(aBaseDimName, &aDeletedNames);
963
964 if ( nParts )
965 {
966 // create date group dimensions
967
968 ScDPNumGroupInfo aEmpty;
969 bool bFirst = true;
970 sal_Int32 nMask = 1;
971 for (sal_uInt16 nBit=0; nBit<32; nBit++)
972 {
973 if ( nParts & nMask )
974 {
975 if ( bFirst )
976 {
977 // innermost part: create NumGroupDimension (replacing original values)
978 // Dimension name is left unchanged
979
980 if ( (nParts == sheet::DataPilotFieldGroupBy::DAYS) && (rInfo.mfStep >= 1.0) )
981 {
982 // only days, and a step value specified: use numerical grouping
983 // with DateValues flag, not date grouping
984
985 ScDPNumGroupInfo aNumInfo( rInfo );
986 aNumInfo.mbDateValues = true;
987
988 ScDPSaveNumGroupDimension aNumGroupDim( aBaseDimName, aNumInfo );
989 pDimData->AddNumGroupDimension( aNumGroupDim );
990 }
991 else
992 {
993 ScDPSaveNumGroupDimension aNumGroupDim( aBaseDimName, rInfo, nMask );
994 pDimData->AddNumGroupDimension( aNumGroupDim );
995 }
996
997 bFirst = false;
998 }
999 else
1000 {
1001 // additional parts: create GroupDimension (shown as additional dimensions)
1002 OUString aGroupDimName =
1003 pDimData->CreateDateGroupDimName(nMask, *pDPObj, true, &aDeletedNames);
1004 ScDPSaveGroupDimension aGroupDim( aBaseDimName, aGroupDimName );
1005 aGroupDim.SetDateInfo( rInfo, nMask );
1006 pDimData->AddGroupDimension( aGroupDim );
1007
1008 // set orientation
1009 ScDPSaveDimension* pSaveDimension = aData.GetDimensionByName( aGroupDimName );
1010 if ( pSaveDimension->GetOrientation() == sheet::DataPilotFieldOrientation_HIDDEN )
1011 {
1012 ScDPSaveDimension* pOldDimension = aData.GetDimensionByName( aBaseDimName );
1013 pSaveDimension->SetOrientation( pOldDimension->GetOrientation() );
1014 long nPosition = 0; //! before (immediate) base
1015 aData.SetPosition( pSaveDimension, nPosition );
1016 }
1017 }
1018 }
1019 nMask *= 2;
1020 }
1021 }
1022
1023 // apply changes
1024 ScDBDocFunc aFunc( *GetViewData()->GetDocShell() );
1025 pDPObj->SetSaveData( aData );
1026 aFunc.RefreshPivotTableGroups(pDPObj);
1027
1028 // unmark cell selection
1029 Unmark();
1030 }
1031
1032 void ScDBFunc::NumGroupDataPilot( const ScDPNumGroupInfo& rInfo )
1033 {
1034 ScDPObject* pDPObj = GetViewData()->GetDocument()->GetDPAtCursor( GetViewData()->GetCurX(),
1035 GetViewData()->GetCurY(), GetViewData()->GetTabNo() );
1036 if (!pDPObj)
1037 return;
1038
1039 ScDPUniqueStringSet aEntries;
1040 long nSelectDimension = -1;
1041 GetSelectedMemberList( aEntries, nSelectDimension );
1042
1043 if (aEntries.empty())
1044 return;
1045
1046 bool bIsDataLayout;
1047 OUString aDimName = pDPObj->GetDimName( nSelectDimension, bIsDataLayout );
1048
1049 ScDPSaveData aData( *pDPObj->GetSaveData() );
1050 ScDPDimensionSaveData* pDimData = aData.GetDimensionData(); // created if not there
1051
1052 ScDPSaveNumGroupDimension* pExisting = pDimData->GetNumGroupDimAcc( aDimName );
1053 if ( pExisting )
1054 {
1055 // modify existing group dimension
1056 pExisting->SetGroupInfo( rInfo );
1057 }
1058 else
1059 {
1060 // create new group dimension
1061 ScDPSaveNumGroupDimension aNumGroupDim( aDimName, rInfo );
1062 pDimData->AddNumGroupDimension( aNumGroupDim );
1063 }
1064
1065 // apply changes
1066 ScDBDocFunc aFunc( *GetViewData()->GetDocShell() );
1067 pDPObj->SetSaveData( aData );
1068 aFunc.RefreshPivotTableGroups(pDPObj);
1069
1070 // unmark cell selection
1071 Unmark();
1072 }
1073
1074 void ScDBFunc::GroupDataPilot()
1075 {
1076 ScDPObject* pDPObj = GetViewData()->GetDocument()->GetDPAtCursor( GetViewData()->GetCurX(),
1077 GetViewData()->GetCurY(), GetViewData()->GetTabNo() );
1078 if (!pDPObj)
1079 return;
1080
1081 ScDPUniqueStringSet aEntries;
1082 long nSelectDimension = -1;
1083 GetSelectedMemberList( aEntries, nSelectDimension );
1084
1085 if (aEntries.empty())
1086 return;
1087
1088 bool bIsDataLayout;
1089 OUString aDimName = pDPObj->GetDimName( nSelectDimension, bIsDataLayout );
1090
1091 ScDPSaveData aData( *pDPObj->GetSaveData() );
1092 ScDPDimensionSaveData* pDimData = aData.GetDimensionData(); // created if not there
1093
1094 // find original base
1095 OUString aBaseDimName = aDimName;
1096 const ScDPSaveGroupDimension* pBaseGroupDim = pDimData->GetNamedGroupDim( aDimName );
1097 if ( pBaseGroupDim )
1098 {
1099 // any entry's SourceDimName is the original base
1100 aBaseDimName = pBaseGroupDim->GetSourceDimName();
1101 }
1102
1103 // find existing group dimension
1104 // (using the selected dim, can be intermediate group dim)
1105 ScDPSaveGroupDimension* pGroupDimension = pDimData->GetGroupDimAccForBase( aDimName );
1106
1107 // remove the selected items from their groups
1108 // (empty groups are removed, too)
1109 if ( pGroupDimension )
1110 {
1111 ScDPUniqueStringSet::const_iterator it = aEntries.begin(), itEnd = aEntries.end();
1112 for (; it != itEnd; ++it)
1113 {
1114 const OUString& aEntryName = *it;
1115 if ( pBaseGroupDim )
1116 {
1117 // for each selected (intermediate) group, remove all its items
1118 // (same logic as for adding, below)
1119 const ScDPSaveGroupItem* pBaseGroup = pBaseGroupDim->GetNamedGroup( aEntryName );
1120 if ( pBaseGroup )
1121 pBaseGroup->RemoveElementsFromGroups( *pGroupDimension ); // remove all elements
1122 else
1123 pGroupDimension->RemoveFromGroups( aEntryName );
1124 }
1125 else
1126 pGroupDimension->RemoveFromGroups( aEntryName );
1127 }
1128 }
1129
1130 ScDPSaveGroupDimension* pNewGroupDim = NULL;
1131 if ( !pGroupDimension )
1132 {
1133 // create a new group dimension
1134 OUString aGroupDimName =
1135 pDimData->CreateGroupDimName(aBaseDimName, *pDPObj, false, NULL);
1136 pNewGroupDim = new ScDPSaveGroupDimension( aBaseDimName, aGroupDimName );
1137
1138 pGroupDimension = pNewGroupDim; // make changes to the new dim if none existed
1139
1140 if ( pBaseGroupDim )
1141 {
1142 // If it's a higher-order group dimension, pre-allocate groups for all
1143 // non-selected original groups, so the individual base members aren't
1144 // used for automatic groups (this would make the original groups hard
1145 // to find).
1146 //! Also do this when removing groups?
1147 //! Handle this case dynamically with automatic groups?
1148
1149 long nGroupCount = pBaseGroupDim->GetGroupCount();
1150 for ( long nGroup = 0; nGroup < nGroupCount; nGroup++ )
1151 {
1152 const ScDPSaveGroupItem* pBaseGroup = pBaseGroupDim->GetGroupByIndex( nGroup );
1153
1154 if (!aEntries.count(pBaseGroup->GetGroupName()))
1155 {
1156 // add an additional group for each item that is not in the selection
1157 ScDPSaveGroupItem aGroup( pBaseGroup->GetGroupName() );
1158 aGroup.AddElementsFromGroup( *pBaseGroup );
1159 pGroupDimension->AddGroupItem( aGroup );
1160 }
1161 }
1162 }
1163 }
1164 OUString aGroupDimName = pGroupDimension->GetGroupDimName();
1165
1166 OUString aGroupName = pGroupDimension->CreateGroupName(ScGlobal::GetRscString(STR_PIVOT_GROUP));
1167 ScDPSaveGroupItem aGroup( aGroupName );
1168 ScDPUniqueStringSet::const_iterator it = aEntries.begin(), itEnd = aEntries.end();
1169 for (; it != itEnd; ++it)
1170 {
1171 const OUString& aEntryName = *it;
1172 if ( pBaseGroupDim )
1173 {
1174 // for each selected (intermediate) group, add all its items
1175 const ScDPSaveGroupItem* pBaseGroup = pBaseGroupDim->GetNamedGroup( aEntryName );
1176 if ( pBaseGroup )
1177 aGroup.AddElementsFromGroup( *pBaseGroup );
1178 else
1179 aGroup.AddElement( aEntryName ); // no group found -> automatic group, add the item itself
1180 }
1181 else
1182 aGroup.AddElement( aEntryName ); // no group dimension, add all items directly
1183 }
1184
1185 pGroupDimension->AddGroupItem( aGroup );
1186
1187 if ( pNewGroupDim )
1188 {
1189 pDimData->AddGroupDimension( *pNewGroupDim );
1190 delete pNewGroupDim; // AddGroupDimension copies the object
1191 // don't access pGroupDimension after here
1192 }
1193 pGroupDimension = pNewGroupDim = NULL;
1194
1195 // set orientation
1196 ScDPSaveDimension* pSaveDimension = aData.GetDimensionByName( aGroupDimName );
1197 if ( pSaveDimension->GetOrientation() == sheet::DataPilotFieldOrientation_HIDDEN )
1198 {
1199 ScDPSaveDimension* pOldDimension = aData.GetDimensionByName( aDimName );
1200 pSaveDimension->SetOrientation( pOldDimension->GetOrientation() );
1201 long nPosition = 0; //! before (immediate) base
1202 aData.SetPosition( pSaveDimension, nPosition );
1203 }
1204
1205 // apply changes
1206 ScDBDocFunc aFunc( *GetViewData()->GetDocShell() );
1207 pDPObj->SetSaveData( aData );
1208 aFunc.RefreshPivotTableGroups(pDPObj);
1209
1210 // unmark cell selection
1211 Unmark();
1212 }
1213
1214 void ScDBFunc::UngroupDataPilot()
1215 {
1216 ScDPObject* pDPObj = GetViewData()->GetDocument()->GetDPAtCursor( GetViewData()->GetCurX(),
1217 GetViewData()->GetCurY(), GetViewData()->GetTabNo() );
1218 if (!pDPObj)
1219 return;
1220
1221 ScDPUniqueStringSet aEntries;
1222 long nSelectDimension = -1;
1223 GetSelectedMemberList( aEntries, nSelectDimension );
1224
1225 if (aEntries.empty())
1226 return;
1227
1228 bool bIsDataLayout;
1229 OUString aDimName = pDPObj->GetDimName( nSelectDimension, bIsDataLayout );
1230
1231 ScDPSaveData aData( *pDPObj->GetSaveData() );
1232 if (!aData.GetExistingDimensionData())
1233 // There is nothing to ungroup.
1234 return;
1235
1236 ScDPDimensionSaveData* pDimData = aData.GetDimensionData();
1237
1238 ScDPSaveGroupDimension* pGroupDim = pDimData->GetNamedGroupDimAcc( aDimName );
1239 const ScDPSaveNumGroupDimension* pNumGroupDim = pDimData->GetNumGroupDim( aDimName );
1240 if ( ( pGroupDim && pGroupDim->GetDatePart() != 0 ) ||
1241 ( pNumGroupDim && pNumGroupDim->GetDatePart() != 0 ) )
1242 {
1243 // Date grouping: need to remove all affected group dimensions.
1244 // This is done using DateGroupDataPilot with nParts=0.
1245
1246 DateGroupDataPilot( ScDPNumGroupInfo(), 0 );
1247 return;
1248 }
1249
1250 if ( pGroupDim )
1251 {
1252 ScDPUniqueStringSet::const_iterator it = aEntries.begin(), itEnd = aEntries.end();
1253 for (; it != itEnd; ++it)
1254 pGroupDim->RemoveGroup(*it);
1255
1256 // remove group dimension if empty
1257 bool bEmptyDim = pGroupDim->IsEmpty();
1258 if ( !bEmptyDim )
1259 {
1260 // If all remaining groups in the dimension aren't shown, remove
1261 // the dimension too, as if it was completely empty.
1262 ScDPUniqueStringSet aVisibleEntries;
1263 pDPObj->GetMemberResultNames( aVisibleEntries, nSelectDimension );
1264 bEmptyDim = pGroupDim->HasOnlyHidden( aVisibleEntries );
1265 }
1266 if ( bEmptyDim )
1267 {
1268 pDimData->RemoveGroupDimension( aDimName ); // pGroupDim is deleted
1269
1270 // also remove SaveData settings for the dimension that no longer exists
1271 aData.RemoveDimensionByName( aDimName );
1272 }
1273 }
1274 else if ( pNumGroupDim )
1275 {
1276 // remove the numerical grouping
1277 pDimData->RemoveNumGroupDimension( aDimName );
1278 // SaveData settings can remain unchanged - the same dimension still exists
1279 }
1280
1281 // apply changes
1282 ScDBDocFunc aFunc( *GetViewData()->GetDocShell() );
1283 pDPObj->SetSaveData( aData );
1284 aFunc.RefreshPivotTableGroups(pDPObj);
1285
1286 // unmark cell selection
1287 Unmark();
1288 }
1289
1290 static OUString lcl_replaceMemberNameInSubtotal(const OUString& rSubtotal, const OUString& rMemberName)
1291 {
1292 sal_Int32 n = rSubtotal.getLength();
1293 const sal_Unicode* p = rSubtotal.getStr();
1294 OUStringBuffer aBuf, aWordBuf;
1295 for (sal_Int32 i = 0; i < n; ++i)
1296 {
1297 sal_Unicode c = p[i];
1298 if (c == sal_Unicode(' '))
1299 {
1300 OUString aWord = aWordBuf.makeStringAndClear();
1301 if (aWord.equals(rMemberName))
1302 aBuf.append(sal_Unicode('?'));
1303 else
1304 aBuf.append(aWord);
1305 aBuf.append(c);
1306 }
1307 else if (c == sal_Unicode('\\'))
1308 {
1309 // Escape a backslash character.
1310 aWordBuf.append(c);
1311 aWordBuf.append(c);
1312 }
1313 else if (c == sal_Unicode('?'))
1314 {
1315 // A literal '?' must be escaped with a backslash ('\');
1316 aWordBuf.append(sal_Unicode('\\'));
1317 aWordBuf.append(c);
1318 }
1319 else
1320 aWordBuf.append(c);
1321 }
1322
1323 if (aWordBuf.getLength() > 0)
1324 {
1325 OUString aWord = aWordBuf.makeStringAndClear();
1326 if (aWord.equals(rMemberName))
1327 aBuf.append(sal_Unicode('?'));
1328 else
1329 aBuf.append(aWord);
1330 }
1331
1332 return aBuf.makeStringAndClear();
1333 }
1334
1335 void ScDBFunc::DataPilotInput( const ScAddress& rPos, const OUString& rString )
1336 {
1337 using namespace ::com::sun::star::sheet;
1338
1339 ScDocument* pDoc = GetViewData()->GetDocument();
1340 ScDPObject* pDPObj = pDoc->GetDPAtCursor( rPos.Col(), rPos.Row(), rPos.Tab() );
1341 if (!pDPObj)
1342 return;
1343
1344 OUString aOldText = pDoc->GetString(rPos.Col(), rPos.Row(), rPos.Tab());
1345
1346 if ( aOldText == rString )
1347 {
1348 // nothing to do: silently exit
1349 return;
1350 }
1351
1352 sal_uInt16 nErrorId = 0;
1353
1354 pDPObj->BuildAllDimensionMembers();
1355 ScDPSaveData aData( *pDPObj->GetSaveData() );
1356 bool bChange = false;
1357
1358 sal_uInt16 nOrient = DataPilotFieldOrientation_HIDDEN;
1359 long nField = pDPObj->GetHeaderDim( rPos, nOrient );
1360 if ( nField >= 0 )
1361 {
1362 // changing a field title
1363 if ( aData.GetExistingDimensionData() )
1364 {
1365 // only group dimensions can be renamed
1366
1367 ScDPDimensionSaveData* pDimData = aData.GetDimensionData();
1368 ScDPSaveGroupDimension* pGroupDim = pDimData->GetNamedGroupDimAcc( aOldText );
1369 if ( pGroupDim )
1370 {
1371 // valid name: not empty, no existing dimension (group or other)
1372 if (!rString.isEmpty() && !pDPObj->IsDimNameInUse(rString))
1373 {
1374 pGroupDim->Rename( rString );
1375
1376 // also rename in SaveData to preserve the field settings
1377 ScDPSaveDimension* pSaveDim = aData.GetDimensionByName( aOldText );
1378 pSaveDim->SetName( rString );
1379
1380 bChange = true;
1381 }
1382 else
1383 nErrorId = STR_INVALIDNAME;
1384 }
1385 }
1386 else if (nOrient == DataPilotFieldOrientation_COLUMN || nOrient == DataPilotFieldOrientation_ROW)
1387 {
1388 bool bDataLayout = false;
1389 OUString aDimName = pDPObj->GetDimName(nField, bDataLayout);
1390 ScDPSaveDimension* pDim = bDataLayout ? aData.GetDataLayoutDimension() : aData.GetDimensionByName(aDimName);
1391 if (pDim)
1392 {
1393 if (!rString.isEmpty())
1394 {
1395 if (rString.equalsIgnoreAsciiCase(aDimName))
1396 {
1397 pDim->RemoveLayoutName();
1398 bChange = true;
1399 }
1400 else if (!pDPObj->IsDimNameInUse(rString))
1401 {
1402 pDim->SetLayoutName(rString);
1403 bChange = true;
1404 }
1405 else
1406 nErrorId = STR_INVALIDNAME;
1407 }
1408 else
1409 nErrorId = STR_INVALIDNAME;
1410 }
1411 }
1412 }
1413 else if (pDPObj->IsDataDescriptionCell(rPos))
1414 {
1415 // There is only one data dimension.
1416 ScDPSaveDimension* pDim = aData.GetFirstDimension(sheet::DataPilotFieldOrientation_DATA);
1417 if (pDim)
1418 {
1419 if (!rString.isEmpty())
1420 {
1421 if (pDim->GetName().equalsIgnoreAsciiCase(rString))
1422 {
1423 pDim->RemoveLayoutName();
1424 bChange = true;
1425 }
1426 else if (!pDPObj->IsDimNameInUse(rString))
1427 {
1428 pDim->SetLayoutName(rString);
1429 bChange = true;
1430 }
1431 else
1432 nErrorId = STR_INVALIDNAME;
1433 }
1434 else
1435 nErrorId = STR_INVALIDNAME;
1436 }
1437 }
1438 else
1439 {
1440 // This is not a field header.
1441 sheet::DataPilotTableHeaderData aPosData;
1442 pDPObj->GetHeaderPositionData(rPos, aPosData);
1443
1444 if ((aPosData.Flags & MemberResultFlags::HASMEMBER) && !aOldText.isEmpty())
1445 {
1446 if ( aData.GetExistingDimensionData() && !(aPosData.Flags & MemberResultFlags::SUBTOTAL))
1447 {
1448 bool bIsDataLayout;
1449 OUString aDimName = pDPObj->GetDimName( aPosData.Dimension, bIsDataLayout );
1450
1451 ScDPDimensionSaveData* pDimData = aData.GetDimensionData();
1452 ScDPSaveGroupDimension* pGroupDim = pDimData->GetNamedGroupDimAcc( aDimName );
1453 if ( pGroupDim )
1454 {
1455 // valid name: not empty, no existing group in this dimension
1456 //! ignore case?
1457 if (!rString.isEmpty() && !pGroupDim->GetNamedGroup(rString))
1458 {
1459 ScDPSaveGroupItem* pGroup = pGroupDim->GetNamedGroupAcc( aOldText );
1460 if ( pGroup )
1461 pGroup->Rename( rString ); // rename the existing group
1462 else
1463 {
1464 // create a new group to replace the automatic group
1465 ScDPSaveGroupItem aGroup( rString );
1466 aGroup.AddElement( aOldText );
1467 pGroupDim->AddGroupItem( aGroup );
1468 }
1469
1470 // in both cases also adjust savedata, to preserve member settings (show details)
1471 ScDPSaveDimension* pSaveDim = aData.GetDimensionByName( aDimName );
1472 ScDPSaveMember* pSaveMember = pSaveDim->GetExistingMemberByName( aOldText );
1473 if ( pSaveMember )
1474 pSaveMember->SetName( rString );
1475
1476 bChange = true;
1477 }
1478 else
1479 nErrorId = STR_INVALIDNAME;
1480 }
1481 }
1482 else if ((aPosData.Flags & MemberResultFlags::GRANDTOTAL))
1483 {
1484 aData.SetGrandTotalName(rString);
1485 bChange = true;
1486 }
1487 else if (aPosData.Dimension >= 0 && !aPosData.MemberName.isEmpty())
1488 {
1489 bool bDataLayout = false;
1490 OUString aDimName = pDPObj->GetDimName(static_cast<long>(aPosData.Dimension), bDataLayout);
1491 if (bDataLayout)
1492 {
1493 // data dimension
1494 do
1495 {
1496 if ((aPosData.Flags & MemberResultFlags::SUBTOTAL))
1497 break;
1498
1499 ScDPSaveDimension* pDim = aData.GetDimensionByName(aPosData.MemberName);
1500 if (!pDim)
1501 break;
1502
1503 if (rString.isEmpty())
1504 {
1505 nErrorId = STR_INVALIDNAME;
1506 break;
1507 }
1508
1509 if (aPosData.MemberName.equalsIgnoreAsciiCase(rString))
1510 {
1511 pDim->RemoveLayoutName();
1512 bChange = true;
1513 }
1514 else if (!pDPObj->IsDimNameInUse(rString))
1515 {
1516 pDim->SetLayoutName(rString);
1517 bChange = true;
1518 }
1519 else
1520 nErrorId = STR_INVALIDNAME;
1521 }
1522 while (false);
1523 }
1524 else
1525 {
1526 // field member
1527 do
1528 {
1529 ScDPSaveDimension* pDim = aData.GetDimensionByName(aDimName);
1530 if (!pDim)
1531 break;
1532
1533 ScDPSaveMember* pMem = pDim->GetExistingMemberByName(aPosData.MemberName);
1534 if (!pMem)
1535 break;
1536
1537 if ((aPosData.Flags & MemberResultFlags::SUBTOTAL))
1538 {
1539 // Change subtotal only when the table has one data dimension.
1540 if (aData.GetDataDimensionCount() > 1)
1541 break;
1542
1543 // display name for subtotal is allowed only if the subtotal type is 'Automatic'.
1544 if (pDim->GetSubTotalsCount() != 1)
1545 break;
1546
1547 if (pDim->GetSubTotalFunc(0) != sheet::GeneralFunction_AUTO)
1548 break;
1549
1550 const OUString* pLayoutName = pMem->GetLayoutName();
1551 String aMemberName;
1552 if (pLayoutName)
1553 aMemberName = *pLayoutName;
1554 else
1555 aMemberName = aPosData.MemberName;
1556
1557 String aNew = lcl_replaceMemberNameInSubtotal(rString, aMemberName);
1558 pDim->SetSubtotalName(aNew);
1559 bChange = true;
1560 }
1561 else
1562 {
1563 // Check to make sure the member name isn't
1564 // already used.
1565 if (!rString.isEmpty())
1566 {
1567 if (rString.equalsIgnoreAsciiCase(pMem->GetName()))
1568 {
1569 pMem->RemoveLayoutName();
1570 bChange = true;
1571 }
1572 else if (!pDim->IsMemberNameInUse(rString))
1573 {
1574 pMem->SetLayoutName(rString);
1575 bChange = true;
1576 }
1577 else
1578 nErrorId = STR_INVALIDNAME;
1579 }
1580 else
1581 nErrorId = STR_INVALIDNAME;
1582 }
1583 }
1584 while (false);
1585 }
1586 }
1587 }
1588 }
1589
1590 if ( bChange )
1591 {
1592 // apply changes
1593 ScDBDocFunc aFunc( *GetViewData()->GetDocShell() );
1594 pDPObj->SetSaveData( aData );
1595 aFunc.UpdatePivotTable(*pDPObj, true, false);
1596 }
1597 else
1598 {
1599 if ( !nErrorId )
1600 nErrorId = STR_ERR_DATAPILOT_INPUT;
1601 ErrorMessage( nErrorId );
1602 }
1603 }
1604
1605 static void lcl_MoveToEnd( ScDPSaveDimension& rDim, const String& rItemName )
1606 {
1607 ScDPSaveMember* pNewMember = NULL;
1608 const ScDPSaveMember* pOldMember = rDim.GetExistingMemberByName( rItemName );
1609 if ( pOldMember )
1610 pNewMember = new ScDPSaveMember( *pOldMember );
1611 else
1612 pNewMember = new ScDPSaveMember( rItemName );
1613 rDim.AddMember( pNewMember );
1614 // AddMember takes ownership of the new pointer,
1615 // puts it to the end of the list even if it was in the list before.
1616 }
1617
1618 struct ScOUStringCollate
1619 {
1620 CollatorWrapper* mpCollator;
1621
1622 ScOUStringCollate(CollatorWrapper* pColl) : mpCollator(pColl) {}
1623
1624 bool operator()(const OUString& rStr1, const OUString& rStr2) const
1625 {
1626 return ( mpCollator->compareString(rStr1, rStr2) < 0 );
1627 }
1628 };
1629
1630 bool ScDBFunc::DataPilotSort( const ScAddress& rPos, bool bAscending, sal_uInt16* pUserListId )
1631 {
1632 ScDocument* pDoc = GetViewData()->GetDocument();
1633 ScDPObject* pDPObj = pDoc->GetDPAtCursor(rPos.Col(), rPos.Row(), rPos.Tab());
1634 if (!pDPObj)
1635 return false;
1636
1637 // We need to run this to get all members later.
1638 if ( pUserListId )
1639 pDPObj->BuildAllDimensionMembers();
1640
1641 sal_uInt16 nOrientation;
1642 long nDimIndex = pDPObj->GetHeaderDim(rPos, nOrientation);
1643 if (nDimIndex < 0)
1644 // Invalid dimension index. Bail out.
1645 return false;
1646
1647 ScDPSaveData* pSaveData = pDPObj->GetSaveData();
1648 if (!pSaveData)
1649 return false;
1650
1651 ScDPSaveData aNewSaveData(*pSaveData);
1652 bool bDataLayout;
1653 OUString aDimName = pDPObj->GetDimName(nDimIndex, bDataLayout);
1654 ScDPSaveDimension* pSaveDim = aNewSaveData.GetDimensionByName(aDimName);
1655 if (!pSaveDim)
1656 return false;
1657
1658 // manual evaluation of sort order is only needed if a user list id is given
1659 if ( pUserListId )
1660 {
1661 typedef ScDPSaveDimension::MemberList MemList;
1662 const MemList& rDimMembers = pSaveDim->GetMembers();
1663 list<OUString> aMembers;
1664 boost::unordered_set<OUString, OUStringHash> aMemberSet;
1665 size_t nMemberCount = 0;
1666 for (MemList::const_iterator itr = rDimMembers.begin(), itrEnd = rDimMembers.end();
1667 itr != itrEnd; ++itr)
1668 {
1669 ScDPSaveMember* pMem = *itr;
1670 aMembers.push_back(pMem->GetName());
1671 aMemberSet.insert(pMem->GetName());
1672 ++nMemberCount;
1673 }
1674
1675 // Sort the member list in ascending order.
1676 ScOUStringCollate aCollate( ScGlobal::GetCollator() );
1677 aMembers.sort(aCollate);
1678
1679 // Collect and rank those custom sort strings that also exist in the member name list.
1680
1681 typedef boost::unordered_map<OUString, sal_uInt16, OUStringHash> UserSortMap;
1682 UserSortMap aSubStrs;
1683 sal_uInt16 nSubCount = 0;
1684 if (pUserListId)
1685 {
1686 ScUserList* pUserList = ScGlobal::GetUserList();
1687 if (!pUserList)
1688 return false;
1689
1690 {
1691 size_t n = pUserList->size();
1692 if (!n || *pUserListId >= static_cast<sal_uInt16>(n))
1693 return false;
1694 }
1695
1696 const ScUserListData* pData = (*pUserList)[*pUserListId];
1697 if (pData)
1698 {
1699 sal_uInt16 n = pData->GetSubCount();
1700 for (sal_uInt16 i = 0; i < n; ++i)
1701 {
1702 OUString aSub = pData->GetSubStr(i);
1703 if (!aMemberSet.count(aSub))
1704 // This string doesn't exist in the member name set. Don't add this.
1705 continue;
1706
1707 aSubStrs.insert(UserSortMap::value_type(aSub, nSubCount++));
1708 }
1709 }
1710 }
1711
1712 // Rank all members.
1713
1714 vector<OUString> aRankedNames(nMemberCount);
1715 sal_uInt16 nCurStrId = 0;
1716 for (list<OUString>::const_iterator itr = aMembers.begin(), itrEnd = aMembers.end();
1717 itr != itrEnd; ++itr)
1718 {
1719 OUString aName = *itr;
1720 sal_uInt16 nRank = 0;
1721 UserSortMap::const_iterator itrSub = aSubStrs.find(aName);
1722 if (itrSub == aSubStrs.end())
1723 nRank = nSubCount + nCurStrId++;
1724 else
1725 nRank = itrSub->second;
1726
1727 if (!bAscending)
1728 nRank = static_cast< sal_uInt16 >( nMemberCount - nRank - 1 );
1729
1730 aRankedNames[nRank] = aName;
1731 }
1732
1733 // Re-order ScDPSaveMember instances with the new ranks.
1734
1735 for (vector<OUString>::const_iterator itr = aRankedNames.begin(), itrEnd = aRankedNames.end();
1736 itr != itrEnd; ++itr)
1737 {
1738 const ScDPSaveMember* pOldMem = pSaveDim->GetExistingMemberByName(*itr);
1739 if (!pOldMem)
1740 // All members are supposed to be present.
1741 continue;
1742
1743 ScDPSaveMember* pNewMem = new ScDPSaveMember(*pOldMem);
1744 pSaveDim->AddMember(pNewMem);
1745 }
1746
1747 // Set the sorting mode to manual for now. We may introduce a new sorting
1748 // mode later on.
1749
1750 sheet::DataPilotFieldSortInfo aSortInfo;
1751 aSortInfo.Mode = sheet::DataPilotFieldSortMode::MANUAL;
1752 pSaveDim->SetSortInfo(&aSortInfo);
1753 }
1754 else
1755 {
1756 // without user list id, just apply sorting mode
1757
1758 sheet::DataPilotFieldSortInfo aSortInfo;
1759 aSortInfo.Mode = sheet::DataPilotFieldSortMode::NAME;
1760 aSortInfo.IsAscending = bAscending;
1761 pSaveDim->SetSortInfo(&aSortInfo);
1762 }
1763
1764 // Update the datapilot with the newly sorted field members.
1765
1766 auto_ptr<ScDPObject> pNewObj(new ScDPObject(*pDPObj));
1767 pNewObj->SetSaveData(aNewSaveData);
1768 ScDBDocFunc aFunc(*GetViewData()->GetDocShell());
1769
1770 return aFunc.DataPilotUpdate(pDPObj, pNewObj.get(), true, false);
1771 }
1772
1773 sal_Bool ScDBFunc::DataPilotMove( const ScRange& rSource, const ScAddress& rDest )
1774 {
1775 sal_Bool bRet = false;
1776 ScDocument* pDoc = GetViewData()->GetDocument();
1777 ScDPObject* pDPObj = pDoc->GetDPAtCursor( rSource.aStart.Col(), rSource.aStart.Row(), rSource.aStart.Tab() );
1778 if ( pDPObj && pDPObj == pDoc->GetDPAtCursor( rDest.Col(), rDest.Row(), rDest.Tab() ) )
1779 {
1780 sheet::DataPilotTableHeaderData aDestData;
1781 pDPObj->GetHeaderPositionData( rDest, aDestData );
1782 bool bValid = ( aDestData.Dimension >= 0 ); // dropping onto a field
1783
1784 // look through the source range
1785 boost::unordered_set< OUString, OUStringHash, std::equal_to<OUString> > aMembersSet; // for lookup
1786 std::vector< OUString > aMembersVector; // members in original order, for inserting
1787 aMembersVector.reserve( std::max( static_cast<SCSIZE>( rSource.aEnd.Col() - rSource.aStart.Col() + 1 ),
1788 static_cast<SCSIZE>( rSource.aEnd.Row() - rSource.aStart.Row() + 1 ) ) );
1789 for (SCROW nRow = rSource.aStart.Row(); bValid && nRow <= rSource.aEnd.Row(); ++nRow )
1790 for (SCCOL nCol = rSource.aStart.Col(); bValid && nCol <= rSource.aEnd.Col(); ++nCol )
1791 {
1792 sheet::DataPilotTableHeaderData aSourceData;
1793 pDPObj->GetHeaderPositionData( ScAddress( nCol, nRow, rSource.aStart.Tab() ), aSourceData );
1794 if ( aSourceData.Dimension == aDestData.Dimension && !aSourceData.MemberName.isEmpty() )
1795 {
1796 if ( aMembersSet.find( aSourceData.MemberName ) == aMembersSet.end() )
1797 {
1798 aMembersSet.insert( aSourceData.MemberName );
1799 aMembersVector.push_back( aSourceData.MemberName );
1800 }
1801 // duplicates are ignored
1802 }
1803 else
1804 bValid = false; // empty (subtotal) or different field
1805 }
1806
1807 if ( bValid )
1808 {
1809 bool bIsDataLayout;
1810 OUString aDimName = pDPObj->GetDimName( aDestData.Dimension, bIsDataLayout );
1811 if ( !bIsDataLayout )
1812 {
1813 ScDPSaveData aData( *pDPObj->GetSaveData() );
1814 ScDPSaveDimension* pDim = aData.GetDimensionByName( aDimName );
1815
1816 // get all member names in source order
1817 uno::Sequence<OUString> aMemberNames;
1818 pDPObj->GetMemberNames( aDestData.Dimension, aMemberNames );
1819
1820 bool bInserted = false;
1821
1822 sal_Int32 nMemberCount = aMemberNames.getLength();
1823 for (sal_Int32 nMemberPos=0; nMemberPos<nMemberCount; ++nMemberPos)
1824 {
1825 String aMemberStr( aMemberNames[nMemberPos] );
1826
1827 if ( !bInserted && aMemberNames[nMemberPos] == aDestData.MemberName )
1828 {
1829 // insert dragged items before this item
1830 for ( std::vector<OUString>::const_iterator aIter = aMembersVector.begin();
1831 aIter != aMembersVector.end(); ++aIter )
1832 lcl_MoveToEnd( *pDim, *aIter );
1833 bInserted = true;
1834 }
1835
1836 if ( aMembersSet.find( aMemberStr ) == aMembersSet.end() ) // skip dragged items
1837 lcl_MoveToEnd( *pDim, aMemberStr );
1838 }
1839 // insert dragged item at end if dest wasn't found (for example, empty)
1840 if ( !bInserted )
1841 for ( std::vector<OUString>::const_iterator aIter = aMembersVector.begin();
1842 aIter != aMembersVector.end(); ++aIter )
1843 lcl_MoveToEnd( *pDim, *aIter );
1844
1845 // Items that were in SaveData, but not in the source, end up at the start of the list.
1846
1847 // set flag for manual sorting
1848 sheet::DataPilotFieldSortInfo aSortInfo;
1849 aSortInfo.Mode = sheet::DataPilotFieldSortMode::MANUAL;
1850 pDim->SetSortInfo( &aSortInfo );
1851
1852 // apply changes
1853 ScDBDocFunc aFunc( *GetViewData()->GetDocShell() );
1854 ScDPObject* pNewObj = new ScDPObject( *pDPObj );
1855 pNewObj->SetSaveData( aData );
1856 aFunc.DataPilotUpdate( pDPObj, pNewObj, sal_True, false ); //! bApi for drag&drop?
1857 delete pNewObj;
1858
1859 Unmark(); // entry was moved - no use in leaving the old cell selected
1860
1861 bRet = sal_True;
1862 }
1863 }
1864 }
1865
1866 return bRet;
1867 }
1868
1869 bool ScDBFunc::HasSelectionForDrillDown( sal_uInt16& rOrientation )
1870 {
1871 bool bRet = false;
1872
1873 ScDPObject* pDPObj = GetViewData()->GetDocument()->GetDPAtCursor( GetViewData()->GetCurX(),
1874 GetViewData()->GetCurY(), GetViewData()->GetTabNo() );
1875 if ( pDPObj )
1876 {
1877 ScDPUniqueStringSet aEntries;
1878 long nSelectDimension = -1;
1879 GetSelectedMemberList( aEntries, nSelectDimension );
1880
1881 if (!aEntries.empty())
1882 {
1883 bool bIsDataLayout;
1884 OUString aDimName = pDPObj->GetDimName( nSelectDimension, bIsDataLayout );
1885 if ( !bIsDataLayout )
1886 {
1887 ScDPSaveData* pSaveData = pDPObj->GetSaveData();
1888 ScDPSaveDimension* pDim = pSaveData->GetExistingDimensionByName( aDimName );
1889 if ( pDim )
1890 {
1891 sal_uInt16 nDimOrient = pDim->GetOrientation();
1892 ScDPSaveDimension* pInner = pSaveData->GetInnermostDimension( nDimOrient );
1893 if ( pDim == pInner )
1894 {
1895 rOrientation = nDimOrient;
1896 bRet = true;
1897 }
1898 }
1899 }
1900 }
1901 }
1902
1903 return bRet;
1904 }
1905
1906 void ScDBFunc::SetDataPilotDetails(bool bShow, const OUString* pNewDimensionName)
1907 {
1908 ScDPObject* pDPObj = GetViewData()->GetDocument()->GetDPAtCursor( GetViewData()->GetCurX(),
1909 GetViewData()->GetCurY(), GetViewData()->GetTabNo() );
1910 if ( pDPObj )
1911 {
1912 ScDPUniqueStringSet aEntries;
1913 long nSelectDimension = -1;
1914 GetSelectedMemberList( aEntries, nSelectDimension );
1915
1916 if (!aEntries.empty())
1917 {
1918 bool bIsDataLayout;
1919 OUString aDimName = pDPObj->GetDimName( nSelectDimension, bIsDataLayout );
1920 if ( !bIsDataLayout )
1921 {
1922 ScDPSaveData aData( *pDPObj->GetSaveData() );
1923 ScDPSaveDimension* pDim = aData.GetDimensionByName( aDimName );
1924
1925 if ( bShow && pNewDimensionName )
1926 {
1927 // add the new dimension with the same orientation, at the end
1928
1929 ScDPSaveDimension* pNewDim = aData.GetDimensionByName( *pNewDimensionName );
1930 ScDPSaveDimension* pDuplicated = NULL;
1931 if ( pNewDim->GetOrientation() == sheet::DataPilotFieldOrientation_DATA )
1932 {
1933 // Need to duplicate the dimension, create column/row in addition to data:
1934 // The duplicated dimension inherits the existing settings, pNewDim is modified below.
1935 pDuplicated = aData.DuplicateDimension( *pNewDimensionName );
1936 }
1937
1938 sal_uInt16 nOrientation = pDim->GetOrientation();
1939 pNewDim->SetOrientation( nOrientation );
1940
1941 long nPosition = LONG_MAX;
1942 aData.SetPosition( pNewDim, nPosition );
1943
1944 ScDPSaveDimension* pDataLayout = aData.GetDataLayoutDimension();
1945 if ( pDataLayout->GetOrientation() == nOrientation &&
1946 aData.GetDataDimensionCount() <= 1 )
1947 {
1948 // If there is only one data dimension, the data layout dimension
1949 // must still be the last one in its orientation.
1950 aData.SetPosition( pDataLayout, nPosition );
1951 }
1952
1953 if ( pDuplicated )
1954 {
1955 // The duplicated (data) dimension needs to be behind the original dimension
1956 aData.SetPosition( pDuplicated, nPosition );
1957 }
1958
1959 // Hide details for all visible members (selected are changed below).
1960 //! Use all members from source level instead (including non-visible)?
1961
1962 ScDPUniqueStringSet aVisibleEntries;
1963 pDPObj->GetMemberResultNames( aVisibleEntries, nSelectDimension );
1964
1965 ScDPUniqueStringSet::const_iterator it = aVisibleEntries.begin(), itEnd = aVisibleEntries.end();
1966 for (; it != itEnd; ++it)
1967 {
1968 const OUString& aVisName = *it;
1969 ScDPSaveMember* pMember = pDim->GetMemberByName( aVisName );
1970 pMember->SetShowDetails( false );
1971 }
1972 }
1973
1974 ScDPUniqueStringSet::const_iterator it = aEntries.begin(), itEnd = aEntries.end();
1975 for (; it != itEnd; ++it)
1976 {
1977 ScDPSaveMember* pMember = pDim->GetMemberByName(*it);
1978 pMember->SetShowDetails( bShow );
1979 }
1980
1981 // apply changes
1982 ScDBDocFunc aFunc( *GetViewData()->GetDocShell() );
1983 ScDPObject* pNewObj = new ScDPObject( *pDPObj );
1984 pNewObj->SetSaveData( aData );
1985 aFunc.DataPilotUpdate( pDPObj, pNewObj, sal_True, false );
1986 delete pNewObj;
1987
1988 // unmark cell selection
1989 Unmark();
1990 }
1991 }
1992 }
1993 }
1994
1995 void ScDBFunc::ShowDataPilotSourceData( ScDPObject& rDPObj, const Sequence<sheet::DataPilotFieldFilter>& rFilters )
1996 {
1997 ScDocument* pDoc = GetViewData()->GetDocument();
1998 if (pDoc->GetDocumentShell()->IsReadOnly())
1999 {
2000 ErrorMessage(STR_READONLYERR);
2001 return;
2002 }
2003
2004 Reference<sheet::XDimensionsSupplier> xDimSupplier = rDPObj.GetSource();
2005 Reference<container::XNameAccess> xDims = xDimSupplier->getDimensions();
2006 Reference<sheet::XDrillDownDataSupplier> xDDSupplier(xDimSupplier, UNO_QUERY);
2007 if (!xDDSupplier.is())
2008 return;
2009
2010 Sequence< Sequence<Any> > aTabData = xDDSupplier->getDrillDownData(rFilters);
2011 sal_Int32 nRowSize = aTabData.getLength();
2012 if (nRowSize <= 1)
2013 // There is no data to show. Bail out.
2014 return;
2015
2016 sal_Int32 nColSize = aTabData[0].getLength();
2017
2018 SCTAB nNewTab = GetViewData()->GetTabNo();
2019
2020 auto_ptr<ScDocument> pInsDoc(new ScDocument(SCDOCMODE_CLIP));
2021 pInsDoc->ResetClip( pDoc, nNewTab );
2022 for (SCROW nRow = 0; nRow < nRowSize; ++nRow)
2023 {
2024 for (SCCOL nCol = 0; nCol < nColSize; ++nCol)
2025 {
2026 const Any& rAny = aTabData[nRow][nCol];
2027 OUString aStr;
2028 double fVal;
2029 if (rAny >>= aStr)
2030 {
2031 ScSetStringParam aParam;
2032 aParam.setTextInput();
2033 pInsDoc->SetString(ScAddress(nCol,nRow,nNewTab), aStr);
2034 }
2035 else if (rAny >>= fVal)
2036 pInsDoc->SetValue(nCol, nRow, nNewTab, fVal);
2037 }
2038 }
2039
2040 // set number format (important for dates)
2041 for (SCCOL nCol = 0; nCol < nColSize; ++nCol)
2042 {
2043 OUString aStr;
2044 if (!(aTabData[0][nCol] >>= aStr))
2045 continue;
2046
2047 Reference<XPropertySet> xPropSet(xDims->getByName(aStr), UNO_QUERY);
2048 if (!xPropSet.is())
2049 continue;
2050
2051 Any any = xPropSet->getPropertyValue( OUString(SC_UNO_DP_NUMBERFO) );
2052 sal_Int32 nNumFmt = 0;
2053 if (!(any >>= nNumFmt))
2054 continue;
2055
2056 ScPatternAttr aPattern( pInsDoc->GetPool() );
2057 aPattern.GetItemSet().Put( SfxUInt32Item(ATTR_VALUE_FORMAT, static_cast<sal_uInt32>(nNumFmt)) );
2058 pInsDoc->ApplyPatternAreaTab(nCol, 1, nCol, nRowSize-1, nNewTab, aPattern);
2059 }
2060
2061 SCCOL nEndCol = 0;
2062 SCROW nEndRow = 0;
2063 pInsDoc->GetCellArea( nNewTab, nEndCol, nEndRow );
2064 pInsDoc->SetClipArea( ScRange( 0, 0, nNewTab, nEndCol, nEndRow, nNewTab ) );
2065
2066 ::svl::IUndoManager* pMgr = GetViewData()->GetDocShell()->GetUndoManager();
2067 String aUndo = ScGlobal::GetRscString( STR_UNDO_DOOUTLINE );
2068 pMgr->EnterListAction( aUndo, aUndo );
2069
2070 OUString aNewTabName;
2071 pDoc->CreateValidTabName(aNewTabName);
2072 if ( InsertTable(aNewTabName, nNewTab) )
2073 PasteFromClip( IDF_ALL, pInsDoc.get() );
2074
2075 pMgr->LeaveListAction();
2076 }
2077
2078 //
2079 // DB-Operationen (Sortieren, Filtern, Teilergebnisse) wiederholen
2080 //
2081
2082 void ScDBFunc::RepeatDB( sal_Bool bRecord )
2083 {
2084 SCCOL nCurX = GetViewData()->GetCurX();
2085 SCROW nCurY = GetViewData()->GetCurY();
2086 SCTAB nTab = GetViewData()->GetTabNo();
2087 ScDocument* pDoc = GetViewData()->GetDocument();
2088 ScDBData* pDBData = GetDBData();
2089 if (bRecord && !pDoc->IsUndoEnabled())
2090 bRecord = false;
2091
2092 ScQueryParam aQueryParam;
2093 pDBData->GetQueryParam( aQueryParam );
2094 sal_Bool bQuery = aQueryParam.GetEntry(0).bDoQuery;
2095
2096 ScSortParam aSortParam;
2097 pDBData->GetSortParam( aSortParam );
2098 sal_Bool bSort = aSortParam.maKeyState[0].bDoSort;
2099
2100 ScSubTotalParam aSubTotalParam;
2101 pDBData->GetSubTotalParam( aSubTotalParam );
2102 sal_Bool bSubTotal = aSubTotalParam.bGroupActive[0] && !aSubTotalParam.bRemoveOnly;
2103
2104 if ( bQuery || bSort || bSubTotal )
2105 {
2106 sal_Bool bQuerySize = false;
2107 ScRange aOldQuery;
2108 ScRange aNewQuery;
2109 if (bQuery && !aQueryParam.bInplace)
2110 {
2111 ScDBData* pDest = pDoc->GetDBAtCursor( aQueryParam.nDestCol, aQueryParam.nDestRow,
2112 aQueryParam.nDestTab, sal_True );
2113 if (pDest && pDest->IsDoSize())
2114 {
2115 pDest->GetArea( aOldQuery );
2116 bQuerySize = sal_True;
2117 }
2118 }
2119
2120 SCTAB nDummy;
2121 SCCOL nStartCol;
2122 SCROW nStartRow;
2123 SCCOL nEndCol;
2124 SCROW nEndRow;
2125 pDBData->GetArea( nDummy, nStartCol, nStartRow, nEndCol, nEndRow );
2126
2127 //! Undo nur benoetigte Daten ?
2128
2129 ScDocument* pUndoDoc = NULL;
2130 ScOutlineTable* pUndoTab = NULL;
2131 ScRangeName* pUndoRange = NULL;
2132 ScDBCollection* pUndoDB = NULL;
2133
2134 if (bRecord)
2135 {
2136 SCTAB nTabCount = pDoc->GetTableCount();
2137 pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
2138 ScOutlineTable* pTable = pDoc->GetOutlineTable( nTab );
2139 if (pTable)
2140 {
2141 pUndoTab = new ScOutlineTable( *pTable );
2142
2143 SCCOLROW nOutStartCol; // Zeilen/Spaltenstatus
2144 SCCOLROW nOutStartRow;
2145 SCCOLROW nOutEndCol;
2146 SCCOLROW nOutEndRow;
2147 pTable->GetColArray()->GetRange( nOutStartCol, nOutEndCol );
2148 pTable->GetRowArray()->GetRange( nOutStartRow, nOutEndRow );
2149
2150 pUndoDoc->InitUndo( pDoc, nTab, nTab, sal_True, sal_True );
2151 pDoc->CopyToDocument( static_cast<SCCOL>(nOutStartCol), 0, nTab, static_cast<SCCOL>(nOutEndCol), MAXROW, nTab, IDF_NONE, false, pUndoDoc );
2152 pDoc->CopyToDocument( 0, nOutStartRow, nTab, MAXCOL, nOutEndRow, nTab, IDF_NONE, false, pUndoDoc );
2153 }
2154 else
2155 pUndoDoc->InitUndo( pDoc, nTab, nTab, false, sal_True );
2156
2157 // Datenbereich sichern - incl. Filter-Ergebnis
2158 pDoc->CopyToDocument( 0,nStartRow,nTab, MAXCOL,nEndRow,nTab, IDF_ALL, false, pUndoDoc );
2159
2160 // alle Formeln wegen Referenzen
2161 pDoc->CopyToDocument( 0,0,0, MAXCOL,MAXROW,nTabCount-1, IDF_FORMULA, false, pUndoDoc );
2162
2163 // DB- und andere Bereiche
2164 ScRangeName* pDocRange = pDoc->GetRangeName();
2165 if (!pDocRange->empty())
2166 pUndoRange = new ScRangeName( *pDocRange );
2167 ScDBCollection* pDocDB = pDoc->GetDBCollection();
2168 if (!pDocDB->empty())
2169 pUndoDB = new ScDBCollection( *pDocDB );
2170 }
2171
2172 if (bSort && bSubTotal)
2173 {
2174 // Sortieren ohne SubTotals
2175
2176 aSubTotalParam.bRemoveOnly = sal_True; // wird unten wieder zurueckgesetzt
2177 DoSubTotals( aSubTotalParam, false );
2178 }
2179
2180 if (bSort)
2181 {
2182 pDBData->GetSortParam( aSortParam ); // Bereich kann sich geaendert haben
2183 Sort( aSortParam, false, false);
2184 }
2185 if (bQuery)
2186 {
2187 pDBData->GetQueryParam( aQueryParam ); // Bereich kann sich geaendert haben
2188 ScRange aAdvSource;
2189 if (pDBData->GetAdvancedQuerySource(aAdvSource))
2190 {
2191 pDoc->CreateQueryParam(
2192 aAdvSource.aStart.Col(), aAdvSource.aStart.Row(),
2193 aAdvSource.aEnd.Col(), aAdvSource.aEnd.Row(),
2194 aAdvSource.aStart.Tab(), aQueryParam );
2195 Query( aQueryParam, &aAdvSource, false );
2196 }
2197 else
2198 Query( aQueryParam, NULL, false );
2199
2200 // bei nicht-inplace kann die Tabelle umgestellt worden sein
2201 if ( !aQueryParam.bInplace && aQueryParam.nDestTab != nTab )
2202 SetTabNo( nTab );
2203 }
2204 if (bSubTotal)
2205 {
2206 pDBData->GetSubTotalParam( aSubTotalParam ); // Bereich kann sich geaendert haben
2207 aSubTotalParam.bRemoveOnly = false;
2208 DoSubTotals( aSubTotalParam, false );
2209 }
2210
2211 if (bRecord)
2212 {
2213 SCTAB nDummyTab;
2214 SCCOL nDummyCol;
2215 SCROW nDummyRow, nNewEndRow;
2216 pDBData->GetArea( nDummyTab, nDummyCol,nDummyRow, nDummyCol,nNewEndRow );
2217
2218 const ScRange* pOld = NULL;
2219 const ScRange* pNew = NULL;
2220 if (bQuerySize)
2221 {
2222 ScDBData* pDest = pDoc->GetDBAtCursor( aQueryParam.nDestCol, aQueryParam.nDestRow,
2223 aQueryParam.nDestTab, sal_True );
2224 if (pDest)
2225 {
2226 pDest->GetArea( aNewQuery );
2227 pOld = &aOldQuery;
2228 pNew = &aNewQuery;
2229 }
2230 }
2231
2232 GetViewData()->GetDocShell()->GetUndoManager()->AddUndoAction(
2233 new ScUndoRepeatDB( GetViewData()->GetDocShell(), nTab,
2234 nStartCol, nStartRow, nEndCol, nEndRow,
2235 nNewEndRow,
2236 nCurX, nCurY,
2237 pUndoDoc, pUndoTab,
2238 pUndoRange, pUndoDB,
2239 pOld, pNew ) );
2240 }
2241
2242 GetViewData()->GetDocShell()->PostPaint(
2243 ScRange(0, 0, nTab, MAXCOL, MAXROW, nTab),
2244 PAINT_GRID | PAINT_LEFT | PAINT_TOP | PAINT_SIZE);
2245 }
2246 else // "Keine Operationen auszufuehren"
2247 ErrorMessage(STR_MSSG_REPEATDB_0);
2248 }
2249
2250 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE