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);
  }
  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);
    }
  }
예제 #3
0
  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;
  }
  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);
  }
  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);
  }
예제 #6
0
  /**
   * 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);
        });
  }
예제 #8
0
  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;
 }
  /**
   * 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();
  }
예제 #12
0
파일: Main.java 프로젝트: 8CAKE/ALE
  @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();
  }
예제 #13
0
 public void addToChart(LineChart<Number, Number> chart) {
   chart.getData().add(getSerie());
 }
예제 #14
0
  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;
  }
  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();
    }
  }
예제 #16
0
  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;
  }
 @SuppressWarnings("unchecked")
 private void removeSeries(XYChart.Series<Number, Number> series) {
   lineChart.getData().removeAll(series);
 }