server

work

Download Browse

+51 −31

Author

Debayan Sutradhar (rnayabed) 2021-03-23 19:51

Committer

Debayan Sutradhar (rnayabed) 2021-03-23 19:51

Hash 20ef5d76a112b40ced9211be8876540ddf37e543

Parent 2f736fc6ed8c50482426e268a6eafebed3151909

Reference git #server/20ef5d76a112b40ced9211be8876540ddf37e543

Modified Files

List

Side by side diff

Inline diff

M src/main/java/com/stream_pi/server/window/dashboard/DashboardBase.java

+2 −2

package com.stream_pi.server.window.dashboard;

import java.util.logging.Logger;

import com.stream_pi.server.client.ClientProfile;

import com.stream_pi.server.connection.ClientConnection;

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

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

import com.stream_pi.server.window.ExceptionAndAlertHandler;

import com.stream_pi.util.exception.SevereException;

import javafx.application.HostServices;

import javafx.geometry.Orientation;

import javafx.scene.control.SplitPane;

import javafx.scene.layout.HBox;

import javafx.scene.layout.Priority;

import javafx.scene.layout.VBox;

public class DashboardBase extends SplitPane implements DashboardInterface {

private final SplitPane leftSplitPane;

private Logger logger;

public ClientProfile currentClientProfile;

private ExceptionAndAlertHandler exceptionAndAlertHandler;

public DashboardBase(ExceptionAndAlertHandler exceptionAndAlertHandler, HostServices hostServices)

{

this.exceptionAndAlertHandler = exceptionAndAlertHandler;

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

leftSplitPane = new SplitPane();

leftSplitPane.getStyleClass().add("dashboard_left_split_pane");

leftSplitPane.setOrientation(Orientation.VERTICAL);

getStyleClass().add("dashboard_right_split_pane");

getItems().add(leftSplitPane);

setPluginsPane(new PluginsPane(hostServices));

setClientDetailsPane(new ClientAndProfileSelectorPane(this));

setActionGridPane(new ActionGridPane(exceptionAndAlertHandler));

setActionDetailsPane(new ActionDetailsPane(exceptionAndAlertHandler, hostServices, getActionGridPane()));

getActionGridPane().setActionDetailsPaneListener(getActionDetailsPane());

}

private PluginsPane pluginsPane;

private void setPluginsPane(PluginsPane pluginsPane)

{

this.pluginsPane = pluginsPane;

getItems().add(this.pluginsPane);

}

public PluginsPane getPluginsPane()

{

return pluginsPane;

}

private ClientAndProfileSelectorPane clientAndProfileSelectorPane;

private void setClientDetailsPane(ClientAndProfileSelectorPane clientAndProfileSelectorPane)

{

this.clientAndProfileSelectorPane = clientAndProfileSelectorPane;

leftSplitPane.getItems().add(this.clientAndProfileSelectorPane);

}

public ClientAndProfileSelectorPane getClientAndProfileSelectorPane()

{

return clientAndProfileSelectorPane;

}

private ActionGridPane actionGridPane;

private void setActionGridPane(ActionGridPane actionGridPane)

{

this.actionGridPane = actionGridPane;

leftSplitPane.getItems().add(this.actionGridPane);

}

public ActionGridPane getActionGridPane()

{

return actionGridPane;

}

private ActionDetailsPane actionDetailsPane;

private void setActionDetailsPane(ActionDetailsPane actionDetailsPane)

{

this.actionDetailsPane = actionDetailsPane;

leftSplitPane.getItems().add(this.actionDetailsPane);

}

public ActionDetailsPane getActionDetailsPane()

{

return actionDetailsPane;

}

public void newSelectedClientConnection(ClientConnection clientConnection)

{

if(clientConnection == null)

{

logger.info("Remove action grid");

}

else

{

getActionDetailsPane().setClient(clientConnection.getClient());

getActionDetailsPane().setClientConnection(clientConnection);

getActionGridPane().setClient(clientConnection.getClient());

getActionGridPane().setClientConnection(clientConnection);

}

public void newSelectedClientProfile(ClientProfile clientProfile)

{

this.currentClientProfile = clientProfile;

getActionDetailsPane().setClientProfile(clientProfile);

drawProfile(this.currentClientProfile);

}

public void drawProfile(ClientProfile clientProfile)

{

logger.info("Drawing ...");

getActionGridPane().setClientProfile(clientProfile);

try {

getActionGridPane().renderGrid();

getActionGridPane().renderActions();

}

catch (SevereException e)

{

exceptionAndAlertHandler.handleSevereException(e);

}

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

+10 −5

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

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("@@## : " + action.getParent());

onActionClicked(getClientProfile().getActionByID(action.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);

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

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

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

vbox.setVisible(false);

scrollPane.setVbarPolicy(ScrollPane.ScrollBarPolicy.NEVER);

setOnDragOver(dragEvent -> {

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

if (action.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(this.action.getID());

try

{

newAction.onActionCreate();

}

catch (Exception e)

{

exceptionAndAlertHandler.handleMinorException(new MinorException("Error","onCreate() failed for "+action.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 Client client;

private ClientConnection clientConnection;

private ClientProfile clientProfile;

public void setClient(Client client) {

public void setClientConnection(ClientConnection clientConnection) {

this.client = client;

this.clientConnection = clientConnection;

}

public Client getClient() {

public ClientConnection getClientConnection() {

return client;

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 Action getAction() {

return action;

}

private ActionBox actionBox;

public ActionBox getActionBox() {

return actionBox;

}

@Override

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

{

clear();

this.action = action;

this.actionBox = actionBox;

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

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 = action.getLocation().getCol() == -1;

System.out.println(isCombineChild);

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

displayNameTextField.setText(action.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 = action.getIcons().containsKey("default");

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

if(!doesDefaultExist)

isDefaultHidden = false;

hideDefaultIconCheckBox.setDisable(!doesDefaultExist);

hideDefaultIconCheckBox.setSelected(isDefaultHidden);

}

else

{

normalActionsPropsVBox.setVisible(false);

toggleActionsPropsVBox.setVisible(true);

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

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

if(!doesToggleOnExist)

isToggleOnHidden = false;

hideToggleOnIconCheckBox.setDisable(!doesToggleOnExist);

hideToggleOnIconCheckBox.setSelected(isToggleOnHidden);

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

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

if(!doesToggleOffExist)

isToggleOffHidden = false;

hideToggleOffIconCheckBox.setDisable(!doesToggleOffExist);

hideToggleOffIconCheckBox.setSelected(isToggleOffHidden);

}

setReturnButtonForCombineActionChildVisible(false);

hideDisplayTextCheckBox.setVisible(true);

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

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

if(!action.getBgColourHex().isEmpty())

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

else

actionBackgroundColourTransparentCheckBox.setSelected(true);

if(!action.getDisplayTextFontColourHex().isEmpty())

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

else

displayTextColourDefaultCheckBox.setSelected(true);

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

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

}

buttonBar.setVisible(true);

vbox.setVisible(true);

scrollPane.setVbarPolicy(ScrollPane.ScrollBarPolicy.AS_NEEDED);

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

{

if(action.isInvalid())

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

else

setActionHeadingLabelText(action.getName());

}

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

setActionHeadingLabelText("Combine action");

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

setActionHeadingLabelText("Folder action");

if(!action.isInvalid())

{

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

renderClientProperties();

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

renderCombineActionProperties();

}

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

}

public void setAction(Action action) {

this.action = action;

}

public FolderAction getActionAsFolderAction(Action action)

{

FolderAction folderAction = new FolderAction();

folderAction.setDisplayText(action.getDisplayText());

folderAction.setName(action.getName());

folderAction.setID(action.getID());

folderAction.setLocation(action.getLocation());

folderAction.setBgColourHex(action.getBgColourHex());

folderAction.setParent(action.getParent());

folderAction.getClientProperties().set(action.getClientProperties());

folderAction.setDisplayTextAlignment(action.getDisplayTextAlignment());

folderAction.setIcons(action.getIcons());

folderAction.setCurrentIconState(action.getCurrentIconState());

folderAction.setDisplayTextFontColourHex(action.getDisplayTextFontColourHex());

return folderAction;

}

public CombineAction getActionAsCombineAction(Action action)

{

CombineAction combineAction = new CombineAction();

combineAction.setDisplayText(action.getDisplayText());

combineAction.setName(action.getName());

combineAction.setID(action.getID());

combineAction.setLocation(action.getLocation());

combineAction.setBgColourHex(action.getBgColourHex());

combineAction.setParent(action.getParent());

combineAction.getClientProperties().set(action.getClientProperties());

combineAction.setDisplayTextAlignment(action.getDisplayTextAlignment());

combineAction.setIcons(action.getIcons());

combineAction.setCurrentIconState(action.getCurrentIconState());

combineAction.setDisplayTextFontColourHex(action.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< action.getClientProperties().getSize(); i++)

{

Property eachProperty = action.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)

{

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)

{

saveAction(action, 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(action.getActionType() == ActionType.NORMAL)

{

if(action.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(action.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/actiondetailpane/OnSaveActionTask.java

+22 −20

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

import java.util.ArrayList;

import java.util.List;

import java.util.logging.Logger;

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.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.server.client.ClientProfile;

import com.stream_pi.server.connection.ClientConnection;

import com.stream_pi.server.uipropertybox.UIPropertyBox;

import com.stream_pi.server.window.ExceptionAndAlertHandler;

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

import com.stream_pi.util.exception.MinorException;

import com.stream_pi.util.exception.SevereException;

import javafx.application.Platform;

import javafx.concurrent.Task;

import javafx.scene.control.Button;

public class OnSaveActionTask extends Task<Void>

{

private Logger logger;

public OnSaveActionTask(ClientConnection connection, Action action, String delayBeforeRunningString, String displayNameText, boolean isCombineChild,

boolean isShowDisplayText, boolean isDefaultDisplayTextColour, String displayTextFontColour, boolean isClearIcon,

boolean isHideDefaultIcon, boolean isHideToggleOffIcon, boolean isHideToggleOnIcon, DisplayTextAlignment displayTextAlignment, boolean isTransparentBackground, String backgroundColour,

CombineActionPropertiesPane combineActionPropertiesPane, ClientProfile clientProfile, boolean sendIcon, ActionBox actionBox,

ArrayList<UIPropertyBox> actionClientProperties, ExceptionAndAlertHandler exceptionAndAlertHandler, Button saveButton, Button deleteButton,

boolean runOnActionSavedFromServer, boolean runAsync)

{

this.saveButton = saveButton;

this.deleteButton = deleteButton;

this.delayBeforeRunningString = delayBeforeRunningString;

this.connection = connection;

this.action = action;

this.displayNameText = displayNameText;

this.isCombineChild = isCombineChild;

this.isShowDisplayText = isShowDisplayText;

this.isDefaultDisplayTextColour = isDefaultDisplayTextColour;

this.displayTextFontColour = displayTextFontColour;

this.isClearIcon = isClearIcon;

this.isHideDefaultIcon = isHideDefaultIcon;

this.isHideToggleOffIcon = isHideToggleOffIcon;

this.isHideToggleOnIcon = isHideToggleOnIcon;

this.displayTextAlignment = displayTextAlignment;

this.isTransparentBackground = isTransparentBackground;

this.combineActionPropertiesPane = combineActionPropertiesPane;

this.clientProfile = clientProfile;

this.sendIcon = sendIcon;

this.actionBox = actionBox;

this.exceptionAndAlertHandler = exceptionAndAlertHandler;

this.backgroundColour = backgroundColour;

this.actionClientProperties = actionClientProperties;

this.runOnActionSavedFromServer = runOnActionSavedFromServer;

logger = Logger.getLogger(getClass().getName());

if(runAsync)

new Thread(this).start();

else

runTask();

}

private boolean runOnActionSavedFromServer;

private Button saveButton;

private Button deleteButton;

private String delayBeforeRunningString;

private boolean isShowDisplayText;

private boolean isCombineChild;

private String displayNameText;

private boolean isDefaultDisplayTextColour;

private ArrayList<UIPropertyBox> actionClientProperties;

private String displayTextFontColour;

private boolean isClearIcon;

private boolean isHideDefaultIcon;

private boolean isHideToggleOffIcon;

private boolean isHideToggleOnIcon;

private DisplayTextAlignment displayTextAlignment;

private boolean isTransparentBackground;

private String backgroundColour;

private CombineActionPropertiesPane combineActionPropertiesPane;

private ClientProfile clientProfile;

private boolean sendIcon;

private ActionBox actionBox;

private ExceptionAndAlertHandler exceptionAndAlertHandler;

private Action action;

private ClientConnection connection;

private void setSaveDeleteButtonState(boolean state)

{

Platform.runLater(()->{

saveButton.setDisable(state);

deleteButton.setDisable(state);

});

}

private void runTask()

{

action.setDisplayText(displayNameText);

if(!isCombineChild)

{

setSaveDeleteButtonState(true);

action.setShowDisplayText(isShowDisplayText);

if(isDefaultDisplayTextColour)

action.setDisplayTextFontColourHex("");

else

{

action.setDisplayTextFontColourHex(displayTextFontColour);

//String fontColour = "#" + displayTextColourPicker.getValue().toString().substring(2);

//action.setDisplayTextFontColourHex(fontColour);

}

if(isClearIcon)

{

action.setIcons(null);

action.setCurrentIconState("");

}

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

{

if(isHideDefaultIcon)

{

if(action.getIcon("default") != null)

action.setCurrentIconState("default");

}

else

{

action.setCurrentIconState("");

}

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

{

action.setCurrentIconState(isHideToggleOffIcon+"__"+isHideToggleOnIcon);

}

action.setDisplayTextAlignment(displayTextAlignment);

if(isTransparentBackground)

action.setBgColourHex("");

else

{

action.setBgColourHex(backgroundColour);

}

System.out.println("parent : "+action.getParent());

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

{

List<String> finalChildren = combineActionPropertiesPane.getFinalChildren();

System.out.println("2334 "+finalChildren.size());

ClientProperties clientProperties = new ClientProperties();

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

{

Property property = new Property(i+"", Type.STRING);

property.setRawValue(finalChildren.get(i));

clientProperties.addProperty(property);

}

action.getClientProperties().set(clientProperties);

}

else

{

action.setDelayBeforeExecuting(Integer.parseInt(delayBeforeRunningString));

//properties

for (UIPropertyBox clientProperty : actionClientProperties) {

action.getClientProperties().get().get(clientProperty.getIndex()).setRawValue(clientProperty.getRawValue());

}

try

{

logger.info("Saving action ... "+action.isHasIcon()+"+"+sendIcon);

if(runOnActionSavedFromServer)

{

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

{

System.out.println("SSSSSDDD : "+property.getName());

System.out.println("@@@@DDD : "+property.getRawValue());

}

try

{

if(action instanceof ExternalPlugin)

((ExternalPlugin) action).onActionSavedFromServer();

}

catch (Exception e)

{

e.printStackTrace();

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

}

connection.saveActionDetails(clientProfile.getID(), action);

if(sendIcon)

{

sendAllIcons(clientProfile, action);

}

if(!isCombineChild)

{

Platform.runLater(()->{

actionBox.clear();

actionBox.setAction(action);

//actionBox.baseInit();

actionBox.init();

});

setSaveDeleteButtonState(false);

}

//clientProfile.removeActionByID(action.getID());

//clientProfile.addAction(action);

if(runOnActionSavedFromServer)

{

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

{

System.out.println("SSSSSDDD : "+property.getName());

System.out.println("@@@@DDD : "+property.getRawValue());

}

try

{

if(action instanceof ExternalPlugin)

((ExternalPlugin) action).onActionSavedFromServer();

}

catch (Exception e)

{

e.printStackTrace();

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

}

catch (SevereException e)

{

e.printStackTrace();

exceptionAndAlertHandler.handleSevereException(e);

}

catch (Exception e)

{

e.printStackTrace();

}

private void sendAllIcons(ClientProfile clientProfile, Action action) throws SevereException

{

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

{

connection.sendIcon(clientProfile.getID(), action.getID(), state, action.getIcon(state));

}

@Override

protected Void call() throws Exception

{

runTask();

return null;

}

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

+2 −0

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