Examples with PlaylistEntryMenuItem se.light.assembly64.model.PlaylistEntryMenuItem used on opensource projects

Example 1 with PlaylistEntryMenuItem

use of se.light.assembly64.model.PlaylistEntryMenuItem in project assembly64fx by freabemania.

the class SidifyMainContoller method init.

public void init(Boolean showBackButton) {
    if (!playerWindowActive.compareAndSet(false, true)) {
        setCancelShow(true);
        return;
    }
    imageCache = CachedImageService.getInstance();
    playListService = PlaylistService.getInstance();
    downloadService = DownloadArtifactsService.getInstance();
    pathService = PathService.getInstance();
    sidPlayService = SIDPlayerService.getInstance();
    volume.setMin(-50L);
    volume.setMax(12);
    volume.setValue(sidPlayService.getVolume());
    volume.valueProperty().addListener(new ChangeListener<Number>() {

        public void changed(ObservableValue<? extends Number> ov, Number oldVal, Number newVal) {
            sidPlayService.setVolume(newVal.intValue());
        }
    });
    volume.valueChangingProperty().addListener(new ChangeListener<Boolean>() {

        @Override
        public void changed(ObservableValue<? extends Boolean> observableValue, Boolean wasChanging, Boolean changing) {
            if (!changing) {
                sidPlayService.storeVolume();
            }
        }
    });
    if (isOffline()) {
        enableSearchImage.setVisible(false);
    }
    performSearchImage.setVisible(false);
    searchField.setVisible(false);
    setIconPlaying(false);
    name.setCellValueFactory(new PropertyValueFactory<PlaylistEntry, String>("nameMasked"));
    group.setCellValueFactory(new PropertyValueFactory<PlaylistEntry, String>("groupMasked"));
    year.setCellValueFactory(new PropertyValueFactory<PlaylistEntry, String>("year"));
    downloaded.setCellValueFactory(new PropertyValueFactory<PlaylistEntry, ImageView>("downloaded"));
    status.setCellValueFactory(new PropertyValueFactory<PlaylistEntry, ImageView>("status"));
    progressSlider.setMin(0);
    progressSlider.setMax(SLIDERMAX);
    progressSlider.disableProperty().setValue(Boolean.TRUE);
    progressUpdater = new ProgressUpdater(played, remaining, progressSlider, prevSub, nextSub);
    status.setMaxWidth(40);
    status.setMinWidth(40);
    status.setSortable(false);
    name.setSortable(false);
    group.setSortable(false);
    year.setSortable(false);
    // songLength.setSortable(false);
    downloaded.setSortable(false);
    songlist.setColumnResizePolicy(TableView.CONSTRAINED_RESIZE_POLICY);
    songlist.setPlaceholder(new Label(""));
    songlist.getSelectionModel().setSelectionMode(SelectionMode.MULTIPLE);
    searchPeriod.setItems(FXCollections.observableArrayList(SEARCH_PERIOD.ALL, SEARCH_PERIOD.ONE_DAY, SEARCH_PERIOD.TWO_DAYS, SEARCH_PERIOD.FOUR_DAYS, SEARCH_PERIOD.ONE_WEEK, SEARCH_PERIOD.TWO_WEEKS, SEARCH_PERIOD.THREE_WEEKS, SEARCH_PERIOD.ONE_MONTH, SEARCH_PERIOD.TWO_MONTHS));
    searchPeriod.getSelectionModel().select(0);
    searchPeriod.setVisible(false);
    if (openedMain || !showBackButton) {
        openedMain = true;
        backToAssemblyImage.setVisible(false);
    }
    getStage().getScene().heightProperty().addListener(new ChangeListener<Number>() {

        @Override
        public void changed(ObservableValue<? extends Number> observableValue, Number oldSceneHeight, Number newSceneHeight) {
            resizeComponentsHeight();
            delayedResize();
        }
    });
    getStage().getScene().widthProperty().addListener(new ChangeListener<Number>() {

        @Override
        public void changed(ObservableValue<? extends Number> observableValue, Number oldSceneHeight, Number newSceneWidth) {
            resizeComponentsWidth();
            delayedResize();
        }
    });
    songlist.setRowFactory(tv -> {
        TableRow<PlaylistEntry> row = new TableRow<>();
        row.setOnDragDetected(event -> {
            if (!row.isEmpty() && isPlaylistMine(activePlaylist)) {
                Integer index = row.getIndex();
                Dragboard db = row.startDragAndDrop(TransferMode.MOVE);
                db.setDragView(row.snapshot(null, null));
                ClipboardContent cc = new ClipboardContent();
                cc.put(SERIALIZED_MIME_TYPE, index);
                db.setContent(cc);
                event.consume();
            }
        });
        row.setOnDragOver(event -> {
            if (!isSearchActive() && isPlaylistMine(activePlaylist)) {
                Dragboard db = event.getDragboard();
                if (db.hasContent(SERIALIZED_MIME_TYPE)) {
                    if (row.getIndex() != ((Integer) db.getContent(SERIALIZED_MIME_TYPE)).intValue()) {
                        event.acceptTransferModes(TransferMode.COPY_OR_MOVE);
                        event.consume();
                    }
                }
            }
        });
        row.setOnDragDropped(event -> {
            if (!isSearchActive() && isPlaylistMine(activePlaylist)) {
                Dragboard db = event.getDragboard();
                if (db.hasContent(SERIALIZED_MIME_TYPE)) {
                    int draggedIndex = (Integer) db.getContent(SERIALIZED_MIME_TYPE);
                    PlaylistEntry draggedPerson = songlist.getItems().remove(draggedIndex);
                    int dropIndex;
                    if (row.isEmpty()) {
                        dropIndex = songlist.getItems().size();
                    } else {
                        dropIndex = row.getIndex();
                    }
                    songlist.getItems().add(dropIndex, draggedPerson);
                    event.setDropCompleted(true);
                    clearAndSelect(dropIndex);
                    Analytics.sendEvent("sidify", "dragndrop_song");
                    playListService.moveSongInList(playListService.getPlaylistForSong(draggedPerson), draggedIndex, dropIndex);
                    event.consume();
                    populateLeftList();
                }
            }
        });
        return row;
    });
    getStage().setOnCloseRequest(new EventHandler<WindowEvent>() {

        public void handle(WindowEvent we) {
            if (GlobalRepoService.getInstance().contains("overridebacktoassembly")) {
                closeAndcleanup(true);
            } else {
                closeAndcleanup(!LocalDBService.getInstance().getSidifyAsDefault());
            }
        }
    });
    populateLeftList();
    leftlist.setCellFactory(callback -> new ListCell<PlayerItem>() {

        @Override
        protected void updateItem(PlayerItem t, boolean bln) {
            super.updateItem(t, bln);
            if (t != null) {
                setText(t.getName());
            }
        }
    });
    leftlist.setOnMousePressed(new EventHandler<MouseEvent>() {

        @Override
        public void handle(MouseEvent event) {
            disableSearch(true, false);
            PlayerItem clickedItem = leftlist.getSelectionModel().getSelectedItem();
            if (clickedItem.getType() == MENU_TYPE.NONCLICKABLE) {
                leftlist.getSelectionModel().clearSelection();
            } else if (clickedItem.getType() == MENU_TYPE.PLAYLIST || clickedItem.getType() == MENU_TYPE.PUBLICLIST) {
                PlaylistInfo playlist = clickedItem.getPlaylist();
                // activePlaylist = playlist;
                if ((event.getButton() == MouseButton.SECONDARY || event.isControlDown()) && !isOffline()) {
                    final ContextMenu contextMenu = new ContextMenu();
                    if (clickedItem.getType() == MENU_TYPE.PLAYLIST) {
                        MenuItem tmp = new MenuItem("Delete");
                        tmp.setOnAction((ActionEvent event2) -> {
                            playListService.deletePlaylist(playlist);
                            populateLeftList();
                            clearSongList();
                        });
                        MenuItem rename = new MenuItem("Edit");
                        rename.setOnAction((ActionEvent event2) -> {
                            GuiUtils.showDialog("sidifyCreateNewPlaylist.fxml", Boolean.TRUE, "Yada", getStage(), new Object[] { playlist, false });
                            populateLeftList();
                        });
                        contextMenu.getItems().add(tmp);
                        contextMenu.getItems().add(rename);
                        leftlist.setContextMenu(contextMenu);
                    } else {
                        MenuItem tmp = new MenuItem("Unfollow");
                        tmp.setOnAction((ActionEvent event2) -> {
                            playListService.deletePlaylist(playlist);
                            playListService.resetAndGetPublicPlaylists();
                            populateLeftList();
                        });
                        contextMenu.getItems().add(tmp);
                    }
                    MenuItem offline = new MenuItem("Download to offline");
                    offline.setOnAction((ActionEvent event2) -> {
                        Analytics.sendEvent("sidify", "download_playlist");
                        workQueue.offer(playlist);
                    });
                    MenuItem info = new MenuItem("Playlistinfo");
                    info.setOnAction((ActionEvent event2) -> {
                        GuiUtils.showDialog("sidifyViewPublicPlaylistInfo.fxml", Boolean.TRUE, "Playlistinfo", getStage(), new Object[] { playlist });
                    });
                    MenuItem exportLists = new MenuItem("Export playlist");
                    exportLists.setOnAction((ActionEvent event2) -> {
                        GuiUtils.showDialog("sidifyExportPlaylist.fxml", Boolean.TRUE, "Playlistinfo", getStage(), new Object[] { playlist });
                    });
                    contextMenu.getItems().add(offline);
                    contextMenu.getItems().add(info);
                    contextMenu.getItems().add(exportLists);
                    leftlist.setContextMenu(contextMenu);
                } else {
                    refreshCurrentSongList(playlist);
                }
                if (event.getClickCount() == 2) {
                    activePlaylist = playlist;
                    if (activePlaylist != null) {
                        List<PlaylistEntry> songsForPlaylist = playListService.getSongsForPlaylist(activePlaylist);
                        if (songsForPlaylist.size() > 0) {
                            if (randomSongs.get() == false) {
                                clearAndSelect(0);
                                setActiveSongInList(0);
                            } else {
                                randomize();
                                clearAndSelect(getActiveSongInList());
                            }
                            startSwitchSongLoopFromScratch();
                        }
                    }
                    songlist.requestFocus();
                }
                scrollToTop();
                populateLeftList();
            }
        }
    });
    songlist.setOnKeyTyped(event -> {
        if (!isSearchActive()) {
            if (event.getCharacter().length() > 0 && event.getCharacter().charAt(0) == Support.ENTER_KEY) {
                setBackgroundplaylistState();
                setNewSongPlayingState(false);
                startSwitchSongLoopFromScratch();
            }
        }
    });
    songlist.setOnMousePressed(event -> {
        songlist.setContextMenu(null);
        List<PlaylistEntry> selectedItems = songlist.getSelectionModel().getSelectedItems();
        if (selectedItems == null) {
            return;
        }
        if (isSearchActive()) {
            List<List<ContentEntry>> contentEntries = new ArrayList<>();
            for (PlaylistEntry playlistEntry : selectedItems) {
                ContentEntryInfo entryInfo = SearchService.getInstance().getSearchItems(playlistEntry.getId(), playlistEntry.getCategory());
                List<ContentEntry> entries = entryInfo.getContentEntry().stream().filter(item -> item.getName().toLowerCase().endsWith(".sid")).collect(Collectors.toList());
                List<ContentEntry> tmp = new ArrayList<>();
                tmp.addAll(entries);
                contentEntries.add(tmp);
            }
            boolean addable = !contentEntries.stream().filter(item -> item.size() > 1).findFirst().isPresent();
            if (event.getButton() == MouseButton.SECONDARY || event.isControlDown()) {
                if (addable) {
                    final ContextMenu contextMenu = new ContextMenu();
                    Menu addToPlaylist = new Menu("Add to playlist");
                    for (PlaylistInfo plist : playListService.getPlaylistInfo()) {
                        PlaylistMenuItem mItem = new PlaylistMenuItem(plist);
                        mItem.setOnAction((ActionEvent event2) -> {
                            PlaylistMenuItem item = (PlaylistMenuItem) event2.getSource();
                            if (Support.isPlaylistMine(item.getPlaylist())) {
                                playListService.addSongs(item.getPlaylist(), selectedItems, contentEntries);
                                songlist.getSelectionModel().clearSelection();
                            } else {
                                GenericMessageDialogController.withErrorProps("Sidify", "You can not add song to public lists!").showAndWait();
                            }
                        });
                        addToPlaylist.getItems().add(mItem);
                    }
                    MenuItem mItem = new MenuItem("Add to new playlist");
                    mItem.setOnAction((ActionEvent event2) -> {
                        SidifyCreatePlaylistController controller = GuiUtils.showDialog("sidifyCreateNewPlaylist.fxml", Boolean.TRUE, "Create new playlist", getStage(), new Object[] { null, false });
                        PlaylistInfo newPlaylist = controller.getNewlyCreatedPlayList();
                        if (newPlaylist != null) {
                            playListService.addSongs(newPlaylist, selectedItems, contentEntries);
                            songlist.getSelectionModel().clearSelection();
                            populateLeftList();
                        }
                    });
                    addToPlaylist.getItems().add(mItem);
                    contextMenu.getItems().add(addToPlaylist);
                    songlist.setContextMenu(contextMenu);
                } else {
                    // If we have more than one entry and
                    // want to add all
                    final ContextMenu contextMenu = new ContextMenu();
                    long nofSids = contentEntries.stream().collect(Collectors.summarizingInt(item -> item.size())).getSum();
                    Menu addToPlaylist = new Menu("Add all (" + nofSids + ") songs to playlist");
                    for (PlaylistInfo plist : playListService.getPlaylistInfo()) {
                        ContentEntryInfoMenuItem mItem = new ContentEntryInfoMenuItem(plist.getName(), contentEntries);
                        mItem.setOnAction((ActionEvent event2) -> {
                            ContentEntryInfoMenuItem item = (ContentEntryInfoMenuItem) event2.getSource();
                            playListService.addSongs(plist, selectedItems, item.getContentEntries());
                            songlist.getSelectionModel().clearSelection();
                            populateLeftList();
                        });
                        addToPlaylist.getItems().add(mItem);
                    }
                    contextMenu.getItems().add(addToPlaylist);
                    MenuItem mItem = new MenuItem("Add to new playlist");
                    mItem.setOnAction((ActionEvent event2) -> {
                        SidifyCreatePlaylistController controller = GuiUtils.showDialog("sidifyCreateNewPlaylist.fxml", Boolean.TRUE, "Create new playlist", getStage(), new Object[] { null, false });
                        PlaylistInfo newPlaylist = controller.getNewlyCreatedPlayList();
                        ContentEntryInfoMenuItem cmItem = new ContentEntryInfoMenuItem(newPlaylist.getName(), contentEntries);
                        if (newPlaylist != null) {
                            playListService.addSongs(newPlaylist, selectedItems, cmItem.getContentEntries());
                            songlist.getSelectionModel().clearSelection();
                            populateLeftList();
                        }
                    });
                    addToPlaylist.getItems().add(mItem);
                    songlist.setContextMenu(contextMenu);
                }
            } else {
                if (event.getClickCount() == 2) {
                    setBackgroundplaylistState();
                    try {
                        if (contentEntries.size() == 1 && contentEntries.get(0).size() == 1) {
                            setNewSongPlayingState(false);
                            selectedItems.get(0).setFileId(contentEntries.get(0).get(0).getId());
                            startSwitchSongLoopFromScratch();
                        } else {
                            GuiUtils.showDialog("sidifyViewMultipeSongs.fxml", Boolean.TRUE, "Choose", getStage(), new Object[] { Support.flattenAndEnrichEntries(selectedItems, contentEntries) });
                            refreshPlaylistIfNeeded(playListService.getPlaylistForSong(selectedItems.get(0)));
                            populateLeftList();
                        }
                    } catch (Exception e) {
                        LOGGER.error("Unable to play item", e);
                    }
                }
            }
        } else {
            List<List<ContentEntry>> contentEntries = new ArrayList<>();
            for (PlaylistEntry playlistEntry : selectedItems) {
                List<ContentEntry> tmp = new ArrayList<>();
                ContentEntry entry = new ContentEntry();
                entry.setFullPlaylistInfo(playlistEntry);
                entry.setId(playlistEntry.getFileId());
                entry.setName(playlistEntry.getName());
                tmp.add(entry);
                contentEntries.add(tmp);
            }
            setBackgroundplaylistState();
            if ((event.getButton() == MouseButton.SECONDARY || event.isControlDown()) && !isOffline()) {
                final ContextMenu contextMenu = new ContextMenu();
                Menu addToPlaylist = new Menu("Add to playlist");
                for (PlaylistInfo plist : playListService.getPlaylistInfo()) {
                    PlaylistMenuItem mItem = new PlaylistMenuItem(plist);
                    mItem.setOnAction((ActionEvent event2) -> {
                        PlaylistMenuItem item = (PlaylistMenuItem) event2.getSource();
                        if (Support.isPlaylistMine(item.getPlaylist())) {
                            playListService.addSongs(item.getPlaylist(), selectedItems, contentEntries);
                            PlaylistInfo currentPlaylist = playListService.getPlaylistForSong(selectedItems.get(0));
                            refreshPlaylistIfNeeded(currentPlaylist);
                            songlist.getSelectionModel().clearSelection();
                        } else {
                            GenericMessageDialogController.withErrorProps("Sidify", "You can not add song to public lists!").showAndWait();
                        }
                    });
                    addToPlaylist.getItems().add(mItem);
                }
                contextMenu.getItems().add(addToPlaylist);
                MenuItem mItem = new MenuItem("Add to new playlist");
                mItem.setOnAction((ActionEvent event2) -> {
                    SidifyCreatePlaylistController controller = GuiUtils.showDialog("sidifyCreateNewPlaylist.fxml", Boolean.TRUE, "Create new playlist", getStage(), new Object[] { null, false });
                    PlaylistInfo newPlaylist = controller.getNewlyCreatedPlayList();
                    ContentEntryInfoMenuItem cmItem = new ContentEntryInfoMenuItem(newPlaylist.getName(), contentEntries);
                    if (newPlaylist != null) {
                        playListService.addSongs(newPlaylist, selectedItems, cmItem.getContentEntries());
                        songlist.getSelectionModel().clearSelection();
                        populateLeftList();
                    }
                });
                addToPlaylist.getItems().add(mItem);
                if (isPlaylistMine(playListService.getPlaylistForSong(selectedItems.get(0)))) {
                    PlaylistEntryMenuItem deleteItem = new PlaylistEntryMenuItem("Delete", selectedItems);
                    deleteItem.setOnAction((ActionEvent event2) -> {
                        PlaylistEntryMenuItem item = (PlaylistEntryMenuItem) event2.getSource();
                        PlaylistInfo currentPlaylist = playListService.getPlaylistForSong(item.getPlaylistEntry());
                        playListService.deleteSongs(currentPlaylist, item.getPlaylistEntries());
                        songlist.getSelectionModel().clearSelection();
                        populateLeftList();
                        refreshPlaylistIfNeeded(currentPlaylist);
                    });
                    contextMenu.getItems().add(deleteItem);
                }
                songlist.setContextMenu(contextMenu);
            } else if (event.getClickCount() == 2) {
                setNewSongPlayingState(false);
                startSwitchSongLoopFromScratch();
                populateLeftList();
            }
        }
    });
    searchField.setOnKeyReleased((event) -> {
        if (event.getCode() == KeyCode.ENTER) {
            doSearch(searchField.getText());
        }
    });
    try {
        searchPeriod.getSelectionModel().selectedItemProperty().addListener((ObservableValue<? extends SEARCH_PERIOD> observable, SEARCH_PERIOD oldValue, SEARCH_PERIOD newValue) -> doSearch(searchField.getText()));
    } catch (Exception e) {
        LOGGER.info("Unable to add listener", e);
    }
    disableSearch();
    workQueue = new ArrayBlockingQueue<>(1000);
    Executors.newSingleThreadExecutor().execute(() -> {
        while (true) {
            try {
                Object queueItem = workQueue.take();
                if (queueItem instanceof PoisonPill) {
                    break;
                } else if (queueItem instanceof PlaylistInfo) {
                    downloadPlaylistOffline((PlaylistInfo) queueItem, true);
                } else if (queueItem instanceof String && ((String) queueItem).equals("checklists")) {
                    for (PlaylistInfo pInfo : playListService.getPlaylistInfo()) {
                        if (pInfo.isAvailableOffline()) {
                            downloadPlaylistOffline(pInfo, false);
                        }
                    }
                }
            } catch (Exception e) {
            }
        }
    });
    if (!isOffline()) {
        checkOfflineScheduler = Executors.newScheduledThreadPool(1);
        checkOfflineScheduler.scheduleAtFixedRate(() -> {
            workQueue.offer("checklists");
        }, 5, 10, TimeUnit.SECONDS);
    }
}