server

rebuild

Download Browse

+2 −2

Author

Debayan Sutradhar (rnayabed) 2021-06-29 09:23

Committer

Debayan Sutradhar (rnayabed) 2021-06-29 09:23

Hash 7524655337e2361dd91a1e46c6fde0f607aaf611

Parent dd53aca145163aa0addafb1ec0ded3fed3eae14f

Reference git #server/7524655337e2361dd91a1e46c6fde0f607aaf611

Modified Files

List

Side by side diff

Inline diff

M src/main/java/com/stream_pi/server/window/dashboard/actiongridpane/ActionBox.java

+1 −1

package com.stream_pi.server.window.dashboard.actiongridpane;

import com.stream_pi.action_api.action.Action;

import com.stream_pi.action_api.action.ActionType;

import com.stream_pi.action_api.action.DisplayTextAlignment;

import com.stream_pi.action_api.action.Location;

import com.stream_pi.action_api.actionproperty.ClientProperties;

import com.stream_pi.action_api.externalplugin.ExternalPlugin;

import com.stream_pi.server.controller.ActionDataFormats;

import com.stream_pi.server.window.ExceptionAndAlertHandler;

import com.stream_pi.server.window.dashboard.actiondetailpane.ActionDetailsPaneListener;

import com.stream_pi.util.exception.MinorException;

import javafx.application.Platform;

import javafx.concurrent.Task;

import javafx.geometry.Pos;

import javafx.scene.CacheHint;

import javafx.scene.control.ContextMenu;

import javafx.scene.control.Label;

import javafx.scene.control.Menu;

import javafx.scene.control.MenuItem;

import javafx.scene.image.Image;

import javafx.scene.input.ClipboardContent;

import javafx.scene.input.Dragboard;

import javafx.scene.input.MouseButton;

import javafx.scene.input.TransferMode;

import javafx.scene.layout.Background;

import javafx.scene.layout.BackgroundImage;

import javafx.scene.layout.BackgroundPosition;

import javafx.scene.layout.BackgroundRepeat;

import javafx.scene.layout.BackgroundSize;

import javafx.scene.layout.StackPane;

import javafx.scene.text.TextAlignment;

import org.kordamp.ikonli.javafx.FontIcon;

import java.io.ByteArrayInputStream;

import java.io.ObjectInputStream;

import java.nio.ByteBuffer;

import java.util.HashMap;

import java.util.List;

