sc/source/core/data/global2.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: global2.cxx,v $
  10  * $Revision: 1.23.32.2 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sc.hxx"
  33
  34
  35
  36 // INCLUDE ---------------------------------------------------------------
  37
  38 #include <sfx2/docfile.hxx>
  39 #include <sfx2/objsh.hxx>
  40 #include <unotools/textsearch.hxx>
  41 #include <svtools/pathoptions.hxx>
  42 #include <svtools/useroptions.hxx>
  43 #include <tools/urlobj.hxx>
  44 #include <unotools/charclass.hxx>
  45 #include <stdlib.h>
  46 #include <ctype.h>
  47 #include <svtools/syslocale.hxx>
  48
  49 #include "global.hxx"
  50 #include "rangeutl.hxx"
  51 #include "pivot.hxx"
  52 #include "rechead.hxx"
  53 #include "compiler.hxx"
  54 #include "paramisc.hxx"
  55
  56 #include "sc.hrc"
  57 #include "globstr.hrc"
  58
  59 using ::std::vector;
  60
  61 // -----------------------------------------------------------------------
  62
  63
  64
  65 #define MAX_LABELS 256 //!!! aus fieldwnd.hxx, muss noch nach global.hxx ???
  66
  67 //------------------------------------------------------------------------
  68 // struct ScImportParam:
  69
  70 ScImportParam::ScImportParam() :
  71     nCol1(0),
  72     nRow1(0),
  73     nCol2(0),
  74     nRow2(0),
  75     bImport(FALSE),
  76     bNative(FALSE),
  77     bSql(TRUE),
  78     nType(ScDbTable)
  79 {
  80 }
  81
  82 ScImportParam::ScImportParam( const ScImportParam& r ) :
  83     nCol1               (r.nCol1),
  84     nRow1               (r.nRow1),
  85     nCol2               (r.nCol2),
  86     nRow2               (r.nRow2),
  87     bImport             (r.bImport),
  88     aDBName             (r.aDBName),
  89     aStatement  (r.aStatement),
  90     bNative             (r.bNative),
  91     bSql                (r.bSql),
  92     nType               (r.nType)
  93 {
  94 }
  95
  96 ScImportParam::~ScImportParam()
  97 {
  98 }
  99
 100 //UNUSED2009-05 void ScImportParam::Clear()
 101 //UNUSED2009-05 {
 102 //UNUSED2009-05     nCol1 = nCol2 = 0;
 103 //UNUSED2009-05     nRow1 = nRow2 = 0;
 104 //UNUSED2009-05     bImport = FALSE;
 105 //UNUSED2009-05     bNative = FALSE;
 106 //UNUSED2009-05     bSql = TRUE;
 107 //UNUSED2009-05     nType = ScDbTable;
 108 //UNUSED2009-05     aDBName.Erase();
 109 //UNUSED2009-05     aStatement.Erase();
 110 //UNUSED2009-05 }
 111
 112 ScImportParam& ScImportParam::operator=( const ScImportParam& r )
 113 {
 114     nCol1                       = r.nCol1;
 115     nRow1                       = r.nRow1;
 116     nCol2                       = r.nCol2;
 117     nRow2                       = r.nRow2;
 118     bImport                     = r.bImport;
 119     aDBName                     = r.aDBName;
 120     aStatement          = r.aStatement;
 121     bNative                     = r.bNative;
 122     bSql                        = r.bSql;
 123     nType                       = r.nType;
 124
 125     return *this;
 126 }
 127
 128 BOOL ScImportParam::operator==( const ScImportParam& rOther ) const
 129 {
 130     return(     nCol1           == rOther.nCol1 &&
 131             nRow1               == rOther.nRow1 &&
 132             nCol2               == rOther.nCol2 &&
 133             nRow2               == rOther.nRow2 &&
 134             bImport             == rOther.bImport &&
 135             aDBName             == rOther.aDBName &&
 136             aStatement  == rOther.aStatement &&
 137             bNative             == rOther.bNative &&
 138             bSql                == rOther.bSql &&
 139             nType               == rOther.nType );
 140
 141     //! nQuerySh und pConnection sind gleich ?
 142 }
 143
 144
 145 //------------------------------------------------------------------------
 146 // struct ScQueryParam:
 147
 148 ScQueryEntry::ScQueryEntry() :
 149     bDoQuery(FALSE),
 150     bQueryByString(FALSE),
 151     bQueryByDate(false),
 152     nField(0),
 153     eOp(SC_EQUAL),
 154     eConnect(SC_AND),
 155     pStr(new String),
 156     nVal(0.0),
 157     pSearchParam(NULL),
 158     pSearchText(NULL)
 159 {
 160 }
 161
 162 ScQueryEntry::ScQueryEntry(const ScQueryEntry& r) :
 163     bDoQuery(r.bDoQuery),
 164     bQueryByString(r.bQueryByString),
 165     bQueryByDate(r.bQueryByDate),
 166     nField(r.nField),
 167     eOp(r.eOp),
 168     eConnect(r.eConnect),
 169     pStr(new String(*r.pStr)),
 170     nVal(r.nVal),
 171     pSearchParam(NULL),
 172     pSearchText(NULL)
 173 {
 174 }
 175
 176 ScQueryEntry::~ScQueryEntry()
 177 {
 178     delete pStr;
 179     if ( pSearchParam )
 180     {
 181         delete pSearchParam;
 182         delete pSearchText;
 183     }
 184 }
 185
 186 ScQueryEntry& ScQueryEntry::operator=( const ScQueryEntry& r )
 187 {
 188     bDoQuery            = r.bDoQuery;
 189     bQueryByString      = r.bQueryByString;
 190     bQueryByDate    = r.bQueryByDate;
 191     eOp                         = r.eOp;
 192     eConnect            = r.eConnect;
 193     nField                      = r.nField;
 194     nVal                        = r.nVal;
 195     *pStr                       = *r.pStr;
 196     if ( pSearchParam )
 197     {
 198         delete pSearchParam;
 199         delete pSearchText;
 200     }
 201     pSearchParam        = NULL;
 202     pSearchText         = NULL;
 203
 204     return *this;
 205 }
 206
 207 void ScQueryEntry::Clear()
 208 {
 209     bDoQuery            = FALSE;
 210     bQueryByString      = FALSE;
 211     bQueryByDate    = false;
 212     eOp                         = SC_EQUAL;
 213     eConnect            = SC_AND;
 214     nField                      = 0;
 215     nVal                        = 0.0;
 216     pStr->Erase();
 217     if ( pSearchParam )
 218     {
 219         delete pSearchParam;
 220         delete pSearchText;
 221     }
 222     pSearchParam        = NULL;
 223     pSearchText         = NULL;
 224 }
 225
 226 BOOL ScQueryEntry::operator==( const ScQueryEntry& r ) const
 227 {
 228     return bDoQuery                     == r.bDoQuery
 229         && bQueryByString       == r.bQueryByString
 230         && bQueryByDate     == r.bQueryByDate
 231         && eOp                          == r.eOp
 232         && eConnect                     == r.eConnect
 233         && nField                       == r.nField
 234         && nVal                         == r.nVal
 235         && *pStr                        == *r.pStr;
 236     //! pSearchParam und pSearchText nicht vergleichen
 237 }
 238
 239 utl::TextSearch* ScQueryEntry::GetSearchTextPtr( BOOL bCaseSens )
 240 {
 241     if ( !pSearchParam )
 242     {
 243         pSearchParam = new utl::SearchParam( *pStr, utl::SearchParam::SRCH_REGEXP,
 244             bCaseSens, FALSE, FALSE );
 245         pSearchText = new utl::TextSearch( *pSearchParam, *ScGlobal::pCharClass );
 246     }
 247     return pSearchText;
 248 }
 249
 250 //------------------------------------------------------------------------
 251 // struct ScSubTotalParam:
 252
 253 ScSubTotalParam::ScSubTotalParam()
 254 {
 255     for ( USHORT i=0; i<MAXSUBTOTAL; i++ )
 256     {
 257         nSubTotals[i] = 0;
 258         pSubTotals[i] = NULL;
 259         pFunctions[i] = NULL;
 260     }
 261
 262     Clear();
 263 }
 264
 265 //------------------------------------------------------------------------
 266
 267 ScSubTotalParam::ScSubTotalParam( const ScSubTotalParam& r ) :
 268         nCol1(r.nCol1),nRow1(r.nRow1),nCol2(r.nCol2),nRow2(r.nRow2),
 269         bRemoveOnly(r.bRemoveOnly),bReplace(r.bReplace),bPagebreak(r.bPagebreak),bCaseSens(r.bCaseSens),
 270         bDoSort(r.bDoSort),bAscending(r.bAscending),bUserDef(r.bUserDef),nUserIndex(r.nUserIndex),
 271         bIncludePattern(r.bIncludePattern)
 272 {
 273     for (USHORT i=0; i<MAXSUBTOTAL; i++)
 274     {
 275         bGroupActive[i] = r.bGroupActive[i];
 276         nField[i]               = r.nField[i];
 277
 278         if ( (r.nSubTotals[i] > 0) && r.pSubTotals[i] && r.pFunctions[i] )
 279         {
 280             nSubTotals[i] = r.nSubTotals[i];
 281             pSubTotals[i] = new SCCOL   [r.nSubTotals[i]];
 282             pFunctions[i] = new ScSubTotalFunc  [r.nSubTotals[i]];
 283
 284             for (SCCOL j=0; j<r.nSubTotals[i]; j++)
 285             {
 286                 pSubTotals[i][j] = r.pSubTotals[i][j];
 287                 pFunctions[i][j] = r.pFunctions[i][j];
 288             }
 289         }
 290         else
 291         {
 292             nSubTotals[i] = 0;
 293             pSubTotals[i] = NULL;
 294             pFunctions[i] = NULL;
 295         }
 296     }
 297 }
 298
 299 //------------------------------------------------------------------------
 300
 301 void ScSubTotalParam::Clear()
 302 {
 303     nCol1=nCol2= 0;
 304     nRow1=nRow2 = 0;
 305     nUserIndex = 0;
 306     bPagebreak=bCaseSens=bUserDef=bIncludePattern=bRemoveOnly = FALSE;
 307     bAscending=bReplace=bDoSort = TRUE;
 308
 309     for (USHORT i=0; i<MAXSUBTOTAL; i++)
 310     {
 311         bGroupActive[i] = FALSE;
 312         nField[i]               = 0;
 313
 314         if ( (nSubTotals[i] > 0) && pSubTotals[i] && pFunctions[i] )
 315         {
 316             for ( SCCOL j=0; j<nSubTotals[i]; j++ ) {
 317                 pSubTotals[i][j] = 0;
 318                 pFunctions[i][j] = SUBTOTAL_FUNC_NONE;
 319             }
 320         }
 321     }
 322 }
 323
 324 //------------------------------------------------------------------------
 325
 326 ScSubTotalParam& ScSubTotalParam::operator=( const ScSubTotalParam& r )
 327 {
 328     nCol1                       = r.nCol1;
 329     nRow1                       = r.nRow1;
 330     nCol2                       = r.nCol2;
 331     nRow2                       = r.nRow2;
 332     bRemoveOnly         = r.bRemoveOnly;
 333     bReplace            = r.bReplace;
 334     bPagebreak          = r.bPagebreak;
 335     bCaseSens           = r.bCaseSens;
 336     bDoSort                     = r.bDoSort;
 337     bAscending          = r.bAscending;
 338     bUserDef            = r.bUserDef;
 339     nUserIndex          = r.nUserIndex;
 340     bIncludePattern     = r.bIncludePattern;
 341
 342     for (USHORT i=0; i<MAXSUBTOTAL; i++)
 343     {
 344         bGroupActive[i] = r.bGroupActive[i];
 345         nField[i]               = r.nField[i];
 346         nSubTotals[i]   = r.nSubTotals[i];
 347
 348         if ( pSubTotals[i] ) delete [] pSubTotals[i];
 349         if ( pFunctions[i] ) delete [] pFunctions[i];
 350
 351         if ( r.nSubTotals[i] > 0 )
 352         {
 353             pSubTotals[i] = new SCCOL   [r.nSubTotals[i]];
 354             pFunctions[i] = new ScSubTotalFunc  [r.nSubTotals[i]];
 355
 356             for (SCCOL j=0; j<r.nSubTotals[i]; j++)
 357             {
 358                 pSubTotals[i][j] = r.pSubTotals[i][j];
 359                 pFunctions[i][j] = r.pFunctions[i][j];
 360             }
 361         }
 362         else
 363         {
 364             nSubTotals[i] = 0;
 365             pSubTotals[i] = NULL;
 366             pFunctions[i] = NULL;
 367         }
 368     }
 369
 370     return *this;
 371 }
 372
 373 //------------------------------------------------------------------------
 374
 375 BOOL ScSubTotalParam::operator==( const ScSubTotalParam& rOther ) const
 376 {
 377     BOOL bEqual =   (nCol1                      == rOther.nCol1)
 378                  && (nRow1                      == rOther.nRow1)
 379                  && (nCol2                      == rOther.nCol2)
 380                  && (nRow2                      == rOther.nRow2)
 381                  && (bRemoveOnly        == rOther.bRemoveOnly)
 382                  && (bReplace           == rOther.bReplace)
 383                  && (bPagebreak         == rOther.bPagebreak)
 384                  && (bDoSort            == rOther.bDoSort)
 385                  && (bCaseSens          == rOther.bCaseSens)
 386                  && (bAscending         == rOther.bAscending)
 387                  && (bUserDef           == rOther.bUserDef)
 388                  && (nUserIndex         == rOther.nUserIndex)
 389                  && (bIncludePattern== rOther.bIncludePattern);
 390
 391     if ( bEqual )
 392     {
 393         bEqual = TRUE;
 394         for ( USHORT i=0; i<MAXSUBTOTAL && bEqual; i++ )
 395         {
 396             bEqual =   (bGroupActive[i] == rOther.bGroupActive[i])
 397                     && (nField[i]               == rOther.nField[i])
 398                     && (nSubTotals[i]   == rOther.nSubTotals[i]);
 399
 400             if ( bEqual && (nSubTotals[i] > 0) )
 401             {
 402                 bEqual = (pSubTotals != NULL) && (pFunctions != NULL);
 403
 404                 for (SCCOL j=0; (j<nSubTotals[i]) && bEqual; j++)
 405                 {
 406                     bEqual =   bEqual
 407                             && (pSubTotals[i][j] == rOther.pSubTotals[i][j])
 408                             && (pFunctions[i][j] == rOther.pFunctions[i][j]);
 409                 }
 410             }
 411         }
 412     }
 413
 414     return bEqual;
 415 }
 416
 417 //------------------------------------------------------------------------
 418
 419 void ScSubTotalParam::SetSubTotals( USHORT                                      nGroup,
 420                                     const SCCOL*                        ptrSubTotals,
 421                                     const ScSubTotalFunc*       ptrFunctions,
 422                                     USHORT                                      nCount )
 423 {
 424     DBG_ASSERT( (nGroup <= MAXSUBTOTAL),
 425                 "ScSubTotalParam::SetSubTotals(): nGroup > MAXSUBTOTAL!" );
 426     DBG_ASSERT( ptrSubTotals,
 427                 "ScSubTotalParam::SetSubTotals(): ptrSubTotals == NULL!" );
 428     DBG_ASSERT( ptrFunctions,
 429                 "ScSubTotalParam::SetSubTotals(): ptrFunctions == NULL!" );
 430     DBG_ASSERT( (nCount > 0),
 431                 "ScSubTotalParam::SetSubTotals(): nCount <= 0!" );
 432
 433     if ( ptrSubTotals && ptrFunctions && (nCount > 0) && (nGroup <= MAXSUBTOTAL) )
 434     {
 435         // 0 wird als 1 aufgefasst, sonst zum Array-Index dekrementieren
 436         if (nGroup != 0)
 437             nGroup--;
 438
 439         delete [] pSubTotals[nGroup];
 440         delete [] pFunctions[nGroup];
 441
 442         pSubTotals[nGroup] = new SCCOL          [nCount];
 443         pFunctions[nGroup] = new ScSubTotalFunc [nCount];
 444         nSubTotals[nGroup] = static_cast<SCCOL>(nCount);
 445
 446         for ( USHORT i=0; i<nCount; i++ )
 447         {
 448             pSubTotals[nGroup][i] = ptrSubTotals[i];
 449             pFunctions[nGroup][i] = ptrFunctions[i];
 450         }
 451     }
 452 }
 453
 454 //------------------------------------------------------------------------
 455 // struct ScConsolidateParam:
 456
 457 ScConsolidateParam::ScConsolidateParam() :
 458     ppDataAreas( NULL )
 459 {
 460     Clear();
 461 }
 462
 463 //------------------------------------------------------------------------
 464
 465 ScConsolidateParam::ScConsolidateParam( const ScConsolidateParam& r ) :
 466         nCol(r.nCol),nRow(r.nRow),nTab(r.nTab),
 467         eFunction(r.eFunction),nDataAreaCount(0),
 468         ppDataAreas( NULL ),
 469         bByCol(r.bByCol),bByRow(r.bByRow),bReferenceData(r.bReferenceData)
 470 {
 471     if ( r.nDataAreaCount > 0 )
 472     {
 473         nDataAreaCount = r.nDataAreaCount;
 474         ppDataAreas = new ScArea*[nDataAreaCount];
 475         for ( USHORT i=0; i<nDataAreaCount; i++ )
 476             ppDataAreas[i] = new ScArea( *(r.ppDataAreas[i]) );
 477     }
 478 }
 479
 480 //------------------------------------------------------------------------
 481
 482 __EXPORT ScConsolidateParam::~ScConsolidateParam()
 483 {
 484     ClearDataAreas();
 485 }
 486
 487 //------------------------------------------------------------------------
 488
 489 void __EXPORT ScConsolidateParam::ClearDataAreas()
 490 {
 491     if ( ppDataAreas )
 492     {
 493         for ( USHORT i=0; i<nDataAreaCount; i++ )
 494             delete ppDataAreas[i];
 495         delete [] ppDataAreas;
 496         ppDataAreas = NULL;
 497     }
 498     nDataAreaCount = 0;
 499 }
 500
 501 //------------------------------------------------------------------------
 502
 503 void __EXPORT ScConsolidateParam::Clear()
 504 {
 505     ClearDataAreas();
 506
 507     nCol = 0;
 508     nRow = 0;
 509     nTab = 0;
 510     bByCol = bByRow = bReferenceData    = FALSE;
 511     eFunction                                                   = SUBTOTAL_FUNC_SUM;
 512 }
 513
 514 //------------------------------------------------------------------------
 515
 516 ScConsolidateParam& __EXPORT ScConsolidateParam::operator=( const ScConsolidateParam& r )
 517 {
 518     nCol                        = r.nCol;
 519     nRow                        = r.nRow;
 520     nTab                        = r.nTab;
 521     bByCol                      = r.bByCol;
 522     bByRow                      = r.bByRow;
 523     bReferenceData      = r.bReferenceData;
 524     eFunction           = r.eFunction;
 525     SetAreas( r.ppDataAreas, r.nDataAreaCount );
 526
 527     return *this;
 528 }
 529
 530 //------------------------------------------------------------------------
 531
 532 BOOL __EXPORT ScConsolidateParam::operator==( const ScConsolidateParam& r ) const
 533 {
 534     BOOL bEqual =       (nCol                   == r.nCol)
 535                  &&     (nRow                   == r.nRow)
 536                  && (nTab                       == r.nTab)
 537                  && (bByCol                     == r.bByCol)
 538                  && (bByRow                     == r.bByRow)
 539                  && (bReferenceData     == r.bReferenceData)
 540                  && (nDataAreaCount     == r.nDataAreaCount)
 541                  && (eFunction          == r.eFunction);
 542
 543     if ( nDataAreaCount == 0 )
 544         bEqual = bEqual && (ppDataAreas == NULL) && (r.ppDataAreas == NULL);
 545     else
 546         bEqual = bEqual && (ppDataAreas != NULL) && (r.ppDataAreas != NULL);
 547
 548     if ( bEqual && (nDataAreaCount > 0) )
 549         for ( USHORT i=0; i<nDataAreaCount && bEqual; i++ )
 550             bEqual = *(ppDataAreas[i]) == *(r.ppDataAreas[i]);
 551
 552     return bEqual;
 553 }
 554
 555 //------------------------------------------------------------------------
 556
 557 void __EXPORT ScConsolidateParam::SetAreas( ScArea* const* ppAreas, USHORT nCount )
 558 {
 559     ClearDataAreas();
 560     if ( ppAreas && nCount > 0 )
 561     {
 562         ppDataAreas = new ScArea*[nCount];
 563         for ( USHORT i=0; i<nCount; i++ )
 564             ppDataAreas[i] = new ScArea( *(ppAreas[i]) );
 565         nDataAreaCount = nCount;
 566     }
 567 }
 568
 569 // -----------------------------------------------------------------------
 570
 571 PivotField::PivotField( SCsCOL nNewCol, USHORT nNewFuncMask ) :
 572     nCol( nNewCol ),
 573     nFuncMask( nNewFuncMask ),
 574     nFuncCount( 0 )
 575 {
 576 }
 577
 578 bool PivotField::operator==( const PivotField& r ) const
 579 {
 580     return (nCol                            == r.nCol)
 581         && (nFuncMask                       == r.nFuncMask)
 582         && (nFuncCount                      == r.nFuncCount)
 583         && (maFieldRef.ReferenceType        == r.maFieldRef.ReferenceType)
 584         && (maFieldRef.ReferenceField       == r.maFieldRef.ReferenceField)
 585         && (maFieldRef.ReferenceItemType    == r.maFieldRef.ReferenceItemType)
 586         && (maFieldRef.ReferenceItemName    == r.maFieldRef.ReferenceItemName);
 587 }
 588
 589 //------------------------------------------------------------------------
 590 // struct ScPivotParam:
 591
 592 ScPivotParam::ScPivotParam()
 593     :   nCol(0), nRow(0), nTab(0),
 594         nPageCount(0), nColCount(0), nRowCount(0), nDataCount(0),
 595         bIgnoreEmptyRows(FALSE), bDetectCategories(FALSE),
 596         bMakeTotalCol(TRUE), bMakeTotalRow(TRUE)
 597 {
 598 }
 599
 600 //------------------------------------------------------------------------
 601
 602 ScPivotParam::ScPivotParam( const ScPivotParam& r )
 603     :   nCol( r.nCol ), nRow( r.nRow ), nTab( r.nTab ),
 604         nPageCount(0), nColCount(0), nRowCount(0), nDataCount(0),
 605         bIgnoreEmptyRows(r.bIgnoreEmptyRows),
 606         bDetectCategories(r.bDetectCategories),
 607         bMakeTotalCol(r.bMakeTotalCol),
 608         bMakeTotalRow(r.bMakeTotalRow)
 609 {
 610     SetPivotArrays  ( r.aPageArr, r.aColArr, r.aRowArr, r.aDataArr,
 611                       r.nPageCount, r.nColCount, r.nRowCount, r.nDataCount );
 612
 613     SetLabelData(r.maLabelArray);
 614 }
 615
 616 //------------------------------------------------------------------------
 617
 618 __EXPORT ScPivotParam::~ScPivotParam()
 619 {
 620 }
 621
 622 //------------------------------------------------------------------------
 623
 624 //UNUSED2009-05 void __EXPORT ScPivotParam::Clear()
 625 //UNUSED2009-05 {
 626 //UNUSED2009-05     nCol = 0;
 627 //UNUSED2009-05     nRow = 0;
 628 //UNUSED2009-05     nTab = 0;
 629 //UNUSED2009-05     bIgnoreEmptyRows = bDetectCategories = FALSE;
 630 //UNUSED2009-05     bMakeTotalCol = bMakeTotalRow = TRUE;
 631 //UNUSED2009-05     ClearLabelData();
 632 //UNUSED2009-05     ClearPivotArrays();
 633 //UNUSED2009-05 }
 634
 635 void __EXPORT ScPivotParam::ClearPivotArrays()
 636 {
 637     memset( aPageArr, 0, PIVOT_MAXPAGEFIELD * sizeof(PivotField) );
 638     memset( aColArr, 0, PIVOT_MAXFIELD * sizeof(PivotField) );
 639     memset( aRowArr, 0, PIVOT_MAXFIELD * sizeof(PivotField) );
 640     memset( aDataArr, 0, PIVOT_MAXFIELD * sizeof(PivotField) );
 641     nPageCount = 0;
 642     nColCount = 0;
 643     nRowCount = 0;
 644     nDataCount = 0;
 645 }
 646
 647 void ScPivotParam::SetLabelData(const vector<ScDPLabelDataRef>& r)
 648 {
 649     vector<ScDPLabelDataRef> aNewArray;
 650     aNewArray.reserve(r.size());
 651     for (vector<ScDPLabelDataRef>::const_iterator itr = r.begin(), itrEnd = r.end();
 652           itr != itrEnd; ++itr)
 653     {
 654         ScDPLabelDataRef p(new ScDPLabelData(**itr));
 655         aNewArray.push_back(p);
 656     }
 657     maLabelArray.swap(aNewArray);
 658 }
 659
 660 //------------------------------------------------------------------------
 661
 662 void __EXPORT ScPivotParam::SetPivotArrays  ( const PivotField* pPageArr,
 663                                               const PivotField* pColArr,
 664                                               const PivotField* pRowArr,
 665                                               const PivotField* pDataArr,
 666                                               SCSIZE            nPageCnt,
 667                                               SCSIZE                    nColCnt,
 668                                               SCSIZE                    nRowCnt,
 669                                               SCSIZE                    nDataCnt )
 670 {
 671     ClearPivotArrays();
 672
 673     if ( pPageArr && pColArr && pRowArr && pDataArr  )
 674     {
 675         nPageCount  = (nPageCnt>PIVOT_MAXPAGEFIELD) ? PIVOT_MAXPAGEFIELD : nPageCnt;
 676         nColCount       = (nColCnt>PIVOT_MAXFIELD) ? PIVOT_MAXFIELD : nColCnt;
 677         nRowCount       = (nRowCnt>PIVOT_MAXFIELD) ? PIVOT_MAXFIELD : nRowCnt;
 678         nDataCount      = (nDataCnt>PIVOT_MAXFIELD) ? PIVOT_MAXFIELD : nDataCnt;
 679
 680         memcpy( aPageArr, pPageArr, nPageCount * sizeof(PivotField) );
 681         memcpy( aColArr,  pColArr,      nColCount  * sizeof(PivotField) );
 682         memcpy( aRowArr,  pRowArr,      nRowCount  * sizeof(PivotField) );
 683         memcpy( aDataArr, pDataArr, nDataCount * sizeof(PivotField) );
 684     }
 685 }
 686
 687 //------------------------------------------------------------------------
 688
 689 ScPivotParam& __EXPORT ScPivotParam::operator=( const ScPivotParam& r )
 690 {
 691     nCol                          = r.nCol;
 692     nRow                          = r.nRow;
 693     nTab                          = r.nTab;
 694     bIgnoreEmptyRows  = r.bIgnoreEmptyRows;
 695     bDetectCategories = r.bDetectCategories;
 696     bMakeTotalCol         = r.bMakeTotalCol;
 697     bMakeTotalRow         = r.bMakeTotalRow;
 698
 699     SetPivotArrays  ( r.aPageArr, r.aColArr, r.aRowArr, r.aDataArr,
 700                       r.nPageCount, r.nColCount, r.nRowCount, r.nDataCount );
 701     SetLabelData(r.maLabelArray);
 702     return *this;
 703 }
 704
 705 //------------------------------------------------------------------------
 706
 707 BOOL __EXPORT ScPivotParam::operator==( const ScPivotParam& r ) const
 708 {
 709     BOOL bEqual =       (nCol           == r.nCol)
 710                  &&     (nRow           == r.nRow)
 711                  && (nTab               == r.nTab)
 712                  && (bIgnoreEmptyRows  == r.bIgnoreEmptyRows)
 713                  && (bDetectCategories == r.bDetectCategories)
 714                  && (bMakeTotalCol == r.bMakeTotalCol)
 715                  && (bMakeTotalRow == r.bMakeTotalRow)
 716                  && (maLabelArray.size() == r.maLabelArray.size())
 717                  && (nPageCount == r.nPageCount)
 718                  && (nColCount  == r.nColCount)
 719                  && (nRowCount  == r.nRowCount)
 720                  && (nDataCount == r.nDataCount);
 721
 722     if ( bEqual )
 723     {
 724         SCSIZE i;
 725
 726         for ( i=0; i<nPageCount && bEqual; i++ )
 727             bEqual = ( aPageArr[i] == r.aPageArr[i] );
 728
 729         for ( i=0; i<nColCount && bEqual; i++ )
 730             bEqual = ( aColArr[i] == r.aColArr[i] );
 731
 732         for ( i=0; i<nRowCount && bEqual; i++ )
 733             bEqual = ( aRowArr[i] == r.aRowArr[i] );
 734
 735         for ( i=0; i<nDataCount && bEqual; i++ )
 736             bEqual = ( aDataArr[i] == r.aDataArr[i] );
 737     }
 738
 739     return bEqual;
 740 }
 741
 742 //------------------------------------------------------------------------
 743 // struct ScSolveParam
 744
 745 ScSolveParam::ScSolveParam()
 746     :   pStrTargetVal( NULL )
 747 {
 748 }
 749
 750 //------------------------------------------------------------------------
 751
 752 ScSolveParam::ScSolveParam( const ScSolveParam& r )
 753     :   aRefFormulaCell ( r.aRefFormulaCell ),
 754         aRefVariableCell( r.aRefVariableCell ),
 755         pStrTargetVal   ( r.pStrTargetVal
 756                             ? new String(*r.pStrTargetVal)
 757                             : NULL )
 758 {
 759 }
 760
 761 //------------------------------------------------------------------------
 762
 763 ScSolveParam::ScSolveParam( const ScAddress& rFormulaCell,
 764                             const ScAddress& rVariableCell,
 765                             const String&       rTargetValStr )
 766     :   aRefFormulaCell ( rFormulaCell ),
 767         aRefVariableCell( rVariableCell ),
 768         pStrTargetVal   ( new String(rTargetValStr) )
 769 {
 770 }
 771
 772 //------------------------------------------------------------------------
 773
 774 ScSolveParam::~ScSolveParam()
 775 {
 776     delete pStrTargetVal;
 777 }
 778
 779 //------------------------------------------------------------------------
 780
 781 ScSolveParam& __EXPORT ScSolveParam::operator=( const ScSolveParam& r )
 782 {
 783     delete pStrTargetVal;
 784
 785     aRefFormulaCell  = r.aRefFormulaCell;
 786     aRefVariableCell = r.aRefVariableCell;
 787     pStrTargetVal    = r.pStrTargetVal
 788                             ? new String(*r.pStrTargetVal)
 789                             : NULL;
 790     return *this;
 791 }
 792
 793 //------------------------------------------------------------------------
 794
 795 BOOL ScSolveParam::operator==( const ScSolveParam& r ) const
 796 {
 797     BOOL bEqual =       (aRefFormulaCell  == r.aRefFormulaCell)
 798                  &&     (aRefVariableCell == r.aRefVariableCell);
 799
 800     if ( bEqual )
 801     {
 802         if ( !pStrTargetVal && !r.pStrTargetVal )
 803             bEqual = TRUE;
 804         else if ( !pStrTargetVal || !r.pStrTargetVal )
 805             bEqual = FALSE;
 806         else if ( pStrTargetVal && r.pStrTargetVal )
 807             bEqual = ( *pStrTargetVal == *(r.pStrTargetVal) );
 808     }
 809
 810     return bEqual;
 811 }
 812
 813
 814 //------------------------------------------------------------------------
 815 // struct ScTabOpParam
 816
 817 ScTabOpParam::ScTabOpParam( const ScTabOpParam& r )
 818     :   aRefFormulaCell ( r.aRefFormulaCell ),
 819         aRefFormulaEnd  ( r.aRefFormulaEnd ),
 820         aRefRowCell             ( r.aRefRowCell ),
 821         aRefColCell             ( r.aRefColCell ),
 822         nMode                   ( r.nMode )
 823 {
 824 }
 825
 826 //------------------------------------------------------------------------
 827
 828 ScTabOpParam::ScTabOpParam( const ScRefAddress& rFormulaCell,
 829                             const ScRefAddress& rFormulaEnd,
 830                             const ScRefAddress& rRowCell,
 831                             const ScRefAddress& rColCell,
 832                                   BYTE           nMd)
 833     :   aRefFormulaCell ( rFormulaCell ),
 834         aRefFormulaEnd  ( rFormulaEnd ),
 835         aRefRowCell             ( rRowCell ),
 836         aRefColCell             ( rColCell ),
 837         nMode                   ( nMd )
 838 {
 839 }
 840
 841 //------------------------------------------------------------------------
 842
 843 ScTabOpParam& ScTabOpParam::operator=( const ScTabOpParam& r )
 844 {
 845     aRefFormulaCell  = r.aRefFormulaCell;
 846     aRefFormulaEnd   = r.aRefFormulaEnd;
 847     aRefRowCell          = r.aRefRowCell;
 848     aRefColCell          = r.aRefColCell;
 849     nMode                    = r.nMode;
 850     return *this;
 851 }
 852
 853 //------------------------------------------------------------------------
 854
 855 BOOL __EXPORT ScTabOpParam::operator==( const ScTabOpParam& r ) const
 856 {
 857     return (            (aRefFormulaCell == r.aRefFormulaCell)
 858                  &&     (aRefFormulaEnd  == r.aRefFormulaEnd)
 859                  &&     (aRefRowCell     == r.aRefRowCell)
 860                  &&     (aRefColCell     == r.aRefColCell)
 861                  && (nMode                       == r.nMode) );
 862 }
 863
 864 String ScGlobal::GetAbsDocName( const String& rFileName,
 865                                 SfxObjectShell* pShell )
 866 {
 867     String aAbsName;
 868     if ( !pShell->HasName() )
 869     {   // maybe relative to document path working directory
 870         INetURLObject aObj;
 871         SvtPathOptions aPathOpt;
 872         aObj.SetSmartURL( aPathOpt.GetWorkPath() );
 873         aObj.setFinalSlash();           // it IS a path
 874         bool bWasAbs = true;
 875         aAbsName = aObj.smartRel2Abs( rFileName, bWasAbs ).GetMainURL(INetURLObject::NO_DECODE);
 876         //      returned string must be encoded because it's used directly to create SfxMedium
 877     }
 878     else
 879     {
 880         const SfxMedium* pMedium = pShell->GetMedium();
 881         if ( pMedium )
 882         {
 883             bool bWasAbs = true;
 884             aAbsName = pMedium->GetURLObject().smartRel2Abs( rFileName, bWasAbs ).GetMainURL(INetURLObject::NO_DECODE);
 885         }
 886         else
 887         {       // This can't happen, but ...
 888             // just to be sure to have the same encoding
 889             INetURLObject aObj;
 890             aObj.SetSmartURL( aAbsName );
 891             aAbsName = aObj.GetMainURL(INetURLObject::NO_DECODE);
 892         }
 893     }
 894     return aAbsName;
 895 }
 896
 897
 898 String ScGlobal::GetDocTabName( const String& rFileName,
 899                                 const String& rTabName )
 900 {
 901     String aDocTab( '\'' );
 902     aDocTab += rFileName;
 903     xub_StrLen nPos = 1;
 904     while( (nPos = aDocTab.Search( '\'', nPos ))
 905             != STRING_NOTFOUND )
 906     {   // escape Quotes
 907         aDocTab.Insert( '\\', nPos );
 908         nPos += 2;
 909     }
 910     aDocTab += '\'';
 911     aDocTab += SC_COMPILER_FILE_TAB_SEP;
 912     aDocTab += rTabName;        // "'Doc'#Tab"
 913     return aDocTab;
 914 }
 915
 916 // ============================================================================
 917
 918 ScSimpleSharedString::StringTable::StringTable() :
 919     mnStrCount(0)
 920 {
 921     // empty string (ID = 0)
 922     maSharedStrings.push_back(String());
 923     maSharedStringIds.insert( SharedStrMap::value_type(String(), mnStrCount++) );
 924 }
 925
 926 ScSimpleSharedString::StringTable::StringTable(const ScSimpleSharedString::StringTable& r) :
 927     maSharedStrings(r.maSharedStrings),
 928     maSharedStringIds(r.maSharedStringIds),
 929     mnStrCount(r.mnStrCount)
 930 {
 931 }
 932
 933 ScSimpleSharedString::StringTable::~StringTable()
 934 {
 935 }
 936
 937 sal_Int32 ScSimpleSharedString::StringTable::insertString(const String& aStr)
 938 {
 939     SharedStrMap::const_iterator itr = maSharedStringIds.find(aStr),
 940         itrEnd = maSharedStringIds.end();
 941
 942     if (itr == itrEnd)
 943     {
 944         // new string.
 945         maSharedStrings.push_back(aStr);
 946         maSharedStringIds.insert( SharedStrMap::value_type(aStr, mnStrCount) );
 947         return mnStrCount++;
 948     }
 949
 950     // existing string.
 951     return itr->second;
 952 }
 953
 954 sal_Int32 ScSimpleSharedString::StringTable::getStringId(const String& aStr)
 955 {
 956     SharedStrMap::const_iterator itr = maSharedStringIds.find(aStr),
 957         itrEnd = maSharedStringIds.end();
 958     if (itr == itrEnd)
 959     {
 960         // string not found.
 961         return insertString(aStr);
 962     }
 963     return itr->second;
 964 }
 965
 966 const String* ScSimpleSharedString::StringTable::getString(sal_Int32 nId) const
 967 {
 968     if (nId >= mnStrCount)
 969         return NULL;
 970
 971     return &maSharedStrings[nId];
 972 }
 973
 974 // ----------------------------------------------------------------------------
 975
 976 ScSimpleSharedString::ScSimpleSharedString()
 977 {
 978 }
 979
 980 ScSimpleSharedString::ScSimpleSharedString(const ScSimpleSharedString& r) :
 981     maStringTable(r.maStringTable)
 982 {
 983 }
 984
 985 ScSimpleSharedString::~ScSimpleSharedString()
 986 {
 987 }
 988
 989 sal_Int32 ScSimpleSharedString::insertString(const String& aStr)
 990 {
 991     return maStringTable.insertString(aStr);
 992 }
 993
 994 const String* ScSimpleSharedString::getString(sal_Int32 nId)
 995 {
 996     return maStringTable.getString(nId);
 997 }
 998
 999 sal_Int32 ScSimpleSharedString::getStringId(const String& aStr)
1000 {
1001     return maStringTable.getStringId(aStr);
1002 }