package timeflow.vis.calendar;
|
|
import timeflow.data.time.*;
|
import timeflow.model.Display;
|
import timeflow.vis.*;
|
|
import java.util.*;
|
import java.awt.*;
|
import java.text.*;
|
|
public class Grid
|
{
|
|
TimeUnit rowUnit, columnUnit;
|
RoughTime startRow, endRow;
|
Interval interval;
|
HashMap<Long, GridCell> cells;
|
int[] screenGridX;
|
int cellHeight = 80, cellWidth, numCols, numRows;
|
Rectangle bounds = new Rectangle();
|
int dy;
|
static final DateFormat dayOfWeek = new SimpleDateFormat("EEE");
|
static final DateFormat month = new SimpleDateFormat("MMM d");
|
static final String[] day =
|
{
|
"SUN", "MON", "TUES", "WED", "THURS", "FRI", "SAT"
|
};
|
|
Grid(TimeUnit rowUnit, TimeUnit columnUnit, Interval interval)
|
{
|
this.rowUnit = rowUnit;
|
this.columnUnit = columnUnit;
|
numCols = columnUnit.numUnitsIn(rowUnit);
|
setInterval(interval);
|
}
|
|
public void setDY(int dy)
|
{
|
this.dy = dy;
|
}
|
|
public int getCalendarHeight()
|
{
|
return bounds.height + bounds.y + 20;
|
}
|
|
public RoughTime getTime(int x, int y)
|
{
|
y += dy;
|
if (!bounds.contains(x, y))
|
{
|
return null;
|
}
|
|
// find grid coordinates.
|
int gridX = (x - bounds.x) / cellWidth;
|
int gridY = (y - bounds.y) / cellHeight;
|
|
return startRow.plus(rowUnit, gridY).plus(columnUnit, gridX);
|
}
|
|
public double getScrollFraction()
|
{
|
double x = (getFirstDrawnTime().getTime() - startRow.getTime()) / (double) (endRow.getTime() - startRow.getTime());
|
if (x < 0)
|
{
|
return 0;
|
}
|
if (x > 1)
|
{
|
return 1;
|
}
|
return x;
|
}
|
|
public RoughTime getFirstDrawnTime()
|
{
|
int gridY = (dy - bounds.y) / cellHeight;
|
|
return startRow.plus(rowUnit, gridY);
|
}
|
|
private Point getGridCorner(long timestamp)
|
{
|
int diff = (int) columnUnit.difference(timestamp, startRow.getTime());
|
int gridX = diff % numCols;
|
int gridY = diff / numCols;
|
return new Point(gridX, gridY);
|
}
|
|
public Rectangle getCell(long timestamp)
|
{
|
Point p = getGridCorner(timestamp);
|
return new Rectangle(bounds.x + p.x * cellWidth, bounds.y + p.y * cellHeight - dy,
|
cellWidth, cellHeight);
|
}
|
|
void setInterval(Interval interval)
|
{
|
this.interval = interval;
|
startRow = rowUnit.roundDown(interval.start);
|
endRow = rowUnit.roundDown(interval.end);
|
numRows = 1 + (int) (rowUnit.difference(endRow.getTime(), startRow.getTime()));
|
|
// the next line fixes a problem with multi-century data sets.
|
// it works, but there's probably a better way to do this :-)
|
if (numRows > 50 && rowUnit.getRoughSize() >= TimeUnit.YEAR.getRoughSize())
|
{
|
numRows++;
|
}
|
}
|
|
void makeCells(java.util.List<VisualAct> visualActs)
|
{
|
cells = new HashMap<Long, GridCell>();
|
for (VisualAct v : visualActs)
|
{
|
if (v.getStart() == null)
|
{
|
continue;
|
}
|
long timestamp = v.getStart().getTime();
|
RoughTime timeKey = columnUnit.roundDown(timestamp);
|
GridCell cell = cells.get(timeKey.getTime());
|
if (cell == null)
|
{
|
cell = new GridCell(timeKey);
|
cells.put(timeKey.getTime(), cell);
|
Point p = getGridCorner(timestamp);
|
cell.gridX = p.x;
|
cell.gridY = p.y;
|
}
|
cell.visualActs.add(v);
|
}
|
}
|
|
void render(Graphics2D g, Display display, Rectangle screenBounds, CalendarVisuals visuals,
|
Collection<Mouseover> objectLocations)
|
{
|
g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
|
int left = 110, right = 20;
|
int padY = 50;
|
boolean shouldLabel = visuals.drawStyle == CalendarVisuals.DrawStyle.LABEL;
|
|
cellWidth = (screenBounds.width - left - right) / numCols;
|
|
boolean fitTight = visuals.fitStyle == CalendarVisuals.FitStyle.TIGHT;
|
int idealHeight = fitTight ? 12 : Display.CALENDAR_CELL_HEIGHT;
|
cellHeight = Math.max(idealHeight, (screenBounds.height - padY - 10) / numRows);
|
this.bounds.setBounds(left, padY, numCols * cellWidth, numRows * cellHeight);
|
|
g.setColor(new Color(240, 240, 240));//Color.white);
|
g.fill(screenBounds);
|
g.setColor(new Color(245, 245, 245));
|
g.drawRect(bounds.x, bounds.y - dy, bounds.width, bounds.height);
|
g.setFont(display.bold());
|
|
// draw vertical grid lines.
|
Color gridColor = new Color(220, 220, 220);
|
|
for (int i = 0; i <= numCols; i++)
|
{
|
int x = bounds.x + i * cellWidth;
|
g.setColor(gridColor);
|
g.drawLine(x, bounds.y - dy, x, bounds.y + bounds.height - dy);
|
if (rowUnit == TimeUnit.WEEK && i < 7)
|
{
|
g.setColor(Color.gray);
|
g.drawString(day[i], x, bounds.y - dy - 6);
|
}
|
}
|
|
// horizontal grid lines.
|
RoughTime labelTime = startRow.copy();
|
int lastLabelY = -100;
|
int lastYear = -1000000;
|
FontMetrics fm = display.boldFontMetrics();
|
int skipped = 0;
|
for (int i = 0; i < numRows; i++)
|
{
|
int y = bounds.y + i * cellHeight;
|
if (y - dy > -50)
|
{
|
if (skipped > 0)
|
{
|
rowUnit.addTo(labelTime, skipped);
|
skipped = 0;
|
}
|
g.setColor(gridColor);
|
g.drawLine(bounds.x, y - dy, bounds.x + bounds.width, y - dy);
|
if (y - lastLabelY > 30 || lastLabelY < 0)
|
{
|
String label = null;
|
if (rowUnit == TimeUnit.WEEK)
|
{
|
int year = TimeUtils.cal(labelTime.getTime()).get(Calendar.YEAR);
|
if (year != lastYear)
|
{
|
label = labelTime.format();
|
} else
|
{
|
label = month.format(labelTime.toDate());
|
}
|
lastYear = year;
|
} else
|
{
|
label = labelTime.format();
|
}
|
g.setColor(Color.gray);
|
g.drawString(label, bounds.x - fm.stringWidth(label) - 15, y + 15 - dy);
|
lastLabelY = y;
|
}
|
if (y - dy > screenBounds.height)
|
{
|
break;
|
}
|
|
// now draw, in gray, the labels for each of the boxes.
|
if (!fitTight)
|
{
|
RoughTime gridLabel = labelTime.copy();
|
int labelH = 13;
|
for (int j = 0; j < numCols; j++)
|
{
|
|
g.setColor(Color.gray);
|
g.setFont(display.bold());
|
String label = columnUnit.format(gridLabel.toDate());
|
g.drawString(label, bounds.x + j * cellWidth + 3, y - dy + labelH);
|
columnUnit.addTo(gridLabel);
|
}
|
}
|
rowUnit.addTo(labelTime);
|
} else
|
{
|
skipped++;
|
}
|
}
|
|
// draw a frame around the whole thing.
|
g.setColor(Color.darkGray);
|
g.drawRect(bounds.x, bounds.y - dy, bounds.width, bounds.height);
|
|
// draw backgrounds
|
for (GridCell cell : cells.values())
|
{
|
// are any visible?
|
boolean visible = false;
|
for (VisualAct v : cell.visualActs)
|
{
|
if (v.isVisible())
|
{
|
visible = true;
|
break;
|
}
|
}
|
int cx = bounds.x + cell.gridX * cellWidth;
|
int cy = bounds.y + cell.gridY * cellHeight - dy;
|
|
if (cy < screenBounds.y - 50 || cy > screenBounds.y + screenBounds.height + 50)
|
{
|
continue;
|
}
|
|
// label top of cell.
|
int labelH = 0;
|
g.setColor(new Color(240, 240, 240));
|
|
if (visible)
|
{
|
g.setColor(Color.white);
|
g.fillRect(cx + 1, cy + 1, cellWidth - 1, cellHeight - 1);
|
}
|
if (cellHeight > 42)
|
{
|
labelH = 13;
|
g.setColor(Color.darkGray);
|
g.setFont(display.bold());
|
String label = columnUnit.format(cell.time.toDate());
|
g.drawString(label, cx + 3, cy + labelH);
|
}
|
|
}
|
|
|
|
// draw items.
|
int mx = 10, my = shouldLabel ? 18 : 10;
|
for (GridCell cell : cells.values())
|
{
|
|
int cx = bounds.x + cell.gridX * cellWidth;
|
int cy = bounds.y + cell.gridY * cellHeight - dy;
|
|
if (cy < screenBounds.y - 50 || cy > screenBounds.y + screenBounds.height + 50)
|
{
|
continue;
|
}
|
|
// label top of cell.
|
int labelH = cellHeight > 42 ? 13 : 0;
|
|
// now draw the items in the cell.
|
// old, non-aggregation code:
|
|
// START AGGREGATION CODE
|
|
ArrayList<VisualAct> visibleActs = new ArrayList<VisualAct>();
|
for (VisualAct v : cell.visualActs)
|
{
|
if (v.isVisible())
|
{
|
visibleActs.add(v);
|
}
|
}
|
Iterator<VisualAct> vacts =
|
VisualActFactory.makeEmFit(visuals.model, visibleActs, new Rectangle(cx, cy, cellWidth, cellHeight)).iterator();
|
|
// END AGGREGATION CODE
|
|
int leftX = 6;
|
int cdx = leftX;
|
int topDotY = Math.min(labelH + 16, cellHeight / 2);
|
int cdy = topDotY;
|
while (vacts.hasNext())
|
{
|
VisualAct v = vacts.next();
|
if (!v.isVisible())
|
{
|
continue;
|
}
|
|
// set x,y, room to right.
|
int x = cx + cdx;
|
int y = cy + cdy;
|
|
int space = cellWidth - 20;
|
v.setX(x);
|
v.setY(y);
|
v.setSpaceToRight(space);
|
Mouseover o = v.draw(g, new Rectangle(cx + 1, cy + labelH + 1, cellWidth - 2, cellHeight - 2 - labelH),
|
bounds, display, shouldLabel, false);
|
if (o != null)
|
{
|
objectLocations.add(o);
|
}
|
|
// go to next location. if we're labeling, we do this vertically.
|
// otherwise, left-to-right, then top-to-bottom.
|
|
if (shouldLabel)
|
{
|
cdy += my;
|
if (cdy > cellHeight - 2 - my)
|
{
|
g.drawString("...", x, y + my);
|
break;
|
}
|
} else
|
{
|
cdx += mx;
|
if (cdx > cellWidth - mx / 2 - 2 && vacts.hasNext())
|
{
|
cdx = leftX;
|
cdy += my;
|
if (cdy > cellHeight - my / 2)
|
{
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
