Java Examples for javafx.scene.control.SeparatorMenuItem

private ContextMenu createContextMenuForGroup(GroupNodeViewModel group) {
    ContextMenu menu = new ContextMenu();
    MenuItem editGroup = new MenuItem(Localization.lang("Edit group"));
    editGroup.setOnAction( event -> {
        menu.hide();
        viewModel.editGroup(group);
    });
    MenuItem addSubgroup = new MenuItem(Localization.lang("Add subgroup"));
    addSubgroup.setOnAction( event -> {
        menu.hide();
        viewModel.addNewSubgroup(group);
    });
    MenuItem removeGroupAndSubgroups = new MenuItem(Localization.lang("Remove group and subgroups"));
    removeGroupAndSubgroups.setOnAction( event -> viewModel.removeGroupAndSubgroups(group));
    MenuItem removeGroupKeepSubgroups = new MenuItem(Localization.lang("Remove group, keep subgroups"));
    removeGroupKeepSubgroups.setOnAction( event -> viewModel.removeGroupKeepSubgroups(group));
    MenuItem removeSubgroups = new MenuItem(Localization.lang("Remove subgroups"));
    removeSubgroups.setOnAction( event -> viewModel.removeSubgroups(group));
    MenuItem addEntries = new MenuItem(Localization.lang("Add selected entries to this group"));
    addEntries.setOnAction( event -> viewModel.addSelectedEntries(group));
    MenuItem removeEntries = new MenuItem(Localization.lang("Remove selected entries from this group"));
    removeEntries.setOnAction( event -> viewModel.removeSelectedEntries(group));
    MenuItem sortAlphabetically = new MenuItem(Localization.lang("Sort all subgroups (recursively)"));
    sortAlphabetically.setOnAction( event -> viewModel.sortAlphabeticallyRecursive(group));
    menu.getItems().add(editGroup);
    menu.getItems().add(new SeparatorMenuItem());
    menu.getItems().addAll(addSubgroup, removeSubgroups, removeGroupAndSubgroups, removeGroupKeepSubgroups);
    menu.getItems().add(new SeparatorMenuItem());
    menu.getItems().addAll(addEntries, removeEntries);
    menu.getItems().add(new SeparatorMenuItem());
    menu.getItems().add(sortAlphabetically);
    return menu;
}

private Menu createProjectMenu() {
    createProject = new MenuItem("Create");
    createProject.setAccelerator(new KeyCodeCombination(KeyCode.N, KeyCombination.CONTROL_DOWN));
    openProject = new MenuItem("Open");
    openProject.setAccelerator(new KeyCodeCombination(KeyCode.O, KeyCombination.CONTROL_DOWN));
    saveProject = new MenuItem("Save");
    saveProject.setAccelerator(new KeyCodeCombination(KeyCode.S, KeyCombination.CONTROL_DOWN));
    saveAsProject = new MenuItem("Save as");
    saveAsProject.setAccelerator(new KeyCodeCombination(KeyCode.S, KeyCombination.SHIFT_DOWN, KeyCombination.CONTROL_DOWN));
    Menu resourcesMenu = new Menu("Resources");
    exportResources = new MenuItem("Export");
    importResources = new MenuItem("Import");
    resourcesMenu.getItems().addAll(exportResources, importResources);
    exit = new MenuItem("Exit");
    Menu projectMenu = new Menu("Project");
    projectMenu.getItems().addAll(createProject, openProject, saveProject, saveAsProject, resourcesMenu, new SeparatorMenuItem(), exit);
    return projectMenu;
}

@NbBundle.Messages({ "ListChart.errorMsg=There was a problem getting the content for the selected event." })
@Override
protected void updateItem(CombinedEvent item, boolean empty) {
    CombinedEvent oldItem = getItem();
    if (oldItem != null) {
        visibleEvents.remove(oldItem);
    }
    super.updateItem(item, empty);
    if (empty || item == null) {
        event = null;
    } else {
        visibleEvents.add(item);
        event = controller.getEventsModel().getEventById(item.getRepresentativeEventID());
        setOnContextMenuRequested( contextMenuEvent -> {
            try {
                EventNode node = EventNode.createEventNode(item.getRepresentativeEventID(), controller.getEventsModel());
                List<MenuItem> menuItems = new ArrayList<>();
                for (Action action : node.getActions(false)) {
                    if (action == null) {
                        menuItems.add(new SeparatorMenuItem());
                    } else {
                        String actionName = Objects.toString(action.getValue(Action.NAME));
                        if (Arrays.asList("&Properties", "Tools").contains(actionName) == false) {
                            if (action instanceof Presenter.Popup) {
                                JMenuItem submenu = ((Presenter.Popup) action).getPopupPresenter();
                                menuItems.add(SwingFXMenuUtils.createFXMenu(submenu));
                            } else {
                                menuItems.add(SwingFXMenuUtils.createFXMenu(new Actions.MenuItem(action, false)));
                            }
                        }
                    }
                }
                ;
                new ContextMenu(menuItems.toArray(new MenuItem[menuItems.size()])).show(this, contextMenuEvent.getScreenX(), contextMenuEvent.getScreenY());
            } catch (IllegalStateException ex) {
                LOGGER.log(Level.SEVERE, "There was no case open to lookup the Sleuthkit object backing a SingleEvent.", ex);
            } catch (TskCoreException ex) {
                LOGGER.log(Level.SEVERE, "Failed to lookup Sleuthkit object backing a SingleEvent.", ex);
                Platform.runLater(() -> {
                    Notifications.create().owner(getScene().getWindow()).text(Bundle.ListChart_errorMsg()).showError();
                });
            }
        });
    }
}

/**
   * Create a custom menu.
   * 
   * @param table
   * @return contextMenu
   */
