public Builder(EngineCategoryDTO categoryDTO) { this.withName(categoryDTO.getName()).withDescription(categoryDTO.getDescription()) .withSubCategories(categoryDTO.getSubCategories()).withIcon(categoryDTO.getIcon()); }
public EngineCategoryDTO build() { return new EngineCategoryDTO(this); } }
public EngineDTO build() { return new EngineDTO(this); }
filteredEngineVersions, engineVersion -> ListWidgetElement.create(engineVersion, Files.exists(Paths.get( getControl().getEnginesPath(), getControl().getEngineCategory().getName().toLowerCase(), getControl().getEngineSubCategory().getName(), engineVersion.getVersion())))); userData.put("Mono", engineItem.getMonoFile()); userData.put("Gecko", engineItem.getGeckoFile()); EngineDTO engineDTO = new EngineDTO.Builder() .withCategory(getControl().getEngineCategory().getName()) .withSubCategory(getControl().getEngineSubCategory().getName()) .withVersion(engineItem.getVersion()) .withUserData(userData).build();
/** * fetches all available engines from the repository * @param categoryDTOS engine categories from the repository * @return available engines */ public List<EngineCategoryDTO> getAvailableEngines(List<CategoryDTO> categoryDTOS) { List<EngineCategoryDTO> engines = new ArrayList<>(); for (CategoryDTO categoryDTO : categoryDTOS) { final String engineName = categoryDTO.getName(); final EngineCategoryDTO engineCategoryDTO = new EngineCategoryDTO.Builder() .withName(engineName) .withDescription(engineName) .withSubCategories(new ArrayList<>()) .build(); engines.add(engineCategoryDTO); } return engines; }
/** * updates available versions for a certain engine * * @param engineCategoryDTO engine * @param versions available versions for the engine */ public void updateVersions(EngineCategoryDTO engineCategoryDTO, List<EngineSubCategoryDTO> versions) { Platform.runLater(() -> { EngineCategoryDTO newEngineCategoryDTO = new EngineCategoryDTO.Builder(engineCategoryDTO) .withSubCategories(versions) .build(); this.engineCategories.remove(engineCategoryDTO); this.engineCategories.add(newEngineCategoryDTO); }); }
/** * This method checks if a given engine version has been installed * * @param engineVersionDTO The engine version to be checked * @return True if the engine version is installed, false otherwise */ private boolean isInstalled(EngineCategoryDTO engineCategory, EngineSubCategoryDTO engineSubCategory, EngineVersionDTO engineVersionDTO) { return Paths.get(enginesPath, engineCategory.getName().toLowerCase(), engineSubCategory.getName(), engineVersionDTO.getVersion()).toFile().exists(); }
private ObservableList<Tab> createEngineSubCategoryTabs() { this.engineCategories, engineCategory -> engineCategory.getSubCategories().stream() .map(engineSubCategory -> { final EngineSubCategoryPanel engineSubCategoryPanel = new EngineSubCategoryPanel(); engineSubCategoryPanel.setEnginesPath(this.enginesPath); engineSubCategoryPanel.setFilter(this.filter); engineSubCategoryPanel.setEngine(this.engines.get(engineCategory.getName().toLowerCase())); .comparing(engineSubCategoryPanel -> engineSubCategoryPanel.getEngineSubCategory().getName())) engineSubCategoryPanel -> new Tab(engineSubCategoryPanel.getEngineSubCategory().getDescription(), engineSubCategoryPanel));
/** * Checks if the given engine category fulfills this filter * * @param engineCategory The engine category * @return True if the given engine category fulfills the filter, false otherwise */ public boolean filter(EngineCategoryDTO engineCategory) { return Optional.ofNullable(searchTerm.getValueSafe()) .map(searchTerm -> engineCategory.getSubCategories().stream() .anyMatch(engineSubCategory -> engineSubCategory.getPackages().stream() .anyMatch(version -> version.getVersion().toLowerCase() .contains(searchTerm.toLowerCase())))) .orElse(true); }
final String engineId = engineCategoryDTO.getName().toLowerCase(); .withTitle(tr("Install {0}", engineDTO.getVersion())) .withMessage(tr("Are you sure you want to install {0}?", engineDTO.getVersion())) .withOwner(enginesView.getContent().getScene().getWindow()) .withResizable(true) .withYesCallback(() -> this.enginesManager.getEngine(engineDTO.getId(), engine -> { engine.install(engineDTO.getSubCategory(), engineDTO.getVersion()); this.versionsCache.remove(engineDTO.getId()); this.forceViewUpdate(); }, e -> Platform.runLater(() -> { .withTitle(tr("Delete {0}", engineDTO.getVersion())) .withMessage(tr("Are you sure you want to delete {0}?", engineDTO.getVersion())) .withOwner(enginesView.getContent().getScene().getWindow()) .withResizable(true) .withYesCallback(() -> this.enginesManager.getEngine(engineDTO.getId(), engine -> { engine.delete(engineDTO.getSubCategory(), engineDTO.getVersion()); this.versionsCache.remove(engineDTO.getId()); this.forceViewUpdate(); }, e -> Platform.runLater(() -> {
/** * Updates the {@link Engine} and {@link EngineDTO} of this {@link EngineDetailsPanelSkin} instance */ private void updateEngine() { final EngineDTO engine = getControl().getEngineDTO(); if (engine != null) { title.setValue(engine.getCategory() + " " + engine.getSubCategory()); engineVersionName.setValue(engine.getVersion()); engineUserData.clear(); engineUserData.putAll(engine.getUserData()); } } }
public static ListWidgetElement<EngineVersionDTO> create(EngineVersionDTO engineVersion, boolean installed) { return new ListWidgetElement<>(engineVersion, Optional.empty(), WINE_MINIATURE, engineVersion.getVersion(), Collections.emptyList(), Collections.emptyList(), installed); }
/** * Creates a {@link FilteredList} object of the engine versions by applying the {@link EnginesFilter} known to the * control * * @return A filtered list of the engine versions */ private ObservableList<EngineVersionDTO> createFilteredEngineVersions() { final EnginesFilter filter = getControl().getFilter(); final EngineCategoryDTO engineCategory = getControl().getEngineCategory(); final EngineSubCategoryDTO engineSubCategory = getControl().getEngineSubCategory(); final FilteredList<EngineVersionDTO> filteredEngineVersions = FXCollections .observableArrayList(engineSubCategory.getPackages()) .sorted(EngineSubCategoryDTO.comparator().reversed()) .filtered(filter.createFilter(engineCategory, engineSubCategory)); filteredEngineVersions.predicateProperty().bind( Bindings.createObjectBinding(() -> filter.createFilter(engineCategory, engineSubCategory), filter.searchTermProperty(), filter.selectedEngineCategoryProperty(), filter.showInstalledProperty(), filter.showNotInstalledProperty())); return filteredEngineVersions; }
public EngineVersionDTO build() { return new EngineVersionDTO(this); }
/** * Checks if a given engine sub category tab fulfills this filter * * @param engineSubCategoryPanel The engine sub category tab * @return True if the given engine sub category tab fulfills the filter, false otherwise */ public boolean filter(EngineSubCategoryPanel engineSubCategoryPanel) { final boolean tabNotEmpty = engineSubCategoryPanel.notEmpty(this); final boolean selectedEngineCategoryConstraint = Optional.ofNullable(selectedEngineCategory.getValue()) .map(selectedEngineCategory -> selectedEngineCategory .equals(engineSubCategoryPanel.getEngineCategory())) .orElse(true); return tabNotEmpty && selectedEngineCategoryConstraint; } }
/** * Checks whether this panel will be empty when applying the given {@link EnginesFilter filter} * * @param filter The applied filter * @return True if this panel will be empty when applying the given filter, false otherwise */ public boolean notEmpty(EnginesFilter filter) { return getEngineSubCategory().getPackages().stream() .anyMatch(filter.createFilter(getEngineCategory(), getEngineSubCategory())); }
public static Comparator<EngineVersionDTO> comparator() { return (o1, o2) -> new VersionComparator().compare(new Version(o1.getVersion()), new Version(o2.getVersion())); }
/** * {@inheritDoc} */ @Override protected ToggleButton convertToToggleButton(EngineCategoryDTO category) { final ToggleButton categoryButton = createSidebarToggleButton(category.getName()); categoryButton.setId(String.format("%sButton", category.getName().toLowerCase())); categoryButton.setOnAction(event -> getControl().setSelectedElement(category)); return categoryButton; } }
/** * Creates a new filter predicate for a {@link EngineCategoryDTO} and {@link EngineSubCategoryDTO}. * This predicate then accepts a {@link EngineVersionDTO} object and returns true if the given object fulfills the * filter predicate and false otherwise * * @param engineCategory The engine category * @param engineSubCategory The engine sub category * @return A new filter predicate */ public Predicate<EngineVersionDTO> createFilter(EngineCategoryDTO engineCategory, EngineSubCategoryDTO engineSubCategory) { return engineVersion -> { final boolean containsSearchTerm = Optional.ofNullable(searchTerm.getValueSafe()) .map(searchTerm -> engineVersion.getVersion().toLowerCase().contains(searchTerm.toLowerCase())) .orElse(true); final boolean fulfillsShowInstalled = showInstalled.getValue() && isInstalled(engineCategory, engineSubCategory, engineVersion); final boolean fulfillsShowNotInstalled = showNotInstalled.getValue() && !isInstalled(engineCategory, engineSubCategory, engineVersion); return containsSearchTerm && (fulfillsShowInstalled || fulfillsShowNotInstalled); }; }