private void updateDistanceDistributionChart() {
double[][] transformedTrajectory = getTransformedTrajectory();
if (transformedTrajectory == null) return;
double approxDiameter =
PhaseSpaceDistribution.maxPhaseSpaceDiameterApproximate(transformedTrajectory);
long[] histo;
// subsequent distance distribution
if (distanceDistributionSelector.getSelectionModel().getSelectedIndex() == 0) {
histo =
PhaseSpaceDistribution.approximateSubsequentDistanceDistribution(
transformedTrajectory, 1500, approxDiameter);
} else {
histo =
PhaseSpaceDistribution.approximateDistanceDistribution(
transformedTrajectory, 1500, approxDiameter);
}
subsequentDistanceDistributionChart.getData().clear();
XYChart.Series series = new XYChart.Series();
for (int i = 0; i < histo.length; i++) {
series.getData().add(new XYChart.Data(i, histo[i]));
}
subsequentDistanceDistributionChart.getData().add(series);
}
public LineChart<String, Number> fillChartNacimientos() {
final CategoryAxis xAxis = new CategoryAxis();
final NumberAxis yAxis = new NumberAxis();
xAxis.setLabel("Mes");
final LineChart<String, Number> lineChart = new LineChart<>(xAxis, yAxis);
lineChart.setTitle("Nacimientos de Beceros Por Año");
// lineChart.setCreateSymbols(false);
lineChart.setAlternativeRowFillVisible(false);
HashMap<Integer, int[]> data = dataForChartNacimientos();
Set<Integer> keySet = data.keySet();
for (Integer key : keySet) {
int[] get = data.get(key);
XYChart.Series series = new XYChart.Series();
series.setName("" + key);
series.getData().add(new XYChart.Data("Ene", get[1]));
series.getData().add(new XYChart.Data("Feb", get[2]));
series.getData().add(new XYChart.Data("Mar", get[3]));
series.getData().add(new XYChart.Data("Abr", get[4]));
series.getData().add(new XYChart.Data("May", get[5]));
series.getData().add(new XYChart.Data("Jun", get[6]));
series.getData().add(new XYChart.Data("Jul", get[7]));
series.getData().add(new XYChart.Data("Aug", get[8]));
series.getData().add(new XYChart.Data("Sep", get[9]));
series.getData().add(new XYChart.Data("Oct", get[10]));
series.getData().add(new XYChart.Data("Nov", get[11]));
series.getData().add(new XYChart.Data("Dec", get[12]));
lineChart.getData().add(series);
}
return (lineChart);
}
/**
* Método para pintar la gráfica
*
* @param min
* @param max
* @param grado
*/
private void pintarGrafica(int min, int max, int grado) {
// Creamos un ObservableList para guardar los puntos que pintaremos en la gráfica
ObservableList<XYChart.Series<Double, Double>> lineChartData =
FXCollections.observableArrayList();
// Instanciamos un punto a pintar
LineChart.Series<Double, Double> series = new LineChart.Series<Double, Double>();
// Imprimimos la función que vamos a pintar como etiqueta
series.setName("f(x^" + grado + ")");
// obtenemos los puntos a pintar. Daros cuenta que los puntos a pintar estan definidos
// por el valor de 'x' y el resultado de 'f(x)', siendo f(x)=Math.pow(x, grado) = x^grado
for (double i = min; i < max; i = i + 0.1) {
series.getData().add(new XYChart.Data<Double, Double>(i, Math.pow(i, grado)));
}
// Guardamos todos los puntos de la función que hemos obtenido
lineChartData.add(series);
// Si No quereis que se pinten los puntos, poner a false
graph.setCreateSymbols(true);
// Ponemos los puntos en la gráfica
graph.setData(lineChartData);
graph.createSymbolsProperty();
}
private void updateTimeSeriesChart() {
// clear time series chart
timeSeriesChart.getData().clear();
// fill time series chart
double[][] transformedTrajectory = getTransformedTrajectory();
for (int i = 0; i < transformedTrajectory.length; i++) {
XYChart.Series series = new XYChart.Series();
series.setName("Dimension " + (i + 1));
for (int j = 0; j < transformedTrajectory[i].length; j++) {
series.getData().add(new XYChart.Data(j, transformedTrajectory[i][j]));
}
timeSeriesChart.getData().add(series);
}
}
/**
* Handle user actions on the toggle group to switch between weekly bar chart and monthly line
* chart
*/
@FXML
private void handleChartRadioActions() {
if (weekRadio.isSelected()) {
// remove month line chart from view
monthLineChart.setVisible(false);
// set week bar chart visible
weekBarChart.setVisible(true);
}
if (monthRadio.isSelected()) {
// remove month line chart from view
weekBarChart.setVisible(false);
// set week bar chart visible
monthLineChart.setVisible(true);
}
}
private void setUpLineChart() {
NumberAxis xAxis = new NumberAxis();
NumberAxis yAxis = new NumberAxis();
xAxis.setLabel("Czas (s)");
yAxis.setLabel("Temperatura (C)");
lineChart = new LineChart<Number, Number>(xAxis, yAxis);
lineChart.setPrefSize(1000, 760);
}
public void drawTrack() {
int offset = Math.round(longestTrackFrameLength / GRAPH_POINT_COUNT);
offset = (int) (offset * (track.getSampleRate() / 44100));
XYChart.Series<Number, Number> series = new XYChart.Series<Number, Number>();
float[] tempData = track.getAudioData();
int audioFileLength = track.getLength();
int x = 0;
/**
* TODO momentan ist die Zeichnung auf 2000 Werte begrenzt, bei längeren Files kommt dadurch
* kein schönes Bild zustande, müssen wir uns noch anschauen
*/
for (int i = 0; i < audioFileLength * track.getNumberOfChannels(); i += offset) {
float mean = 0;
float leftChannel = tempData[i];
if (track.getNumberOfChannels() == 2) {
float rightChannel = tempData[i + 1];
mean = (leftChannel + rightChannel) / 2;
} else {
mean = leftChannel;
}
series.getData().add(new XYChart.Data<Number, Number>(x, mean));
x++;
}
// Fill rest with zeroes
// TODO: it seems like we're actually drawing 2 x 2000 points??
for (; x < GRAPH_POINT_COUNT * track.getNumberOfChannels(); x++) {
series.getData().add(new XYChart.Data<Number, Number>(x, 0));
}
lineChartWaveform.getData().clear();
lineChartWaveform.getData().add(series);
NumberAxis xAxis = (NumberAxis) lineChartWaveform.getXAxis();
xAxis.setAutoRanging(false);
xAxis.setUpperBound(x - 1);
NumberAxis yAxis = (NumberAxis) lineChartWaveform.getYAxis();
yAxis.setAutoRanging(false);
yAxis.setLowerBound(-1.0);
yAxis.setUpperBound(1.0);
}
protected LineChart<Number, Number> createChart() {
final NumberAxis xAxis = new NumberAxis();
final NumberAxis yAxis = new NumberAxis();
final LineChart<Number, Number> lc = new LineChart<Number, Number>(xAxis, yAxis);
// setup chart
lc.setTitle("Basic LineChart");
xAxis.setLabel("X Axis");
yAxis.setLabel("Y Axis");
// add starting data
Series<Number, Number> series = new Series<Number, Number>();
series.setName("Data Series 1");
series.getData().add(new XYChart.Data<Number, Number>(20d, 50d));
series.getData().add(new XYChart.Data<Number, Number>(40d, 80d));
series.getData().add(new XYChart.Data<Number, Number>(50d, 90d));
series.getData().add(new XYChart.Data<Number, Number>(70d, 30d));
series.getData().add(new XYChart.Data<Number, Number>(170d, 122d));
lc.getData().add(series);
return lc;
}
public Parent createContent() {
xAxis = new CategoryAxis();
yAxis = new NumberAxis();
chart = new LineChart<>(xAxis, yAxis);
// setup chart
chart.setTitle("LineChart with Category Axis");
xAxis.setLabel("X Axis");
yAxis.setLabel("Y Axis");
// add starting data
XYChart.Series<String, Number> series = new XYChart.Series<>();
series.setName("Data Series 1");
series.getData().add(new XYChart.Data<String, Number>(CATEGORIES[0], 50d));
series.getData().add(new XYChart.Data<String, Number>(CATEGORIES[1], 80d));
series.getData().add(new XYChart.Data<String, Number>(CATEGORIES[2], 90d));
series.getData().add(new XYChart.Data<String, Number>(CATEGORIES[3], 30d));
series.getData().add(new XYChart.Data<String, Number>(CATEGORIES[4], 122d));
series.getData().add(new XYChart.Data<String, Number>(CATEGORIES[5], 10d));
chart.getData().add(series);
return chart;
}
@Override
public void start(Stage stage) {
Parameters parameters = getParameters();
List<String> rawArguments = parameters.getRaw();
List<String> file_paths = new LinkedList<String>();
int size = rawArguments.size(); // un solo file / argomento in realtà
for (int i = 0; i < size; i++) {
String path_data_file = rawArguments.get(i);
System.out.println(" * data file n." + (i + 1) + " : " + path_data_file);
file_paths.add(path_data_file);
}
stage.setTitle("Cpu during joining");
final NumberAxis xAxis = new NumberAxis();
final NumberAxis yAxis = new NumberAxis();
xAxis.setLabel("time");
// xAxis.setTickUnit(10);
yAxis.setLabel("CPU %");
yAxis.setTickUnit(2);
final LineChart<Number, Number> lineChart = new LineChart<Number, Number>(xAxis, yAxis);
lineChart.setTitle("CPU during Joining and Cleanups");
lineChart.setCreateSymbols(false);
// add_line_to_chart(lineChart, file_paths.get(0), "from 3 to 4 nodes", 3, 80000);
// add_line_to_chart(lineChart, file_paths.get(0), "from 4 to 5 nodes", 4, 95000);
add_line_to_chart(lineChart, file_paths.get(0), "from 5 to 6 nodes", 5, 112000);
Scene scene = new Scene(lineChart, 800, 600);
stage.setScene(scene);
stage.show();
}
private void enableStereoSettings(SidTune tune) {
EmulationSection emulationSection = util.getConfig().getEmulationSection();
boolean second = SidTune.isSIDUsed(emulationSection, tune, 1);
boolean third = SidTune.isSIDUsed(emulationSection, tune, 2);
int sidBase = SidTune.getSIDAddress(emulationSection, tune, 0);
int dualSidBase = SidTune.getSIDAddress(emulationSection, tune, 1);
boolean isForcedStereo = second && emulationSection.isForceStereoTune();
boolean isFakeStereo = isForcedStereo && dualSidBase == sidBase;
boolean isForced3Sid = third && emulationSection.isForce3SIDTune();
if (isFakeStereo) {
stereoMode.getSelectionModel().select(StereoMode.FAKE_STEREO);
} else if (isForced3Sid) {
stereoMode.getSelectionModel().select(StereoMode.THREE_SID);
} else if (isForcedStereo) {
stereoMode.getSelectionModel().select(StereoMode.STEREO);
} else {
stereoMode.getSelectionModel().select(StereoMode.AUTO);
}
// stereo, only:
mainBalance.setDisable(!second);
secondVolume.setDisable(!second);
secondBalance.setDisable(!second);
sid2Emulation.setDisable(!second);
sid2Model.setDisable(!second);
secondFilter.setDisable(!second);
secondFilterCurve.setDisable(!second);
// 3-SID, only:
thirdVolume.setDisable(!third);
thirdBalance.setDisable(!third);
sid3Emulation.setDisable(!third);
sid3Model.setDisable(!third);
thirdFilter.setDisable(!third);
thirdFilterCurve.setDisable(!third);
// fake stereo, only:
sidToRead.setDisable(!(isFakeStereo));
// forced stereo or forced 3-SID, only:
baseAddress.setDisable(!(isForcedStereo || isForced3Sid));
// forced 3-SID, only:
thirdAddress.setDisable(!isForced3Sid);
}
/**
* Called after @FXML annotated fields are injected and so is used to update the view with the
* data built in the constructor.
*
* <p>Retrieves history and achievement information from the account to build the charts and set
* the text for attribute and username labels.
*
* <p>First displays the user's workout activity in the last seven days but the user is allowed to
* switch between last 30 days/ last 7 days charts
*/
@FXML
private void initialize() {
// build the series from the workout history information
workoutHistoryLog = HistoryAnalyser.getDailyWorkoutHistoryFromCurrentAccount();
makeWeekSeriesFromAccountHistory();
makeMonthSeriesFromAccountHistory();
// ----------------------------------------------------------//
// Character attributes and avatar
// Get the authenticated and up to date account and get its attributes
Account account = Main.account;
attributes = account.getCharacterAttributes();
// ----------------------------------------------------------//
// Progress charts
// immediately remove the line chart that displays the last 30 days of workout activity from
// view
monthLineChart.setVisible(false);
// add the series to their charts
weekBarChart.getData().add(seriesW);
monthLineChart.getData().add(seriesM);
// manage the toggling feature between month and weekRadios
radioGroup = new ToggleGroup();
monthRadio.setToggleGroup(radioGroup);
weekRadio.setToggleGroup(radioGroup);
// Initially set week radio to selected
weekRadio.setSelected(true);
showAccountAttributes();
showAvatarInStackPane();
showAchievementsInListView();
}
private void updateLineLengthHistogram(ObservableValue obs, Number oldValue, Number newValue) {
if (drqa == null) return;
long[][] histos;
if (useDRQA.isSelected())
histos = new long[][] {drqa.l_hist, drqa.v_hist, drqa.w_hist, drqa.r_hist};
else {
// add indefinite and definite histograms
histos =
new long[][] {
Arrays.copyOf(drqa.l_hist, drqa.l_hist.length),
Arrays.copyOf(drqa.v_hist, drqa.v_hist.length),
Arrays.copyOf(drqa.w_hist, drqa.w_hist.length),
Arrays.copyOf(drqa.r_hist, drqa.r_hist.length),
};
long[][] indefiniteHistos =
new long[][] {
drqa.l_hist_indefinite,
drqa.v_hist_indefinite,
drqa.w_hist_indefinite,
drqa.r_hist_indefinite
};
// add the indefinite histos to the definite histos to gain traditional rqa
for (int i = 0; i < histos.length; i++) {
for (int j = 0; j < indefiniteHistos[i].length; j++) histos[i][j] += indefiniteHistos[i][j];
}
}
lineLengthHistogram.getData().clear();
long[] histogram = histos[newValue.intValue()];
// fill time series chart
XYChart.Series series = new XYChart.Series();
for (int i = 0; i < histogram.length; i++) {
series.getData().add(new XYChart.Data(i, histogram[i]));
}
lineLengthHistogram.getData().add(series);
}
/**
* Draw filter curve of the specified SID number and filter name
*
* @param filterBox filter combo box
* @param num SID chip number
*/
private void drawFilterCurve(
final ComboBox<String> filterBox, LineChart<Number, Number> filterCurve) {
EmulationSection emulationSection = util.getConfig().getEmulationSection();
XYChart.Series<Number, Number> series = new XYChart.Series<Number, Number>();
series.setName(util.getBundle().getString("FILTERCURVE_TITLE"));
filterCurve.getData().clear();
SidTune tune = util.getPlayer().getTune();
boolean second = SidTune.isSIDUsed(emulationSection, tune, 1);
boolean third = SidTune.isSIDUsed(emulationSection, tune, 2);
Optional<FilterSection> optFilter =
util.getConfig()
.getFilterSection()
.stream()
.filter(f -> f.getName().equals(filterBox.getSelectionModel().getSelectedItem()))
.findFirst();
if (optFilter.isPresent()) {
FilterSection filter = optFilter.get();
// stereo curve or 3-SID curve currently not used?
if (!((filterCurve == secondFilterCurve && !second)
|| (filterCurve == thirdFilterCurve && !third))) {
for (int fc = 0; fc < SIDChip.FC_MAX; fc += STEP) {
if (filter.isReSIDFilter6581() || filter.isReSIDFilter8580()) {
double data = resid_builder.resid.FilterModelConfig.estimateFrequency(filter, fc);
series.getData().add(new XYChart.Data<Number, Number>(fc, (int) data));
} else if (filter.isReSIDfpFilter6581() || filter.isReSIDfpFilter8580()) {
double data = resid_builder.residfp.FilterModelConfig.estimateFrequency(filter, fc);
series.getData().add(new XYChart.Data<Number, Number>(fc, (int) data));
}
}
}
}
filterCurve.getData().add(series);
}
@Override
public void initialize(URL arg0, ResourceBundle arg1) {
days.bind(viewModel.daysProperty());
targetLineSeries.dataProperty().bind(viewModel.targetLineDataProperty());
loggedHoursSeries.dataProperty().bind(viewModel.loggedHoursDataProperty());
burndownSeries.dataProperty().bind(viewModel.burndownDataProperty());
burndownChart.getData().addAll(targetLineSeries, loggedHoursSeries, burndownSeries);
burndownChart.getXAxis().setAutoRanging(true);
// style
burndownChart.setLegendVisible(false);
burndownChart.setAnimated(false);
yAxis.setMinorTickVisible(false);
exportHyperlink.setOnAction(
event -> {
burndownChart.snapshot(
snapshotResult -> {
WritableImage image = snapshotResult.getImage();
// https://community.oracle.com/thread/2450090?tstart=0
final FileChooser fileChooser = new FileChooser();
fileChooser
.getExtensionFilters()
.addAll(
new FileChooser.ExtensionFilter("PNG Files", "*.png"),
new FileChooser.ExtensionFilter("All Files", "*"));
String organisationFilename =
viewModel.organisationProperty().get().getSaveLocation().getName();
fileChooser.setInitialFileName(
organisationFilename.substring(0, organisationFilename.lastIndexOf('.'))
+ ".png");
File file = fileChooser.showSaveDialog(burndownChart.getScene().getWindow());
try {
if (file != null) {
ImageIO.write(SwingFXUtils.fromFXImage(image, null), "png", file);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
},
null,
null);
});
}
@Override
public void start(Stage primaryStage) throws Exception {
try {
screenSize = Screen.getPrimary().getVisualBounds();
width = screenSize.getWidth(); // gd.getDisplayMode().getWidth();
height = screenSize.getHeight(); // gd.getDisplayMode().getHeight();
} catch (Exception excep) {
System.out.println("<----- Exception in Get Screen Size ----->");
excep.printStackTrace();
System.out.println("<---------->\n");
}
try {
dbCon =
DriverManager.getConnection(
"jdbc:mysql://192.168.1.6:3306/ale", "Root", "oqu#$XQgHFzDj@1MGg1G8");
estCon = true;
} catch (SQLException sqlExcep) {
System.out.println("<----- SQL Exception in Establishing Database Connection ----->");
sqlExcep.printStackTrace();
System.out.println("<---------->\n");
}
xmlParser.generateUserInfo();
superUser = xmlParser.getSuperUser();
// ----------------------------------------------------------------------------------------------------> Top Panel Start
closeBtn = new Button("");
closeBtn.getStyleClass().add("systemBtn");
closeBtn.setOnAction(
e -> {
systemClose();
});
minimizeBtn = new Button("");
minimizeBtn.getStyleClass().add("systemBtn");
minimizeBtn.setOnAction(
e -> {
primaryStage.setIconified(true);
});
miscContainer = new HBox();
calcBtn = new Button();
calcBtn.getStyleClass().addAll("calcBtn");
calcBtn.setOnAction(
e -> {
calculator calculator = new calculator();
scientificCalculator scientificCalculator = new scientificCalculator();
calculator.start(calculatorName);
});
miscContainer.getChildren().add(calcBtn);
topPanel = new HBox(1);
topPanel.getStyleClass().add("topPanel");
topPanel.setPrefWidth(width);
topPanel.setAlignment(Pos.CENTER_RIGHT);
topPanel.setPadding(new Insets(0, 0, 0, 0));
topPanel.getChildren().addAll(miscContainer, minimizeBtn, closeBtn);
// ------------------------------------------------------------------------------------------------------> Top Panel End
// ----------------------------------------------------------------------------------------------> Navigation Panel Start
Line initDivider = new Line();
initDivider.setStartX(0.0f);
initDivider.setEndX(205.0f);
initDivider.setStroke(Color.GRAY);
// <----- Dashboard ----->
dashboardToolTip = new Tooltip("Dashboard");
dashboardBtn = new Button("");
dashboardBtn.getStyleClass().add("dashboardBtn");
dashboardBtn.setTooltip(dashboardToolTip);
dashboardBtn.setOnAction(
e -> {
resetBtns();
rootPane.setCenter(dashBoardBase);
});
// <----- Profile ----->
profileToolTip = new Tooltip("Profile");
profileBtn = new Button();
profileBtn.getStyleClass().add("profileBtn");
profileBtn.setTooltip(profileToolTip);
profileBtn.setOnAction(
e -> {
resetBtns();
rootPane.setCenter(profilePanel);
});
// <----- Courses ----->
courseToolTip = new Tooltip("Courses");
coursesBtn = new Button("");
coursesBtn.getStyleClass().add("coursesBtn");
coursesBtn.setTooltip(courseToolTip);
coursesBtn.setOnAction(
e -> {
resetBtns();
rootPane.setCenter(coursesPanel);
// miscContainer.getChildren().addAll(watchVidBtn);
coursesPanel.setContent(coursesGridPanel);
});
Line mainDivider = new Line();
mainDivider.setStartX(0.0f);
mainDivider.setEndX(205.0f);
mainDivider.setStroke(Color.GRAY);
// <----- Simulations ----->
simsToolTip = new Tooltip("Simulations");
simsBtn = new Button();
simsBtn.getStyleClass().add("simsBtn");
simsBtn.setTooltip(simsToolTip);
simsBtn.setOnAction(
e -> {
resetBtns();
rootPane.setCenter(simsPanel);
simsPanel.setContent(simsGridPanel);
});
// <----- Text Editor ----->
textEditorToolTip = new Tooltip("Text Editor");
textEditorBtn = new Button();
textEditorBtn.getStyleClass().add("textEditorBtn");
textEditorBtn.setTooltip(textEditorToolTip);
textEditorBtn.setOnAction(
e -> {
resetBtns();
rootPane.setCenter(textEditorPanel);
miscContainer.getChildren().addAll(saveDocBtn);
});
Line toolsDivider = new Line();
toolsDivider.setStartX(0.0f);
toolsDivider.setEndX(205.0f);
toolsDivider.setStroke(Color.GRAY);
// <----- Wolfram Alpha ----->
wolframToolTip = new Tooltip("Wolfram Alpha");
wolframBtn = new Button();
wolframBtn.getStyleClass().add("wolframBtn");
wolframBtn.setTooltip(wolframToolTip);
wolframBtn.setOnAction(
e -> {
resetBtns();
rootPane.setCenter(wolframPanel);
});
// <----- Wikipedia ----->
wikipediaToolTip = new Tooltip();
wikipediaBtn = new Button();
wikipediaBtn.getStyleClass().add("wikipediaBtn");
wikipediaBtn.setTooltip(wikipediaToolTip);
wikipediaBtn.setOnAction(
e -> {
resetBtns();
rootPane.setCenter(wikipediaPanel);
});
Line sitesDivider = new Line();
sitesDivider.setStartX(0.0f);
sitesDivider.setEndX(205.0f);
sitesDivider.setStroke(Color.GRAY);
// <----- Settings ----->
settingsToolTip = new Tooltip("Settings");
settingsBtn = new Button();
settingsBtn.getStyleClass().add("settingsBtn");
settingsBtn.setTooltip(settingsToolTip);
settingsBtn.setOnAction(
e -> {
resetBtns();
rootPane.setCenter(settingsPanel);
});
leftPanel = new VBox(0);
// leftPanel.setPrefWidth(1);
leftPanel.getStyleClass().add("leftPane");
leftPanel
.getChildren()
.addAll(
initDivider,
dashboardBtn,
profileBtn,
coursesBtn,
mainDivider,
simsBtn,
textEditorBtn,
toolsDivider,
wolframBtn,
wikipediaBtn,
sitesDivider,
settingsBtn);
topPanel = new HBox(1);
topPanel.getStyleClass().add("topPanel");
topPanel.setPrefWidth(width);
topPanel.setAlignment(Pos.CENTER_RIGHT);
topPanel.setPadding(new Insets(0, 0, 0, 0));
topPanel.getChildren().addAll(miscContainer, minimizeBtn, closeBtn);
// ------------------------------------------------------------------------------------------------> Navigation Panel End
// -----------------------------------------------------------------------------------------------> Dashboard Pane Start
final WebView webVid = new WebView();
final WebEngine webVidEngine = webVid.getEngine();
webVid.setPrefHeight(860);
webVid.setPrefWidth(width - 118);
webVidEngine.loadContent("");
final NumberAxis xAxis = new NumberAxis();
final NumberAxis yAxis = new NumberAxis();
xAxis.setLabel("Day");
yAxis.setLabel("Score");
final LineChart<Number, Number> lineChart = new LineChart<Number, Number>(xAxis, yAxis);
lineChart.setTitle("Line Chart");
XYChart.Series<Number, Number> series = new XYChart.Series<Number, Number>();
series.setName("My Data");
// populating the series with data
series.getData().add(new XYChart.Data<Number, Number>(0.25, 36));
series.getData().add(new XYChart.Data<Number, Number>(1, 23));
series.getData().add(new XYChart.Data<Number, Number>(2, 114));
series.getData().add(new XYChart.Data<Number, Number>(3, 15));
series.getData().add(new XYChart.Data<Number, Number>(4, 124));
lineChart.getData().add(series);
lineChart.setPrefWidth(400);
lineChart.setPrefHeight(300);
lineChart.setLegendVisible(false);
chatRoomField = new TextField();
chatRoomField.getStyleClass().add("textField");
chatRoomField.setPromptText("Enter Chat Room");
chatRoomField.setOnKeyPressed(
new EventHandler<KeyEvent>() {
@Override
public void handle(KeyEvent event) {
if (event.getCode() == KeyCode.ENTER) {
chatRoom = chatRoomField.getText();
client.connect(messageArea, messageInputArea, superUser, chatRoom);
}
}
});
messageArea = new TextArea();
messageArea.getStyleClass().add("textArea");
messageArea.setWrapText(true);
messageArea.setPrefHeight(740);
messageArea.setEditable(false);
messageInputArea = new TextArea();
messageInputArea.getStyleClass().add("textArea");
messageInputArea.setWrapText(true);
messageInputArea.setPrefHeight(100);
messageInputArea.setPromptText("Enter Message");
messageInputArea.setOnKeyPressed(
new EventHandler<KeyEvent>() {
@Override
public void handle(KeyEvent event) {
if (event.getCode() == KeyCode.ENTER) {
client.send(messageArea, messageInputArea, superUser, chatRoom);
event.consume();
}
}
});
chatBox = new VBox();
chatBox.setPrefWidth(250);
chatBox.setMaxWidth(250);
chatBox.getStyleClass().add("chatBox");
chatBox.getChildren().addAll(chatRoomField, messageArea, messageInputArea);
// client.test(messageArea, messageInputArea);
dashboardGridPanel = new GridPane();
dashboardGridPanel.getStyleClass().add("gridPane");
dashboardGridPanel.setVgap(5);
dashboardGridPanel.setHgap(5);
dashboardGridPanel.setGridLinesVisible(false);
dashboardGridPanel.setPrefWidth(width - 430);
dashboardGridPanel.setPrefHeight(860);
dashboardGridPanel.setColumnIndex(lineChart, 0);
dashboardGridPanel.setRowIndex(lineChart, 0);
dashboardGridPanel.getChildren().addAll(lineChart);
dashboardPanel = new ScrollPane();
dashboardPanel.getStyleClass().add("scrollPane");
dashboardPanel.setPrefWidth(width - 400);
dashboardPanel.setPrefHeight(860);
dashboardPanel.setContent(dashboardGridPanel);
dashBoardBase = new HBox();
dashBoardBase.setPrefWidth(width - (leftPanel.getWidth() + chatBox.getWidth()));
dashBoardBase.setPrefHeight(860);
dashBoardBase.getChildren().addAll(dashboardPanel, chatBox);
// -------------------------------------------------------------------------------------------------> Dashboard Pane End
// -------------------------------------------------------------------------------------------------> Profile Pane Start
profilePictureBtn = new Button();
profilePictureBtn.getStyleClass().addAll("profilePictureBtn");
String profileUserName = xmlParser.getSuperUser();
String profileEmail = xmlParser.getEmail();
String profileAge = xmlParser.getAge();
String profileSchool = xmlParser.getSchool();
String profileCountry = "";
String profileCity = "";
userNameLbl = new Label(profileUserName);
userNameLbl.getStyleClass().add("profileLbl");
userNameLbl.setAlignment(Pos.CENTER);
emailLbl = new Label(profileEmail);
emailLbl.getStyleClass().add("profileLbl");
ageLbl = new Label(profileAge);
ageLbl.getStyleClass().add("profileLbl");
schoolLbl = new Label(profileSchool);
schoolLbl.getStyleClass().add("profileLbl");
profileGridPanel = new GridPane();
profileGridPanel.getStyleClass().add("gridPane");
profileGridPanel.setVgap(5);
profileGridPanel.setHgap(5);
profileGridPanel.setGridLinesVisible(false);
profileGridPanel.setPrefWidth(width - 208);
profileGridPanel.setPrefHeight(860);
profileGridPanel.setAlignment(Pos.TOP_CENTER);
profileGridPanel.setRowIndex(profilePictureBtn, 0);
profileGridPanel.setColumnIndex(profilePictureBtn, 0);
profileGridPanel.setRowIndex(userNameLbl, 1);
profileGridPanel.setColumnIndex(userNameLbl, 0);
profileGridPanel.setRowIndex(emailLbl, 2);
profileGridPanel.setColumnIndex(emailLbl, 0);
profileGridPanel.setRowIndex(ageLbl, 3);
profileGridPanel.setColumnIndex(ageLbl, 0);
profileGridPanel.setRowIndex(schoolLbl, 4);
profileGridPanel.setColumnIndex(schoolLbl, 0);
profileGridPanel
.getChildren()
.addAll(profilePictureBtn, userNameLbl, emailLbl, ageLbl, schoolLbl);
profilePanel = new ScrollPane();
profilePanel.getStyleClass().add("scrollPane");
profilePanel.setContent(profileGridPanel);
// ---------------------------------------------------------------------------------------------------> Profile Pane End
// -------------------------------------------------------------------------------------------------> Courses Pane Start
String course = "";
// Media media = new Media("media.mp4");
// mediaPlayer = new MediaPlayer(media);
// mediaPlayer.setAutoPlay(true);
// mediaView = new MediaView(mediaPlayer);
watchVidBtn = new Button("Watch Video");
watchVidBtn.getStyleClass().add("btn");
watchVidBtn.setOnAction(
e -> {
// coursesPanel.setContent(mediaView);
});
chemistryBtn = new Button();
chemistryBtn.getStyleClass().add("chemistryBtn");
chemistryBtn.setOnAction(
e -> {
displayCourse("chemistry");
});
physicsBtn = new Button();
physicsBtn.getStyleClass().add("physicsBtn");
physicsBtn.setOnAction(
e -> {
displayCourse("physics");
});
mathsBtn = new Button();
mathsBtn.getStyleClass().add("mathsBtn");
bioBtn = new Button();
bioBtn.getStyleClass().add("bioBtn");
bioBtn.setOnAction(
e -> {
rootPane.setCenter(biologyCourse.biologyPane());
});
// Course Web View
try {
courseView = new WebView();
courseWebEngine = courseView.getEngine();
courseView.setPrefHeight(860);
courseView.setPrefWidth(width - 208);
} catch (Exception excep) {
System.out.println("<----- Exception in Course Web ----->");
excep.printStackTrace();
System.out.println("<---------->\n");
}
coursesGridPanel = new GridPane();
coursesGridPanel.getStyleClass().add("gridPane");
coursesGridPanel.setVgap(5);
coursesGridPanel.setHgap(5);
coursesGridPanel.setGridLinesVisible(false);
coursesGridPanel.setPrefWidth(width - 208);
coursesGridPanel.setPrefHeight(860);
coursesGridPanel.setRowIndex(chemistryBtn, 1);
coursesGridPanel.setColumnIndex(chemistryBtn, 1);
coursesGridPanel.setRowIndex(physicsBtn, 1);
coursesGridPanel.setColumnIndex(physicsBtn, 2);
coursesGridPanel.setRowIndex(mathsBtn, 1);
coursesGridPanel.setColumnIndex(mathsBtn, 3);
coursesGridPanel.setRowIndex(bioBtn, 1);
coursesGridPanel.setColumnIndex(bioBtn, 4);
coursesGridPanel.getChildren().addAll(chemistryBtn, physicsBtn, mathsBtn, bioBtn);
coursesPanel = new ScrollPane();
coursesPanel.getStyleClass().add("scrollPane");
coursesPanel.setPrefWidth(width - 118);
coursesPanel.setPrefHeight(860);
coursesPanel.setContent(coursesGridPanel);
// ---------------------------------------------------------------------------------------------------> Courses Pane End
// ---------------------------------------------------------------------------------------------> Simulations Pane Start
final WebView browser = new WebView();
final WebEngine webEngine = browser.getEngine();
browser.setPrefHeight(860);
browser.setPrefWidth(width - 208);
/*
File phetImageFile = new File("img/styleDark/poweredByPHET.png");
String phetImageURL = phetImageFile.toURI().toURL().toString();
Image phetImage = new Image(phetImageURL, false);
*/
final ImageView phetImageView = new ImageView();
final Image phetImage =
new Image(Main.class.getResourceAsStream("img/styleDark/poweredByPHET.png"));
phetImageView.setImage(phetImage);
Label motionLbl = new Label("Motion");
motionLbl.getStyleClass().add("lbl");
forcesAndMotionBtn = new Button();
forcesAndMotionBtn.getStyleClass().add("forcesAndMotionBtn");
forcesAndMotionBtn.setOnAction(
e -> {
webEngine.load(
"https://phet.colorado.edu/sims/html/balancing-act/latest/balancing-act_en.html");
simsPanel.setContent(browser);
});
balancingActBtn = new Button();
balancingActBtn.getStyleClass().add("balancingActBtn");
balancingActBtn.setOnAction(
e -> {
webEngine.load(
"https://phet.colorado.edu/sims/html/balancing-act/latest/balancing-act_en.html");
simsPanel.setContent(browser);
});
energySkateParkBtn = new Button();
energySkateParkBtn.getStyleClass().add("energySkateParkBtn");
energySkateParkBtn.setOnAction(
e -> {
webEngine.load(
"https://phet.colorado.edu/sims/html/energy-skate-park-basics/latest/"
+ "energy-skate-park-basics_en.html");
simsPanel.setContent(browser);
});
balloonsAndStaticElectricityBtn = new Button();
balloonsAndStaticElectricityBtn.getStyleClass().add("balloonsAndStaticElectricityBtn");
balloonsAndStaticElectricityBtn.setOnAction(
e -> {
webEngine.load(
"https://phet.colorado.edu/sims/html/balloons-and-static-electricity/latest/"
+ "balloons-and-static-electricity_en.html");
simsPanel.setContent(browser);
});
buildAnAtomBtn = new Button();
buildAnAtomBtn.getStyleClass().add("buildAnAtomBtn");
buildAnAtomBtn.setOnAction(
e -> {
webEngine.load(
"https://phet.colorado.edu/sims/html/build-an-atom/latest/build-an-atom_en.html");
simsPanel.setContent(browser);
});
colorVisionBtn = new Button();
colorVisionBtn.getStyleClass().add("colorVisionBtn");
colorVisionBtn.setOnAction(
e -> {
webEngine.load(
"https://phet.colorado.edu/sims/html/color-vision/latest/color-vision_en.html");
simsPanel.setContent(browser);
});
Label soundAndWavesLbl = new Label("Sound and Waves");
soundAndWavesLbl.getStyleClass().add("lbl");
wavesOnAStringBtn = new Button();
wavesOnAStringBtn.getStyleClass().add("wavesOnAStringBtn");
wavesOnAStringBtn.setOnAction(
e -> {
webEngine.load(
"https://phet.colorado.edu/sims/html/wave-on-a-string/latest/wave-on-a-string_en.html");
simsPanel.setContent(browser);
});
/*
motionSimsFlowPane = new FlowPane();
motionSimsFlowPane.getStyleClass().add("flowPane");
motionSimsFlowPane.setVgap(5);
motionSimsFlowPane.setHgap(5);
motionSimsFlowPane.setAlignment(Pos.TOP_LEFT);
motionSimsFlowPane.getChildren().addAll(forcesAndMotionBtn, balancingActBtn, energySkateParkBtn,
buildAnAtomBtn, colorVisionBtn, wavesOnAStringBtn);
soundAndWavesFlowPane = new FlowPane();
soundAndWavesFlowPane.getStyleClass().add("flowPane");
soundAndWavesFlowPane.setVgap(5);
soundAndWavesFlowPane.setHgap(5);
soundAndWavesFlowPane.setAlignment(Pos.TOP_LEFT);
soundAndWavesFlowPane.getChildren().addAll(wavesOnAStringBtn);
simsBox = new VBox();
simsBox.getStyleClass().add("vbox");
simsBox.setPrefHeight(height);
simsBox.setPrefWidth(width);
simsBox.getChildren().addAll(motionLbl, motionSimsFlowPane, soundAndWavesLbl, soundAndWavesFlowPane);
*/
simsGridPanel = new GridPane();
simsGridPanel.getStyleClass().add("gridPane");
simsGridPanel.setVgap(5);
simsGridPanel.setHgap(5);
simsGridPanel.setGridLinesVisible(false);
simsGridPanel.setPrefWidth(width - 208);
simsGridPanel.setPrefHeight(860);
simsGridPanel.setRowIndex(phetImageView, 0);
simsGridPanel.setColumnIndex(phetImageView, 4);
simsGridPanel.setRowIndex(motionLbl, 0);
simsGridPanel.setColumnIndex(motionLbl, 0);
simsGridPanel.setRowIndex(forcesAndMotionBtn, 1);
simsGridPanel.setColumnIndex(forcesAndMotionBtn, 0);
simsGridPanel.setRowIndex(balancingActBtn, 1);
simsGridPanel.setColumnIndex(balancingActBtn, 1);
simsGridPanel.setRowIndex(energySkateParkBtn, 1);
simsGridPanel.setColumnIndex(energySkateParkBtn, 2);
simsGridPanel.setRowIndex(buildAnAtomBtn, 1);
simsGridPanel.setColumnIndex(buildAnAtomBtn, 3);
simsGridPanel.setRowIndex(colorVisionBtn, 1);
simsGridPanel.setColumnIndex(colorVisionBtn, 4);
simsGridPanel.setRowIndex(soundAndWavesLbl, 2);
simsGridPanel.setColumnIndex(soundAndWavesLbl, 0);
simsGridPanel.setColumnSpan(soundAndWavesLbl, 4);
simsGridPanel.setRowIndex(wavesOnAStringBtn, 3);
simsGridPanel.setColumnIndex(wavesOnAStringBtn, 0);
simsGridPanel
.getChildren()
.addAll(
phetImageView,
motionLbl,
forcesAndMotionBtn,
balancingActBtn,
energySkateParkBtn,
buildAnAtomBtn,
colorVisionBtn,
soundAndWavesLbl,
wavesOnAStringBtn);
simsPanel = new ScrollPane();
simsPanel.getStyleClass().add("scrollPane");
simsPanel.setContent(simsGridPanel);
// -----------------------------------------------------------------------------------------------> Simulations Pane End
// ---------------------------------------------------------------------------------------------> Text Editor Pane Start
htmlEditor = new HTMLEditor();
htmlEditor.setPrefHeight(860);
htmlEditor.setPrefWidth(width - 208);
// Prevents Scroll on Space Pressed
htmlEditor.addEventFilter(
KeyEvent.KEY_PRESSED,
new EventHandler<KeyEvent>() {
@Override
public void handle(KeyEvent event) {
if (event.getEventType() == KeyEvent.KEY_PRESSED) {
if (event.getCode() == KeyCode.SPACE) {
event.consume();
}
}
}
});
XWPFDocument document = new XWPFDocument();
XWPFParagraph tmpParagraph = document.createParagraph();
XWPFRun tmpRun = tmpParagraph.createRun();
saveDocBtn = new Button();
saveDocBtn.getStyleClass().add("btn");
saveDocBtn.setText("Save");
saveDocBtn.setOnAction(
e -> {
tmpRun.setText(tools.stripHTMLTags(htmlEditor.getHtmlText()));
tmpRun.setFontSize(12);
saveDocument(document, primaryStage);
});
textEditorPanel = new ScrollPane();
textEditorPanel.getStyleClass().add("scrollPane");
textEditorPanel.setContent(htmlEditor);
// -----------------------------------------------------------------------------------------------> Text Editor Pane End
// -------------------------------------------------------------------------------------------------> Wolfram Pane Start
Boolean wolframActive = false;
try {
final WebView wolframWeb = new WebView();
wolframWeb.getStyleClass().add("webView");
final WebEngine wolframWebEngine = wolframWeb.getEngine();
wolframWeb.setPrefHeight(860);
wolframWeb.setPrefWidth(width - 208);
if (wolframActive == false) {
wolframWebEngine.load("http://www.wolframalpha.com/");
wolframActive = true;
}
wolframPanel = new ScrollPane();
wolframPanel.setContent(wolframWeb);
} catch (Exception excep) {
System.out.println("<----- Exception in Wolfram Alpha Web ----->");
excep.printStackTrace();
System.out.println("<---------->\n");
}
// ---------------------------------------------------------------------------------------------------> Wolfram Pane End
// ------------------------------------------------------------------------------------------------> Wikipedia Pane Start
Boolean wikipediaActive = false;
try {
final WebView wikipediaWeb = new WebView();
wikipediaWeb.getStyleClass().add("scrollPane");
wikipediaWebEngine = wikipediaWeb.getEngine();
wikipediaWeb.setPrefHeight(860);
wikipediaWeb.setPrefWidth(width - 208);
if (wikipediaActive == false) {
wikipediaWebEngine.load("https://en.wikipedia.org/wiki/Main_Page");
wikipediaActive = true;
}
wikipediaPanel = new ScrollPane();
wikipediaPanel.setContent(wikipediaWeb);
} catch (Exception e) {
e.printStackTrace();
}
// --------------------------------------------------------------------------------------------------> Wikipedia Pane End
// -------------------------------------------------------------------------------------------------> Settings Pane Start
settingsGridPanel = new GridPane();
settingsGridPanel.getStyleClass().add("gridPane");
settingsGridPanel.setPrefWidth(width - 208);
settingsGridPanel.setPrefHeight(height);
settingsGridPanel.setVgap(5);
settingsGridPanel.setHgap(5);
settingsPanel = new ScrollPane();
settingsPanel.getStyleClass().add("scrollPane");
settingsPanel.setContent(settingsGridPanel);
// ---------------------------------------------------------------------------------------------------> Settings Pane End
rootPane = new BorderPane();
rootPane.setLeft(leftPanel);
rootPane.setTop(topPanel);
rootPane.setCenter(dashBoardBase);
rootPane.getStyleClass().add("rootPane");
rootPane.getStylesheets().add(Main.class.getResource("css/styleDark.css").toExternalForm());
programWidth = primaryStage.getWidth();
programHeight = primaryStage.getHeight();
primaryStage.setTitle("ALE");
primaryStage.initStyle(StageStyle.UNDECORATED);
primaryStage
.getIcons()
.add(new javafx.scene.image.Image(Main.class.getResourceAsStream("img/aleIcon.png")));
primaryStage.setScene(new Scene(rootPane, width, height));
primaryStage.show();
}
private Pane createChartsPane(double spacing) {
final DateFormat dateFormat =
DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.MEDIUM);
final XYChart.Series<String, Number> mpsSeries = new XYChart.Series<>();
mpsSeries.setName("Flow Speed");
final XYChart.Series<String, Number> rpsSeries = new XYChart.Series<>();
rpsSeries.setName("Sensor Speed");
KeyFrame chartUpdateFrame =
new KeyFrame(
Duration.seconds(5),
new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent t) {
if (orca.isRunning()) {
ORCABuffer.Capture rpsCapture =
buffer
.getRotationsPerSecondBuffer()
.get(buffer.getRotationsPerSecondBuffer().size() - 1);
rpsSeries
.getData()
.add(
new XYChart.Data<String, Number>(
dateFormat.format(rpsCapture.getCaptureDate().getTime()),
rpsCapture.getData()));
ORCABuffer.Capture mpsCapture =
buffer
.getMetersPerSecondBuffer()
.get(buffer.getMetersPerSecondBuffer().size() - 1);
mpsSeries
.getData()
.add(
new XYChart.Data<String, Number>(
dateFormat.format(mpsCapture.getCaptureDate().getTime()),
mpsCapture.getData()));
}
}
});
Timeline chartUpdate = new Timeline(chartUpdateFrame);
chartUpdate.setCycleCount(Timeline.INDEFINITE);
chartUpdate.play();
LineChart<String, Number> mpsChart =
new LineChart(
CategoryAxisBuilder.create().label("Date").build(),
NumberAxisBuilder.create().label("Meters Per Second").build());
mpsChart.setTitle("Flow Speed");
mpsChart.getData().add(mpsSeries);
LineChart<String, Number> rpsChart =
new LineChart(
CategoryAxisBuilder.create().label("Date").build(),
NumberAxisBuilder.create().label("Rotations Per Sectond").build());
rpsChart.setTitle("Sensor Speed");
rpsChart.getData().add(rpsSeries);
VBox charts = new VBox(spacing);
charts.getChildren().addAll(mpsChart, rpsChart);
return charts;
}
public void addToChart(LineChart<Number, Number> chart) {
chart.getData().add(getSerie());
}
private void add_line_to_chart(
LineChart<Number, Number> lineChart, String file_path, String name, int num, int ir) {
XYChart.Series<Number, Number> series = new XYChart.Series<Number, Number>();
series.setName(name);
try {
BufferedReader reader = new BufferedReader(new FileReader(file_path));
System.out.println("\n * parsing input file");
// nodi, IR, CPU, THR mRT p95RT
// line format : 3; 80000; 91.701; 79753.125; 5.8; 16.0;
// n token : 0 1 2 3 4 5
int time = 0;
String line = reader.readLine();
while (line != null) {
StringTokenizer st = new StringTokenizer(line, ";");
st.nextToken();
int inputrate = Integer.parseInt(st.nextToken());
if (inputrate == ir) {
double cpu = Double.parseDouble(st.nextToken());
series.getData().add(new XYChart.Data<Number, Number>(time, cpu));
time = time + 15;
}
line = reader.readLine();
}
reader.close();
lineChart.getData().add(series);
System.out.println(" * new line inserted");
} catch (IOException e) {
System.err.println("Error in opening|writing|closing the file: " + file_path);
e.printStackTrace();
}
XYChart.Series<Number, Number> seriesnodi = new XYChart.Series<Number, Number>();
seriesnodi.setName("number of nodes");
try {
BufferedReader reader = new BufferedReader(new FileReader(file_path));
System.out.println("\n * parsing input file");
// nodi, IR, CPU, THR mRT p95RT
// line format : 3; 80000; 91.701; 79753.125; 5.8; 16.0;
// n token : 0 1 2 3 4 5
int time = 0;
String line = reader.readLine();
while (line != null) {
StringTokenizer st = new StringTokenizer(line, ";");
int nodi = Integer.parseInt(st.nextToken());
int inputrate = Integer.parseInt(st.nextToken());
if (inputrate == ir) {
seriesnodi.getData().add(new XYChart.Data<Number, Number>(time, nodi * 8));
time = time + 15;
}
line = reader.readLine();
}
reader.close();
lineChart.getData().add(seriesnodi);
System.out.println(" * new line inserted");
} catch (IOException e) {
System.err.println("Error in opening|writing|closing the file: " + file_path);
e.printStackTrace();
}
}
static LineChart<String, Number> initializeChart(
String title, boolean showPercentages, VBox container) {
final CategoryAxis xAxis = new CategoryAxis();
final NumberAxis yAxis = new NumberAxis();
if (showPercentages) {
yAxis.setLabel("%");
} else {
yAxis.setLabel("€");
}
yAxis.setForceZeroInRange(false);
yAxis.setSide(Side.RIGHT);
final LineChart<String, Number> lineChart = new LineChart<>(xAxis, yAxis);
lineChart.setPrefHeight(700);
lineChart.setTitle(title);
lineChart.setTitleSide(Side.LEFT);
lineChart.setCreateSymbols(false);
lineChart.setVerticalGridLinesVisible(false);
lineChart.setHorizontalGridLinesVisible(true);
XYChart.Series seriesMax = new XYChart.Series();
XYChart.Series seriesMin = new XYChart.Series();
XYChart.Series seriesAverage = new XYChart.Series();
lineChart.getData().addAll(seriesMax, seriesMin, seriesAverage);
lineChart.setLegendVisible(true);
lineChart.setLegendSide(Side.RIGHT);
container.getChildren().add(lineChart);
lineChart.getStylesheets().add("charts.css");
return lineChart;
}
protected TabbedInspector buildInspector() {
// create the network
network = new ExchangeNetwork(getGoodType());
// if there is no GUI, forget about it
Preconditions.checkState(MacroII.hasGUI()); // can't be called otherwise!
TabbedInspector toReturn = new TabbedInspector(true);
toReturn.setName(toString() + " inspector");
/**
* ******************************************* Prices ******************************************
*/
// switching to JavaFX for fun and profit
// set up the chart
panel = new JFXPanel();
NumberAxis xAxis = new NumberAxis();
NumberAxis yAxis = new NumberAxis();
xAxis.setLabel("Day");
yAxis.setLabel("Price");
final LineChart<Number, Number> priceChart = new LineChart<>(xAxis, yAxis);
priceChart.setAnimated(true);
// set up the series
priceSeries = new XYChart.Series<>();
priceSeries.setName("LastClosingPrice");
// now make the price update whenever data updates!
// use steppable to update
priceChart.getData().add(priceSeries);
Platform.runLater(
new Runnable() {
@Override
public void run() {
panel.setScene(new Scene(priceChart));
}
});
// we are going to add the new JPanel IN the new inspector
closingPriceInspector =
new Inspector() {
@Override
public void updateInspector() {
SwingUtilities.invokeLater(
new Runnable() {
public void run() {
repaint();
}
});
}
};
closingPriceInspector.setVolatile(true);
closingPriceInspector.setLayout(new BorderLayout()); // this centers it
closingPriceInspector.add(panel);
toReturn.addInspector(closingPriceInspector, "Closing price");
/**
* ******************************************* VOLUME ******************************************
*/
// switching to JavaFX for fun and profit
// set up the chart
final JFXPanel panel2 = new JFXPanel();
xAxis = new NumberAxis();
yAxis = new NumberAxis();
xAxis.setLabel("Day");
yAxis.setLabel("Volume");
final LineChart<Number, Number> volumeChart = new LineChart<>(xAxis, yAxis);
volumeChart.setAnimated(true);
volumeChart.setCreateSymbols(false);
// set up the series
volumeSeries = new XYChart.Series<Number, Number>();
volumeSeries.setName("Daily Volume Traded");
volumeChart.getData().add(volumeSeries);
Platform.runLater(
new Runnable() {
@Override
public void run() {
panel2.setScene(new Scene(volumeChart));
}
});
// we are going to add the new JPanel IN the new inspector
Inspector closingVolumeInspector =
new Inspector() {
@Override
public void updateInspector() {
SwingUtilities.invokeLater(
new Runnable() {
public void run() {
repaint();
}
});
}
};
closingVolumeInspector.setVolatile(true);
closingVolumeInspector.setLayout(new BorderLayout()); // this centers it
closingVolumeInspector.add(panel2);
toReturn.addInspector(closingVolumeInspector, "Volume");
/**
* ******************************************* TIMELINE
* ******************************************
*/
// todo logtodo
/**
* ************************************************* Network
* *************************************************
*/
Inspector networkInspector =
new Inspector() {
@Override
public void updateInspector() {
SwingUtilities.invokeLater(
new Runnable() {
public void run() {
repaint();
}
});
}
};
networkInspector.setLayout(new BorderLayout());
// add the visualization
networkInspector.add(network.getVisualization());
toReturn.addInspector(networkInspector, "Network");
return toReturn;
}
protected PropertySheet createPropertySheet() {
final LineChart<Number, Number> lc = (LineChart<Number, Number>) getChildren().get(0);
final NumberAxis xAxis = (NumberAxis) lc.getXAxis();
final NumberAxis yAxis = (NumberAxis) lc.getYAxis();
// create actions
EventHandler<ActionEvent> addDataItem =
new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent actionEvent) {
if (lc.getData() == null) {
lc.setData(
FXCollections.observableArrayList(
new Series<Number, Number>(
FXCollections.observableArrayList(
new XYChart.Data<Number, Number>(
Math.random() * 1000, Math.random() * 1000)))));
} else if (lc.getData().isEmpty()) {
lc.getData()
.add(
new Series<Number, Number>(
FXCollections.observableArrayList(
new XYChart.Data<Number, Number>(
Math.random() * 1000, Math.random() * 1000))));
} else {
Series<Number, Number> s =
lc.getData().get((int) (Math.random() * lc.getData().size()));
if (s != null)
s.getData()
.add(
new LineChart.Data<Number, Number>(
Math.random() * 1000, Math.random() * 1000));
}
}
};
EventHandler<ActionEvent> insertDataItem =
new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent actionEvent) {
if (lc.getData() != null && !lc.getData().isEmpty()) {
Series<Number, Number> s =
lc.getData().get((int) (Math.random() * lc.getData().size()));
if (s != null)
s.getData()
.add(
(int) (s.getData().size() * Math.random()),
new LineChart.Data<Number, Number>(
Math.random() * 1000, Math.random() * 1000));
}
}
};
EventHandler<ActionEvent> addDataItemNegative =
new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent actionEvent) {
if (lc.getData() == null) {
lc.setData(
FXCollections.observableArrayList(
new Series<Number, Number>(
FXCollections.observableArrayList(
new XYChart.Data<Number, Number>(
Math.random() * -200, Math.random() * -200)))));
} else if (lc.getData().isEmpty()) {
lc.getData()
.add(
new Series<Number, Number>(
FXCollections.observableArrayList(
new XYChart.Data<Number, Number>(
Math.random() * -200, Math.random() * -200))));
} else {
Series<Number, Number> s =
lc.getData().get((int) (Math.random() * lc.getData().size()));
if (s != null)
s.getData()
.add(
new LineChart.Data<Number, Number>(
Math.random() * -200, Math.random() * -200));
}
}
};
EventHandler<ActionEvent> deleteDataItem =
new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent actionEvent) {
ChartActions.deleteDataItem(lc);
}
};
EventHandler<ActionEvent> changeDataItem =
new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent actionEvent) {
if (lc.getData() != null && !lc.getData().isEmpty()) {
Series<Number, Number> s =
lc.getData().get((int) (Math.random() * (lc.getData().size())));
if (s != null && !s.getData().isEmpty()) {
XYChart.Data<Number, Number> d =
s.getData().get((int) (Math.random() * (s.getData().size())));
if (d != null) {
d.setXValue(d.getXValue().doubleValue() + (Math.random() * 50) - 25);
d.setYValue(Math.random() * 1000);
}
}
}
}
};
EventHandler<ActionEvent> addSeries =
new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent actionEvent) {
if (lc.getData() == null) {
lc.setData(FXCollections.<Series<Number, Number>>observableArrayList());
}
Series<Number, Number> series = new Series<Number, Number>();
series.setName("Data Series 1");
double x = 0;
for (int i = 0; i < 10; i++) {
x += Math.random() * 100;
series.getData().add(new LineChart.Data<Number, Number>(x, Math.random() * 800));
}
if (lc.getData() == null)
lc.setData(FXCollections.<Series<Number, Number>>observableArrayList());
lc.getData().add(series);
}
};
EventHandler<ActionEvent> deleteSeries =
new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent actionEvent) {
if (lc.getData() != null && !lc.getData().isEmpty()) {
lc.getData().remove((int) (Math.random() * lc.getData().size()));
}
}
};
EventHandler<ActionEvent> animateData =
new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent actionEvent) {
if (lc.getData() == null) {
return;
}
Timeline tl = new Timeline();
tl.getKeyFrames()
.add(
new KeyFrame(
Duration.millis(500),
new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent actionEvent) {
for (Series<Number, Number> series : lc.getData()) {
for (XYChart.Data<Number, Number> data : series.getData()) {
data.setXValue(Math.random() * 1000);
data.setYValue(Math.random() * 1000);
}
}
}
}));
tl.setCycleCount(30);
tl.play();
}
};
EventHandler<ActionEvent> animateDataFast =
new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent actionEvent) {
if (lc.getData() == null) {
return;
}
lc.setAnimated(false);
Timeline tl = new Timeline();
tl.getKeyFrames()
.add(
new KeyFrame(
Duration.millis(50),
new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent actionEvent) {
for (Series<Number, Number> series : lc.getData()) {
for (XYChart.Data<Number, Number> data : series.getData()) {
data.setXValue(-500 + Math.random() * 1000);
data.setYValue(-500 + Math.random() * 1000);
}
}
}
}));
tl.setOnFinished(
new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent actionEvent) {
lc.setAnimated(true);
}
});
tl.setCycleCount(100);
tl.play();
}
};
EventHandler<ActionEvent> removeAllData =
new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent actionEvent) {
lc.setData(null);
}
};
EventHandler<ActionEvent> setNewData =
new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent actionEvent) {
ObservableList<Series<Number, Number>> data = FXCollections.observableArrayList();
for (int j = 0; j < 5; j++) {
Series<Number, Number> series = new Series<Number, Number>();
series.setName("Data Series " + j);
double x = 0;
for (int i = 0; i < 10; i++) {
x += Math.random() * 100;
series.getData().add(new LineChart.Data<Number, Number>(x, Math.random() * 800));
}
data.add(series);
}
lc.setData(data);
}
};
// Create X/Y side overriding values to filter out unhelpful values
List<Enum> xValidSides = new ArrayList();
xValidSides.add(Side.BOTTOM);
xValidSides.add(Side.TOP);
List<Enum> yValidSides = new ArrayList();
yValidSides.add(Side.LEFT);
yValidSides.add(Side.RIGHT);
// create property editor
return new PropertySheet(
new PropertySheet.PropertyGroup(
"Actions",
PropertySheet.createProperty("Add Data Item", addDataItem),
PropertySheet.createProperty("Insert Data Item", insertDataItem),
PropertySheet.createProperty("Add Data Item Negative", addDataItemNegative),
PropertySheet.createProperty("Delete Data Item", deleteDataItem),
PropertySheet.createProperty("Change Data Item", changeDataItem),
PropertySheet.createProperty("Add Series", addSeries),
PropertySheet.createProperty("Delete Series", deleteSeries),
PropertySheet.createProperty("Remove All Data", removeAllData),
PropertySheet.createProperty("Set New Data", setNewData)),
new PropertySheet.PropertyGroup(
"Chart Properties",
PropertySheet.createProperty("Title", lc.titleProperty()),
PropertySheet.createProperty("Title Side", lc.titleSideProperty()),
PropertySheet.createProperty("Legend Side", lc.legendSideProperty())),
new PropertySheet.PropertyGroup(
"XY Chart Properties",
PropertySheet.createProperty(
"Vertical Grid Line Visible", lc.verticalGridLinesVisibleProperty()),
PropertySheet.createProperty(
"Horizontal Grid Line Visible", lc.horizontalGridLinesVisibleProperty()),
PropertySheet.createProperty(
"Alternative Column Fill Visible", lc.alternativeColumnFillVisibleProperty()),
PropertySheet.createProperty(
"Alternative Row Fill Visible", lc.alternativeRowFillVisibleProperty()),
PropertySheet.createProperty(
"Vertical Zero Line Visible", lc.verticalZeroLineVisibleProperty()),
PropertySheet.createProperty(
"Horizontal Zero Line Visible", lc.horizontalZeroLineVisibleProperty()),
PropertySheet.createProperty("Animated", lc.animatedProperty())),
new PropertySheet.PropertyGroup(
"Line Chart Properties",
PropertySheet.createProperty("Create Symbols", lc.createSymbolsProperty())),
new PropertySheet.PropertyGroup(
"X Axis Properties",
PropertySheet.createProperty("Side", xAxis.sideProperty(), xValidSides),
PropertySheet.createProperty("Label", xAxis.labelProperty()),
PropertySheet.createProperty("Tick Mark Length", xAxis.tickLengthProperty()),
PropertySheet.createProperty("Auto Ranging", xAxis.autoRangingProperty()),
PropertySheet.createProperty("Tick Label Font", xAxis.tickLabelFontProperty()),
PropertySheet.createProperty("Tick Label Fill", xAxis.tickLabelFillProperty()),
PropertySheet.createProperty("Tick Label Gap", xAxis.tickLabelGapProperty()),
// Value Axis Props
// PropertySheet.createProperty("Scale",xAxis.scaleProperty(), true),
PropertySheet.createProperty("Lower Bound", xAxis.lowerBoundProperty(), true),
PropertySheet.createProperty("Upper Bound", xAxis.upperBoundProperty(), true),
PropertySheet.createProperty(
"Tick Label Formatter", xAxis.tickLabelFormatterProperty()),
PropertySheet.createProperty("Minor Tick Length", xAxis.minorTickLengthProperty()),
PropertySheet.createProperty("Minor Tick Count", xAxis.minorTickCountProperty()),
// Number Axis Properties
PropertySheet.createProperty("Force Zero In Range", xAxis.forceZeroInRangeProperty()),
PropertySheet.createProperty("Tick Unit", xAxis.tickUnitProperty())),
new PropertySheet.PropertyGroup(
"Y Axis Properties",
PropertySheet.createProperty("Side", yAxis.sideProperty(), yValidSides),
PropertySheet.createProperty("Label", yAxis.labelProperty()),
PropertySheet.createProperty("Tick Mark Length", yAxis.tickLengthProperty()),
PropertySheet.createProperty("Auto Ranging", yAxis.autoRangingProperty()),
PropertySheet.createProperty("Tick Label Font", yAxis.tickLabelFontProperty()),
PropertySheet.createProperty("Tick Label Fill", yAxis.tickLabelFillProperty()),
PropertySheet.createProperty("Tick Label Gap", yAxis.tickLabelGapProperty()),
// Value Axis Props
// PropertySheet.createProperty("Scale",yAxis.scaleProperty(), true),
PropertySheet.createProperty("Lower Bound", yAxis.lowerBoundProperty(), true),
PropertySheet.createProperty("Upper Bound", yAxis.upperBoundProperty(), true),
PropertySheet.createProperty(
"Tick Label Formatter", yAxis.tickLabelFormatterProperty()),
PropertySheet.createProperty("Minor Tick Length", yAxis.minorTickLengthProperty()),
PropertySheet.createProperty("Minor Tick Count", yAxis.minorTickCountProperty()),
// Number Axis Properties
PropertySheet.createProperty("Force Zero In Range", yAxis.forceZeroInRangeProperty()),
PropertySheet.createProperty("Tick Unit", yAxis.tickUnitProperty())));
}
@SuppressWarnings("unchecked")
private void removeSeries(XYChart.Series<Number, Number> series) {
lineChart.getData().removeAll(series);
}