private static ContextMenu createContextMenu(TreeTableView<FeatureTableRow> table) {
    // New context menu
    ContextMenu cm = new ContextMenu();
    CustomMenuItem cmi;
    // Select all item
    Label selectAll = new Label("Select all");
    selectAll.addEventHandler(MouseEvent.MOUSE_CLICKED, new EventHandler<MouseEvent>() {

        @Override
        public void handle(MouseEvent event) {
            for (Object obj : table.getColumns()) {
                ((TreeTableColumn<?, ?>) obj).setVisible(true);
            }
        }
    });
    cmi = new CustomMenuItem(selectAll);
    cmi.setHideOnClick(false);
    cm.getItems().add(cmi);
    // Deselect all item
    Label deselectAll = new Label("Deselect all");
    deselectAll.addEventHandler(MouseEvent.MOUSE_CLICKED, new EventHandler<MouseEvent>() {

        @Override
        public void handle(MouseEvent event) {
            for (Object obj : table.getColumns()) {
                ((TreeTableColumn<?, ?>) obj).setVisible(false);
            }
        }
    });
    cmi = new CustomMenuItem(deselectAll);
    cmi.setHideOnClick(false);
    cm.getItems().add(cmi);
    // Separator
    cm.getItems().add(new SeparatorMenuItem());
    // Variables
    Boolean sampleColumns = false;
    // menu item for each of the available columns
    for (Object obj : table.getColumns()) {
        TreeTableColumn<?, ?> tableColumn = (TreeTableColumn<?, ?>) obj;
        int childrenColumns = tableColumn.getColumns().size();
        CheckBox cb;
        if (childrenColumns != 0 && !sampleColumns) {
            sampleColumns = true;
            // Separator
            cm.getItems().add(new SeparatorMenuItem());
            // Sample specific columns
            for (TreeTableColumn<?, ?> col : tableColumn.getColumns()) {
                cb = new CheckBox("Sample: " + col.getText());
                // Bind to all equal sample specific columns
                for (Object obj2 : table.getColumns()) {
                    TreeTableColumn<?, ?> tableColumn2 = (TreeTableColumn<?, ?>) obj2;
                    int childrenColumns2 = tableColumn2.getColumns().size();
                    if (childrenColumns2 != 0) {
                        for (TreeTableColumn<?, ?> col2 : tableColumn2.getColumns()) {
                            if (col.getText().equals(col2.getText())) {
                                cb.selectedProperty().bindBidirectional(col2.visibleProperty());
                            // cb.setSelected(true);
                            // cb.selectedProperty().addListener(
                            // new ChangeListener<Boolean>() {
                            // public void changed(
                            // ObservableValue<? extends Boolean> ov,
                            // Boolean old_val,
                            // Boolean new_val) {
                            // col2.setVisible(new_val);
                            // }
                            // });
                            }
                        }
                    }
                }
                cmi = new CustomMenuItem(cb);
                cmi.setHideOnClick(false);
                cm.getItems().add(cmi);
            }
            // Separator
            cm.getItems().add(new SeparatorMenuItem());
        }
        if (childrenColumns == 0) {
            cb = new CheckBox(tableColumn.getText());
            cb.selectedProperty().bindBidirectional(tableColumn.visibleProperty());
            cmi = new CustomMenuItem(cb);
            cmi.setHideOnClick(false);
            cm.getItems().add(cmi);
        }
    }
    return cm;
}

/**
	 * Update menu items of button "Assign".
	 */
private void initMenuItemsOfButtonAssign() {
    try {
        ObservableList<MenuItem> items = bnAssignSelection.getItems();
        items.remove(1, items.size());
        if (!issue.isNew()) {
            IssueService srv = Globals.getIssueService();
            final String resourceText = resb.getString("bnCreateSubtask.text");
            boolean hasSeparator = false;
            for (IdName subtaskType : srv.getSubtaskTypes(issue)) {
                if (!hasSeparator) {
                    items.add(new SeparatorMenuItem());
                    hasSeparator = true;
                }
                MenuItem mnCreateSubtask = new MenuItem();
                mnCreateSubtask.setText(MessageFormat.format(resourceText, subtaskType.getName()));
                mnCreateSubtask.setGraphic(new ImageView(subtaskType.getImage()));
                mnCreateSubtask.setOnAction(( e) -> {
                    onCreateSubtask(subtaskType);
                });
                items.add(mnCreateSubtask);
            }
        }
    } catch (Exception e) {
    }
}

/**
	 * Builds the menu.
	 *
	 * @return Menu for JSkat
	 */
