@Override
  protected ObservableList<Wordnet> call() throws Exception {

    // using executorService to ensure that database upload is a background
    // progress, so that all the parsing and comparing is done, while
    // database upload is probably still running. only supposed to run one
    // uploading process at a time, the
    // rest is in queue.
    ExecutorService executor =
        new ThreadPoolExecutor(
            1, 1, 10, TimeUnit.HOURS, new ArrayBlockingQueue<Runnable>(inList.size(), true));

    for (int i = 0; i < inList.size(); i++) {

      WordnetParser rspParser = chosenParser.getClass().newInstance();
      rspParser.setSourcePath(inList.get(i).getAbsolutePath());

      Wordnet wordnet = rspParser.callCall();
      // System.out.println(getProgress() + (1.0 / (double)
      // inList.size()) + " / " + "1" + "\n");
      // updateProgress(1/i, 1); //TODO reimplement progressbar
      // Platform.runLater(new Runnable() {
      //
      // @Override
      // public void run() {
      partialResults.get().add(wordnet);

      if (exportXml)
        Output.outToFileXmlFile(
            wordnet.getSynsetList(),
            wordnet.getLang(),
            "D:\\Programmierung\\git repo\\wdntxml\\out");

      if (outData) {
        // add database-upload-process to executorService
        executor.submit(
            new Runnable() {

              @Override
              public void run() {

                try {
                  Output.outToDB(
                      wordnet, dbUrl, dbUser, dbPassword, dbPort, sshUser, sshPassword, sshPort);
                  progress++;
                  updateProgress(((double) progress) / ((double) maxProgress), 1);

                } catch (ClassNotFoundException e) {
                  // TODO Auto-generated catch block
                  e.printStackTrace();
                } catch (SQLException e) {
                  // TODO Auto-generated catch block
                  e.printStackTrace();
                }
              }
            });
      }
    }
    return getPartialResults();
  }
Esempio n. 2
0
  // wyœwietla wszystkie albumy
  private void drawAlbums() {
    for (int i = 0; i < albumList.size(); i++) {
      VBox vBox = new VBox(5);

      // ok³adka albumu
      Song tempSong = new Song(albumList.get(i).albumSongList.get(0));
      ImageView albumCover = new ImageView(tempSong.getAlbumCover());
      albumCover.setFitWidth(130);
      albumCover.setPreserveRatio(true);
      albumCover.setSmooth(true);
      albumCover.imageProperty().bind(tempSong.albumCoverProperty());

      // tytu³ albumu
      Text albumTitle = new Text(albumList.get(i).getAlbumTitle());
      albumTitle.getStyleClass().add("text");
      vBox.getChildren().addAll(albumCover, albumTitle);
      vBox.setAlignment(Pos.CENTER);

      // dodaje do ka¿dego albumu listener którym otwiera listê z piosenkami
      vBox.setOnMouseClicked(
          e -> {
            Text tempText = (Text) vBox.getChildren().get(1);
            for (int j = 0; j < albumList.size(); j++) {
              if (albumList.get(j).getAlbumTitle().equals(tempText.getText())) {
                showCurrentAlbum(albumList.get(j));
                break;
              }
            }
          });

      flowPane.getChildren().add(vBox);
    }
  }
