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.
125 lines
2.5 KiB
125 lines
2.5 KiB
use super::*;
|
|
use treemap::{
|
|
Rect,
|
|
Mappable,
|
|
TreemapLayout
|
|
};
|
|
use data::{FsInfo, INodeInfoGraph, INodeInfoGraphEntry};
|
|
|
|
/// A treemap of all **files** in the graph.
|
|
#[derive(Debug, Clone, PartialEq)]
|
|
pub struct Treemap
|
|
{
|
|
//layout: TreemapLayout,
|
|
nodes: Vec<MapNode>,
|
|
}
|
|
|
|
impl Treemap
|
|
{
|
|
/// All nodes of the map.
|
|
#[inline] pub fn nodes(&self) -> &[MapNode]
|
|
{
|
|
&self.nodes[..]
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq)]
|
|
pub struct MapNode
|
|
{
|
|
name: String,
|
|
|
|
vw_size: f64, // Should be halved each iteration
|
|
vw_bounds: Rect, // should be Rect::new() before aligntment
|
|
}
|
|
|
|
impl MapNode
|
|
{
|
|
/// The calculated bounds of the node
|
|
#[inline] pub fn bounds(&self) -> &Rect
|
|
{
|
|
&self.vw_bounds
|
|
}
|
|
/// The name of the node
|
|
#[inline] pub fn name(&self) -> &str
|
|
{
|
|
&self.name[..]
|
|
}
|
|
|
|
#[inline] fn size(&self) -> f64 //Is this useful for consumer?
|
|
{
|
|
self.vw_size
|
|
}
|
|
|
|
#[inline] fn new(name: String) -> Self
|
|
{
|
|
Self {
|
|
vw_size: 1.0,
|
|
vw_bounds: Rect::new(),
|
|
name,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Create a treemap from this graph.
|
|
pub fn treemap(_cfg: &Config, graph: &INodeInfoGraph, (w, h): (f64, f64)) -> Treemap
|
|
{
|
|
let layout = TreemapLayout::new();
|
|
let mut nodes = Vec::with_capacity(graph.len());
|
|
//TODO: Recursively walk the graph, halving size with each iteration. (Maybe we need `INodeInfoGraph` here, not `Hierarchicalinodegraph`?)
|
|
let total_size = graph.total_size();
|
|
|
|
let size = 1.0;
|
|
|
|
fn calc_path<'a, I: IntoIterator<Item = INodeInfoGraphEntry<'a>>>(insert: &'a mut Vec<MapNode>, from: I, total_size: u64, size: f64, scale: f64)
|
|
{
|
|
for top in from {
|
|
let path = top.path();
|
|
match top.info() {
|
|
FsInfo::Directory(_) => {
|
|
//TODO: Do we add dir itself? I think not?
|
|
// Add children
|
|
let size = size * 0.5;
|
|
calc_path(insert, top.level().unwrap(), total_size, size, scale);
|
|
},
|
|
&FsInfo::File(sz, _) => {
|
|
let fract = (sz as f64) / (total_size as f64);
|
|
insert.push(MapNode {
|
|
name: path.to_string_lossy().into_owned(),
|
|
vw_size: fract * scale,
|
|
vw_bounds: Rect::new(),
|
|
})
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
calc_path(&mut nodes, graph.top_level(), total_size, size, 1.0);
|
|
|
|
layout.layout_items(&mut nodes[..], Rect {
|
|
x: 0.0,
|
|
y: 0.0,
|
|
w, h,
|
|
});
|
|
|
|
Treemap {
|
|
//layout,
|
|
nodes
|
|
}
|
|
}
|
|
|
|
impl Mappable for MapNode
|
|
{
|
|
fn size(&self) -> f64
|
|
{
|
|
self.vw_size
|
|
}
|
|
fn bounds(&self) -> &Rect
|
|
{
|
|
&self.vw_bounds
|
|
}
|
|
fn set_bounds(&mut self, bounds: Rect)
|
|
{
|
|
self.vw_bounds = bounds;
|
|
}
|
|
}
|