public static MenuBar build() {
    JSkatResourceBundle strings = JSkatResourceBundle.INSTANCE;
    MenuBar menuBar = new MenuBar();
    Menu fileMenu = new Menu(strings.getString("file"));
    MenuItem loadSeriesMenuItem = new MenuItem(strings.getString("load_series"));
    loadSeriesMenuItem.setGraphic(JSkatGraphicRepository.INSTANCE.getImageView(Icon.LOAD, IconSize.SMALL));
    MenuItem saveSeriesMenuItem = new MenuItem(strings.getString("save_series"));
    saveSeriesMenuItem.setGraphic(JSkatGraphicRepository.INSTANCE.getImageView(Icon.SAVE, IconSize.SMALL));
    MenuItem saveSeriesAsMenuItem = new MenuItem(strings.getString("save_series_as"));
    saveSeriesAsMenuItem.setGraphic(JSkatGraphicRepository.INSTANCE.getImageView(Icon.SAVE_AS, IconSize.SMALL));
    MenuItem exitJSkatMenuItem = new MenuItem(strings.getString("exit_jskat"));
    exitJSkatMenuItem.setGraphic(JSkatGraphicRepository.INSTANCE.getImageView(Icon.EXIT, IconSize.SMALL));
    exitJSkatMenuItem.setOnAction( actionEvent -> JSkatMaster.INSTANCE.exitJSkat());
    fileMenu.getItems().addAll(loadSeriesMenuItem, saveSeriesMenuItem, saveSeriesAsMenuItem, new SeparatorMenuItem(), exitJSkatMenuItem);
    Menu skatTableMenu = new Menu(strings.getString("skat_table"));
    //$NON-NLS-1$
    MenuItem playOnLocalTable = new MenuItem(strings.getString("play_on_local_table"));
    playOnLocalTable.setGraphic(JSkatGraphicRepository.INSTANCE.getImageView(Icon.TABLE, IconSize.SMALL));
    playOnLocalTable.setOnAction( actionEvent -> JSkatMaster.INSTANCE.createTable());
    //$NON-NLS-1$
    MenuItem startSkatSeriesMenuItem = new MenuItem(strings.getString("start_series"));
    startSkatSeriesMenuItem.setOnAction( actionEvent -> JSkatEventBus.INSTANCE.post(new CreateSkatSeriesCommand()));
    startSkatSeriesMenuItem.setGraphic(JSkatGraphicRepository.INSTANCE.getImageView(Icon.PLAY, IconSize.SMALL));
    MenuItem replayGameMenuItem = new MenuItem(strings.getString("replay_game"));
    replayGameMenuItem.setOnAction( actionEvent -> JSkatEventBus.TABLE_EVENT_BUSSES.get(JSkatApplicationData.INSTANCE.getActiveTable()).post(new ReplayGameCommand()));
    replayGameMenuItem.setGraphic(JSkatGraphicRepository.INSTANCE.getImageView(Icon.FIRST, IconSize.SMALL));
    MenuItem nextReplayMoveMenuItem = new MenuItem(strings.getString("next_replay_move"));
    nextReplayMoveMenuItem.setOnAction( actionEvent -> JSkatEventBus.TABLE_EVENT_BUSSES.get(JSkatApplicationData.INSTANCE.getActiveTable()).post(new NextReplayMoveCommand()));
    nextReplayMoveMenuItem.setGraphic(JSkatGraphicRepository.INSTANCE.getImageView(Icon.NEXT, IconSize.SMALL));
    skatTableMenu.getItems().addAll(playOnLocalTable, new SeparatorMenuItem(), startSkatSeriesMenuItem, new SeparatorMenuItem(), replayGameMenuItem, nextReplayMoveMenuItem);
    Menu neuralNetworksMenu = new Menu(strings.getString("neural_networks"));
    MenuItem loadNeuralNetworksMenuItem = new MenuItem(strings.getString("load_nn"));
    loadNeuralNetworksMenuItem.setGraphic(JSkatGraphicRepository.INSTANCE.getImageView(Icon.LOAD, IconSize.SMALL));
    loadNeuralNetworksMenuItem.setOnAction( actionEvent -> JSkatMaster.INSTANCE.loadNeuralNetworks());
    MenuItem saveNeuralNetworksMenuItem = new MenuItem(strings.getString("save_nn"));
    saveNeuralNetworksMenuItem.setGraphic(JSkatGraphicRepository.INSTANCE.getImageView(Icon.SAVE, IconSize.SMALL));
    saveNeuralNetworksMenuItem.setOnAction( actionEvent -> JSkatMaster.INSTANCE.saveNeuralNetworks());
    MenuItem resetNeuralNetworksMenuItem = new MenuItem(strings.getString("reset_nn"));
    resetNeuralNetworksMenuItem.setOnAction( actionEvent -> JSkatMaster.INSTANCE.resetNeuralNetworks());
    resetNeuralNetworksMenuItem.setGraphic(JSkatGraphicRepository.INSTANCE.getImageView(Icon.UNDO, IconSize.SMALL));
    MenuItem trainNeuralNetworksMenuItem = new MenuItem(strings.getString("train_nn"));
    trainNeuralNetworksMenuItem.setOnAction( actionEvent -> JSkatMaster.INSTANCE.trainNeuralNetworks());
    trainNeuralNetworksMenuItem.setGraphic(JSkatGraphicRepository.INSTANCE.getImageView(Icon.TRAIN_NN, IconSize.SMALL));
    MenuItem stopTrainNeuralNetworksMenuItem = new MenuItem(strings.getString("stop_train_nn"));
    stopTrainNeuralNetworksMenuItem.setOnAction( actionEvent -> JSkatMaster.INSTANCE.stopTrainNeuralNetworks());
    stopTrainNeuralNetworksMenuItem.setGraphic(JSkatGraphicRepository.INSTANCE.getImageView(Icon.PAUSE, IconSize.SMALL));
    neuralNetworksMenu.getItems().addAll(loadNeuralNetworksMenuItem, saveNeuralNetworksMenuItem, new SeparatorMenuItem(), resetNeuralNetworksMenuItem, trainNeuralNetworksMenuItem, stopTrainNeuralNetworksMenuItem);
    Menu issMenu = new Menu(strings.getString("iss"));
    MenuItem playOnIssMenuItem = new MenuItem(strings.getString("play_on_iss"));
    playOnIssMenuItem.setOnAction( actionEvent -> JSkatMaster.INSTANCE.getIssController().showISSLoginPanel());
    playOnIssMenuItem.setGraphic(JSkatGraphicRepository.INSTANCE.getImageView(Icon.CONNECT_ISS, IconSize.SMALL));
    MenuItem createNewTableOnIssMenuItem = new MenuItem(strings.getString("new_table"));
    createNewTableOnIssMenuItem.setOnAction( actionEvent -> JSkatMaster.INSTANCE.getIssController().requestTableCreation());
    createNewTableOnIssMenuItem.setGraphic(JSkatGraphicRepository.INSTANCE.getImageView(Icon.TABLE, IconSize.SMALL));
    MenuItem invitePlayerMenuItem = new MenuItem(strings.getString("invite"));
    invitePlayerMenuItem.setOnAction( actionEvent -> JSkatMaster.INSTANCE.invitePlayer());
    invitePlayerMenuItem.setGraphic(JSkatGraphicRepository.INSTANCE.getImageView(Icon.INVITE, IconSize.SMALL));
    issMenu.getItems().addAll(playOnIssMenuItem, new SeparatorMenuItem(), createNewTableOnIssMenuItem, invitePlayerMenuItem);
    Menu extrasMenu = new Menu(strings.getString("extras"));
    MenuItem preferencesMenuItem = new MenuItem(strings.getString("preferences"));
    preferencesMenuItem.setOnAction( actionEvent -> JSkatEventBus.INSTANCE.post(new ShowPreferencesCommand()));
    preferencesMenuItem.setGraphic(JSkatGraphicRepository.INSTANCE.getImageView(Icon.PREFERENCES, IconSize.SMALL));
    extrasMenu.getItems().addAll(preferencesMenuItem);
    Menu helpMenu = new Menu(strings.getString("help"));
    MenuItem helpMenuItem = new MenuItem(strings.getString("help"));
    helpMenuItem.setOnAction( actionEvent -> JSkatEventBus.INSTANCE.post(new ShowHelpCommand()));
    helpMenuItem.setGraphic(JSkatGraphicRepository.INSTANCE.getImageView(Icon.HELP, IconSize.SMALL));
    MenuItem licenseMenuItem = new MenuItem(strings.getString("license"));
    licenseMenuItem.setOnAction( actionEvent -> JSkatEventBus.INSTANCE.post(new ShowLicenseCommand()));
    licenseMenuItem.setGraphic(JSkatGraphicRepository.INSTANCE.getImageView(Icon.LICENSE, IconSize.SMALL));
    MenuItem aboutMenuItem = new MenuItem(strings.getString("about"));
    aboutMenuItem.setOnAction( actionEvent -> JSkatEventBus.INSTANCE.post(new ShowAboutInformationCommand()));
    aboutMenuItem.setGraphic(JSkatGraphicRepository.INSTANCE.getImageView(Icon.ABOUT, IconSize.SMALL));
    helpMenu.getItems().addAll(helpMenuItem, new SeparatorMenuItem(), licenseMenuItem, aboutMenuItem);
    menuBar.getMenus().addAll(fileMenu, skatTableMenu, neuralNetworksMenu, issMenu, extrasMenu, helpMenu);
    return menuBar;
}

