server

fixed lots of stuff, and added lots of stufffff

Download Browse

+89 −18

Author

Debayan Sutradhar (rnayabed) 2021-04-01 01:38

Committer

Debayan Sutradhar (rnayabed) 2021-04-01 01:38

Hash bf4b1574eed8514e4d49367f05a0b2ac3b432287

Parent a6eedf4d002a7f3dd1e337ee8c75b01979d2d305

Reference git #server/bf4b1574eed8514e4d49367f05a0b2ac3b432287

Modified Files

List

Side by side diff

Inline diff

M src/main/java/com/stream_pi/server/connection/ClientConnection.java

+6 −2

package com.stream_pi.server.connection;

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.Property;

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

import com.stream_pi.action_api.externalplugin.ExternalPlugin;

import com.stream_pi.action_api.externalplugin.NormalAction;

import com.stream_pi.action_api.externalplugin.ToggleAction;

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.client.ClientTheme;

import com.stream_pi.server.info.ServerInfo;

import com.stream_pi.server.window.ExceptionAndAlertHandler;

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

import com.stream_pi.util.alert.StreamPiAlert;

import com.stream_pi.util.alert.StreamPiAlertType;

import com.stream_pi.util.comms.Message;

import com.stream_pi.util.exception.MinorException;

import com.stream_pi.util.exception.SevereException;

import com.stream_pi.util.exception.StreamPiException;

import com.stream_pi.util.platform.Platform;

import com.stream_pi.util.platform.ReleaseStatus;

import com.stream_pi.util.version.Version;

import javafx.concurrent.Task;

import java.io.*;

import java.net.Socket;

import java.net.SocketAddress;

import java.util.ArrayList;

import java.util.concurrent.atomic.AtomicBoolean;

import java.util.logging.Level;

import java.util.logging.Logger;

public class ClientConnection extends Thread

