|
|
|
/* -*- 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 __KDCHARTVECTORTABLE_H__
|
|
|
|
#define __KDCHARTVECTORTABLE_H__
|
|
|
|
|
|
|
|
#include <tqvaluevector.h>
|
|
|
|
#include <tqshared.h>
|
|
|
|
#include <tqtable.h>
|
|
|
|
|
|
|
|
#include <KDChartDataIntern.h>
|
|
|
|
#include <KDChartTableBase.h>
|
|
|
|
|
|
|
|
class KDCHART_EXPORT KDChartVectorTablePrivate : public TQShared
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
KDChartVectorTablePrivate() : TQShared() {
|
|
|
|
row_count = 0;
|
|
|
|
col_count = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
KDChartVectorTablePrivate( uint _rows, uint _cols ) : TQShared() {
|
|
|
|
matrix.resize( _rows * _cols, KDChartData() );
|
|
|
|
col_count = _cols;
|
|
|
|
row_count = _rows;
|
|
|
|
}
|
|
|
|
|
|
|
|
KDChartVectorTablePrivate( const KDChartVectorTablePrivate& _t ) :
|
|
|
|
TQShared(),
|
|
|
|
matrix( _t.matrix ),
|
|
|
|
col_count( _t.col_count ),
|
|
|
|
row_count( _t.row_count ) {}
|
|
|
|
|
|
|
|
~KDChartVectorTablePrivate() {}
|
|
|
|
|
|
|
|
void expand( uint _rows, uint _cols ) {
|
|
|
|
// Save the old table
|
|
|
|
TQValueVector<KDChartData> save( matrix );
|
|
|
|
|
|
|
|
// Delete old data, then resize
|
|
|
|
matrix.resize( 0 );
|
|
|
|
matrix.resize( _rows * _cols, KDChartData() );
|
|
|
|
|
|
|
|
// Copy over the old data
|
|
|
|
for( uint row = 0; row < TQMIN( row_count, _rows ); row++ )
|
|
|
|
for( uint col = 0; col < TQMIN( col_count, _cols ); col++ )
|
|
|
|
matrix[ row * _cols + col ].setAll( save[ row * col_count + col ] );
|
|
|
|
|
|
|
|
// set the new counts
|
|
|
|
col_count = _cols;
|
|
|
|
row_count = _rows;
|
|
|
|
}
|
|
|
|
|
|
|
|
KDChartData& cell( uint _row, uint _col ) {
|
|
|
|
Q_ASSERT( _row < row_count );
|
|
|
|
Q_ASSERT( _col < col_count );
|
|
|
|
return matrix[ static_cast < int > ( _row * col_count + _col ) ];
|
|
|
|
}
|
|
|
|
const KDChartData& cell( uint _row, uint _col ) const {
|
|
|
|
Q_ASSERT( _row < row_count );
|
|
|
|
Q_ASSERT( _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 );
|
|
|
|
Q_ASSERT( _col < col_count );
|
|
|
|
matrix[ static_cast < int > ( _row * col_count + _col ) ].setAll( _element );
|
|
|
|
}
|
|
|
|
|
|
|
|
void clearCell( uint _row, uint _col ) {
|
|
|
|
Q_ASSERT( _row < row_count );
|
|
|
|
Q_ASSERT( _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[ r * col_count + c ].clearValue();
|
|
|
|
}
|
|
|
|
|
|
|
|
TQValueVector<KDChartData> matrix;
|
|
|
|
|
|
|
|
uint col_count;
|
|
|
|
uint row_count;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
class KDCHART_EXPORT KDChartVectorTableData : public KDChartTableDataBase
|
|
|
|
{
|
|
|
|
Q_OBJECT
|
|
|
|
TQ_OBJECT
|
|
|
|
|
|
|
|
private:
|
|
|
|
typedef KDChartVectorTablePrivate Priv;
|
|
|
|
uint _usedRows, _usedCols;
|
|
|
|
|
|
|
|
public:
|
|
|
|
/**
|
|
|
|
* Typedefs
|
|
|
|
*/
|
|
|
|
typedef TQValueVector<KDChartData>::iterator Iterator;
|
|
|
|
typedef TQValueVector<KDChartData>::const_iterator ConstIterator;
|
|
|
|
|
|
|
|
typedef TQValueVector<int>::iterator RowIterator;
|
|
|
|
typedef TQValueVector<int>::const_iterator ConstRowIterator;
|
|
|
|
|
|
|
|
typedef TQValueVector<int>::iterator ColIterator;
|
|
|
|
typedef TQValueVector<int>::const_iterator ConstColIterator;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* API
|
|
|
|
*/
|
|
|
|
KDChartVectorTableData() :
|
|
|
|
KDChartTableDataBase()
|
|
|
|
{
|
|
|
|
sh = new Priv;
|
|
|
|
_usedCols = 0;
|
|
|
|
_usedRows = 0;
|
|
|
|
}
|
|
|
|
KDChartVectorTableData( uint _rows, uint _cols ) :
|
|
|
|
KDChartTableDataBase()
|
|
|
|
{
|
|
|
|
sh = new Priv( _rows, _cols );
|
|
|
|
_usedRows = _rows;
|
|
|
|
_usedCols = _cols;
|
|
|
|
}
|
|
|
|
|
|
|
|
KDChartVectorTableData( const KDChartVectorTableData& _t ) :
|
|
|
|
KDChartTableDataBase( _t ) {
|
|
|
|
_useUsedRows = _t._useUsedRows;
|
|
|
|
_useUsedCols = _t._useUsedCols;
|
|
|
|
_usedRows = _t._usedRows;
|
|
|
|
_usedCols = _t._usedCols;
|
|
|
|
sh = _t.sh;
|
|
|
|
sh->ref();
|
|
|
|
setSorted( _t.sorted() );
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual ~KDChartVectorTableData() {
|
|
|
|
if ( sh->deref() )
|
|
|
|
delete sh;
|
|
|
|
}
|
|
|
|
|
|
|
|
KDChartVectorTableData& operator=( const KDChartVectorTableData& 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;
|
|
|
|
}
|
|
|
|
|
|
|
|
public slots:
|
|
|
|
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();
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
// WARNING: The KDChartData class is an internal class now,
|
|
|
|
// and nobody supposed to use it any longer.
|
|
|
|
// Instead, please use cellCoord(), cellProp(), setCell(), setProp(), ...
|
|
|
|
// (khz, 2006-05-23)
|
|
|
|
/*
|
|
|
|
KDChartData& cell( uint _row, uint _col ) {
|
|
|
|
detach();
|
|
|
|
return sh->cell( _row, _col );
|
|
|
|
}
|
|
|
|
*/
|
|
|
|
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();
|
|
|
|
}
|
|
|
|
|
|
|
|
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__
|
|
|
|
|