/**
     * Fill panel with currently submitted tasks. Add listeners on
     * {@link TaskManager} to be aware of new events.
     */
private void initTasks() {
    final MenuItem clearErrorItem = new MenuItem(GeotkFX.getString(ProgressMonitor.class, "cleanErrorList"));
    clearErrorItem.setOnAction( evt -> taskRegistry.getTasksInError().clear());
    final Label icon = new Label(FontAwesomeIcons.ICON_TRASH_O);
    icon.setStyle(ICON_LABEL_FONT_FAMILY);
    clearErrorItem.setGraphic(icon);
    clearErrorItem.getStyleClass().add(CLEAR_MENU_ITEM_CSS_CLASS);
    tasksInError.getItems().add(clearErrorItem);
    tasksInError.getItems().add(new SeparatorMenuItem());
    // Listen on current running tasks
    final ObservableList<Task> tmpSubmittedTasks = taskRegistry.getSubmittedTasks();
    tmpSubmittedTasks.addListener((ListChangeListener.Change<? extends Task> c) -> {
        final Set<Task> toAdd = new HashSet<>();
        final Set<Task> toRemove = new HashSet<>();
        storeChanges(c, toAdd, toRemove);
        Platform.runLater(() -> {
            for (final Task task : toAdd) {
                final CustomMenuItem item = new CustomMenuItem(new TaskProgress(task));
                item.setHideOnClick(false);
                runningTasks.getItems().add(item);
            }
            // remove Ended tasks
            runningTasks.getItems().removeIf(new GetItemsForTask(toRemove));
        });
    });
    // Check failed tasks.
    final ObservableList<Task> tmpTasksInError = taskRegistry.getTasksInError();
    tmpTasksInError.addListener((ListChangeListener.Change<? extends Task> c) -> {
        final Set<Task> toAdd = new HashSet<>();
        final Set<Task> toRemove = new HashSet<>();
        storeChanges(c, toAdd, toRemove);
        Platform.runLater(() -> {
            for (final Task task : toAdd) {
                tasksInError.getItems().add(new ErrorMenuItem(task));
            }
            // remove Ended tasks
            tasksInError.getItems().removeIf(new GetItemsForTask(toRemove));
        });
    });
    final Runnable initPanel = () -> {
        final int nbSubmitted = tmpSubmittedTasks.size();
        // do not add last task to our menu, it will be used on main display.
        for (int i = 0; i < nbSubmitted; i++) {
            final CustomMenuItem item = new CustomMenuItem(new TaskProgress(tmpSubmittedTasks.get(i)));
            item.setHideOnClick(false);
            runningTasks.getItems().add(item);
        }
        for (final Task t : tmpTasksInError) {
            tasksInError.getItems().add(new ErrorMenuItem(t));
        }
    };
    if (Platform.isFxApplicationThread()) {
        initPanel.run();
    } else {
        Platform.runLater(initPanel);
    }
}

@Override
public boolean isSeparator() {
    final MenuItem item = getRealComponent();
    return //$NON-NLS-1$
    EventThreadQueuerJavaFXImpl.invokeAndWait(//$NON-NLS-1$
    "hasSubMenu", new Callable<Boolean>() {

        @Override
        public Boolean call() throws Exception {
            return item instanceof SeparatorMenuItem;
        }
    });
}

/**
	 * Create context menu for the subscription tab.
	 * 
	 * @param connection The connection associated with the tab
	 * @param subscription The subscription associated with the tab
	 * @param eventManager The global event manager
	 * @param subscriptionManager The connection's subscription manager 
	 * @param configurationManager The global configuration manager
	 * @param subscriptionController The subscription controller for this subscription
	 * 
	 * @return The created context menu
	 */
