Você não pode selecionar mais de 25 tópicos
Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.
609 linhas
15 KiB
609 linhas
15 KiB
/*
|
|
* File name: ktreemaptile.cpp
|
|
* Summary: High level classes for KDirStat
|
|
* License: LGPL - See file COPYING.LIB for details.
|
|
* Author: Stefan Hundhammer <sh@suse.de>
|
|
*
|
|
* Updated: 2003-01-30
|
|
*/
|
|
|
|
|
|
#include <math.h>
|
|
#include <algorithm>
|
|
|
|
#include <kapp.h>
|
|
#include <tdelocale.h>
|
|
#include <tdeglobal.h>
|
|
#include <tqimage.h>
|
|
#include <tqpainter.h>
|
|
|
|
#include "ktreemaptile.h"
|
|
#include "ktreemapview.h"
|
|
#include "kdirtreeiterators.h"
|
|
#include "kdirtreeview.h"
|
|
|
|
|
|
using namespace KDirStat;
|
|
using std::max;
|
|
using std::min;
|
|
|
|
|
|
KTreemapTile::KTreemapTile( KTreemapView * parentView,
|
|
KTreemapTile * parentTile,
|
|
KFileInfo * orig,
|
|
const TQRect & rect,
|
|
KOrientation orientation )
|
|
: TQCanvasRectangle( rect, parentView->canvas() )
|
|
, _parentView( parentView )
|
|
, _parentTile( parentTile )
|
|
, _orig( orig )
|
|
{
|
|
init();
|
|
|
|
if ( parentTile )
|
|
_cushionSurface = parentTile->cushionSurface();
|
|
|
|
createChildren( rect, orientation );
|
|
}
|
|
|
|
|
|
KTreemapTile::KTreemapTile( KTreemapView * parentView,
|
|
KTreemapTile * parentTile,
|
|
KFileInfo * orig,
|
|
const TQRect & rect,
|
|
const KCushionSurface & cushionSurface,
|
|
KOrientation orientation )
|
|
: TQCanvasRectangle( rect, parentView->canvas() )
|
|
, _parentView( parentView )
|
|
, _parentTile( parentTile )
|
|
, _orig( orig )
|
|
, _cushionSurface( cushionSurface )
|
|
{
|
|
init();
|
|
|
|
// Intentionally not copying the parent's cushion surface!
|
|
|
|
createChildren( rect, orientation );
|
|
}
|
|
|
|
|
|
KTreemapTile::~KTreemapTile()
|
|
{
|
|
// NOP
|
|
}
|
|
|
|
|
|
void
|
|
KTreemapTile::init()
|
|
{
|
|
// Set up height (z coordinate) - one level higher than the parent so this
|
|
// will be closer to the foreground.
|
|
//
|
|
// Note that this must happen before any children are created.
|
|
// I found that out the hard way. ;-)
|
|
|
|
setZ( _parentTile ? ( _parentTile->z() + 1.0 ) : 0.0 );
|
|
|
|
setBrush( TQColor( 0x60, 0x60, 0x60 ) );
|
|
setPen( TQt::NoPen );
|
|
|
|
show(); // TQCanvasItems are invisible by default!
|
|
|
|
// kdDebug() << "Creating treemap tile for " << orig << " " << rect << " size " << orig->totalSize() << endl;
|
|
}
|
|
|
|
|
|
void
|
|
KTreemapTile::createChildren( const TQRect & rect,
|
|
KOrientation orientation )
|
|
{
|
|
if ( _orig->totalSize() == 0 ) // Prevent division by zero
|
|
return;
|
|
|
|
if ( _parentView->squarify() )
|
|
createSquarifiedChildren( rect );
|
|
else
|
|
createChildrenSimple( rect, orientation );
|
|
}
|
|
|
|
|
|
void
|
|
KTreemapTile::createChildrenSimple( const TQRect & rect,
|
|
KOrientation orientation )
|
|
{
|
|
|
|
KOrientation dir = orientation;
|
|
KOrientation childDir = orientation;
|
|
|
|
if ( dir == KTreemapAuto )
|
|
dir = rect.width() > rect.height() ? KTreemapHorizontal : KTreemapVertical;
|
|
|
|
if ( orientation == KTreemapHorizontal ) childDir = KTreemapVertical;
|
|
if ( orientation == KTreemapVertical ) childDir = KTreemapHorizontal;
|
|
|
|
int offset = 0;
|
|
int size = dir == KTreemapHorizontal ? rect.width() : rect.height();
|
|
int count = 0;
|
|
double scale = (double) size / (double) _orig->totalSize();
|
|
|
|
_cushionSurface.addRidge( childDir, _cushionSurface.height(), rect );
|
|
|
|
KFileInfoSortedBySizeIterator it( _orig,
|
|
(KFileSize) ( _parentView->minTileSize() / scale ),
|
|
KDotEntryAsSubDir );
|
|
|
|
while ( *it )
|
|
{
|
|
int childSize = 0;
|
|
|
|
childSize = (int) ( scale * (*it)->totalSize() );
|
|
|
|
if ( childSize >= _parentView->minTileSize() )
|
|
{
|
|
TQRect childRect;
|
|
|
|
if ( dir == KTreemapHorizontal )
|
|
childRect = TQRect( rect.x() + offset, rect.y(), childSize, rect.height() );
|
|
else
|
|
childRect = TQRect( rect.x(), rect.y() + offset, rect.width(), childSize );
|
|
|
|
KTreemapTile * tile = new KTreemapTile( _parentView, this, *it, childRect, childDir );
|
|
TQ_CHECK_PTR( tile );
|
|
|
|
tile->cushionSurface().addRidge( dir,
|
|
_cushionSurface.height() * _parentView->heightScaleFactor(),
|
|
childRect );
|
|
|
|
offset += childSize;
|
|
}
|
|
|
|
++count;
|
|
++it;
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
KTreemapTile::createSquarifiedChildren( const TQRect & rect )
|
|
{
|
|
if ( _orig->totalSize() == 0 )
|
|
{
|
|
kdError() << k_funcinfo << "Zero totalSize()" << endl;
|
|
return;
|
|
}
|
|
|
|
double scale = rect.width() * (double) rect.height() / _orig->totalSize();
|
|
KFileSize minSize = (KFileSize) ( _parentView->minTileSize() / scale );
|
|
|
|
#if 0
|
|
if ( _orig->hasChildren() )
|
|
{
|
|
_cushionSurface.addRidge( KTreemapHorizontal, _cushionSurface.height(), rect );
|
|
_cushionSurface.addRidge( KTreemapVertical, _cushionSurface.height(), rect );
|
|
}
|
|
#endif
|
|
|
|
KFileInfoSortedBySizeIterator it( _orig, minSize, KDotEntryAsSubDir );
|
|
TQRect childrenRect = rect;
|
|
|
|
while ( *it )
|
|
{
|
|
KFileInfoList row = squarify( childrenRect, scale, it );
|
|
childrenRect = layoutRow( childrenRect, scale, row );
|
|
}
|
|
}
|
|
|
|
|
|
KFileInfoList
|
|
KTreemapTile::squarify( const TQRect & rect,
|
|
double scale,
|
|
KFileInfoSortedBySizeIterator & it )
|
|
{
|
|
// kdDebug() << "squarify() " << _orig << " " << rect << endl;
|
|
|
|
KFileInfoList row;
|
|
int length = max( rect.width(), rect.height() );
|
|
|
|
if ( length == 0 ) // Sanity check
|
|
{
|
|
kdWarning() << k_funcinfo << "Zero length" << endl;
|
|
|
|
if ( *it ) // Prevent endless loop in case of error:
|
|
++it; // Advance iterator.
|
|
|
|
return row;
|
|
}
|
|
|
|
|
|
bool improvingAspectRatio = true;
|
|
double lastWorstAspectRatio = -1.0;
|
|
double sum = 0;
|
|
|
|
// This is a bit ugly, but doing all calculations in the 'size' dimension
|
|
// is more efficient here since that requires only one scaling before
|
|
// doing all other calculations in the loop.
|
|
const double scaledLengthSquare = length * (double) length / scale;
|
|
|
|
while ( *it && improvingAspectRatio )
|
|
{
|
|
sum += (*it)->totalSize();
|
|
|
|
if ( ! row.isEmpty() && sum != 0 && (*it)->totalSize() != 0 )
|
|
{
|
|
double sumSquare = sum * sum;
|
|
double worstAspectRatio = max( scaledLengthSquare * row.first()->totalSize() / sumSquare,
|
|
sumSquare / ( scaledLengthSquare * (*it)->totalSize() ) );
|
|
|
|
if ( lastWorstAspectRatio >= 0.0 &&
|
|
worstAspectRatio > lastWorstAspectRatio )
|
|
{
|
|
improvingAspectRatio = false;
|
|
}
|
|
|
|
lastWorstAspectRatio = worstAspectRatio;
|
|
}
|
|
|
|
if ( improvingAspectRatio )
|
|
{
|
|
// kdDebug() << "Adding " << *it << " size " << (*it)->totalSize() << endl;
|
|
row.append( *it );
|
|
++it;
|
|
}
|
|
else
|
|
{
|
|
// kdDebug() << "Getting worse after adding " << *it << " size " << (*it)->totalSize() << endl;
|
|
}
|
|
}
|
|
|
|
return row;
|
|
}
|
|
|
|
|
|
|
|
TQRect
|
|
KTreemapTile::layoutRow( const TQRect & rect,
|
|
double scale,
|
|
KFileInfoList & row )
|
|
{
|
|
if ( row.isEmpty() )
|
|
return rect;
|
|
|
|
// Determine the direction in which to subdivide.
|
|
// We always use the longer side of the rectangle.
|
|
KOrientation dir = rect.width() > rect.height() ? KTreemapHorizontal : KTreemapVertical;
|
|
|
|
// This row's primary length is the longer one.
|
|
int primary = max( rect.width(), rect.height() );
|
|
|
|
// This row's secondary length is determined by the area (the number of
|
|
// pixels) to be allocated for all of the row's items.
|
|
KFileSize sum = row.sumTotalSizes();
|
|
int secondary = (int) ( sum * scale / primary );
|
|
|
|
if ( sum == 0 ) // Prevent division by zero.
|
|
return rect;
|
|
|
|
if ( secondary < _parentView->minTileSize() ) // We don't want tiles that small.
|
|
return rect;
|
|
|
|
|
|
// Set up a cushion surface for this layout row:
|
|
// Add another ridge perpendicular to the row's direction
|
|
// that optically groups this row's tiles together.
|
|
|
|
KCushionSurface rowCushionSurface = _cushionSurface;
|
|
|
|
rowCushionSurface.addRidge( dir == KTreemapHorizontal ? KTreemapVertical : KTreemapHorizontal,
|
|
_cushionSurface.height() * _parentView->heightScaleFactor(),
|
|
rect );
|
|
|
|
int offset = 0;
|
|
int remaining = primary;
|
|
KFileInfoListIterator it( row );
|
|
|
|
while ( *it )
|
|
{
|
|
int childSize = (int) ( (*it)->totalSize() / (double) sum * primary + 0.5 );
|
|
|
|
if ( childSize > remaining ) // Prevent overflow because of accumulated rounding errors
|
|
childSize = remaining;
|
|
|
|
remaining -= childSize;
|
|
|
|
if ( childSize >= _parentView->minTileSize() )
|
|
{
|
|
TQRect childRect;
|
|
|
|
if ( dir == KTreemapHorizontal )
|
|
childRect = TQRect( rect.x() + offset, rect.y(), childSize, secondary );
|
|
else
|
|
childRect = TQRect( rect.x(), rect.y() + offset, secondary, childSize );
|
|
|
|
KTreemapTile * tile = new KTreemapTile( _parentView, this, *it, childRect, rowCushionSurface );
|
|
TQ_CHECK_PTR( tile );
|
|
|
|
tile->cushionSurface().addRidge( dir,
|
|
rowCushionSurface.height() * _parentView->heightScaleFactor(),
|
|
childRect );
|
|
offset += childSize;
|
|
}
|
|
|
|
++it;
|
|
}
|
|
|
|
|
|
// Subtract the layouted area from the rectangle.
|
|
|
|
TQRect newRect;
|
|
|
|
if ( dir == KTreemapHorizontal )
|
|
newRect = TQRect( rect.x(), rect.y() + secondary, rect.width(), rect.height() - secondary );
|
|
else
|
|
newRect = TQRect( rect.x() + secondary, rect.y(), rect.width() - secondary, rect.height() );
|
|
|
|
// kdDebug() << "Left over:" << " " << newRect << " " << _orig << endl;
|
|
|
|
return newRect;
|
|
}
|
|
|
|
|
|
void
|
|
KTreemapTile::drawShape( TQPainter & painter )
|
|
{
|
|
// kdDebug() << k_funcinfo << endl;
|
|
|
|
TQSize size = rect().size();
|
|
|
|
if ( size.height() < 1 || size.width() < 1 )
|
|
return;
|
|
|
|
|
|
if ( _parentView->doCushionShading() )
|
|
{
|
|
if ( _orig->isDir() || _orig->isDotEntry() )
|
|
{
|
|
TQCanvasRectangle::drawShape( painter );
|
|
}
|
|
else
|
|
{
|
|
if ( _cushion.isNull() )
|
|
_cushion = renderCushion();
|
|
|
|
TQRect rect = TQCanvasRectangle::rect();
|
|
|
|
if ( ! _cushion.isNull() )
|
|
painter.drawPixmap( rect, _cushion );
|
|
|
|
if ( _parentView->forceCushionGrid() )
|
|
{
|
|
// Draw a clearly visible boundary
|
|
|
|
painter.setPen( TQPen( _parentView->cushionGridColor(), 1 ) );
|
|
|
|
if ( rect.x() > 0 )
|
|
painter.drawLine( rect.topLeft(), rect.bottomLeft() + TQPoint( 0, 1 ) );
|
|
|
|
if ( rect.y() > 0 )
|
|
painter.drawLine( rect.topLeft(), rect.topRight() + TQPoint( 1, 0 ) );
|
|
}
|
|
}
|
|
}
|
|
else // No cushion shading, use plain tiles
|
|
{
|
|
painter.setPen( TQPen( _parentView->outlineColor(), 1 ) );
|
|
|
|
if ( _orig->isDir() || _orig->isDotEntry() )
|
|
painter.setBrush( _parentView->dirFillColor() );
|
|
else
|
|
{
|
|
painter.setBrush( _parentView->tileColor( _orig ) );
|
|
#if 0
|
|
painter.setBrush( _parentView->fileFillColor() );
|
|
#endif
|
|
}
|
|
|
|
TQCanvasRectangle::drawShape( painter );
|
|
}
|
|
}
|
|
|
|
|
|
TQPixmap
|
|
KTreemapTile::renderCushion()
|
|
{
|
|
TQRect rect = TQCanvasRectangle::rect();
|
|
|
|
if ( rect.width() < 1 || rect.height() < 1 )
|
|
return TQPixmap();
|
|
|
|
// kdDebug() << k_funcinfo << endl;
|
|
|
|
double nx;
|
|
double ny;
|
|
double cosa;
|
|
int x, y;
|
|
int red, green, blue;
|
|
|
|
|
|
// Cache some values. They are used for each loop iteration, so let's try
|
|
// to keep multiple indirect references down.
|
|
|
|
int ambientLight = parentView()->ambientLight();
|
|
double lightX = parentView()->lightX();
|
|
double lightY = parentView()->lightY();
|
|
double lightZ = parentView()->lightZ();
|
|
|
|
double xx2 = cushionSurface().xx2();
|
|
double xx1 = cushionSurface().xx1();
|
|
double yy2 = cushionSurface().yy2();
|
|
double yy1 = cushionSurface().yy1();
|
|
|
|
int x0 = rect.x();
|
|
int y0 = rect.y();
|
|
|
|
TQColor color = parentView()->tileColor( _orig );
|
|
int maxRed = max( 0, color.red() - ambientLight );
|
|
int maxGreen = max( 0, color.green() - ambientLight );
|
|
int maxBlue = max( 0, color.blue() - ambientLight );
|
|
|
|
TQImage image( rect.width(), rect.height(), 32 );
|
|
|
|
for ( y = 0; y < rect.height(); y++ )
|
|
{
|
|
for ( x = 0; x < rect.width(); x++ )
|
|
{
|
|
nx = 2.0 * xx2 * (x+x0) + xx1;
|
|
ny = 2.0 * yy2 * (y+y0) + yy1;
|
|
cosa = ( nx * lightX + ny * lightY + lightZ ) / sqrt( nx*nx + ny*ny + 1.0 );
|
|
|
|
red = (int) ( maxRed * cosa + 0.5 );
|
|
green = (int) ( maxGreen * cosa + 0.5 );
|
|
blue = (int) ( maxBlue * cosa + 0.5 );
|
|
|
|
if ( red < 0 ) red = 0;
|
|
if ( green < 0 ) green = 0;
|
|
if ( blue < 0 ) blue = 0;
|
|
|
|
red += ambientLight;
|
|
green += ambientLight;
|
|
blue += ambientLight;
|
|
|
|
image.setPixel( x, y, tqRgb( red, green, blue) );
|
|
}
|
|
}
|
|
|
|
if ( _parentView->ensureContrast() )
|
|
ensureContrast( image );
|
|
|
|
return TQPixmap( image );
|
|
}
|
|
|
|
|
|
void
|
|
KTreemapTile::ensureContrast( TQImage & image )
|
|
{
|
|
if ( image.width() > 5 )
|
|
{
|
|
// Check contrast along the right image boundary:
|
|
//
|
|
// Compare samples from the outmost boundary to samples a few pixels to
|
|
// the inside and count identical pixel values. A number of identical
|
|
// pixels are tolerated, but not too many.
|
|
|
|
int x1 = image.width() - 6;
|
|
int x2 = image.width() - 1;
|
|
int interval = max( image.height() / 10, 5 );
|
|
int sameColorCount = 0;
|
|
|
|
|
|
// Take samples
|
|
|
|
for ( int y = interval; y < image.height(); y+= interval )
|
|
{
|
|
if ( image.pixel( x1, y ) == image.pixel( x2, y ) )
|
|
sameColorCount++;
|
|
}
|
|
|
|
if ( sameColorCount * 10 > image.height() )
|
|
{
|
|
// Add a line at the right boundary
|
|
|
|
TQRgb val = contrastingColor( image.pixel( x2, image.height() / 2 ) );
|
|
|
|
for ( int y = 0; y < image.height(); y++ )
|
|
image.setPixel( x2, y, val );
|
|
}
|
|
}
|
|
|
|
|
|
if ( image.height() > 5 )
|
|
{
|
|
// Check contrast along the bottom boundary
|
|
|
|
int y1 = image.height() - 6;
|
|
int y2 = image.height() - 1;
|
|
int interval = max( image.width() / 10, 5 );
|
|
int sameColorCount = 0;
|
|
|
|
for ( int x = interval; x < image.width(); x += interval )
|
|
{
|
|
if ( image.pixel( x, y1 ) == image.pixel( x, y2 ) )
|
|
sameColorCount++;
|
|
}
|
|
|
|
if ( sameColorCount * 10 > image.height() )
|
|
{
|
|
// Add a grey line at the bottom boundary
|
|
|
|
TQRgb val = contrastingColor( image.pixel( image.width() / 2, y2 ) );
|
|
|
|
for ( int x = 0; x < image.width(); x++ )
|
|
image.setPixel( x, y2, val );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
TQRgb
|
|
KTreemapTile::contrastingColor( TQRgb col )
|
|
{
|
|
if ( tqGray( col ) < 128 )
|
|
return tqRgb( tqRed( col ) * 2, tqGreen( col ) * 2, tqBlue( col ) * 2 );
|
|
else
|
|
return tqRgb( tqRed( col ) / 2, tqGreen( col ) / 2, tqBlue( col ) / 2 );
|
|
}
|
|
|
|
|
|
|
|
|
|
KCushionSurface::KCushionSurface()
|
|
{
|
|
_xx2 = 0.0;
|
|
_xx1 = 0.0;
|
|
_yy2 = 0.0;
|
|
_yy1 = 0.0;
|
|
_height = CushionHeight;
|
|
}
|
|
|
|
|
|
void
|
|
KCushionSurface::addRidge( KOrientation dim, double height, const TQRect & rect )
|
|
{
|
|
_height = height;
|
|
|
|
if ( dim == KTreemapHorizontal )
|
|
{
|
|
_xx2 = squareRidge( _xx2, _height, rect.left(), rect.right() );
|
|
_xx1 = linearRidge( _xx1, _height, rect.left(), rect.right() );
|
|
}
|
|
else
|
|
{
|
|
_yy2 = squareRidge( _yy2, _height, rect.top(), rect.bottom() );
|
|
_yy1 = linearRidge( _yy1, _height, rect.top(), rect.bottom() );
|
|
}
|
|
}
|
|
|
|
|
|
double
|
|
KCushionSurface::squareRidge( double squareCoefficient, double height, int x1, int x2 )
|
|
{
|
|
if ( x2 != x1 ) // Avoid division by zero
|
|
squareCoefficient -= 4.0 * height / ( x2 - x1 );
|
|
|
|
return squareCoefficient;
|
|
}
|
|
|
|
|
|
double
|
|
KCushionSurface::linearRidge( double linearCoefficient, double height, int x1, int x2 )
|
|
{
|
|
if ( x2 != x1 ) // Avoid division by zero
|
|
linearCoefficient += 4.0 * height * ( x2 + x1 ) / ( x2 - x1 );
|
|
|
|
return linearCoefficient;
|
|
}
|
|
|
|
|
|
|
|
|
|
// EOF
|