public class ActionBox extends StackPane{

private Label displayTextLabel;

private int row;

private int col;

public void setRow(int row) {

this.row = row;

}

public void setCol(int col) {

this.col = col;

}

public int getRow() {

return row;

}

public int getCol() {

return col;

}

private ActionDetailsPaneListener actionDetailsPaneListener;

private final ActionDetailsPaneListener actionDetailsPaneListener;

public void clear()

{

setStyle(null);

setAction(null);

getStyleClass().clear();

setBackground(Background.EMPTY);

removeFontIcon();

getChildren().clear();

baseInit();

}

public void baseInit()

{

displayTextLabel = new Label();

displayTextLabel.setWrapText(true);

displayTextLabel.setTextAlignment(TextAlignment.CENTER);

displayTextLabel.getStyleClass().add("action_box_display_text_label");

displayTextLabel.prefHeightProperty().bind(heightProperty());

displayTextLabel.prefWidthProperty().bind(widthProperty());

getChildren().addAll(displayTextLabel);

setMinSize(size, size);

setMaxSize(size, size);

getStyleClass().add("action_box");

setIcon(null);

getStyleClass().add("action_box_valid");

setOnDragOver(dragEvent ->

{

if(dragEvent.getDragboard().hasContent(ActionDataFormats.ACTION_TYPE))

{

dragEvent.acceptTransferModes(TransferMode.ANY);

dragEvent.consume();

}

});

setOnDragDropped(dragEvent ->

{

try

{

if(action == null)

{

Dragboard db = dragEvent.getDragboard();

ActionType actionType = (ActionType) db.getContent(ActionDataFormats.ACTION_TYPE);

if(actionType == ActionType.NORMAL || actionType == ActionType.TOGGLE)

{

String moduleName = (String) dragEvent.getDragboard().getContent(ActionDataFormats.MODULE_NAME);

ExternalPlugin newAction = actionGridPaneListener.createNewActionFromExternalPlugin(moduleName);

boolean isNew = (boolean) db.getContent(ActionDataFormats.IS_NEW);

if(isNew)

{

newAction.getClientProperties().resetToDefaults();

newAction.setDisplayText(newAction.getName());

if(newAction.getActionType() == ActionType.TOGGLE)

{

newAction.setShowDisplayText(false);

newAction.setDisplayTextAlignment(DisplayTextAlignment.BOTTOM);

}

else

{

newAction.setShowDisplayText(true);

newAction.setDisplayTextAlignment(DisplayTextAlignment.CENTER);

}

if(actionType == ActionType.TOGGLE)

newAction.setCurrentIconState("false__false");

}

else

{

newAction.setClientProperties((ClientProperties) db.getContent(ActionDataFormats.CLIENT_PROPERTIES));

newAction.setIcons((HashMap<String, byte[]>) db.getContent(ActionDataFormats.ICONS));

newAction.setCurrentIconState((String) db.getContent(ActionDataFormats.CURRENT_ICON_STATE));

newAction.setBgColourHex((String) db.getContent(ActionDataFormats.BACKGROUND_COLOUR));

newAction.setDisplayTextFontColourHex((String) db.getContent(ActionDataFormats.DISPLAY_TEXT_FONT_COLOUR));

newAction.setDisplayText((String) db.getContent(ActionDataFormats.DISPLAY_TEXT));

newAction.setDisplayTextAlignment((DisplayTextAlignment) db.getContent(ActionDataFormats.DISPLAY_TEXT_ALIGNMENT));

newAction.setShowDisplayText((boolean) db.getContent(ActionDataFormats.DISPLAY_TEXT_SHOW));

}

newAction.setLocation(new Location(getRow(),

getCol()));

newAction.setParent(actionGridPaneListener.getCurrentParent());

newAction.setSocketAddressForClient(actionGridPaneListener.getClientConnection().getRemoteSocketAddress());

try

{

newAction.onActionCreate();

}

catch (Exception e)

{

exceptionAndAlertHandler.handleMinorException(new MinorException("Error","onCreate() failed for "+action.getModuleName()+"\n\n"+e.getMessage()));

}

newAction.setProfileID(actionGridPaneListener.getCurrentProfile().getID());

newAction.setSocketAddressForClient(actionGridPaneListener.getClientConnection().getRemoteSocketAddress());

actionGridPaneListener.addActionToCurrentClientProfile(newAction);

setAction(newAction);

init();

actionDetailsPaneListener.onActionClicked(newAction, this);

if(newAction.isHasIcon())

actionDetailsPaneListener.setSendIcon(true);

actionDetailsPaneListener.saveAction(true, false);

}

else

{

Action newAction = actionGridPaneListener.createNewOtherAction(actionType);

newAction.setLocation(new Location(getRow(),

getCol()));

newAction.setParent(actionGridPaneListener.getCurrentParent());

newAction.setProfileID(actionGridPaneListener.getCurrentProfile().getID());

newAction.setSocketAddressForClient(actionGridPaneListener.getClientConnection().getRemoteSocketAddress());

actionGridPaneListener.addActionToCurrentClientProfile(newAction);

setAction(newAction);

init();

actionDetailsPaneListener.onActionClicked(newAction, this);

if(newAction.isHasIcon())

actionDetailsPaneListener.setSendIcon(true);

actionDetailsPaneListener.saveAction(true, false);

}

catch (MinorException e)

{

exceptionAndAlertHandler.handleMinorException(e);

e.printStackTrace();

}

catch (Exception e)

{

e.printStackTrace();

}

});

setOnDragDetected(mouseEvent -> {

if(getAction()!=null)

{

if(getAction().getActionType() == ActionType.NORMAL ||

getAction().getActionType() == ActionType.TOGGLE)

{

Dragboard db = startDragAndDrop(TransferMode.ANY);

ClipboardContent content = new ClipboardContent();

content.put(ActionDataFormats.CLIENT_PROPERTIES, getAction().getClientProperties());

content.put(ActionDataFormats.ICONS, getAction().getIcons());

content.put(ActionDataFormats.CURRENT_ICON_STATE, getAction().getCurrentIconState());

content.put(ActionDataFormats.BACKGROUND_COLOUR, getAction().getBgColourHex());

content.put(ActionDataFormats.DISPLAY_TEXT_FONT_COLOUR, getAction().getDisplayTextFontColourHex());

content.put(ActionDataFormats.DISPLAY_TEXT, getAction().getDisplayText());

content.put(ActionDataFormats.DISPLAY_TEXT_ALIGNMENT, getAction().getDisplayTextAlignment());

content.put(ActionDataFormats.DISPLAY_TEXT_SHOW, getAction().isShowDisplayText());

content.put(ActionDataFormats.IS_NEW, false);

content.put(ActionDataFormats.ACTION_TYPE, getAction().getActionType());

content.put(ActionDataFormats.MODULE_NAME, getAction().getModuleName());

db.setContent(content);

mouseEvent.consume();

}

});

setOnMouseClicked(mouseEvent -> {

if(action != null)

{

if(mouseEvent.getClickCount() == 2 && getAction().getActionType() == ActionType.FOLDER)

{

getActionDetailsPaneListener().onOpenFolderButtonClicked();

}

else

{

try

{

actionDetailsPaneListener.onActionClicked(action, this);

if(mouseEvent.getButton().equals(MouseButton.SECONDARY))

{

actionContextMenu.show(this, mouseEvent.getScreenX(),

mouseEvent.getScreenY());

}

catch (MinorException e)

{

exceptionAndAlertHandler.handleMinorException(e);

e.printStackTrace();

}

});

actionContextMenu = new ContextMenu();

MenuItem deleteActionMenuItem = new MenuItem("Delete Action");

deleteActionMenuItem.getStyleClass().add("action_box_delete_menu_item");

FontIcon deleteIcon = new FontIcon("fas-trash");

deleteIcon.getStyleClass().add("action_box_delete_menu_item_icon");

deleteActionMenuItem.setGraphic(deleteIcon);

deleteActionMenuItem.setOnAction(event-> deleteAction());

showToggleOffMenuItem = new MenuItem("Show Toggle OFF");

showToggleOffMenuItem.getStyleClass().add("action_box_toggle_off_menu_item");

FontIcon toggleOffIcon = new FontIcon("fas-toggle-off");

toggleOffIcon.getStyleClass().add("action_box_toggle_off_menu_item_icon");

showToggleOffMenuItem.setGraphic(toggleOffIcon);

showToggleOffMenuItem.setOnAction(event-> fakeToggle(false));

showToggleOnMenuItem = new MenuItem("Show Toggle ON");

showToggleOnMenuItem.getStyleClass().add("action_box_toggle_on_menu_item");

FontIcon toggleOnIcon = new FontIcon("fas-toggle-on");

toggleOnIcon.getStyleClass().add("action_box_toggle_on_menu_item_icon");

showToggleOnMenuItem.setGraphic(toggleOnIcon);

showToggleOnMenuItem.setOnAction(event-> fakeToggle(true));

actionContextMenu.getItems().addAll(deleteActionMenuItem, showToggleOffMenuItem, showToggleOnMenuItem);

setCache(true);

setCacheHint(CacheHint.QUALITY);

}

private MenuItem showToggleOffMenuItem;

private MenuItem showToggleOnMenuItem;

private void deleteAction()

{

actionDetailsPaneListener.onDeleteButtonClicked();

}

ContextMenu actionContextMenu;

public void setInvalid(boolean invalid)

{

if(invalid)

{

getStyleClass().remove("action_box_valid");

getStyleClass().add("action_box_invalid");

}

else

{

getStyleClass().remove("action_box_invalid");

getStyleClass().add("action_box_valid");

}

public ActionDetailsPaneListener getActionDetailsPaneListener() {

return actionDetailsPaneListener;

}

public ActionGridPaneListener getActionGridPaneListener() {

return actionGridPaneListener;

}

private int size;

private ActionGridPaneListener actionGridPaneListener;

public ActionBox(int size, ActionDetailsPaneListener actionDetailsPaneListener, ActionGridPaneListener actionGridPaneListener,

int col, int row)

{

this.actionGridPaneListener = actionGridPaneListener;

this.actionDetailsPaneListener = actionDetailsPaneListener;

this.size = size;

this.col = col;

this.row = row;

baseInit();

}

public void setIcon(byte[] iconByteArray)

{

removeFontIcon();

if(iconByteArray == null)

{

getStyleClass().remove("action_box_icon_present");

getStyleClass().add("action_box_icon_not_present");

setBackground(null);

}

else

{

getStyleClass().add("action_box_icon_present");

getStyleClass().remove("action_box_icon_not_present");

setBackground(

new Background(

new BackgroundImage(new Image(

new ByteArrayInputStream(iconByteArray), size, size, false, true

), BackgroundRepeat.NO_REPEAT, BackgroundRepeat.NO_REPEAT, BackgroundPosition.CENTER,

new BackgroundSize(100, 100, true, true, true, false))

)

);

}

public void setDefaultToggleIcon(boolean isToggleOn)

{

String styleClass;

if(isToggleOn)

{

styleClass = "action_box_toggle_on";

}

else

{

styleClass = "action_box_toggle_off";

}

setBackground(null);

if(fontIcon!=null)

{

fontIcon.getStyleClass().removeIf(s -> s.equals("action_box_toggle_off") || s.equals("action_box_toggle_on"));

}

else

{

fontIcon = new FontIcon();

fontIcon.setIconSize((int) (size * 0.8));

getChildren().add(fontIcon);

}

fontIcon.getStyleClass().add(styleClass);

fontIcon.toBack();

}

public void removeFontIcon()

{

if(fontIcon!=null)

{

getChildren().remove(fontIcon);

fontIcon = null;

}

FontIcon fontIcon = null;

private Action action = null;

private ExceptionAndAlertHandler exceptionAndAlertHandler;

public ActionBox(int size, Action action, ActionDetailsPaneListener actionDetailsPaneListener, ExceptionAndAlertHandler exceptionAndAlertHandler, ActionGridPaneListener actionGridPaneListener,

int col, int row)

{

this.actionGridPaneListener = actionGridPaneListener;

this.exceptionAndAlertHandler = exceptionAndAlertHandler;

this.action = action;

this.actionDetailsPaneListener = actionDetailsPaneListener;

this.size = size;

this.col = col;

this.row = row;

baseInit();

init();

}

public Action getAction() {

return action;

}

public void setAction(Action action)

{

this.action = action;

}

public void init()

{

init(false);

}

public void init(boolean start)

{

setBackground(null);

setStyle(null);

showToggleOffMenuItem.setVisible(getAction().getActionType() == ActionType.TOGGLE);

showToggleOnMenuItem.setVisible(getAction().getActionType() == ActionType.TOGGLE);

if(getAction().isShowDisplayText())

setDisplayTextLabel(getAction().getDisplayText());

else

setDisplayTextLabel("");

setDisplayTextAlignment(action.getDisplayTextAlignment());

setBackgroundColour(action.getBgColourHex());

setDisplayTextFontColour(action.getDisplayTextFontColourHex());

setInvalid(action.isInvalid());

Platform.runLater(()->{

try {

if(action.getActionType() == ActionType.TOGGLE)

{

fakeToggle(start);

}

else

{

if(action.isHasIcon())

{

if(!action.getCurrentIconState().isBlank())

{

setIcon(action.getCurrentIcon());

}

else

{

setIcon(null);

}

catch (Exception e)

{

e.printStackTrace();

}

});

}

public void fakeToggle(boolean isON)

{

String[] toggleStatesHiddenStatus = action.getCurrentIconState().split("__");

boolean isToggleOffHidden = toggleStatesHiddenStatus[0].equals("true");

boolean isToggleOnHidden = toggleStatesHiddenStatus[1].equals("true");

if(isON) // ON

{

if(action.isHasIcon())

{

boolean isToggleOnPresent = action.getIcons().containsKey("toggle_on");

if(isToggleOnPresent)

{

if(isToggleOnHidden)

{

setDefaultToggleIcon(true);

}

else

{

setIcon(action.getIcons().get("toggle_on"));

}

else

{

setDefaultToggleIcon(true);

}

else

{

setDefaultToggleIcon(true);

}

else // OFF

{

if(action.isHasIcon())

{

boolean isToggleOffPresent = action.getIcons().containsKey("toggle_off");

if(isToggleOffPresent)

{

if(isToggleOffHidden)

{

setDefaultToggleIcon(false);

}

else

{

setIcon(action.getIcons().get("toggle_off"));

}

else

{

setDefaultToggleIcon(false);

}

else

{

setDefaultToggleIcon(false);

}

public void setDisplayTextLabel(String text)

{

displayTextLabel.setText(text);

}

public void setDisplayTextAlignment(DisplayTextAlignment displayTextAlignment)

{

if(displayTextAlignment == DisplayTextAlignment.CENTER)

displayTextLabel.setAlignment(Pos.CENTER);

else if (displayTextAlignment == DisplayTextAlignment.BOTTOM)

displayTextLabel.setAlignment(Pos.BOTTOM_CENTER);

else if (displayTextAlignment == DisplayTextAlignment.TOP)

displayTextLabel.setAlignment(Pos.TOP_CENTER);

}

public void setDisplayTextFontColour(String colour)

{

if(!colour.isEmpty())

displayTextLabel.setStyle("-fx-text-fill : "+colour+";");

}

public void setBackgroundColour(String colour)

{

if(!colour.isEmpty())

setStyle("-fx-background-color : "+colour);

}

public void setSelected(boolean status)

{

if(status)

{

getStyleClass().add("action_box_selected");

}

else

{

getStyleClass().remove("action_box_selected");

}

M src/main/java/com/stream_pi/server/window/settings/GeneralSettings.java

+1 −1

package com.stream_pi.server.window.settings;

import com.stream_pi.action_api.actionproperty.property.FileExtensionFilter;

import com.stream_pi.server.controller.ServerListener;

import com.stream_pi.server.info.StartupFlags;

import com.stream_pi.server.io.Config;

import com.stream_pi.server.window.ExceptionAndAlertHandler;

import com.stream_pi.server.info.ServerInfo;

import com.stream_pi.util.alert.StreamPiAlert;

import com.stream_pi.util.alert.StreamPiAlertListener;

import com.stream_pi.util.alert.StreamPiAlertType;

import com.stream_pi.util.checkforupdates.CheckForUpdates;

import com.stream_pi.util.checkforupdates.UpdateHyperlinkOnClick;

import com.stream_pi.util.exception.MinorException;

import com.stream_pi.util.exception.SevereException;

import com.stream_pi.util.platform.PlatformType;

import com.stream_pi.util.startatboot.StartAtBoot;

import com.stream_pi.util.uihelper.HBoxInputBox;

import com.stream_pi.util.uihelper.HBoxInputBoxWithDirectoryChooser;

import com.stream_pi.util.uihelper.HBoxInputBoxWithFileChooser;

import com.stream_pi.util.uihelper.HBoxWithSpaceBetween;

import javafx.application.HostServices;

import javafx.application.Platform;

import javafx.concurrent.Task;

import javafx.event.ActionEvent;

import javafx.geometry.Insets;

import javafx.geometry.Pos;

import javafx.scene.control.Button;

import javafx.scene.control.Label;

import javafx.scene.control.TextField;

import javafx.scene.layout.*;

import javafx.stage.DirectoryChooser;

import javafx.stage.FileChooser;

import org.controlsfx.control.ToggleSwitch;

import org.kordamp.ikonli.javafx.FontIcon;

import org.w3c.dom.Text;

import java.awt.SystemTray;

import java.io.File;

import java.util.logging.Logger;

public class GeneralSettings extends VBox {

private final TextField serverNameTextField;

private final TextField portTextField;

private final TextField pluginsPathTextField;

private final TextField themesPathTextField;

private final TextField actionGridPaneActionBoxSize;

private final TextField actionGridPaneActionBoxGap;

private final ToggleSwitch startOnBootToggleSwitch;

private final HBoxWithSpaceBetween startOnBootHBox;

private final TextField soundOnActionClickedFilePathTextField;

private final ToggleSwitch soundOnActionClickedToggleSwitch;

private final HBoxWithSpaceBetween soundOnActionClickedToggleSwitchHBox;

private final ToggleSwitch minimizeToSystemTrayOnCloseToggleSwitch;

private final HBoxWithSpaceBetween minimizeToSystemTrayOnCloseHBox;

private final ToggleSwitch showAlertsPopupToggleSwitch;

private final HBoxWithSpaceBetween showAlertsPopupHBox;

private final Button saveButton;

private final Button checkForUpdatesButton;

private final Button factoryResetButton;

private Logger logger;

private ExceptionAndAlertHandler exceptionAndAlertHandler;

private ServerListener serverListener;

private HostServices hostServices;

public GeneralSettings(ExceptionAndAlertHandler exceptionAndAlertHandler, ServerListener serverListener, HostServices hostServices)

{

this.hostServices = hostServices;

this.exceptionAndAlertHandler = exceptionAndAlertHandler;

this.serverListener = serverListener;

logger = Logger.getLogger(GeneralSettings.class.getName());

serverNameTextField = new TextField();

portTextField = new TextField();

pluginsPathTextField = new TextField();

themesPathTextField = new TextField();

actionGridPaneActionBoxSize = new TextField();

actionGridPaneActionBoxGap = new TextField();

startOnBootToggleSwitch = new ToggleSwitch();

startOnBootHBox = new HBoxWithSpaceBetween("Start on Boot", startOnBootToggleSwitch);

startOnBootHBox.managedProperty().bind(startOnBootHBox.visibleProperty());

soundOnActionClickedToggleSwitch = new ToggleSwitch();

soundOnActionClickedToggleSwitchHBox = new HBoxWithSpaceBetween("Sound on Action Clicked", soundOnActionClickedToggleSwitch);

soundOnActionClickedFilePathTextField = new TextField();

HBoxInputBoxWithFileChooser soundHBoxInputBoxWithFileChooser = new HBoxInputBoxWithFileChooser("Sound File Path", soundOnActionClickedFilePathTextField,

new FileChooser.ExtensionFilter("Sounds","*.mp3","*.mp4", "*.m4a", "*.m4v","*.wav","*.aif", "*.aiff","*.fxm","*.flv","*.m3u8"));

soundHBoxInputBoxWithFileChooser.setUseLast(false);

soundHBoxInputBoxWithFileChooser.setRememberThis(false);

soundHBoxInputBoxWithFileChooser.getFileChooseButton().disableProperty().bind(soundOnActionClickedToggleSwitch.selectedProperty().not());

minimizeToSystemTrayOnCloseToggleSwitch = new ToggleSwitch();

minimizeToSystemTrayOnCloseHBox = new HBoxWithSpaceBetween("Minimise To Tray On Close", minimizeToSystemTrayOnCloseToggleSwitch);

showAlertsPopupToggleSwitch = new ToggleSwitch();

showAlertsPopupHBox = new HBoxWithSpaceBetween("Show Popup On Alert", showAlertsPopupToggleSwitch);

checkForUpdatesButton = new Button("Check for updates");

checkForUpdatesButton.setOnAction(event->checkForUpdates());

factoryResetButton = new Button("Factory Reset");

factoryResetButton.setOnAction(actionEvent -> onFactoryResetButtonClicked());

getStyleClass().add("general_settings");

prefWidthProperty().bind(widthProperty());

setAlignment(Pos.CENTER);

setSpacing(5);

getChildren().addAll(

new HBoxInputBox("Server Name", serverNameTextField),

new HBoxInputBox("Port", portTextField),

new HBoxInputBox("Grid Pane - Box Size", actionGridPaneActionBoxSize),

new HBoxInputBox("Grid Pane - Box Gap", actionGridPaneActionBoxGap),

new HBoxInputBoxWithDirectoryChooser("Plugins Path", pluginsPathTextField),

new HBoxInputBoxWithDirectoryChooser("Themes Path", themesPathTextField),

soundHBoxInputBoxWithFileChooser,

soundOnActionClickedToggleSwitchHBox,

minimizeToSystemTrayOnCloseHBox,

startOnBootHBox,

showAlertsPopupHBox

);

serverNameTextField.setPrefWidth(200);

saveButton = new Button("Save");

saveButton.setOnAction(event->save());

getChildren().addAll(factoryResetButton, checkForUpdatesButton, saveButton);

setPadding(new Insets(10));

}

private void checkForUpdates()

{

new CheckForUpdates(checkForUpdatesButton,

PlatformType.SERVER, ServerInfo.getInstance().getVersion(), new UpdateHyperlinkOnClick() {

@Override

public void handle(ActionEvent actionEvent) {

hostServices.showDocument(getURL());

}

});

}

public void loadDataFromConfig() throws SevereException {

Config config = Config.getInstance();

Platform.runLater(()->

{

serverNameTextField.setText(config.getServerName());

portTextField.setText(config.getPort()+"");

pluginsPathTextField.setText(config.getPluginsPath());

themesPathTextField.setText(config.getThemesPath());

actionGridPaneActionBoxSize.setText(config.getActionGridActionSize()+"");

actionGridPaneActionBoxGap.setText(config.getActionGridActionGap()+"");

minimizeToSystemTrayOnCloseToggleSwitch.setSelected(config.getMinimiseToSystemTrayOnClose());

showAlertsPopupToggleSwitch.setSelected(config.isShowAlertsPopup());

startOnBootToggleSwitch.setSelected(config.getStartOnBoot());

soundOnActionClickedToggleSwitch.setSelected(config.getSoundOnActionClickedStatus());

soundOnActionClickedFilePathTextField.setText(config.getSoundOnActionClickedFilePath());

});

}

public void save()

{

new Thread(new Task<Void>() {

@Override

protected Void call()

{

try {

boolean toBeReloaded = false;

boolean dashToBeReRendered = false;

Platform.runLater(()->{

saveButton.setDisable(true);

});

String serverNameStr = serverNameTextField.getText();

String serverPortStr = portTextField.getText();

String pluginsPathStr = pluginsPathTextField.getText();

String themesPathStr = themesPathTextField.getText();

String actionGridActionBoxSize = actionGridPaneActionBoxSize.getText();

String actionGridActionBoxGap = actionGridPaneActionBoxGap.getText();

boolean minimizeToSystemTrayOnClose = minimizeToSystemTrayOnCloseToggleSwitch.isSelected();

boolean showAlertsPopup = showAlertsPopupToggleSwitch.isSelected();

boolean startOnBoot = startOnBootToggleSwitch.isSelected();

boolean soundOnActionClicked = soundOnActionClickedToggleSwitch.isSelected();

String soundOnActionClickedFilePath = soundOnActionClickedFilePathTextField.getText();

Config config = Config.getInstance();

StringBuilder errors = new StringBuilder();

if(serverNameStr.isBlank())

{

errors.append("* Server Name cannot be blank.\n");

}

else

{

if(!config.getServerName().equals(serverNameStr))

{

toBeReloaded = true;

}

int serverPort=-1;

try {

serverPort = Integer.parseInt(serverPortStr);

if (serverPort < 1024)

errors.append("* Server Port must be more than 1024\n");

else if(serverPort > 65535)

errors.append("* Server Port must be lesser than 65535\n");

if(config.getPort()!=serverPort)

{

toBeReloaded = true;

}

catch (NumberFormatException e)

{

errors.append("* Server Port must be integer.\n");

}

int actionSize=-1;

try

{

actionSize = Integer.parseInt(actionGridActionBoxSize);

if(config.getActionGridActionSize() != actionSize)

{

dashToBeReRendered = true;

}

catch (NumberFormatException e)

{

errors.append("* action Size must be integer.\n");

}

int actionGap=-1;

try

{

actionGap = Integer.parseInt(actionGridActionBoxGap);

if(config.getActionGridActionGap() != actionGap)

{

dashToBeReRendered = true;

}

catch (NumberFormatException e)

{

errors.append("* action Gap must be integer.\n");

}

if(pluginsPathStr.isBlank())

{

errors.append("* Plugins Path must not be blank.\n");

}

else

{

if(!config.getPluginsPath().equals(pluginsPathStr))

{

toBeReloaded = true;

}

if(themesPathStr.isBlank())

{

errors.append("* Themes Path must not be blank.\n");

}

else

{

if(!config.getThemesPath().equals(themesPathStr))

{

toBeReloaded = true;

}

if(!errors.toString().isEmpty())

{

throw new MinorException("Uh Oh!", "Please rectify the following errors and try again :\n"+errors.toString());

throw new MinorException("Uh Oh!", "Please rectify the following errors and try again :\n"+ errors);

}

if(config.getStartOnBoot() != startOnBoot)

{

StartAtBoot startAtBoot = new StartAtBoot(PlatformType.SERVER, ServerInfo.getInstance().getPlatform());

if(startOnBoot)

{

try

{

startAtBoot.create(StartupFlags.RUNNER_FILE_NAME);

}

catch (MinorException e)

{

exceptionAndAlertHandler.handleMinorException(e);

startOnBoot = false;

}

else

{

boolean result = startAtBoot.delete();

if(!result)

new StreamPiAlert("Uh Oh!", "Unable to delete starter file", StreamPiAlertType.ERROR).show();

}

if(minimizeToSystemTrayOnClose)

{

if(!SystemTray.isSupported())

{

StreamPiAlert alert = new StreamPiAlert("Not Supported", "Tray System not supported on this platform ", StreamPiAlertType.ERROR);

alert.show();

minimizeToSystemTrayOnClose = false;

}

if(soundOnActionClicked)

{

if(soundOnActionClickedFilePath.isBlank())

{

StreamPiAlert alert = new StreamPiAlert("No sound file specified",

"Sound File cannot be empty", StreamPiAlertType.ERROR);

alert.show();

soundOnActionClicked = false;

}

else

{

File soundFile = new File(soundOnActionClickedFilePath);

if(!soundFile.exists() || !soundFile.isFile())

{

StreamPiAlert alert = new StreamPiAlert("File not found",

"No sound file at \n"+soundOnActionClickedFilePath+"\n" +

"Unable to set sound on action clicked.", StreamPiAlertType.ERROR);

alert.show();

soundOnActionClicked = false;

}

config.setServerName(serverNameStr);

config.setServerPort(serverPort);

config.setActionGridGap(actionGap);

config.setActionGridSize(actionSize);

config.setPluginsPath(pluginsPathStr);

config.setThemesPath(themesPathStr);

config.setMinimiseToSystemTrayOnClose(minimizeToSystemTrayOnClose);

StreamPiAlert.setIsShowPopup(showAlertsPopup);

config.setShowAlertsPopup(showAlertsPopup);

config.setStartupOnBoot(startOnBoot);

if(soundOnActionClicked)

{

serverListener.initSoundOnActionClicked();

}

config.setSoundOnActionClickedStatus(soundOnActionClicked);

config.setSoundOnActionClickedFilePath(soundOnActionClickedFilePath);

config.save();

loadDataFromConfig();

if(toBeReloaded)

{

StreamPiAlert restartPrompt = new StreamPiAlert(

"Warning",

"Stream-Pi Server needs to be restarted for these changes to take effect. Restart?\n" +

"All your current connections will be disconnected.",

StreamPiAlertType.WARNING

);

String yesOption = "Yes";

String noOption = "No";

restartPrompt.setButtons(yesOption, noOption);

restartPrompt.setOnClicked(new StreamPiAlertListener() {

@Override

public void onClick(String s) {

if(s.equals(yesOption))

{

serverListener.restart();

}

});

restartPrompt.show();

}

if(dashToBeReRendered)

{

serverListener.clearTemp();

}

catch (MinorException e)

{

exceptionAndAlertHandler.handleMinorException(e);

}

catch (SevereException e)

{

exceptionAndAlertHandler.handleSevereException(e);

}

finally {

Platform.runLater(()->{

saveButton.setDisable(false);

});

}

return null;

}

}).start();

}

private void onFactoryResetButtonClicked()

{

StreamPiAlert confirmation = new StreamPiAlert("Warning","Are you sure?\n" +

"This will erase everything.",StreamPiAlertType.WARNING);

String yesButton = "Yes";

String noButton = "No";

confirmation.setButtons(yesButton, noButton);

confirmation.setOnClicked(new StreamPiAlertListener() {

@Override

public void onClick(String s) {

if(s.equals(yesButton))

{

serverListener.factoryReset();

}

});

confirmation.show();

}

Public

server

Clone or download

rebuild

Modified Files