{

private Socket socket;

private ServerListener serverListener;

private AtomicBoolean stop = new AtomicBoolean(false);

private ObjectOutputStream oos;

private ObjectInputStream ois;

private Logger logger;

private Client client = null;

private ExceptionAndAlertHandler exceptionAndAlertHandler;

public ClientConnection(Socket socket, ServerListener serverListener, ExceptionAndAlertHandler exceptionAndAlertHandler)

{

this.exceptionAndAlertHandler = exceptionAndAlertHandler;

this.socket = socket;

this.serverListener = serverListener;

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

try

{

oos = new ObjectOutputStream(socket.getOutputStream());

ois = new ObjectInputStream(socket.getInputStream());

} catch (IOException e) {

e.printStackTrace();

exceptionAndAlertHandler.handleMinorException(new MinorException("Unable to start socket streams"));

}

start();

}

public synchronized void exit()

{

if(stop.get())

return;

logger.info("Stopping ...");

try

{

if(socket !=null)

{

logger.info("Stopping connection "+getRemoteSocketAddress());

disconnect();

}

catch (SevereException e)

{

e.printStackTrace();

exceptionAndAlertHandler.handleSevereException(e);

}

public SocketAddress getRemoteSocketAddress()

{

return socket.getRemoteSocketAddress();

}

public synchronized void exitAndRemove()

{

exit();

removeConnection();

serverListener.clearTemp();

}

public void removeConnection()

{

ClientConnections.getInstance().removeConnection(this);

}

public void sendIcon(String profileID, String actionID, String state, byte[] icon) throws SevereException

{

try

{

Thread.sleep(50);

}

catch (InterruptedException e)

{

e.printStackTrace();

}

Message message = new Message("action_icon");

message.setStringArrValue(profileID, actionID, state);

message.setByteArrValue(icon);

sendMessage(message);

}

public void initAfterConnectionQueryReceive(Message message) throws StreamPiException

{

String[] ar = message.getStringArrValue();

logger.info("Setting up client object ...");

Version clientVersion;

Version commsStandard;

Version themesStandard;

ReleaseStatus releaseStatus;

try

{

clientVersion = new Version(ar[0]);

releaseStatus = ReleaseStatus.valueOf(ar[1]);

commsStandard = new Version(ar[2]);

themesStandard = new Version(ar[3]);

}

catch (MinorException e)

{

exitAndRemove();

throw new MinorException(e.getShortMessage()+" (client '"+socket.getRemoteSocketAddress()+"' )");

}

if(!commsStandard.isEqual(ServerInfo.getInstance().getCommStandardVersion()))

{

String errTxt = "Server and client Communication standards do not match. Make sure you are on the latest version of server and client.\n" +

"Server Comms. Standard : "+ServerInfo.getInstance().getCommStandardVersion().getText()+

"\nclient Comms. Standard : "+commsStandard.getText();

disconnect(errTxt);

throw new MinorException(errTxt);

}

client = new Client(clientVersion, releaseStatus, commsStandard, themesStandard, ar[4], Platform.valueOf(ar[7]), socket.getRemoteSocketAddress());

client.setDisplayWidth(Double.parseDouble(ar[5]));

client.setDisplayHeight(Double.parseDouble(ar[6]));

client.setDefaultProfileID(ar[8]);

client.setDefaultThemeFullName(ar[9]);

//call get profiles command.

serverListener.clearTemp();

}

public synchronized Client getClient()

{

return client;

}

@Override

public void run() {

try {

initAfterConnectionQuerySend();

} catch (SevereException e) {

e.printStackTrace();

exceptionAndAlertHandler.handleSevereException(e);

exitAndRemove();

return;

}

try

{

while(!stop.get())

{

try

{

Message message = (Message) ois.readObject();

String header = message.getHeader();

switch (header)

{

case "action_icon" : onActionIconReceived(message);

break;

case "disconnect" : clientDisconnected(message);

break;

case "client_details" : initAfterConnectionQueryReceive(message);

getProfilesFromClient();

getThemesFromClient();

break;

case "client_screen_details" : onClientScreenDetailsReceived(message);

break;

case "profiles" : registerProfilesFromClient(message);

break;

case "profile_details" : registerProfileDetailsFromClient(message);

break;

case "action_details" : registerActionToProfile(message);

break;

case "themes": registerThemes(message);

break;

case "action_clicked": onActionClicked(message);

break;

default: logger.warning("Command '"+header+"' does not match records. Make sure client and server versions are equal.");

}

catch (IOException | ClassNotFoundException e)

{

logger.log(Level.SEVERE, e.getMessage());

e.printStackTrace();

serverListener.clearTemp();

if(!stop.get())

{

removeConnection();

throw new MinorException("Accidentally disconnected from "+getClient().getNickName()+".");

}

exitAndRemove();

return;

}

catch (StreamPiException e)

{

e.printStackTrace();

if(e instanceof MinorException)

exceptionAndAlertHandler.handleMinorException((MinorException) e);

else if (e instanceof SevereException)

exceptionAndAlertHandler.handleSevereException((SevereException) e);

}

// commands

private void onActionIconReceived(Message message) throws MinorException

{

String[] s = message.getStringArrValue();

String profileID = s[0];

String actionID = s[1];

String iconState = s[2];

getClient()

.getProfileByID(profileID)

.getActionByID(actionID)

.addIcon(iconState,message.getByteArrValue());

}

public void initAfterConnectionQuerySend() throws SevereException

{

logger.info("Asking client details ...");

sendMessage(new Message("get_client_details"));

}

public void disconnect() throws SevereException {

disconnect("");

}

public void disconnect(String message) throws SevereException {

if(stop.get())

return;

stop.set(true);

logger.info("Sending client disconnect message ...");

Message m = new Message("disconnect");

m.setStringValue(message);

sendMessage(m);

try

{

if(!socket.isClosed())

socket.close();

}

catch (IOException e)

{

e.printStackTrace();

throw new SevereException("Unable to close socket");

}

public synchronized void sendMessage(Message message) throws SevereException

{

try

{

oos.writeObject(message);

oos.flush();

}

catch (IOException e)

{

e.printStackTrace();

throw new SevereException("Unable to write to io Stream!");

}

public void clientDisconnected(Message message)

{

stop.set(true);

String txt = "Disconnected!";

String msg = message.getStringValue();

if(!msg.isBlank())

txt = "Message : "+msg;

new StreamPiAlert("Disconnected from "+getClient().getNickName()+".", txt, StreamPiAlertType.WARNING).show();;

exitAndRemove();

}

public void getProfilesFromClient() throws StreamPiException

{

logger.info("Asking client to send profiles ...");

sendMessage(new Message("get_profiles"));

}

public void getThemesFromClient() throws StreamPiException

{

logger.info("Asking clients to send themes ...");

sendMessage(new Message("get_themes"));

}

public void registerThemes(Message message)

{

String[] r = message.getStringArrValue();

for(int i =0; i<(r.length);i+=4)

{

ClientTheme clientTheme = new ClientTheme(

r[i],

r[i+1],

r[i+2],

r[i+3]

);

try

{

getClient().addTheme(clientTheme);

}

catch (CloneNotSupportedException e)

{

logger.log(Level.SEVERE, e.getMessage());

e.printStackTrace();

}

public void registerProfilesFromClient(Message message) throws StreamPiException

{

logger.info("Registering profiles ...");

String[] r = message.getStringArrValue();

for (String profileID : r) {

getProfileDetailsFromClient(profileID);

}

public void getProfileDetailsFromClient(String ID) throws StreamPiException

{

logger.info("Asking client to send details of profile : "+ID);

Message message = new Message("get_profile_details");

message.setStringValue(ID);

sendMessage(message);

}

public void registerProfileDetailsFromClient(Message message)

{

String[] r = message.getStringArrValue();

String ID = r[0];

logger.info("Registering details for profile : "+ID);

String name = r[1];

int rows = Integer.parseInt(r[2]);

int cols = Integer.parseInt(r[3]);

int actionSize = Integer.parseInt(r[4]);

int actionGap = Integer.parseInt(r[5]);

ClientProfile clientProfile = new ClientProfile(name, ID, rows, cols, actionSize, actionGap);

logger.info("Added client profile "+clientProfile.getName());

try

{

getClient().addProfile(clientProfile);

}

catch (CloneNotSupportedException e)

{

logger.severe(e.getMessage());

e.printStackTrace();

}

serverListener.clearTemp();

}

public synchronized void registerActionToProfile(Message message) throws StreamPiException

{

String[] r = message.getStringArrValue();

String profileID = r[0];

String ID = r[1];

ActionType actionType = ActionType.valueOf(r[2]);

//3 - Version

//4 - ModuleName

//display

String bgColorHex = r[5];

//icon

String[] allIconStateNames = r[6].split("::");

String defaultIconState = r[7];

//text

boolean isShowDisplayText = r[8].equals("true");

String displayFontColor = r[9];

String displayText = r[10];

DisplayTextAlignment displayTextAlignment = DisplayTextAlignment.valueOf(r[11]);

//location

String row = r[12];

String col = r[13];

Location location = new Location(Integer.parseInt(row), Integer.parseInt(col));

String root = r[14];

int delayBeforeRunning = Integer.parseInt(r[15]);

//client properties

int clientPropertiesSize = Integer.parseInt(r[16]);

ClientProperties clientProperties = new ClientProperties();

if(actionType == ActionType.FOLDER)

clientProperties.setDuplicatePropertyAllowed(true);

for(int i = 17;i<((clientPropertiesSize*2) + 17); i+=2)

{

Property property = new Property(r[i], Type.STRING);

property.setRawValue(r[i+1]);

clientProperties.addProperty(property);

}

//set up action

//action toBeAdded = null;

boolean createBasicAction = false;

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

{

String moduleName = r[4];

Version version = new Version(r[3]);

ExternalPlugin originalAction = ExternalPlugins.getInstance().getPluginByModuleName(moduleName);

if(originalAction == null)

{

createBasicAction = true;

}

else

{

if(originalAction.getVersion().getMajor() != version.getMajor())

{

createBasicAction = true;

}

else

{

try

{

ExternalPlugin newPlugin = originalAction.clone();

newPlugin.setID(ID);

System.out.println("SAVVEEEEEEEEEEEEEEE@@@@@ : "+profileID);

newPlugin.setProfileID(profileID);

newPlugin.setSocketAddressForClient(socket.getRemoteSocketAddress());

newPlugin.setBgColourHex(bgColorHex);

newPlugin.setCurrentIconState(defaultIconState);

newPlugin.setShowDisplayText(isShowDisplayText);

newPlugin.setDisplayTextFontColourHex(displayFontColor);

newPlugin.setDisplayText(displayText);

newPlugin.setDisplayTextAlignment(displayTextAlignment);

newPlugin.setLocation(location);

newPlugin.setParent(root);

newPlugin.setDelayBeforeExecuting(delayBeforeRunning);

ClientProperties finalClientProperties = new ClientProperties();

for(Property property : originalAction.getClientProperties().get())

{

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

{

Property property1 = clientProperties.get().get(i);

if (property.getName().equals(property1.getName()))

{

property.setRawValue(property1.getRawValue());

finalClientProperties.addProperty(property);

}

newPlugin.setClientProperties(finalClientProperties);

getClient().getProfileByID(profileID).addAction(newPlugin);

}

catch (CloneNotSupportedException e)

{

exceptionAndAlertHandler.handleMinorException(new MinorException("action", "Unable to clone"));

}

else

{

createBasicAction = true;

}

if(createBasicAction)

{

Action action = new Action(ID, actionType);

action.setID(ID);

action.setProfileID(profileID);

action.setSocketAddressForClient(socket.getRemoteSocketAddress());

action.setBgColourHex(bgColorHex);

action.setCurrentIconState(defaultIconState);

action.setShowDisplayText(isShowDisplayText);

action.setDisplayTextFontColourHex(displayFontColor);

action.setDisplayText(displayText);

action.setDisplayTextAlignment(displayTextAlignment);

action.setLocation(location);

action.setParent(root);

action.setDelayBeforeExecuting(delayBeforeRunning);

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

{

String moduleName = r[4];

Version version = new Version(r[3]);

action.setInvalid(true);

action.setVersion(version);

action.setModuleName(moduleName);

}

action.setClientProperties(clientProperties);

try

{

getClient().getProfileByID(profileID).addAction(action);

}

catch (CloneNotSupportedException e)

{

e.printStackTrace();

exceptionAndAlertHandler.handleMinorException(new MinorException("action", "Unable to clone"));

}

public synchronized void saveActionDetails(String profileID, Action action) throws SevereException

{

ArrayList<String> a = new ArrayList<>();

a.add(profileID);

a.add(action.getID());

a.add(action.getActionType()+"");

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

{

a.add(action.getVersion().getText());

System.out.println("VERSION :sdd "+action.getVersion().getText());

}

else

{

a.add("no");

}

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

{

a.add(action.getModuleName());

}

else

{

a.add("nut");

}

//display

a.add(action.getBgColourHex());

//icon

StringBuilder allIconStatesNames = new StringBuilder();

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

{

allIconStatesNames.append(eachState).append("::");

}

a.add(allIconStatesNames.toString());

a.add(action.getCurrentIconState());

//text

a.add(action.isShowDisplayText()+"");

a.add(action.getDisplayTextFontColourHex());

a.add(action.getDisplayText());

a.add(action.getDisplayTextAlignment()+"");

//location

if(action.getLocation() == null)

{

a.add("-1");

}

else

{

a.add(action.getLocation().getRow()+"");

a.add(action.getLocation().getCol()+"");

}

a.add(action.getParent());

a.add(action.getDelayBeforeExecuting()+"");

//client properties

ClientProperties clientProperties = action.getClientProperties();

a.add(clientProperties.getSize()+"");

for(Property property : clientProperties.get())

{

a.add(property.getName());

a.add(property.getRawValue());

}

Message message = new Message("save_action_details");

String[] x = new String[a.size()];

x = a.toArray(x);

message.setStringArrValue(x);

sendMessage(message);

}

public void getClientScreenDetails() throws SevereException

{

Message message = new Message("get_client_screen_details");

sendMessage(message);

}

public void onClientScreenDetailsReceived(Message message)

{

double width = Double.parseDouble(message.getStringArrValue()[0]);

double height = Double.parseDouble(message.getStringArrValue()[1]);

getClient().setDisplayWidth(width);

getClient().setDisplayHeight(height);

}

public void deleteAction(String profileID, String actionID) throws SevereException

{

Message message = new Message("delete_action");

message.setStringArrValue(profileID, actionID);

sendMessage(message);

}

public void saveClientDetails(String clientNickname, String defaultProfileID,

String defaultThemeFullName) throws SevereException

{

Message message = new Message("save_client_details");

message.setStringArrValue(

clientNickname,

defaultProfileID,

defaultThemeFullName

);

sendMessage(message);

client.setNickName(clientNickname);

client.setDefaultProfileID(defaultProfileID);

client.setDefaultThemeFullName(defaultThemeFullName);

}

public void saveProfileDetails(ClientProfile clientProfile) throws SevereException, CloneNotSupportedException {

if(client.getProfileByID(clientProfile.getID()) !=null)

{

client.getProfileByID(clientProfile.getID()).setName(clientProfile.getName());

client.getProfileByID(clientProfile.getID()).setRows(clientProfile.getRows());

client.getProfileByID(clientProfile.getID()).setCols(clientProfile.getCols());

client.getProfileByID(clientProfile.getID()).setActionSize(clientProfile.getActionSize());

client.getProfileByID(clientProfile.getID()).setActionGap(clientProfile.getActionGap());

}

else

client.addProfile(clientProfile);

Message message = new Message("save_client_profile");

message.setStringArrValue(

clientProfile.getID(),

clientProfile.getName(),

clientProfile.getRows()+"",

clientProfile.getCols()+"",

clientProfile.getActionSize()+"",

clientProfile.getActionGap()+""

);

sendMessage(message);

}

public void deleteProfile(String ID) throws SevereException

{

Message message = new Message("delete_profile");

message.setStringValue(ID);

sendMessage(message);

}

public void onActionClicked(Message message)

{

try

{

String[] r = message.getStringArrValue();

String profileID = r[0];

String actionID = r[1];

boolean toggle = r[2].equals("true");

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

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

{

if(action.isInvalid())

{

throw new MinorException(

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

);

}

else

{

if(action instanceof ToggleAction)

{

new Thread(new Task<Void>() {

@Override

protected Void call()

{

try

{

boolean result = serverListener.onToggleActionClicked((ToggleAction) action, toggle);

boolean result = serverListener.onToggleActionClicked((ToggleAction) action, toggle, profileID);

if(!result)

{

sendActionFailed(profileID, actionID);

}

catch (SevereException e)

{

exceptionAndAlertHandler.handleSevereException(e);

}

catch (Exception e)

{

e.printStackTrace();

}

return null;

}

}).start();

}

else if(action instanceof NormalAction)

{

new Thread(new Task<Void>() {

@Override

protected Void call()

{

try

{

boolean result = serverListener.onNormalActionClicked((NormalAction) action);

boolean result = serverListener.onNormalActionClicked((NormalAction) action, profileID);

if(!result)

{

sendActionFailed(profileID, actionID);

}

catch (SevereException e)

{

exceptionAndAlertHandler.handleSevereException(e);

}

catch (Exception e)

{

e.printStackTrace();

}

return null;

}

}).start();

}

} catch (Exception e) {

e.printStackTrace();

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

}

public void sendActionFailed(String profileID, String actionID) throws SevereException {

logger.info("Sending failed status ...");

Message message = new Message("action_failed");

message.setStringArrValue(profileID, actionID);

sendMessage(message);

}

M src/main/java/com/stream_pi/server/connection/MainServer.java

+1 −1

package com.stream_pi.server.connection;

import com.stream_pi.server.io.Config;

import com.stream_pi.server.window.ExceptionAndAlertHandler;

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

import com.stream_pi.util.exception.MinorException;

import com.stream_pi.util.exception.SevereException;

import javafx.application.Platform;

import javafx.stage.Stage;

import java.io.IOException;

import java.net.*;

import java.util.Enumeration;

import java.util.concurrent.atomic.AtomicBoolean;

import java.util.logging.Logger;

public class MainServer extends Thread{

private ServerListener serverListener;

private Logger logger = Logger.getLogger(MainServer.class.getName());

private int port;

private ServerSocket serverSocket = null;

//private Server server;

private AtomicBoolean stop = new AtomicBoolean(false);

private ExceptionAndAlertHandler exceptionAndAlertHandler;

public MainServer(ServerListener serverListener, ExceptionAndAlertHandler exceptionAndAlertHandler)

{

this.exceptionAndAlertHandler = exceptionAndAlertHandler;

this.serverListener = serverListener;

}

public void setPort(int port) {

this.port = port;

}

@Override

public synchronized void start() {

stop.set(false);

super.start();

}

public void stopListeningForConnections()

{

/*if(server !=null)

{

if(!server.isShutdown())

server.shutdown();

}*/

try

{

logger.info("Stopping listening for connections ...");

if(serverSocket!=null)

if(!serverSocket.isClosed())

{

stop.set(true);

serverSocket.close();

}

} catch (IOException e) {

e.printStackTrace();

}

finally {

logger.info("... Done!");

}

@Override

public void run() {

logger.warning("Starting main server on port "+port+" ...");

try {

logger.info("Starting server on port "+port+" ...");

serverSocket = new ServerSocket(port);

setupStageTitle(true);

while(!stop.get())

{

Socket s = serverSocket.accept();

ClientConnections.getInstance().addConnection(new ClientConnection(s, serverListener, exceptionAndAlertHandler));

logger.info("New client connected ("+s.getRemoteSocketAddress()+") !");

}

catch (SocketException e)

{

if(!e.getMessage().contains("Socket closed"))

if(!e.getMessage().contains("Socket closed") && !e.getMessage().contains("Interrupted function call: accept failed"))

{

logger.info("Main Server stopped accepting calls ...");

setupStageTitle(false);

exceptionAndAlertHandler.handleMinorException(new MinorException("Sorry!","Server could not be started at "+port+".\n" +

"This could be due to another process or another instance of Stream-Pi Server using the same port. \n\n" +

"If another Server Instance probably running, close it. If not, try changing the port in settings and restart Stream-Pi Server." +

"If the problem still persists, consider contacting us. \n\nFull Message : "+e.getMessage()));

e.printStackTrace();

}

catch (IOException e)

{

exceptionAndAlertHandler.handleSevereException(new SevereException("MainServer io Exception occurred!"));

e.printStackTrace();

}

private void setupStageTitle(boolean isSuccess)

{

try

{

if(isSuccess)

{

StringBuilder ips = new StringBuilder();

Enumeration<NetworkInterface> e = NetworkInterface.getNetworkInterfaces();

while(e.hasMoreElements())

{

NetworkInterface n = e.nextElement();

Enumeration<InetAddress> ee = n.getInetAddresses();

while (ee.hasMoreElements())

{

InetAddress i = ee.nextElement();

String hostAddress = i.getHostAddress();

if(i instanceof Inet4Address)

{

ips.append(hostAddress);

if(e.hasMoreElements())

ips.append(" / ");

}

Platform.runLater(()-> serverListener.getStage().setTitle("Stream-Pi Server - IP(s): "+ips.toString()+" | Port: "+ port));

}

else

{

Platform.runLater(()-> serverListener.getStage().setTitle("Stream-Pi Server - Offline"));

}

catch (Exception e)

{

e.printStackTrace();

exceptionAndAlertHandler.handleMinorException(new MinorException("Error",e.getMessage()));

}

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

+2 −2

package com.stream_pi.server.connection;

import com.stream_pi.action_api.externalplugin.NormalAction;

import com.stream_pi.action_api.externalplugin.ToggleAction;

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

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

import com.stream_pi.util.exception.SevereException;

import javafx.stage.Stage;

public interface ServerListener

{

boolean onNormalActionClicked(NormalAction action);

boolean onNormalActionClicked(NormalAction action, String profileID);

boolean onToggleActionClicked(ToggleAction action, boolean toggle);

boolean onToggleActionClicked(ToggleAction action, boolean toggle, String profileID);

void clearTemp();

void init();

void othInit();

Stage getStage();

DashboardBase getDashboardBase();

void initLogger() throws SevereException;

}

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

+43 −11

package com.stream_pi.server.controller;

import com.stream_pi.action_api.action.Action;

import com.stream_pi.action_api.action.ServerConnection;

import com.stream_pi.action_api.action.PropertySaver;

import com.stream_pi.action_api.externalplugin.NormalAction;

import com.stream_pi.action_api.externalplugin.ToggleAction;

import com.stream_pi.server.Main;

import com.stream_pi.server.action.ExternalPlugins;

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.io.Config;

import com.stream_pi.server.info.ServerInfo;

import com.stream_pi.server.window.Base;

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

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.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 javafx.animation.Interpolator;

import javafx.animation.KeyFrame;

import javafx.animation.KeyValue;

import javafx.animation.Timeline;

import javafx.application.Platform;

import javafx.beans.value.ChangeListener;

import javafx.beans.value.ObservableValue;

import javafx.concurrent.Task;

import javafx.scene.Node;

import javafx.scene.Scene;

import javafx.stage.Modality;

import javafx.stage.Stage;

import javafx.stage.WindowEvent;

import java.awt.SystemTray;

import javafx.util.Duration;

import java.awt.Toolkit;

import java.awt.TrayIcon;

import java.awt.PopupMenu;

import java.awt.MenuItem;

import java.net.Inet4Address;

import java.net.InetAddress;

import java.net.NetworkInterface;

import java.net.SocketAddress;

import java.util.Enumeration;

import java.util.Random;

import java.util.logging.Level;

public class Controller extends Base implements PropertySaver, ServerConnection

{

MainServer mainServer;

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().setServerConnection(this);

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

openSettingsTimeLine.play();

});

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

closeSettingsTimeLine.play();

});

getSettingsPane().getThemesSettings().setController(this);

mainServer = new MainServer(this, this);

if(getConfig().isFirstTimeUse())

{

Stage stage = new Stage();

Scene s = new Scene(new FirstTimeUse(this, this),

getConfig().getStartupWindowWidth(), getConfig().getStartupWindowHeight());

stage.setResizable(false);

stage.setScene(s);

stage.setTitle("Stream-Pi Server Setup");

stage.initModality(Modality.APPLICATION_MODAL);

stage.setOnCloseRequest(event->Platform.exit());

stage.show();

}

else

{

if(getConfig().isAllowDonatePopup())

{

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

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

}

othInit();

}

catch (SevereException e)

{

handleSevereException(e);

}

@Override

public void othInit()

{

try

{

if(ServerInfo.getInstance().isStartMinimised() && SystemTray.isSupported())

minimiseApp();

else

getStage().show();

}

catch(MinorException e)

{

handleMinorException(e);

}

new Thread(new Task<Void>() {

@Override

protected Void call()

{

try

{

getSettingsPane().getGeneralSettings().loadDataFromConfig();

//themes

getSettingsPane().getThemesSettings().setThemes(getThemes());

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

getSettingsPane().getThemesSettings().loadThemes();

//clients

getSettingsPane().getClientsSettings().loadData();

try

{

//Plugins

Platform.runLater(()->{

getDashboardPane().getPluginsPane().clearData();

getDashboardPane().getPluginsPane().loadOtherActions();

});

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

ExternalPlugins.getInstance().init();

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

getSettingsPane().getPluginsSettings().loadPlugins();

}

catch (MinorException e)

{

getSettingsPane().getPluginsSettings().showPluginInitError();

handleMinorException(e);

}

//Server

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

mainServer.start();

}

catch (SevereException e)

{

handleSevereException(e);

}

return null;

}

}).start();

}

@Override

public DashboardBase getDashboardBase() {

return getDashboardPane();

}

private void setupSettingsWindowsAnimations()

{

Node settingsNode = getSettingsPane();

Node dashboardNode = getDashboardPane();

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(event1 -> {

settingsNode.toFront();

});

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

new Thread(new Task<Void>() {

@Override

protected Void call() {

try {

getSettingsPane().getClientsSettings().loadData();

getSettingsPane().getGeneralSettings().loadDataFromConfig();

getSettingsPane().getPluginsSettings().loadPlugins();

getSettingsPane().getThemesSettings().setThemes(getThemes());

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

getSettingsPane().getThemesSettings().loadThemes();

getSettingsPane().setDefaultTabToGeneral();

}

catch (SevereException e)

{

handleSevereException(e);

}

catch (MinorException e)

{

handleMinorException(e);

}

return null;

}

}).start();

});

}

private Timeline openSettingsTimeLine;

private Timeline closeSettingsTimeLine;

public Controller(){

mainServer = null;

}

public void onCloseRequest(WindowEvent event)

{

try

{

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

SystemTray.isSupported())

{

minimiseApp();

event.consume();

return;

}

getConfig().setStartupWindowSize(

getWidth(),

getHeight()

);

getConfig().save();

onQuitApp();

ExternalPlugins.getInstance().shutDownActions();

Platform.exit();

}

catch (SevereException e)

{

handleSevereException(e);

}

catch (MinorException e)

{

handleMinorException(e);

}

finally

{

closeLogger();

}

public void onQuitApp()

{

if(mainServer!=null)

mainServer.stopListeningForConnections();

ClientConnections.getInstance().disconnectAll();

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

}

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

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

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.getMessage(), e);

e.printStackTrace();

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

}

@Override

public void handleSevereException(SevereException e) {

getLogger().log(Level.SEVERE, e.getMessage(), 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)

{

onQuitApp();

Platform.exit();

}

});

alert.show();

});

}

@Override

public synchronized boolean onNormalActionClicked(NormalAction action) {

public synchronized boolean onNormalActionClicked(NormalAction action, String profileID) {

try{

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

action.onActionClicked();

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

action.getID(),

profileID

);

if(actionBox != null)

{

Platform.runLater(actionBox::init);

}

return true;

}

catch (Exception e)

{

//check if its windows UAC related

if(e.getMessage().contains("operation requires elevation"))

{

handleMinorException(new MinorException(

"Action Execution Failed!",

"Error running action at ["+action.getLocation().getRow()+","+action.getLocation().getCol()+"] ("+action.getDisplayText()+")\n"+

"This action requires higher UAC privileges. Re-launch Stream-Pi Server with 'Administrator Privileges' in order to run this command.")

);

}

else

{

handleMinorException(new MinorException(

"Action Execution Failed!",

"Error running action at ["+action.getLocation().getRow()+","+action.getLocation().getCol()+"] ("+action.getDisplayText()+")\n"+

"Check stacktrace/log to know what exactly happened\n\nMessage : \n"+e.getMessage() )

);

}

return false;

}

@Override

public boolean onToggleActionClicked(ToggleAction action, boolean toggle) {

public boolean onToggleActionClicked(ToggleAction action, boolean toggle, String profileID)

{

try{

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

if(toggle)

{

action.onToggleOn();

}

else

{

action.onToggleOff();

}

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

// action.getID(),

// profileID

// );

// if(actionBox != null)

// {

// Platform.runLater(()->actionBox.init(toggle));

// }

return true;

}

catch (Exception e)

{

e.printStackTrace();

//check if its windows UAC related

if(e.getMessage().contains("operation requires elevation"))

{

handleMinorException(new MinorException(

"Action Execution Failed!",

"Error running action at ["+action.getLocation().getRow()+","+action.getLocation().getCol()+"] ("+action.getDisplayText()+")\n"+

"This action requires higher UAC privileges. Re-launch Stream-Pi Server with 'Administrator Privileges' in order to run this command.")

);

}

else

{

handleMinorException(new MinorException(

"Action Execution Failed!",

"Error running action at ["+action.getLocation().getRow()+","+action.getLocation().getCol()+"] ("+action.getDisplayText()+")\n"+

"Check stacktrace/log to know what exactly happened\n\nMessage : \n"+e.getMessage() )

);

}

return false;

}

@Override

public void clearTemp() {

Platform.runLater(() -> {

getDashboardPane().getClientAndProfileSelectorPane().refresh();

getDashboardPane().getActionGridPane().clear();

getDashboardPane().getActionGridPane().setFreshRender(true);

getDashboardPane().getActionDetailsPane().clear();

getSettingsPane().getClientsSettings().loadData();

});

}

@Override

public void saveServerProperties()

{

try

{

ExternalPlugins.getInstance().saveServerSettings();

getSettingsPane().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 {

if(getDashboardPane().getActionGridPane().getCurrentParent().equals(action.getParent()) &&

// if(getDashboardPane().getActionGridPane().getCurrentParent().equals(action.getParent()) &&

getDashboardPane().getClientAndProfileSelectorPane().getCurrentSelectedClientProfile().getID().equals(profileID) &&

// getDashboardPane().getClientAndProfileSelectorPane().getCurrentSelectedClientProfile().getID().equals(profileID) &&

getDashboardPane().getClientAndProfileSelectorPane().getCurrentSelectedClientConnection().getRemoteSocketAddress().equals(socketAddress))

// getDashboardPane().getClientAndProfileSelectorPane().getCurrentSelectedClientConnection().getRemoteSocketAddress().equals(socketAddress))

// {

// getDashboardPane().getActionGridPane().renderAction(action);

// }

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

{

getDashboardPane().getActionGridPane().renderAction(action);

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

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

{

getDashboardPane().getActionDetailsPane().setAction(action);

getDashboardPane().getActionDetailsPane().refresh();

}

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

{

getDashboardPane().getActionDetailsPane().setAction(action);

getDashboardPane().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)

{

new Thread(new Task<Void>() {

@Override

protected Void call()

{

saveClientActionMain(profileID, actionID, socketAddress, sendIcons);

return null;

}

}).start();

}

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)

{

new Thread(new Task<Void>() {

@Override

protected Void call()

{

saveAllIconsMain(profileID, actionID, socketAddress);

return null;

}

}).start();

}

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) {

new Thread(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;

}

}).start();

}

@Override

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

return ServerInfo.getInstance().getPlatform();

}

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

+2 −0

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.ControlType;

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

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

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

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.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.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 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");

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

openFolderButton.setGraphic(folderOpenIcon);

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

saveButton = new Button("Apply Changes");

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

saveButton.setGraphic(syncIcon);

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

deleteButton = new Button("Delete action");

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

returnButtonForCombineActionChild = new Button("Return");

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

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

returnButtonForCombineActionChild.setOnAction(event -> {

try {

logger.info("@@## : " + getAction().getParent());

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

} catch (MinorException e) {

e.printStackTrace();

}

});

buttonBar = new HBox(openFolderButton, 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);

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

displayTextFieldHBox = new HBoxInputBox("Display Name", displayNameTextField, hideDisplayTextCheckBox);

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

displayTextAlignmentComboBox);

normalToggleActionCommonPropsVBox = new VBox(

displayTextColourHBox,

alignmentHBox,

bgColourHBox,

clearIconHBox

);

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

normalToggleActionCommonPropsVBox.setSpacing(10.0);

normalActionsPropsVBox = new VBox(

new HBoxInputBoxWithFileChooser("Icon", defaultIconFileTextField, hideDefaultIconCheckBox,

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

);

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

normalActionsPropsVBox.setSpacing(10.0);

toggleActionsPropsVBox = new VBox(

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

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

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

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

);

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

toggleActionsPropsVBox.setSpacing(10.0);

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

normalActionsPropsVBox, toggleActionsPropsVBox, 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 (Exception e)

{

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

}

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

System.out.println(getAction().getProfileID()+"KOBAAA");

renderActionProperties();

}

public void refresh() throws MinorException

{

clear(false);

renderActionProperties();

}

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

scrollPane.setVbarPolicy(ScrollPane.ScrollBarPolicy.NEVER);

buttonBar.setVisible(false);

setActionHeadingLabelText("");

actionBackgroundColourPicker.setValue(Color.WHITE);

displayTextColourPicker.setValue(Color.WHITE);

if(actionNull)

{

action = null;

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;

System.out.println(isCombineChild);

System.out.println("DISPLAY : "+getAction().getDisplayText());

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

if(isCombineChild)

{

setReturnButtonForCombineActionChildVisible(true);

normalActionsPropsVBox.setVisible(false);

normalToggleActionCommonPropsVBox.setVisible(false);

hideDisplayTextCheckBox.setSelected(false);

hideDisplayTextCheckBox.setVisible(false);

}

else

{

normalToggleActionCommonPropsVBox.setVisible(true);

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

{

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

}

else

{

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

}

setReturnButtonForCombineActionChildVisible(false);

hideDisplayTextCheckBox.setVisible(true);

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

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

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

}

buttonBar.setVisible(true);

vbox.setVisible(true);

scrollPane.setVbarPolicy(ScrollPane.ScrollBarPolicy.AS_NEEDED);

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

{

if(getAction().isInvalid())

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

else

setActionHeadingLabelText(getAction().getName());

}

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

setActionHeadingLabelText("Combine action");

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

setActionHeadingLabelText("Folder action");

if(!getAction().isInvalid())

{

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

renderClientProperties();

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

renderCombineActionProperties();

renderPluginExtraButtonBar();

}

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(getActionAsCombineAction(action),

getClientProfile(),

this

);

clientPropertiesVBox.getChildren().add(combineActionPropertiesPane);

}

catch (MinorException e)

{

e.printStackTrace();

exceptionAndAlertHandler.handleMinorException(e);

}

@Override

public synchronized void setAction(Action action) {

this.action = action;

}

public FolderAction getActionAsFolderAction(Action action)

{

FolderAction folderAction = new FolderAction();

folderAction.setDisplayText(getAction().getDisplayText());

folderAction.setName(getAction().getName());

folderAction.setID(getAction().getID());

folderAction.setLocation(getAction().getLocation());

folderAction.setBgColourHex(getAction().getBgColourHex());

folderAction.setParent(getAction().getParent());

folderAction.getClientProperties().set(getAction().getClientProperties());

folderAction.setDisplayTextAlignment(getAction().getDisplayTextAlignment());

folderAction.setIcons(getAction().getIcons());

folderAction.setCurrentIconState(getAction().getCurrentIconState());

folderAction.setDisplayTextFontColourHex(getAction().getDisplayTextFontColourHex());

return folderAction;

}

public CombineAction getActionAsCombineAction(Action action)

{

CombineAction combineAction = new CombineAction();

combineAction.setDisplayText(getAction().getDisplayText());

combineAction.setName(getAction().getName());

combineAction.setID(getAction().getID());

combineAction.setLocation(getAction().getLocation());

combineAction.setBgColourHex(getAction().getBgColourHex());

combineAction.setParent(getAction().getParent());

combineAction.getClientProperties().set(getAction().getClientProperties());

combineAction.setDisplayTextAlignment(getAction().getDisplayTextAlignment());

combineAction.setIcons(getAction().getIcons());

combineAction.setCurrentIconState(getAction().getCurrentIconState());

combineAction.setDisplayTextFontColourHex(getAction().getDisplayTextFontColourHex());

return combineAction;

}

@Override

public void onOpenFolderButtonClicked()

{

FolderAction folderAction = getActionAsFolderAction(action);

actionBox.getActionGridPaneListener().renderFolder(folderAction);

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;

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

HBox hBox = new HBox(label);

hBox.setSpacing(5.0);

hBox.setAlignment(Pos.CENTER_LEFT);

Node controlNode = null;

if(eachProperty.getHelpLink() != null)

{

Button helpButton = new Button();

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

helpButton.setGraphic(questionIcon);

helpButton.setOnAction(event -> {

hostServices.showDocument(eachProperty.getHelpLink());

});

hBox.getChildren().add(helpButton);

hBox.getChildren().add(controlNode);

}

hBox.getChildren().add(SpaceFiller.horizontal());

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

{

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

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

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

controlNode = comboBox;

hBox.getChildren().add(controlNode);

}

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

{

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

FileExtensionFilter[] fileExtensionFilters = eachProperty.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()

);

}

hBox = new HBoxInputBoxWithFileChooser(eachProperty.getDisplayName(), textField, null,

extensionFilters);

controlNode = textField;

}

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

{

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

hBox.getChildren().add(controlNode);

}

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

{

PasswordField textField = new PasswordField();

textField.setText(eachProperty.getRawValue());

controlNode= textField;

hBox.getChildren().add(controlNode);

}

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

{

ToggleButton toggleButton = new ToggleButton();

toggleButton.setSelected(eachProperty.getBoolValue());

if(eachProperty.getBoolValue())

toggleButton.setText("ON");

else

toggleButton.setText("OFF");

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

if(t1)

toggleButton.setText("ON");

else

toggleButton.setText("OFF");

});

controlNode = toggleButton;

hBox.getChildren().add(controlNode);

}

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

{

Slider slider = new Slider();

slider.setValue(eachProperty.getDoubleValue());

slider.setMax(eachProperty.getMaxDoubleValue());

slider.setMin(eachProperty.getMinDoubleValue());

controlNode = slider;

hBox.getChildren().add(controlNode);

}

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

{

Slider slider = new Slider();

slider.setValue(eachProperty.getIntValue());

slider.setMax(eachProperty.getMaxIntValue());

slider.setMin(eachProperty.getMinIntValue());

slider.setBlockIncrement(1.0);

slider.setSnapToTicks(true);

controlNode = slider;

hBox.getChildren().add(controlNode);

}

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

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

actionClientProperties.add(clientProperty);

clientPropertiesVBox.getChildren().add(hBox);

}

public void onSaveButtonClicked()

{

try {

// saveButton.setDisable(true);

// deleteButton.setDisable(true);

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 void saveAction(Action action, boolean runAsync, boolean runOnActionSavedFromServer)

{

logger.info("gOAT@ :"+action.getProfileID());

new OnSaveActionTask(

ClientConnections.getInstance().getClientConnectionBySocketAddress(

getClient().getRemoteSocketAddress()

action,

delayBeforeRunningTextField.getText(),

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, runOnActionSavedFromServer, runAsync

);

}

@Override

public void saveAction(boolean runAsync, boolean runOnActionSavedFromServer)

{

logger.info("ENGREJDERMAARBOOR:"+getAction().getProfileID());

logger.info("ENGREJDERMAARBOOR:"+getAction().getDisplayText());

saveAction(getAction(), runAsync, runOnActionSavedFromServer);

}

public void setFolderButtonVisible(boolean visible)

{

openFolderButton.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.NORMAL)

{

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

}

public void onDeleteButtonClicked()

{

new OnDeleteActionTask(

ClientConnections.getInstance().getClientConnectionBySocketAddress(

getClient().getRemoteSocketAddress()

action,

isCombineChild(),

getCombineActionPropertiesPane(),

clientProfile, actionBox, this, exceptionAndAlertHandler,

!isCombineChild

);

}

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

+7 −2

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

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;

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