Esempio n. 3
0
  private final void defineStretching() {
    //////////// give resizing hints
    ObservableList<RowConstraints> rows = getRowConstraints();
    logger.info("original row constraints size" + rows.size());

    RowConstraints rc;

    rc = new RowConstraints();
    // rc.setPercentHeight( 0 );
    rc.setVgrow(Priority.NEVER);
    rc.setMinHeight(StaticConst.GU);
    rows.add(rc);
    rc = new RowConstraints();
    // rc.setPercentHeight( 100 );
    rc.setVgrow(Priority.ALWAYS);
    rows.add(rc);
    rc = new RowConstraints();
    // rc.setPercentHeight( 0 );
    rc.setVgrow(Priority.NEVER);
    rows.add(rc);

    ObservableList<ColumnConstraints> ccs = getColumnConstraints();
    logger.info("original column constraints size" + ccs.size());
    ColumnConstraints cc;

    cc = new ColumnConstraints();
    cc.setHgrow(Priority.ALWAYS);
    ccs.add(cc);
  }
  private void setupStageLocation(Stage stage) {
    ObservableList<Screen> screens = Screen.getScreens();
    Screen screen =
        screens.size() <= screenNumber ? Screen.getPrimary() : screens.get(screenNumber);

    Rectangle2D bounds = screen.getBounds();
    boolean primary =
        screen.equals(
            Screen.getPrimary()); // WORKAROUND: this doesn't work nice in combination with full
    // screen, so this hack is used to prevent going fullscreen when
    // screen is not primary

    if (primary) {
      stage.setX(bounds.getMinX());
      stage.setY(bounds.getMinY());
      stage.setWidth(bounds.getWidth());
      stage.setHeight(bounds.getHeight());
      stage.setFullScreen(true);
    } else {
      stage.setX(bounds.getMinX());
      stage.setY(bounds.getMinY());
      stage.setWidth(bounds.getWidth());
      stage.setHeight(bounds.getHeight());
      stage.toFront();
    }
  }
  public static boolean writeFile(ObservableList<XYChart.Data> list, String path)
      throws FileNotFoundException {
    try {
      boolean newFile = false;
      File file = new File(path);
      System.out.println(file.exists());
      newFile = file.createNewFile();
      System.out.println(newFile);
      System.out.println(file.exists());
      PrintWriter printWriter;
      try {
        printWriter = new PrintWriter(new FileOutputStream(file));

        for (int i = 0; i < list.size(); i++) {
          String x = list.get(i).getXValue().toString();
          String y = list.get(i).getYValue().toString();
          String line = x + "\t" + y;
          printWriter.println(line);
        }
        printWriter.close();
      } catch (Exception ex) {
        return false;
      }
    } catch (IOException ex) {
      return false;
    }

    return true;
  }
 /** Sanity? Removing last child throws IOOB if selected */
 @Test
 public void testSelectedRemoveLast() {
   int lastIndex = rawItems.size() - 1;
   TreeItem lastChild = (TreeItem) getRootChildren().get(lastIndex);
   getSelectionModel().select(lastChild);
   getRootChildren().remove(lastChild);
 }
 @FXML
 public void ok() {
   ObservableList<UITableColumnVO> items = columnListView.getItems();
   if (items != null && items.size() > 0) {
     List<IgnoredColumn> ignoredColumns = new ArrayList<>();
     List<ColumnOverride> columnOverrides = new ArrayList<>();
     items
         .stream()
         .forEach(
             item -> {
               if (!item.getChecked()) {
                 IgnoredColumn ignoredColumn = new IgnoredColumn(item.getColumnName());
                 ignoredColumns.add(ignoredColumn);
               } else if (item.getTypeHandle() != null
                   || item.getJavaType() != null
                   || item.getPropertyName() != null) { // unchecked and have typeHandler value
                 ColumnOverride columnOverride = new ColumnOverride(item.getColumnName());
                 columnOverride.setTypeHandler(item.getTypeHandle());
                 columnOverride.setJavaProperty(item.getPropertyName());
                 columnOverride.setJavaType(item.getJavaType());
                 columnOverrides.add(columnOverride);
               }
             });
     mainUIController.setIgnoredColumns(ignoredColumns);
     mainUIController.setColumnOverrides(columnOverrides);
   }
   getDialogStage().close();
 }
Esempio n. 8
0
  // wyœwietla wszystkie playlisty
  private void drawPlaylists() {
    for (int i = 0; i < playlistList.size(); i++) {
      VBox vBox = new VBox(5);

      ImageView playlistCover =
          new ImageView(new Image(new File("temp_cover.png").toURI().toString()));
      playlistCover.setFitWidth(130);
      playlistCover.setPreserveRatio(true);
      playlistCover.setSmooth(true);

      int ext = playlistList.get(i).getName().lastIndexOf('.');
      Text playlistTitle = new Text(playlistList.get(i).getName().substring(0, ext));
      playlistTitle.getStyleClass().add("text");
      vBox.getChildren().addAll(playlistCover, playlistTitle);
      vBox.setAlignment(Pos.CENTER);

      vBox.setOnMouseClicked(
          e -> {
            Text tempText = (Text) vBox.getChildren().get(1);
            showCurrentPlaylist(new File("Playlists/" + tempText.getText() + ".fpl"));
          });

      flowPane.getChildren().add(vBox);
    }
  }
