server

fix #52

Download Browse

fix #51 better sound handling

+93 −53

Author

Debayan Sutradhar (rnayabed) 2021-06-13 10:25

Committer

Debayan Sutradhar (rnayabed) 2021-06-13 10:25

Hash 9ad30b8c61629ee750709736855b8149086e300c

Parent 930331445a39cea89d97cb1598444c4ea0b9dbc6

Reference git #server/9ad30b8c61629ee750709736855b8149086e300c

Modified Files

List

Side by side diff

Inline diff

M src/main/java/com/stream_pi/server/controller/Controller.java

+15 −20

package com.stream_pi.server.controller;

import com.stream_pi.action_api.action.Action;

import com.stream_pi.action_api.action.ActionType;

import com.stream_pi.action_api.action.PropertySaver;

import com.stream_pi.action_api.action.ServerConnection;

import com.stream_pi.action_api.externalplugin.NormalAction;

import com.stream_pi.action_api.externalplugin.ToggleAction;

import com.stream_pi.action_api.externalplugin.ToggleExtras;

import com.stream_pi.server.Main;

import com.stream_pi.server.action.ExternalPlugins;

import com.stream_pi.server.client.Client;

import com.stream_pi.server.client.ClientProfile;

import com.stream_pi.server.connection.ClientConnection;

import com.stream_pi.server.connection.ClientConnections;

import com.stream_pi.server.connection.MainServer;

import com.stream_pi.server.info.ServerInfo;

import com.stream_pi.server.info.StartupFlags;

import com.stream_pi.server.io.Config;

import com.stream_pi.server.window.Base;

import com.stream_pi.server.window.dashboard.DashboardBase;

import com.stream_pi.server.window.dashboard.DonatePopupContent;

import com.stream_pi.server.window.dashboard.actiongridpane.ActionBox;

import com.stream_pi.server.window.firsttimeuse.FirstTimeUse;

import com.stream_pi.server.window.settings.SettingsBase;

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.exception.*;

import com.stream_pi.util.iohelper.IOHelper;

import javafx.animation.Animation;

import javafx.animation.Interpolator;

import javafx.animation.KeyFrame;

import javafx.animation.KeyValue;

import javafx.animation.Timeline;

import javafx.application.Platform;

import javafx.concurrent.Task;

import javafx.scene.Node;

import javafx.scene.Scene;

import javafx.scene.image.Image;

import javafx.scene.media.AudioClip;

import javafx.stage.Modality;

import javafx.stage.Stage;

import javafx.stage.WindowEvent;

import javafx.util.Duration;

import java.awt.MenuItem;

import java.awt.PopupMenu;

import java.awt.SystemTray;

import java.awt.Toolkit;

import java.awt.TrayIcon;

import java.io.File;

import java.net.SocketAddress;

import java.util.Objects;

import java.util.Random;

import java.util.Timer;

import java.util.TimerTask;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.ScheduledExecutorService;

import java.util.logging.Level;

public class Controller extends Base implements PropertySaver, ServerConnection, ToggleExtras