public static ContextMenu createSubscriptionTabContextMenu(final MqttAsyncConnection connection, final MqttSubscription subscription, final IKBus eventBus, final SubscriptionManager subscriptionManager, final ConfigurationManager configurationManager, final SubscriptionController subscriptionController) {
    final ContextMenu contextMenu = new ContextMenu();
    // Cancel
    MenuItem cancelItem = new MenuItem("Unsubscribe (and keep the tab)");
    cancelItem.setDisable(false);
    cancelItem.setOnAction(new EventHandler<ActionEvent>() {

        public void handle(ActionEvent e) {
            connection.unsubscribe(subscription, true);
        }
    });
    contextMenu.getItems().add(cancelItem);
    // Re-subscribe
    MenuItem resubscribeItem = new MenuItem("Re-subscribe");
    resubscribeItem.setDisable(true);
    resubscribeItem.setOnAction(new EventHandler<ActionEvent>() {

        public void handle(ActionEvent e) {
            connection.resubscribe(subscription);
        }
    });
    contextMenu.getItems().add(resubscribeItem);
    // Close
    MenuItem closeItem = new MenuItem("Unsubscribe (and close tab)");
    closeItem.setOnAction(new EventHandler<ActionEvent>() {

        public void handle(ActionEvent e) {
            subscriptionManager.removeSubscription(subscription.getTopic());
        }
    });
    contextMenu.getItems().add(closeItem);
    // Separator
    contextMenu.getItems().add(new SeparatorMenuItem());
    // Copy subscription topic string
    final MenuItem copyTopicItem = new MenuItem("Copy subscription topic to clipboard");
    copyTopicItem.setOnAction(new EventHandler<ActionEvent>() {

        public void handle(ActionEvent e) {
            UiUtils.copyToClipboard(subscription.getTopic());
        }
    });
    contextMenu.getItems().add(copyTopicItem);
    // Separator
    contextMenu.getItems().add(new SeparatorMenuItem());
    // Clear data
    MenuItem clearItem = new MenuItem("Clear subscription history");
    clearItem.setOnAction(new EventHandler<ActionEvent>() {

        public void handle(ActionEvent e) {
            eventBus.publish(new ClearTabEvent(subscription.getStore()));
            // eventManager.notifyClearHistory(subscription.getStore());
            StatisticsManager.resetMessagesReceived(connection.getId(), subscription.getTopic());
            subscription.getStore().clear();
        }
    });
    contextMenu.getItems().add(clearItem);
    // Separator
    contextMenu.getItems().add(new SeparatorMenuItem());
    final Menu chartsMenu = new Menu("Charts");
    contextMenu.getItems().add(chartsMenu);
    // Message load charts
    MenuItem messageLoadChartItem = new MenuItem("Show message load chart");
    messageLoadChartItem.setOnAction(new EventHandler<ActionEvent>() {

        public void handle(ActionEvent e) {
            new ChartFactory<FormattedMqttMessage>().createMessageBasedLineChart(Arrays.asList(SubscriptionController.AVG5_TOPIC, SubscriptionController.AVG30_TOPIC, SubscriptionController.AVG300_TOPIC), subscriptionController.getStatsHistory(), ChartMode.USER_DRIVEN_MSG_PAYLOAD, "Series", "Load", "msgs/s", "Message load statistics for " + subscription.getTopic() + " - " + connection.getName(), subscriptionController.getScene(), eventBus);
        }
    });
    chartsMenu.getItems().add(messageLoadChartItem);
    // Message count charts
    MenuItem messageCountChartItem = new MenuItem("Show message count chart");
    messageCountChartItem.setOnAction(new EventHandler<ActionEvent>() {

        public void handle(ActionEvent e) {
            new ChartFactory<FormattedMqttMessage>().createMessageBasedPieChart("Message count statistics for " + subscription.getTopic(), subscriptionController.getScene(), subscriptionController.getSubscription().getStore().getNonFilteredMessageList().getTopicSummary().getObservableMessagesPerTopic());
        }
    });
    chartsMenu.getItems().add(messageCountChartItem);
    final Menu configuration = new Menu("Configuration");
    contextMenu.getItems().add(configuration);
    // Separator
    // configuration.getItems().add(new SeparatorMenuItem());
    // Adds/updates this subscription in the configuration file
    final MenuItem addItem = new MenuItem("Add/update this subscription");
    addItem.setOnAction(new EventHandler<ActionEvent>() {

        public void handle(ActionEvent e) {
            configurationManager.updateSubscriptionConfiguration(connection, subscription);
        }
    });
    configuration.getItems().add(addItem);
    // Removes this subscription from the configuration file
    final MenuItem removeItem = new MenuItem("Remove this subscription");
    removeItem.setOnAction(new EventHandler<ActionEvent>() {

        public void handle(ActionEvent e) {
            configurationManager.deleteSubscriptionConfiguration(connection, subscription);
        }
    });
    configuration.getItems().add(removeItem);
    final Menu view = new Menu("View");
    contextMenu.getItems().add(view);
    // Change color
    final MenuItem changeColorMenu = new MenuItem("Change tab color");
    changeColorMenu.setOnAction(new EventHandler<ActionEvent>() {

        @Override
        public void handle(ActionEvent event) {
            final Color newColor = DialogFactory.createColorChoiceDialog(subscription.getColor(), "Select new subscription color", "Subscription color: ");
            if (!newColor.equals(subscription.getColor())) {
                subscription.setColor(newColor);
                subscription.getSubscriptionController().getTab().setStyle(StylingUtils.createBaseRGBString(newColor));
                // Update subscription tab
                subscription.getSubscriptionController().getSummaryTablePaneController().refreshRowStyling();
                // Update 'all' tab				
                subscriptionManager.getSubscriptionControllersMap().get(SubscriptionManager.ALL_SUBSCRIPTIONS_TAB_TITLE).getSummaryTablePaneController().refreshRowStyling();
            }
        }
    });
    view.getItems().add(changeColorMenu);
    // View
    final MenuItem detachMenu = new MenuItem("Detach to a separate window");
    detachMenu.setOnAction(TabUtils.createTabDetachEvent(detachMenu, subscriptionController, connection.getName() + " - " + subscription.getTopic(), 5));
    view.getItems().add(detachMenu);
    return contextMenu;
}

/**
     * Creates the context menu.
     * 
     * @return The context menu.
     */
private ContextMenu createContextMenu() {
    final ContextMenu menu = new ContextMenu();
    MenuItem zoomIn = new MenuItem("Zoom In");
    zoomIn.setOnAction( e -> {
        handleZoom(this.zoomMultiplier);
    });
    MenuItem zoomOut = new MenuItem("Zoom Out");
    zoomOut.setOnAction( e -> {
        handleZoom(1.0 / this.zoomMultiplier);
    });
    MenuItem zoomToFit = new MenuItem("Zoom To Fit");
    zoomToFit.setOnAction( e -> {
        handleZoomToFit();
    });
    SeparatorMenuItem separator = new SeparatorMenuItem();
    Menu export = new Menu("Export As");
    MenuItem pngItem = new MenuItem("PNG...");
    pngItem.setOnAction( e -> {
        handleExportToPNG();
    });
    export.getItems().add(pngItem);
    MenuItem jpegItem = new MenuItem("JPEG...");
    jpegItem.setOnAction( e -> {
        handleExportToJPEG();
    });
    export.getItems().add(jpegItem);
    // provide a PDF export menu item
    if (ExportFormats.isOrsonPDFAvailable()) {
        MenuItem pdfItem = new MenuItem("PDF...");
        pdfItem.setOnAction( e -> {
            handleExportToPDF();
        });
        export.getItems().add(pdfItem);
    }
    // provide a SVG export menu item
    if (ExportFormats.isJFreeSVGAvailable()) {
        MenuItem svgItem = new MenuItem("SVG...");
        svgItem.setOnAction( e -> {
            handleExportToSVG();
        });
        export.getItems().add(svgItem);
    }
    menu.getItems().addAll(zoomIn, zoomOut, zoomToFit, separator, export);
    return menu;
}

