binfilter/inc/bf_sch/memchrt.hxx

   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: memchrt.hxx,v $
  10  * $Revision: 1.12 $
  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 #ifndef _SCH_MEMCHRT_HXX
  32 #define _SCH_MEMCHRT_HXX
  33
  34 #ifndef _SFXDEFS_HXX
  35 #include <bf_sfx2/sfxdefs.hxx>
  36 #endif
  37 #ifndef _SFXMODULE_HXX
  38 #include <bf_sfx2/module.hxx>
  39 #endif
  40 #ifndef _COLOR_HXX
  41 #include <tools/color.hxx>
  42 #endif
  43 #ifndef _LINK_HXX
  44 #include <tools/link.hxx>
  45 #endif
  46 #ifndef _STRING_HXX
  47 #include <tools/string.hxx>
  48 #endif
  49 #ifndef _RTL_USTRBUF_HXX_
  50 #include <rtl/ustrbuf.hxx>
  51 #endif
  52 #include <bf_sch/cellranges.hxx>
  53
  54 #ifndef _COM_SUN_STAR_CHART_CHARTSERIESADDRESS_HPP_
  55 #include <com/sun/star/chart/ChartSeriesAddress.hpp>
  56 #endif
  57 class SvStream;
  58
  59 namespace binfilter {
  60
  61 class SfxItemSet;
  62 class SvNumberFormatter;
  63 class ChartModel;
  64
  65 #define SCH_COPY_HACK
  66
  67 enum ChartDataId
  68 {
  69         CHDATAID_NONE,
  70         CHDATAID_MEMCHART,
  71         CHDATAID_DYNCHART,
  72         CHDATAID_MEMCHART_PLUS
  73 };
  74
  75 // This struct contains information about selection in the chart, so that
  76 // other apps (esp. calc) know what is currently selected
  77
  78 struct ChartSelectionInfo
  79 {
  80         ChartSelectionInfo() : nRow(0), nCol(0), fValue(0.0), nValue(0), nSelection(0) {}
  81         ChartSelectionInfo(long sel) : nRow(0), nCol(0), fValue(0.0), nValue(0), nSelection(sel) {}
  82         BOOL operator == (const ChartSelectionInfo& s) const
  83         {
  84                 return nRow                             == s.nRow
  85                         && nCol                         == s.nCol
  86                         && nSelection           == s.nSelection
  87                         && fValue                       == s.fValue
  88                         && nValue                       == s.nValue
  89                         && aSelectionColor      == s.aSelectionColor;
  90         }
  91         long    nRow;                    // Datenzeilen-Koordinate
  92         long    nCol;                    // Datenspaltenkoordinate
  93         double  fValue;                  // neuer Wert fuer die Zelle (nCol,nRow)
  94         long    nValue;                  // reserviert, evtl. fuer Numberformat und andere Informationen
  95         long    nSelection;      // s.u. , 31-Bit-Register (also besser Int32? -> return ist long)
  96         Color   aSelectionColor; // Farbe des Selektions-Rahmens
  97 };
  98
  99 // Flags fuer nSelection UND den Rueckgabewert der CallBackFunktion
 100 // long ChartSelectionCallback(struct ChartSelectionInfo *pInfo), die mittels
 101 // SchMemChart::SetSelectionCallback(...) am Chart angemeldet wird
 102
 103 #define CHART_SEL_NONE                  1       // bestehende Selektion aufheben (derzeit default, da im Chart keine Multiselektion besteht)
 104 #define CHART_SEL_ALL                   2       // den gesamten MemChart-Datenbereich selektieren
 105 #define CHART_SEL_ROW                   4       // die DatenReihe nRow selektieren
 106 #define CHART_SEL_COL                   8       // die DatenSpalte nCol Selektieren
 107 #define CHART_SEL_POINT                 16      // den Datenpunkt selektieren
 108 #define CHART_SEL_SETCURSOR             32      // Cursor an die Stelle (nCol,nRow) setzen
 109 #define CHART_SEL_CHANGEVALUE   64      // Wert in der Tabelle aendern (auf fValue)
 110 #define CHART_SEL_COLOR                 128     // Farbinformation für farbigen Rahmen um den Selektionsbereich herum ist gesetzt
 111 #define CHART_SEL_QUERYSUPPORT  256
 112 #define CHART_SEL_QUERYPOSSIBLE 512
 113
 114 /*
 115  In der Callback-routine soll wie folgt verfahren werden:
 116  Kann eine Aktion (z.B. Aenderung des Wertes) ausgefuehrt werden, so MUSS das
 117  entsprechende Flag im Rueckgabewert gesetzt werden, kann die Aktion nicht ausgefuehrt
 118  werden, so DARF das Flag NICHT gesetzt werden.
 119
 120 Prioritaet der Aktionen:
 121
 122  Prio 0 : CHART_SEL_QUERYSUPPORT
 123  Prio 1 : CHART_SEL_NONE   ; wichtig fuer (spaetere) Multiselektion.
 124  Prio 2 : CHART_SEL_BORDERONLY ; Selektionsmodus, wird vorerst immer gesetzt sein
 125  Prio n : der Rest....
 126
 127 CHART_SEL_QUERYSUPPORT:
 128  Ist dieses Flag gesetzt, DARF die Aktion NICHT ausgefuehrt werden, sondern nur
 129  zurueckgegeben werden, ob es moeglich waere!
 130
 131 CHART_SEL_NONE:
 132
 133   Aufheben der Selektion, bei Multiselektion ist dieses Flag NICHT gesetzt, die neue Selektion
 134   wird zusaetzlich angewand. (derzeit im Chart nicht implementiert, daher immer gesetzt)
 135
 136 */
 137
 138 // ============================================================
 139 // ============================================================
 140 //
 141 //              SchMemChart: class for chart data
 142 //
 143 // ============================================================
 144 // ============================================================
 145
 146 #define TRANS_NONE      0
 147 #define TRANS_COL       1
 148 #define TRANS_ROW       2
 149 #define TRANS_ERROR 3
 150
 151 class SchMemChart
 152 {
 153 private:
 154         long                    nLastSelInfoReturn;
 155         ULONG           nRefCount;
 156         mutable String* mpColNameBuffer;
 157         mutable String* mpRowNameBuffer;
 158
 159 protected :
 160         long                    nTranslated;
 161         short                   nRowCnt;
 162         short                   nColCnt;
 163         String                  aMainTitle;
 164         String                  aSubTitle;
 165         String                  aXAxisTitle;
 166         String                  aYAxisTitle;
 167         String                  aZAxisTitle;
 168         short                   eDataType;
 169         String          aSomeData1;
 170         String          aSomeData2;
 171         String          aSomeData3;
 172         String          aSomeData4;
 173         double          *pData;
 174         String          *pColText;
 175         String          *pRowText;
 176         ChartDataId     myID;
 177
 178
 179         // number formatter and format id
 180         SvNumberFormatter*  mpNumFormatter;
 181         sal_Int32 *pRowNumFmtId;
 182         sal_Int32 *pColNumFmtId;
 183
 184         // translation table for row-/column reordering (internal)
 185         sal_Int32 *pRowTable;
 186         sal_Int32 *pColTable;
 187         ChartSelectionInfo aSelectionInfo;
 188
 189         // is not copied in copy contrustor (?)
 190         Link aAppLink;
 191         BOOL bReadOnly;
 192
 193         ::rtl::OUString maCategoriesRangeAddress;
 194         ::com::sun::star::uno::Sequence<
 195                 ::com::sun::star::chart::ChartSeriesAddress > maSeriesAddresses;
 196
 197     /// contains all information necessary to write the source data ranges
 198     SchChartRange maChartRange;
 199
 200     ::rtl::OUStringBuffer getXMLStringForCellAddress( const SchCellAddress& rCell );
 201      void getSingleCellAddressFromXMLString( const ::rtl::OUString& rXMLString,
 202                                              sal_Int32 nStartPos, sal_Int32 nEndPos,
 203                                              SchSingleCell& rSingleCell );
 204      bool getCellAddressFromXMLString( const ::rtl::OUString& rXMLString,
 205                                       sal_Int32 nStartPos, sal_Int32 nEndPos,
 206                                       SchCellAddress& rOutCell,
 207                                       ::rtl::OUString& rOutTableName );
 208     bool getCellRangeAddressFromXMLString( const ::rtl::OUString& rXMLString,
 209                                            sal_Int32 nStartPos, sal_Int32 nEndPos,
 210                                            SchCellRangeAddress& rOutRange );
 211
 212 public:
 213
 214         inline void SetReadOnly( BOOL bNewValue );
 215         BOOL IsReadOnly() { return bReadOnly; }
 216
 217         SchMemChart(ChartDataId myID);
 218         SchMemChart(short nCols, short nRows);
 219         SchMemChart(const SchMemChart& rMemChart);
 220         ~SchMemChart()
 221         {
 222             delete[] pRowText;
 223             delete[] pColText;
 224             delete[] pData;
 225
 226             if( pRowNumFmtId )
 227                 delete[] pRowNumFmtId;
 228             if( pColNumFmtId )
 229                 delete[] pColNumFmtId;
 230             if( pRowTable )
 231                 delete[] pRowTable;
 232             if( pColTable )
 233                 delete[] pColTable;
 234             delete[] mpRowNameBuffer;
 235             delete[] mpColNameBuffer;
 236         }
 237
 238         // initialize number format, -1 means unset
 239         void InitNumFmt();
 240
 241         // transfer chart selection to calc or writer
 242         const ChartSelectionInfo& GetSelectionInfo() const { return aSelectionInfo; }
 243         // methods for translation of data
 244         inline void ResetTranslation(sal_Int32 *pTable,long nCnt);
 245 #if OSL_DEBUG_LEVEL > 0
 246         BOOL VerifyTranslation();
 247 #endif
 248         long GetTranslation() const { return nTranslated; }
 249         inline void UpdateTranslation(sal_Int32 *pTable,long nCnt);
 250         // for acces always use these Get-methods !
 251         double GetTransData(long nCol,long nRow);
 252         double GetTransDataInPercent(long nCol ,long nRow,BOOL bRowData) const;
 253         const String& GetTransColText(long nCol) const;
 254         const String& GetTransRowText(long nRow) const;
 255
 256         const sal_Int32 *GetRowTranslation() const { return pRowTable; }
 257         const sal_Int32 *GetColTranslation() const { return pColTable; }
 258
 259 #ifdef SCH_COPY_HACK
 260         const sal_Int32* GetRowNumFmtTable() const { return pRowNumFmtId; }
 261         const sal_Int32* GetColNumFmtTable() const { return pColNumFmtId; }
 262
 263         // ********************
 264         // BM: Fix for #68864#
 265         // Use these four methods with care! The arrays MUST have the correct size!
 266         // ********************
 267         void SetRowTranslation( const sal_Int32* pTransTable )
 268         {
 269                 if( !pRowTable ) return;
 270                 for( sal_Int32 i=0; i<nRowCnt; i++ )
 271                         pRowTable[ i ] = pTransTable[ i ];
 272         }
 273         void SetColTranslation( const sal_Int32* pTransTable )
 274         {
 275                 if( !pColTable ) return;
 276                 for( sal_Int32 i=0; i<nColCnt; i++ )
 277                         pColTable[ i ] = pTransTable[ i ];
 278         }
 279         void SetRowNumFmtTable( const sal_Int32* pNumFmtTable )
 280         {
 281                 if( !pRowNumFmtId ) return;
 282                 for( sal_Int32 i=0; i<nRowCnt; i++ )
 283                         pRowNumFmtId[ i ] = pNumFmtTable[ i ];
 284         }
 285         void SetColNumFmtTable( const sal_Int32* pNumFmtTable )
 286         {
 287                 if( !pColNumFmtId ) return;
 288                 for( sal_Int32 i=0; i<nColCnt; i++ )
 289                         pColNumFmtId[ i ] = pNumFmtTable[ i ];
 290         }
 291         // this is only valid if the corresponding translation table was set correctly!
 292         void SetTranslation( long nTrans ) { nTranslated = nTrans; }
 293         // ********************
 294 #endif
 295
 296
 297
 298         // number format
 299
 300         void SetNumberFormatter(SvNumberFormatter* pNumFormatter) { mpNumFormatter = pNumFormatter; }
 301         SvNumberFormatter*  GetNumberFormatter() const { return mpNumFormatter; }
 302
 303         void SetNumFormatIdRow( const long nRow, const long nFmtId )    { if( pRowNumFmtId && nRow < nRowCnt ) pRowNumFmtId[ nRow ] = nFmtId; }
 304         void SetNumFormatIdCol( const long nCol, const long nFmtId )    { if( pColNumFmtId && nCol < nColCnt ) pColNumFmtId[ nCol ] = nFmtId; }
 305         long GetNumFormatIdRow( const long nRow ) const                                 { return ( pRowNumFmtId && nRow < nRowCnt )? pRowNumFmtId[ nRow ]: -1; }
 306         long GetNumFormatIdCol( const long nCol ) const                                 { return ( pColNumFmtId && nCol < nColCnt )? pColNumFmtId[ nCol ]: -1; }
 307         long GetTransNumFormatIdRow( const long nRow ) const;
 308         long GetTransNumFormatIdCol( const long nCol ) const;
 309
 310         void SetSelectionHdl(const Link& rLink) { aAppLink=rLink; }
 311
 312         void SetNonNumericData(const SchMemChart &rMemChart);
 313
 314         void SetDataType(short eType) { eDataType = eType; }
 315         short GetDataType() const { return eDataType; }
 316
 317         short GetColCount() const { return nColCnt;     }
 318         short GetRowCount() const {     return nRowCnt; }
 319
 320         const String& GetMainTitle() const      { return aMainTitle; }
 321         const String& GetSubTitle() const       { return aSubTitle; }
 322
 323         void SetMainTitle(const String& rText) { aMainTitle = rText; }
 324         void SetSubTitle(const String& rText) { aSubTitle = rText; }
 325
 326         const String& GetXAxisTitle() const     { return aXAxisTitle; }
 327         const String& GetYAxisTitle() const     { return aYAxisTitle; }
 328         const String& GetZAxisTitle() const     { return aZAxisTitle; }
 329
 330         void SetXAxisTitle(const String& rText) { aXAxisTitle = rText; }
 331         void SetYAxisTitle(const String& rText) { aYAxisTitle = rText; }
 332         void SetZAxisTitle(const String& rText) { aZAxisTitle = rText; }
 333
 334         friend SvStream& operator << (SvStream& rOut, const SchMemChart& rMemChart);
 335         friend SvStream& operator >> (SvStream& rIn, SchMemChart& rMemChart);
 336
 337         const String& GetColText(short nCol) const { return pColText[nCol]; }
 338         const String& GetRowText(short nRow) const { return pRowText[nRow]; }
 339
 340         ChartDataId GetId() const { return myID; }
 341         double GetData(short nCol, short nRow) const { return pData[nCol * nRowCnt + nRow]; }
 342         double GetDataInPercent(const short nCol , const short nRow, const BOOL bRowData) const;
 343
 344         inline void InsertCols(short nAtCol, short nCount);
 345         inline void RemoveCols(short nAtCol, short nCount);
 346         inline void InsertRows(short nAtRow, short nCount);
 347         inline void RemoveRows(short nAtRow, short nCount);
 348         inline void SwapCols(int nAtCol1, int nAtCol2);
 349         inline void SwapRows(int nAtRow1, int nAtRow2);
 350
 351         void SetData(short nCol, short nRow, const double& rVal)
 352         { pData[nCol * nRowCnt + nRow] = rVal; }
 353
 354         String& SomeData1() { return aSomeData1; }
 355         String& SomeData2() { return aSomeData2; }
 356         String& SomeData3() { return aSomeData3; }
 357         String& SomeData4() { return aSomeData4; }
 358
 359         const String& SomeData1() const { return aSomeData1; }
 360         const String& SomeData2() const { return aSomeData2; }
 361         const String& SomeData3() const { return aSomeData3; }
 362         const String& SomeData4() const { return aSomeData4; }
 363
 364         void SetColText(short nCol, const String& rText) { pColText[nCol] = rText; }
 365         void SetRowText(short nRow, const String& rText) { pRowText[nRow] = rText; }
 366
 367
 368
 369
 370
 371         friend class ChartModel;
 372
 373         void IncreaseRefCount() { nRefCount++; }
 374         BOOL DecreaseRefCount()
 375         {
 376                 DBG_ASSERT( nRefCount, "SchMemChart::DecreaseRefCount: illegal decrement of RefCount");
 377                 if(nRefCount) nRefCount--;
 378                 return (nRefCount==0);  // true iff object can be deleted
 379         }
 380
 381         // get a string for default (column|row) labels
 382         // the indexes start at 0, but the text starts with "(Column|Row) 1"
 383         String GetDefaultColumnText( sal_Int32 nCol ) const;
 384         String GetDefaultRowText( sal_Int32 nRow ) const;
 385
 386     // ====================
 387
 388     /// @deprecated
 389     void SetCategoriesRangeAddress( const ::rtl::OUString& rCellRangeAddress )
 390         { maCategoriesRangeAddress = rCellRangeAddress; }
 391
 392     /// @deprecated
 393     void SetSeriesAddresses( const ::com::sun::star::uno::Sequence< ::com::sun::star::chart::ChartSeriesAddress >& rCellRangeAddresses )
 394         { maSeriesAddresses = rCellRangeAddresses; }
 395
 396     /// @deprecated
 397     const ::rtl::OUString&
 398         GetCategoriesRangeAddress()
 399         { return maCategoriesRangeAddress; }
 400
 401     /// @deprecated
 402     const ::com::sun::star::uno::Sequence< ::com::sun::star::chart::ChartSeriesAddress >&
 403         GetSeriesAddresses()
 404         { return maSeriesAddresses; }
 405
 406     // --------------------
 407
 408     /// get table ranges for entire chart
 409     const SchChartRange& GetChartRange() const
 410         { return maChartRange; }
 411     /// set table ranges for entire chart
 412     void SetChartRange( const SchChartRange& rRange )
 413         { maChartRange = rRange; }
 414
 415     /** convert SomeData string(s) to SchChartRange and vice versa for Writer
 416         @return <TRUE/>, iff the conversion was successfully done.
 417     */
 418     bool ConvertChartRangeForWriter( BOOL bOldToNew = TRUE );
 419
 420     /** convert SomeData string(s) to SchChartRange and vice versa for Calc
 421         @return <TRUE/>, iff the conversion was successfully done.
 422      */
 423     bool ConvertChartRangeForCalc( BOOL bOldToNew = FALSE );
 424
 425     ::rtl::OUString getXMLStringForChartRange();
 426     void getChartRangeForXMLString( const ::rtl::OUString& rXMLString );
 427
 428     /** create a string of form "1 2 3 4" containing a list of table numbers
 429         in SchChartRange maChartRange to create SomeData for calc
 430      */
 431     ::rtl::OUString createTableNumberList();
 432     /** prerequisite: maChartRange must be set and have the correct dimension
 433         for all table numbers to fit in
 434     */
 435     void parseTableNumberList( const ::rtl::OUString& rList );
 436 };
 437
 438 // ==================== Inline Implementations ====================
 439
 440 inline void SchMemChart::ResetTranslation(sal_Int32 *pTable,long nCnt)
 441 {
 442         long i;
 443         if(pTable)
 444                 for(i=0;i<nCnt;i++)
 445                         pTable[i]=i;
 446
 447         if(pTable==pRowTable && nTranslated==TRANS_ROW)
 448                 nTranslated=TRANS_NONE;
 449         if(pTable==pColTable && nTranslated==TRANS_COL)
 450                 nTranslated=TRANS_NONE;
 451 }
 452
 453 inline void SchMemChart::UpdateTranslation(sal_Int32 *pTable,long nCnt)
 454 {
 455         if( (pTable==pRowTable && nTranslated==TRANS_ROW)
 456           ||(pTable==pColTable && nTranslated==TRANS_COL))
 457         {
 458                 long i;
 459                 sal_Int32 nMax=0;
 460                 for(i=0;i<nCnt;i++)
 461                         nMax=Max(nMax,pTable[i]);
 462
 463                 if(nMax>=nCnt)//something added
 464                 {
 465                         long nStart=-1,nEnd=-1;
 466                         for(i=0;i<nCnt;i++)
 467                         {
 468                                 if(pTable[i]==-1)//markierung gefunden
 469                                 {
 470                                         if(nStart!=-1)
 471                                                 nEnd=i;
 472                                         else
 473                                                 nStart=i;
 474                                 }
 475                         }
 476
 477                         long nDiff=nEnd-nStart;//soviele sind neu
 478
 479                         DBG_ASSERT( (nDiff>0) && ((nEnd-nStart) == (nCnt-nMax)),"MemChart::Something went wrong!");
 480
 481                         if( (nDiff<=0) || ((nEnd-nStart)!=(nCnt-nMax)))
 482                                 return;
 483
 484                         long nNew = nStart;
 485
 486                         for(i=0;i<nCnt;i++)
 487                         {
 488                                 if(pTable[i]>nStart)
 489                                 {
 490                                         pTable[i]+=nDiff;   //nach hinten verschieben
 491                                 }
 492                                 else if (pTable[i]==-1)
 493                                 {
 494                                         pTable[i]=nNew;     //"einfuegen"
 495                                         nNew++;
 496                                 }
 497                         }
 498                 }
 499                 else //something removed
 500                 {
 501                         ResetTranslation(pTable,nCnt); //keine schoene Loesung....(ToDo:), Aufwand recht hoch...
 502                 }
 503         }
 504         else
 505         {
 506                 ResetTranslation(pTable,nCnt); //Normale Reihenfolge, da nicht die Sortierte Tabelll geupdated wird
 507         }
 508 }
 509
 510 inline void SchMemChart::InsertCols(short nAtCol, short nCount)
 511 {
 512         double* pOldData = pData;
 513
 514         short nNewColCnt = nColCnt + nCount;
 515
 516         pData                   = new double[nNewColCnt * nRowCnt];
 517
 518         short i, j, nOld, nMax;
 519
 520         for (i = 0, nOld = 0; i < nAtCol; i++, nOld++)
 521         {
 522                 for (j = 0; j < nRowCnt; j++)
 523                 {
 524                         pData[i * nRowCnt + j] = pOldData[nOld * nRowCnt + j];
 525                 }
 526         }
 527
 528         nMax = nAtCol + nCount;
 529
 530         for (; i < nMax; i++)
 531         {
 532                 for (j = 0; j < nRowCnt; j++)
 533                 {
 534                         pData[i * nRowCnt + j] = 0.0;
 535                 }
 536         }
 537
 538         for (; i < nNewColCnt; i++, nOld++)
 539         {
 540                 for (j = 0; j < nRowCnt; j++)
 541                 {
 542                         pData[i * nRowCnt + j] = pOldData[nOld * nRowCnt + j];
 543                 }
 544         }
 545         delete[] pOldData;
 546
 547         String *pOldColText     = pColText;
 548         sal_Int32 *pOldColNumFmtId = pColNumFmtId;
 549         sal_Int32 *pOldColTable    = pColTable;
 550
 551         pColNumFmtId    = new sal_Int32 [nNewColCnt];
 552         pColTable               = new sal_Int32 [nNewColCnt];
 553         pColText                = new String[nNewColCnt];
 554
 555         long nC=nNewColCnt;
 556         while(nC--)
 557         {
 558                 pColTable[nC]    = -1; //init
 559                 pColNumFmtId[nC] = -1;
 560         }
 561
 562         for (i = 0, nOld = 0;; i++, nOld++)
 563         {
 564                 if (i == nAtCol)
 565                         i += nCount;
 566                 if (i >= nNewColCnt)
 567                         break;
 568
 569                 pColText[i]     = pOldColText[nOld];
 570                 pColTable[i]    = pOldColTable[nOld];
 571                 pColNumFmtId[i] = pOldColNumFmtId[nOld];
 572         }
 573
 574         delete[] pOldColNumFmtId;
 575         delete[] pOldColTable;
 576         delete[] pOldColText;
 577
 578         nColCnt = nNewColCnt;
 579
 580         UpdateTranslation(pColTable,nColCnt);
 581 }
 582
 583 inline void SchMemChart::RemoveCols(short nAtCol, short nCount)
 584 {
 585         DBG_ASSERT( nAtCol < nColCnt, "column index overflow");
 586
 587         if (nAtCol + nCount > nColCnt)
 588                 nCount = nColCnt - nAtCol;
 589
 590         short nNewColCnt = nColCnt - nCount;
 591
 592         double* pOldData = pData;
 593         pData = new double[nNewColCnt * nRowCnt];
 594
 595         String* pOldColText             = pColText;
 596         sal_Int32* pOldColNumFmtId      = pColNumFmtId;
 597         sal_Int32* pOldColTable = pColTable;
 598
 599         pColText                = new String[nNewColCnt];
 600         pColNumFmtId    = new sal_Int32 [nNewColCnt];
 601         pColTable               = new sal_Int32 [nNewColCnt];
 602
 603         short i, j, nOld;
 604
 605         for (i = 0, nOld = 0;; i++, nOld++)
 606         {
 607                 if (nOld == nAtCol)
 608                         nOld += nCount;
 609                 if (nOld >= nColCnt)
 610                         break;
 611
 612                 for (j = 0; j < nRowCnt; j++)
 613                         pData[i * nRowCnt + j] = pOldData[nOld * nRowCnt + j];
 614
 615                 pColText[i]             = pOldColText[nOld];
 616                 pColTable[i]    = pOldColTable[nOld];
 617                 pColNumFmtId[i] = pOldColNumFmtId[nOld];
 618         }
 619
 620         delete[] pOldData;
 621         delete[] pOldColText;
 622         delete[] pOldColTable;
 623         delete[] pOldColNumFmtId;
 624
 625         nColCnt = nNewColCnt;
 626
 627         UpdateTranslation(pColTable,nColCnt);
 628 }
 629
 630 inline void SchMemChart::InsertRows(short nAtRow, short nCount)
 631 {
 632         double* pOldData = pData;
 633
 634         short nNewRowCnt = nRowCnt + nCount;
 635
 636         pData = new double[nColCnt * nNewRowCnt];
 637
 638         short i, j, nOld, nMax, nGapEnd;
 639
 640         for (i = 0; i < nColCnt; i++)
 641         {
 642                 for (j = 0, nOld= 0; j < nAtRow; j++, nOld++)
 643                 {
 644                         pData[i * nNewRowCnt + j] = pOldData[i * nRowCnt + nOld];
 645                 }
 646         }
 647
 648         nMax = nAtRow + nCount;
 649
 650         for (i = 0; i < nColCnt; i++)
 651         {
 652                 for (j = nAtRow; j < nMax; j++)
 653                 {
 654                         pData[i * nNewRowCnt + j] = 0.0;
 655                 }
 656         }
 657
 658         nGapEnd = nMax;
 659
 660         for (i = 0; i < nColCnt; i++)
 661         {
 662                 for (j = nGapEnd, nOld = nAtRow; j < nNewRowCnt; j++, nOld++)
 663                 {
 664                         pData[i * nNewRowCnt + j] = pOldData[i * nRowCnt + nOld];
 665                 }
 666         }
 667         delete[] pOldData;
 668
 669         String *pOldRowText     =pRowText;
 670         sal_Int32 *pOldRowNumFmtId =pRowNumFmtId;
 671         sal_Int32 *pOldRowTable    =pRowTable;
 672
 673         pRowNumFmtId    = new sal_Int32 [nNewRowCnt];
 674         pRowTable               = new sal_Int32 [nNewRowCnt];
 675         pRowText        = new String[nNewRowCnt];
 676
 677         long nC=nNewRowCnt;
 678         while(nC--) //init
 679         {
 680                 pRowNumFmtId[nC]        = -1;
 681                 pRowTable[nC]   = -1;
 682         }
 683
 684         for (i = 0, nOld = 0;; i++, nOld++)
 685         {
 686                 if (i == nAtRow)
 687                         i += nCount;
 688                 if (i >= nNewRowCnt)
 689                         break;
 690
 691                 pRowNumFmtId[i] = pOldRowNumFmtId[nOld];
 692                 pRowTable[i]    = pOldRowTable[nOld];
 693                 pRowText[i]     = pOldRowText[nOld];
 694         }
 695
 696         delete[] pOldRowText;
 697         delete[] pOldRowTable;
 698         delete[] pOldRowNumFmtId;
 699
 700         nRowCnt = nNewRowCnt;
 701
 702         UpdateTranslation(pRowTable,nRowCnt);
 703 }
 704
 705 inline void SchMemChart::RemoveRows(short nAtRow, short nCount)
 706 {
 707         DBG_ASSERT( nAtRow < nRowCnt, "row  index overflow" );
 708
 709         if (nAtRow + nCount > nRowCnt)
 710                 nCount = nRowCnt - nAtRow;
 711
 712         short nNewRowCnt = nRowCnt - nCount;
 713
 714         double* pOldData = pData;
 715         pData = new double[nColCnt * nNewRowCnt];
 716
 717         short i, j, nOld;
 718
 719         for (i = 0; i < nColCnt; i++)
 720                 for (j = 0, nOld = 0;; j++, nOld++)
 721                 {
 722                         if (nOld == nAtRow)
 723                                 nOld += nCount;
 724                         if (nOld >= nRowCnt)
 725                                 break;
 726
 727                         pData[i * nNewRowCnt + j] = pOldData[i * nRowCnt + nOld];
 728                 }
 729
 730         delete[] pOldData;
 731
 732         String* pOldRowText             = pRowText;
 733         sal_Int32*   pOldRowNumFmtId    = pRowNumFmtId;
 734         sal_Int32*   pOldRowTable       = pRowTable;
 735
 736         pRowText                = new String[nNewRowCnt];
 737         pRowNumFmtId    = new sal_Int32 [nNewRowCnt];
 738         pRowTable               = new sal_Int32 [nNewRowCnt];
 739
 740         for (i = 0, nOld = 0;; i++, nOld++)
 741         {
 742                 if (nOld == nAtRow)
 743                         nOld += nCount;
 744                 if (nOld >= nRowCnt)
 745                         break;
 746
 747                 pRowText[i] = pOldRowText[nOld];
 748                 pRowTable[i] = pOldRowTable[nOld];
 749                 pRowNumFmtId[i] = pOldRowNumFmtId[nOld];
 750         }
 751
 752         delete[] pOldRowText;
 753         delete[] pOldRowTable;
 754         delete[] pOldRowNumFmtId;
 755
 756         nRowCnt = nNewRowCnt;
 757
 758         UpdateTranslation(pRowTable,nRowCnt);
 759 }
 760
 761 inline void SchMemChart::SwapCols(int nAtCol1, int nAtCol2)
 762 {
 763         // Wenn hier Aenderungen Stattfinden, mu?auch im Logbuch
 764         // angepasst werden
 765         if (nAtCol1 > nAtCol2)
 766         {
 767                 long nTemp = nAtCol1;
 768
 769                 nAtCol1 = nAtCol2;
 770                 nAtCol2 = nTemp;
 771         }
 772
 773         if (nAtCol1 >= nColCnt - 1) nAtCol1 = nColCnt - 2;
 774         if (nAtCol2 >= nColCnt) nAtCol2 = nColCnt - 1;
 775
 776         nAtCol1 = Max(nAtCol1, 0);
 777         nAtCol2 = Max(nAtCol2, 0);
 778         //Insbesondere bis hier,, da dieses Handling autokorrigierend ist
 779
 780         double *pSrc  = pData + nAtCol1 * nRowCnt;
 781         double *pDest = pData + nAtCol2 * nRowCnt;
 782
 783         for (long nSwaps = 0;
 784                           nSwaps < nRowCnt;
 785                           nSwaps ++)
 786         {
 787                 double fSwap = *pSrc;
 788
 789                 *pSrc  = *pDest;
 790                 *pDest = fSwap;
 791
 792                 pSrc ++;
 793                 pDest ++;
 794         }
 795
 796         String aTemp = pColText [nAtCol1];
 797         pColText [nAtCol1] = pColText [nAtCol2];
 798         pColText [nAtCol2] = aTemp;
 799
 800         long nTmp = pColTable [nAtCol1];
 801         pColTable [nAtCol1] = pColTable [nAtCol2];
 802         pColTable [nAtCol2] = nTmp;
 803
 804         nTmp = pColNumFmtId[nAtCol1];
 805         pColNumFmtId [nAtCol1] = pColNumFmtId [nAtCol2];
 806         pColNumFmtId [nAtCol2] = nTmp;
 807
 808         ResetTranslation(pColTable,nColCnt); //ToDo:???
 809 }
 810
 811 inline void SchMemChart::SwapRows(int nAtRow1,int nAtRow2)
 812 {
 813
 814         // Wenn hier Aenderungen Stattfinden, mu?auch im Logbuch
 815         // angepasst werden
 816         if (nAtRow1 > nAtRow2)
 817         {
 818                 long nTemp = nAtRow1;
 819
 820                 nAtRow1 = nAtRow2;
 821                 nAtRow2 = nTemp;
 822         }
 823
 824         if (nAtRow1 >= nRowCnt - 1) nAtRow1 = nRowCnt - 2;
 825         if (nAtRow2 >= nRowCnt) nAtRow2 = nRowCnt - 1;
 826
 827         nAtRow1 = Max(nAtRow1, 0);
 828         nAtRow2 = Max(nAtRow2, 0);
 829         //Insbesondere bis hier,, da dieses Handling autokorrigierend ist
 830
 831         double *pSrc  = pData + nAtRow1;
 832         double *pDest = pData + nAtRow2;
 833
 834         for (long nSwaps = 0;
 835                           nSwaps < nColCnt;
 836                           nSwaps ++)
 837         {
 838                 double fSwap = *pSrc;
 839
 840                 *pSrc  = *pDest;
 841                 *pDest = fSwap;
 842
 843                 pSrc  += nRowCnt;
 844                 pDest += nRowCnt;
 845         }
 846
 847         String aTemp = pRowText [nAtRow1];
 848         pRowText [nAtRow1] = pRowText [nAtRow2];
 849         pRowText [nAtRow2] = aTemp;
 850
 851         long nTmp = pRowTable [nAtRow1];
 852         pRowTable [nAtRow1] = pRowTable [nAtRow2];
 853         pRowTable [nAtRow2] = nTmp;
 854
 855         nTmp = pRowNumFmtId[nAtRow1];
 856         pRowNumFmtId [nAtRow1] = pRowNumFmtId [nAtRow2];
 857         pRowNumFmtId [nAtRow2] = nTmp;
 858
 859         ResetTranslation(pRowTable,nRowCnt);//ToDo:???
 860 }
 861
 862 inline void SchMemChart::SetReadOnly( BOOL bNewValue )
 863 {
 864     // do not set ReadOnly, if there is no external data set
 865     if( bNewValue && maChartRange.maRanges.size() == 0 )
 866         return;
 867     else
 868         bReadOnly = bNewValue;
 869 }
 870
 871 } //namespace binfilter
 872 #endif  // _SCH_MEMCHRT_HXX
 873