Wie man Justinmind Plugins erstellt

Starten Sie die Eclipse-App in Ihrem JustinmindSDK-Ordner. Wählen Sie dann einen Ordner, in dem Sie Ihren Arbeitsbereich speichern möchten und klicken Sie auf „Dies als Standard verwenden und nicht mehr nachfragen“.

Erste Einrichtung

Wählen Sie dann „Neues Java-Projekt erstellen…“.

Wählen Sie einen Namen für Ihr Plugin und stellen Sie sicher, dass die ausgewählte Ausführungsumgebung JRE ‚JavaSE-11‘ ist. Klicken Sie dann auf Weiter.

Klicken Sie in den Java-Einstellungen auf die Registerkarte Bibliotheken. Wählen Sie „ModulePath“ und fügen Sie alle JavaFX-Module hinzu, die Sie im Ordner ‚javafx‘ innerhalb des Ordners ‚JustinmindPluginSDK‘ finden, indem Sie die Option Externe JARS hinzufügen verwenden.

Für Windows : JustinmindPluginSDK/javafx/lib

Für MacOS: Anwendungen/JustinmindPluginSDK/javafx/lib

Wählen Sie „Klassenpfad“ und fügen Sie alle Jars hinzu, die im Ordner ‚api_plugins‘ enthalten sind, den Sie im Ordner JustinmindSDK finden.

Für Windows : JustinmindPluginSDK/api_plugins/

Für MacOS: /Programme/JustinmindPluginSDK/api_plugins/

Klicken Sie auf Fertig stellen.

Wählen Sie die Option Don’t create module-info.java, wenn Sie dazu aufgefordert werden.

Jetzt haben wir das Haupt-Java-Projekt erstellt, das den Code unseres Plugins enthalten wird.

Schreiben Sie Ihr Plugin

Struktur

Die Struktur eines Justinmind-Plugins ist sehr einfach. Sie benötigen lediglich eine Hauptklassendatei, die den Ausführungscode für die Aktion Ihres Plugins enthält. Diese Klasse muss die Justinmind API-Schnittstelle ‚IPlugin‘ implementieren.

IPlugin definiert zwei Methoden:

getName() – diese Methode definiert den Namen, der in der Justinmind UI angezeigt wird, sobald Ihr Plugin installiert ist.

run() – was Ihr Plugin macht.

Erstellen Sie die Klassendatei. Klicken Sie mit der rechten Maustaste auf Ihren Plugin-Ordner ’src‘ und wählen Sie Neue>Klasse.

Geben Sie Ihrer Hauptklasse einen Namen und wählen Sie die IPlugin-Schnittstelle aus dem Paket com.justinmind.prototyper.api.plugins. Klicken Sie auf Fertigstellen.

Jetzt können Sie Ihren Code schreiben.

Beispiel: alle Texte in eine CSV-Datei exportieren

import java.awt.Desktop;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.List;
import com.justinmind.pcontrols.ControlUtils;
import com.justinmind.prototyper.api.API;
import com.justinmind.prototyper.api.IPrototype;
import com.justinmind.prototyper.api.plugins.IPlugin;
import com.justinmind.prototyper.api.ui.canvas.ICanvas;
import com.justinmind.prototyper.api.ui.component.ICanvasComponent;
import com.justinmind.prototyper.api.ui.component.IImage;
import com.justinmind.prototyper.api.ui.component.IInput;
import com.justinmind.prototyper.api.ui.component.IValuedComponent;
import javafx.stage.FileChooser;

public class TestPlugin implements IPlugin { 

  @Override
  public void run() {
    try {
      IPrototype prototype = API.getPrototypeLoader().loadPrototype();
      List canvas = prototype.getApiCanvases();
      String content = "Word in prototype\n\n";
      for (ICanvas current : canvas) {
        content += "Screen: " + current.getApiName() + "\n";
        List components = current.getApiRoot().getApiChildren();
        for (ICanvasComponent iComponent : components) {
          content += addTextsToContent(iComponent);
        }
      }
 
      FileChooser dialog = new FileChooser();
      FileChooser.ExtensionFilter extFilter = new FileChooser.ExtensionFilter("CSV files (*.csv)", "*.csv");
      dialog.getExtensionFilters().add(extFilter);
      File file = dialog.showSaveDialog(ControlUtils.getMainWindow());
      if (file != null) {
        Writer output = null;
        FileWriter fw = null;
        try {
          fw = new FileWriter(file);
          output = new BufferedWriter(fw);
          output.write(content);
          output.close();
          Desktop.getDesktop().open(file);
        } catch (IOException e) {
          Alert a = new Alert(AlertType.ERROR);
          a.setContentText(e.getLocalizedMessage());
          a.show();
        }
      } else {
        // show error
      }
    } catch (Exception e) {
      Alert a = new Alert(AlertType.ERROR);
      a.setContentText(e.getLocalizedMessage());
      a.show();
    }
  } 

  private String addTextsToContent(ICanvasComponent iComponent) {
    String content = "";
    if (iComponent instanceof IValuedComponent && !(iComponent instanceof IImage) && !(iComponent instanceof IInput)) {
      content += ((IValuedComponent) iComponent).getApiValue() + "\n";
    }
    List components = iComponent.getApiChildren();
    for (ICanvasComponent current_child : components) {
      content += addTextsToContent(current_child);
    }
    return content;
  }

  @Override
  public String getName() {
    return "Test Plugin";
  }
}

Einsatz

Sobald Ihr Code fertig ist, müssen Sie ihn als JAR-Datei exportieren, um ein gültiges installierbares Plugin in Justinmind zu erstellen.

Klicken Sie mit der rechten Maustaste auf Ihr Plugin-Projekt und wählen Sie Exportieren.

Wählen Sie unter Java die JAR-Datei aus und klicken Sie auf Weiter.

Wählen Sie ein Exportziel aus, wobei Sie alle anderen Optionen als Standard belassen, und klicken Sie auf Fertig stellen.

Installieren und ausführen

Sobald wir unser Plugin in eine JAR-Datei gepackt haben, müssen wir es in unserer Justinmind-App installieren, um es ausführen zu können.

Öffnen Sie Justinmind und öffnen Sie das Menü Plug-ins.

Wählen Sie die Option Ein Plug-in installieren…

Wählen Sie die exportierte JAR-Datei mit Ihrem Plugin und klicken Sie auf Öffnen.

Danach wird Ihr Plugin installiert und unter dem Menü Plugins erscheint eine neue Option mit dem Namen, den Sie bei der Implementierung Ihres Plugins gewählt haben. Um es auszuführen, klicken Sie einfach darauf.