@Override
public void initialize(URL url, ResourceBundle r) {
    topBox.getItems().add(crashReportsButton);
    // TODO: Should we hide these buttons, when disconnected ?
    hideProcessesButton.setGraphic(FAIcon.create().icon(AwesomeIcon.RANDOM));
    hideProcessesButton.setContentDisplay(ContentDisplay.TOP);
    hideProcessesButton.setGraphicTextGap(0d);
    hideProcessesButton.setTooltip(new Tooltip("Show/Hide the Processes (ctrl+p)"));
    // TODO: Should we hide these buttons, when disconnected ?
    hideFunctionsButton.setGraphic(FAIcon.create().icon(AwesomeIcon.CUBE));
    hideFunctionsButton.setContentDisplay(ContentDisplay.TOP);
    hideFunctionsButton.setGraphicTextGap(0d);
    hideFunctionsButton.setTooltip(new Tooltip("Show/Hide the Modules (ctrl+m)"));
    refreshModulesButton.setGraphic(FAIcon.create().icon(AwesomeIcon.ROTATE_LEFT));
    refreshModulesButton.setContentDisplay(ContentDisplay.TOP);
    refreshModulesButton.setGraphicTextGap(0d);
    refreshModulesButton.setTooltip(new Tooltip("Refresh Modules and Functions to show new, hot-loaded code (ctrl+r)"));
    refreshModulesButton.disableProperty().bind(ErlyBerly.nodeAPI().connectedProperty().not());
    erlangMemoryButton.setGraphic(FAIcon.create().icon(AwesomeIcon.PIE_CHART));
    erlangMemoryButton.setContentDisplay(ContentDisplay.TOP);
    erlangMemoryButton.setGraphicTextGap(0d);
    erlangMemoryButton.setTooltip(new Tooltip("Refresh Modules and Functions to show new, hot-loaded code (ctrl+r)"));
    erlangMemoryButton.disableProperty().bind(ErlyBerly.nodeAPI().connectedProperty().not());
    // TODO: maybe make this button available, sometimes, there are crashes causing the node to go down,
    // and then it's disabled when disconnected....( i would like to see the crashes ) :)
    crashReportsButton.setGraphic(crashReportsGraphic());
    crashReportsButton.setContentDisplay(ContentDisplay.LEFT);
    crashReportsButton.setGraphicTextGap(0d);
    crashReportsButton.setTooltip(new Tooltip("View crash reports received from the connected node."));
    // disable the button if we're not connected or there are no crash report menu items
    crashReportsButton.disableProperty().bind(ErlyBerly.nodeAPI().connectedProperty().not().or(Bindings.size(crashReportsButton.getItems()).isEqualTo(2)));
    crashReportsButton.setStyle("-fx-font-size: 10; -fx-padding: 5 5 5 5;");
    crashReportsButton.getItems().addAll(removeCrashReportsMenuItem(), new SeparatorMenuItem());
    ErlyBerly.nodeAPI().getCrashReports().addListener((ListChangeListener.Change<? extends OtpErlangObject> e) -> {
        while (e.next()) {
            for (OtpErlangObject obj : e.getAddedSubList()) {
                CrashReport crashReport = new CrashReport(obj);
                MenuItem menuItem;
                menuItem = new MenuItem();
                menuItem.setGraphic(new CrashReportGraphic(crashReport));
                menuItem.setOnAction(( action) -> {
                    unreadCrashReportsProperty.set(0);
                    ErlyBerly.showPane("Crash Report", ErlyBerly.wrapInPane(crashReportView(crashReport)));
                });
                crashReportsButton.getItems().add(menuItem);
            }
        }
    });
    xrefAnalysisButton.setGraphic(xrefAnalysisGraphic());
    xrefAnalysisButton.setContentDisplay(ContentDisplay.TOP);
    xrefAnalysisButton.setGraphicTextGap(0d);
    xrefAnalysisButton.setTooltip(new Tooltip("Start xref analysis. This may take a while, an ok is displayed when complete."));
    xrefAnalysisButton.disableProperty().bind(ErlyBerly.nodeAPI().connectedProperty().not().or(isXrefAnalysing).or(ErlyBerly.nodeAPI().xrefStartedProperty()));
    xrefAnalysisButton.setOnAction(( e) -> {
        try {
            ErlyBerly.nodeAPI().asyncEnsureXRefStarted();
            isXrefAnalysing.set(true);
        } catch (Exception e1) {
            e1.printStackTrace();
        }
    });
    disconnectButton.setGraphic(FAIcon.create().icon(AwesomeIcon.EJECT));
    disconnectButton.setContentDisplay(ContentDisplay.TOP);
    disconnectButton.setGraphicTextGap(0d);
    disconnectButton.setTooltip(new Tooltip("Disconnect"));
    disconnectButton.disableProperty().bind(ErlyBerly.nodeAPI().connectedProperty().not());
    disconnectButton.setOnAction(( e) -> {
        try {
            disconnect();
        } catch (Exception e1) {
            e1.printStackTrace();
        }
    });
    prefButton.setGraphic(FAIcon.create().icon(AwesomeIcon.GEARS));
    prefButton.setContentDisplay(ContentDisplay.TOP);
    prefButton.setGraphicTextGap(0d);
    prefButton.setTooltip(new Tooltip("Preferences"));
    prefButton.disableProperty().bind(ErlyBerly.nodeAPI().connectedProperty().not());
    prefButton.setOnAction(( e) -> {
        displayPreferencesPane();
    });
    suspendButton.setContentDisplay(ContentDisplay.TOP);
    suspendButton.setGraphicTextGap(0d);
    suspendButton.setTooltip(new Tooltip("Toggle Trace Suspension"));
    suspendButton.disableProperty().bind(ErlyBerly.nodeAPI().connectedProperty().not());
    suspendButton.setOnAction(( e) -> {
        suspendTraces();
    });
    // set the default text and icon
    onSuspendedStateChanged(false);
    // listen to when tracing is suspend or not, and update the button text and icon
    ErlyBerly.nodeAPI().suspendedProperty().addListener(( o,  oldv,  suspended) -> {
        onSuspendedStateChanged(suspended);
    });
    hideProcsProperty().addListener((Observable o) -> {
        toggleHideProcs();
    });
    hideFunctionsProperty().addListener((Observable o) -> {
        toggleHideFuncs();
    });
    erlangMemoryButton.setOnAction(( e) -> {
        showErlangMemory();
    });
    FxmlLoadable loader = processCountStat();
    topBox.getItems().add(new Separator(Orientation.VERTICAL));
    topBox.getItems().add(loader.fxmlNode);
    // let's store the ui preferences, as the end user changes them...
    PrefBind.bindBoolean("hideProcesses", hideProcessesButton.selectedProperty());
    PrefBind.bindBoolean("hideModules", hideFunctionsButton.selectedProperty());
    boolean hideProcs = PrefBind.getOrDefaultBoolean("hideProcesses", false);
    boolean hideMods = PrefBind.getOrDefaultBoolean("hideModules", false);
    if (hideProcs) {
        // click the hide button manually.
        hideProcessesButton.setSelected(true);
    }
    if (hideMods) {
        // click the hide button manually.
        hideFunctionsButton.setSelected(true);
    }
    toggleHideProcs();
    toggleHideFuncs();
    ErlyBerly.nodeAPI().getCrashReports().addListener(this::traceLogsChanged);
    ErlyBerly.nodeAPI().xrefStartedProperty().addListener(( e,  oldv,  newv) -> {
        if (newv)
            isXrefAnalysing.set(false);
    });
}

