LCOV - code coverage report
Current view: top level - sc/source/ui/dbgui - PivotLayoutTreeListData.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 134 0.0 %
Date: 2014-04-14 Functions: 0 15 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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             : 
      12             : #include "PivotLayoutTreeListData.hxx"
      13             : #include "PivotLayoutDialog.hxx"
      14             : 
      15             : #include <svtools/treelistentry.hxx>
      16             : #include "pivot.hxx"
      17             : #include "scabstdlg.hxx"
      18             : 
      19             : using namespace std;
      20             : 
      21           0 : extern "C" SAL_DLLPUBLIC_EXPORT Window* SAL_CALL makeScPivotLayoutTreeListData(Window *pParent, VclBuilder::stringmap& )
      22             : {
      23           0 :     return new ScPivotLayoutTreeListData(pParent, WB_BORDER | WB_TABSTOP | WB_CLIPCHILDREN | WB_FORCE_MAKEVISIBLE);
      24             : }
      25             : 
      26             : namespace
      27             : {
      28             : 
      29           0 : OUString lclGetFunctionMaskName(const sal_uInt16 nFunctionMask)
      30             : {
      31           0 :     switch (nFunctionMask)
      32             :     {
      33           0 :         case PIVOT_FUNC_SUM:       return OUString("Sum");
      34           0 :         case PIVOT_FUNC_COUNT:     return OUString("Count");
      35           0 :         case PIVOT_FUNC_AVERAGE:   return OUString("Mean");
      36           0 :         case PIVOT_FUNC_MAX:       return OUString("Max");
      37           0 :         case PIVOT_FUNC_MIN:       return OUString("Min");
      38           0 :         case PIVOT_FUNC_PRODUCT:   return OUString("Product");
      39           0 :         case PIVOT_FUNC_COUNT_NUM: return OUString("Count");
      40           0 :         case PIVOT_FUNC_STD_DEV:   return OUString("StDev");
      41           0 :         case PIVOT_FUNC_STD_DEVP:  return OUString("StDevP");
      42           0 :         case PIVOT_FUNC_STD_VAR:   return OUString("Var");
      43           0 :         case PIVOT_FUNC_STD_VARP:  return OUString("VarP");
      44             :         default:
      45           0 :             break;
      46             :     }
      47           0 :     return OUString();
      48             : }
      49             : 
      50           0 : OUString lclCreateDataItemName(const sal_uInt16 nFunctionMask, const OUString& rName, const sal_uInt8 nDuplicationCount)
      51             : {
      52           0 :     OUStringBuffer aBuffer;
      53           0 :     aBuffer.append(lclGetFunctionMaskName(nFunctionMask));
      54           0 :     aBuffer.append(" - ");
      55           0 :     aBuffer.append(rName);
      56           0 :     if(nDuplicationCount > 0)
      57             :     {
      58           0 :         aBuffer.append(" ");
      59           0 :         aBuffer.append(OUString::number(nDuplicationCount));
      60             :     }
      61             : 
      62           0 :     return aBuffer.makeStringAndClear();
      63             : }
      64             : 
      65             : } // anonymous namespace
      66             : 
      67           0 : ScPivotLayoutTreeListData::ScPivotLayoutTreeListData(Window* pParent, WinBits nBits) :
      68           0 :     ScPivotLayoutTreeListBase(pParent, nBits, DATA_LIST)
      69           0 : {}
      70             : 
      71           0 : ScPivotLayoutTreeListData::~ScPivotLayoutTreeListData()
      72           0 : {}
      73             : 
      74           0 : bool ScPivotLayoutTreeListData::DoubleClickHdl()
      75             : {
      76           0 :     ScItemValue* pCurrentItemValue = (ScItemValue*) GetCurEntry()->GetUserData();
      77           0 :     ScPivotFuncData& rCurrentFunctionData = pCurrentItemValue->maFunctionData;
      78             : 
      79           0 :     SCCOL nCurrentColumn = rCurrentFunctionData.mnCol;
      80           0 :     ScDPLabelData* pCurrentLabelData = mpParent->GetLabelData(nCurrentColumn);
      81           0 :     if (!pCurrentLabelData)
      82           0 :         return false;
      83             : 
      84           0 :     ScAbstractDialogFactory* pFactory = ScAbstractDialogFactory::Create();
      85             : 
      86             :     boost::scoped_ptr<AbstractScDPFunctionDlg> pDialog(
      87           0 :         pFactory->CreateScDPFunctionDlg(this, mpParent->GetLabelDataVector(), *pCurrentLabelData, rCurrentFunctionData));
      88             : 
      89           0 :     if (pDialog->Execute() == RET_OK)
      90             :     {
      91           0 :         rCurrentFunctionData.mnFuncMask = pDialog->GetFuncMask();
      92           0 :         pCurrentLabelData->mnFuncMask = pDialog->GetFuncMask();
      93             : 
      94           0 :         rCurrentFunctionData.maFieldRef = pDialog->GetFieldRef();
      95             : 
      96           0 :         ScDPLabelData* pDFData = mpParent->GetLabelData(rCurrentFunctionData.mnCol);
      97             : 
      98           0 :         AdjustDuplicateCount(pCurrentItemValue);
      99             : 
     100             :         OUString sDataItemName = lclCreateDataItemName(
     101             :                                     rCurrentFunctionData.mnFuncMask,
     102             :                                     pDFData->maName,
     103           0 :                                     rCurrentFunctionData.mnDupCount);
     104             : 
     105           0 :         SetEntryText(GetCurEntry(), sDataItemName);
     106             :     }
     107             : 
     108           0 :     return true;
     109             : }
     110             : 
     111           0 : void ScPivotLayoutTreeListData::FillDataField(ScPivotFieldVector& rDataFields)
     112             : {
     113           0 :     Clear();
     114           0 :     maDataItemValues.clear();
     115             : 
     116           0 :     ScPivotFieldVector::iterator it;
     117           0 :     for (it = rDataFields.begin(); it != rDataFields.end(); ++it)
     118             :     {
     119           0 :         ScPivotField& rField = *it;
     120             : 
     121           0 :         if (rField.nCol == PIVOT_DATA_FIELD)
     122           0 :             continue;
     123             : 
     124             :         SCCOL nColumn;
     125           0 :         if (rField.mnOriginalDim >= 0)
     126           0 :             nColumn = rField.mnOriginalDim;
     127             :         else
     128           0 :             nColumn = rField.nCol;
     129             : 
     130           0 :         ScItemValue* pOriginalItemValue = mpParent->GetItem(nColumn);
     131           0 :         ScItemValue* pItemValue = new ScItemValue(pOriginalItemValue->maName, nColumn, rField.nFuncMask);
     132             : 
     133           0 :         pItemValue->mpOriginalItemValue = pOriginalItemValue;
     134           0 :         pItemValue->maFunctionData.mnOriginalDim = rField.mnOriginalDim;
     135           0 :         pItemValue->maFunctionData.maFieldRef = rField.maFieldRef;
     136             : 
     137           0 :         AdjustDuplicateCount(pItemValue);
     138             :         OUString sDataItemName = lclCreateDataItemName(pItemValue->maFunctionData.mnFuncMask,
     139             :                                                        pItemValue->maName,
     140           0 :                                                        pItemValue->maFunctionData.mnDupCount);
     141             : 
     142           0 :         maDataItemValues.push_back(pItemValue);
     143           0 :         InsertEntry(sDataItemName, NULL, false, TREELIST_APPEND, pItemValue);
     144           0 :     }
     145           0 : }
     146             : 
     147           0 : void ScPivotLayoutTreeListData::PushDataFieldNames(vector<ScDPName>& rDataFieldNames)
     148             : {
     149             :     SvTreeListEntry* pLoopEntry;
     150           0 :     for (pLoopEntry = First(); pLoopEntry != NULL; pLoopEntry = Next(pLoopEntry))
     151             :     {
     152           0 :         ScItemValue* pEachItemValue = (ScItemValue*) pLoopEntry->GetUserData();
     153           0 :         SCCOL nColumn = pEachItemValue->maFunctionData.mnCol;
     154             : 
     155           0 :         ScDPLabelData* pLabelData = mpParent->GetLabelData(nColumn);
     156             : 
     157           0 :         if (pLabelData == NULL && pLabelData->maName.isEmpty())
     158           0 :             continue;
     159             : 
     160           0 :         OUString sLayoutName = pLabelData->maLayoutName;
     161           0 :         if (sLayoutName.isEmpty())
     162             :         {
     163           0 :             sLayoutName = lclCreateDataItemName(
     164             :                             pEachItemValue->maFunctionData.mnFuncMask,
     165             :                             pEachItemValue->maName,
     166           0 :                             pEachItemValue->maFunctionData.mnDupCount);
     167             :         }
     168             : 
     169           0 :         rDataFieldNames.push_back(ScDPName(pLabelData->maName, sLayoutName, pLabelData->mnDupCount));
     170           0 :     }
     171           0 : }
     172             : 
     173           0 : void ScPivotLayoutTreeListData::InsertEntryForSourceTarget(SvTreeListEntry* pSource, SvTreeListEntry* pTarget)
     174             : {
     175           0 :     ScItemValue* pItemValue = (ScItemValue*) pSource->GetUserData();
     176             : 
     177           0 :     if(mpParent->IsDataElement(pItemValue->maFunctionData.mnCol))
     178           0 :         return;
     179             : 
     180           0 :     if (HasEntry(pSource))
     181             :     {
     182           0 :         OUString rText = GetEntryText(pSource);
     183           0 :         GetModel()->Remove(pSource);
     184           0 :         sal_uLong nPosition = (pTarget == NULL) ? TREELIST_APPEND : GetModel()->GetAbsPos(pTarget) + 1;
     185           0 :         InsertEntry(rText, NULL, false, nPosition, pItemValue);
     186             :     }
     187             :     else
     188             :     {
     189           0 :         sal_uLong nPosition = (pTarget == NULL) ? TREELIST_APPEND : GetModel()->GetAbsPos(pTarget) + 1;
     190           0 :         InsertEntryForItem(pItemValue->mpOriginalItemValue, nPosition);
     191             :     }
     192             : }
     193             : 
     194           0 : void ScPivotLayoutTreeListData::InsertEntryForItem(ScItemValue* pItemValue, sal_uLong nPosition)
     195             : {
     196           0 :     ScItemValue* pDataItemValue = new ScItemValue(pItemValue);
     197           0 :     pDataItemValue->mpOriginalItemValue = pItemValue;
     198           0 :     maDataItemValues.push_back(pDataItemValue);
     199             : 
     200           0 :     ScPivotFuncData& rFunctionData = pDataItemValue->maFunctionData;
     201             : 
     202           0 :     if (rFunctionData.mnFuncMask == PIVOT_FUNC_NONE ||
     203           0 :         rFunctionData.mnFuncMask == PIVOT_FUNC_AUTO)
     204             :     {
     205           0 :         rFunctionData.mnFuncMask = PIVOT_FUNC_SUM;
     206             :     }
     207             : 
     208           0 :     AdjustDuplicateCount(pDataItemValue);
     209             : 
     210             :     OUString sDataName = lclCreateDataItemName(
     211             :                             rFunctionData.mnFuncMask,
     212             :                             pDataItemValue->maName,
     213           0 :                             rFunctionData.mnDupCount);
     214             : 
     215           0 :     InsertEntry(sDataName, NULL, false, nPosition, pDataItemValue);
     216           0 : }
     217             : 
     218           0 : void ScPivotLayoutTreeListData::AdjustDuplicateCount(ScItemValue* pInputItemValue)
     219             : {
     220           0 :     ScPivotFuncData& rInputFunctionData = pInputItemValue->maFunctionData;
     221             : 
     222           0 :     bool bFoundDuplicate = false;
     223             : 
     224           0 :     rInputFunctionData.mnDupCount = 0;
     225           0 :     sal_uInt8 nMaxDuplicateCount = 0;
     226             : 
     227             :     SvTreeListEntry* pEachEntry;
     228           0 :     for (pEachEntry = First(); pEachEntry != NULL; pEachEntry = Next(pEachEntry))
     229             :     {
     230           0 :         ScItemValue* pItemValue = (ScItemValue*) pEachEntry->GetUserData();
     231           0 :         if (pItemValue == pInputItemValue)
     232           0 :             continue;
     233             : 
     234           0 :         ScPivotFuncData& rFunctionData = pItemValue->maFunctionData;
     235             : 
     236           0 :         if (rFunctionData.mnCol      == rInputFunctionData.mnCol &&
     237           0 :             rFunctionData.mnFuncMask == rInputFunctionData.mnFuncMask)
     238             :         {
     239           0 :             bFoundDuplicate = true;
     240           0 :             if(rFunctionData.mnDupCount > nMaxDuplicateCount)
     241           0 :                 nMaxDuplicateCount = rFunctionData.mnDupCount;
     242             :         }
     243             :     }
     244             : 
     245           0 :     if(bFoundDuplicate)
     246             :     {
     247           0 :         rInputFunctionData.mnDupCount = nMaxDuplicateCount + 1;
     248             :     }
     249           0 : }
     250             : 
     251           0 : void ScPivotLayoutTreeListData::KeyInput(const KeyEvent& rKeyEvent)
     252             : {
     253           0 :     KeyCode aCode = rKeyEvent.GetKeyCode();
     254           0 :     sal_uInt16 nCode = aCode.GetCode();
     255             : 
     256           0 :     switch (nCode)
     257             :     {
     258             :         case KEY_DELETE:
     259           0 :             GetModel()->Remove(GetCurEntry());
     260           0 :             return;
     261             :     }
     262           0 :     SvTreeListBox::KeyInput(rKeyEvent);
     263           0 : }
     264             : 
     265             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10