{

private final ExecutorService executor = Executors.newCachedThreadPool();

private MainServer mainServer;

private Animation openSettingsAnimation;

private Animation closeSettingsAnimation;

public Controller(){

mainServer = null;

}

public void setupDashWindow() throws SevereException

{

try

{

getStage().setOnCloseRequest(this::onCloseRequest);

}

catch (Exception e)

{

e.printStackTrace();

throw new SevereException(e.getMessage());

}

@Override

public void init()

{

try

{

initBase();

setupDashWindow();

setupSettingsWindowsAnimations();

ExternalPlugins.getInstance().setPropertySaver(this);

ExternalPlugins.getInstance().setToggleExtras(this);

ExternalPlugins.getInstance().setServerConnection(this);

getDashboardBase().getPluginsPane().getSettingsButton().setOnAction(event -> {

openSettingsAnimation.play();

});

getSettingsBase().getCloseButton().setOnAction(event -> {

closeSettingsAnimation.play();

});

getSettingsBase().getThemesSettings().setController(this);

mainServer = new MainServer(this, this);

if(getConfig().isFirstTimeUse())

{

firstTimeUse = new FirstTimeUse(this, this);

getChildren().add(firstTimeUse);

firstTimeUse.toFront();

getStage().setTitle("Stream-Pi Server");

getStage().show();

}

else

{

if(getConfig().isAllowDonatePopup())

{

if(new Random().nextInt(50) == 3)

new DonatePopupContent(getHostServices(), this).show();

}

othInit();

}

catch (SevereException e)

{

handleSevereException(e);

}

@Override

public void othInit()

{

try

{

if(StartupFlags.START_MINIMISED && SystemTray.isSupported())

{

minimiseApp();

}

else

{

getStage().show();

}

StreamPiAlert.setIsShowPopup(getConfig().isShowAlertsPopup());

}

catch(MinorException e)

{

handleMinorException(e);

}

if(getConfig().getSoundOnActionClickedStatus())

{

initSoundOnActionClicked();

}

executor.execute(new Task<Void>() {

@Override

protected Void call()

{

try

{

getSettingsBase().getGeneralSettings().loadDataFromConfig();

//themes

getSettingsBase().getThemesSettings().setThemes(getThemes());

getSettingsBase().getThemesSettings().setCurrentThemeFullName(getCurrentTheme().getFullName());

getSettingsBase().getThemesSettings().loadThemes();

//clients

getSettingsBase().getClientsSettings().loadData();

try

{

//Plugins

Platform.runLater(()->{

getDashboardBase().getPluginsPane().clearData();

getDashboardBase().getPluginsPane().loadOtherActions();

});

ExternalPlugins.setPluginsLocation(getConfig().getPluginsPath());

ExternalPlugins.getInstance().init();

Platform.runLater(()->getDashboardBase().getPluginsPane().loadData());

getSettingsBase().getPluginsSettings().loadPlugins();

}

catch (MinorException e)

{

getSettingsBase().getPluginsSettings().showPluginInitError();

handleMinorException(e);

}

//Server

mainServer.setPort(getConfig().getPort());

mainServer.start();

}

catch (SevereException e)

{

handleSevereException(e);

}

return null;

}

});

}

@Override

public void factoryReset()

{

getLogger().info("Reset to factory ...");

onQuitApp();

boolean result = IOHelper.deleteFile(getServerInfo().getPrePath());

if(result)

{

init();

}

else

{

handleSevereException(new SevereException("Unable to delete all files successfully. Installation corrupt. Re-install."));

}

private void setupSettingsWindowsAnimations()

{

Node settingsNode = getSettingsBase();

Node dashboardNode = getDashboardBase();

openSettingsAnimation = createOpenSettingsAnimation(settingsNode, dashboardNode);

closeSettingsAnimation = createCloseSettingsAnimation(settingsNode, dashboardNode);

}

public void onCloseRequest(WindowEvent event)

{

try

{

if(Config.getInstance().getMinimiseToSystemTrayOnClose() &&

SystemTray.isSupported())

{

minimiseApp();

event.consume();

return;

}

onQuitApp();

exit();

}

catch (SevereException e)

{

handleSevereException(e);

}

catch (MinorException e)

{

handleMinorException(e);

}

public void onQuitApp()

{

getLogger().info("Shutting down ...");

try

{

if(getConfig() != null)

{

getConfig().setStartupWindowSize(getWidth(), getHeight());

getConfig().setRightDividerPositions(getDashboardBase().getDividerPositions());

getConfig().setLeftDividerPositions(getDashboardBase().getLeftSplitPane().getDividerPositions());

getConfig().save();

}

catch (SevereException e)

{

handleSevereException(e);

}

stopServerAndAllConnections();

ExternalPlugins.getInstance().shutDownActions();

closeLogger();

Config.nullify();

}

public void exit()

{

executor.shutdown();

Platform.exit();

}

private void stopServerAndAllConnections()

{

if(mainServer!=null)

mainServer.stopListeningForConnections();

ClientConnections.getInstance().disconnectAll();

}

@Override

public void restart()

{

getLogger().info("Restarting ...");

onQuitApp();

Platform.runLater(this::init);

}

public void minimiseApp() throws MinorException

{

try

{

SystemTray systemTray = SystemTray.getSystemTray();

if(getTrayIcon() == null)

initIconTray(systemTray);

systemTray.add(getTrayIcon());

getStage().hide();

getStage().setOnShown(windowEvent -> {

systemTray.remove(getTrayIcon());

});

}

catch(Exception e)

{

throw new MinorException(e.getMessage());

}

public void initIconTray(SystemTray systemTray)

{

Platform.setImplicitExit(false);

PopupMenu popup = new PopupMenu();

MenuItem exitItem = new MenuItem("Exit");

exitItem.addActionListener(l->{

systemTray.remove(getTrayIcon());

onQuitApp();

exit();

});

popup.add(exitItem);

TrayIcon trayIcon = new TrayIcon(

Toolkit.getDefaultToolkit().getImage(Main.class.getResource("app_icon.png")),

"Stream-Pi Server",

popup

);

trayIcon.addActionListener(l-> Platform.runLater(()-> {

getStage().show();

getStage().setAlwaysOnTop(true);

getStage().setAlwaysOnTop(false);

}));

trayIcon.setImageAutoSize(true);

this.trayIcon = trayIcon;

}

private TrayIcon trayIcon = null;

public TrayIcon getTrayIcon()

{

return trayIcon;

}

@Override

public void handleMinorException(MinorException e)

{

getLogger().log(Level.SEVERE, e.getShortMessage(), e);

e.printStackTrace();

new StreamPiAlert(e.getTitle(), e.getShortMessage(), StreamPiAlertType.WARNING).show();

Platform.runLater(()-> new StreamPiAlert(e.getTitle(), e.getShortMessage(), StreamPiAlertType.WARNING).show());

}

@Override

public void handleSevereException(SevereException e)

{

getLogger().log(Level.SEVERE, e.getShortMessage(), e);

e.printStackTrace();

Platform.runLater(()->{

StreamPiAlert alert = new StreamPiAlert(e.getTitle(), e.getShortMessage(), StreamPiAlertType.ERROR);

alert.setOnClicked(new StreamPiAlertListener()

{

@Override

public void onClick(String txt)

{

@Override

onQuitApp();

public void onClick(String txt)

exit();

{

}

onQuitApp();

exit();

}

});

alert.show();

});

alert.show();

}

private AudioClip audioClip = null;

private String audioFilePath = null;

private void playSound()

{

if(audioClip.isPlaying())

{

Platform.runLater(audioClip::stop);

return;

}

if(!audioFilePath.equals(getConfig().getSoundOnActionClickedFilePath()))

{

initSoundOnActionClicked();

}

Platform.runLater(audioClip::play);

}

private void initSoundOnActionClicked()

@Override

public void initSoundOnActionClicked()

{

audioFilePath = getConfig().getSoundOnActionClickedFilePath();

File file = new File(audioFilePath);

if(!file.exists())

{

audioFilePath = null;

audioClip = null;

getConfig().setSoundOnActionClickedStatus(false);

getConfig().setSoundOnActionClickedFilePath("");

handleMinorException(new MinorException("The sound file for on action click sound is missing."));

return;

}

audioClip = new AudioClip(file.toURI().toString());

}

@Override

public void onActionClicked(Client client, String profileID, String actionID, boolean toggle)

{

try

{

Action action = client.getProfileByID(profileID).getActionByID(actionID);

if(getConfig().getSoundOnActionClickedStatus())

{

playSound();

}

if(action.isInvalid())

{

throw new MinorException(

"The action isn't installed on the server."

);

}

executor.execute(new Task<Void>() {

@Override

protected Void call()

{

try

{

Thread.sleep(action.getDelayBeforeExecuting());

getLogger().info("action "+action.getID()+" clicked!");

if(action instanceof ToggleAction)

{

onToggleActionClicked((ToggleAction) action, toggle, profileID,

client.getRemoteSocketAddress());

}

else if (action instanceof NormalAction)

{

onNormalActionClicked((NormalAction) action, profileID,

client.getRemoteSocketAddress());

}

catch (InterruptedException e)

{

e.printStackTrace();

getLogger().info("onActionClicked scheduled task was interrupted ...");

}

return null;

}

});

}

catch (Exception e)

{

e.printStackTrace();

handleMinorException(new MinorException(e.getMessage()));

}

public synchronized void onNormalActionClicked(NormalAction action, String profileID, SocketAddress socketAddress)

{

try

{

action.onActionClicked();

}

catch (MinorException e)

{

sendActionFailed(e, socketAddress, profileID, action.getID());

}

public synchronized void onToggleActionClicked(ToggleAction action, boolean toggle, String profileID, SocketAddress socketAddress)

{

try

{

if(toggle)

{

action.onToggleOn();

}

else

{

action.onToggleOff();

}

catch (MinorException e)

{

sendActionFailed(e, socketAddress, profileID, action.getID());

}

@Override

public void clearTemp() {

Platform.runLater(() -> {

getDashboardBase().getClientAndProfileSelectorPane().refresh();

getDashboardBase().getActionGridPane().clear();

getDashboardBase().getActionGridPane().setFreshRender(true);

getDashboardBase().getActionDetailsPane().clear();

getSettingsBase().getClientsSettings().loadData();

});

}

@Override

public void saveServerProperties()

{

try

{

ExternalPlugins.getInstance().saveServerSettings();

getSettingsBase().getPluginsSettings().loadPlugins();

} catch (MinorException e) {

e.printStackTrace();

handleMinorException(e);

}

private void saveClientActionMain(String profileID, String actionID, SocketAddress socketAddress, boolean sendIcons)

{

try {

ClientConnection clientConnection = ClientConnections.getInstance().getClientConnectionBySocketAddress(socketAddress);

ClientProfile clientProfile = clientConnection.getClient().getProfileByID(profileID);

Action action = clientProfile.getActionByID(actionID);

clientConnection.saveActionDetails(profileID, action);

if(sendIcons && action.isHasIcon())

{

saveAllIcons(profileID, actionID, socketAddress, false);

}

Platform.runLater(()->{

try {

ActionBox actionBox = getDashboardBase().getActionGridPane().getActionBoxByIDAndProfileID(

action.getID(),

profileID

);

if(actionBox != null)

{

Platform.runLater(actionBox::init);

}

if(getDashboardBase().getActionDetailsPane().getAction() != null)

{

// This block is executed when no Action is selected.

if(getDashboardBase().getActionDetailsPane().getAction().getID().equals(actionID))

{

getDashboardBase().getActionDetailsPane().setAction(action);

getDashboardBase().getActionDetailsPane().refresh();

}

catch (Exception e)

{

e.printStackTrace();

}

});

}

catch (SevereException e)

{

handleSevereException(e);

}

@Override

public void saveClientAction(String profileID, String actionID, SocketAddress socketAddress, boolean sendIcons, boolean runAsync)

{

if(runAsync)

{

executor.execute(new Task<Void>() {

@Override

protected Void call()

{

saveClientActionMain(profileID, actionID, socketAddress, sendIcons);

return null;

}

});

}

else

{

saveClientActionMain(profileID, actionID, socketAddress, sendIcons);

}

@Override

public void saveAllIcons(String profileID, String actionID, SocketAddress socketAddress)

{

saveAllIcons(profileID, actionID, socketAddress, true);

}

public void saveAllIcons(String profileID, String actionID, SocketAddress socketAddress, boolean async)

{

if(async)

{

executor.execute(new Task<Void>() {

@Override

protected Void call()

{

saveAllIconsMain(profileID, actionID, socketAddress);

return null;

}

});

}

else

{

saveAllIconsMain(profileID, actionID, socketAddress);

}

private void saveAllIconsMain(String profileID, String actionID, SocketAddress socketAddress)

{

try {

ClientConnection clientConnection = ClientConnections.getInstance().getClientConnectionBySocketAddress(socketAddress);

ClientProfile clientProfile = clientConnection.getClient().getProfileByID(profileID);

Action action = clientProfile.getActionByID(actionID);

for(String eachState : action.getIcons().keySet())

{

clientConnection.sendIcon(profileID, actionID, eachState,

action.getIcon(eachState));

}

catch (SevereException e)

{

handleSevereException(e);

}

@Override

public void saveIcon(String state, String profileID, String actionID, SocketAddress socketAddress) {

executor.execute(new Task<Void>() {

@Override

protected Void call()

{

try {

ClientConnection clientConnection = ClientConnections.getInstance().getClientConnectionBySocketAddress(socketAddress);

ClientProfile clientProfile = clientConnection.getClient().getProfileByID(profileID);

Action action = clientProfile.getActionByID(actionID);

clientConnection.sendIcon(profileID, actionID, state, action.getIcon(state));

}

catch (SevereException e)

{

handleSevereException(e);

}

return null;

}

});

}

@Override

public com.stream_pi.util.platform.Platform getPlatform() {

return ServerInfo.getInstance().getPlatform();

}

@Override

public void sendActionFailed(MinorException exception, SocketAddress socketAddress, String profileID, String actionID)

{

if(exception.getTitle() != null)

{

exception.setShortMessage(exception.getTitle()+"\n"+exception.getShortMessage());

}

exception.setTitle("Error while running action");

handleMinorException(exception);

executor.execute(new Task<Void>() {

@Override

protected Void call()

{

try {

ClientConnections.getInstance().getClientConnectionBySocketAddress(socketAddress)

.sendActionFailed(profileID, actionID);

}

catch (SevereException e)

{

handleSevereException(e);

}

return null;

}

});

}

private Animation createOpenSettingsAnimation(Node settingsNode, Node dashboardNode) {

Timeline openSettingsTimeline = new Timeline();

openSettingsTimeline.setCycleCount(1);

openSettingsTimeline.getKeyFrames().addAll(

new KeyFrame(Duration.millis(0.0D),

new KeyValue(settingsNode.opacityProperty(),

0.0D, Interpolator.EASE_IN),

new KeyValue(settingsNode.scaleXProperty(),

1.1D, Interpolator.EASE_IN),

new KeyValue(settingsNode.scaleYProperty(),

1.1D, Interpolator.EASE_IN),

new KeyValue(settingsNode.scaleZProperty(),

1.1D, Interpolator.EASE_IN)),

new KeyFrame(Duration.millis(90.0D),

new KeyValue(settingsNode.opacityProperty(),

1.0D, Interpolator.LINEAR),

new KeyValue(settingsNode.scaleXProperty(),

1.0D, Interpolator.LINEAR),

new KeyValue(settingsNode.scaleYProperty(),

1.0D, Interpolator.LINEAR),

new KeyValue(settingsNode.scaleZProperty(),

1.0D, Interpolator.LINEAR)),

new KeyFrame(Duration.millis(0.0D),

new KeyValue(dashboardNode.opacityProperty(),

1.0D, Interpolator.LINEAR),

new KeyValue(dashboardNode.scaleXProperty(),

1.0D, Interpolator.LINEAR),

new KeyValue(dashboardNode.scaleYProperty(),

1.0D, Interpolator.LINEAR),

new KeyValue(dashboardNode.scaleZProperty(),

1.0D, Interpolator.LINEAR)),

new KeyFrame(Duration.millis(90.0D),

new KeyValue(dashboardNode.opacityProperty(),

0.0D, Interpolator.LINEAR),

new KeyValue(dashboardNode.scaleXProperty(),

0.9D, Interpolator.LINEAR),

new KeyValue(dashboardNode.scaleYProperty(),

0.9D, Interpolator.LINEAR),

new KeyValue(dashboardNode.scaleZProperty(),

0.9D, Interpolator.LINEAR))

);

openSettingsTimeline.setOnFinished(e -> settingsNode.toFront());

return openSettingsTimeline;

}

private Animation createCloseSettingsAnimation(Node settingsNode, Node dashboardNode) {

Timeline closeSettingsTimeline = new Timeline();

closeSettingsTimeline.setCycleCount(1);

closeSettingsTimeline.getKeyFrames().addAll(

new KeyFrame(Duration.millis(0.0D),

new KeyValue(settingsNode.opacityProperty(),

1.0D, Interpolator.LINEAR),

new KeyValue(settingsNode.scaleXProperty(),

1.0D, Interpolator.LINEAR),

new KeyValue(settingsNode.scaleYProperty(),

1.0D, Interpolator.LINEAR),

new KeyValue(settingsNode.scaleZProperty(),

1.0D, Interpolator.LINEAR)),

new KeyFrame(Duration.millis(90.0D),

new KeyValue(settingsNode.opacityProperty(),

0.0D, Interpolator.LINEAR),

new KeyValue(settingsNode.scaleXProperty(),

1.1D, Interpolator.LINEAR),

new KeyValue(settingsNode.scaleYProperty(),

1.1D, Interpolator.LINEAR),

new KeyValue(settingsNode.scaleZProperty(),

1.1D, Interpolator.LINEAR)),

new KeyFrame(Duration.millis(0.0D),

new KeyValue(dashboardNode.opacityProperty(),

0.0D, Interpolator.LINEAR),

new KeyValue(dashboardNode.scaleXProperty(),

0.9D, Interpolator.LINEAR),

new KeyValue(dashboardNode.scaleYProperty(),

0.9D, Interpolator.LINEAR),

new KeyValue(dashboardNode.scaleZProperty(),

0.9D, Interpolator.LINEAR)),

new KeyFrame(Duration.millis(90.0D),

new KeyValue(dashboardNode.opacityProperty(),

1.0D, Interpolator.LINEAR),

new KeyValue(dashboardNode.scaleXProperty(),

1.0D, Interpolator.LINEAR),

new KeyValue(dashboardNode.scaleYProperty(),

1.0D, Interpolator.LINEAR),

new KeyValue(dashboardNode.scaleZProperty(),

1.0D, Interpolator.LINEAR))

);

closeSettingsTimeline.setOnFinished(event1 -> {

dashboardNode.toFront();

executor.execute(new Task<Void>() {

@Override

protected Void call() {

try {

getSettingsBase().getClientsSettings().loadData();

getSettingsBase().getGeneralSettings().loadDataFromConfig();

getSettingsBase().getPluginsSettings().loadPlugins();

getSettingsBase().getThemesSettings().setThemes(getThemes());

getSettingsBase().getThemesSettings().setCurrentThemeFullName(getCurrentTheme().getFullName());

getSettingsBase().getThemesSettings().loadThemes();

getSettingsBase().setDefaultTabToGeneral();

}

catch (SevereException e)

{

handleSevereException(e);

}

catch (MinorException e)

{

handleMinorException(e);

}

return null;

}

});

return closeSettingsTimeline;

}

@Override

public void setToggleStatus(boolean currentStatus, String profileID, String actionID, SocketAddress clientSocketAddress)

throws MinorException

{

ClientConnection clientConnection = ClientConnections.getInstance().getClientConnectionBySocketAddress(

clientSocketAddress

);

if(clientConnection == null)

throw new ClientNotFoundException("setToggleStatus failed because no client found with given socket address");

new Thread(new Task<Void>() {

@Override

protected Void call()

{

try

{

clientConnection.setToggleStatus(currentStatus, profileID, actionID);

}

catch (SevereException e)

{

handleSevereException(e);

}

return null;

}

}).start();

}

M src/main/java/com/stream_pi/server/controller/ServerListener.java

+2 −0

package com.stream_pi.server.controller;

import com.stream_pi.action_api.externalplugin.NormalAction;

import com.stream_pi.action_api.externalplugin.ToggleAction;

import com.stream_pi.server.client.Client;

import com.stream_pi.server.window.dashboard.ClientAndProfileSelectorPane;

import com.stream_pi.server.window.dashboard.DashboardBase;

import com.stream_pi.server.window.settings.SettingsBase;

import com.stream_pi.util.exception.SevereException;

import javafx.stage.Stage;

import java.net.SocketAddress;

public interface ServerListener

{

void onActionClicked(Client client, String profileID, String actionID, boolean toggle);

void clearTemp();

void init();

void restart();

void othInit();

Stage getStage();

DashboardBase getDashboardBase();

SettingsBase getSettingsBase();

void initLogger() throws SevereException;

void factoryReset();

void initSoundOnActionClicked();

}

M src/main/java/com/stream_pi/server/window/dashboard/actiondetailpane/ActionDetailsPane.java

+3 −11

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

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.actionproperty.property.*;

import com.stream_pi.action_api.externalplugin.ExternalPlugin;

import com.stream_pi.action_api.otheractions.CombineAction;

import com.stream_pi.action_api.otheractions.FolderAction;

import com.stream_pi.server.uipropertybox.UIPropertyBox;

import com.stream_pi.server.client.Client;

import com.stream_pi.server.client.ClientProfile;

import com.stream_pi.server.connection.ClientConnection;

import com.stream_pi.server.connection.ClientConnections;

import com.stream_pi.server.window.dashboard.actiongridpane.ActionBox;

import com.stream_pi.server.window.ExceptionAndAlertHandler;

import com.stream_pi.server.controller.ActionDataFormats;

import com.stream_pi.server.window.dashboard.actiongridpane.ActionGridPaneListener;

import com.stream_pi.server.window.helper.Helper;

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.exception.MinorException;

import com.stream_pi.util.exception.SevereException;

import com.stream_pi.util.uihelper.HBoxInputBox;

import com.stream_pi.util.uihelper.HBoxInputBoxWithFileChooser;

import com.stream_pi.util.uihelper.HBoxWithSpaceBetween;

import com.stream_pi.util.uihelper.SpaceFiller;

import javafx.application.HostServices;

import javafx.collections.FXCollections;

import javafx.concurrent.Task;

import javafx.geometry.Insets;

import javafx.geometry.Pos;

import javafx.scene.Node;

import javafx.scene.control.*;

import javafx.scene.input.Dragboard;

import javafx.scene.input.TransferMode;

import javafx.scene.layout.HBox;

import javafx.scene.layout.Priority;

import javafx.scene.layout.VBox;

import javafx.scene.paint.Color;

import javafx.stage.FileChooser;

import javafx.stage.Window;

import javafx.util.Callback;

import org.kordamp.ikonli.javafx.FontIcon;

import java.io.File;

import java.nio.file.Files;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.logging.Logger;

public class ActionDetailsPane extends VBox implements ActionDetailsPaneListener

{

private ScrollPane scrollPane;

private VBox vbox;

private VBox clientPropertiesVBox;

private Button saveButton;

private Button deleteButton;

private Button openFolderButton;

private Button resetToDefaultsButton;

private HBox buttonBar;

private VBox pluginExtraButtonBar;

private Label actionHeadingLabel;

private Logger logger;

private Button returnButtonForCombineActionChild;

private ExceptionAndAlertHandler exceptionAndAlertHandler;

private HostServices hostServices;

private ActionGridPaneListener actionGridPaneListener;

public ActionDetailsPane(ExceptionAndAlertHandler exceptionAndAlertHandler, HostServices hostServices,

ActionGridPaneListener actionGridPaneListener)

{

this.hostServices = hostServices;

this.exceptionAndAlertHandler = exceptionAndAlertHandler;

this.actionGridPaneListener = actionGridPaneListener;

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

setSpacing(10.0);

clientPropertiesVBox = new VBox();

clientPropertiesVBox.setSpacing(10.0);

vbox = new VBox();

vbox.setPadding(new Insets(0, 25, 0, 5));

vbox.getStyleClass().add("action_details_pane_vbox");

vbox.setSpacing(10.0);

pluginExtraButtonBar = new VBox();

pluginExtraButtonBar.setSpacing(10.0);

getStyleClass().add("action_details_pane");

scrollPane = new ScrollPane();

VBox.setMargin(scrollPane, new Insets(0, 0, 0, 10));

scrollPane.getStyleClass().add("action_details_pane_scroll_pane");

setMinHeight(210);

scrollPane.setContent(vbox);

vbox.prefWidthProperty().bind(scrollPane.widthProperty());

scrollPane.prefWidthProperty().bind(widthProperty());

VBox.setVgrow(scrollPane, Priority.ALWAYS);

scrollPane.setHbarPolicy(ScrollPane.ScrollBarPolicy.NEVER);

openFolderButton = new Button("Open Folder");

openFolderButton.managedProperty().bind(openFolderButton.visibleProperty());

FontIcon folderOpenIcon = new FontIcon("far-folder-open");

openFolderButton.setGraphic(folderOpenIcon);

openFolderButton.setOnAction(event -> onOpenFolderButtonClicked());

saveButton = new Button("Save");

saveButton.getStyleClass().add("action_details_pane_save_button");

FontIcon syncIcon = new FontIcon("far-save");

syncIcon.getStyleClass().add("action_details_save_delete_button_icon");

saveButton.setGraphic(syncIcon);

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

deleteButton = new Button();

deleteButton.getStyleClass().add("action_details_pane_delete_button");

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

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

deleteButton.setGraphic(deleteIcon);

deleteButton.setOnAction(event -> onDeleteButtonClicked());

resetToDefaultsButton = new Button("Reset");

resetToDefaultsButton.managedProperty().bind(resetToDefaultsButton.visibleProperty());

resetToDefaultsButton.getStyleClass().add("action_details_pane_reset_button");

FontIcon resetToDefaultsIcon = new FontIcon("fas-sync-alt");

resetToDefaultsIcon.getStyleClass().add("action_details_pane_reset_button_icon");

resetToDefaultsButton.setGraphic(resetToDefaultsIcon);

resetToDefaultsButton.setOnAction(event -> onResetToDefaultsButtonClicked());

returnButtonForCombineActionChild = new Button("Return");

returnButtonForCombineActionChild.setGraphic(new FontIcon("fas-caret-left"));

returnButtonForCombineActionChild.managedProperty().bind(returnButtonForCombineActionChild.visibleProperty());

returnButtonForCombineActionChild.setOnAction(event -> {

try

{

onActionClicked(getClientProfile().getActionByID(getAction().getParent()), getActionBox());

} catch (MinorException e)

{

e.printStackTrace();

}

});

buttonBar = new HBox(openFolderButton, resetToDefaultsButton, returnButtonForCombineActionChild, saveButton, deleteButton);

buttonBar.getStyleClass().add("action_details_pane_button_bar");

buttonBar.setPadding(new Insets(10, 10, 10, 0));

buttonBar.setAlignment(Pos.CENTER_RIGHT);

buttonBar.setVisible(false);

buttonBar.setSpacing(10.0);

actionHeadingLabel = new Label();

actionHeadingLabel.getStyleClass().add("action_details_pane_heading_label");

HBox headingHBox = new HBox(actionHeadingLabel);

headingHBox.getStyleClass().add("action_details_pane_heading_box");

headingHBox.setPadding(new Insets(5, 10, 0, 10));

getChildren().addAll(headingHBox, scrollPane, buttonBar);

displayTextAlignmentComboBox = new ComboBox<>(FXCollections.observableArrayList(DisplayTextAlignment.TOP,

DisplayTextAlignment.CENTER, DisplayTextAlignment.BOTTOM));

displayTextAlignmentComboBox.managedProperty().bind(displayTextAlignmentComboBox.visibleProperty());

Callback<ListView<DisplayTextAlignment>, ListCell<DisplayTextAlignment>> displayTextAlignmentComboBoxFactory = new Callback<>() {

@Override

public ListCell<DisplayTextAlignment> call(ListView<DisplayTextAlignment> displayTextAlignment) {

return new ListCell<>() {

@Override

protected void updateItem(DisplayTextAlignment displayTextAlignment, boolean b) {

super.updateItem(displayTextAlignment, b);

if (displayTextAlignment != null) {

setText(displayTextAlignment.getUIName());

}

};

}

};

displayTextAlignmentComboBox.setCellFactory(displayTextAlignmentComboBoxFactory);

displayTextAlignmentComboBox.setButtonCell(displayTextAlignmentComboBoxFactory.call(null));

actionClientProperties = new ArrayList<>();

displayNameTextField = new TextField();

displayNameTextField.managedProperty().bind(displayNameTextField.visibleProperty());

defaultIconFileTextField = new TextField();

defaultIconFileTextField.textProperty().addListener((observableValue, s, t1) -> {

try {

if (!s.equals(t1) && t1.length() > 0) {

byte[] iconFileByteArray = Files.readAllBytes(new File(t1).toPath());

hideDefaultIconCheckBox.setDisable(false);

hideDefaultIconCheckBox.setSelected(false);

clearIconButton.setDisable(false);

getAction().addIcon("default", iconFileByteArray);

getAction().setCurrentIconState("default");

setSendIcon(true);

}

} catch (Exception e) {

e.printStackTrace();

exceptionAndAlertHandler.handleMinorException(new MinorException(e.getMessage()));

}

});

toggleOffIconFileTextField = new TextField();

toggleOffIconFileTextField.textProperty().addListener((observableValue, s, t1) -> {

try {

if (!s.equals(t1) && t1.length() > 0) {

byte[] iconFileByteArray = Files.readAllBytes(new File(t1).toPath());

hideToggleOffIconCheckBox.setDisable(false);

hideToggleOffIconCheckBox.setSelected(false);

clearIconButton.setDisable(false);

getAction().addIcon("toggle_off", iconFileByteArray);

setSendIcon(true);

}

} catch (Exception e) {

e.printStackTrace();

exceptionAndAlertHandler.handleMinorException(new MinorException(e.getMessage()));

}

});

toggleOnIconFileTextField = new TextField();

toggleOnIconFileTextField.textProperty().addListener((observableValue, s, t1) -> {

try {

if (!s.equals(t1) && t1.length() > 0) {

byte[] iconFileByteArray = Files.readAllBytes(new File(t1).toPath());

hideToggleOnIconCheckBox.setDisable(false);

hideToggleOnIconCheckBox.setSelected(false);

clearIconButton.setDisable(false);

getAction().addIcon("toggle_on", iconFileByteArray);

setSendIcon(true);

}

} catch (Exception e) {

e.printStackTrace();

exceptionAndAlertHandler.handleMinorException(new MinorException(e.getMessage()));

}

});

clearIconButton = new Button("Clear Icon");

clearIconButton.managedProperty().bind(clearIconButton.visibleProperty());

clearIconButton.setOnAction(event ->

{

hideDefaultIconCheckBox.setDisable(true);

hideDefaultIconCheckBox.setSelected(false);

hideToggleOffIconCheckBox.setDisable(true);

hideToggleOffIconCheckBox.setSelected(false);

hideToggleOnIconCheckBox.setDisable(true);

hideToggleOnIconCheckBox.setSelected(false);

clearIconButton.setDisable(true);

setSendIcon(false);

defaultIconFileTextField.clear();

toggleOffIconFileTextField.clear();

toggleOnIconFileTextField.clear();

});

hideDisplayTextCheckBox = new CheckBox("Hide");

hideDisplayTextCheckBox.managedProperty().bind(hideDisplayTextCheckBox.visibleProperty());

hideDefaultIconCheckBox = new CheckBox("Hide");

hideToggleOnIconCheckBox = new CheckBox("Hide");

hideToggleOffIconCheckBox = new CheckBox("Hide");

actionBackgroundColourPicker = new ColorPicker();

actionBackgroundColourPicker.managedProperty().bind(actionBackgroundColourPicker.visibleProperty());

displayTextColourPicker = new ColorPicker();

displayTextColourPicker.managedProperty().bind(displayTextColourPicker.visibleProperty());

actionBackgroundColourTransparentCheckBox = new CheckBox("Default");

actionBackgroundColourPicker.disableProperty()

.bind(actionBackgroundColourTransparentCheckBox.selectedProperty());

HBox.setMargin(actionBackgroundColourTransparentCheckBox, new Insets(0, 0, 0, 10));

displayTextColourDefaultCheckBox = new CheckBox("Default");

displayTextColourPicker.disableProperty()

.bind(displayTextColourDefaultCheckBox.selectedProperty());

HBox.setMargin(displayTextColourDefaultCheckBox, new Insets(0, 0, 0, 10));

HBox displayTextColourHBox = new HBox(new Label("Display Text Colour"), SpaceFiller.horizontal(), displayTextColourPicker,

displayTextColourDefaultCheckBox);

displayTextColourHBox.setAlignment(Pos.CENTER);

displayTextColourHBox.setSpacing(5.0);

HBox bgColourHBox = new HBox(new Label("Background Colour"), SpaceFiller.horizontal(), actionBackgroundColourPicker,

actionBackgroundColourTransparentCheckBox);

bgColourHBox.setAlignment(Pos.CENTER);

bgColourHBox.setSpacing(5.0);

HBox clearIconHBox = new HBox(clearIconButton);

clearIconHBox.setAlignment(Pos.CENTER_RIGHT);

HBox.setMargin(hideDisplayTextCheckBox, new Insets(0, 0, 0, 45));

HBoxInputBox s = new HBoxInputBox("Display Name", displayNameTextField);

HBox.setHgrow(s, Priority.ALWAYS);

displayTextFieldHBox = new HBox(s, hideDisplayTextCheckBox);

HBox alignmentHBox = new HBox(new Label("Alignment"), SpaceFiller.horizontal(),

displayTextAlignmentComboBox);

normalToggleActionCommonPropsVBox = new VBox(

displayTextColourHBox,

alignmentHBox,

bgColourHBox

);

normalToggleActionCommonPropsVBox.managedProperty().bind(normalToggleActionCommonPropsVBox.visibleProperty());

normalToggleActionCommonPropsVBox.setSpacing(10.0);

FileChooser.ExtensionFilter iconExtensions = new FileChooser.ExtensionFilter("Images", "*.jpeg", "*.jpg", "*.png", "*.gif");

normalActionsPropsVBox = new VBox(

new HBoxInputBoxWithFileChooser("Icon", defaultIconFileTextField, hideDefaultIconCheckBox,

iconExtensions)

);

normalActionsPropsVBox.managedProperty().bind(normalActionsPropsVBox.visibleProperty());

normalActionsPropsVBox.setSpacing(10.0);

toggleActionsPropsVBox = new VBox(

new HBoxInputBoxWithFileChooser("Toggle Off Icon", toggleOffIconFileTextField, hideToggleOffIconCheckBox,

iconExtensions),

new HBoxInputBoxWithFileChooser("Toggle On Icon", toggleOnIconFileTextField, hideToggleOnIconCheckBox,

iconExtensions)

);

toggleActionsPropsVBox.managedProperty().bind(toggleActionsPropsVBox.visibleProperty());

toggleActionsPropsVBox.setSpacing(10.0);

vbox.getChildren().addAll(displayTextFieldHBox,normalToggleActionCommonPropsVBox,

normalActionsPropsVBox, toggleActionsPropsVBox,

clearIconHBox, clientPropertiesVBox,

pluginExtraButtonBar);

vbox.setVisible(false);

scrollPane.setVbarPolicy(ScrollPane.ScrollBarPolicy.NEVER);

setOnDragOver(dragEvent -> {

if (dragEvent.getDragboard().hasContent(ActionDataFormats.ACTION_TYPE) && action != null) {

if (getAction().getActionType() == ActionType.COMBINE) {

dragEvent.acceptTransferModes(TransferMode.ANY);

dragEvent.consume();

}

});

setOnDragDropped(dragEvent -> {

try {

Dragboard db = dragEvent.getDragboard();

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

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

{

ExternalPlugin newAction = actionGridPaneListener.createNewActionFromExternalPlugin(

(String) db.getContent(ActionDataFormats.MODULE_NAME)

);

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

if(isNew)

{

newAction.setDisplayText("Untitled Action");

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(-1, -1));

newAction.setParent(getAction().getID());

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

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

try

{

newAction.onActionCreate();

}

catch (MinorException e)

{

e.setTitle("Error");

e.setShortMessage("onCreate() failed for "+getAction().getModuleName()+"\n\n"+e.getShortMessage());

exceptionAndAlertHandler.handleMinorException(e);

}

combineActionPropertiesPane.getCombineAction().addChild(newAction.getID());

addActionToCurrentClientProfile(newAction);

ClientConnection connection = ClientConnections.getInstance()

.getClientConnectionBySocketAddress(getClient().getRemoteSocketAddress());

connection.saveActionDetails(getClientProfile().getID(), newAction);

combineActionPropertiesPane.renderProps();

saveAction(true, false);

}

} catch (MinorException e) {

exceptionAndAlertHandler.handleMinorException(e);

e.printStackTrace();

} catch (SevereException e) {

exceptionAndAlertHandler.handleSevereException(e);

e.printStackTrace();

} catch (CloneNotSupportedException e) {

e.printStackTrace();

} catch (Exception e)

{

e.printStackTrace();

}

});

}

private void onResetToDefaultsButtonClicked()

{

StreamPiAlert streamPiAlert = new StreamPiAlert(

"Warning",

"Are you sure you want to reset the action?",

StreamPiAlertType.WARNING

);

String optionYes = "Yes";

String optionNo = "No";

streamPiAlert.setButtons(optionYes, optionNo);

streamPiAlert.setOnClicked(new StreamPiAlertListener() {

@Override

public void onClick(String s) {

if(s.equals(optionYes))

{

getAction().getClientProperties().resetToDefaults();

try

{

onActionClicked(getAction(), getActionBox());

saveAction(true, true);

}

catch (MinorException e)

{

exceptionAndAlertHandler.handleMinorException(e);

}

});

streamPiAlert.show();

}

private VBox normalActionsPropsVBox;

private VBox normalToggleActionCommonPropsVBox;

private VBox toggleActionsPropsVBox;

private HBox displayTextFieldHBox;

private ClientConnection clientConnection;

private ClientProfile clientProfile;

public void setClientConnection(ClientConnection clientConnection) {

this.clientConnection = clientConnection;

}

public ClientConnection getClientConnection() {

return clientConnection;

}

public Client getClient()

{

return getClientConnection().getClient();

}

public void setClientProfile(ClientProfile clientProfile) {

this.clientProfile = clientProfile;

}

public ClientProfile getClientProfile() {

return clientProfile;

}

public void setActionHeadingLabelText(String text) {

actionHeadingLabel.setText(text);

}

private Action action;

public synchronized Action getAction() {

return action;

}

private ActionBox actionBox;

public ActionBox getActionBox() {

return actionBox;

}

@Override

public void onActionClicked(Action action, ActionBox actionBox) throws MinorException

{

clear();

setAction(action);

this.actionBox = actionBox;

actionBox.setSelected(true);

renderActionProperties();

}

public void refresh()

{

clear(false);

try

{

renderActionProperties();

}

catch (MinorException e)

{

exceptionAndAlertHandler.handleMinorException(e);

}

private TextField displayNameTextField;

private CheckBox hideDisplayTextCheckBox;

private CheckBox hideDefaultIconCheckBox;

private TextField defaultIconFileTextField;

private CheckBox hideToggleOnIconCheckBox;

private TextField toggleOnIconFileTextField;

private CheckBox hideToggleOffIconCheckBox;

private TextField toggleOffIconFileTextField;

private Button clearIconButton;

private ColorPicker actionBackgroundColourPicker;

private ColorPicker displayTextColourPicker;

private CheckBox actionBackgroundColourTransparentCheckBox;

private CheckBox displayTextColourDefaultCheckBox;

private ComboBox<DisplayTextAlignment> displayTextAlignmentComboBox;

public void clear(boolean actionNull)

{

sendIcon = false;

actionClientProperties.clear();

displayNameTextField.clear();

defaultIconFileTextField.clear();

toggleOffIconFileTextField.clear();

toggleOnIconFileTextField.clear();

clientPropertiesVBox.getChildren().clear();

pluginExtraButtonBar.getChildren().clear();

vbox.setVisible(false);

normalActionsPropsVBox.setVisible(false);

toggleActionsPropsVBox.setVisible(false);

saveButton.setVisible(false);

openFolderButton.setVisible(false);

resetToDefaultsButton.setVisible(false);

returnButtonForCombineActionChild.setVisible(false);

scrollPane.setVbarPolicy(ScrollPane.ScrollBarPolicy.NEVER);

buttonBar.setVisible(false);

setActionHeadingLabelText("");

actionBackgroundColourPicker.setValue(Color.WHITE);

displayTextColourPicker.setValue(Color.WHITE);

if(actionNull)

{

action = null;

if(actionBox !=null)

{

actionBox.setSelected(false);

actionBox = null;

}

@Override

public void clear()

{

clear(true);

}

boolean isCombineChild = false;

public boolean isCombineChild() {

return isCombineChild;

}

public void renderActionProperties() throws MinorException

{

//Combine Child action

isCombineChild = getAction().getLocation().getCol() == -1;

displayNameTextField.setText(getAction().getDisplayText());

vbox.setVisible(true);

scrollPane.setVbarPolicy(ScrollPane.ScrollBarPolicy.AS_NEEDED);

buttonBar.setVisible(true);

displayTextAlignmentComboBox.getSelectionModel().select(getAction().getDisplayTextAlignment());

if(!getAction().getBgColourHex().isEmpty())

actionBackgroundColourPicker.setValue(Color.valueOf(getAction().getBgColourHex()));

else

actionBackgroundColourTransparentCheckBox.setSelected(true);

if(!getAction().getDisplayTextFontColourHex().isEmpty())

displayTextColourPicker.setValue(Color.valueOf(getAction().getDisplayTextFontColourHex()));

else

displayTextColourDefaultCheckBox.setSelected(true);

hideDisplayTextCheckBox.setSelected(!getAction().isShowDisplayText());

if(getAction().isInvalid())

{

setActionHeadingLabelText("Invalid action ("+getAction().getModuleName()+")");

return;

}

saveButton.setVisible(!getAction().isInvalid());

if(isCombineChild)

{

setReturnButtonForCombineActionChildVisible(true);

normalActionsPropsVBox.setVisible(false);

normalToggleActionCommonPropsVBox.setVisible(false);

hideDisplayTextCheckBox.setSelected(false);

hideDisplayTextCheckBox.setVisible(false);

}

else

{

normalToggleActionCommonPropsVBox.setVisible(true);

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

{

normalActionsPropsVBox.setVisible(false);

toggleActionsPropsVBox.setVisible(true);

boolean doesToggleOnExist = getAction().getIcons().containsKey("toggle_on");

boolean isToggleOnHidden = getAction().getCurrentIconState().contains("toggle_on");

if(!doesToggleOnExist)

isToggleOnHidden = false;

hideToggleOnIconCheckBox.setDisable(!doesToggleOnExist);

hideToggleOnIconCheckBox.setSelected(isToggleOnHidden);

boolean doesToggleOffExist = getAction().getIcons().containsKey("toggle_off");

boolean isToggleOffHidden = getAction().getCurrentIconState().contains("toggle_off");

if(!doesToggleOffExist)

isToggleOffHidden = false;

hideToggleOffIconCheckBox.setDisable(!doesToggleOffExist);

hideToggleOffIconCheckBox.setSelected(isToggleOffHidden);

}

else

{

normalActionsPropsVBox.setVisible(true);

toggleActionsPropsVBox.setVisible(false);

boolean doesDefaultExist = getAction().getIcons().containsKey("default");

boolean isDefaultHidden = !getAction().getCurrentIconState().equals("default");

if(!doesDefaultExist)

isDefaultHidden = false;

hideDefaultIconCheckBox.setDisable(!doesDefaultExist);

hideDefaultIconCheckBox.setSelected(isDefaultHidden);

}

setReturnButtonForCombineActionChildVisible(false);

hideDisplayTextCheckBox.setVisible(true);

setFolderButtonVisible(getAction().getActionType().equals(ActionType.FOLDER));

setResetToDefaultsButtonVisible(!(getAction().getActionType().equals(ActionType.FOLDER) || getAction().getActionType().equals(ActionType.COMBINE)));

clearIconButton.setDisable(!getAction().isHasIcon());

}

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

{

setActionHeadingLabelText(getAction().getName());

}

else if(getAction().getActionType() == ActionType.COMBINE)

{

setActionHeadingLabelText("Combine action");

}

else if(getAction().getActionType() == ActionType.FOLDER)

{

setActionHeadingLabelText("Folder action");

}

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

{

renderClientProperties();

renderPluginExtraButtonBar();

}

else if(getAction().getActionType() == ActionType.COMBINE)

renderCombineActionProperties();

}

private void renderPluginExtraButtonBar()

{

ExternalPlugin externalPlugin = (ExternalPlugin) getAction();

externalPlugin.initClientActionSettingsButtonBar();

if(externalPlugin.getClientActionSettingsButtonBar() != null)

{

HBox tba = new HBox(SpaceFiller.horizontal(), externalPlugin.getClientActionSettingsButtonBar());

pluginExtraButtonBar.getChildren().add(tba);

}

private CombineActionPropertiesPane combineActionPropertiesPane;

public CombineActionPropertiesPane getCombineActionPropertiesPane() {

return combineActionPropertiesPane;

}

public void setReturnButtonForCombineActionChildVisible(boolean visible)

{

returnButtonForCombineActionChild.setVisible(visible);

}

public void renderCombineActionProperties()

{

try

{

combineActionPropertiesPane = new CombineActionPropertiesPane((CombineAction) getAction(),

getClientProfile(),

this

);

clientPropertiesVBox.getChildren().add(combineActionPropertiesPane);

}

catch (MinorException e)

{

e.printStackTrace();

exceptionAndAlertHandler.handleMinorException(e);

}

@Override

public synchronized void setAction(Action action) {

this.action = action;

}

@Override

public void onOpenFolderButtonClicked()

{

actionBox.getActionGridPaneListener().renderFolder((FolderAction) getAction());

clear();

}

@Override

public Window getCurrentWindow() {

return getScene().getWindow();

}

private ArrayList<UIPropertyBox> actionClientProperties;

private TextField delayBeforeRunningTextField;

public void renderClientProperties() throws MinorException

{

delayBeforeRunningTextField = new TextField();

delayBeforeRunningTextField.setText(getAction().getDelayBeforeExecuting()+"");

clientPropertiesVBox.getChildren().add(

new HBoxInputBox("Delay before running (milli-seconds)", delayBeforeRunningTextField, 100)

);

for(int i =0;i< getAction().getClientProperties().getSize(); i++)

{

Property eachProperty = getAction().getClientProperties().get().get(i);

if(!eachProperty.isVisible())

continue;

Helper.ControlNodePair controlNodePair = new Helper().getControlNode(eachProperty);

Label label = new Label(eachProperty.getDisplayName());

UIPropertyBox clientProperty = new UIPropertyBox(i, eachProperty.getDisplayName(), controlNodePair.getControlNode(),

Node controlNode = Helper.getControlNode(eachProperty);

HBoxWithSpaceBetween hBoxWithSpaceBetween = new HBoxWithSpaceBetween(label, controlNode);

UIPropertyBox clientProperty = new UIPropertyBox(i, eachProperty.getDisplayName(), controlNode,

eachProperty.getControlType(), eachProperty.getType(), eachProperty.isCanBeBlank());

actionClientProperties.add(clientProperty);

clientPropertiesVBox.getChildren().add(controlNodePair.getUINode());

clientPropertiesVBox.getChildren().add(hBoxWithSpaceBetween);

}

public void onSaveButtonClicked()

{

try

{

validateForm();

saveAction(true, true);

}

catch (MinorException e)

{

exceptionAndAlertHandler.handleMinorException(e);

}

private boolean sendIcon = false;

@Override

public void setSendIcon(boolean sendIcon)

{

this.sendIcon = sendIcon;

}

public void addActionToCurrentClientProfile(Action newAction) throws CloneNotSupportedException {

getClientProfile().addAction(newAction);

}

@Override

public synchronized void saveAction(Action action, boolean runAsync, boolean runOnActionSavedFromServer)

{

String delayBeforeRunning = "0";

if(action.getActionType() != ActionType.FOLDER && action.getActionType() !=ActionType.COMBINE)

delayBeforeRunning =delayBeforeRunningTextField.getText();

new OnSaveActionTask(

ClientConnections.getInstance().getClientConnectionBySocketAddress(

getClient().getRemoteSocketAddress()

action, delayBeforeRunning,

displayNameTextField.getText(),

isCombineChild(),

!hideDisplayTextCheckBox.isSelected(),

displayTextColourDefaultCheckBox.isSelected(),

"#" + displayTextColourPicker.getValue().toString().substring(2),

clearIconButton.isDisable(),

hideDefaultIconCheckBox.isSelected(),

hideToggleOffIconCheckBox.isSelected(),

hideToggleOnIconCheckBox.isSelected(),

displayTextAlignmentComboBox.getSelectionModel().getSelectedItem(),

actionBackgroundColourTransparentCheckBox.isSelected(),

"#" + actionBackgroundColourPicker.getValue().toString().substring(2),

getCombineActionPropertiesPane(),

clientProfile, sendIcon, actionBox, actionClientProperties, exceptionAndAlertHandler,

saveButton, deleteButton, resetToDefaultsButton, runOnActionSavedFromServer, runAsync, this

);

}

@Override

public void saveAction(boolean runAsync, boolean runOnActionSavedFromServer)

{

saveAction(getAction(), runAsync, runOnActionSavedFromServer);

}

public void setFolderButtonVisible(boolean visible)

{

openFolderButton.setVisible(visible);

}

public void setResetToDefaultsButtonVisible(boolean visible)

{

resetToDefaultsButton.setVisible(visible);

}

public void validateForm() throws MinorException

{

String displayNameStr = displayNameTextField.getText();

StringBuilder finalErrors = new StringBuilder();

if(displayNameStr.isBlank())

{

finalErrors.append(" * Display Name cannot be blank\n");

}

if(!isCombineChild())

{

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

{

if(getAction().isHasIcon())

{

if(hideDisplayTextCheckBox.isSelected() && hideDefaultIconCheckBox.isSelected())

{

finalErrors.append(" * Both Icon and display text check box cannot be hidden.\n");

}

else

{

if(hideDisplayTextCheckBox.isSelected())

finalErrors.append(" * Display Text cannot be hidden since there is no icon.\n");

}

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

{

try

{

int n = Integer.parseInt(delayBeforeRunningTextField.getText());

if (n<0)

{

finalErrors.append(" * Sleep should be greater than 0.\n");

}

catch (Exception e)

{

finalErrors.append(" * Sleep should be a number.\n");

}

for (UIPropertyBox clientProperty : actionClientProperties) {

Node controlNode = clientProperty.getControlNode();

if (clientProperty.getControlType() == ControlType.TEXT_FIELD ||

clientProperty.getControlType() == ControlType.FILE_PATH)

{

String value = ((TextField) controlNode).getText();

if(clientProperty.getType() == Type.INTEGER)

{

try

{

Integer.parseInt(value);

}

catch (NumberFormatException e)

{

finalErrors.append(" -> ").append(clientProperty.getDisplayName()).append(" must be integer.\n");

}

else

{

if(value.isBlank() && !clientProperty.isCanBeBlank())

finalErrors.append(" -> ").append(clientProperty.getDisplayName()).append(" cannot be blank.\n");

}

if(!finalErrors.toString().isEmpty())

{

throw new MinorException("You made mistakes",

finalErrors.toString());

}

@Override

public void onDeleteButtonClicked()

{

StreamPiAlert streamPiAlert = new StreamPiAlert(

"Warning",

"Are you sure you want to delete the action?",

StreamPiAlertType.WARNING

);

String optionYes = "Yes";

String optionNo = "No";

streamPiAlert.setButtons(optionYes, optionNo);

ActionDetailsPane actionDetailsPane = this;

streamPiAlert.setOnClicked(new StreamPiAlertListener() {

@Override

public void onClick(String s) {

if(s.equals(optionYes))

{

new OnDeleteActionTask(

ClientConnections.getInstance().getClientConnectionBySocketAddress(

getClient().getRemoteSocketAddress()

action,

isCombineChild(),

getCombineActionPropertiesPane(),

clientProfile, actionBox, actionDetailsPane, exceptionAndAlertHandler,

!isCombineChild

);

}

});

streamPiAlert.show();

}

M src/main/java/com/stream_pi/server/window/helper/Helper.java

+62 −9

package com.stream_pi.server.window.helper;

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

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

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

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

import com.stream_pi.util.exception.MinorException;

import com.stream_pi.util.uihelper.HBoxInputBoxWithFileChooser;

import com.stream_pi.util.uihelper.HBoxWithSpaceBetween;

import javafx.scene.Node;

import javafx.scene.control.*;

import javafx.stage.FileChooser;

import javafx.util.Callback;

public class Helper

{

public static Node getControlNode(Property property) throws MinorException

public class ControlNodePair

{

private Node controlNode = null;

private Node UINode = null;

public ControlNodePair(Node controlNode, Node UINode)

{

this.controlNode = controlNode;

this.UINode = UINode;

}

public Node getUINode()

{

return UINode;

}

public Node getControlNode()

{

return controlNode;

}

public ControlNodePair getControlNode(Property property) throws MinorException

{

Node UINode = null, controlNode = null;

if(property.getControlType() == ControlType.COMBO_BOX)

{

ComboBox<ListValue> comboBox = new ComboBox<>();

comboBox.getItems().addAll(property.getListValue());

Callback<ListView<ListValue>, ListCell<ListValue>> clientsComboBoxFactory = new Callback<>() {

@Override

public ListCell<ListValue> call(ListView<ListValue> clientConnectionListView) {

return new ListCell<>() {

@Override

protected void updateItem(ListValue listValue, boolean b)

{

super.updateItem(listValue, b);

if(listValue == null)

{

setText("Choose value");

}

else

{

setText(listValue.getDisplayName());

}

};

}

};

comboBox.setCellFactory(clientsComboBoxFactory);

comboBox.setButtonCell(clientsComboBoxFactory.call(null));

comboBox.getSelectionModel().select(property.getSelectedIndex());

return comboBox;

controlNode = comboBox;

}

else if(property.getControlType() == ControlType.TEXT_FIELD)

{

return new TextField(property.getRawValue());

controlNode = new TextField(property.getRawValue());

}

else if(property.getControlType() == ControlType.TEXT_FIELD_MASKED)

{

PasswordField textField = new PasswordField();

textField.setText(property.getRawValue());

return textField;

controlNode = textField;

}

else if(property.getControlType() == ControlType.TOGGLE)

{

ToggleButton toggleButton = new ToggleButton();

toggleButton.setSelected(property.getBoolValue());

if(property.getBoolValue())

toggleButton.setText("ON");

else

toggleButton.setText("OFF");

toggleButton.selectedProperty().addListener((observableValue, aBoolean, t1) -> {

if(t1)

toggleButton.setText("ON");

else

toggleButton.setText("OFF");

});

return toggleButton;

controlNode = toggleButton;

}

else if(property.getControlType() == ControlType.SLIDER_DOUBLE)

{

Slider slider = new Slider();

slider.setValue(property.getDoubleValue());

slider.setMax(property.getMaxDoubleValue());

slider.setMin(property.getMinDoubleValue());

return slider;

controlNode = slider;

}

else if(property.getControlType() == ControlType.SLIDER_INTEGER)

{

Slider slider = new Slider();

slider.setValue(property.getIntValue());

slider.setMax(property.getMaxIntValue());

slider.setMin(property.getMinIntValue());

slider.setBlockIncrement(1.0);

slider.setSnapToTicks(true);

return slider;

controlNode = slider;

}

else if(property.getControlType() == ControlType.FILE_PATH)

{

TextField textField = new TextField(property.getRawValue());

FileExtensionFilter[] fileExtensionFilters = property.getExtensionFilters();

FileChooser.ExtensionFilter[] extensionFilters = new FileChooser.ExtensionFilter[fileExtensionFilters.length];

for(int x = 0;x<fileExtensionFilters.length;x++)

{

extensionFilters[x] = new FileChooser.ExtensionFilter(

fileExtensionFilters[x].getDescription(),

fileExtensionFilters[x].getExtensions()

);

}

UINode = new HBoxInputBoxWithFileChooser(property.getDisplayName(), textField, null,

extensionFilters);

controlNode =textField;

}

if(property.getControlType() != ControlType.FILE_PATH)

{

UINode = new HBoxWithSpaceBetween(new Label(property.getDisplayName()), controlNode);

}

return null;

return new ControlNodePair(controlNode, UINode);

}

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

+8 −0

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());

}

if(config.getStartOnBoot() != startOnBoot)

{

if(StartupFlags.RUNNER_FILE_NAME == null)

{

new StreamPiAlert("Uh Oh", "No Runner File Name Specified as startup arguments. Cant set run at boot.", StreamPiAlertType.ERROR).show();

startOnBoot = false;

}

else

{

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

if(startOnBoot)

{

startAtBoot.create(new File(StartupFlags.RUNNER_FILE_NAME));

}

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();

}

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

+3 −13

package com.stream_pi.server.window.settings;

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

import com.stream_pi.action_api.externalplugin.ExternalPlugin;

import com.stream_pi.server.uipropertybox.UIPropertyBox;

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

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

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

import com.stream_pi.server.action.ExternalPlugins;

import com.stream_pi.server.controller.ServerListener;

import com.stream_pi.server.window.ExceptionAndAlertHandler;

import com.stream_pi.server.window.helper.Helper;

import com.stream_pi.util.exception.MinorException;

import com.stream_pi.util.uihelper.HBoxWithSpaceBetween;

import com.stream_pi.util.uihelper.SpaceFiller;

import javafx.util.Callback;

import org.kordamp.ikonli.javafx.FontIcon;

import javafx.application.HostServices;

import javafx.application.Platform;

import javafx.geometry.Pos;

import javafx.scene.Node;

import javafx.scene.control.*;

import javafx.scene.layout.HBox;

import javafx.scene.layout.Priority;

import javafx.scene.layout.Region;

import javafx.scene.layout.VBox;

import java.util.ArrayList;

import java.util.List;

import java.util.logging.Logger;

public class PluginsSettings extends VBox {

private VBox pluginsSettingsVBox;

private ServerListener serverListener;

private Logger logger;

private ExceptionAndAlertHandler exceptionAndAlertHandler;

private HostServices hostServices;

public PluginsSettings(ExceptionAndAlertHandler exceptionAndAlertHandler, HostServices hostServices)

{

getStyleClass().add("plugins_settings");

this.hostServices = hostServices;

this.exceptionAndAlertHandler = exceptionAndAlertHandler;

pluginProperties = new ArrayList<>();

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

pluginsSettingsVBox = new VBox();

pluginsSettingsVBox.getStyleClass().add("plugins_settings_vbox");

pluginsSettingsVBox.setAlignment(Pos.TOP_CENTER);

ScrollPane scrollPane = new ScrollPane();

scrollPane.getStyleClass().add("plugins_settings_scroll_pane");

scrollPane.setHbarPolicy(ScrollPane.ScrollBarPolicy.NEVER);

scrollPane.maxWidthProperty().bind(widthProperty().multiply(0.8));

pluginsSettingsVBox.prefWidthProperty().bind(scrollPane.widthProperty().subtract(25));

scrollPane.setContent(pluginsSettingsVBox);

VBox.setVgrow(scrollPane, Priority.ALWAYS);

setAlignment(Pos.TOP_CENTER);

saveButton = new Button("Save");

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

HBox hBox = new HBox(saveButton);

hBox.setAlignment(Pos.CENTER_RIGHT);

getChildren().addAll(scrollPane, hBox);

}

private Button saveButton;

public void onSaveButtonClicked()

{

try {

//form validation

StringBuilder finalErrors = new StringBuilder();

for (PluginProperties p : pluginProperties)

{

StringBuilder errors = new StringBuilder();

for(int j = 0; j < p.getServerPropertyUIBox().size(); j++)

{

UIPropertyBox serverProperty = p.getServerPropertyUIBox().get(j);

Node controlNode = serverProperty.getControlNode();

if (serverProperty.getControlType() == ControlType.TEXT_FIELD)

{

String value = ((TextField) controlNode).getText();

if(serverProperty.getType() == Type.INTEGER)

{

try

{

Integer.parseInt(value);

}

catch (NumberFormatException e)

{

errors.append(" -> ").append(serverProperty.getDisplayName()).append(" must be integer.\n");

}

else

{

if(value.isBlank() && !serverProperty.isCanBeBlank())

errors.append(" -> ").append(serverProperty.getDisplayName()).append(" cannot be blank.\n");

}

else if(serverProperty.getControlType() == ControlType.TEXT_FIELD_MASKED)

{

String value = ((TextField) controlNode).getText();

if(value.isBlank() && !serverProperty.isCanBeBlank())

errors.append(" -> ").append(serverProperty.getDisplayName()).append(" cannot be blank.\n");

}

if(!errors.toString().isBlank())

{

finalErrors.append(" * ").append(p.getName()).append("\n").append(errors.toString()).append("\n");

}

if(!finalErrors.toString().isEmpty())

{

throw new MinorException("Form Validation Errors",

"Please rectify the following errors and try again \n"+finalErrors.toString());

}

//save

for (PluginProperties pp : pluginProperties) {

for (int j = 0; j < pp.getServerPropertyUIBox().size(); j++) {

UIPropertyBox serverProperty = pp.getServerPropertyUIBox().get(j);

String rawValue = serverProperty.getRawValue();

ExternalPlugins.getInstance().getActionFromIndex(pp.getIndex())

.getServerProperties().get()

.get(serverProperty.getIndex()).setRawValue(rawValue);

}

ExternalPlugins.getInstance().saveServerSettings();

ExternalPlugins.getInstance().initPlugins();

}

catch (MinorException e)

{

e.printStackTrace();

exceptionAndAlertHandler.handleMinorException(e);

}

private ArrayList<PluginProperties> pluginProperties;

public void showPluginInitError()

{

Platform.runLater(()->{

pluginsSettingsVBox.getChildren().add(new Label("Plugin init error. Resolve issues and restart."));

saveButton.setVisible(false);

});

}

public void loadPlugins() throws MinorException {

pluginProperties.clear();

List<ExternalPlugin> actions = ExternalPlugins.getInstance().getPlugins();

Platform.runLater(()-> pluginsSettingsVBox.getChildren().clear());

if(actions.size() == 0)

{

Platform.runLater(()->{

Label l = new Label("No Plugins Installed.");

l.getStyleClass().add("plugins_pane_no_plugins_installed_label");

pluginsSettingsVBox.getChildren().add(l);

saveButton.setVisible(false);

});

return;

}

else

{

Platform.runLater(()->saveButton.setVisible(true));

}

for(int i = 0; i<actions.size(); i++)

{

ExternalPlugin action = actions.get(i);

if(!action.isVisibleInServerSettingsPane())

continue;

Label headingLabel = new Label(action.getName());

headingLabel.getStyleClass().add("plugins_settings_each_plugin_heading_label");

HBox headerHBox = new HBox(headingLabel);

headerHBox.getStyleClass().add("plugins_settings_each_plugin_header");

if (action.getHelpLink()!=null)

{

Button helpButton = new Button();

helpButton.getStyleClass().add("plugins_settings_each_plugin_help_button");

FontIcon questionIcon = new FontIcon("fas-question");

questionIcon.getStyleClass().add("plugins_settings_each_plugin_help_icon");

helpButton.setGraphic(questionIcon);

helpButton.setOnAction(event -> hostServices.showDocument(action.getHelpLink()));

headerHBox.getChildren().addAll(SpaceFiller.horizontal() ,helpButton);

}

Label authorLabel = new Label(action.getAuthor());

authorLabel.getStyleClass().add("plugins_settings_each_plugin_author_label");

Label moduleLabel = new Label(action.getModuleName());

moduleLabel.getStyleClass().add("plugins_settings_each_plugin_module_label");

Label versionLabel = new Label("Version : "+action.getVersion().getText());

versionLabel.getStyleClass().add("plugins_settings_each_plugin_version_label");

VBox serverPropertiesVBox = new VBox();

serverPropertiesVBox.getStyleClass().add("plugins_settings_each_plugin_server_properties_box");

serverPropertiesVBox.setSpacing(10.0);

List<Property> serverProperties = action.getServerProperties().get();

ArrayList<UIPropertyBox> serverPropertyArrayList = new ArrayList<>();

for(int j =0; j<serverProperties.size(); j++)

{

Property eachProperty = serverProperties.get(j);

if(!eachProperty.isVisible())

continue;

Helper.ControlNodePair controlNodePair = new Helper().getControlNode(eachProperty);

UIPropertyBox serverProperty = new UIPropertyBox(j, eachProperty.getDisplayName(), controlNodePair.getControlNode(), eachProperty.getControlType(), eachProperty.getType(), eachProperty.isCanBeBlank());

Label label = new Label(eachProperty.getDisplayName());

Node controlNode = Helper.getControlNode(eachProperty);

HBoxWithSpaceBetween hBoxWithSpaceBetween = new HBoxWithSpaceBetween(label, controlNode);

UIPropertyBox serverProperty = new UIPropertyBox(j, eachProperty.getDisplayName(), controlNode, eachProperty.getControlType(), eachProperty.getType(), eachProperty.isCanBeBlank());

serverPropertyArrayList.add(serverProperty);

serverPropertiesVBox.getChildren().add(controlNodePair.getUINode());

serverPropertiesVBox.getChildren().add(hBoxWithSpaceBetween);

}

PluginProperties pp = new PluginProperties(i, serverPropertyArrayList, action.getName());

pluginProperties.add(pp);

Platform.runLater(()->{

VBox vBox = new VBox();

vBox.getStyleClass().add("plugins_settings_each_plugin_box");

vBox.setSpacing(5.0);

vBox.getChildren().addAll(headerHBox, authorLabel, moduleLabel, versionLabel, serverPropertiesVBox);

if(action.getServerSettingsButtonBar()!=null)

{

action.getServerSettingsButtonBar().getStyleClass().add("plugins_settings_each_plugin_button_bar");

HBox buttonBarHBox = new HBox(SpaceFiller.horizontal(), action.getServerSettingsButtonBar());

buttonBarHBox.getStyleClass().add("plugins_settings_each_plugin_button_bar_hbox");

vBox.getChildren().add(buttonBarHBox);

}

pluginsSettingsVBox.getChildren().add(vBox);

});

}

public class PluginProperties

{

private int index;

private ArrayList<UIPropertyBox> serverProperty;

private String name;

public PluginProperties(int index, ArrayList<UIPropertyBox> serverProperty, String name)

{

this.index = index;

this.serverProperty = serverProperty;

this.name = name;

}

public String getName()

{

return name;

}

public int getIndex() {

return index;

}

public ArrayList<UIPropertyBox> getServerPropertyUIBox() {

return serverProperty;

}

Public

server

Clone or download

fix #52

Modified Files