/**
	 * Create the context menu of an overlay button.
	 *
	 * @param position
	 *            The position of the button.
	 * @param forNewButton
	 *            Flag indicating the popup is displayed for a new button. Then it is enforced to select a new overlay.
	 * @return the context menu.
	 */
private ContextMenu createOverlayButtonContextMenu(final int position, final boolean forNewButton) {
    ToggleButton button = mOverlayButtons[position];
    ContextMenu menu = new ContextMenu();
    if (position == getHighestOverlayButtonIndex()) {
        if (position > 1) {
            MenuItem menuItemRemove = new MenuItem();
            menuItemRemove.setText(ResourceUtil.getString(ResourceConstants.MENU_REMOVE_OVERLAY_BUTTON));
            menuItemRemove.setOnAction(new EventHandler<ActionEvent>() {

                @Override
                public void handle(final ActionEvent event) {
                    mOverlayButtons[position].setSelected(false);
                    handleBtnOverlayPressed(mOverlayButtons[position]);
                    PreferenceUtil.setIndexedPreference(KEY_INDEXED_OVERLAY_TYPE, position, -1);
                    mOverlayButtons[position].setVisible(false);
                    mOverlayButtons[position].setManaged(false);
                    createOverlayButtonContextMenus();
                }
            });
            menu.getItems().add(menuItemRemove);
        }
        if (position < OVERLAY_BUTTON_COUNT) {
            MenuItem menuItemAdd = new MenuItem();
            menuItemAdd.setText(ResourceUtil.getString(ResourceConstants.MENU_ADD_OVERLAY_BUTTON));
            menuItemAdd.setOnAction(new EventHandler<ActionEvent>() {

                @Override
                public void handle(final ActionEvent event) {
                    ContextMenu contextMenu = createOverlayButtonContextMenu(position + 1, true);
                    contextMenu.show(button, menu.getAnchorX(), menu.getAnchorY());
                }
            });
            menu.getItems().add(menuItemAdd);
        }
        menu.getItems().add(new SeparatorMenuItem());
    }
    MenuItem[] secondaryMenuItems = new MenuItem[OVERLAY_BUTTON_COUNT];
    for (int i = 1; i <= OVERLAY_COUNT; i++) {
        final int index = i;
        final Integer oldButtonPosition = getButtonForOverlayWithIndex(i);
        MenuItem menuItem = null;
        if (oldButtonPosition == null) {
            menuItem = new MenuItem();
            menuItem.setText(OVERLAY_NAMES[i - 1]);
            menu.getItems().add(menuItem);
        } else {
            if (!forNewButton) {
                menuItem = new MenuItem();
                menuItem.setText(OVERLAY_BUTTON_STRINGS[oldButtonPosition - 1] + " " + OVERLAY_NAMES[i - 1]);
                if (oldButtonPosition == position) {
                    menuItem.getStyleClass().add("bold");
                }
                secondaryMenuItems[oldButtonPosition - 1] = menuItem;
            }
        }
        if (menuItem != null) {
            menuItem.setOnAction(new EventHandler<ActionEvent>() {

                @Override
                public void handle(final ActionEvent event) {
                    if (oldButtonPosition != null && oldButtonPosition != position) {
                        // If the same overlay is already used, switch overlays
                        int currentOverlay = PreferenceUtil.getIndexedPreferenceInt(KEY_INDEXED_OVERLAY_TYPE, position, -1);
                        PreferenceUtil.setIndexedPreference(KEY_INDEXED_OVERLAY_TYPE, oldButtonPosition, currentOverlay);
                    }
                    PreferenceUtil.setIndexedPreference(KEY_INDEXED_OVERLAY_TYPE, position, index);
                    mOverlayButtons[position].setSelected(true);
                    mOverlayButtons[position].setVisible(true);
                    mOverlayButtons[position].setManaged(true);
                    handleBtnOverlayPressed(mOverlayButtons[position]);
                    createOverlayButtonContextMenus();
                }
            });
        }
    }
    for (MenuItem menuItem : secondaryMenuItems) {
        if (menuItem != null) {
            menu.getItems().add(menuItem);
        }
    }
    return menu;
}

/**
     * Manage buttons and menu items
     */
void initDecoration() {
    MenuItem minimizeMenuItem = null;
    // Menu
    final ContextMenu contextMenu = new ContextMenu();
    contextMenu.setAutoHide(true);
    if (minimize != null) {
        // Utility Stage
        minimizeMenuItem = new MenuItem(LOC.getString("Minimize"));
        minimizeMenuItem.setAccelerator(new KeyCodeCombination(KeyCode.M, KeyCombination.SHORTCUT_DOWN));
        minimizeMenuItem.setOnAction( e -> switchMinimize());
        contextMenu.getItems().add(minimizeMenuItem);
    }
    if (maximize != null && stage.isResizable()) {
        // Utility Stage type
        maximizeMenuItem = new MenuItem(LOC.getString("Maximize"));
        maximizeMenuItem.setOnAction( e -> {
            switchMaximize();
            contextMenu.hide();
        });
        contextMenu.getItems().addAll(maximizeMenuItem, new SeparatorMenuItem());
    }
    // Fullscreen
    if (stageStyle != StageStyle.UTILITY && stage.isResizable()) {
        fullScreenMenuItem = new CheckMenuItem(LOC.getString("FullScreen"));
        fullScreenMenuItem.setOnAction( e -> switchFullscreen());
        fullScreenMenuItem.setAccelerator(new KeyCodeCombination(KeyCode.F, KeyCombination.CONTROL_DOWN, KeyCombination.SHORTCUT_DOWN));
        contextMenu.getItems().addAll(fullScreenMenuItem, new SeparatorMenuItem());
    }
    // Close
    MenuItem closeMenuItem = new MenuItem(LOC.getString("Close"));
    closeMenuItem.setOnAction( e -> switchClose());
    closeMenuItem.setAccelerator(new KeyCodeCombination(KeyCode.W, KeyCombination.SHORTCUT_DOWN));
    contextMenu.getItems().add(closeMenuItem);
    menu.setOnMousePressed( t -> {
        if (contextMenu.isShowing()) {
            contextMenu.hide();
        } else {
            contextMenu.show(menu, Side.BOTTOM, 0, 0);
        }
    });
    // Close button
    close.setTooltip(new Tooltip(LOC.getString("Close")));
    close.setOnAction( t -> switchClose());
    // Maximize button
    // If changed via contextual menu
    maximizeProperty().addListener(( ov,  t,  t1) -> {
        Tooltip tooltip = maximize.getTooltip();
        if (tooltip.getText().equals(LOC.getString("Maximize"))) {
            tooltip.setText(LOC.getString("Restore"));
            maximizeMenuItem.setText(LOC.getString("Restore"));
            maximize.getStyleClass().add("decoration-button-restore");
            resize.setVisible(false);
        } else {
            tooltip.setText(LOC.getString("Maximize"));
            maximizeMenuItem.setText(LOC.getString("Maximize"));
            maximize.getStyleClass().remove("decoration-button-restore");
            resize.setVisible(true);
        }
    });
    if (maximize != null) {
        // Utility Stage
        maximize.setTooltip(new Tooltip(LOC.getString("Maximize")));
        maximize.setOnAction( t -> switchMaximize());
    }
    if (fullscreen != null) {
        // Utility Stage
        fullscreen.setTooltip(new Tooltip(LOC.getString("FullScreen")));
        fullscreen.setOnAction( t -> switchFullscreen());
    }
    // Minimize button
    if (minimize != null) {
        // Utility Stage
        minimize.setTooltip(new Tooltip(LOC.getString("Minimize")));
        minimize.setOnAction( t -> switchMinimize());
    }
    // Transfer stage title to undecorator tiltle label
    title.setText(stage.getTitle());
}

