You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
kmymoney/libkdchart/KDChartListTable.h

485 lines
14 KiB

/* -*- Mode: C++ -*-
KDChart - a multi-platform charting engine
*/
/****************************************************************************
** Copyright (C) 2001-2003 Klarälvdalens Datakonsult AB. All rights reserved.
**
** This file is part of the KDChart library.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** Licensees holding valid commercial KDChart licenses may use this file in
** accordance with the KDChart Commercial License Agreement provided with
** the Software.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.klaralvdalens-datakonsult.se/?page=products for
** information about KDChart Commercial License Agreements.
**
** Contact info@klaralvdalens-datakonsult.se if any conditions of this
** licensing are not clear to you.
**
**********************************************************************/
#ifndef __KDCHARTLISTTABLE_H__
#define __KDCHARTLISTTABLE_H__
#include <tqvaluelist.h>
#include <tqshared.h>
#include <tqtable.h>
#include <KDChartDataIntern.h>
#include <KDChartTableBase.h>
class KDCHART_EXPORT KDChartListTablePrivate : public TQShared
{
public:
KDChartListTablePrivate() : TQShared() {
row_count = 0;
col_count = 0;
}
KDChartListTablePrivate( uint _rows, uint _cols ) : TQShared() {
for ( uint i = 0; i < _rows; i++ )
row_list.append( int() );
for ( uint j = 0; j < _cols; j++ )
col_list.append( int() );
for ( uint k = 0; k < _rows * _cols; k++ )
matrix.append( KDChartData() );
col_count = _cols;
row_count = _rows;
}
KDChartListTablePrivate( const KDChartListTablePrivate& _t ) :
TQShared(),
matrix( _t.matrix ),
row_list( _t.row_list ),
col_list( _t.col_list ),
col_count( _t.col_count ),
row_count( _t.row_count ) {}
~KDChartListTablePrivate() {}
void expand( uint _rows, uint _cols ) {
if ( _rows > row_count ) {
for ( uint r = 0; r < _rows - row_count; ++r ) {
row_list.append( int() );
for ( uint i = 0; i < col_count; ++i )
matrix.append( KDChartData() );
}
row_count = _rows;
}
if ( _cols > col_count ) {
uint old = col_count;
col_count = _cols;
for ( uint c = 0; c < _cols - old; ++c ) {
col_list.append( int() );
for ( uint i = 0; i < row_count; ++i )
matrix.insert( matrix.at( i * col_count + old + c ), KDChartData() );
}
}
}
const KDChartData& cell( uint _row, uint _col ) const
{
Q_ASSERT( _row < row_count && _col < col_count );
return matrix[ static_cast < int > ( _row * col_count + _col ) ];
}
KDChartData& cell( uint _row, uint _col )
{
Q_ASSERT( _row < row_count && _col < col_count );
return matrix[ static_cast < int > ( _row * col_count + _col ) ];
}
void setCell( uint _row, uint _col, const KDChartData& _element )
{
Q_ASSERT( _row < row_count && _col < col_count );
matrix[ static_cast < int > ( _row * col_count + _col ) ].setAll( _element );
}
void clearCell( uint _row, uint _col ) {
Q_ASSERT( _row < row_count && _col < col_count );
matrix[ static_cast < int > ( _row * col_count + _col ) ].clearValue();
}
void clearAllCells() {
for ( uint r = 0; r < row_count; ++r )
for ( uint c = 0; c < col_count; ++c )
matrix[ static_cast < int > ( r * col_count + c ) ].clearValue();
}
int& row( uint _row ) {
Q_ASSERT( _row < row_count );
return row_list[ _row ];
}
const int& row( uint _row ) const {
Q_ASSERT( _row < row_count );
return row_list[ _row ];
}
void setRow( uint _row, const int& _v ) {
Q_ASSERT( _row < row_count );
row_list[ _row ] = _v;
}
int& col( uint _col ) {
Q_ASSERT( _col < col_count );
return col_list[ _col ];
}
const int& col( uint _col ) const {
Q_ASSERT( _col < col_count );
return col_list[ _col ];
}
void setCol( uint _col, const int& _v ) {
Q_ASSERT( _col < col_count );
col_list[ _col ] = _v;
}
void insertColumn( uint _c ) {
Q_ASSERT( _c <= col_count );
++col_count;
TQValueList < KDChartData > ::Iterator it;
for ( uint i = 0; i < row_count; ++i ) {
it = matrix.at( i * col_count + _c );
matrix.insert( it, KDChartData() );
}
TQValueList < int > ::Iterator it2 = col_list.at( _c );
col_list.insert( it2, int() );
}
void insertRow( uint _r ) {
Q_ASSERT( _r <= row_count );
++row_count;
TQValueList < KDChartData > ::Iterator it = matrix.at( _r * col_count );
for ( uint i = 0; i < col_count; ++i )
matrix.insert( it, KDChartData() );
TQValueList < int > ::Iterator it2 = row_list.at( _r );
row_list.insert( it2, int() );
}
void removeColumn( uint _c ) {
Q_ASSERT( _c < col_count );
--col_count;
TQValueList < KDChartData > ::Iterator it;
for ( uint i = 0; i < row_count; ++i ) {
it = matrix.at( i * col_count + _c );
matrix.remove( it );
}
TQValueList < int > ::Iterator it2 = col_list.at( _c );
col_list.remove( it2 );
}
void removeRow( uint _r ) {
Q_ASSERT( _r < row_count );
--row_count;
TQValueList < KDChartData > ::Iterator it = matrix.at( _r * col_count );
for ( uint i = 0; i < col_count; ++i )
it = matrix.remove( it );
TQValueList < int > ::Iterator it2 = row_list.at( _r );
row_list.remove( it2 );
}
TQValueList < KDChartData > matrix;
TQValueList < int > row_list;
TQValueList < int > col_list;
uint col_count;
uint row_count;
};
class KDChartListTableData : public KDChartTableDataBase
{
private:
typedef KDChartListTablePrivate Priv;
uint _usedRows, _usedCols;
public:
/**
* Typedefs
*/
typedef TQValueList < KDChartData > ::Iterator Iterator;
typedef TQValueList < KDChartData > ::ConstIterator ConstIterator;
typedef TQValueList < int > ::Iterator RowIterator;
typedef TQValueList < int > ::ConstIterator ConstRowIterator;
typedef TQValueList < int > ::Iterator ColIterator;
typedef TQValueList < int > ::ConstIterator ConstColIterator;
/**
* API
*/
KDChartListTableData() :
KDChartTableDataBase()
{
sh = new Priv;
_usedCols = 0;
_usedRows = 0;
}
KDChartListTableData( uint _rows, uint _cols ) :
KDChartTableDataBase()
{
sh = new Priv( _rows, _cols );
_usedRows = _rows;
_usedCols = _cols;
}
KDChartListTableData( const KDChartListTableData& _t ) :
KDChartTableDataBase( _t ) {
_useUsedRows = _t._useUsedRows;
_useUsedCols = _t._useUsedCols;
_usedRows = _t._usedRows;
_usedCols = _t._usedCols;
sh = _t.sh;
sh->ref();
setSorted( _t.sorted() );
}
virtual ~KDChartListTableData() {
if ( sh->deref() )
delete sh;
}
KDChartListTableData& operator=( const KDChartListTableData& t ) {
if ( &t == this )
return * this;
_useUsedRows = t._useUsedRows;
_useUsedCols = t._useUsedCols;
_usedRows = t._usedRows;
_usedCols = t._usedCols;
t.sh->ref();
if ( sh->deref() )
delete sh;
sh = t.sh;
setSorted( t.sorted() );
return *this;
}
Iterator begin() {
return sh->matrix.begin();
}
ConstIterator begin() const {
return sh->matrix.begin();
}
Iterator end() {
return sh->matrix.end();
}
ConstIterator end() const {
return sh->matrix.end();
}
ColIterator colBegin() {
return sh->col_list.begin();
}
ConstColIterator colBegin() const {
return sh->col_list.begin();
}
ColIterator colEnd() {
return sh->col_list.end();
}
ConstColIterator colEnd() const
{
return sh->col_list.end();
}
RowIterator rowBegin() {
return sh->row_list.begin();
}
ConstRowIterator rowBegin() const {
return sh->row_list.begin();
}
RowIterator rowEnd() {
return sh->row_list.end();
}
ConstRowIterator rowEnd() const {
return sh->row_list.end();
}
bool isEmpty() const {
return ( sh->col_count == 0 && sh->row_count == 0 );
}
uint cols() const {
return sh->col_count;
}
uint rows() const {
return sh->row_count;
}
virtual bool cellCoord( uint _row, uint _col,
TQVariant& _value,
int coordinate=1 ) const
{
if( _row >= sh->row_count || _col >= sh->col_count )
return false;
_value = sh->cell( _row, _col ).value( coordinate );
return true;
}
virtual bool cellProp( uint _row, uint _col,
int& _prop ) const
{
if( _row >= sh->row_count || _col >= sh->col_count )
return false;
_prop = sh->cell( _row, _col ).propertySet();
return true;
}
virtual void setCell( uint _row, uint _col,
const TQVariant& _value1,
const TQVariant& _value2=TQVariant() )
{
detach();
const KDChartData element( _value1, _value2 );
sh->setCell( _row, _col, element );
}
virtual void setProp( uint _row, uint _col,
int _propSet=0 )
{
sh->cell( _row, _col ).setPropertySet( _propSet );
}
void clearCell( uint _row, uint _col ) {
detach();
sh->clearCell( _row, _col );
}
void clearAllCells() {
detach();
sh->clearAllCells();
}
int& row( uint _row ) {
detach();
return sh->row( _row );
}
const int& row( uint _row ) const {
return sh->row( _row );
}
void setRow( uint _row, const int& _v ) {
detach();
sh->setRow( _row, _v );
}
int& col( uint _col ) {
detach();
return sh->col( _col );
}
const int& col( uint _col ) const {
return sh->col( _col );
}
void setCol( uint _col, const int& _v ) {
detach();
sh->setCol( _col, _v );
}
void insertColumn( uint _c ) {
detach();
sh->insertColumn( _c );
++_usedCols;
}
void insertRow( uint _r ) {
detach();
sh->insertRow( _r );
++_usedRows;
}
void removeColumn( uint _c ) {
detach();
sh->removeColumn( _c );
if( _usedCols )
--_usedCols;
}
void removeRow( uint _r ) {
detach();
sh->removeRow( _r );
if( _usedRows )
--_usedRows;
}
void expand( uint _rows, uint _cols ) {
detach();
sh->expand( _rows, _cols );
// adjust the usedRows / usedCols, if they had been set before
if( _useUsedCols )
setUsedCols( TQMIN( _usedCols, _cols ) );
if( _useUsedRows )
setUsedRows( TQMIN( _usedRows, _rows ) );
}
void setUsedRows( uint _rows ) {
Q_ASSERT( _rows <= rows() );
if( _usedRows < _rows )
setSorted( false );
_usedRows = _rows;
_useUsedRows = true;
}
uint usedRows() const {
return _useUsedRows ? _usedRows : rows();
}
void setUsedCols( uint _cols ) {
Q_ASSERT( _cols <= cols() );
if( _usedCols < _cols )
setSorted( false );
_usedCols = _cols;
_useUsedCols = true;
}
uint usedCols() const {
return _useUsedCols ? _usedCols : cols();
}
private:
/**
* Helpers
*/
void detach() {
if ( sh->count > 1 ) {
sh->deref();
sh = new Priv( *sh );
}
setSorted( false );
}
/**
* Variables
*/
Priv* sh;
};
#endif
// __KDCHARTLISTTABLE_H__