Esempio n. 9
0
  @Override
  public Music getMusic(int nr) {
    if (nr < 0 || nr >= music.size()) {
      return null;
    }

    return music.get(nr);
  }
Esempio n. 10
0
 // ******************** Misc **********************************************
 private static void calcNoOfNodes(Node node) {
   if (node instanceof Parent) {
     if (((Parent) node).getChildrenUnmodifiable().size() != 0) {
       ObservableList<Node> tempChildren = ((Parent) node).getChildrenUnmodifiable();
       noOfNodes += tempChildren.size();
       tempChildren.forEach(n -> calcNoOfNodes(n));
     }
   }
 }
  @Test
  public void getNext3() throws Exception {

    ObservableList<Appointment> appointments = AppointmentHelper.getNextAppointments(3);

    assertEquals(3, appointments.size());

    assertEquals(a0.getId(), appointments.get(0).getId());
  }
Esempio n. 12
0
 private void detectScreen() {
     Screen screen = Screen.getPrimary();
     ObservableList<Screen> screens = Screen.getScreens();
     Integer screenId = main.getConfig().get(PainelConfig.KEY_MONITOR_ID, Integer.class).getValue();
     if (screenId > 0 && screens.size() > screenId) {
         screen = screens.get(screenId);
     }
     display = new Display(screen);
 }
 private int getIndexOfComponentInParent(Node component) {
   Parent parent = component.getParent();
   if (parent == null) return -1;
   ObservableList<Node> components = parent.getChildrenUnmodifiable();
   for (int i = 0; i < components.size(); i++) {
     if (components.get(i) == component) return i;
   }
   return -1;
 }
Esempio n. 14
0
  private void cleanUpRepeatingFramesAndValues() {
    ObservableList<KeyFrame> timelineKeyFrames =
        timeline.getKeyFrames().sorted(new KeyFrameComparator());
    //        Timeline timeline;
    int kfTotal = timelineKeyFrames.size(), kfRemoved = 0;
    int kvTotal = 0, kvRemoved = 0;
    Map<Duration, KeyFrame> kfUnique = new HashMap<>();
    Map<WritableValue, KeyValue> kvUnique = new HashMap<>();
    MapOfLists<KeyFrame, KeyFrame> duplicates = new MapOfLists<>();
    Iterator<KeyFrame> iterator = timelineKeyFrames.iterator();
    while (iterator.hasNext()) {
      KeyFrame duplicate = iterator.next();
      KeyFrame original = kfUnique.put(duplicate.getTime(), duplicate);
      if (original != null) {
        kfRemoved++;
        iterator.remove(); // removing duplicate keyFrame
        duplicates.add(original, duplicate);

        kfUnique.put(duplicate.getTime(), original);
      }
      kvUnique.clear();
      for (KeyValue kvDup : duplicate.getValues()) {
        kvTotal++;
        KeyValue kvOrig = kvUnique.put(kvDup.getTarget(), kvDup);
        if (kvOrig != null) {
          kvRemoved++;
          if (!kvOrig.getEndValue().equals(kvDup.getEndValue())
              && kvOrig.getTarget() == kvDup.getTarget()) {
            System.err.println(
                "KeyValues set different values for KeyFrame "
                    + duplicate.getTime()
                    + ":"
                    + "\n kvOrig = "
                    + kvOrig
                    + ", \nkvDup = "
                    + kvDup);
          }
        }
      }
    }
    for (KeyFrame orig : duplicates.keySet()) {
      List<KeyValue> keyValues = new ArrayList<>();
      for (KeyFrame dup : duplicates.get(orig)) {
        keyValues.addAll(dup.getValues());
      }
      timelineKeyFrames.set(
          timelineKeyFrames.indexOf(orig),
          new KeyFrame(orig.getTime(), keyValues.toArray(new KeyValue[keyValues.size()])));
    }
    System.out.printf(
        "Removed %d (%.2f%%) duplicate KeyFrames out of total %d.\n",
        kfRemoved, 100d * kfRemoved / kfTotal, kfTotal);
    System.out.printf(
        "Identified %d (%.2f%%) duplicate KeyValues out of total %d.\n",
        kvRemoved, 100d * kvRemoved / kvTotal, kvTotal);
  }
 public void deleteMarker(Waypoint point) {
   int listSize = waypointList.size();
   for (int index = 0; index < listSize; index++) {
     Waypoint current = waypointList.get(index);
     if (current.getPointNo() == point.getPointNo()) {
       waypointList.remove(index);
       break;
     }
   }
 }
