@UiHandler("importButton")
 public void onImportClicked(SelectionEvent<Item> event) {
   if (deviceCombo.getValue() == null) {
     new AlertMessageBox(i18n.error(), i18n.errFillFields()).show();
   } else {
     new ImportDialog(deviceCombo.getValue()).show();
   }
 }
 @Override
 public void onAnything() {
   Device oldDevice = deviceCombo.getValue();
   if (oldDevice != null) {
     deviceCombo.setValue(deviceStore.findModel(oldDevice));
   } else if (deviceStore.size() == 1) {
     deviceCombo.setValue(deviceStore.get(0));
   }
 }
  public void initProviders() throws DataBaseException {
    providers = dao.getProviders();
    selectProviderCb.getItems().clear();

    for (Provider provider : providers) {
      selectProviderCb.getItems().add(provider.getName());
    }
    selectProviderCb.setValue(providers.get(0).getName());
  }
  private void initializeAssignmentListViewAndFilters() {
    final ListBinding<PersonnelAssignment> filteredAssignementBinding =
        new ListBinding<PersonnelAssignment>() {
          final ObjectBinding<ObservableList<PersonnelAssignment>> internalBinding =
              Bindings.select(
                  assignmentsFilterComboBox.getSelectionModel().selectedItemProperty(),
                  "assignments");

          {
            bind(internalBinding);
          }

          @Override
          protected ObservableList<PersonnelAssignment> computeValue() {
            return internalBinding.get();
          }

          @Override
          public Spliterator<PersonnelAssignment> spliterator() {
            return super.spliterator();
          }
        };

    assigmentsListView.itemsProperty().bind(filteredAssignementBinding);
    assigmentsListView.setCellFactory(
        new PropertyListCellFactory<PersonnelAssignment>("name", null));

    assignmentsFilterComboBox.getItems().clear();
    assignmentsFilterComboBox.getItems().addAll(assignementFilters);
    assignmentsFilterComboBox.setCellFactory(
        new PropertyListCellFactory<AssignementFilter>("name", null));
    assignmentsFilterComboBox.setButtonCell(
        new ListCell<AssignementFilter>() {
          @Override
          protected void updateItem(AssignementFilter item, boolean empty) {
            super.updateItem(item, empty);
            if (textProperty().isBound()) {
              textProperty().unbind();
            }
            if (item != null || !empty) {
              textProperty().bind(item.nameProperty());
            }
          }
        });
  }
 @UiHandler("loadButton")
 public void onLoadClicked(SelectEvent event) {
   archiveHandler.onLoad(
       deviceCombo.getValue(),
       getCombineDate(fromDate, fromTime),
       getCombineDate(toDate, toTime),
       !disableFilter.getValue(),
       snapToRoads.getValue(),
       new ArchiveStyle(style));
 }
  public void open(File f) {
    Properties open = new Properties();
    InputStream input = null;

    try {
      input = new FileInputStream(f);
      open.load(input);

      selectProviderCb.setValue(open.getProperty("provider"));
      selectGrainCb.setValue(open.getProperty("grain"));
      weightTf.setText(open.getProperty("weight"));
      infoTa.setText(open.getProperty("info"));

      for (Entry<String, TextField> entry : propertiesTf.entrySet()) {
        String propertyName = entry.getKey();
        TextField tf = entry.getValue();
        CheckBox cb = propertiesCb.get(propertyName);

        tf.setText(open.getProperty(propertyName));
        if (open.getProperty(propertyName + "_ENABLED").equals("ON")) {
          tf.setDisable(false);
          cb.setSelected(true);
        } else {
          tf.setDisable(true);
          cb.setSelected(false);
        }
      }

      mainStage.setTitle(f.getName());
    } catch (Exception ex) {
      infoTa.setText("Не могу открыть файл");
    } finally {
      if (input != null) {
        try {
          input.close();
        } catch (IOException e) {
          e.printStackTrace();
        }
      }
    }
  }
  public void initGrains() {
    grains = new ArrayList<>();
    grains.add(new Wheat());
    grains.add(new Rice());
    for (Grain grain : grains) {
      selectGrainCb.getItems().add(grain.getDescription());
    }

    selectGrainCb
        .valueProperty()
        .addListener(
            new ChangeListener<String>() {
              @Override
              public void changed(ObservableValue ov, String t, String t1) {
                grain = getGrain(t1);
                initProperties(grain);
              }
            });

    selectGrainCb.setValue(grains.get(0).getDescription());
  }
  public void save(File f) {
    Properties save = new Properties();
    OutputStream output = null;

    try {
      save.setProperty("provider", selectProviderCb.getValue());
      save.setProperty("grain", selectGrainCb.getValue());
      save.setProperty("weight", weightTf.getText());
      save.setProperty("info", infoTa.getText());

      for (Entry<String, TextField> entry : propertiesTf.entrySet()) {
        TextField tf = entry.getValue();
        String propertyName = entry.getKey();

        save.setProperty(propertyName, tf.getText());
        if (tf.isDisable()) {
          save.setProperty(propertyName + "_ENABLED", "OFF");
        } else {
          save.setProperty(propertyName + "_ENABLED", "ON");
        }
      }

      output = new FileOutputStream(f);
      save.store(output, null);
      mainStage.setTitle(f.getName());
    } catch (Exception ex) {
      infoTa.setText("Не могу сохранить в файл");
    } finally {
      if (output != null) {
        try {
          output.close();
        } catch (IOException e) {
          e.printStackTrace();
        }
      }
    }
  }
  @UiHandler("gpxButton")
  public void onGPXClicked(SelectionEvent<Item> event) {
    if (deviceCombo.getValue() == null) {
      new AlertMessageBox(i18n.error(), i18n.errFillFields()).show();
    } else {
      DateTimeFormat jsonTimeFormat =
          ApplicationContext.getInstance().getFormatterUtil().getRequestTimeFormat();

      Window.open(
          "/traccar/export/gpx"
              + "?deviceId="
              + (deviceCombo.getValue() == null ? null : deviceCombo.getValue().getId())
              + "&from="
              + jsonTimeFormat.format(getCombineDate(fromDate, fromTime)).replaceFirst("\\+", "%2B")
              + "&to="
              + jsonTimeFormat.format(getCombineDate(toDate, toTime)).replaceFirst("\\+", "%2B")
              + "&filter="
              + !disableFilter.getValue()
              + "&snapToRoads="
              + snapToRoads.getValue(),
          "_blank",
          null);
    }
  }
  public void showHistory() {
    provider = getProvider(selectProviderCb.getValue());

    try {
      FXMLLoader loader =
          new FXMLLoader(getClass().getResource("/main/by/ggtu/dzmitry/view/History.fxml"));
      AnchorPane layout = (AnchorPane) loader.load();
      HistoryController historyController = loader.getController();
      Scene scene = new Scene(layout);
      Stage stage = new Stage();
      stage.setScene(scene);
      stage.show();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
 public void addSkillFilter(ActionEvent event) {
   final Skill skill = skillFilterComboBox.getSelectionModel().getSelectedItem();
   SkillFilter skillFilter = new SkillFilter();
   skillFilter.setSkill(skill);
   String minValueText = skillFilterMinValueComponent.getText();
   skillFilter.setMinValue(
       (minValueText == null || minValueText.isEmpty()) ? null : Integer.parseInt(minValueText));
   String maxValueText = skillFilterMaxValueComponent.getText();
   skillFilter.setMaxValue(
       (maxValueText == null || maxValueText.isEmpty()) ? null : Integer.parseInt(maxValueText));
   skillFiltersTableView.getItems().add(skillFilter);
   // We don't need to update #skillFiltersMatcher because of the biding
   // betwen skillFiltersMatcher' matchers and the items of
   // skillFiltersTableView
   updateOfficialFiltersResult();
 }
  public void newFile() {
    infoTa.setText("");
    selectProviderCb.setValue(providers.get(0).getName());
    weightTf.setText("0.0");

    for (Entry<String, TextField> entry : propertiesTf.entrySet()) {
      String propertyName = entry.getKey();
      TextField tf = entry.getValue();
      CheckBox cb = propertiesCb.get(propertyName);

      tf.setText("0.0");
      tf.setDisable(true);
      cb.setSelected(false);
    }

    file = null;
    mainStage.setTitle("unknown");
  }
  protected void replaceToCombo(String key, Container container, String defaultValue) {
    final TextField field = (TextField) map.get(key);
    HorizontalLayout layout = (HorizontalLayout) field.getParent();
    field.setVisible(false);
    final ComboBox comboBox = new ComboBox("", container);
    comboBox.setImmediate(true);
    comboBox.setNullSelectionAllowed(false);

    comboBox.addValueChangeListener(
        new Property.ValueChangeListener() {
          @Override
          public void valueChange(Property.ValueChangeEvent valueChangeEvent) {
            field.setValue((String) comboBox.getValue());
          }
        });

    if (container.containsId(field.getValue())) {
      comboBox.select(field.getValue());
    } else {
      field.setValue(defaultValue);
      comboBox.select(defaultValue);
    }
    layout.addComponent(comboBox, 1);
  }
 public void selectDevice(Device device) {
   deviceCombo.setValue(device, false);
 }
  public void HandlerCalcPriceButton(ActionEvent event) {
    try {
      grain = getGrain(selectGrainCb.getValue());
      System.out.println("> " + grain.getName());

      try {
        grain.setWeight(Double.parseDouble(weightTf.getText()));
      } catch (NumberFormatException e) {
        weightTf.requestFocus();
        throw new NumberFormatException("Вес партии зерна");
      }

      for (Entry<String, TextField> entry : propertiesTf.entrySet()) {
        TextField tf = entry.getValue();
        String propertyName = entry.getKey();
        System.out.println("\t> " + propertyName);

        if (!tf.isDisable()) {
          try {
            grain.getProperty(propertyName).setValue(Double.parseDouble(tf.getText()));

          } catch (NumberFormatException e) {
            tf.requestFocus();
            throw new NumberFormatException(grain.getProperty(propertyName).getDescription());
          }

          grain.getProperty(propertyName).setEnabled(true);

        } else {
          grain.getProperty(propertyName).setEnabled(false);
        }
      }

      System.out.println("> before calculator");

      PriceCalculator calculator = new PriceCalculator(grain, dao);
      calculator.calculatePrice();
      infoTa.setText(calculator.toString());

      Supply supply = new Supply();
      supply.setProvider(selectProviderCb.getValue());
      supply.setDate(new Date(Calendar.getInstance().getTimeInMillis()));
      //            supply.setGrain(grain.getName());
      supply.setGrain(grain.getDescription());
      supply.setWeight(grain.getWeight());
      supply.setPrice(calculator.getPrice());

      dao.saveSupply(supply);

    } catch (RestrictiveConditionException e) {
      Utils.showErrorDialog("Ограшичительные кондиции!", e);
      infoTa.clear();
    } catch (DataBaseException e) {
      Utils.showErrorDialog("Обшибка базы данных!", e);
      infoTa.clear();
    } catch (NumberFormatException e) {
      Utils.showErrorDialog("Неверный ввод!", e);
      infoTa.clear();
    } catch (Exception ex) {
      Utils.showErrorDialog("Ошибка!", ex);
      infoTa.clear();
    }
  }
  private void initializeSkillFilterTab() {
    skillFilterComboBox.getItems().addAll(skills);
    PropertyListCellFactory<Skill> propertyListCellFactory =
        new PropertyListCellFactory<>("name", null);
    skillFilterComboBox.setButtonCell(
        new ListCell<Skill>() {
          @Override
          protected void updateItem(Skill arg0, boolean arg1) {
            super.updateItem(arg0, arg1);
            if (arg1 || arg0 == null) {
              this.setText(null);
            } else {
              this.setText(arg0.getName());
            }
          }
        });
    skillFilterComboBox.setCellFactory(propertyListCellFactory);
    skillFiltersNameColumn.setCellValueFactory(
        new Callback<CellDataFeatures<SkillFilter, String>, ObservableValue<String>>() {
          @Override
          public ObservableValue<String> call(CellDataFeatures<SkillFilter, String> arg0) {
            return Bindings.selectString(arg0.getValue().skillProperty(), "name");
          }
        });

    skillFilterMinValueColumn.setCellValueFactory(
        new PropertyValueFactory<SkillFilter, Integer>("minValue"));
    skillFilterMaxValueColumn.setCellValueFactory(
        new PropertyValueFactory<SkillFilter, Integer>("maxValue"));
    skillFiltersTableView
        .getItems()
        .addListener(
            new ListChangeListener<SkillFilter>() {
              @Override
              public void onChanged(Change<? extends SkillFilter> arg0) {
                while (arg0.next()) {
                  for (SkillFilter skillFilter : arg0.getAddedSubList()) {
                    final Skill skill = skillFilter.getSkill();
                    TableColumn<Official, Number> skillColumn = new TableColumn<>(skill.getName());
                    skillColumn.setCellValueFactory(
                        new Callback<
                            CellDataFeatures<Official, Number>, ObservableValue<Number>>() {
                          @Override
                          public ObservableValue<Number> call(
                              CellDataFeatures<Official, Number> arg0) {
                            Official official = arg0.getValue();
                            IntegerBinding selectInteger =
                                Bindings.selectInteger(
                                    official.skillLevelsProperty().valueAt(skill), "level");
                            selectInteger.addListener(
                                new ChangeListener<Number>() {
                                  @Override
                                  public void changed(
                                      ObservableValue<? extends Number> arg0,
                                      Number arg1,
                                      Number arg2) {
                                    updateOfficialFiltersResult();
                                  }
                                });
                            return selectInteger;
                          }
                        });
                    officialsFilteredTableView.getColumns().add(skillColumn);
                    skillFiltersColumn.put(skill, skillColumn);
                  }

                  for (SkillFilter skillFilter : arg0.getRemoved()) {
                    final Skill skill = skillFilter.getSkill();
                    TableColumn<Official, Number> column = skillFiltersColumn.remove(skill);

                    if (column != null) {
                      officialsFilteredTableView.getColumns().remove(column);
                    }
                  }
                }
              }
            });
    Bindings.bindContent(skillFiltersMatcher.getMatchers(), skillFiltersTableView.getItems());
  }