public SlidingCategoryDataset(CategoryDataset underlying,
    int firstColumn,
    int maxColumns) 
{
        this.underlying = underlying;
        this.firstCategoryIndex = firstColumn;
        this.maximumCategoryCount = maxColumns;
}

Creates a new instance.

Parameters:

underlying - the underlying dataset (null not permitted).

firstColumn - the index of the first visible column from the underlying dataset.

maxColumns - the maximumColumnCount.

 public Object clone() throws CloneNotSupportedException 
{
        SlidingCategoryDataset clone = (SlidingCategoryDataset) super.clone();
        if (this.underlying instanceof PublicCloneable) {
        	PublicCloneable pc = (PublicCloneable) this.underlying;
            clone.underlying = (CategoryDataset) pc.clone();
        }
        return clone;
}

Returns an independent copy of the dataset. Note that:
• the underlying dataset is only cloned if it implements the PublicCloneable interface;
• the listeners registered with this dataset are not carried over to the cloned dataset.

 public boolean equals(Object obj) 
{
		if (obj == this) {
			return true;
		}
		if (!(obj instanceof SlidingCategoryDataset)) {
			return false;
		}
		SlidingCategoryDataset that = (SlidingCategoryDataset) obj;
		if (this.firstCategoryIndex != that.firstCategoryIndex) {
			return false;
		}
		if (this.maximumCategoryCount != that.maximumCategoryCount) {
			return false;
		}
		if (!this.underlying.equals(that.underlying)) {
			return false;
		}
		return true;
}

Tests this SlidingCategoryDataset for equality with an arbitrary object.

 public int getColumnCount() 
{
		int last = lastCategoryIndex();
		if (last == -1) {
			return 0;
		}
		else {
            return Math.max(last - this.firstCategoryIndex + 1, 0);
		}
}

Returns the number of columns in the table.

 public int getColumnIndex(Comparable key) 
{
		int index = this.underlying.getColumnIndex(key);
		if (index  >= this.firstCategoryIndex && index < = lastCategoryIndex()) {
			return index - this.firstCategoryIndex;
		}
		return -1;  // we didn't find the key
}

Returns the index for the specified column key.

 public Comparable getColumnKey(int column) 
{
		return this.underlying.getColumnKey(column + this.firstCategoryIndex);
}

Returns the column key for a given index.

 public List getColumnKeys() 
{
		List result = new java.util.ArrayList();
		int last = lastCategoryIndex();
		for (int i = this.firstCategoryIndex; i <  last; i++) {
			result.add(this.underlying.getColumnKey(i));
		}
		return Collections.unmodifiableList(result);
}

Returns the column keys.

 public int getFirstCategoryIndex() 
{
		return this.firstCategoryIndex;
}

Returns the index of the first visible category.

 public int getMaximumCategoryCount() 
{
		return this.maximumCategoryCount;
}

Returns the maximum category count.

 public int getRowCount() 
{
		return this.underlying.getRowCount();
}

Returns the number of rows in the table.

 public int getRowIndex(Comparable key) 
{
		return this.underlying.getRowIndex(key);
}

Returns the row index for a given key.

 public Comparable getRowKey(int row) 
{
		return this.underlying.getRowKey(row);
}

Returns the row key for a given index.

 public List getRowKeys() 
{
		return this.underlying.getRowKeys();
}

Returns the row keys.

 public CategoryDataset getUnderlyingDataset() 
{
		return this.underlying;
}

Returns the underlying dataset that was supplied to the constructor.

 public Number getValue(Comparable rowKey,
    Comparable columnKey) 
{
		int r = getRowIndex(rowKey);
		int c = getColumnIndex(columnKey);
		if (c != -1) {
            return this.underlying.getValue(r, c + this.firstCategoryIndex);
		}
		else {
			throw new UnknownKeyException("Unknown columnKey: " + columnKey);
		}
}

Returns the value for a pair of keys.

 public Number getValue(int row,
    int column) 
{
		return this.underlying.getValue(row, column + this.firstCategoryIndex);
}

Returns a value from the table.

 public  void setFirstCategoryIndex(int first) 
{
		if (first <  0 || first  >= this.underlying.getColumnCount()) {
			throw new IllegalArgumentException("Invalid index.");
		}
		this.firstCategoryIndex = first;
		fireDatasetChanged();
}

Sets the index of the first category that should be used from the underlying dataset, and sends a DatasetChangeEvent to all registered listeners.

 public  void setMaximumCategoryCount(int max) 
{
		if (max <  0) {
			throw new IllegalArgumentException("Requires 'max'  >= 0.");
		}
		this.maximumCategoryCount = max;
		fireDatasetChanged();
}

Sets the maximum category count and sends a DatasetChangeEvent to all registered listeners.