public void show() {
    final Stage dialog = new Stage();
    dialog.setResizable(true);
    dialog.setTitle("Bioalcidae for " + getNgsFile().getSource());
    final VBox contentPane = new VBox(5);
    VBox.setVgrow(contentPane, Priority.ALWAYS);
    final Menu fileMenu = new Menu("File");
    MenuItem menu = new MenuItem("Save script as...");
    menu.setOnAction( AE -> {
    });
    fileMenu.getItems().add(menu);
    menu = new MenuItem("Load Script ...");
    menu.setOnAction( AE -> {
        actionLoadScript(dialog, this.scriptArea);
    });
    fileMenu.getItems().add(menu);
    menu = new MenuItem("Validate Script ...");
    menu.setOnAction( AE -> {
        actionValidateScript(dialog, this.scriptArea);
    });
    fileMenu.getItems().add(menu);
    menu = new MenuItem("Run To File");
    menu.setOnAction( AE -> {
        execute(dialog, true);
    });
    fileMenu.getItems().add(menu);
    menu = new MenuItem("Run To Dialog");
    menu.setOnAction( AE -> {
        execute(dialog, false);
    });
    fileMenu.getItems().add(menu);
    fileMenu.getItems().add(new SeparatorMenuItem());
    menu = new MenuItem("Close");
    menu.setOnAction( AE -> {
        dialog.hide();
    });
    fileMenu.getItems().add(menu);
    /** snippets */
    final Menu snippetmenu = new Menu("Snippets");
    loadSnippets().stream().filter( C -> C.isBioalcidaeScope()).forEach( C -> {
        final MenuItem item = new MenuItem(C.label + (C.function ? "[Function]" : ""));
        item.setOnAction(C.handler(AbstractAwkLike.this.scriptArea));
        snippetmenu.getItems().add(item);
    });
    final MenuBar menuBar = new MenuBar(fileMenu, snippetmenu);
    contentPane.getChildren().add(menuBar);
    final FlowPane top = new FlowPane(5, 5);
    Button button = new Button("Save Script as...");
    button.setOnAction( AE -> {
        actionSaveScript(dialog, this.scriptArea);
    });
    top.getChildren().add(button);
    button = new Button("Open Script as ...");
    button.setOnAction( AE -> {
        actionLoadScript(dialog, this.scriptArea);
    });
    top.getChildren().add(button);
    button = new Button("Validate");
    button.setTooltip(new Tooltip("Validate javascript syntax"));
    button.setOnAction( AE -> {
        actionValidateScript(dialog, this.scriptArea);
    });
    top.getChildren().add(button);
    contentPane.getChildren().add(top);
    contentPane.getChildren().add(new Separator(Orientation.HORIZONTAL));
    final BorderPane scriptPane = new BorderPane(this.scriptArea);
    scriptPane.setPadding(new Insets(5));
    scriptPane.setMaxHeight(Double.MAX_VALUE);
    scriptPane.setMaxWidth(Double.MAX_VALUE);
    contentPane.getChildren().add(scriptPane);
    contentPane.getChildren().add(new Separator(Orientation.HORIZONTAL));
    final FlowPane helpLabel = new FlowPane(getHelpString());
    contentPane.getChildren().add(helpLabel);
    final HBox buttonPane = new HBox(5);
    buttonPane.setPadding(new Insets(5));
    button = new Button("Run To File....");
    button.setTooltip(new Tooltip("Run the process and save the result in a new file"));
    button.setFont(Font.font(button.getFont().getFamily(), 24));
    button.setTextFill(Color.GREEN);
    button.setOnAction( AE -> {
        execute(dialog, true);
    });
    buttonPane.getChildren().add(button);
    button = new Button("Run To Dialog....");
    button.setTextFill(Color.GREEN);
    button.setTooltip(new Tooltip("Run the process and display the result in a new window"));
    button.setFont(Font.font(button.getFont().getFamily(), 24));
    button.setOnAction( AE -> {
        execute(dialog, false);
    });
    buttonPane.getChildren().add(button);
    button = new Button("Stop");
    button.setTextFill(Color.RED);
    button.setTooltip(new Tooltip("Stop current running process"));
    button.setFont(Font.font(button.getFont().getFamily(), 24));
    button.setOnAction( AE -> {
        stopRunner();
    });
    buttonPane.getChildren().add(button);
    contentPane.getChildren().add(buttonPane);
    contentPane.getChildren().add(this.progessLabel);
    dialog.setScene(new Scene(contentPane));
    dialog.initOwner(NgsStage.this);
    dialog.initModality(Modality.APPLICATION_MODAL);
    dialog.showAndWait();
}

/**
     * 建立新的{@link javafx.scene.control.SeparatorMenuItem}建構器。
     *
     * @return 新的{@link javafx.scene.control.SeparatorMenuItemMaker}
     */
@SuppressWarnings({ "rawtypes", "unchecked" })
public static javafx.scene.control.SeparatorMenuItemMaker<javafx.scene.control.SeparatorMenuItem, ?> separatorMenuItem() {
    return new javafx.scene.control.SeparatorMenuItemMaker();
}