Esempio n. 16
0
  /**
   * Creates a translation part of word card, it corresponds to one meaning.
   *
   * @return true if there are any translations in this translation block.
   */
  public boolean create(Connect conn, TTranslation _ttranslation, TLang _lang) {
    meaning_summary = _ttranslation.getMeaningSummary();

    TTranslationEntry[] trans_entries = TTranslationEntry.getByTranslation(conn, _ttranslation);
    // System.out.println("WCTranslation.create() _lang=" + _lang.getLanguage().toString() + ";
    // trans_entries.length=" + trans_entries);

    List<TranslationEntryItem> data_trans = new ArrayList();

    //  listview_trans.items length =" + trans_entries.length);
    trans_entry_items_size = trans_entries.length;
    // trans_entry_items = new TranslationEntryItem[trans_entries.length];
    for (int i = 0; i < trans_entries.length; i++) {
      TTranslationEntry e = trans_entries[i];

      LanguageType l = e.getLang().getLanguage();
      String lang_name_value = l.getName();
      String lang_code_value = l.getCode();
      String translation_text = e.getWikiText().getText();

      TranslationEntryItem item = new TranslationEntryItem();
      item.create(lang_name_value, lang_code_value, translation_text);
      data_trans.add(item);
    }
    //  TranslationEntryItem[] trans_entry_items = data_trans.toArray();
    // insert trans_entry_items into listview_trans.items;

    ObservableList<TranslationEntryItem> data = FXCollections.observableArrayList(data_trans);

    listview_trans.setCellFactory(
        new Callback<
            ListView<wiwordik.word_card.TranslationEntryItem>,
            ListCell<wiwordik.word_card.TranslationEntryItem>>() {
          @Override
          public ListCell<wiwordik.word_card.TranslationEntryItem> call(
              ListView<wiwordik.word_card.TranslationEntryItem> list) {
            return new wiwordik.word_card.TranslationCell();
          }
        });
    listview_trans.setItems(data);
    setMinMaxTranslationBoxHeight(listview_trans, data.size());

    // GUI                          right - indent for translation list words
    //                          top right bottom left
    group.setPadding(new Insets(0, 20, 0, 0));

    Text t_meaning_summary = new Text();
    t_meaning_summary.setText(meaning_summary);

    group.getChildren().addAll(t_meaning_summary);
    group.getChildren().addAll(listview_trans);

    return trans_entries.length > 0;
  }
