1*cde9e8dcSAndrew Rist /************************************************************** 2cdf0e10cSrcweir * 3*cde9e8dcSAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one 4*cde9e8dcSAndrew Rist * or more contributor license agreements. See the NOTICE file 5*cde9e8dcSAndrew Rist * distributed with this work for additional information 6*cde9e8dcSAndrew Rist * regarding copyright ownership. The ASF licenses this file 7*cde9e8dcSAndrew Rist * to you under the Apache License, Version 2.0 (the 8*cde9e8dcSAndrew Rist * "License"); you may not use this file except in compliance 9*cde9e8dcSAndrew Rist * with the License. You may obtain a copy of the License at 10*cde9e8dcSAndrew Rist * 11*cde9e8dcSAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0 12*cde9e8dcSAndrew Rist * 13*cde9e8dcSAndrew Rist * Unless required by applicable law or agreed to in writing, 14*cde9e8dcSAndrew Rist * software distributed under the License is distributed on an 15*cde9e8dcSAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16*cde9e8dcSAndrew Rist * KIND, either express or implied. See the License for the 17*cde9e8dcSAndrew Rist * specific language governing permissions and limitations 18*cde9e8dcSAndrew Rist * under the License. 19*cde9e8dcSAndrew Rist * 20*cde9e8dcSAndrew Rist *************************************************************/ 21*cde9e8dcSAndrew Rist 22*cde9e8dcSAndrew Rist 23cdf0e10cSrcweir 24cdf0e10cSrcweir // MARKER(update_precomp.py): autogen include statement, do not remove 25cdf0e10cSrcweir #include "precompiled_chart2.hxx" 26cdf0e10cSrcweir 27cdf0e10cSrcweir #include "InternalData.hxx" 28cdf0e10cSrcweir #include "ResId.hxx" 29cdf0e10cSrcweir #include "Strings.hrc" 30cdf0e10cSrcweir #include "macros.hxx" 31cdf0e10cSrcweir 32cdf0e10cSrcweir #include <rtl/math.hxx> 33cdf0e10cSrcweir 34cdf0e10cSrcweir using ::com::sun::star::uno::Sequence; 35cdf0e10cSrcweir using ::rtl::OUString; 36cdf0e10cSrcweir 37cdf0e10cSrcweir using namespace ::com::sun::star; 38cdf0e10cSrcweir using namespace ::std; 39cdf0e10cSrcweir 40cdf0e10cSrcweir namespace chart 41cdf0e10cSrcweir { 42cdf0e10cSrcweir 43cdf0e10cSrcweir // ---------------------------------------- 44cdf0e10cSrcweir namespace 45cdf0e10cSrcweir { 46cdf0e10cSrcweir struct lcl_NumberedStringGenerator 47cdf0e10cSrcweir { 48cdf0e10cSrcweir lcl_NumberedStringGenerator( const OUString & rStub, const OUString & rWildcard ) : 49cdf0e10cSrcweir m_aStub( rStub ), 50cdf0e10cSrcweir m_nCounter( 0 ), 51cdf0e10cSrcweir m_nStubStartIndex( rStub.indexOf( rWildcard )), 52cdf0e10cSrcweir m_nWildcardLength( rWildcard.getLength()) 53cdf0e10cSrcweir { 54cdf0e10cSrcweir } 55cdf0e10cSrcweir vector< uno::Any > operator()() 56cdf0e10cSrcweir { 57cdf0e10cSrcweir vector< uno::Any > aRet(1); 58cdf0e10cSrcweir aRet[0] = uno::makeAny( m_aStub.replaceAt( m_nStubStartIndex, m_nWildcardLength, OUString::valueOf( ++m_nCounter )) ); 59cdf0e10cSrcweir return aRet; 60cdf0e10cSrcweir } 61cdf0e10cSrcweir private: 62cdf0e10cSrcweir OUString m_aStub; 63cdf0e10cSrcweir sal_Int32 m_nCounter; 64cdf0e10cSrcweir const sal_Int32 m_nStubStartIndex; 65cdf0e10cSrcweir const sal_Int32 m_nWildcardLength; 66cdf0e10cSrcweir }; 67cdf0e10cSrcweir 68cdf0e10cSrcweir template< typename T > 69cdf0e10cSrcweir Sequence< T > lcl_ValarrayToSequence( const ::std::valarray< T > & rValarray ) 70cdf0e10cSrcweir { 71cdf0e10cSrcweir // is there a more elegant way of conversion? 72cdf0e10cSrcweir Sequence< T > aResult( rValarray.size()); 73cdf0e10cSrcweir for( size_t i = 0; i < rValarray.size(); ++i ) 74cdf0e10cSrcweir aResult[i] = rValarray[i]; 75cdf0e10cSrcweir return aResult; 76cdf0e10cSrcweir } 77cdf0e10cSrcweir 78cdf0e10cSrcweir } // anonymous namespace 79cdf0e10cSrcweir // ---------------------------------------- 80cdf0e10cSrcweir 81cdf0e10cSrcweir InternalData::InternalData() 82cdf0e10cSrcweir : m_nColumnCount( 0 ) 83cdf0e10cSrcweir , m_nRowCount( 0 ) 84cdf0e10cSrcweir , m_aRowLabels( 0 ) 85cdf0e10cSrcweir , m_aColumnLabels( 0 ) 86cdf0e10cSrcweir {} 87cdf0e10cSrcweir 88cdf0e10cSrcweir void InternalData::createDefaultData() 89cdf0e10cSrcweir { 90cdf0e10cSrcweir const sal_Int32 nRowCount = 4; 91cdf0e10cSrcweir const sal_Int32 nColumnCount = 3; 92cdf0e10cSrcweir 93cdf0e10cSrcweir m_nRowCount = nRowCount; 94cdf0e10cSrcweir m_nColumnCount = nColumnCount; 95cdf0e10cSrcweir const sal_Int32 nSize = nColumnCount * nRowCount; 96cdf0e10cSrcweir // @todo: localize this! 97cdf0e10cSrcweir const OUString aRowName( ::chart::SchResId::getResString( STR_ROW_LABEL )); 98cdf0e10cSrcweir const OUString aColName( ::chart::SchResId::getResString( STR_COLUMN_LABEL )); 99cdf0e10cSrcweir 100cdf0e10cSrcweir const double fDefaultData[ nSize ] = 101cdf0e10cSrcweir { 9.10, 3.20, 4.54, 102cdf0e10cSrcweir 2.40, 8.80, 9.65, 103cdf0e10cSrcweir 3.10, 1.50, 3.70, 104cdf0e10cSrcweir 4.30, 9.02, 6.20 }; 105cdf0e10cSrcweir 106cdf0e10cSrcweir m_aData.resize( nSize ); 107cdf0e10cSrcweir for( sal_Int32 i=0; i<nSize; ++i ) 108cdf0e10cSrcweir m_aData[i] = fDefaultData[i]; 109cdf0e10cSrcweir 110cdf0e10cSrcweir m_aRowLabels.clear(); 111cdf0e10cSrcweir m_aRowLabels.reserve( m_nRowCount ); 112cdf0e10cSrcweir generate_n( back_inserter( m_aRowLabels ), m_nRowCount, 113cdf0e10cSrcweir lcl_NumberedStringGenerator( aRowName, C2U("%ROWNUMBER") )); 114cdf0e10cSrcweir 115cdf0e10cSrcweir m_aColumnLabels.clear(); 116cdf0e10cSrcweir m_aColumnLabels.reserve( m_nColumnCount ); 117cdf0e10cSrcweir generate_n( back_inserter( m_aColumnLabels ), m_nColumnCount, 118cdf0e10cSrcweir lcl_NumberedStringGenerator( aColName, C2U("%COLUMNNUMBER") )); 119cdf0e10cSrcweir } 120cdf0e10cSrcweir 121cdf0e10cSrcweir void InternalData::setData( const Sequence< Sequence< double > >& rDataInRows ) 122cdf0e10cSrcweir { 123cdf0e10cSrcweir m_nRowCount = rDataInRows.getLength(); 124cdf0e10cSrcweir m_nColumnCount = (m_nRowCount ? rDataInRows[0].getLength() : 0); 125cdf0e10cSrcweir 126cdf0e10cSrcweir if( m_aRowLabels.size() != static_cast< sal_uInt32 >( m_nRowCount )) 127cdf0e10cSrcweir m_aRowLabels.resize( m_nRowCount ); 128cdf0e10cSrcweir if( m_aColumnLabels.size() != static_cast< sal_uInt32 >( m_nColumnCount )) 129cdf0e10cSrcweir m_aColumnLabels.resize( m_nColumnCount ); 130cdf0e10cSrcweir 131cdf0e10cSrcweir m_aData.resize( m_nRowCount * m_nColumnCount ); 132cdf0e10cSrcweir double fNan; 133cdf0e10cSrcweir ::rtl::math::setNan( & fNan ); 134cdf0e10cSrcweir // set all values to Nan 135cdf0e10cSrcweir m_aData = fNan; 136cdf0e10cSrcweir 137cdf0e10cSrcweir for( sal_Int32 nRow=0; nRow<m_nRowCount; ++nRow ) 138cdf0e10cSrcweir { 139cdf0e10cSrcweir int nDataIdx = nRow*m_nColumnCount; 140cdf0e10cSrcweir const sal_Int32 nMax = ::std::min( rDataInRows[nRow].getLength(), m_nColumnCount ); 141cdf0e10cSrcweir for( sal_Int32 nCol=0; nCol < nMax; ++nCol ) 142cdf0e10cSrcweir { 143cdf0e10cSrcweir m_aData[nDataIdx] = rDataInRows[nRow][nCol]; 144cdf0e10cSrcweir nDataIdx += 1; 145cdf0e10cSrcweir } 146cdf0e10cSrcweir } 147cdf0e10cSrcweir } 148cdf0e10cSrcweir 149cdf0e10cSrcweir Sequence< Sequence< double > > InternalData::getData() const 150cdf0e10cSrcweir { 151cdf0e10cSrcweir Sequence< Sequence< double > > aResult( m_nRowCount ); 152cdf0e10cSrcweir 153cdf0e10cSrcweir for( sal_Int32 i=0; i<m_nRowCount; ++i ) 154cdf0e10cSrcweir aResult[i] = lcl_ValarrayToSequence< tDataType::value_type >( 155cdf0e10cSrcweir m_aData[ ::std::slice( i*m_nColumnCount, m_nColumnCount, 1 ) ] ); 156cdf0e10cSrcweir 157cdf0e10cSrcweir return aResult; 158cdf0e10cSrcweir } 159cdf0e10cSrcweir 160cdf0e10cSrcweir Sequence< double > InternalData::getColumnValues( sal_Int32 nColumnIndex ) const 161cdf0e10cSrcweir { 162cdf0e10cSrcweir if( nColumnIndex >= 0 && nColumnIndex < m_nColumnCount ) 163cdf0e10cSrcweir return lcl_ValarrayToSequence< tDataType::value_type >( 164cdf0e10cSrcweir m_aData[ ::std::slice( nColumnIndex, m_nRowCount, m_nColumnCount ) ] ); 165cdf0e10cSrcweir return Sequence< double >(); 166cdf0e10cSrcweir } 167cdf0e10cSrcweir Sequence< double > InternalData::getRowValues( sal_Int32 nRowIndex ) const 168cdf0e10cSrcweir { 169cdf0e10cSrcweir if( nRowIndex >= 0 && nRowIndex < m_nRowCount ) 170cdf0e10cSrcweir return lcl_ValarrayToSequence< tDataType::value_type >( 171cdf0e10cSrcweir m_aData[ ::std::slice( nRowIndex*m_nColumnCount, m_nColumnCount, 1 ) ] ); 172cdf0e10cSrcweir return Sequence< double >(); 173cdf0e10cSrcweir } 174cdf0e10cSrcweir 175cdf0e10cSrcweir void InternalData::setColumnValues( sal_Int32 nColumnIndex, const vector< double > & rNewData ) 176cdf0e10cSrcweir { 177cdf0e10cSrcweir if( nColumnIndex < 0 ) 178cdf0e10cSrcweir return; 179cdf0e10cSrcweir enlargeData( nColumnIndex + 1, rNewData.size() ); 180cdf0e10cSrcweir 181cdf0e10cSrcweir tDataType aSlice = m_aData[ ::std::slice( nColumnIndex, m_nRowCount, m_nColumnCount ) ]; 182cdf0e10cSrcweir for( vector< double >::size_type i = 0; i < rNewData.size(); ++i ) 183cdf0e10cSrcweir aSlice[i] = rNewData[i]; 184cdf0e10cSrcweir m_aData[ ::std::slice( nColumnIndex, m_nRowCount, m_nColumnCount ) ] = aSlice; 185cdf0e10cSrcweir } 186cdf0e10cSrcweir 187cdf0e10cSrcweir void InternalData::setRowValues( sal_Int32 nRowIndex, const vector< double > & rNewData ) 188cdf0e10cSrcweir { 189cdf0e10cSrcweir if( nRowIndex < 0 ) 190cdf0e10cSrcweir return; 191cdf0e10cSrcweir enlargeData( rNewData.size(), nRowIndex+1 ); 192cdf0e10cSrcweir 193cdf0e10cSrcweir tDataType aSlice = m_aData[ ::std::slice( nRowIndex*m_nColumnCount, m_nColumnCount, 1 ) ]; 194cdf0e10cSrcweir for( vector< double >::size_type i = 0; i < rNewData.size(); ++i ) 195cdf0e10cSrcweir aSlice[i] = rNewData[i]; 196cdf0e10cSrcweir m_aData[ ::std::slice( nRowIndex*m_nColumnCount, m_nColumnCount, 1 ) ]= aSlice; 197cdf0e10cSrcweir } 198cdf0e10cSrcweir 199cdf0e10cSrcweir void InternalData::setComplexColumnLabel( sal_Int32 nColumnIndex, const vector< uno::Any >& rComplexLabel ) 200cdf0e10cSrcweir { 201cdf0e10cSrcweir if( nColumnIndex < 0 ) 202cdf0e10cSrcweir return; 203cdf0e10cSrcweir if( nColumnIndex >= static_cast< sal_Int32 >( m_aColumnLabels.size() ) ) 204cdf0e10cSrcweir { 205cdf0e10cSrcweir m_aColumnLabels.resize(nColumnIndex+1); 206cdf0e10cSrcweir enlargeData( nColumnIndex+1, 0 ); 207cdf0e10cSrcweir } 208cdf0e10cSrcweir m_aColumnLabels[nColumnIndex]=rComplexLabel; 209cdf0e10cSrcweir } 210cdf0e10cSrcweir 211cdf0e10cSrcweir void InternalData::setComplexRowLabel( sal_Int32 nRowIndex, const vector< uno::Any >& rComplexLabel ) 212cdf0e10cSrcweir { 213cdf0e10cSrcweir if( nRowIndex < 0 ) 214cdf0e10cSrcweir return; 215cdf0e10cSrcweir if( nRowIndex >= static_cast< sal_Int32 >( m_aRowLabels.size() ) ) 216cdf0e10cSrcweir { 217cdf0e10cSrcweir m_aRowLabels.resize(nRowIndex+1); 218cdf0e10cSrcweir enlargeData( 0, nRowIndex+1 ); 219cdf0e10cSrcweir } 220cdf0e10cSrcweir m_aRowLabels[nRowIndex] = rComplexLabel; 221cdf0e10cSrcweir } 222cdf0e10cSrcweir 223cdf0e10cSrcweir vector< uno::Any > InternalData::getComplexColumnLabel( sal_Int32 nColumnIndex ) const 224cdf0e10cSrcweir { 225cdf0e10cSrcweir if( nColumnIndex < static_cast< sal_Int32 >( m_aColumnLabels.size() ) ) 226cdf0e10cSrcweir return m_aColumnLabels[nColumnIndex]; 227cdf0e10cSrcweir else 228cdf0e10cSrcweir return vector< uno::Any >(); 229cdf0e10cSrcweir } 230cdf0e10cSrcweir vector< uno::Any > InternalData::getComplexRowLabel( sal_Int32 nRowIndex ) const 231cdf0e10cSrcweir { 232cdf0e10cSrcweir if( nRowIndex < static_cast< sal_Int32 >( m_aRowLabels.size() ) ) 233cdf0e10cSrcweir return m_aRowLabels[nRowIndex]; 234cdf0e10cSrcweir else 235cdf0e10cSrcweir return vector< uno::Any >(); 236cdf0e10cSrcweir } 237cdf0e10cSrcweir 238cdf0e10cSrcweir void InternalData::swapRowWithNext( sal_Int32 nRowIndex ) 239cdf0e10cSrcweir { 240cdf0e10cSrcweir if( nRowIndex < m_nRowCount - 1 ) 241cdf0e10cSrcweir { 242cdf0e10cSrcweir const sal_Int32 nMax = m_nColumnCount; 243cdf0e10cSrcweir for( sal_Int32 nColIdx=0; nColIdx<nMax; ++nColIdx ) 244cdf0e10cSrcweir { 245cdf0e10cSrcweir size_t nIndex1 = nColIdx + nRowIndex*m_nColumnCount; 246cdf0e10cSrcweir size_t nIndex2 = nIndex1 + m_nColumnCount; 247cdf0e10cSrcweir double fTemp = m_aData[nIndex1]; 248cdf0e10cSrcweir m_aData[nIndex1] = m_aData[nIndex2]; 249cdf0e10cSrcweir m_aData[nIndex2] = fTemp; 250cdf0e10cSrcweir } 251cdf0e10cSrcweir 252cdf0e10cSrcweir vector< uno::Any > aTemp( m_aRowLabels[nRowIndex] ); 253cdf0e10cSrcweir m_aRowLabels[nRowIndex] = m_aRowLabels[nRowIndex + 1]; 254cdf0e10cSrcweir m_aRowLabels[nRowIndex + 1] = aTemp; 255cdf0e10cSrcweir } 256cdf0e10cSrcweir } 257cdf0e10cSrcweir 258cdf0e10cSrcweir void InternalData::swapColumnWithNext( sal_Int32 nColumnIndex ) 259cdf0e10cSrcweir { 260cdf0e10cSrcweir if( nColumnIndex < m_nColumnCount - 1 ) 261cdf0e10cSrcweir { 262cdf0e10cSrcweir const sal_Int32 nMax = m_nRowCount; 263cdf0e10cSrcweir for( sal_Int32 nRowIdx=0; nRowIdx<nMax; ++nRowIdx ) 264cdf0e10cSrcweir { 265cdf0e10cSrcweir size_t nIndex1 = nColumnIndex + nRowIdx*m_nColumnCount; 266cdf0e10cSrcweir size_t nIndex2 = nIndex1 + 1; 267cdf0e10cSrcweir double fTemp = m_aData[nIndex1]; 268cdf0e10cSrcweir m_aData[nIndex1] = m_aData[nIndex2]; 269cdf0e10cSrcweir m_aData[nIndex2] = fTemp; 270cdf0e10cSrcweir } 271cdf0e10cSrcweir 272cdf0e10cSrcweir vector< uno::Any > aTemp( m_aColumnLabels[nColumnIndex] ); 273cdf0e10cSrcweir m_aColumnLabels[nColumnIndex] = m_aColumnLabels[nColumnIndex + 1]; 274cdf0e10cSrcweir m_aColumnLabels[nColumnIndex + 1] = aTemp; 275cdf0e10cSrcweir } 276cdf0e10cSrcweir } 277cdf0e10cSrcweir 278cdf0e10cSrcweir bool InternalData::enlargeData( sal_Int32 nColumnCount, sal_Int32 nRowCount ) 279cdf0e10cSrcweir { 280cdf0e10cSrcweir sal_Int32 nNewColumnCount( ::std::max<sal_Int32>( m_nColumnCount, nColumnCount ) ); 281cdf0e10cSrcweir sal_Int32 nNewRowCount( ::std::max<sal_Int32>( m_nRowCount, nRowCount ) ); 282cdf0e10cSrcweir sal_Int32 nNewSize( nNewColumnCount*nNewRowCount ); 283cdf0e10cSrcweir 284cdf0e10cSrcweir bool bGrow = (nNewSize > m_nColumnCount*m_nRowCount); 285cdf0e10cSrcweir 286cdf0e10cSrcweir if( bGrow ) 287cdf0e10cSrcweir { 288cdf0e10cSrcweir double fNan; 289cdf0e10cSrcweir ::rtl::math::setNan( &fNan ); 290cdf0e10cSrcweir tDataType aNewData( fNan, nNewSize ); 291cdf0e10cSrcweir // copy old data 292cdf0e10cSrcweir for( int nCol=0; nCol<m_nColumnCount; ++nCol ) 293cdf0e10cSrcweir static_cast< tDataType >( 294cdf0e10cSrcweir aNewData[ ::std::slice( nCol, m_nRowCount, nNewColumnCount ) ] ) = 295cdf0e10cSrcweir m_aData[ ::std::slice( nCol, m_nRowCount, m_nColumnCount ) ]; 296cdf0e10cSrcweir 297cdf0e10cSrcweir m_aData.resize( nNewSize ); 298cdf0e10cSrcweir m_aData = aNewData; 299cdf0e10cSrcweir } 300cdf0e10cSrcweir m_nColumnCount = nNewColumnCount; 301cdf0e10cSrcweir m_nRowCount = nNewRowCount; 302cdf0e10cSrcweir return bGrow; 303cdf0e10cSrcweir } 304cdf0e10cSrcweir 305cdf0e10cSrcweir void InternalData::insertColumn( sal_Int32 nAfterIndex ) 306cdf0e10cSrcweir { 307cdf0e10cSrcweir // note: -1 is allowed, as we insert after the given index 308cdf0e10cSrcweir OSL_ASSERT( nAfterIndex < m_nColumnCount && nAfterIndex >= -1 ); 309cdf0e10cSrcweir if( nAfterIndex >= m_nColumnCount || nAfterIndex < -1 ) 310cdf0e10cSrcweir return; 311cdf0e10cSrcweir sal_Int32 nNewColumnCount = m_nColumnCount + 1; 312cdf0e10cSrcweir sal_Int32 nNewSize( nNewColumnCount * m_nRowCount ); 313cdf0e10cSrcweir 314cdf0e10cSrcweir double fNan; 315cdf0e10cSrcweir ::rtl::math::setNan( &fNan ); 316cdf0e10cSrcweir tDataType aNewData( fNan, nNewSize ); 317cdf0e10cSrcweir 318cdf0e10cSrcweir // copy old data 319cdf0e10cSrcweir int nCol=0; 320cdf0e10cSrcweir for( ; nCol<=nAfterIndex; ++nCol ) 321cdf0e10cSrcweir aNewData[ ::std::slice( nCol, m_nRowCount, nNewColumnCount ) ] = 322cdf0e10cSrcweir static_cast< tDataType >( 323cdf0e10cSrcweir m_aData[ ::std::slice( nCol, m_nRowCount, m_nColumnCount ) ] ); 324cdf0e10cSrcweir for( ++nCol; nCol<nNewColumnCount; ++nCol ) 325cdf0e10cSrcweir aNewData[ ::std::slice( nCol, m_nRowCount, nNewColumnCount ) ] = 326cdf0e10cSrcweir static_cast< tDataType >( 327cdf0e10cSrcweir m_aData[ ::std::slice( nCol - 1, m_nRowCount, m_nColumnCount ) ] ); 328cdf0e10cSrcweir 329cdf0e10cSrcweir m_nColumnCount = nNewColumnCount; 330cdf0e10cSrcweir m_aData.resize( nNewSize ); 331cdf0e10cSrcweir m_aData = aNewData; 332cdf0e10cSrcweir 333cdf0e10cSrcweir // labels 334cdf0e10cSrcweir if( nAfterIndex < static_cast< sal_Int32 >( m_aColumnLabels.size())) 335cdf0e10cSrcweir m_aColumnLabels.insert( m_aColumnLabels.begin() + (nAfterIndex + 1), vector< uno::Any >(1) ); 336cdf0e10cSrcweir 337cdf0e10cSrcweir #if OSL_DEBUG_LEVEL > 2 338cdf0e10cSrcweir traceData(); 339cdf0e10cSrcweir #endif 340cdf0e10cSrcweir } 341cdf0e10cSrcweir 342cdf0e10cSrcweir sal_Int32 InternalData::appendColumn() 343cdf0e10cSrcweir { 344cdf0e10cSrcweir insertColumn( getColumnCount() - 1 ); 345cdf0e10cSrcweir return getColumnCount() - 1; 346cdf0e10cSrcweir } 347cdf0e10cSrcweir 348cdf0e10cSrcweir sal_Int32 InternalData::appendRow() 349cdf0e10cSrcweir { 350cdf0e10cSrcweir insertRow( getRowCount() - 1 ); 351cdf0e10cSrcweir return getRowCount() - 1; 352cdf0e10cSrcweir } 353cdf0e10cSrcweir 354cdf0e10cSrcweir void InternalData::insertRow( sal_Int32 nAfterIndex ) 355cdf0e10cSrcweir { 356cdf0e10cSrcweir // note: -1 is allowed, as we insert after the given index 357cdf0e10cSrcweir OSL_ASSERT( nAfterIndex < m_nRowCount && nAfterIndex >= -1 ); 358cdf0e10cSrcweir if( nAfterIndex >= m_nRowCount || nAfterIndex < -1 ) 359cdf0e10cSrcweir return; 360cdf0e10cSrcweir sal_Int32 nNewRowCount = m_nRowCount + 1; 361cdf0e10cSrcweir sal_Int32 nNewSize( m_nColumnCount * nNewRowCount ); 362cdf0e10cSrcweir 363cdf0e10cSrcweir double fNan; 364cdf0e10cSrcweir ::rtl::math::setNan( &fNan ); 365cdf0e10cSrcweir tDataType aNewData( fNan, nNewSize ); 366cdf0e10cSrcweir 367cdf0e10cSrcweir // copy old data 368cdf0e10cSrcweir sal_Int32 nIndex = nAfterIndex + 1; 369cdf0e10cSrcweir aNewData[ ::std::slice( 0, nIndex * m_nColumnCount, 1 ) ] = 370cdf0e10cSrcweir static_cast< tDataType >( 371cdf0e10cSrcweir m_aData[ ::std::slice( 0, nIndex * m_nColumnCount, 1 ) ] ); 372cdf0e10cSrcweir 373cdf0e10cSrcweir if( nIndex < m_nRowCount ) 374cdf0e10cSrcweir { 375cdf0e10cSrcweir sal_Int32 nRemainingCount = m_nColumnCount * (m_nRowCount - nIndex); 376cdf0e10cSrcweir aNewData[ ::std::slice( (nIndex + 1) * m_nColumnCount, nRemainingCount, 1 ) ] = 377cdf0e10cSrcweir static_cast< tDataType >( 378cdf0e10cSrcweir m_aData[ ::std::slice( nIndex * m_nColumnCount, nRemainingCount, 1 ) ] ); 379cdf0e10cSrcweir } 380cdf0e10cSrcweir 381cdf0e10cSrcweir m_nRowCount = nNewRowCount; 382cdf0e10cSrcweir m_aData.resize( nNewSize ); 383cdf0e10cSrcweir m_aData = aNewData; 384cdf0e10cSrcweir 385cdf0e10cSrcweir // labels 386cdf0e10cSrcweir if( nAfterIndex < static_cast< sal_Int32 >( m_aRowLabels.size())) 387cdf0e10cSrcweir m_aRowLabels.insert( m_aRowLabels.begin() + nIndex, vector< uno::Any > (1)); 388cdf0e10cSrcweir 389cdf0e10cSrcweir #if OSL_DEBUG_LEVEL > 2 390cdf0e10cSrcweir traceData(); 391cdf0e10cSrcweir #endif 392cdf0e10cSrcweir } 393cdf0e10cSrcweir 394cdf0e10cSrcweir void InternalData::deleteColumn( sal_Int32 nAtIndex ) 395cdf0e10cSrcweir { 396cdf0e10cSrcweir OSL_ASSERT( nAtIndex < m_nColumnCount && nAtIndex >= 0 ); 397cdf0e10cSrcweir if( nAtIndex >= m_nColumnCount || m_nColumnCount < 1 || nAtIndex < 0 ) 398cdf0e10cSrcweir return; 399cdf0e10cSrcweir sal_Int32 nNewColumnCount = m_nColumnCount - 1; 400cdf0e10cSrcweir sal_Int32 nNewSize( nNewColumnCount * m_nRowCount ); 401cdf0e10cSrcweir 402cdf0e10cSrcweir double fNan; 403cdf0e10cSrcweir ::rtl::math::setNan( &fNan ); 404cdf0e10cSrcweir tDataType aNewData( fNan, nNewSize ); 405cdf0e10cSrcweir 406cdf0e10cSrcweir // copy old data 407cdf0e10cSrcweir int nCol=0; 408cdf0e10cSrcweir for( ; nCol<nAtIndex; ++nCol ) 409cdf0e10cSrcweir aNewData[ ::std::slice( nCol, m_nRowCount, nNewColumnCount ) ] = 410cdf0e10cSrcweir static_cast< tDataType >( 411cdf0e10cSrcweir m_aData[ ::std::slice( nCol, m_nRowCount, m_nColumnCount ) ] ); 412cdf0e10cSrcweir for( ; nCol<nNewColumnCount; ++nCol ) 413cdf0e10cSrcweir aNewData[ ::std::slice( nCol, m_nRowCount, nNewColumnCount ) ] = 414cdf0e10cSrcweir static_cast< tDataType >( 415cdf0e10cSrcweir m_aData[ ::std::slice( nCol + 1, m_nRowCount, m_nColumnCount ) ] ); 416cdf0e10cSrcweir 417cdf0e10cSrcweir m_nColumnCount = nNewColumnCount; 418cdf0e10cSrcweir m_aData.resize( nNewSize ); 419cdf0e10cSrcweir m_aData = aNewData; 420cdf0e10cSrcweir 421cdf0e10cSrcweir // labels 422cdf0e10cSrcweir if( nAtIndex < static_cast< sal_Int32 >( m_aColumnLabels.size())) 423cdf0e10cSrcweir m_aColumnLabels.erase( m_aColumnLabels.begin() + nAtIndex ); 424cdf0e10cSrcweir 425cdf0e10cSrcweir #if OSL_DEBUG_LEVEL > 2 426cdf0e10cSrcweir traceData(); 427cdf0e10cSrcweir #endif 428cdf0e10cSrcweir } 429cdf0e10cSrcweir 430cdf0e10cSrcweir void InternalData::deleteRow( sal_Int32 nAtIndex ) 431cdf0e10cSrcweir { 432cdf0e10cSrcweir OSL_ASSERT( nAtIndex < m_nRowCount && nAtIndex >= 0 ); 433cdf0e10cSrcweir if( nAtIndex >= m_nRowCount || m_nRowCount < 1 || nAtIndex < 0 ) 434cdf0e10cSrcweir return; 435cdf0e10cSrcweir sal_Int32 nNewRowCount = m_nRowCount - 1; 436cdf0e10cSrcweir sal_Int32 nNewSize( m_nColumnCount * nNewRowCount ); 437cdf0e10cSrcweir 438cdf0e10cSrcweir double fNan; 439cdf0e10cSrcweir ::rtl::math::setNan( &fNan ); 440cdf0e10cSrcweir tDataType aNewData( fNan, nNewSize ); 441cdf0e10cSrcweir 442cdf0e10cSrcweir // copy old data 443cdf0e10cSrcweir sal_Int32 nIndex = nAtIndex; 444cdf0e10cSrcweir if( nIndex ) 445cdf0e10cSrcweir aNewData[ ::std::slice( 0, nIndex * m_nColumnCount, 1 ) ] = 446cdf0e10cSrcweir static_cast< tDataType >( 447cdf0e10cSrcweir m_aData[ ::std::slice( 0, nIndex * m_nColumnCount, 1 ) ] ); 448cdf0e10cSrcweir 449cdf0e10cSrcweir if( nIndex < nNewRowCount ) 450cdf0e10cSrcweir { 451cdf0e10cSrcweir sal_Int32 nRemainingCount = m_nColumnCount * (nNewRowCount - nIndex); 452cdf0e10cSrcweir aNewData[ ::std::slice( nIndex * m_nColumnCount, nRemainingCount, 1 ) ] = 453cdf0e10cSrcweir static_cast< tDataType >( 454cdf0e10cSrcweir m_aData[ ::std::slice( (nIndex + 1) * m_nColumnCount, nRemainingCount, 1 ) ] ); 455cdf0e10cSrcweir } 456cdf0e10cSrcweir 457cdf0e10cSrcweir m_nRowCount = nNewRowCount; 458cdf0e10cSrcweir m_aData.resize( nNewSize ); 459cdf0e10cSrcweir m_aData = aNewData; 460cdf0e10cSrcweir 461cdf0e10cSrcweir // labels 462cdf0e10cSrcweir if( nAtIndex < static_cast< sal_Int32 >( m_aRowLabels.size())) 463cdf0e10cSrcweir m_aRowLabels.erase( m_aRowLabels.begin() + nAtIndex ); 464cdf0e10cSrcweir 465cdf0e10cSrcweir #if OSL_DEBUG_LEVEL > 2 466cdf0e10cSrcweir traceData(); 467cdf0e10cSrcweir #endif 468cdf0e10cSrcweir } 469cdf0e10cSrcweir 470cdf0e10cSrcweir sal_Int32 InternalData::getRowCount() const 471cdf0e10cSrcweir { 472cdf0e10cSrcweir return m_nRowCount; 473cdf0e10cSrcweir } 474cdf0e10cSrcweir 475cdf0e10cSrcweir sal_Int32 InternalData::getColumnCount() const 476cdf0e10cSrcweir { 477cdf0e10cSrcweir return m_nColumnCount; 478cdf0e10cSrcweir } 479cdf0e10cSrcweir 480cdf0e10cSrcweir void InternalData::setComplexRowLabels( const vector< vector< uno::Any > >& rNewRowLabels ) 481cdf0e10cSrcweir { 482cdf0e10cSrcweir m_aRowLabels = rNewRowLabels; 483cdf0e10cSrcweir sal_Int32 nNewRowCount = static_cast< sal_Int32 >( m_aRowLabels.size() ); 484cdf0e10cSrcweir if( nNewRowCount < m_nRowCount ) 485cdf0e10cSrcweir m_aRowLabels.resize( m_nRowCount ); 486cdf0e10cSrcweir else 487cdf0e10cSrcweir enlargeData( 0, nNewRowCount ); 488cdf0e10cSrcweir } 489cdf0e10cSrcweir 490cdf0e10cSrcweir vector< vector< uno::Any > > InternalData::getComplexRowLabels() const 491cdf0e10cSrcweir { 492cdf0e10cSrcweir return m_aRowLabels; 493cdf0e10cSrcweir } 494cdf0e10cSrcweir 495cdf0e10cSrcweir void InternalData::setComplexColumnLabels( const vector< vector< uno::Any > >& rNewColumnLabels ) 496cdf0e10cSrcweir { 497cdf0e10cSrcweir m_aColumnLabels = rNewColumnLabels; 498cdf0e10cSrcweir sal_Int32 nNewColumnCount = static_cast< sal_Int32 >( m_aColumnLabels.size() ); 499cdf0e10cSrcweir if( nNewColumnCount < m_nColumnCount ) 500cdf0e10cSrcweir m_aColumnLabels.resize( m_nColumnCount ); 501cdf0e10cSrcweir else 502cdf0e10cSrcweir enlargeData( nNewColumnCount, 0 ); 503cdf0e10cSrcweir } 504cdf0e10cSrcweir 505cdf0e10cSrcweir vector< vector< uno::Any > > InternalData::getComplexColumnLabels() const 506cdf0e10cSrcweir { 507cdf0e10cSrcweir return m_aColumnLabels; 508cdf0e10cSrcweir } 509cdf0e10cSrcweir 510cdf0e10cSrcweir #if OSL_DEBUG_LEVEL > 2 511cdf0e10cSrcweir void InternalData::traceData() const 512cdf0e10cSrcweir { 513cdf0e10cSrcweir OSL_TRACE( "InternalData: Data in rows\n" ); 514cdf0e10cSrcweir 515cdf0e10cSrcweir for( sal_Int32 i=0; i<m_nRowCount; ++i ) 516cdf0e10cSrcweir { 517cdf0e10cSrcweir tDataType aSlice( m_aData[ ::std::slice( i*m_nColumnCount, m_nColumnCount, 1 ) ] ); 518cdf0e10cSrcweir for( sal_Int32 j=0; j<m_nColumnCount; ++j ) 519cdf0e10cSrcweir OSL_TRACE( "%lf ", aSlice[j] ); 520cdf0e10cSrcweir OSL_TRACE( "\n" ); 521cdf0e10cSrcweir } 522cdf0e10cSrcweir OSL_TRACE( "\n" ); 523cdf0e10cSrcweir } 524cdf0e10cSrcweir #endif 525cdf0e10cSrcweir 526cdf0e10cSrcweir } // namespace chart 527