PageRenderTime 58ms CodeModel.GetById 21ms RepoModel.GetById 0ms app.codeStats 1ms

/libreoffice-3.6.0.2/binfilter/bf_sc/source/core/data/sc_pivot.cxx

#
C++ | 1213 lines | 985 code | 68 blank | 160 comment | 238 complexity | 7e95a92e6a1d5dde847b35e8a329e7af MD5 | raw file
Possible License(s): MPL-2.0-no-copyleft-exception, LGPL-2.1, AGPL-1.0, BSD-3-Clause-No-Nuclear-License-2014, GPL-3.0, LGPL-3.0 
    

  1. /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
    2. 

  2. /*************************************************************************
    3. 

  3.  *
    4. 

  4.  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    5. 

  5.  *
    6. 

  6.  * Copyright 2000, 2010 Oracle and/or its affiliates.
    7. 

  7.  *
    8. 

  8.  * OpenOffice.org - a multi-platform office productivity suite
    9. 

  9.  *
    10. 

  10.  * This file is part of OpenOffice.org.
    11. 

  11.  *
    12. 

  12.  * OpenOffice.org is free software: you can redistribute it and/or modify
    13. 

  13.  * it under the terms of the GNU Lesser General Public License version 3
    14. 

  14.  * only, as published by the Free Software Foundation.
    15. 

  15.  *
    16. 

  16.  * OpenOffice.org is distributed in the hope that it will be useful,
    17. 

  17.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
    18. 

  18.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    19. 

  19.  * GNU Lesser General Public License version 3 for more details
    20. 

  20.  * (a copy is included in the LICENSE file that accompanied this code).
    21. 

  21.  *
    22. 

  22.  * You should have received a copy of the GNU Lesser General Public License
    23. 

  23.  * version 3 along with OpenOffice.org.  If not, see
    24. 

  24.  * <http://www.openoffice.org/license.html>
    25. 

  25.  * for a copy of the LGPLv3 License.
    26. 

  26.  *
    27. 

  27.  ************************************************************************/
    28. 

  28. 

  29. #ifdef _MSC_VER
    30. 

  30. #pragma hdrstop
    31. 

  31. #endif
    32. 

  32. 

  33. // -----------------------------------------------------------------------
    34. 

  34. 

  35. #ifdef _MSC_VER
    36. 

  36. #pragma optimize("",off)
    37. 

  37. #endif
    38. 

  38. #ifdef _MSC_VER
    39. 

  39. #pragma optimize("q",off) // p-code off
    40. 

  40. #endif
    41. 

  41. 

  42. 

  43. // INCLUDE ---------------------------------------------------------------
    44. 

  44. 

  45. #include <bf_svtools/bf_solar.h>
    46. 

  46. #include <string.h>
    47. 

  47. #include <math.h>
    48. 

  48. 

  49. 

  50. #include "globstr.hrc"
    51. 

  51. #include "subtotal.hxx"
    52. 

  52. #include "docpool.hxx"
    53. 

  53. #include "document.hxx"
    54. 

  54. #include "userlist.hxx"
    55. 

  55. #include "pivot.hxx"
    56. 

  56. #include "cell.hxx"
    57. 

  57. #include "rechead.hxx"
    58. 

  58. namespace binfilter {
    59. 

  59. 

  60. 

  61. // STATIC DATA -----------------------------------------------------------
    62. 

  62. 

  63. //! bei Gelegenheit...
    64. 

  64. 

  65. static short    nStaticStrRefCount = 0;
    66. 

  66. static String*  pLabel[PIVOT_MAXFUNC+1];            // incl. "auto"
    67. 

  67. static String*  pLabelTotal;
    68. 

  68. static String*  pLabelData;
    69. 

  69. 

  70. static USHORT nDataMult = 1;
    71. 

  71. 

  72. #define nFirstLine  2
    73. 

  73. 

  74. static const USHORT nFuncMaskArr[PIVOT_MAXFUNC+1] =
    75. 

  75.     {   PIVOT_FUNC_SUM,
    76. 

  76.         PIVOT_FUNC_COUNT,
    77. 

  77.         PIVOT_FUNC_AVERAGE,
    78. 

  78.         PIVOT_FUNC_MAX,
    79. 

  79.         PIVOT_FUNC_MIN,
    80. 

  80.         PIVOT_FUNC_PRODUCT,
    81. 

  81.         PIVOT_FUNC_COUNT_NUM,
    82. 

  82.         PIVOT_FUNC_STD_DEV,
    83. 

  83.         PIVOT_FUNC_STD_DEVP,
    84. 

  84.         PIVOT_FUNC_STD_VAR,
    85. 

  85.         PIVOT_FUNC_STD_VARP,
    86. 

  86.         PIVOT_FUNC_AUTO };              // automatisch
    87. 

  87. 

  88. // -----------------------------------------------------------------------
    89. 

  89. 

  90. //  1   Filter-Knopf
    91. 

  91. //  2   Feldnamen links
    92. 

  92. //  3   "Daten" links
    93. 

  93. //  4   Feldnamen oben
    94. 

  94. //  5   "Daten" oben
    95. 

  95. //  6   einzelne "Gesamt" oben rechts
    96. 

  96. //  7   "Gesamt" oben rechts
    97. 

  97. //  8   einzelne "Gesamt" unten links
    98. 

  98. //  9   "Gesamt" unten links
    99. 

  99. //  10  innere Kategorie links
    100. 

  100. //  11  Teilergebnis Label einzeln links
    101. 

  101. //  12  Teilergebnis Label gesamt links
    102. 

  102. //  13  letzte Kategorie links
    103. 

  103. //  14  innere Kategorie oben
    104. 

  104. //  15  Teilergebnis Label einzeln oben
    105. 

  105. //  16  Teilergebnis Label gesamt oben
    106. 

  106. //  17  letzte Kategorie oben
    107. 

  107. //  18  Werte innen
    108. 

  108. //  19  Werte in Teilergebnisspalte
    109. 

  109. //  20  Werte in Gesamt-Spalte
    110. 

  110. //  21  Werte in einzelnen Gesamt-Spalten
    111. 

  111. //  22  Werte in Ergebnis-Zeile Teilergebnis oder Gesamt
    112. 

  112. //  23  Kreuzung von Spalte/Zeile (Teilergebnis-Spalte)
    113. 

  113. //  24  Kreuzung von Spalte/Zeile (Gesamt-Spalte)
    114. 

  114. //  25  wie 24 bei einzelnen "Gesamt"
    115. 

  115. 

  116. 

  117. 

  118. /*N*/ ScPivot::ScPivot(ScDocument* pDocument) :
    119. 

  119. /*N*/   pDoc            (pDocument),
    120. 

  120. /*N*/   aQuery          (),
    121. 

  121. /*N*/   bHasHeader      (FALSE),
    122. 

  122. /*N*/   bIgnoreEmpty    (FALSE),
    123. 

  123. /*N*/   bDetectCat      (FALSE),
    124. 

  124. /*N*/   bMakeTotalCol   (TRUE),
    125. 

  125. /*N*/   bMakeTotalRow   (TRUE),
    126. 

  126. /*N*/   nColNameCount   (0),
    127. 

  127. /*N*/   pColNames       (NULL),
    128. 

  128. /*N*/   nSrcCol1        (0),
    129. 

  129. /*N*/   nSrcRow1        (0),
    130. 

  130. /*N*/   nSrcCol2        (0),
    131. 

  131. /*N*/   nSrcRow2        (0),
    132. 

  132. /*N*/   nSrcTab         (0),
    133. 

  133. /*N*/   nDestCol1       (0),
    134. 

  134. /*N*/   nDestRow1       (0),
    135. 

  135. /*N*/   nDestCol2       (0),
    136. 

  136. /*N*/   nDestRow2       (0),
    137. 

  137. /*N*/   nDestTab        (0),
    138. 

  138. /*N*/   nDataStartCol   (0),
    139. 

  139. /*N*/   nDataStartRow   (0),
    140. 

  140. /*N*/   nColCount       (0),
    141. 

  141. /*N*/   nRowCount       (0),
    142. 

  142. /*N*/   nDataCount      (0),
    143. 

  143. /*N*/   bValidArea      (FALSE),
    144. 

  144. /*N*/   bDataAtCol      (FALSE)
    145. 

  145. /*N*/ {
    146. 

  146. /*N*/   short i;
    147. 

  147. /*N*/   for (i=0; i<PIVOT_MAXFIELD; i++)
    148. 

  148. /*N*/   {
    149. 

  149. /*N*/       pColList[i] = new PivotStrCollection();
    150. 

  150. /*N*/       pRowList[i] = new PivotStrCollection();
    151. 

  151. /*N*/   }
    152. 

  152. /*N*/   pDataList = pColList[0];
    153. 

  153. /*N*/   ppDataArr = NULL;
    154. 

  154. /*N*/   nDataColCount = 0;
    155. 

  155. /*N*/   nDataRowCount = 0;
    156. 

  156. /*N*/   nRecCount = 0;
    157. 

  157. /*N*/   pColRef = NULL;
    158. 

  158. /*N*/
    159. 

  159. /*N*/   // Initialisierung der statischen Strings, wenn noetig
    160. 

  160. /*N*/   nStaticStrRefCount += 1;
    161. 

  161. /*N*/   if ( nStaticStrRefCount < 2 )
    162. 

  162. /*N*/   {
    163. 

  163. /*N*/       pLabelTotal = new String( ScGlobal::GetRscString(STR_PIVOT_TOTAL) );
    164. 

  164. /*N*/       pLabelData  = new String( ScGlobal::GetRscString(STR_PIVOT_DATA) );
    165. 

  165. /*N*/
    166. 

  166. /*N*/       for ( i=0; i<=PIVOT_MAXFUNC; i++ )          //  incl. "auto"
    167. 

  167. /*N*/           pLabel[i] = new String;                 //  kein Leerzeichen
    168. 

  168. /*N*/
    169. 

  169. /*N*/       *pLabel[ 0] = ScGlobal::GetRscString(STR_FUN_TEXT_SUM);
    170. 

  170. /*N*/       *pLabel[ 1] = ScGlobal::GetRscString(STR_FUN_TEXT_COUNT);
    171. 

  171. /*N*/       *pLabel[ 2] = ScGlobal::GetRscString(STR_FUN_TEXT_AVG);
    172. 

  172. /*N*/       *pLabel[ 3] = ScGlobal::GetRscString(STR_FUN_TEXT_MAX);
    173. 

  173. /*N*/       *pLabel[ 4] = ScGlobal::GetRscString(STR_FUN_TEXT_MIN);
    174. 

  174. /*N*/       *pLabel[ 5] = ScGlobal::GetRscString(STR_FUN_TEXT_PRODUCT);
    175. 

  175. /*N*/       *pLabel[ 6] = ScGlobal::GetRscString(STR_FUN_TEXT_COUNT);           // Count2
    176. 

  176. /*N*/       *pLabel[ 7] = ScGlobal::GetRscString(STR_FUN_TEXT_STDDEV);
    177. 

  177. /*N*/       *pLabel[ 8] = ScGlobal::GetRscString(STR_FUN_TEXT_STDDEV);          // Stddev2
    178. 

  178. /*N*/       *pLabel[ 9] = ScGlobal::GetRscString(STR_FUN_TEXT_VAR);
    179. 

  179. /*N*/       *pLabel[10] = ScGlobal::GetRscString(STR_FUN_TEXT_VAR);             // Var2
    180. 

  180. /*N*/       *pLabel[11] = ScGlobal::GetRscString(STR_TABLE_ERGEBNIS);
    181. 

  181. /*N*/   }
    182. 

  182. /*N*/ }
    183. 

  183. /*N*/
    184. 

  184. /*N*/ ScPivot::ScPivot(const ScPivot& rPivot): DataObject(rPivot),
    185. 

  185. /*N*/   pDoc            (rPivot.pDoc),
    186. 

  186. /*N*/   aQuery          (rPivot.aQuery),
    187. 

  187. /*N*/   bHasHeader      (rPivot.bHasHeader),
    188. 

  188. /*N*/   bIgnoreEmpty    (rPivot.bIgnoreEmpty),
    189. 

  189. /*N*/   bDetectCat      (rPivot.bDetectCat),
    190. 

  190. /*N*/   bMakeTotalCol   (rPivot.bMakeTotalCol),
    191. 

  191. /*N*/   bMakeTotalRow   (rPivot.bMakeTotalRow),
    192. 

  192. /*N*/   aName           (rPivot.aName),
    193. 

  193. /*N*/   aTag            (rPivot.aTag),
    194. 

  194. /*N*/   nColNameCount   (0),
    195. 

  195. /*N*/   pColNames       (NULL),
    196. 

  196. /*N*/   nSrcCol1        (rPivot.nSrcCol1),
    197. 

  197. /*N*/   nSrcRow1        (rPivot.nSrcRow1),
    198. 

  198. /*N*/   nSrcCol2        (rPivot.nSrcCol2),
    199. 

  199. /*N*/   nSrcRow2        (rPivot.nSrcRow2),
    200. 

  200. /*N*/   nSrcTab         (rPivot.nSrcTab),
    201. 

  201. /*N*/   nDestCol1       (rPivot.nDestCol1),
    202. 

  202. /*N*/   nDestRow1       (rPivot.nDestRow1),
    203. 

  203. /*N*/   nDestCol2       (rPivot.nDestCol2),
    204. 

  204. /*N*/   nDestRow2       (rPivot.nDestRow2),
    205. 

  205. /*N*/   nDestTab        (rPivot.nDestTab),
    206. 

  206. /*N*/   nDataStartCol   (0),
    207. 

  207. /*N*/   nDataStartRow   (0),
    208. 

  208. /*N*/   nColCount       (0),
    209. 

  209. /*N*/   nRowCount       (0),
    210. 

  210. /*N*/   nDataCount      (0),
    211. 

  211. /*N*/   bValidArea      (FALSE),
    212. 

  212. /*N*/   bDataAtCol      (FALSE)
    213. 

  213. /*N*/ {
    214. 

  214. /*N*/   if (rPivot.nColNameCount && rPivot.pColNames)
    215. 

  215. /*N*/   {
    216. 

  216. /*N*/       nColNameCount = rPivot.nColNameCount;
    217. 

  217. /*N*/       pColNames = new String[nColNameCount];
    218. 

  218. /*N*/       for (USHORT nCol=0; nCol<nColNameCount; nCol++)
    219. 

  219. /*N*/           pColNames[nCol] = rPivot.pColNames[nCol];
    220. 

  220. /*N*/   }
    221. 

  221. /*N*/
    222. 

  222. /*N*/   short i;
    223. 

  223. /*N*/   for (i=0; i<PIVOT_MAXFIELD; i++)
    224. 

  224. /*N*/   {
    225. 

  225. /*N*/       pColList[i] = new PivotStrCollection();
    226. 

  226. /*N*/       pRowList[i] = new PivotStrCollection();
    227. 

  227. /*N*/   }
    228. 

  228. /*N*/   pDataList = pColList[0];
    229. 

  229. /*N*/   ppDataArr = NULL;
    230. 

  230. /*N*/   nRecCount = 0;
    231. 

  231. /*N*/   pColRef = NULL;
    232. 

  232. /*N*/
    233. 

  233. /*N*/   SetColFields( rPivot.aColArr, rPivot.nColCount );
    234. 

  234. /*N*/   SetRowFields( rPivot.aRowArr, rPivot.nRowCount );
    235. 

  235. /*N*/   SetDataFields( rPivot.aDataArr, rPivot.nDataCount );
    236. 

  236. /*N*/
    237. 

  237. /*N*/   nStaticStrRefCount += 1;
    238. 

  238. /*N*/ }
    239. 

  239. 

  240. /*N*/ ScPivot::~ScPivot()
    241. 

  241. /*N*/ {
    242. 

  242. /*N*/   short i;
    243. 

  243. /*N*/   for (i=0; i<PIVOT_MAXFIELD; i++)
    244. 

  244. /*N*/   {
    245. 

  245. /*N*/       delete pColList[i];
    246. 

  246. /*N*/       delete pRowList[i];
    247. 

  247. /*N*/   }
    248. 

  248. /*N*/   if (ppDataArr)
    249. 

  249. /*N*/   {
    250. 

  250. /*N*/       for (i=0; i<nDataRowCount; i++)
    251. 

  251. /*N*/           delete[] ppDataArr[i];
    252. 

  252. /*N*/       delete[] ppDataArr;
    253. 

  253. /*N*/       ppDataArr = NULL;
    254. 

  254. /*N*/   }
    255. 

  255. /*N*/   delete[] pColRef;
    256. 

  256. /*N*/
    257. 

  257. /*N*/   delete[] pColNames;
    258. 

  258. /*N*/
    259. 

  259. /*N*/   // statische Strings ggF. wieder abraeumen
    260. 

  260. /*N*/   nStaticStrRefCount -= 1;
    261. 

  261. /*N*/   if ( nStaticStrRefCount == 0 )
    262. 

  262. /*N*/   {
    263. 

  263. /*N*/       delete pLabelTotal;
    264. 

  264. /*N*/       delete pLabelData;
    265. 

  265. /*N*/
    266. 

  266. /*N*/       for ( i=0; i<=PIVOT_MAXFUNC; i++ )          // incl. "auto"
    267. 

  267. /*N*/           delete pLabel[i];
    268. 

  268. /*N*/   }
    269. 

  269. /*N*/ }
    270. 

  270. 

  271. 

  272. /*N*/ void lcl_LoadFieldArr30( SvStream& rStream, PivotField* pField, USHORT nCount )
    273. 

  273. /*N*/ {
    274. 

  274. /*N*/   USHORT i;
    275. 

  275. /*N*/
    276. 

  276. /*N*/   for (i=0; i<nCount; i++)
    277. 

  277. /*N*/   {
    278. 

  278. /*N*/       rStream >> pField[i].nCol
    279. 

  279. /*N*/               >> pField[i].nFuncMask
    280. 

  280. /*N*/               >> pField[i].nFuncCount;
    281. 

  281. /*N*/   }
    282. 

  282. /*N*/ }
    283. 

  283. 

  284. /*N*/ void lcl_LoadFieldArr( SvStream& rStream, PivotField* pField, USHORT nCount )
    285. 

  285. /*N*/ {
    286. 

  286. /*N*/   USHORT i;
    287. 

  287. /*N*/
    288. 

  288. /*N*/   for (i=0; i<nCount; i++)
    289. 

  289. /*N*/   {
    290. 

  290. /*N*/       BYTE cData;
    291. 

  291. /*N*/       rStream >> cData;
    292. 

  292. /*N*/       if( cData & 0x0F )
    293. 

  293. /*N*/           rStream.SeekRel( cData & 0x0F );
    294. 

  294. /*N*/       rStream >> pField[i].nCol
    295. 

  295. /*N*/               >> pField[i].nFuncMask
    296. 

  296. /*N*/               >> pField[i].nFuncCount;
    297. 

  297. /*N*/   }
    298. 

  298. /*N*/ }
    299. 

  299. 

  300. //  nach Load muessen Daten neu berechnet werden !
    301. 

  301. 

  302. /*N*/ BOOL ScPivot::Load( SvStream& rStream, ScMultipleReadHeader& rHdr )
    303. 

  303. /*N*/ {
    304. 

  304. /*N*/   rHdr.StartEntry();
    305. 

  305. /*N*/
    306. 

  306. /*N*/   rStream >> bHasHeader
    307. 

  307. /*N*/
    308. 

  308. /*N*/           >> nSrcCol1
    309. 

  309. /*N*/           >> nSrcRow1
    310. 

  310. /*N*/           >> nSrcCol2
    311. 

  311. /*N*/           >> nSrcRow2
    312. 

  312. /*N*/           >> nSrcTab
    313. 

  313. /*N*/
    314. 

  314. /*N*/           >> nDestCol1
    315. 

  315. /*N*/           >> nDestRow1
    316. 

  316. /*N*/           >> nDestCol2
    317. 

  317. /*N*/           >> nDestRow2
    318. 

  318. /*N*/           >> nDestTab;
    319. 

  319. /*N*/
    320. 

  320. /*N*/                       //  Arrays immer ueber Set...Fields initalisieren!
    321. 

  321. /*N*/
    322. 

  322. /*N*/   short nCount;
    323. 

  323. /*N*/   PivotFieldArr aFieldArr;
    324. 

  324. /*N*/
    325. 

  325. /*N*/   if( pDoc->GetSrcVersion() >= SC_DATABYTES2 )
    326. 

  326. /*N*/   {
    327. 

  327. /*N*/       rStream >> nCount;
    328. 

  328. /*N*/       lcl_LoadFieldArr( rStream, aFieldArr, nCount );
    329. 

  329. /*N*/       SetColFields(aFieldArr, nCount);
    330. 

  330. /*N*/
    331. 

  331. /*N*/       rStream >> nCount;
    332. 

  332. /*N*/       lcl_LoadFieldArr( rStream, aFieldArr, nCount );
    333. 

  333. /*N*/       SetRowFields(aFieldArr, nCount);
    334. 

  334. /*N*/
    335. 

  335. /*N*/       rStream >> nCount;
    336. 

  336. /*N*/       lcl_LoadFieldArr( rStream, aFieldArr, nCount );
    337. 

  337. /*N*/       SetDataFields(aFieldArr, nCount);
    338. 

  338. /*N*/   }
    339. 

  339. /*N*/   else
    340. 

  340. /*N*/   {
    341. 

  341. /*N*/       rStream >> nCount;
    342. 

  342. /*N*/       lcl_LoadFieldArr30( rStream, aFieldArr, nCount );
    343. 

  343. /*N*/       SetColFields(aFieldArr, nCount);
    344. 

  344. /*N*/
    345. 

  345. /*N*/       rStream >> nCount;
    346. 

  346. /*N*/       lcl_LoadFieldArr30( rStream, aFieldArr, nCount );
    347. 

  347. /*N*/       SetRowFields(aFieldArr, nCount);
    348. 

  348. /*N*/
    349. 

  349. /*N*/       rStream >> nCount;
    350. 

  350. /*N*/       lcl_LoadFieldArr30( rStream, aFieldArr, nCount );
    351. 

  351. /*N*/       SetDataFields(aFieldArr, nCount);
    352. 

  352. /*N*/   }
    353. 

  353. /*N*/
    354. 

  354. /*N*/   aQuery.Load( rStream );
    355. 

  355. /*N*/
    356. 

  356. /*N*/   rStream >> bIgnoreEmpty;
    357. 

  357. /*N*/   rStream >> bDetectCat;
    358. 

  358. /*N*/
    359. 

  359. /*N*/   if (rHdr.BytesLeft())
    360. 

  360. /*N*/   {
    361. 

  361. /*N*/       rStream >> bMakeTotalCol;       // ab 355i
    362. 

  362. /*N*/       rStream >> bMakeTotalRow;
    363. 

  363. /*N*/   }
    364. 

  364. /*N*/
    365. 

  365. /*N*/   if (rHdr.BytesLeft())               // ab 500a
    366. 

  366. /*N*/   {
    367. 

  367. /*N*/       aName = rStream.ReadUniOrByteString( rStream.GetStreamCharSet() );
    368. 

  368. /*N*/       aTag = rStream.ReadUniOrByteString( rStream.GetStreamCharSet() );
    369. 

  369. /*N*/
    370. 

  370. /*N*/       DBG_ASSERT(!pColNames, "Spaltennamen schon gesetzt?");
    371. 

  371. /*N*/       rStream >> nColNameCount;
    372. 

  372. /*N*/       if (nColNameCount)
    373. 

  373. /*N*/       {
    374. 

  374. /*N*/           pColNames = new String[nColNameCount];
    375. 

  375. /*N*/           for (USHORT nCol=0; nCol<nColNameCount; nCol++)
    376. 

  376. /*N*/               pColNames[nCol] = rStream.ReadUniOrByteString( rStream.GetStreamCharSet() );
    377. 

  377. /*N*/       }
    378. 

  378. /*N*/   }
    379. 

  379. /*N*/   // sonst wird hinterher aus ScPivotCollection::Load ein Name vergeben
    380. 

  380. /*N*/
    381. 

  381. /*N*/   rHdr.EndEntry();
    382. 

  382. /*N*/   return TRUE;
    383. 

  383. /*N*/ }
    384. 

  384. 

  385. /*N*/ void ScPivot::SetQuery(const ScQueryParam& rQuery)
    386. 

  386. /*N*/ {
    387. 

  387. /*N*/   aQuery = rQuery;
    388. 

  388. /*N*/
    389. 

  389. /*N*/   bValidArea = FALSE;
    390. 

  390. /*N*/ }
    391. 

  391. 

  392. /*N*/ void ScPivot::GetQuery(ScQueryParam& rQuery) const
    393. 

  393. /*N*/ {
    394. 

  394. /*N*/   rQuery = aQuery;
    395. 

  395. /*N*/ }
    396. 

  396. 

  397. /*N*/ void ScPivot::SetHeader(BOOL bHeader)
    398. 

  398. /*N*/ {
    399. 

  399. /*N*/   bHasHeader = bHeader;
    400. 

  400. /*N*/   bValidArea = FALSE;
    401. 

  401. /*N*/ }
    402. 

  402. 

  403. 

  404. /*N*/ void ScPivot::SetIgnoreEmpty(BOOL bIgnore)
    405. 

  405. /*N*/ {
    406. 

  406. /*N*/   bIgnoreEmpty = bIgnore;
    407. 

  407. /*N*/   bValidArea   = FALSE;
    408. 

  408. /*N*/ }
    409. 

  409. 

  410. /*N*/ BOOL ScPivot::GetIgnoreEmpty() const
    411. 

  411. /*N*/ {
    412. 

  412. /*N*/   return bIgnoreEmpty;
    413. 

  413. /*N*/ }
    414. 

  414. 

  415. /*N*/ void ScPivot::SetDetectCat(BOOL bDetect)
    416. 

  416. /*N*/ {
    417. 

  417. /*N*/   bDetectCat = bDetect;
    418. 

  418. /*N*/   bValidArea = FALSE;
    419. 

  419. /*N*/ }
    420. 

  420. 

  421. /*N*/ BOOL ScPivot::GetDetectCat() const
    422. 

  422. /*N*/ {
    423. 

  423. /*N*/   return bDetectCat;
    424. 

  424. /*N*/ }
    425. 

  425. 

  426. /*N*/ void ScPivot::SetMakeTotalCol(BOOL bSet)
    427. 

  427. /*N*/ {
    428. 

  428. /*N*/   bMakeTotalCol = bSet;
    429. 

  429. /*N*/   bValidArea    = FALSE;
    430. 

  430. /*N*/ }
    431. 

  431. 

  432. /*N*/ BOOL ScPivot::GetMakeTotalCol() const
    433. 

  433. /*N*/ {
    434. 

  434. /*N*/   return bMakeTotalCol;
    435. 

  435. /*N*/ }
    436. 

  436. 

  437. /*N*/ void ScPivot::SetMakeTotalRow(BOOL bSet)
    438. 

  438. /*N*/ {
    439. 

  439. /*N*/   bMakeTotalRow = bSet;
    440. 

  440. /*N*/   bValidArea    = FALSE;
    441. 

  441. /*N*/ }
    442. 

  442. 

  443. /*N*/ BOOL ScPivot::GetMakeTotalRow() const
    444. 

  444. /*N*/ {
    445. 

  445. /*N*/   return bMakeTotalRow;
    446. 

  446. /*N*/ }
    447. 

  447. 

  448. /*N*/ void ScPivot::SetName(const String& rNew)
    449. 

  449. /*N*/ {
    450. 

  450. /*N*/   aName = rNew;
    451. 

  451. /*N*/ }
    452. 

  452. 

  453. /*N*/ const String& ScPivot::GetName() const
    454. 

  454. /*N*/ {
    455. 

  455. /*N*/   return aName;
    456. 

  456. /*N*/ }
    457. 

  457. 

  458. /*N*/ void ScPivot::SetTag(const String& rNew)
    459. 

  459. /*N*/ {
    460. 

  460. /*N*/   aTag = rNew;
    461. 

  461. /*N*/ }
    462. 

  462. 

  463. /*N*/ const String& ScPivot::GetTag() const
    464. 

  464. /*N*/ {
    465. 

  465. /*N*/   return aTag;
    466. 

  466. /*N*/ }
    467. 

  467. 

  468. /*N*/ void ScPivot::SetSrcArea(USHORT nCol1, USHORT nRow1, USHORT nCol2, USHORT nRow2, USHORT nTab)
    469. 

  469. /*N*/ {
    470. 

  470. /*N*/   nSrcCol1 = Min(nCol1, (USHORT)MAXCOL);
    471. 

  471. /*N*/   nSrcRow1 = Min(nRow1, (USHORT)MAXROW);
    472. 

  472. /*N*/   nSrcCol2 = Min(nCol2, (USHORT)MAXCOL);
    473. 

  473. /*N*/   nSrcRow2 = Min(nRow2, (USHORT)MAXROW);
    474. 

  474. /*N*/   nSrcTab = nTab;
    475. 

  475. /*N*/   bValidArea = FALSE;
    476. 

  476. /*N*/ }
    477. 

  477. 

  478. /*N*/ void ScPivot::GetSrcArea(USHORT& rCol1, USHORT& rRow1, USHORT& rCol2, USHORT& rRow2, USHORT& rTab) const
    479. 

  479. /*N*/ {
    480. 

  480. /*N*/   rCol1 = nSrcCol1;
    481. 

  481. /*N*/   rRow1 = nSrcRow1;
    482. 

  482. /*N*/   rCol2 = nSrcCol2;
    483. 

  483. /*N*/   rRow2 = nSrcRow2;
    484. 

  484. /*N*/   rTab = nSrcTab;
    485. 

  485. /*N*/ }
    486. 

  486. 

  487. /*N*/ ScRange ScPivot::GetSrcArea() const
    488. 

  488. /*N*/ {
    489. 

  489. /*N*/   return ScRange( nSrcCol1,nSrcRow1,nSrcTab, nSrcCol2,nSrcRow2,nSrcTab );
    490. 

  490. /*N*/ }
    491. 

  491. 

  492. /*N*/ void ScPivot::SetDestPos(USHORT nCol, USHORT nRow, USHORT nTab)
    493. 

  493. /*N*/ {
    494. 

  494. /*N*/   nDestCol1 = nCol;
    495. 

  495. /*N*/   nDestRow1 = nRow;
    496. 

  496. /*N*/   nDestTab = nTab;
    497. 

  497. /*N*/   bValidArea = FALSE;
    498. 

  498. /*N*/ }
    499. 

  499. 

  500. /*N*/ void ScPivot::GetDestArea(USHORT& rCol1, USHORT& rRow1, USHORT& rCol2, USHORT& rRow2, USHORT& rTab) const
    501. 

  501. /*N*/ {
    502. 

  502. /*N*/   rCol1 = nDestCol1;
    503. 

  503. /*N*/   rRow1 = nDestRow1;
    504. 

  504. /*N*/   rTab = nDestTab;
    505. 

  505. /*N*/   if (bValidArea)
    506. 

  506. /*N*/   {
    507. 

  507. /*N*/       rCol2 = nDestCol2;
    508. 

  508. /*N*/       rRow2 = nDestRow2;
    509. 

  509. /*N*/   }
    510. 

  510. /*N*/   else
    511. 

  511. /*N*/   {
    512. 

  512. /*N*/       rCol2 = nDestCol1;
    513. 

  513. /*N*/       rRow2 = nDestRow1;
    514. 

  514. /*N*/   }
    515. 

  515. /*N*/ }
    516. 

  516. 

  517. /*N*/ ScRange ScPivot::GetDestArea() const
    518. 

  518. /*N*/ {
    519. 

  519. /*N*/   ScAddress aStart( nDestCol1, nDestRow1, nDestTab );
    520. 

  520. /*N*/   ScAddress aEnd = aStart;
    521. 

  521. /*N*/   if ( bValidArea )
    522. 

  522. /*N*/       aEnd = ScAddress( nDestCol2, nDestRow2, nDestTab );
    523. 

  523. /*N*/   return ScRange( aStart, aEnd );
    524. 

  524. /*N*/ }
    525. 

  525. 

  526. /*N*/ void ScPivot::MoveSrcArea( USHORT nNewCol, USHORT nNewRow, USHORT nNewTab )
    527. 

  527. /*N*/ {
    528. 

  528. /*N*/   if ( nNewCol != nSrcCol1 || nNewRow != nSrcRow1 || nNewTab != nSrcTab )
    529. 

  529. /*N*/   {
    530. 

  530. /*N*/       USHORT i;
    531. 

  531. /*N*/       short nDiffX = nNewCol - (short) nSrcCol1;
    532. 

  532. /*N*/       short nDiffY = nNewRow - (short) nSrcRow1;
    533. 

  533. /*N*/
    534. 

  534. /*N*/       nSrcTab = nNewTab;
    535. 

  535. /*N*/       nSrcCol1 += nDiffX;
    536. 

  536. /*N*/       nSrcCol2 += nDiffX;
    537. 

  537. /*N*/       nSrcRow1 += nDiffY;
    538. 

  538. /*N*/       nSrcRow2 += nDiffY;
    539. 

  539. /*N*/
    540. 

  540. /*N*/       aQuery.nCol1 += nDiffX;
    541. 

  541. /*N*/       aQuery.nCol2 += nDiffX;
    542. 

  542. /*N*/       aQuery.nRow1 += nDiffY;
    543. 

  543. /*N*/       aQuery.nRow2 += nDiffY;
    544. 

  544. /*N*/
    545. 

  545. /*N*/       USHORT nEC = aQuery.GetEntryCount();
    546. 

  546. /*N*/       for (i=0; i<nEC; i++)
    547. 

  547. /*N*/           if (aQuery.GetEntry(i).bDoQuery)
    548. 

  548. /*N*/               aQuery.GetEntry(i).nField += nDiffX;
    549. 

  549. /*N*/
    550. 

  550. /*N*/       if (bValidArea)
    551. 

  551. /*N*/       {
    552. 

  552. /*N*/           short nC;
    553. 

  553. /*N*/           for (nC=0; nC<nColCount; nC++)
    554. 

  554. /*N*/               if (aColArr[nC].nCol != PIVOT_DATA_FIELD)
    555. 

  555. /*N*/                   aColArr[nC].nCol += nDiffX;
    556. 

  556. /*N*/           for (nC=0; nC<nRowCount; nC++)
    557. 

  557. /*N*/               if (aRowArr[nC].nCol != PIVOT_DATA_FIELD)
    558. 

  558. /*N*/                   aRowArr[nC].nCol += nDiffX;
    559. 

  559. /*N*/           for (nC=0; nC<nDataCount; nC++)
    560. 

  560. /*N*/               if (aDataArr[nC].nCol != PIVOT_DATA_FIELD)
    561. 

  561. /*N*/                   aDataArr[nC].nCol += nDiffX;
    562. 

  562. /*N*/       }
    563. 

  563. /*N*/   }
    564. 

  564. /*N*/ }
    565. 

  565. 

  566. 

  567. /*N*/ void ScPivot::MoveDestArea( USHORT nNewCol, USHORT nNewRow, USHORT nNewTab )
    568. 

  568. /*N*/ {
    569. 

  569. /*N*/   if ( nNewCol != nDestCol1 || nNewRow != nDestRow1 || nNewTab != nDestTab )
    570. 

  570. /*N*/   {
    571. 

  571. /*N*/       short nDiffX = nNewCol - (short) nDestCol1;
    572. 

  572. /*N*/       short nDiffY = nNewRow - (short) nDestRow1;
    573. 

  573. /*N*/
    574. 

  574. /*N*/       nDestTab = nNewTab;
    575. 

  575. /*N*/       nDestCol1 += nDiffX;
    576. 

  576. /*N*/       nDestRow1 += nDiffY;
    577. 

  577. /*N*/
    578. 

  578. /*N*/       if (bValidArea)
    579. 

  579. /*N*/       {
    580. 

  580. /*N*/           nDestCol2 += nDiffX;
    581. 

  581. /*N*/           nDestRow2 += nDiffY;
    582. 

  582. /*N*/
    583. 

  583. /*N*/           nDataStartCol += nDiffX;
    584. 

  584. /*N*/           nDataStartRow += nDiffY;
    585. 

  585. /*N*/       }
    586. 

  586. /*N*/   }
    587. 

  587. /*N*/ }
    588. 

  588. 

  589. /*N*/ void ScPivot::SetColFields(const PivotField* pFieldArr, short nCount)
    590. 

  590. /*N*/ {
    591. 

  591. /*N*/   nColCount = Max((short)0, Min(nCount, (short)PIVOT_MAXFIELD));
    592. 

  592. /*N*/   for (short i = 0; i < nColCount; i++)
    593. 

  593. /*N*/   {
    594. 

  594. /*N*/       aColArr[i] = pFieldArr[i];
    595. 

  595. /*N*/       aColArr[i].nFuncCount = 0;
    596. 

  596. /*N*/       if (aColArr[i].nCol == PIVOT_DATA_FIELD)
    597. 

  597. /*N*/       {
    598. 

  598. /*N*/           aColArr[i].nFuncMask = PIVOT_FUNC_NONE;
    599. 

  599. /*N*/           pDataList = pColList[i];
    600. 

  600. /*N*/           bDataAtCol = TRUE;
    601. 

  601. /*N*/       }
    602. 

  602. /*N*/       else
    603. 

  603. /*N*/       {
    604. 

  604. /*N*/           for (short j=0; j<=PIVOT_MAXFUNC; j++)              // incl. "auto"
    605. 

  605. /*N*/               if (aColArr[i].nFuncMask & nFuncMaskArr[j])
    606. 

  606. /*N*/                   aColArr[i].nFuncCount++;
    607. 

  607. /*N*/       }
    608. 

  608. /*N*/   }
    609. 

  609. /*N*/   bValidArea = FALSE;
    610. 

  610. /*N*/ }
    611. 

  611. 

  612. /*N*/ void ScPivot::GetColFields(PivotField* pFieldArr, short& rCount) const
    613. 

  613. /*N*/ {
    614. 

  614. /*N*/   for (short i=0; i<nColCount; i++)
    615. 

  615. /*N*/       pFieldArr[i] = aColArr[i];
    616. 

  616. /*N*/   rCount = nColCount;
    617. 

  617. /*N*/ }
    618. 

  618. 

  619. /*N*/ void ScPivot::SetRowFields(const PivotField* pFieldArr, short nCount)
    620. 

  620. /*N*/ {
    621. 

  621. /*N*/   nRowCount = Max((short)0, Min(nCount, (short)PIVOT_MAXFIELD));
    622. 

  622. /*N*/   for (short i = 0; i < nRowCount; i++)
    623. 

  623. /*N*/   {
    624. 

  624. /*N*/       aRowArr[i] = pFieldArr[i];
    625. 

  625. /*N*/       aRowArr[i].nFuncCount = 0;
    626. 

  626. /*N*/       if (aRowArr[i].nCol == PIVOT_DATA_FIELD)
    627. 

  627. /*N*/       {
    628. 

  628. /*N*/           aRowArr[i].nFuncMask = PIVOT_FUNC_NONE;
    629. 

  629. /*N*/           pDataList = pRowList[i];
    630. 

  630. /*N*/           bDataAtCol = FALSE;
    631. 

  631. /*N*/       }
    632. 

  632. /*N*/       else
    633. 

  633. /*N*/       {
    634. 

  634. /*N*/           for (short j=0; j<=PIVOT_MAXFUNC; j++)              // incl. "auto"
    635. 

  635. /*N*/               if (aRowArr[i].nFuncMask & nFuncMaskArr[j])
    636. 

  636. /*N*/                   aRowArr[i].nFuncCount++;
    637. 

  637. /*N*/       }
    638. 

  638. /*N*/   }
    639. 

  639. /*N*/   bValidArea = FALSE;
    640. 

  640. /*N*/ }
    641. 

  641. 

  642. /*N*/ void ScPivot::GetRowFields(PivotField* pFieldArr, short& rCount) const
    643. 

  643. /*N*/ {
    644. 

  644. /*N*/   for (short i=0; i<nRowCount; i++)
    645. 

  645. /*N*/       pFieldArr[i] = aRowArr[i];
    646. 

  646. /*N*/   rCount = nRowCount;
    647. 

  647. /*N*/ }
    648. 

  648. 

  649. /*N*/ void ScPivot::SetDataFields(const PivotField* pFieldArr, short nCount)
    650. 

  650. /*N*/ {
    651. 

  651. /*N*/   USHORT nFuncNo;
    652. 

  652. /*N*/   short i;
    653. 

  653. /*N*/
    654. 

  654. /*N*/   //
    655. 

  655. /*N*/   //      nDataCount vorausberechnen (wie unten)
    656. 

  656. /*N*/   //
    657. 

  657. /*N*/
    658. 

  658. /*N*/   nDataCount = 0;
    659. 

  659. /*N*/   for (i = 0; i < nCount; i++)
    660. 

  660. /*N*/       for (nFuncNo=0; nFuncNo<PIVOT_MAXFUNC; nFuncNo++)
    661. 

  661. /*N*/           if (pFieldArr[i].nFuncMask & nFuncMaskArr[nFuncNo])
    662. 

  662. /*N*/               if (nDataCount+1 < PIVOT_MAXFIELD)
    663. 

  663. /*N*/                   ++nDataCount;
    664. 

  664. /*N*/
    665. 

  665. /*N*/   //
    666. 

  666. /*N*/   //      Eintraege anpassen
    667. 

  667. /*N*/   //
    668. 

  668. /*N*/
    669. 

  669. /*N*/   if ((nRowCount == 1) && (aRowArr[0].nCol == PIVOT_DATA_FIELD) && (nDataCount == 1))
    670. 

  670. /*N*/   {
    671. 

  671. /*?*/       aColArr[nColCount] = aRowArr[0];
    672. 

  672. /*?*/       pDataList = pColList[nColCount];
    673. 

  673. /*?*/       nColCount++;
    674. 

  674. /*?*/       nRowCount--;
    675. 

  675. /*?*/       bDataAtCol = TRUE;
    676. 

  676. /*N*/   }
    677. 

  677. /*N*/   if ((nColCount == 1) && (aColArr[0].nCol == PIVOT_DATA_FIELD) && (nDataCount == 1))
    678. 

  678. /*N*/   {
    679. 

  679. /*?*/       aRowArr[nRowCount] = aColArr[0];
    680. 

  680. /*?*/       pDataList = pRowList[nRowCount];
    681. 

  681. /*?*/       nRowCount++;
    682. 

  682. /*?*/       nColCount--;
    683. 

  683. /*?*/       bDataAtCol = FALSE;
    684. 

  684. /*N*/   }
    685. 

  685. /*N*/
    686. 

  686. /*N*/   if ((nDataCount == 1)
    687. 

  687. /*N*/       && (aColArr[nColCount-1].nCol != PIVOT_DATA_FIELD)
    688. 

  688. /*N*/       && (aColArr[nRowCount-1].nCol != PIVOT_DATA_FIELD))
    689. 

  689. /*N*/   {
    690. 

  690. /*?*/       if (bDataAtCol)
    691. 

  691. /*?*/       {
    692. 

  692. /*?*/           PivotField aField;
    693. 

  693. /*?*/           short nIndex = PIVOT_MAXFIELD;
    694. 

  694. /*?*/           for (i=0; i<nColCount; i++)
    695. 

  695. /*?*/           {
    696. 

  696. /*?*/               if (aColArr[i].nCol == PIVOT_DATA_FIELD)
    697. 

  697. /*?*/               {
    698. 

  698. /*?*/                   aField = aColArr[i];
    699. 

  699. /*?*/                   nIndex = i;
    700. 

  700. /*?*/               }
    701. 

  701. /*?*/           }
    702. 

  702. /*?*/           DBG_ASSERT(nIndex < PIVOT_MAXFIELD, "no data field (GPF in old versions!)");
    703. 

  703. /*?*/           if ( nIndex < PIVOT_MAXFIELD )
    704. 

  704. /*?*/           {
    705. 

  705. /*?*/               memcpy(&aColArr[nIndex], &aColArr[nIndex+1], (PIVOT_MAXFIELD - nIndex - 1) * sizeof(PivotField));
    706. 

  706. /*?*/               aColArr[nColCount-1] = aField;
    707. 

  707. /*?*/               pDataList = pColList[nColCount-1];
    708. 

  708. /*?*/           }
    709. 

  709. /*?*/       }
    710. 

  710. /*?*/       else
    711. 

  711. /*?*/       {
    712. 

  712. /*?*/           PivotField aField;
    713. 

  713. /*?*/           short nIndex = PIVOT_MAXFIELD;
    714. 

  714. /*?*/           for (i=0; i<nRowCount; i++)
    715. 

  715. /*?*/           {
    716. 

  716. /*?*/               if (aRowArr[i].nCol == PIVOT_DATA_FIELD)
    717. 

  717. /*?*/               {
    718. 

  718. /*?*/                   aField = aRowArr[i];
    719. 

  719. /*?*/                   nIndex = i;
    720. 

  720. /*?*/               }
    721. 

  721. /*?*/           }
    722. 

  722. /*?*/           DBG_ASSERT(nIndex < PIVOT_MAXFIELD, "no data field (GPF in old versions!)");
    723. 

  723. /*?*/           if ( nIndex < PIVOT_MAXFIELD )
    724. 

  724. /*?*/           {
    725. 

  725. /*?*/               memcpy(&aRowArr[nIndex], &aRowArr[nIndex+1], (PIVOT_MAXFIELD - nIndex - 1) * sizeof(PivotField));
    726. 

  726. /*?*/               aRowArr[nRowCount-1] = aField;
    727. 

  727. /*?*/               pDataList = pRowList[nRowCount-1];
    728. 

  728. /*?*/           }
    729. 

  729. /*?*/       }
    730. 

  730. /*N*/   }
    731. 

  731. /*N*/
    732. 

  732. /*N*/   //
    733. 

  733. /*N*/   //      Datenfelder in Eintraege mit nur einer Funktion aufteilen
    734. 

  734. /*N*/   //
    735. 

  735. /*N*/
    736. 

  736. /*N*/   pDataList->FreeAll();
    737. 

  737. /*N*/   nDataCount = 0;
    738. 

  738. /*N*/   for (i = 0; i < nCount; i++)
    739. 

  739. /*N*/   {
    740. 

  740. /*N*/       for (nFuncNo=0; nFuncNo<PIVOT_MAXFUNC; nFuncNo++)
    741. 

  741. /*N*/           if (pFieldArr[i].nFuncMask & nFuncMaskArr[nFuncNo])
    742. 

  742. /*N*/               if (nDataCount+1 < PIVOT_MAXFIELD)
    743. 

  743. /*N*/               {
    744. 

  744. /*N*/                   aDataArr[nDataCount] = pFieldArr[i];
    745. 

  745. /*N*/                   aDataArr[nDataCount].nFuncCount = 0;
    746. 

  746. /*N*/                   aDataArr[nDataCount].nFuncMask  = nFuncMaskArr[nFuncNo];
    747. 

  747. /*N*/
    748. 

  748. /*N*/                   String aStr;
    749. 

  749. /*N*/                   pDoc->GetString(aDataArr[nDataCount].nCol, nSrcRow1, nSrcTab, aStr);
    750. 

  750. /*N*/                   if (aStr.Len() == 0)
    751. 

  751. /*?*/                       aStr = ColToAlpha( aDataArr[nDataCount].nCol );
    752. 

  752. /*N*/                   TypedStrData* pStrData = new TypedStrData(aStr);
    753. 

  753. /*N*/                   if (!(pDataList->AtInsert(pDataList->GetCount(), pStrData)))
    754. 

  754. /*N*/                   {
    755. 

  755. /*?*/                       delete pStrData;
    756. 

  756. /*?*/                       OSL_FAIL("Fehler bei pDataList->AtInsert");
    757. 

  757. /*N*/                   }
    758. 

  758. /*N*/
    759. 

  759. /*N*/                   ++nDataCount;
    760. 

  760. /*N*/               }
    761. 

  761. /*N*/   }
    762. 

  762. /*N*/
    763. 

  763. /*N*/   //
    764. 

  764. /*N*/   //
    765. 

  765. /*N*/   //
    766. 

  766. /*N*/
    767. 

  767. /*N*/   bValidArea = FALSE;
    768. 

  768. /*N*/ }
    769. 

  769. 

  770. /*N*/ void ScPivot::GetDataFields(PivotField* pFieldArr, short& rCount) const
    771. 

  771. /*N*/ {
    772. 

  772. /*N*/   rCount = 0;
    773. 

  773. /*N*/   for (short i=0; i<nDataCount; i++)
    774. 

  774. /*N*/   {
    775. 

  775. /*N*/       BOOL bFound = FALSE;
    776. 

  776. /*N*/       for (short j=0; j<rCount && !bFound; j++)
    777. 

  777. /*?*/           if (pFieldArr[j].nCol == aDataArr[i].nCol)
    778. 

  778. /*?*/           {
    779. 

  779. /*?*/               //  add to previous column only if new bits aren't already set there
    780. 

  780. /*?*/               if ( ( pFieldArr[j].nFuncMask & aDataArr[i].nFuncMask ) == 0 )
    781. 

  781. /*?*/               {
    782. 

  782. /*?*/                   pFieldArr[j].nFuncMask |= aDataArr[i].nFuncMask;
    783. 

  783. /*?*/                   pFieldArr[j].nFuncCount++;
    784. 

  784. /*?*/                   bFound = TRUE;
    785. 

  785. /*?*/               }
    786. 

  786. /*?*/           }
    787. 

  787. /*N*/       if (!bFound)
    788. 

  788. /*N*/       {
    789. 

  789. /*N*/           pFieldArr[rCount] = aDataArr[i];
    790. 

  790. /*N*/           ++rCount;
    791. 

  791. /*N*/       }
    792. 

  792. /*N*/   }
    793. 

  793. /*N*/ }
    794. 

  794. 

  795. /*N*/ BOOL ScPivot::CreateData(BOOL bKeepDest)
    796. 

  796. /*N*/ {
    797. 

  797. /*N*/   USHORT nOldCol2 = nDestCol2;
    798. 

  798. /*N*/   USHORT nOldRow2 = nDestRow2;
    799. 

  799. /*N*/
    800. 

  800. /*N*/   pColRef = new PivotColRef[MAXCOL];
    801. 

  801. /*N*/   aQuery.nCol1 = nSrcCol1;
    802. 

  802. /*N*/   aQuery.nRow1 = nSrcRow1;
    803. 

  803. /*N*/   aQuery.nCol2 = nSrcCol2;
    804. 

  804. /*N*/   aQuery.nRow2 = nSrcRow2;
    805. 

  805. /*N*/   aQuery.bHasHeader = bHasHeader;
    806. 

  806. /*N*/   BOOL bRet = CreateFields();
    807. 

  807. /*N*/   if (bRet)
    808. 

  808. /*N*/   {
    809. 

  809. /*N*/       short i=0;                  // nDataMult berechnen - nach CreateFields, vor CreateFieldData !!!
    810. 

  810. /*N*/       nDataMult = 1;
    811. 

  811. /*N*/       if (nDataCount > 1)
    812. 

  812. /*N*/       {
    813. 

  813. /*?*/           if (bDataAtCol)
    814. 

  814. /*?*/           {
    815. 

  815. /*?*/               while (i<nColCount && aColArr[i].nCol != PIVOT_DATA_FIELD) i++;
    816. 

  816. /*?*/               i++;
    817. 

  817. /*?*/               while (i<nColCount)
    818. 

  818. /*?*/                   nDataMult *= pColList[i++]->GetCount();
    819. 

  819. /*?*/           }
    820. 

  820. /*?*/           else
    821. 

  821. /*?*/           {
    822. 

  822. /*?*/               while (i<nRowCount && aRowArr[i].nCol != PIVOT_DATA_FIELD) i++;
    823. 

  823. /*?*/               i++;
    824. 

  824. /*?*/               while (i<nRowCount)
    825. 

  825. /*?*/                   nDataMult *= pRowList[i++]->GetCount();
    826. 

  826. /*?*/           }
    827. 

  827. /*N*/       }
    828. 

  828. /*N*/       DBG_ASSERT(nDataMult,"nDataMult==0");
    829. 

  829. /*N*/
    830. 

  830. /*N*/       CalcArea();
    831. 

  831. /*N*/       if ((nDestCol2 <= MAXCOL) && (nDestRow2 <= MAXROW))
    832. 

  832. /*N*/       {
    833. 

  833. /*N*/           CreateFieldData();
    834. 

  834. /*N*/           bValidArea = TRUE;
    835. 

  835. /*N*/       }
    836. 

  836. /*N*/       else
    837. 

  837. /*N*/           bRet = FALSE;
    838. 

  838. /*N*/   }
    839. 

  839. /*N*/
    840. 

  840. /*N*/   if ( bKeepDest )
    841. 

  841. /*N*/   {
    842. 

  842. /*N*/       bValidArea = TRUE;          //! ???
    843. 

  843. /*N*/       nDestCol2 = nOldCol2;
    844. 

  844. /*N*/       nDestRow2 = nOldRow2;
    845. 

  845. /*N*/   }
    846. 

  846. /*N*/
    847. 

  847. /*N*/   return bRet;
    848. 

  848. /*N*/ }
    849. 

  849. 

  850. 

  851. /*N*/ void ScPivot::ReleaseData()
    852. 

  852. /*N*/ {
    853. 

  853. /*N*/   short i;
    854. 

  854. /*N*/   for (i = 0; i < PIVOT_MAXFIELD; i++)
    855. 

  855. /*N*/   {
    856. 

  856. /*N*/       pColList[i]->FreeAll();
    857. 

  857. /*N*/       pRowList[i]->FreeAll();
    858. 

  858. /*N*/   }
    859. 

  859. /*N*/   if (ppDataArr)
    860. 

  860. /*N*/   {
    861. 

  861. /*N*/       for (i=0; i<nDataRowCount; i++)
    862. 

  862. /*N*/           delete[] ppDataArr[i];
    863. 

  863. /*N*/       delete[] ppDataArr;
    864. 

  864. /*N*/       ppDataArr = NULL;
    865. 

  865. /*N*/   }
    866. 

  866. /*N*/   nDataColCount = 0;
    867. 

  867. /*N*/   nDataRowCount = 0;
    868. 

  868. /*N*/   delete[] pColRef;
    869. 

  869. /*N*/   pColRef = NULL;
    870. 

  870. /*N*/ }
    871. 

  871. 

  872. //--------------------------------------------------------------------------------------------------
    873. 

  873. // Private Methoden
    874. 

  874. //--------------------------------------------------------------------------------------------------
    875. 

  875. 

  876. /*N*/ BOOL ScPivot::CreateFields()
    877. 

  877. /*N*/ {
    878. 

  878. /*N*/   short   i;
    879. 

  879. /*N*/   USHORT  nRow;
    880. 

  880. /*N*/   USHORT  nHeader;
    881. 

  881. /*N*/   String  aStr;
    882. 

  882. /*N*/   TypedStrData* pStrData;
    883. 

  883. /*N*/   if (bHasHeader)
    884. 

  884. /*N*/       nHeader = 1;
    885. 

  885. /*N*/   else
    886. 

  886. /*N*/       nHeader = 0;
    887. 

  887. /*N*/
    888. 

  888. /*N*/   // Sortieren nach Benutzerdefinierte Listen ??
    889. 

  889. /*N*/   for (i = 0; i < nColCount; i++)
    890. 

  890. /*N*/   {
    891. 

  891. /*N*/       if (aColArr[i].nCol != PIVOT_DATA_FIELD)
    892. 

  892. /*N*/       {
    893. 

  893. /*N*/           pDoc->GetString(aColArr[i].nCol, nSrcRow1 + nHeader, nSrcTab, aStr);
    894. 

  894. /*N*/           pColList[i]->SetUserData(ScGlobal::GetUserList()->GetData(aStr));
    895. 

  895. /*N*/       }
    896. 

  896. /*N*/       else
    897. 

  897. /*N*/           pColList[i]->SetUserData(NULL);
    898. 

  898. /*N*/   }
    899. 

  899. /*N*/   for (i = 0; i < nRowCount; i++)
    900. 

  900. /*N*/   {
    901. 

  901. /*N*/       if (aRowArr[i].nCol != PIVOT_DATA_FIELD)
    902. 

  902. /*N*/       {
    903. 

  903. /*N*/           pDoc->GetString(aRowArr[i].nCol, nSrcRow1 + nHeader, nSrcTab, aStr);
    904. 

  904. /*N*/           pRowList[i]->SetUserData(ScGlobal::GetUserList()->GetData(aStr));
    905. 

  905. /*N*/       }
    906. 

  906. /*N*/       else
    907. 

  907. /*?*/           pRowList[i]->SetUserData(NULL);
    908. 

  908. /*N*/   }
    909. 

  909. /*N*/
    910. 

  910. /*N*/   ScAddress aSrcAdr( nSrcCol1, 0, nSrcTab );
    911. 

  911. /*N*/   for (nRow = nSrcRow1 + nHeader; nRow <= nSrcRow2; nRow++)
    912. 

  912. /*N*/   {
    913. 

  913. /*N*/       BOOL bValidLine = TRUE;
    914. 

  914. /*N*/       if (bValidLine)
    915. 

  915. /*N*/           bValidLine = pDoc->pTab[nSrcTab]->ValidQuery(nRow, aQuery);
    916. 

  916. /*N*/       if (bValidLine)
    917. 

  917. /*N*/       {
    918. 

  918. /*N*/           //  Sortierte Liste der Felder erzeugen
    919. 

  919. /*N*/           //! statt GetCategoryString leere weglassen !
    920. 

  920. /*N*/
    921. 

  921. /*N*/           for (i = 0; i < nColCount; i++)
    922. 

  922. /*N*/           {
    923. 

  923. /*N*/               if (aColArr[i].nCol != PIVOT_DATA_FIELD)
    924. 

  924. /*N*/               {
    925. 

  925. /*N*/                   USHORT nCatRow = bDetectCat ? GetCategoryRow( aColArr[i].nCol, nRow ) : nRow;
    926. 

  926. /*N*/                   pStrData = new TypedStrData( pDoc, aColArr[i].nCol, nCatRow, nSrcTab, TRUE );
    927. 

  927. /*N*/                   if (!(pColList[i]->Insert(pStrData)))
    928. 

  928. /*N*/                       delete pStrData;
    929. 

  929. /*N*/               }
    930. 

  930. /*N*/           }
    931. 

  931. /*N*/           for (i = 0; i < nRowCount; i++)
    932. 

  932. /*N*/           {
    933. 

  933. /*N*/               if (aRowArr[i].nCol != PIVOT_DATA_FIELD)
    934. 

  934. /*N*/               {
    935. 

  935. /*N*/                   USHORT nCatRow = bDetectCat ? GetCategoryRow( aRowArr[i].nCol, nRow ) : nRow;
    936. 

  936. /*N*/                   pStrData = new TypedStrData( pDoc, aRowArr[i].nCol, nCatRow, nSrcTab, TRUE );
    937. 

  937. /*N*/                   if (!(pRowList[i]->Insert(pStrData)))
    938. 

  938. /*N*/                       delete pStrData;
    939. 

  939. /*N*/               }
    940. 

  940. /*N*/           }
    941. 

  941. /*N*/       }
    942. 

  942. /*N*/   }
    943. 

  943. /*N*/   return TRUE;
    944. 

  944. /*N*/ }
    945. 

  945. 

  946. /*N*/ void ScPivot::CreateFieldData()
    947. 

  947. /*N*/ {
    948. 

  948. /*N*/   USHORT* pRowListIndex = nRowCount ? new USHORT[nRowCount] : NULL;
    949. 

  949. /*N*/   USHORT* pColListIndex = nColCount ? new USHORT[nColCount] : NULL;
    950. 

  950. /*N*/
    951. 

  951. /*N*/   short i,j,k;
    952. 

  952. /*N*/
    953. 

  953. /*N*/   ppDataArr = new SubTotal*[nDataRowCount];
    954. 

  954. /*N*/   for (i=0; i<nDataRowCount; i++)
    955. 

  955. /*N*/       ppDataArr[i] = new SubTotal[nDataColCount];
    956. 

  956. /*N*/
    957. 

  957. /*N*/   if (bDataAtCol)
    958. 

  958. /*N*/       for (j=0; j<nDataRowCount; j++)
    959. 

  959. /*N*/           for (i=0; i<nDataColCount; i++)
    960. 

  960. /*N*/               ppDataArr[j][i].nIndex = j/nDataMult%nDataCount;
    961. 

  961. /*N*/   else
    962. 

  962. /*?*/       for (j=0; j<nDataRowCount; j++)
    963. 

  963. /*?*/           for (i=0; i<nDataColCount; i++)
    964. 

  964. /*?*/               ppDataArr[j][i].nIndex = i/nDataMult%nDataCount;
    965. 

  965. /*N*/
    966. 

  966. /*N*/   short nHeader;
    967. 

  967. /*N*/   if (bHasHeader)
    968. 

  968. /*N*/       nHeader = 1;
    969. 

  969. /*N*/   else
    970. 

  970. /*N*/       nHeader = 0;
    971. 

  971. /*N*/   ScAddress aSrcAdr( nSrcCol1, 0, nSrcTab );
    972. 

  972. /*N*/   for (USHORT nRow = nSrcRow1 + nHeader; nRow <= nSrcRow2; nRow++)
    973. 

  973. /*N*/   {
    974. 

  974. /*N*/       BOOL bValidLine = TRUE;
    975. 

  975. /*N*/       if (bValidLine)
    976. 

  976. /*N*/           bValidLine = pDoc->pTab[nSrcTab]->ValidQuery(nRow, aQuery);
    977. 

  977. /*N*/       if (bValidLine)
    978. 

  978. /*N*/       {
    979. 

  979. /*N*/           //      Indizes der Kategorien nur einmal ausserhalb nDataCount
    980. 

  980. /*N*/           for (j=0; j<nRowCount; j++)
    981. 

  981. /*N*/               if (aRowArr[j].nCol != PIVOT_DATA_FIELD)
    982. 

  982. /*N*/               {
    983. 

  983. /*N*/                   USHORT nCatRow = bDetectCat ? GetCategoryRow( aRowArr[j].nCol, nRow ) : nRow;
    984. 

  984. /*N*/                   TypedStrData aStrData( pDoc, aRowArr[j].nCol, nCatRow, nSrcTab, TRUE );
    985. 

  985. /*N*/                   pRowListIndex[j] = pRowList[j]->GetIndex(&aStrData);
    986. 

  986. /*N*/               }
    987. 

  987. /*N*/           for (j=0; j<nColCount; j++)
    988. 

  988. /*N*/               if (aColArr[j].nCol != PIVOT_DATA_FIELD)
    989. 

  989. /*N*/               {
    990. 

  990. /*N*/                   USHORT nCatRow = bDetectCat ? GetCategoryRow( aColArr[j].nCol, nRow ) : nRow;
    991. 

  991. /*N*/                   TypedStrData aStrData( pDoc, aColArr[j].nCol, nCatRow, nSrcTab, TRUE );
    992. 

  992. /*N*/                   pColListIndex[j] = pColList[j]->GetIndex(&aStrData);
    993. 

  993. /*N*/               }
    994. 

  994. /*N*/
    995. 

  995. /*N*/           String aStr;
    996. 

  996. /*N*/           short nCIndex;
    997. 

  997. /*N*/           short nRIndex;
    998. 

  998. /*N*/           short nIndex;
    999. 

  999. /*N*/           ScAddress aAdr( 0, nRow, nSrcTab );
    1000. 

  1000. /*N*/
    1001. 

  1001. /*N*/           for (i=0; i<nDataCount; i++)
    1002. 

  1002. /*N*/           {
    1003. 

  1003. /*N*/               // ColIndex Berechnen
    1004. 

  1004. /*N*/               nCIndex = 0;
    1005. 

  1005. /*N*/               for (j=0; j<nRowCount; j++)
    1006. 

  1006. /*N*/               {
    1007. 

  1007. /*N*/                   if (aRowArr[j].nCol == PIVOT_DATA_FIELD)
    1008. 

  1008. /*N*/                       nIndex = i;
    1009. 

  1009. /*N*/                   else
    1010. 

  1010. /*N*/                       nIndex = pRowListIndex[j];
    1011. 

  1011. /*N*/                   if (nIndex)
    1012. 

  1012. /*N*/                   {
    1013. 

  1013. /*N*/                       for (k=j+1; k<nRowCount; k++)
    1014. 

  1014. /*?*/                           nIndex *= pRowList[k]->GetCount();
    1015. 

  1015. /*N*/                       nCIndex += nIndex;
    1016. 

  1016. /*N*/                   }
    1017. 

  1017. /*N*/               }
    1018. 

  1018. /*N*/               // RowIndex Berechnen
    1019. 

  1019. /*N*/               nRIndex = 0;
    1020. 

  1020. /*N*/               for (j=0; j<nColCount; j++)
    1021. 

  1021. /*N*/               {
    1022. 

  1022. /*N*/                   if (aColArr[j].nCol == PIVOT_DATA_FIELD)
    1023. 

  1023. /*N*/                       nIndex = i;
    1024. 

  1024. /*N*/                   else
    1025. 

  1025. /*N*/                       nIndex = pColListIndex[j];
    1026. 

  1026. /*N*/                   if (nIndex)
    1027. 

  1027. /*N*/                   {
    1028. 

  1028. /*N*/                       for (k=j+1; k<nColCount; k++)
    1029. 

  1029. /*N*/                           nIndex *= pColList[k]->GetCount();
    1030. 

  1030. /*N*/                       nRIndex += nIndex;
    1031. 

  1031. /*N*/                   }
    1032. 

  1032. /*N*/               }
    1033. 

  1033. /*N*/               //  Daten eintragen
    1034. 

  1034. /*N*/               if ((nCIndex < nDataColCount) && (nRIndex < nDataRowCount))
    1035. 

  1035. /*N*/               {
    1036. 

  1036. /*N*/                   DBG_ASSERT((short)ppDataArr[nRIndex][nCIndex].nIndex == i, "falsch init.");
    1037. 

  1037. /*N*/
    1038. 

  1038. /*N*/                   ppDataArr[nRIndex][nCIndex].nIndex = i;
    1039. 

  1039. /*N*/                   aAdr.SetCol( aDataArr[i].nCol );
    1040. 

  1040. /*N*/                   CellType eCellType = pDoc->GetCellType( aAdr );
    1041. 

  1041. /*N*/                   if ((eCellType != CELLTYPE_NONE) && (eCellType != CELLTYPE_NOTE))
    1042. 

  1042. /*N*/                   {
    1043. 

  1043. /*N*/                       BOOL bValue = (eCellType == CELLTYPE_VALUE);
    1044. 

  1044. /*N*/                       if (eCellType == CELLTYPE_FORMULA)
    1045. 

  1045. /*N*/                       {
    1046. 

  1046. /*N*/                           ScBaseCell* pCell = pDoc->GetCell( aAdr );
    1047. 

  1047. /*N*/                           bValue = ((ScFormulaCell*)pCell)->IsValue();
    1048. 

  1048. /*N*/                       }
    1049. 

  1049. /*N*/
    1050. 

  1050. /*N*/                       if (bValue)
    1051. 

  1051. /*N*/                       {
    1052. 

  1052. /*N*/                           double nVal = pDoc->GetValue( aAdr );
    1053. 

  1053. /*N*/                           ppDataArr[nRIndex][nCIndex].Update(nVal);
    1054. 

  1054. /*N*/                       }
    1055. 

  1055. /*N*/                   }
    1056. 

  1056. /*N*/               }
    1057. 

  1057. /*N*/           }
    1058. 

  1058. /*N*/       }
    1059. 

  1059. /*N*/   }
    1060. 

  1060. /*N*/
    1061. 

  1061. /*N*/   delete pColListIndex;
    1062. 

  1062. /*N*/   delete pRowListIndex;
    1063. 

  1063. /*N*/ }
    1064. 

  1064. 

  1065. /*N*/ void ScPivot::CalcArea()
    1066. 

  1066. /*N*/ {
    1067. 

  1067. /*N*/   BOOL bNoRows = (nRowCount == 0) || ( nRowCount == 1 && aRowArr[0].nCol == PIVOT_DATA_FIELD );
    1068. 

  1068. /*N*/   BOOL bNoCols = (nColCount == 0) || ( nColCount == 1 && aColArr[0].nCol == PIVOT_DATA_FIELD );
    1069. 

  1069. /*N*/   if (!bMakeTotalCol) bNoRows = TRUE;
    1070. 

  1070. /*N*/   if (!bMakeTotalRow) bNoCols = TRUE;
    1071. 

  1071. /*N*/
    1072. 

  1072. /*N*/   short i;
    1073. 

  1073. /*N*/   short nDx;
    1074. 

  1074. /*N*/   // StartSpalte/StartZeile des Datenbereichs berechnen
    1075. 

  1075. /*N*/   if (bDataAtCol)
    1076. 

  1076. /*N*/   {
    1077. 

  1077. /*N*/       if (nDataCount > 1)
    1078. 

  1078. /*?*/           nDataStartCol = nDestCol1 + nColCount;
    1079. 

  1079. /*N*/       else
    1080. 

  1080. /*N*/           nDataStartCol = nDestCol1 + Max(0, nColCount - 1);
    1081. 

  1081. /*N*/   }
    1082. 

  1082. /*N*/   else
    1083. 

  1083. /*?*/       nDataStartCol = nDestCol1 + nColCount;
    1084. 

  1084. /*N*/   if (!bDataAtCol)
    1085. 

  1085. /*N*/   {
    1086. 

  1086. /*?*/       if (nDataCount > 1)
    1087. 

  1087. /*?*/           nDataStartRow = nDestRow1 + nRowCount + nFirstLine + 1;
    1088. 

  1088. /*?*/       else
    1089. 

  1089. /*?*/           nDataStartRow = nDestRow1 + Max(0, nRowCount - 1) + nFirstLine + 1;
    1090. 

  1090. /*N*/   }
    1091. 

  1091. /*N*/   else
    1092. 

  1092. /*N*/       nDataStartRow = nDestRow1 + nRowCount + nFirstLine + 1;
    1093. 

  1093. /*N*/
    1094. 

  1094. /*N*/   //
    1095. 

  1095. /*N*/   //      Groesse der PivotTabelle berechnen
    1096. 

  1096. /*N*/   //
    1097. 

  1097. /*N*/
    1098. 

  1098. /*N*/   if (nRowCount == 0 || (nRowCount==1 && aRowArr[0].nCol==PIVOT_DATA_FIELD && nDataCount==1))
    1099. 

  1099. /*N*/   {
    1100. 

  1100. /*?*/       nDataColCount = 1;
    1101. 

  1101. /*?*/       if (nDataCount == 1)
    1102. 

  1102. /*?*/           nDestCol2 = nDestCol1 + nColCount - 1;
    1103. 

  1103. /*?*/       else
    1104. 

  1104. /*?*/           nDestCol2 = nDestCol1 + nColCount;
    1105. 

  1105. /*N*/   }
    1106. 

  1106. /*N*/   else
    1107. 

  1107. /*N*/   {
    1108. 

  1108. /*N*/       // Anzahl Spalten
    1109. 

  1109. /*N*/       if ((aRowArr[nRowCount-1].nCol == PIVOT_DATA_FIELD) && (nDataCount == 1))
    1110. 

  1110. /*N*/           nDx = 2;
    1111. 

  1111. /*N*/       else
    1112. 

  1112. /*N*/           nDx = 1;
    1113. 

  1113. /*N*/       long nColLines = pRowList[nRowCount-nDx]->GetCount();   // long um Ueberlauf zu erkennen
    1114. 

  1114. /*N*/       nDataColCount = pRowList[nRowCount-nDx]->GetCount();
    1115. 

  1115. /*N*/       for (i=nRowCount-nDx-1; i >= 0; i--)
    1116. 

  1116. /*N*/       {
    1117. 

  1117. /*?*/           nColLines *= pRowList[i]->GetCount();
    1118. 

  1118. /*?*/           nDataColCount *= pRowList[i]->GetCount();
    1119. 

  1119. /*?*/           if (!bDataAtCol)
    1120. 

  1120. /*?*/               nColLines += (pRowList[i]->GetCount() * aRowArr[i].nFuncCount * nDataCount);
    1121. 

  1121. /*?*/           else
    1122. 

  1122. /*?*/               nColLines += (pRowList[i]->GetCount() * aRowArr[i].nFuncCount);
    1123. 

  1123. /*N*/       }
    1124. 

  1124. /*N*/       if (nColLines > MAXCOL)
    1125. 

  1125. /*?*/           nDestCol2 = MAXCOL+2;   // ungueltig, 1 wird unten abgezogen
    1126. 

  1126. /*N*/       else if (bDataAtCol)
    1127. 

  1127. /*N*/       {
    1128. 

  1128. /*N*/           if (nDataCount > 1)
    1129. 

  1129. /*?*/               nDestCol2 = nDestCol1 + nColCount + nColLines;
    1130. 

  1130. /*N*/           else
    1131. 

  1131. /*N*/               nDestCol2 = nDestCol1 + (nColCount - 1) + nColLines;
    1132. 

  1132. /*N*/           if (!bMakeTotalCol)
    1133. 

  1133. /*?*/               --nDestCol2;
    1134. 

  1134. /*N*/       }
    1135. 

  1135. /*N*/       else
    1136. 

  1136. /*?*/           nDestCol2 = nDestCol1 + nColCount + nColLines;
    1137. 

  1137. /*N*/   }
    1138. 

  1138. /*N*/
    1139. 

  1139. /*N*/   if (nColCount == 0 || (nColCount==1 && aColArr[0].nCol==PIVOT_DATA_FIELD && nDataCount==1))
    1140. 

  1140. /*N*/   {
    1141. 

  1141. /*?*/       nDataRowCount = 1;
    1142. 

  1142. /*?*/       if (nDataCount == 1)
    1143. 

  1143. /*?*/           nDestRow2 = nDestRow1 + (nRowCount - 1) + nFirstLine + 1;
    1144. 

  1144. /*?*/       else
    1145. 

  1145. /*?*/           nDestRow2 = nDestRow1 + nRowCount + nFirstLine + 1;
    1146. 

  1146. /*N*/   }
    1147. 

  1147. /*N*/   else
    1148. 

  1148. /*N*/   {
    1149. 

  1149. /*N*/       // Anzahl Zeilen
    1150. 

  1150. /*N*/       if ((aColArr[nColCount-1].nCol == PIVOT_DATA_FIELD) && (nDataCount == 1))
    1151. 

  1151. /*N*/           nDx = 2;
    1152. 

  1152. /*N*/       else
    1153. 

  1153. /*N*/           nDx = 1;
    1154. 

  1154. /*N*/       long nRowLines = pColList[nColCount-nDx]->GetCount();   // long um Ueberlauf zu erkennen
    1155. 

  1155. /*N*/       nDataRowCount = pColList[nColCount-nDx]->GetCount();
    1156. 

  1156. /*N*/       for (i=nColCount-nDx-1; i >= 0; i--)
    1157. 

  1157. /*N*/       {
    1158. 

  1158. /*?*/           nRowLines *= pColList[i]->GetCount();
    1159. 

  1159. /*?*/           nDataRowCount *= pColList[i]->GetCount();
    1160. 

  1160. /*?*/           if (bDataAtCol)
    1161. 

  1161. /*?*/               nRowLines += (pColList[i]->GetCount() * aColArr[i].nFuncCount * nDataCount);
    1162. 

  1162. /*?*/           else
    1163. 

  1163. /*?*/               nRowLines += (pColList[i]->GetCount() * aColArr[i].nFuncCount);
    1164. 

  1164. /*N*/       }
    1165. 

  1165. /*N*/       if (nRowLines > MAXROW)
    1166. 

  1166. /*?*/           nDestRow2 = MAXROW+2;   // ungueltig, 1 wird unten abgezogen
    1167. 

  1167. /*N*/       else if (!bDataAtCol)
    1168. 

  1168. /*N*/       {
    1169. 

  1169. /*?*/           if (nDataCount > 1)
    1170. 

  1170. /*?*/               nDestRow2 = nDestRow1 + nRowCount + nRowLines + nFirstLine + 1;
    1171. 

  1171. /*?*/           else
    1172. 

  1172. /*?*/               nDestRow2 = nDestRow1 + (nRowCount - 1) + nRowLines + nFirstLine + 1;
    1173. 

  1173. /*?*/           if (!bMakeTotalRow)
    1174. 

  1174. /*?*/               --nDestRow2;
    1175. 

  1175. /*N*/       }
    1176. 

  1176. /*N*/       else
    1177. 

  1177. /*N*/           nDestRow2 = nDestRow1 + nRowCount + nRowLines + nFirstLine + 1;
    1178. 

  1178. /*N*/   }
    1179. 

  1179. /*N*/
    1180. 

  1180. /*N*/   if (bDataAtCol)
    1181. 

  1181. /*N*/   {
    1182. 

  1182. /*N*/       if (!bNoCols)
    1183. 

  1183. /*N*/           nDestRow2 += nDataCount;
    1184. 

  1184. /*N*/       nDestRow2 --;
    1185. 

  1185. /*N*/   }
    1186. 

  1186. /*N*/   else
    1187. 

  1187. /*N*/   {
    1188. 

  1188. /*?*/       if (!bNoRows)
    1189. 

  1189. /*?*/           nDestCol2 += nDataCount;
    1190. 

  1190. /*?*/       nDestCol2 --;
    1191. 

  1191. /*N*/   }
    1192. 

  1192. /*N*/ }
    1193. 

  1193. 

  1194. /*N*/ USHORT ScPivot::GetCategoryRow( USHORT nCol, USHORT nRow )
    1195. 

  1195. /*N*/ {
    1196. 

  1196. /*N*/   USHORT nMinRow = nSrcRow1;
    1197. 

  1197. /*N*/   if (bHasHeader) ++nMinRow;
    1198. 

  1198. /*N*/   BOOL bFound = FALSE;
    1199. 

  1199. /*N*/   do
    1200. 

  1200. /*N*/   {
    1201. 

  1201. /*N*/       if ( !pDoc->HasData( nCol, nRow, nSrcTab ) && nRow>nMinRow )
    1202. 

  1202. /*N*/           --nRow;
    1203. 

  1203. /*N*/       else
    1204. 

  1204. /*N*/           bFound = TRUE;
    1205. 

  1205. /*N*/   }
    1206. 

  1206. /*N*/   while (!bFound);
    1207. 

  1207. /*N*/   return nRow;
    1208. 

  1208. /*N*/ }
    1209. 

  1209. 

  1210. 

  1211. }
    1212. 

  1212. 

  1213. /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
    1214. 

  1214.