mirror of
https://github.com/overcuriousity/autopsy-flatpak.git
synced 2025-07-12 16:06:15 +00:00
1180 lines
50 KiB
Java
1180 lines
50 KiB
Java
/*
|
|
* Autopsy Forensic Browser
|
|
*
|
|
* Copyright 2011 Basis Technology Corp.
|
|
* Contact: carrier <at> sleuthkit <dot> org
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
package org.sleuthkit.autopsy.timeline;
|
|
|
|
import com.sun.javafx.application.PlatformImpl;
|
|
import java.awt.Component;
|
|
import java.awt.Dimension;
|
|
import java.beans.PropertyChangeEvent;
|
|
import java.beans.PropertyChangeListener;
|
|
import java.io.BufferedWriter;
|
|
import java.io.FileInputStream;
|
|
import java.io.FileNotFoundException;
|
|
import java.io.FileWriter;
|
|
import java.io.IOException;
|
|
import java.sql.ResultSet;
|
|
import java.sql.SQLException;
|
|
import java.text.DateFormat;
|
|
import java.text.DateFormatSymbols;
|
|
import java.text.ParseException;
|
|
import java.text.SimpleDateFormat;
|
|
import java.util.ArrayList;
|
|
import java.util.Calendar;
|
|
import java.util.Collections;
|
|
import java.util.Date;
|
|
import java.util.List;
|
|
import java.util.Locale;
|
|
import java.util.Scanner;
|
|
import java.util.Stack;
|
|
import java.util.logging.Level;
|
|
import javafx.application.Platform;
|
|
import javafx.collections.FXCollections;
|
|
import javafx.collections.ObservableList;
|
|
import javafx.embed.swing.JFXPanel;
|
|
import javafx.event.ActionEvent;
|
|
import javafx.event.EventHandler;
|
|
import javafx.geometry.Pos;
|
|
import javafx.scene.Group;
|
|
import javafx.scene.Scene;
|
|
import javafx.scene.chart.BarChart;
|
|
import javafx.scene.chart.CategoryAxis;
|
|
import javafx.scene.chart.NumberAxis;
|
|
import javafx.scene.control.Button;
|
|
import javafx.scene.control.ComboBox;
|
|
import javafx.scene.control.Label;
|
|
import javafx.scene.control.ScrollPane;
|
|
import javafx.scene.input.MouseButton;
|
|
import javafx.scene.input.MouseEvent;
|
|
import javafx.scene.layout.HBox;
|
|
import javafx.scene.layout.VBox;
|
|
import javafx.scene.paint.Color;
|
|
import javax.swing.BoxLayout;
|
|
import javax.swing.JFrame;
|
|
import javax.swing.JOptionPane;
|
|
import javax.swing.JPanel;
|
|
import javax.swing.JSplitPane;
|
|
import javax.swing.SwingUtilities;
|
|
import org.netbeans.api.progress.ProgressHandle;
|
|
import org.netbeans.api.progress.ProgressHandleFactory;
|
|
import org.openide.awt.ActionID;
|
|
import org.openide.awt.ActionReference;
|
|
import org.openide.awt.ActionReferences;
|
|
import org.openide.awt.ActionRegistration;
|
|
import org.openide.modules.InstalledFileLocator;
|
|
import org.openide.nodes.ChildFactory;
|
|
import org.openide.nodes.Children;
|
|
import org.openide.nodes.Node;
|
|
import org.openide.util.Exceptions;
|
|
import org.openide.util.HelpCtx;
|
|
import org.openide.util.NbBundle;
|
|
import org.openide.util.actions.CallableSystemAction;
|
|
import org.openide.util.actions.Presenter;
|
|
import org.sleuthkit.autopsy.casemodule.Case;
|
|
import org.sleuthkit.autopsy.corecomponents.DataContentPanel;
|
|
import org.sleuthkit.autopsy.corecomponents.DataResultPanel;
|
|
import org.sleuthkit.autopsy.coreutils.Logger;
|
|
import org.sleuthkit.autopsy.coreutils.PlatformUtil;
|
|
import org.sleuthkit.autopsy.datamodel.DirectoryNode;
|
|
import org.sleuthkit.autopsy.datamodel.DisplayableItemNode;
|
|
import org.sleuthkit.autopsy.datamodel.DisplayableItemNodeVisitor;
|
|
import org.sleuthkit.autopsy.datamodel.FileNode;
|
|
import org.sleuthkit.autopsy.ingest.IngestManager;
|
|
import org.sleuthkit.autopsy.recentactivity.JavaSystemCaller;
|
|
import org.sleuthkit.datamodel.AbstractFile;
|
|
import org.sleuthkit.datamodel.Directory;
|
|
import org.sleuthkit.datamodel.File;
|
|
import org.sleuthkit.datamodel.FsContent;
|
|
import org.sleuthkit.datamodel.SleuthkitCase;
|
|
import org.sleuthkit.datamodel.TskCoreException;
|
|
import org.sleuthkit.datamodel.TskData;
|
|
|
|
@ActionID(category = "Tools", id = "org.sleuthkit.autopsy.timeline.Simile2")
|
|
@ActionRegistration(displayName = "#CTL_MakeTimeline")
|
|
@ActionReferences(value = {
|
|
@ActionReference(path = "Menu/Tools", position = 100)})
|
|
@NbBundle.Messages(value = "CTL_TimelineView=Generate Timeline")
|
|
|
|
public class Simile2 extends CallableSystemAction implements Presenter.Toolbar, PropertyChangeListener {
|
|
private static final Logger logger = Logger.getLogger(Simile2.class.getName());
|
|
private final java.io.File macRoot = InstalledFileLocator.getDefault().locate("mactime", Simile2.class.getPackage().getName(), false);
|
|
private JFrame jf; //frame for holding all the elements
|
|
private Group group_Charts; //Orders the charts
|
|
private Scene scene_Charts; //Displays the charts
|
|
private HBox hBox_Charts; //Holds the navigation buttons in horiztonal fashion.
|
|
private VBox vBox_FX; //Holds the JavaFX Elements in vertical fashion.
|
|
private JFXPanel panel_Charts; //FX panel to hold the group
|
|
private BarChart chart_Events; //Yearly/Monthly events - Bar chart
|
|
private ScrollPane scroll_Events; //Scroll Panes for dealing with oversized an oversized chart
|
|
private final int Height_Frame = 850; //Sizing constants
|
|
private final int Width_Frame = 1300;
|
|
private Button button_DrillUp; //Navigation buttons
|
|
private Button button_Reset;
|
|
private Button button_Go;
|
|
private ComboBox<String> dropdown_SelectYears; //Dropdown box for selecting years. Useful when the charts' scale means some years are unclickable, despite having events.
|
|
private final Stack<BarChart> stack_PrevCharts = new Stack<BarChart>(); //Stack for storing drill-up information.
|
|
private BarChart chart_TopLevel; //the topmost chart, used for resetting to default view.
|
|
private DataResultPanel dataResult;
|
|
private DataContentPanel dataContentPanel;
|
|
private ProgressHandle progress;
|
|
private java.io.File moduleDir;
|
|
private String mactimeFileName;
|
|
private List<YearEpoch> data;
|
|
private boolean listeningToAddImage = false;
|
|
private long lastObjectId = -1;
|
|
private TimelineProgressDialog dialog;
|
|
|
|
//Swing components and JavafX components don't play super well together
|
|
//Swing components need to be initialized first, in the swing specific thread
|
|
//Next, the javafx components may be initialized.
|
|
private void customizeSwing() {
|
|
SwingUtilities.invokeLater(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
dataContentPanel = new DataContentPanel();
|
|
dataResult = DataResultPanel.createInstance("Timeline Results", "", Node.EMPTY, 0, dataContentPanel);
|
|
dataResult.setContentViewer(new DataContentPanel());
|
|
dataResult.setAlignmentX(Component.LEFT_ALIGNMENT);
|
|
dataResult.setPreferredSize(new Dimension(700, 300));
|
|
logger.log(Level.INFO, "Successfully created viewers");
|
|
}
|
|
});
|
|
}
|
|
|
|
private void customize() {
|
|
|
|
//Making the main frame *
|
|
jf = new JFrame(Case.getCurrentCase().getName() + " - Autopsy Timeline (Beta)");
|
|
jf.setSize(Width_Frame, Height_Frame); //(Width, Height)
|
|
|
|
//JPanels are used as the cohesive glue that binds everything together.*/
|
|
//The chartJpanel holds the chart,
|
|
//aligned vertically (Y_AXIS)
|
|
final JPanel chartJPanel = new JPanel();
|
|
chartJPanel.setLayout(new BoxLayout(chartJPanel, BoxLayout.Y_AXIS));
|
|
|
|
//ViewerJPanel holds both of the DataResult/DataContent viewers,
|
|
//aligned horizontally (X_AXIS)
|
|
final JPanel viewerJPanel = new JPanel();
|
|
viewerJPanel.setLayout(new BoxLayout(viewerJPanel, BoxLayout.X_AXIS));
|
|
|
|
//ComboJPanel holds both of the above JPanels together,
|
|
//aligned vertically (Y_AXIS)
|
|
|
|
// create a horizontal split pane
|
|
final JSplitPane splitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT, chartJPanel, viewerJPanel);
|
|
splitPane.setDividerLocation(450);
|
|
|
|
//JavaFX thread
|
|
//JavaFX components MUST be run in the JavaFX thread, otherwise massive amounts of exceptions will be thrown and caught. Liable to freeze up and crash.
|
|
//Components can be declared whenever, but initialization and manipulation must take place here.
|
|
PlatformImpl.startup(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
try {
|
|
// start the progress bar
|
|
progress = ProgressHandleFactory.createHandle("Creating timeline . . .");
|
|
progress.start();
|
|
|
|
panel_Charts = new JFXPanel();
|
|
group_Charts = new Group();
|
|
scene_Charts = new Scene(group_Charts, Width_Frame, Math.round(Height_Frame / .75)); //Width, Height
|
|
vBox_FX = new VBox(5);
|
|
vBox_FX.setAlignment(Pos.BOTTOM_CENTER);
|
|
hBox_Charts = new HBox(10);
|
|
hBox_Charts.setAlignment(Pos.BOTTOM_CENTER);
|
|
|
|
//Initializing default values for the scroll pane
|
|
scroll_Events = new ScrollPane();
|
|
scroll_Events.setPrefSize(Width_Frame, Math.round(Height_Frame / .75)); //Width, Height
|
|
scroll_Events.setContent(null); //Needs some content, otherwise it crashes
|
|
|
|
// set up moduleDir
|
|
moduleDir = new java.io.File(Case.getCurrentCase().getCaseDirectory() + java.io.File.separator + "timeline");
|
|
if (!moduleDir.exists()) {
|
|
moduleDir.mkdir();
|
|
}
|
|
|
|
java.io.File mactimeFile = new java.io.File(moduleDir, mactimeFileName);
|
|
if (!mactimeFile.exists()) {
|
|
logger.log(Level.INFO, "Creating mactime file.");
|
|
String bodyFilePath = makeBodyFile();
|
|
makeMacTime(bodyFilePath);
|
|
data = null;
|
|
} else {
|
|
logger.log(Level.INFO, "mactime file already exists; parsing that.");
|
|
}
|
|
|
|
if (data == null) {
|
|
data = parseMacTime(mactimeFile); //The sum total of the mactime parsing. YearEpochs contain everything you need to make a timeline.
|
|
}
|
|
|
|
//Making a dropdown box to select years.
|
|
List<String> lsi = new ArrayList<String>(); //List is in the format of {Year : Number of Events}, used for selecting from the dropdown.
|
|
for (YearEpoch ye : data) {
|
|
lsi.add(ye.year + " : " + ye.getNumFiles());
|
|
}
|
|
ObservableList<String> listSelect = FXCollections.observableArrayList(lsi);
|
|
dropdown_SelectYears = new ComboBox(listSelect);
|
|
|
|
//Buttons for navigating up and down the timeline
|
|
button_DrillUp = new Button("Drill up");
|
|
button_DrillUp.setOnAction(new EventHandler<ActionEvent>() {
|
|
@Override
|
|
public void handle(ActionEvent e) {
|
|
BarChart bc;
|
|
if (stack_PrevCharts.size() == 0) {
|
|
bc = chart_TopLevel;
|
|
} else {
|
|
bc = stack_PrevCharts.pop();
|
|
}
|
|
chart_Events = bc;
|
|
scroll_Events.setContent(chart_Events);
|
|
}
|
|
});
|
|
button_Reset = new Button("Reset");
|
|
button_Reset.setOnAction(new EventHandler<ActionEvent>() {
|
|
@Override
|
|
public void handle(ActionEvent e) {
|
|
stack_PrevCharts.clear();
|
|
chart_Events = chart_TopLevel;
|
|
scroll_Events.setContent(chart_Events);
|
|
}
|
|
});
|
|
button_Go = new Button("►");
|
|
button_Go.setOnAction(new EventHandler<ActionEvent>() {
|
|
@Override
|
|
public void handle(ActionEvent e) {
|
|
if (dropdown_SelectYears.getValue() != null) {
|
|
chart_Events = createMonthsWithDrill(findYear(data, Integer.valueOf(dropdown_SelectYears.getValue().split(" ")[0])));
|
|
scroll_Events.setContent(chart_Events);
|
|
}
|
|
}
|
|
});
|
|
|
|
//Adding things to the V and H boxes.
|
|
//hBox_Charts stores the pseudo menu bar at the top of the timeline. |Drill Up|Drill Down|Reset|View Year: [Select Year]|►|
|
|
hBox_Charts.getChildren().addAll(button_DrillUp, button_Reset, new Label("View Year:"), dropdown_SelectYears, button_Go);
|
|
vBox_FX.getChildren().addAll(hBox_Charts, scroll_Events); //FxBox_V holds things in a visual stack.
|
|
group_Charts.getChildren().add(vBox_FX); //Adding the FxBox to the group. Groups make things easier to manipulate without having to update a hundred things every change.
|
|
panel_Charts.setScene(scene_Charts);
|
|
|
|
|
|
panel_Charts.setAlignmentX(Component.LEFT_ALIGNMENT);
|
|
|
|
chartJPanel.add(panel_Charts);
|
|
viewerJPanel.add(dataResult);
|
|
|
|
viewerJPanel.add(dataContentPanel);
|
|
chartJPanel.setAlignmentX(Component.LEFT_ALIGNMENT);
|
|
viewerJPanel.setAlignmentX(Component.LEFT_ALIGNMENT);
|
|
|
|
chart_TopLevel = createYearChartWithDrill(data);
|
|
chart_Events = chart_TopLevel;
|
|
scroll_Events.setContent(chart_Events);
|
|
|
|
jf.add(splitPane);
|
|
jf.setVisible(true);
|
|
} finally {
|
|
// stop the progress bar
|
|
progress.finish();
|
|
|
|
// close the dialog
|
|
dialog.doClose(0);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Creates a BarChart with datapoints for all the years from the parsed
|
|
* mactime file.
|
|
*
|
|
* @param allYears The list of years that have data from the mactime file
|
|
* @return BarChart scaled to the year level
|
|
*/
|
|
private BarChart createYearChartWithDrill(final List<YearEpoch> allYears) {
|
|
final CategoryAxis xAxis = new CategoryAxis(); //Axes are very specific types. Categorys are strings.
|
|
final NumberAxis yAxis = new NumberAxis();
|
|
final Label l = new Label("");
|
|
l.setStyle("-fx-font: 24 arial;");
|
|
l.setTextFill(Color.AZURE);
|
|
xAxis.setLabel("Years");
|
|
yAxis.setLabel("Number of Events");
|
|
//Charts are made up of individual pieces of Chart.Data. In this case, a piece of data is a single bar on the graph.
|
|
//Data is packaged into a series, which can be assigned custom colors or styling
|
|
//After the series are created, 1 or more series are packaged into a single chart.
|
|
ObservableList<BarChart.Series<String, Number>> bcData = FXCollections.observableArrayList();
|
|
BarChart.Series<String, Number> se = new BarChart.Series<String, Number>();
|
|
for (final YearEpoch ye : allYears) {
|
|
se.getData().add(new BarChart.Data<String, Number>(String.valueOf(ye.year), ye.getNumFiles()));
|
|
}
|
|
bcData.add(se);
|
|
|
|
//Note:
|
|
// BarChart.Data wraps the Java Nodes class. BUT, until a BarChart.Data gets added to an actual series, it's node is null, and you can perform no operations on it.
|
|
// When the Data is added to a series(or a chart? I am unclear on where), a node is automaticaly generated for it, after which you can perform any of the operations it offers.
|
|
// In addtion, you are free to set the node to whatever you want. It wraps the most generic Node class.
|
|
// But it is for this reason that the chart generating functions have two forloops. I do not believe they can be condensed into a single loop due to the nodes being null until
|
|
// an undetermined point in time.
|
|
BarChart<String, Number> bc = new BarChart<String, Number>(xAxis, yAxis, bcData);
|
|
for (final BarChart.Data data : bc.getData().get(0).getData()) { //.get(0) refers to the BarChart.Series class to work on. There is only one series in this graph, so get(0) is safe.
|
|
data.getNode().setScaleX(.5);
|
|
data.getNode().addEventHandler(MouseEvent.MOUSE_CLICKED,
|
|
new EventHandler<MouseEvent>() {
|
|
@Override
|
|
public void handle(MouseEvent e) {
|
|
if (e.getButton().equals(MouseButton.PRIMARY)) {
|
|
if (e.getClickCount() == 2) { //Checking for a doubleclick
|
|
PlatformImpl.startup(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
BarChart b = createMonthsWithDrill((YearEpoch) findYear(allYears, Integer.valueOf((String) data.getXValue())));
|
|
chart_Events = b;
|
|
scroll_Events.setContent(chart_Events);
|
|
}
|
|
});
|
|
//If a single click, hover a label over the cursor with information about the selection
|
|
} else if (e.getClickCount() == 1) {
|
|
l.setText(findYear(allYears, Integer.valueOf((String) data.getXValue())).getNumFiles() + " events");
|
|
l.setTranslateX(e.getX());
|
|
l.setTranslateY(e.getY());
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
bc.autosize(); //Get an auto height
|
|
bc.setPrefWidth(Width_Frame); //but override the width
|
|
bc.setLegendVisible(false); //The legend adds too much extra chart space, it's not necessary.
|
|
return bc;
|
|
}
|
|
|
|
/*
|
|
* Displays a chart with events from one year only, separated into 1-month chunks.
|
|
* Always 12 per year, empty months are represented by no bar.
|
|
*/
|
|
private BarChart createMonthsWithDrill(final YearEpoch ye) {
|
|
|
|
final CategoryAxis xAxis = new CategoryAxis();
|
|
final NumberAxis yAxis = new NumberAxis();
|
|
xAxis.setLabel("Month (" + ye.year + ")");
|
|
yAxis.setLabel("Number of Events");
|
|
ObservableList<BarChart.Series<String, Number>> bcData = FXCollections.observableArrayList();
|
|
|
|
BarChart.Series<String, Number> se = new BarChart.Series<String, Number>();
|
|
for (int monthNum = 0; monthNum < 12; ++monthNum) {
|
|
String monthName = new DateFormatSymbols().getMonths()[monthNum];
|
|
MonthEpoch month = ye.getMonth(monthNum);
|
|
int numEvents = month == null ? 0 : month.getNumFiles();
|
|
se.getData().add(new BarChart.Data<String, Number>(monthName, numEvents)); //Adding new data at {X-pos, Y-Pos}
|
|
}
|
|
bcData.add(se);
|
|
final BarChart<String, Number> bc = new BarChart<String, Number>(xAxis, yAxis, bcData);
|
|
|
|
for (int i = 0; i < 12; i++) {
|
|
for (final BarChart.Data data : bc.getData().get(0).getData()) {
|
|
//Note:
|
|
// All the charts of this package have a problem where when the chart gets below a certain pixel ratio, the data stops drawing. The axes and the labels remain,
|
|
// But the actual chart data is invisible, unclickable, and unrendered. To partially compensate for that, data.getNode() can be manually scaled up to increase visibility.
|
|
// Sometimes I've had it jacked up to as much as x2400 just to see a sliver of information.
|
|
// But that doesn't work all the time. Adding it to a scrollpane and letting the user scroll up and down to view the chart is the other workaround. Both of these fixes suck.
|
|
|
|
data.getNode().setScaleX(.5);
|
|
data.getNode().addEventHandler(MouseEvent.MOUSE_PRESSED,
|
|
new EventHandler<MouseEvent>() {
|
|
@Override
|
|
public void handle(MouseEvent e) {
|
|
if (e.getButton().equals(MouseButton.PRIMARY)) {
|
|
if (e.getClickCount() == 2) {
|
|
PlatformImpl.startup(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
chart_Events = createEventsByMonth(findMonth(ye.months, monthStringToInt((String) data.getXValue())), ye);
|
|
scroll_Events.setContent(chart_Events);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
bc.autosize();
|
|
bc.setPrefWidth(Width_Frame);
|
|
bc.setLegendVisible(false);
|
|
stack_PrevCharts.push(bc);
|
|
return bc;
|
|
}
|
|
|
|
|
|
/*
|
|
* Displays a chart with events from one month only.
|
|
* Up to 31 days per month, as low as 28 as determined by the specific MonthEpoch
|
|
*/
|
|
private BarChart createEventsByMonth(final MonthEpoch me, final YearEpoch ye) {
|
|
final CategoryAxis xAxis = new CategoryAxis();
|
|
final NumberAxis yAxis = new NumberAxis();
|
|
xAxis.setLabel("Day of Month");
|
|
yAxis.setLabel("Number of Events");
|
|
ObservableList<BarChart.Data> bcData = makeObservableListByMonthAllDays(me, ye.getYear());
|
|
BarChart.Series<String, Number> series = new BarChart.Series(bcData);
|
|
series.setName(me.getMonthName() + " " + ye.getYear());
|
|
|
|
ObservableList<BarChart.Series<String, Number>> ol = FXCollections.observableArrayList(series);
|
|
|
|
final BarChart<String, Number> bc = new BarChart<String, Number>(xAxis, yAxis, ol);
|
|
for (final BarChart.Data data : bc.getData().get(0).getData()) {
|
|
//data.getNode().setScaleX(2);
|
|
data.getNode().addEventHandler(MouseEvent.MOUSE_PRESSED,
|
|
new EventHandler<MouseEvent>() {
|
|
MonthEpoch myme = me;
|
|
|
|
@Override
|
|
public void handle(MouseEvent e) {
|
|
int day = (Integer.valueOf(((String) data.getXValue()).split("-")[1]));
|
|
DayEpoch de = myme.getDay(day);
|
|
List<AbstractFile> afs = Collections.EMPTY_LIST;
|
|
if (de != null) {
|
|
afs = de.getEvents();
|
|
} else {
|
|
logger.log(Level.SEVERE, "There were no events for the clicked-on day.");
|
|
}
|
|
final FsContentRootNode d = new FsContentRootNode("Test Root", afs);
|
|
SwingUtilities.invokeLater(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
dataResult.setNode(d);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
bc.autosize();
|
|
bc.setPrefWidth(Width_Frame);
|
|
return bc;
|
|
}
|
|
|
|
private static ObservableList<BarChart.Data> makeObservableListByMonthAllDays(final MonthEpoch me, int year) {
|
|
ObservableList<BarChart.Data> bcData = FXCollections.observableArrayList();
|
|
int totalDays = me.getTotalNumDays(year);
|
|
for (int i = 1; i <= totalDays; ++i) {
|
|
DayEpoch day = me.getDay(i);
|
|
int numFiles = day == null ? 0 : day.getNumFiles();
|
|
BarChart.Data d = new BarChart.Data(me.month + 1 + "-" + i, numFiles);
|
|
d.setExtraValue(me);
|
|
bcData.add(d);
|
|
}
|
|
return bcData;
|
|
}
|
|
|
|
/*
|
|
* Section for Utility functions
|
|
*/
|
|
/**
|
|
*
|
|
* @param mon The month to convert. Must be minimum 4 characters long "February" and "Febr" are acceptable.
|
|
* @return The integer value of the month. February = 1, July = 6
|
|
*/
|
|
private static int monthStringToInt(String mon) {
|
|
try {
|
|
Date date = new SimpleDateFormat("MMMM", Locale.ENGLISH).parse(mon);
|
|
Calendar cal = Calendar.getInstance();
|
|
cal.setTime(date);
|
|
return cal.get(Calendar.MONTH);
|
|
} catch (ParseException ex) {
|
|
logger.log(Level.WARNING, "Unable to convert string " + mon + " to integer", ex);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Used for finding the proper month in a list of available months
|
|
* @param lst The list of months to search through. It is assumed that the desired match is in this list.
|
|
* @param match The month, in integer format, to retrieve.
|
|
* @return The month epoch as specified by match.
|
|
*/
|
|
private static MonthEpoch findMonth(List<MonthEpoch> lst, int match) {
|
|
for (MonthEpoch e : lst) {
|
|
if (e.month == match) {
|
|
return e;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Used for finding the proper year in a list of available years
|
|
* @param lst The list of years to search through. It is assumed that the desired match is in this list.
|
|
* @param match The year to retrieve.
|
|
* @return The year epoch as specified by match.
|
|
*/
|
|
private static YearEpoch findYear(List<YearEpoch> lst, int match) {
|
|
for (YearEpoch e : lst) {
|
|
if (e.year == match) {
|
|
return e;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
public void propertyChange(PropertyChangeEvent evt) {
|
|
String prop = evt.getPropertyName();
|
|
if (!prop.equals(Case.CASE_ADD_IMAGE)) {
|
|
return;
|
|
}
|
|
|
|
if (jf != null && !jf.isVisible()) {
|
|
// change the lastObjectId to trigger a reparse of mactime data
|
|
++lastObjectId;
|
|
return;
|
|
}
|
|
|
|
int answer = JOptionPane.showConfirmDialog(jf, "Timeline is out of date. Would you like to regenerate it?", "Select an option", JOptionPane.YES_NO_OPTION);
|
|
if (answer != JOptionPane.YES_OPTION) {
|
|
return;
|
|
}
|
|
|
|
clearMactimeData();
|
|
|
|
// call performAction as if the user selected 'Make Timeline' from the menu
|
|
performAction();
|
|
}
|
|
|
|
private void clearMactimeData() {
|
|
// get rid of the old data
|
|
data = null;
|
|
|
|
// get rid of the mactime file
|
|
java.io.File mactimeFile = new java.io.File(moduleDir, mactimeFileName);
|
|
mactimeFile.delete();
|
|
|
|
// close the jframe
|
|
jf.setVisible(false);
|
|
jf.dispose();
|
|
|
|
// remove ourself as change listener on Case
|
|
Case currcase = Case.getCurrentCase();
|
|
if (currcase != null) {
|
|
currcase.removePropertyChangeListener(this);
|
|
listeningToAddImage = false;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* The backbone of the timeline functionality, years are split into months, months into days, and days contain the events of that given day.
|
|
* All of those are Epochs.
|
|
*/
|
|
abstract class Epoch {
|
|
abstract public int getNumFiles();
|
|
}
|
|
|
|
private class YearEpoch extends Epoch {
|
|
|
|
private int year;
|
|
private List<MonthEpoch> months = new ArrayList<>();
|
|
|
|
YearEpoch(int year) {
|
|
this.year = year;
|
|
}
|
|
|
|
public int getYear() {
|
|
return year;
|
|
}
|
|
|
|
@Override
|
|
public int getNumFiles() {
|
|
int size = 0;
|
|
for (MonthEpoch me : months) {
|
|
size += me.getNumFiles();
|
|
}
|
|
return size;
|
|
}
|
|
|
|
public MonthEpoch getMonth(int monthNum) {
|
|
MonthEpoch month = null;
|
|
for (MonthEpoch me :months) {
|
|
if (me.getMonthInt() == monthNum) {
|
|
month = me;
|
|
break;
|
|
}
|
|
}
|
|
return month;
|
|
}
|
|
|
|
public void add(AbstractFile af, int month, int day) {
|
|
// see if this month is in the list
|
|
MonthEpoch monthEpoch = null;
|
|
for (MonthEpoch me : months) {
|
|
if (me.getMonthInt() == month) {
|
|
monthEpoch = me;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (monthEpoch == null) {
|
|
monthEpoch = new MonthEpoch(month);
|
|
months.add(monthEpoch);
|
|
}
|
|
|
|
// add the file the the MonthEpoch object
|
|
monthEpoch.add(af, day);
|
|
}
|
|
}
|
|
|
|
private class MonthEpoch extends Epoch {
|
|
|
|
private int month; //Zero-indexed: June = 5, August = 7, etc
|
|
private List<DayEpoch> days = new ArrayList<>(); //List of DayEpochs in this month, max 31
|
|
|
|
MonthEpoch(int month) {
|
|
this.month = month;
|
|
}
|
|
|
|
public int getMonthInt() {
|
|
return month;
|
|
}
|
|
|
|
public int getTotalNumDays(int year) {
|
|
Calendar cal = Calendar.getInstance();
|
|
cal.set(year, month, 1);
|
|
return cal.getActualMaximum(Calendar.DAY_OF_MONTH);
|
|
}
|
|
|
|
@Override
|
|
public int getNumFiles() {
|
|
int numFiles = 0;
|
|
for (DayEpoch de : days) {
|
|
numFiles += de.getNumFiles();
|
|
}
|
|
return numFiles;
|
|
}
|
|
|
|
public DayEpoch getDay(int dayNum) {
|
|
DayEpoch de = null;
|
|
for (DayEpoch d : days) {
|
|
if (d.dayNum == dayNum) {
|
|
de = d;
|
|
break;
|
|
}
|
|
}
|
|
return de;
|
|
}
|
|
|
|
public void add(AbstractFile af, int day) {
|
|
DayEpoch dayEpoch = null;
|
|
for (DayEpoch de : days) {
|
|
if (de.getDayInt() == day) {
|
|
dayEpoch = de;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (dayEpoch == null) {
|
|
dayEpoch = new DayEpoch(day);
|
|
days.add(dayEpoch);
|
|
}
|
|
|
|
dayEpoch.add(af);
|
|
}
|
|
|
|
/**
|
|
* Returns the month's name in String format, e.g., September, July,
|
|
*/
|
|
String getMonthName() {
|
|
return new DateFormatSymbols().getMonths()[month];
|
|
}
|
|
|
|
/**
|
|
* @return the list of days in this month
|
|
*/
|
|
List<DayEpoch> getDays() {
|
|
return this.days;
|
|
}
|
|
}
|
|
|
|
private class DayEpoch extends Epoch {
|
|
|
|
private List<AbstractFile> files = new ArrayList<>();
|
|
int dayNum = 0; //Day of the month this Epoch represents, 1 indexed: 28=28.
|
|
|
|
DayEpoch(int dayOfMonth) {
|
|
this.dayNum = dayOfMonth;
|
|
}
|
|
|
|
public int getDayInt() {
|
|
return dayNum;
|
|
}
|
|
|
|
@Override
|
|
public int getNumFiles() {
|
|
return files.size();
|
|
}
|
|
|
|
public void add(AbstractFile af) {
|
|
files.add(af);
|
|
}
|
|
|
|
List<AbstractFile> getEvents() {
|
|
return this.files;
|
|
}
|
|
}
|
|
|
|
// The node factories used to make lists of files to send to the result viewer
|
|
private class FsContentNodeChildFactory extends ChildFactory<AbstractFile> {
|
|
List<AbstractFile> l;
|
|
FsContentNodeChildFactory(List<AbstractFile> l) {
|
|
this.l = l;
|
|
}
|
|
@Override
|
|
protected boolean createKeys(List<AbstractFile> list) {
|
|
list.addAll(l);
|
|
return true;
|
|
}
|
|
@Override
|
|
protected Node createNodeForKey(AbstractFile file) {
|
|
Node n;
|
|
if (file.isDir()) {
|
|
n = new DirectoryNode((Directory) file);
|
|
} else {
|
|
n = new FileNode((File) file) {
|
|
|
|
@Override
|
|
public boolean isLeafTypeNode() {
|
|
return false;
|
|
}
|
|
|
|
};
|
|
}
|
|
return n;
|
|
}
|
|
}
|
|
|
|
private class FsContentRootNode extends DisplayableItemNode {
|
|
FsContentRootNode(String NAME, List<AbstractFile> l) {
|
|
super(Children.create(new FsContentNodeChildFactory(l), true));
|
|
super.setName(NAME);
|
|
super.setDisplayName(NAME);
|
|
}
|
|
@Override
|
|
public DisplayableItemNode.TYPE getDisplayableItemNodeType() {
|
|
return DisplayableItemNode.TYPE.CONTENT;
|
|
}
|
|
@Override
|
|
public <T> T accept(DisplayableItemNodeVisitor<T> v) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private List<YearEpoch> parseMacTime(java.io.File f) {
|
|
List<YearEpoch> years = new ArrayList<>();
|
|
Scanner scan;
|
|
try {
|
|
scan = new Scanner(new FileInputStream(f));
|
|
} catch (FileNotFoundException ex) {
|
|
logger.log(Level.SEVERE, "Error: could not find mactime file.", ex);
|
|
return years;
|
|
}
|
|
scan.useDelimiter(",");
|
|
scan.nextLine(); // skip the header line
|
|
SleuthkitCase skCase = Case.getCurrentCase().getSleuthkitCase();
|
|
|
|
int prevYear = -1;
|
|
YearEpoch ye = null;
|
|
while (scan.hasNextLine()) {
|
|
String[] s = scan.nextLine().split(","); //1999-02-08T11:08:08Z, 78706, m..b, rrwxrwxrwx, 0, 0, 8355, /img...
|
|
String[] datetime = s[0].split("T"); //{1999-02-08, 11:08:08Z}
|
|
String[] date = datetime[0].split("-"); // {1999, 02, 08}
|
|
int year = Integer.valueOf(date[0]);
|
|
int month = Integer.valueOf(date[1]) - 1; //Months are zero indexed: 1 = February, 6 = July, 11 = December
|
|
int day = Integer.valueOf(date[2]); //Days are 1 indexed
|
|
long ObjId = Long.valueOf(s[4]);
|
|
|
|
// when the year changes, create and add a new YearEpoch object to the list
|
|
if (year != prevYear) {
|
|
ye = new YearEpoch(year);
|
|
years.add(ye);
|
|
prevYear = year;
|
|
}
|
|
|
|
// create and add the file
|
|
AbstractFile file;
|
|
try {
|
|
file = skCase.getAbstractFileById(ObjId);
|
|
} catch (TskCoreException ex) {
|
|
logger.log(Level.SEVERE, "Could not find a file with ID " + ObjId, ex);
|
|
continue;
|
|
}
|
|
ye.add(file, month, day);
|
|
}
|
|
|
|
scan.close();
|
|
|
|
return years;
|
|
}
|
|
|
|
private String makeBodyFile() {
|
|
// Setup timestamp
|
|
DateFormat dateFormat = new SimpleDateFormat("MM-dd-yyyy-HH-mm-ss");
|
|
Date date = new Date();
|
|
String datenotime = dateFormat.format(date);
|
|
|
|
Case currentCase = Case.getCurrentCase();
|
|
SleuthkitCase skCase = currentCase.getSleuthkitCase();
|
|
// Get report path
|
|
String bodyFilePath = moduleDir.getAbsolutePath()
|
|
+ java.io.File.separator + currentCase.getName() + "-" + datenotime + ".txt";
|
|
|
|
// Run query to get all files
|
|
String filesAndDirs = "type = '" + TskData.TSK_DB_FILES_TYPE_ENUM.FS.getFileType() + "' "
|
|
+ "AND name != '.' "
|
|
+ "AND name != '..'";
|
|
List<FsContent> fs = Collections.EMPTY_LIST;
|
|
try {
|
|
fs = skCase.findFilesWhere(filesAndDirs);
|
|
} catch (TskCoreException ex) {
|
|
Exceptions.printStackTrace(ex);
|
|
}
|
|
|
|
// Loop files and write info to report
|
|
BufferedWriter out = null;
|
|
try {
|
|
out = new BufferedWriter(new FileWriter(bodyFilePath, true));
|
|
} catch (IOException ex) {
|
|
logger.log(Level.WARNING, "Could not create new BufferedWriter for body file.", ex);
|
|
}
|
|
for (FsContent file : fs) {
|
|
try {
|
|
// MD5|name|inode|mode_as_string|ObjId|GID|size|atime|mtime|ctime|crtime
|
|
//out = new BufferedWriter(new FileWriter(bodyFilePath, true));
|
|
|
|
if (file.getMd5Hash() != null) {
|
|
out.write(file.getMd5Hash());
|
|
}
|
|
out.write("|");
|
|
String path = "";
|
|
try {
|
|
path = file.getUniquePath();
|
|
} catch (TskCoreException e) {
|
|
logger.log(Level.WARNING, "Failed to get the unique path.", e);
|
|
}
|
|
|
|
out.write(path);
|
|
|
|
out.write("|");
|
|
out.write(Long.toString(file.getMetaAddr()));
|
|
out.write("|");
|
|
String modeString = file.getModesAsString();
|
|
if (modeString != null) {
|
|
out.write(modeString);
|
|
}
|
|
out.write("|");
|
|
out.write(Long.toString(file.getId()));
|
|
out.write("|");
|
|
out.write(Long.toString(file.getGid()));
|
|
out.write("|");
|
|
out.write(Long.toString(file.getSize()));
|
|
out.write("|");
|
|
out.write(Long.toString(file.getAtime()));
|
|
out.write("|");
|
|
out.write(Long.toString(file.getMtime()));
|
|
out.write("|");
|
|
out.write(Long.toString(file.getCtime()));
|
|
out.write("|");
|
|
out.write(Long.toString(file.getCrtime()));
|
|
out.write("\n");
|
|
} catch (IOException ex) {
|
|
logger.log(Level.WARNING, "Probelm while trying to write data to the body file.", ex);
|
|
break;
|
|
}
|
|
}
|
|
|
|
try {
|
|
out.flush();
|
|
out.close();
|
|
} catch (IOException ex1) {
|
|
logger.log(Level.WARNING, "Could not flush and/or close body file.", ex1);
|
|
}
|
|
|
|
return bodyFilePath;
|
|
}
|
|
|
|
private String makeMacTime(String pathToBodyFile) {
|
|
String macpath = "";
|
|
final String machome = macRoot.getAbsolutePath();
|
|
if (PlatformUtil.isWindowsOS()) {
|
|
macpath = machome + java.io.File.separator + "mactime.exe";
|
|
macpath = PlatformUtil.getOSFilePath(macpath);
|
|
} else {
|
|
macpath = "perl " + machome + java.io.File.separator + "mactime.pl";
|
|
}
|
|
String macfile = moduleDir.getAbsolutePath() + java.io.File.separator + mactimeFileName;
|
|
macfile = PlatformUtil.getOSFilePath(macfile);
|
|
String command = macpath + " -b " + "\"" + pathToBodyFile + "\"" + " -d " + " -y " + ">" + "\"" + macfile + "\"";
|
|
try {
|
|
JavaSystemCaller.Exec.execute("\"" + command + "\"");
|
|
} catch (InterruptedException ie) {
|
|
logger.log(Level.WARNING, "Mactime process was interrupted by user", ie);
|
|
return null;
|
|
} catch (IOException ioe) {
|
|
logger.log(Level.SEVERE, "Could not create mactime file, encountered error ", ioe);
|
|
return null;
|
|
}
|
|
return macfile;
|
|
}
|
|
|
|
@Override
|
|
public boolean isEnabled() {
|
|
return Case.isCaseOpen();
|
|
}
|
|
|
|
@Override
|
|
public void performAction() {
|
|
if (!Case.existsCurrentCase()) {
|
|
return;
|
|
}
|
|
|
|
try {
|
|
if (Case.getCurrentCase().getImages().isEmpty()) {
|
|
logger.log(Level.INFO, "Error creating timeline, there are no images to parse");
|
|
} else {
|
|
|
|
if (IngestManager.getDefault().isIngestRunning()) {
|
|
int answer = JOptionPane.showConfirmDialog(new JFrame(),
|
|
"You are trying to generate a timeline before "
|
|
+ "ingest has been completed. The timeline may be "
|
|
+ "incomplete. Do you want to continue?", "Timeline",
|
|
JOptionPane.YES_NO_OPTION);
|
|
if (answer != JOptionPane.YES_OPTION) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
logger.log(Level.INFO, "Beginning generation of timeline");
|
|
|
|
// if the timeline window is already open, do nothing
|
|
if (jf != null && jf.isVisible()) {
|
|
return;
|
|
}
|
|
|
|
Platform.setImplicitExit(false);
|
|
|
|
// listen for case changes (specifically images being added).
|
|
Case currcase = Case.getCurrentCase();
|
|
if (currcase != null && !listeningToAddImage) {
|
|
currcase.addPropertyChangeListener(this);
|
|
listeningToAddImage = true;
|
|
}
|
|
|
|
// create the modal dialog
|
|
SwingUtilities.invokeLater(new Runnable () {
|
|
@Override
|
|
public void run() {
|
|
dialog = new TimelineProgressDialog(jf, true);
|
|
dialog.setVisible(true);
|
|
}
|
|
});
|
|
|
|
// initialize mactimeFileName
|
|
mactimeFileName = Case.getCurrentCase().getName() + "-MACTIME.txt";
|
|
|
|
// see if data has been added to the database since the last
|
|
// time timeline ran
|
|
long objId = Case.getCurrentCase().getSleuthkitCase().getLastObjectId();
|
|
if (objId != lastObjectId && lastObjectId != -1) {
|
|
clearMactimeData();
|
|
}
|
|
lastObjectId = objId;
|
|
|
|
customizeSwing();
|
|
customize();
|
|
}
|
|
} catch (TskCoreException ex) {
|
|
Exceptions.printStackTrace(ex);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public String getName() {
|
|
return "Make Timeline (Beta)";
|
|
}
|
|
|
|
@Override
|
|
public HelpCtx getHelpCtx() {
|
|
return HelpCtx.DEFAULT_HELP;
|
|
}
|
|
|
|
@Override
|
|
public boolean asynchronous() {
|
|
return false;
|
|
}
|
|
//<editor-fold defaultstate="collapsed" desc="Old Functions">
|
|
/**
|
|
* Old Functions *
|
|
*/
|
|
// private BarChart createEventsByYear(final YearEpoch ye) {
|
|
// final CategoryAxis xAxis = new CategoryAxis();
|
|
// final NumberAxis yAxis = new NumberAxis();
|
|
// final int maxEvents = ye.max;
|
|
// final int maxNumDays = ye.numDays;
|
|
// xAxis.setLabel("Day of Year");
|
|
// yAxis.setLabel("Number of Events");
|
|
// ObservableList<BarChart.Series<String, Number>> seriesList = FXCollections.observableArrayList();
|
|
// for (final MonthEpoch me : ye.months) {
|
|
// BarChart.Series<String, Number> series = new BarChart.Series(makeObservableListByMonthAllDays(me));
|
|
// series.setName(me.getMonthName() + " " + me.year);
|
|
// seriesList.add(series);
|
|
// }
|
|
// final BarChart<String, Number> bc = new BarChart<String, Number>(xAxis, yAxis, seriesList);
|
|
// for (int i = 0; i < bc.getData().size(); i++) {
|
|
// for (final BarChart.Data data : bc.getData().get(i).getData()) {
|
|
// data.getNode().setScaleX(240);
|
|
// data.getNode().addEventHandler(MouseEvent.MOUSE_PRESSED,
|
|
// new EventHandler<MouseEvent>() {
|
|
// @Override
|
|
// public void handle(MouseEvent e) {
|
|
// final FsContentRootNode d = new FsContentRootNode("Test Year Nodes", (((MonthEpoch) data.getExtraValue()).getDays().get(Integer.valueOf(((String) data.getXValue()).split("-")[1]))).getEvents());
|
|
// SwingUtilities.invokeLater(new Runnable() {
|
|
// @Override
|
|
// public void run() {
|
|
// dataResult.setNode(d);
|
|
// }
|
|
// });
|
|
// }
|
|
// });
|
|
// }
|
|
// }
|
|
// bc.autosize();
|
|
// bc.setPrefWidth(63 * maxNumDays);
|
|
// //bc.setScaleX(1.25);
|
|
// //bc.setMinSize(30 * maxNumDays, 4 * maxEvents); // 40 * numDays in year, 4 * maxEvents
|
|
// //bc.setMaxSize(30 * maxNumDays, 4 * maxEvents); //Width, Height
|
|
// return bc;
|
|
// }
|
|
/*
|
|
* the small 12-month chart
|
|
*/
|
|
// private BarChart createMonthBarChartFromYear(final YearEpoch ye) {
|
|
// final CategoryAxis xAxis = new CategoryAxis();
|
|
// final NumberAxis yAxis = new NumberAxis();
|
|
// final int numMonths = 12;
|
|
// final int maxEvents = ye.max;
|
|
// xAxis.setLabel("Month (" + ye.year + ")");
|
|
// yAxis.setLabel("Number of Events");
|
|
// ObservableList<BarChart.Series<String, Number>> bcData = FXCollections.observableArrayList();
|
|
//
|
|
// BarChart.Series<String, Number> se = new BarChart.Series<String, Number>();
|
|
// for (final MonthEpoch me : ye.months) {
|
|
// se.getData().add(new BarChart.Data<String, Number>(me.getMonthName(), me.total));
|
|
// }
|
|
// bcData.add(se);
|
|
//
|
|
//
|
|
// final BarChart<String, Number> bc = new BarChart<String, Number>(xAxis, yAxis, bcData);//bcData);
|
|
// for (int i = 0; i < numMonths; i++) {
|
|
// for (final BarChart.Data data : bc.getData().get(0).getData()) {
|
|
// data.getNode().setScaleX(26);
|
|
// data.getNode().addEventHandler(MouseEvent.MOUSE_PRESSED,
|
|
// new EventHandler<MouseEvent>() {
|
|
// @Override
|
|
// public void handle(MouseEvent e) {
|
|
//
|
|
// PlatformImpl.startup(new Runnable() {
|
|
// @Override
|
|
// public void run() {
|
|
// chart_Events = createEventsByMonth(findMonth(ye.months, month_StringtoInt((String) data.getXValue())));
|
|
// scroll_Events.setContent(chart_Events);
|
|
// }
|
|
// });
|
|
//
|
|
// }
|
|
// });
|
|
// }
|
|
// }
|
|
//
|
|
// bc.setPrefHeight(Height_PieBoxes);
|
|
// bc.setPrefWidth(Width_PieBoxes);
|
|
// bc.setLegendVisible(false);
|
|
// return bc;
|
|
// }
|
|
// boolean checkCache(List<YearEpoch> epochs, int match) {
|
|
// for (Epoch e : epochs) {
|
|
// if (e.year == match) {
|
|
// return true;
|
|
// }
|
|
// }
|
|
// return false;
|
|
// }
|
|
//
|
|
// YearEpoch getFromCache(List<YearEpoch> epochs, int match) {
|
|
// for (YearEpoch e : epochs) {
|
|
// if (e.year == match) {
|
|
// return e;
|
|
// }
|
|
// }
|
|
// return null;
|
|
// }
|
|
// private PieChart initYearChart() {
|
|
// ObservableList<PieChart.Data> pieChartData =
|
|
// FXCollections.observableArrayList();
|
|
//
|
|
// double totalEvents = 0.0;
|
|
// String sep = java.io.File.separator;
|
|
// java.io.File mactime = new java.io.File("C:" + sep + "Users" + sep + "nflower" + sep + "Downloads" + sep + "kanarazu-12-21-2012-11-15-46-mactime.txt");
|
|
// List<YearEpoch> ls = parseMacTime(mactime);
|
|
//
|
|
// for (int i = 0; i < ls.size(); i++) {
|
|
// cachedYears.add(ls.get(i));
|
|
// totalEvents += ls.get(i).total;
|
|
// }
|
|
//
|
|
// for (YearEpoch e : ls) {
|
|
// PieChart.Data d = new PieChart.Data(String.valueOf(e.year), (e.total / totalEvents) * 100);
|
|
// pieChartData.add(d);
|
|
// }
|
|
// final PieChart chart = new PieChart(pieChartData);
|
|
// chart.setTitle("Years with Activity");
|
|
// for (int i = 0; i < chart.getData().size(); i++) {
|
|
// final PieChart.Data data = chart.getData().get(i);
|
|
// final YearEpoch y = findYear(ls, Integer.valueOf(data.getName()));
|
|
// data.getNode().setUserData(y);
|
|
// data.getNode().addEventHandler(MouseEvent.MOUSE_PRESSED,
|
|
// new EventHandler<MouseEvent>() {
|
|
// @Override
|
|
// public void handle(MouseEvent e) {
|
|
// chart_Months = createMonthBarChartFromYear(((YearEpoch) data.getNode().getUserData()));
|
|
// scroll_Months.setContent(chart_Months);
|
|
//
|
|
// chart_Events = createEventsByYear(y);
|
|
// scroll_Events.setContent(chart_Events);
|
|
// chart_Events.getBoundsInParent();
|
|
// }
|
|
// });
|
|
//
|
|
// }
|
|
// chart.setLegendVisible(false);
|
|
// chart.setPrefHeight(Height_PieBoxes / 1.3);
|
|
// chart.setPrefWidth(Width_PieBoxes / 1.1);
|
|
// return chart;
|
|
// }
|
|
//</editor-fold>
|
|
}
|