Esempio n. 17
0
  // Сохранение в базу данных
  public static void setList(ObservableList<ContructorViewer> list) {
    if (list.size() == contructorsDB.size()) {
      for (int i = 0; i < list.size(); i++) {
        contructorsDB.get(i).setName(list.get(i).getName());
      }
      contructorsDB.forEach(contructor -> contrImpl.update(contructor));
    } else {
      List<Contructor> contructorsDBNEW = new ArrayList<Contructor>();
      list.forEach(
          new Consumer<ContructorViewer>() {

            @Override
            public void accept(ContructorViewer contr) {
              // TODO Auto-generated method stub
              contructorsDBNEW.add(new Contructor(contr.getName()));
            }
          });
      contructorsDB.forEach(contructor -> contrImpl.delete(contructor));
      contructorsDBNEW.forEach(contructor -> contrImpl.create(contructor));
    }
  }
 /**
  * Test notification on setAll if there are already set indices. Changed implementation due to
  * RT-39776, test assumption incorrect.
  */
 @Test
 public void testSetAllNotificationIfHasSet() {
   int[] indices = new int[] {3, 5, 1};
   indicesList.addIndices(indices);
   report.clear();
   indicesList.setAllIndices();
   //        report.prettyPrint();
   assertEquals(items.size(), indicesList.size());
   assertEquals(1, report.getEventCount());
   Change c = report.getLastChange();
   assertEquals(4, getChangeCount(c, ChangeType.ADDED));
 }
  public void addTab(Tab tab, boolean closable) {

    // new RuntimeException().printStackTrace();

    Platform.runLater(
        () -> {
          final ObservableList<Tab> tabs = getTabs();
          tab.setClosable(closable);
          int index = tabs.size() - 1;
          // new RuntimeException().printStackTrace();
          tabs.add(index, tab);
          setSelectedTab(tab);
        });
  }
 /**
  * Regression testing: SelectedItems contains null after removing unselected grandParent of
  * selectedItem https://javafx-jira.kenai.com/browse/RT-38334
  *
  * <p>This is the exact replication of the bug report: grandParent is last
  */
 @Test
 public void testSelectedItemsOnRemoveGrandParentOfSelectedItemIfLast_38334() {
   TreeItem grandParent = createBranch("grandParent", true);
   TreeItem childWithSelection = createBranch("selected", true);
   grandParent.getChildren().add(childWithSelection);
   TreeItem selected = (TreeItem) childWithSelection.getChildren().get(0);
   int lastIndex = rawItems.size() - 1;
   TreeItem oldFirst = (TreeItem) getRootChildren().get(lastIndex);
   getRootChildren().add(grandParent);
   getSelectionModel().select(selected);
   getRootChildren().remove(grandParent);
   assertEquals("sibling of removed selected", oldFirst, getSelectedItem());
   assertEquals("selectedItems contain sibling", oldFirst, getSelectedItems().get(0));
 }
Esempio n. 21
0
  private void onListChanged() {
    Log.traceCall();
    list.clear();
    list.addAll(
        tradeManager
            .getTrades()
            .stream()
            .map(PendingTradesListItem::new)
            .collect(Collectors.toList()));

    // we sort by date, earliest first
    list.sort((o1, o2) -> o2.getTrade().getDate().compareTo(o1.getTrade().getDate()));

    // TODO improve selectedItem handling
    // selectedItem does not get set to null if we dont have the view visible
    // So if the item gets removed form the list, and a new item is added we need to check if the
    // old
    // selectedItem is in the new list, if not we know it is an invalid one
    if (list.size() == 1) onSelectTrade(list.get(0));
    else if (list.size() > 1 && (selectedItem == null || !list.contains(selectedItem)))
      onSelectTrade(list.get(0));
    else if (list.size() == 0) onSelectTrade(null);
  }
Esempio n. 22
0
  // Adding functionality to the forward button
  public String goForward() {
    final WebHistory history = browser.getEngine().getHistory();
    ObservableList<WebHistory.Entry> entryList = history.getEntries();
    int currentIndex = history.getCurrentIndex();

    Platform.runLater(() -> history.go(1));
    if (currentIndex < entryList.size() - 2) {
      entryList.get(currentIndex + 1);
      forwardButton.setDisable(false);
    } else {
      entryList.get(history.getCurrentIndex());
      forwardButton.setDisable(true);
      backButton.setDisable(false);
    }
    return entryList.get(currentIndex).getUrl();
  }
 @Test
 public void testSelectedOnExpandedGrandBranchCollapsed() {
   TreeItem childBranch = createBranch("expandedChild", true);
   TreeItem grandChildBranch = createBranch("expandedGrandChild", true);
   childBranch.getChildren().add(0, grandChildBranch);
   TreeItem selected = (TreeItem) grandChildBranch.getChildren().get(rawItems.size() - 1);
   getRootChildren().add(0, childBranch);
   getSelectionModel().select(selected);
   TreeItem selectedItem = getSelectedItems().get(0);
   assertEquals(selectedItem, getSelectedItems().get(0));
   assertEquals(selectedItem, getSelectedItem());
   grandChildBranch.setExpanded(false);
   assertEquals("selected items size", 1, getSelectedItems().size());
   assertEquals(grandChildBranch, getSelectedItem());
   //        assertEquals(index, getSelectionModel().getSelectedIndex());
   //        assertEquals(index, getSelectionModel().getSelectedIndices().get(0).intValue());
 }
