Java tutorial
/* * Copyright (C) 2011 Andrea Schweer * * This file is part of the Digital Parrot. * * The Digital Parrot is free software; you can redistribute it and/or modify * it under the terms of the Eclipse Public License as published by the Eclipse * Foundation or its Agreement Steward, either version 1.0 of the License, or * (at your option) any later version. * * The Digital Parrot is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY * or FITNESS FOR A PARTICULAR PURPOSE. See the Eclipse Public License for * more details. * * You should have received a copy of the Eclipse Public License along with the * Digital Parrot. If not, see http://www.eclipse.org/legal/epl-v10.html. * */ package net.schweerelos.timeline.ui; import java.awt.BasicStroke; import java.awt.Color; import java.awt.Dimension; import java.awt.Font; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.Paint; import java.awt.RenderingHints; import java.awt.event.ActionEvent; import java.awt.event.ComponentAdapter; import java.awt.event.ComponentEvent; import java.awt.event.KeyEvent; import java.awt.event.MouseEvent; import java.beans.PropertyChangeEvent; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import javax.swing.AbstractAction; import javax.swing.Action; import javax.swing.DefaultListSelectionModel; import javax.swing.ImageIcon; import javax.swing.JPanel; import javax.swing.ListSelectionModel; import javax.swing.ToolTipManager; import javax.swing.event.ListSelectionEvent; import javax.swing.event.ListSelectionListener; import javax.swing.event.MouseInputAdapter; import net.schweerelos.parrot.timeline.IntervalListener; import net.schweerelos.timeline.model.IntervalChain; import net.schweerelos.timeline.model.PayloadInterval; import net.schweerelos.timeline.model.Timeline; import org.apache.log4j.Logger; import org.joda.time.DateTime; import org.joda.time.Duration; import org.joda.time.Interval; public class TimelinePanel<T extends Object> extends JPanel { private static final float ZOOM_FACTOR = 3.0f; private static final long serialVersionUID = 1L; private ListSelectionModel selectionModel; private AbstractAction zoomOutAction; private AbstractAction zoomInAction; private Logger logger; private Map<ColorKeys, Color> colors; private Timeline<T> tModel; private static final Map<ColorKeys, Color> DEFAULT_COLORS = new HashMap<ColorKeys, Color>(); static { DEFAULT_COLORS.put(ColorKeys.Background, Color.WHITE); DEFAULT_COLORS.put(ColorKeys.Label, new Color(0x6292E4)); DEFAULT_COLORS.put(ColorKeys.LabelOdd, DEFAULT_COLORS.get(ColorKeys.Label)); DEFAULT_COLORS.put(ColorKeys.BackgroundOdd, new Color(0xF2FAFC)); DEFAULT_COLORS.put(ColorKeys.SelectedOutline, new Color(0xFFCB77)); DEFAULT_COLORS.put(ColorKeys.IntervalFill, new Color(0xfff9e9)); DEFAULT_COLORS.put(ColorKeys.IntervalOutline, new Color(0xf7d891)); DEFAULT_COLORS.put(ColorKeys.HistogramFill, new Color(0xbacbce)); } private static final int INTERVAL_HEIGHT = 12; private static final int MINIMUM_H_GAP = 2; private static final int V_GAP = 5; private static final int HISTOGRAM_HEIGHT = 12; private static final int SHORTEST_VISIBLE_INTERVAL = 3; public TimelinePanel() { this(DEFAULT_COLORS); } public TimelinePanel(Map<ColorKeys, Color> colors) { super(); logger = Logger.getLogger(TimelinePanel.class); this.colors = colors; setLayout(new TimelineLayout(MINIMUM_H_GAP, V_GAP, INTERVAL_HEIGHT, HISTOGRAM_HEIGHT)); setOpaque(true); setBackground(colors.get(ColorKeys.Background)); ToolTipManager.sharedInstance().registerComponent(this); selectionModel = new DefaultListSelectionModel(); selectionModel.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION); MouseInputAdapter mouseAdapter = new MouseInputAdapter() { private boolean dragging; private int lastDraggedOverSlice; @Override public void mousePressed(MouseEvent e) { selectionModel.setValueIsAdjusting(true); int slice = convertXCoordToRow(e.getX()); if (selectionModel.isSelectedIndex(slice)) { return; } if (!e.isShiftDown() && !e.isControlDown()) { // "naked" click -> start selection process from scratch selectionModel.clearSelection(); } if (selectionModel.isSelectionEmpty()) { // empty selection -> start a new selection selectionModel.setSelectionInterval(slice, slice); } else if (e.isControlDown()) { // ctrl -> toggle selection of selected slice int anchor = selectionModel.getAnchorSelectionIndex(); if (selectionModel.isSelectedIndex(slice)) { selectionModel.removeSelectionInterval(slice, slice); } else { selectionModel.addSelectionInterval(slice, slice); } selectionModel.setAnchorSelectionIndex(anchor); } else if (e.isShiftDown()) { // shift -> select from anchor (first clicked cell) to // current int anchor = selectionModel.getAnchorSelectionIndex(); selectionModel.addSelectionInterval(anchor, slice); selectionModel.setAnchorSelectionIndex(anchor); } repaint(); } @Override public void mouseReleased(MouseEvent e) { if (!dragging) { return; // ignore } selectionModel.setValueIsAdjusting(false); dragging = false; } @Override public void mouseClicked(MouseEvent e) { selectionModel.setValueIsAdjusting(false); if (e.getClickCount() == 2) { zoomToSelection(); } } @Override public void mouseDragged(MouseEvent e) { int slice = convertXCoordToRow(e.getX()); if (e.isControlDown() || e.isShiftDown() || slice == lastDraggedOverSlice) { return; // ignore } lastDraggedOverSlice = slice; dragging = true; int anchor = selectionModel.getAnchorSelectionIndex(); if (slice < anchor) { // selection is between start and anchor selectionModel.setSelectionInterval(slice, anchor); selectionModel.setAnchorSelectionIndex(anchor); } else { // selection is between anchor and end selectionModel.setSelectionInterval(anchor, slice); selectionModel.setAnchorSelectionIndex(anchor); } repaint(); } }; addMouseListener(mouseAdapter); addMouseMotionListener(mouseAdapter); zoomOutAction = new AbstractAction("Zoom out", new ImageIcon("images/zoom-out.png")) { private static final long serialVersionUID = 1L; @Override public void actionPerformed(ActionEvent e) { // add a (zoom factor) proportion of the current interval at the // beginning // and add another one at the end long seconds = tModel.getDuration().getStandardSeconds(); int difference = (int) Math.ceil(seconds / ZOOM_FACTOR); DateTime newStart = tModel.getStart().minusSeconds(difference); DateTime newEnd = tModel.getEnd().plusSeconds(difference); tModel.setInterval(newStart, newEnd); } }; zoomOutAction.putValue(Action.MNEMONIC_KEY, KeyEvent.VK_O); zoomOutAction.putValue(Action.DISPLAYED_MNEMONIC_INDEX_KEY, 5); zoomInAction = new AbstractAction("Zoom in", new ImageIcon("images/zoom-in.png")) { private static final long serialVersionUID = 1L; @Override public void actionPerformed(ActionEvent e) { if (!selectionModel.isSelectionEmpty()) { zoomToSelection(); } else { // otherwise: // remove a (zoom factor) proportion of the current interval at // the beginning and remove another one at the end zoomIn(); } } }; zoomInAction.putValue(Action.MNEMONIC_KEY, KeyEvent.VK_I); selectionModel.addListSelectionListener(new ListSelectionListener() { @Override public void valueChanged(ListSelectionEvent e) { if (!e.getValueIsAdjusting()) { zoomInAction.setEnabled(canZoomInFurther()); } } }); clearAll(); addComponentListener(new ComponentAdapter() { @Override public void componentResized(ComponentEvent e) { adjustVisibleIntervals(); } }); } @Override public String getToolTipText() { return "Timeline"; } @Override public String getToolTipText(MouseEvent event) { try { int slice = event.getX() / calculateSliceWidth(getWidth()); return tModel.extractLabel(slice); } catch (IllegalArgumentException iae) { return getToolTipText(); } } private int calculateSliceWidth(double totalWidth) { return (int) Math.floor((double) totalWidth / (double) tModel.getNumSlices()); } private int convertXCoordToRow(int xCoord) { return xCoord / calculateSliceWidth(getWidth()); } public int convertDateToXCoord(DateTime date) { if (!tModel.isWithinRange(date)) { if (tModel.isBeforeStart(date)) { return 0; } else { return getWidth(); } } Duration visibleDuration = tModel.getDuration(); Duration fromStart = new Duration(tModel.getStart(), date); float ratio = fromStart.getMillis() / (float) visibleDuration.getMillis(); int xCoord = (int) Math.floor(ratio * getWidth()); return xCoord; } public void addListSelectionListener(ListSelectionListener listener) { selectionModel.addListSelectionListener(listener); } public void removeListSelectionListener(ListSelectionListener listener) { selectionModel.removeListSelectionListener(listener); } public void addIntervalListener(IntervalListener listener) { tModel.addIntervalListener(listener); } public void removeIntervalListener(IntervalListener listener) { tModel.removeIntervalListener(listener); } public void setModel(Timeline<T> tModel) { if (this.tModel != null) { clearAll(); } if (tModel == null) { clearAll(); return; } this.tModel = tModel; tModel.addIntervalListener(new IntervalListener() { @Override public void propertyChange(PropertyChangeEvent evt) { modelChanged(); } }); modelChanged(); } private void modelChanged() { selectionModel.clearSelection(); zoomInAction.setEnabled(canZoomInFurther()); zoomOutAction.setEnabled(canZoomOutFurther()); int numSlices = tModel.getNumSlices(); setPreferredSize(new Dimension(40 * numSlices, 120)); setMinimumSize(new Dimension(20 * numSlices, 70)); setSize(getPreferredSize()); adjustVisibleIntervals(); } private void adjustVisibleIntervals() { removeAll(); if (tModel != null) { Duration smallestVisibleDuration = calculateSmallestVisibleDuration(); for (PayloadInterval<T> interval : tModel.getVisibleIntervals(smallestVisibleDuration)) { IntervalView intervalView = new IntervalView(interval); intervalView.setColors(colors); add(intervalView); } } validate(); if (isVisible()) { repaint(); } } private Duration calculateSmallestVisibleDuration() { Duration visibleDuration = tModel.getDuration(); float millisPerPixel = (float) visibleDuration.getMillis() / (float) getWidth(); float secondsPerPixel = millisPerPixel / 1000; long minSeconds = (long) Math.ceil(secondsPerPixel * SHORTEST_VISIBLE_INTERVAL); return Duration.standardSeconds(minSeconds); } @Override public void paintComponent(Graphics g) { // draw "normal" panel stuff below everything else super.paintComponent(g); if (tModel == null) { return; } // set up graphics config Graphics2D graphics = (Graphics2D) g; graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); graphics.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON); // draw slices if (tModel.getNumSlices() > 0) { drawSlices(graphics); } } private void drawSlices(Graphics2D graphics) { int sliceWidth = calculateSliceWidth(getWidth()); int width = getWidth(); if (sliceWidth < 10) { // TODO real error handling logger.error("slices too thin, only " + sliceWidth + " pixels."); return; } Paint originalPaint = graphics.getPaint(); Font originalFont = graphics.getFont(); Font font = graphics.getFont().deriveFont(Font.BOLD); graphics.setFont(font); int[] intervalsInSlice = new int[tModel.getNumSlices()]; int maxIntervalsPerSlice = 0; for (int slice = 0; slice < tModel.getNumSlices(); slice++) { Interval sliceInterval = tModel.convertSliceToInterval(slice); int numIntervals = tModel.countIntervalsWithinRange(sliceInterval); intervalsInSlice[slice] = numIntervals; if (numIntervals > maxIntervalsPerSlice) { maxIntervalsPerSlice = numIntervals; } } int xCoord = 0; DateTime sliceStart = tModel.getStart(); for (int slice = 0; slice < tModel.getNumSlices(); slice++) { if (xCoord + sliceWidth > width) { sliceWidth = width - xCoord; logger.info("next slice will be only " + sliceWidth + " wide"); } // draw background (or not) boolean oddSlice = slice % 2 == 1; if (oddSlice) { // odd slice -> draw bg graphics.setColor(colors.get(ColorKeys.BackgroundOdd)); graphics.fillRect(xCoord, 0, sliceWidth, getHeight()); } // draw histogram if (maxIntervalsPerSlice > 0 && intervalsInSlice[slice] > 0) { double histProportion = intervalsInSlice[slice] / (double) maxIntervalsPerSlice; int histHeight = (int) Math.round(histProportion * HISTOGRAM_HEIGHT); if (histHeight > 0) { graphics.setColor(colors.get(ColorKeys.HistogramFill)); graphics.fillRect(xCoord + 1, getHeight() - histHeight, sliceWidth - 1, histHeight); } } // draw selection outline if (selectionModel.isSelectedIndex(slice)) { graphics.setColor(colors.get(ColorKeys.SelectedOutline)); graphics.setStroke(new BasicStroke(2)); graphics.drawRect(xCoord, 0, sliceWidth - 1, getHeight() - 1); } // draw label if (oddSlice) { // set colour for label graphics.setColor(colors.get(ColorKeys.LabelOdd)); } else { // set colour for label graphics.setColor(colors.get(ColorKeys.Label)); } String sliceName = tModel.extractLabel(sliceStart); int stringWidth = graphics.getFontMetrics().stringWidth(sliceName); int textXCoord = xCoord + (sliceWidth - stringWidth) / 2; int textYCoord = graphics.getFontMetrics().getMaxAscent() + 2; graphics.drawString(sliceName, textXCoord, textYCoord); // update variables for next slice xCoord += sliceWidth; sliceStart = sliceStart.plus(tModel.getIncrement()); } graphics.setPaint(originalPaint); graphics.setFont(originalFont); } public void clearAll() { if (tModel != null) { tModel.clear(); } tModel = null; selectionModel.clearSelection(); zoomInAction.setEnabled(false); zoomOutAction.setEnabled(false); } public IntervalChain<T> getSelections() { IntervalChain<T> result = new IntervalChain<T>(); if (selectionModel.isSelectionEmpty()) { return result; } List<Interval> selections = new ArrayList<Interval>(); int minSelectedIndex = selectionModel.getMinSelectionIndex(); int maxSelectedIndex = selectionModel.getMaxSelectionIndex(); DateTime lastStart = null; int currentIndex = minSelectedIndex; while (currentIndex <= maxSelectedIndex) { if (selectionModel.isSelectedIndex(currentIndex)) { if (lastStart == null) { // start of a new interval lastStart = tModel.convertSliceToInterval(currentIndex).getStart(); } } else { if (lastStart != null) { // end of a new interval DateTime end = tModel.convertSliceToInterval(currentIndex).getEnd(); Interval newInterval = new Interval(lastStart, end); selections.add(newInterval); lastStart = null; } } currentIndex++; } // lastStart should be non-null now if (lastStart != null) { // end of a new interval DateTime end = tModel.convertSliceToInterval(maxSelectedIndex).getEnd(); Interval newInterval = new Interval(lastStart, end); selections.add(newInterval); } else { logger.warn("last start is null, shouldn't happen"); } // TODO see if we can get this to be more efficient for (PayloadInterval<T> interval : tModel.getIntervalsWithinRange()) { for (Interval selection : selections) { if (selection.contains(interval.toInterval())) { result.add(interval); } } } return result; } public boolean isSelectionEmpty() { return selectionModel.isSelectionEmpty(); } public Action getZoomInAction() { return zoomInAction; } public Action getZoomOutAction() { return zoomOutAction; } private boolean canZoomInFurther() { if (tModel == null) { return false; } boolean canZoomToSelection = !selectionModel.isSelectionEmpty() && tModel.getNumSlices() > 1; return canZoomToSelection || tModel.canZoomInFurther(); } private boolean canZoomOutFurther() { if (tModel == null) { return false; } return tModel.canZoomOutFurther(); } public Timeline<T> getModel() { return tModel; } @Override public Dimension getMinimumSize() { return getLayout().minimumLayoutSize(this); } @Override public Dimension getPreferredSize() { return getLayout().preferredLayoutSize(this); } private void zoomToSelection() { DateTime newStart = tModel.convertSliceToInterval(selectionModel.getMinSelectionIndex()).getStart(); DateTime newEnd = tModel.convertSliceToInterval(selectionModel.getMaxSelectionIndex()).getEnd(); tModel.setInterval(newStart, newEnd); } private void zoomIn() { long seconds = tModel.getDuration().getStandardSeconds(); int difference = (int) Math.floor(seconds / ZOOM_FACTOR); DateTime newStart = tModel.getStart().plusSeconds(difference); DateTime newEnd = tModel.getEnd().minusSeconds(difference); tModel.setInterval(newStart, newEnd); } }