Esempio n. 24
0
  /** Mètode que canvia la llista que es mostra per pantalla */
  public void setData(String city, int units) {
    data.remove(1, data.size());
    File inputFile = new File(city + units + ".xml");
    try {
      DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
      DocumentBuilder db = dbf.newDocumentBuilder();
      Document doc = db.parse(inputFile);
      // És important normalitzar
      doc.getDocumentElement().normalize();

      NodeList nl = doc.getElementsByTagName("time");
      temp = new Temps();
      TempUnitari tempU = null;
      for (int i = 0; i < nl.getLength(); i++) {
        tempU = new TempUnitari();
        Element temps = (Element) nl.item(i);
        String[] horari = temps.getAttribute("day").split("-");
        String diaVista = horari[2] + "/" + horari[1];
        String descripcio =
            temps.getFirstChild().getAttributes().getNamedItem("name").getTextContent();
        String icon =
            temps.getFirstChild().getAttributes().getNamedItem("var").getTextContent() + "#";
        Element temperatura = (Element) temps.getChildNodes().item(4);
        String tempMin = temperatura.getAttribute("min");
        String tempMax = temperatura.getAttribute("max");
        Element humitat = (Element) temps.getChildNodes().item(6);
        String humidity = humitat.getAttribute("value");
        Element presio = (Element) temps.getChildNodes().item(5);
        String pressure = presio.getAttribute("value");
        tempU.setTempsMin(Double.parseDouble(tempMin));
        tempU.setTempsMax(Double.parseDouble(tempMax));
        tempU.setHumidity(Integer.parseInt(humidity));
        tempU.setPressure(Double.parseDouble(pressure));
        temp.add(tempU);
        // afegir el String al observableList per a que el mostri el listView
        data.add(icon + diaVista + "\t-\t" + descripcio + "\t-\t" + tempMin + "/" + tempMax);
      }
    } catch (ParserConfigurationException e) {
      e.printStackTrace();
    } catch (SAXException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
  protected String supportedFreq(ObservableList<? extends String> list) {

    final StringBuilder sb = new StringBuilder();

    if (list != null) {

      for (int i = 0, max = list.size(); i < max; i++) {

        sb.append(list.get(i));

        if (i < max - 1) {

          sb.append(",");
        }
      }
    }
    final String str = sb.toString();

    return str;
  }
 protected List<IJavaFXElement> found(List<IJavaFXElement> pElements, IJavaFXAgent driver) {
   List<IJavaFXElement> r = new ArrayList<IJavaFXElement>();
   for (IJavaFXElement je : pElements) {
     Node component = je.getComponent();
     if (!(component instanceof Parent)) continue;
     int index = getIndexOfComponentInParent(component);
     if (index < 0) continue;
     Parent parent = component.getParent();
     JFXWindow topContainer = driver.switchTo().getTopContainer();
     ObservableList<Node> children = parent.getChildrenUnmodifiable();
     for (int i = index + 1; i < children.size(); i++) {
       Node c = children.get(i);
       IJavaFXElement je2 =
           JavaFXElementFactory.createElement(c, driver, driver.switchTo().getTopContainer());
       if (sibling.matchesSelector(je2).size() > 0) {
         IJavaFXElement e =
             topContainer.addElement(JavaFXElementFactory.createElement(c, driver, topContainer));
         if (!r.contains(e)) r.add(e);
       }
     }
   }
   return r;
 }
Esempio n. 27
0
  @Override
  public void initialize(URL url, ResourceBundle rb) {

    Sql.loadSql();

    total.setText("$" + expenseTotal);

    name.setCellValueFactory(new PropertyValueFactory<Expense, String>("name"));
    name.setCellFactory(TextFieldTableCell.<String>forTableColumn());
    vendor.setCellValueFactory(new PropertyValueFactory<Expense, String>("vendor"));
    vendor.setCellFactory(TextFieldTableCell.<String>forTableColumn());
    date.setCellValueFactory(new PropertyValueFactory<Expense, String>("date"));
    date.setCellFactory(TextFieldTableCell.<String>forTableColumn());
    cost.setCellValueFactory(new PropertyValueFactory<Expense, Double>("cost"));
    cost.setCellFactory(
        TextFieldTableCell.forTableColumn(
            new StringConverter<Double>() {

              @Override
              public String toString(Double object) {
                return object.toString();
              }

              @Override
              public Double fromString(String string) {
                return Double.parseDouble(string);
              }
            }));

    add.setOnAction(e -> Action.addExpense());
    delete.setOnAction(e -> Action.deleteExpense());

    if (tableList.size() > 0) emptyLabel.setText("");

    table.setItems(tableList);
    pieChart.setData(pieChartList);
  }
  public static DefaultBoxAndWhiskerCategoryDataset getDatasetForBoxAndWhiskers(
      ObservableList<EvaluationHelper> allEvaluationHelper, ArrayList<Bereich> bereiche) {

    int categoryCount = bereiche.size();
    int entityCount = allEvaluationHelper.size();

    final DefaultBoxAndWhiskerCategoryDataset dataset = new DefaultBoxAndWhiskerCategoryDataset();

    for (int j = 0; j < categoryCount; j++) {
      final List<Double> list = new ArrayList<Double>();
      for (int k = 0; k < entityCount; k++) {

        int valCount = 0;
        double avValue = 0;

        for (Item item : allEvaluationHelper.get(k).getItems()) {
          if (bereiche.get(j).equals(item.getBereich())) {
            if (!allEvaluationHelper.get(k).getItemWertung().get(valCount).isEmpty()) {
              avValue +=
                  Double.parseDouble(allEvaluationHelper.get(k).getItemWertung().get(valCount));
            }
            valCount++;
          }
        }
        if (valCount != 0) {
          avValue /= valCount;
        }

        list.add(new Double(avValue));
      }
      dataset.add(
          list,
          SeCatResourceBundle.getInstance().getString("scene.chart.all.averagevalues"),
          bereiche.get(j).getName());
    }
    return dataset;
  }
  public ReadInTask2(
      ObservableList<File> inList,
      String dbUrl,
      String dbUser,
      String dbPassword,
      WordnetParser chosenParser,
      boolean exportXml,
      int dbPort,
      String sshUser,
      String sshPassword,
      int sshPort) {
    this(inList, chosenParser, exportXml);

    this.dbUrl = dbUrl;
    this.dbUser = dbUser;
    this.dbPassword = dbPassword;
    this.outData = true;
    this.dbPort = dbPort;
    this.sshUser = sshUser;
    this.sshPassword = sshPassword;
    this.sshPort = sshPort;

    maxProgress = inList.size();
  }
  public void handleMoveSegmentTo(ActionEvent actionEvent) {
    try {
      FXMLLoader loader = new FXMLLoader(getClass().getResource("/com/view/moveSegmentPopup.fxml"));
      AnchorPane pane = (AnchorPane) loader.load();
      Stage dialogStage = new Stage();
      dialogStage.setTitle("Move selected segment to track");
      dialogStage.initModality(Modality.WINDOW_MODAL);
      dialogStage.initOwner(Main.primaryStage);
      Scene scene = new Scene(pane);
      dialogStage.setScene(scene);

      MoveSegmentPopupController controller = loader.getController();
      controller.setDialogStage(dialogStage);

      dialogStage.showAndWait();

      if (controller.isOkClicked()) {
        int beat = controller.getBeat();
        String trackName = controller.getTrack();
        ObservableList<Node> tracksList = Controller.getComposeAreaVBox().getChildren();
        for (int i = 0; i < tracksList.size(); i++) {
          TrackController track = (TrackController) tracksList.get(i);
          if (track.nameProperty().getValue().equals(trackName)) {
            Rectangle rectangle = (Rectangle) track.getTrackBeats().getChildren().get(beat - 1);
            MusicSegmentController newSegment =
                new MusicSegmentController(this.name, this.length, this.width, this.audioPath);
            newSegment.setLayoutX(rectangle.getLayoutX());
            newSegment.setLayoutY(i * 55 + 6);
            Controller.anchorPaneComposition.getChildren().add(newSegment);
          }
        }
      }
    } catch (IOException ex) {
      ex.printStackTrace();
    }
  }