requestHandling

src/main/java/com/github/johmara/hansviz/BrowserViewerWindow.java

@@ -14,6 +14,7 @@
 
 package com.github.johmara.hansviz;
 
+import com.github.johmara.hansviz.JSHandler.JSMessageRouterHandler;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.vfs.VirtualFile;
@@ -23,6 +24,8 @@
 import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.ui.jcef.JBCefBrowser;
 import org.cef.CefApp;
+import org.cef.CefClient;
+import org.cef.browser.CefMessageRouter;
 
 import javax.swing.*;
 
@@ -35,8 +38,7 @@ public class BrowserViewerWindow {
 
     private final Box content;
     private final Project project;
-    private String tangleFeature = "";
-    private String locationFeature = "";
+
 
     /**
      * Constructs a JCEF view containing the Feature Localisation View and Tangling View
@@ -46,6 +48,7 @@ public class BrowserViewerWindow {
     public BrowserViewerWindow(BrowserViewerService service, Project project) {
         webView = new JBCefBrowser();
         registerAppSchemeHandler();
+        initialiseJSHandler(webView.getCefBrowser().getClient());
         webView.loadURL("http://hans/index.html");
 
         /**
@@ -56,51 +59,21 @@ public BrowserViewerWindow(BrowserViewerService service, Project project) {
 
         // Setup the menubar in JCEF
         JMenuBar menuBar = new JMenuBar();
-        /*JMenuItem fileMenuItem = new JMenuItem("Feature Location Visualization");
-        JMenuItem tanglingMenuItem = new JMenuItem("Feature Tangling Visualization");
-        JBColor menuItemColor = new JBColor(
-                fileMenuItem.getBackground(), fileMenuItem.getBackground());*/
-
-
-        /*MouseAdapter miMouseAdapter = new MouseAdapter() {
-            @Override
-            public void mouseClicked(MouseEvent e) {
-                String url = "http://myapp/html/";
-                if (e.getComponent() == fileMenuItem) {
-                    url += "fileView.html";
-                    locationFeature = "";
-                } else if (e.getComponent() == tanglingMenuItem) {
-                    try {
-                        String featureTangling = JSONHandler.toJSONString(iFeatureAnnotationUtil.getFeatureAnnotationTanglings(project.getBasePath()));
-                    } catch (IOException ioException) {
-                        ioException.printStackTrace();
-                    }
-                    url += "tanglingView.html";
-                }
-                webView.loadURL(url);
-            }
-
-            @Override
-            public void mouseEntered(MouseEvent e) {
-                e.getComponent().setBackground(JBColor.CYAN);
-            }
-
-            @Override
-            public void mouseExited(MouseEvent e) {
-                e.getComponent().setBackground(menuItemColor);
-            }
-        };*/
-        /*fileMenuItem.addMouseListener(miMouseAdapter);
-        tanglingMenuItem.addMouseListener(miMouseAdapter);*/
 
-        /*menuBar.add(fileMenuItem);
-        menuBar.add(tanglingMenuItem);*/
         content = new Box(BoxLayout.Y_AXIS);
         content.add(menuBar);
         content.add(webView.getComponent());
         this.project = project;
     }
 
+    private void initialiseJSHandler(CefClient client) {
+        // create routing point for JS -> window.java ({})
+        CefMessageRouter.CefMessageRouterConfig cefMessageRouterConfig = new CefMessageRouter.CefMessageRouterConfig("java","javaCancel");
+        CefMessageRouter cefMessageRouter = CefMessageRouter.create(cefMessageRouterConfig);
+        cefMessageRouter.addHandler(new JSMessageRouterHandler(), true);
+        client.addMessageRouter(cefMessageRouter);
+    }
+
     private void registerAppSchemeHandler() {
         CefApp.getInstance().registerSchemeHandlerFactory(
                 "http",
@@ -118,289 +91,8 @@ public JComponent content() {
         return content;
     }
 
-    /**
-     * Register a new SchemeHandlerFactory using CustomSchemeHandlerFactory
-     */
-    /*private void registerAppSchemeHandler() {
-        CefApp.getInstance().registerSchemeHandlerFactory(
-                "http",
-                "myapp",
-                new CustomSchemeHandlerFactory()
-        );
-    }*/
-
-    /**
-     * Makes a client able to process JS requests
-     * @param client The browser client that should handle JS requests
-     */
-    /*private void handleJS(CefClient client) {
-        // Query a route configuration, html pages used window.java ({}) and window.javaCancel ({}) to call this method
-        CefMessageRouter.CefMessageRouterConfig cmrConfig = new CefMessageRouter.CefMessageRouterConfig(
-                "java","javaCancel");
-        // Create query routing
-        CefMessageRouter cmr = CefMessageRouter.create(cmrConfig);
-        cmr.addHandler(new CefMessageRouterHandler() {
-
-            @Override
-            public void setNativeRef(String str, long val) {
-                System.out.println(str+"  "+val);
-            }
-
-            @Override
-            public long getNativeRef(String str) {
-                System.out.println(str);
-                return 0;
-            }
-
-            @Override
-            public void onQueryCanceled(CefBrowser browser, CefFrame frame, long query_id) {
-                System.out.println("Cancel the query:" + query_id);
-            }
 
-            @Override
-            public boolean onQuery(CefBrowser browser, CefFrame frame, long query_id, String request,
-                                   boolean persistent, CefQueryCallback callback) {
-                System.out.println("Request:"+request+"\nQuery_id:"+query_id+"\nPersistent:"+persistent);
 
-                String[] temp = request.split(" ");
-                String cmd = temp[0];
-                boolean handled = false;
-                String cbSyntaxFailureMsg = "\"Message syntax incorrect!\nCorrect syntax: ";
-                String debugSyntax = "Debug <data>";
-                String deleteFeSyntax = "DeleteFe <featureName>";
-                String deleteFiSyntax = "DeleteFi <fileName>";
-                String getDataSyntax = "getData [feature | tangle]";
-                String openSyntax = "OpenFile <fileName>";
-                String renameFeSyntax = "RenameFe <oldName> <newName>";
-                String renameFiSyntax = "RenameFi <oldName> <newName>";
-                *//* Supported operations:
-                 * - Debug:
-                 *      Description: Print data to java console (Used for debug purposes)
-                 *      Syntax: Debug <data>
-                 * - DeleteFe:
-                 *      Description: Deletes a feature
-                 *      Syntax: DeleteFe <featureName>
-                 * - DeleteFi:
-                 *      Description: Deletes a file/folder
-                 *      Syntax: DeleteFi <fileName/folderName>
-                 * - GetData:
-                 *      Description: Requests data for feature- or tangleview
-                 *      Syntax: GetData [feature | tangle]
-                 * - OpenFile:
-                 *      Description: Opens a file in editor or expands folder in project view
-                 *      Syntax: OpenFile <fileName/folderName>
-                 * - RenameFe:
-                 *      Description: Renames a feature
-                 *      Syntax: RenameFe <oldName> <newName>
-                 * - RenameFi:
-                 *      Description: Renames a file
-                 *      Syntax: RenameFi <oldFileName> <newFileName>
-                 *//*
-                switch (cmd) {
-                    case "Debug":
-                        try {
-                            String data = temp[1];
-                            System.out.println(data);
-                            callback.success("Debug message '" + data + "' was received!");
-                            handled = true;
-                        } catch (IndexOutOfBoundsException e) {
-                            // Incorrect syntax
-                            callback.failure(400, cbSyntaxFailureMsg + debugSyntax);
-                        }
-                        break;
-                    case "DeleteFe":
-                        try {
-                            String featureName = temp[1];
-                            // TODO: Implement actual deletion of feature (require editing API)
-                            callback.success(featureName + " was deleted!");
-                            handled = true;
-                        } catch (IndexOutOfBoundsException e) {
-                            // Incorrect syntax
-                            callback.failure(400, cbSyntaxFailureMsg + deleteFeSyntax);
-                        }
-                        break;
-                    case "DeleteFi":
-                        try {
-                            String fileName = temp[1];
-                            // Send handling of deleting file to be processed by an EDT thread when available
-                            ApplicationManager.getApplication().invokeLater(() -> {
-                                final VirtualFile vFile = getVirtualFile(fileName);
-                                if (vFile != null) {
-                                    ApplicationManager.getApplication().runWriteAction(() -> {
-                                        try {
-                                            vFile.delete(this);
-                                            callback.success(fileName + " was deleted!");
-                                        } catch (IOException e) {
-                                            // Failed to delete
-                                            callback.failure(500, fileName + "could not be deleted!");
-                                        }
-                                    });
-                                } else {
-                                    // File/Folder not found
-                                    callback.failure(404, fileName + " could not be found!");
-                                }
-                            });
-                            handled = true;
-                        } catch (IndexOutOfBoundsException e) {
-                            // Incorrect syntax
-                            callback.failure(400, cbSyntaxFailureMsg + deleteFiSyntax);
-                        }
-                        break;
-                    case "GetData":
-                        try {
-                            String requestedData = temp[1];
-                            if (requestedData.equals("feature")) {
-                                // TODO: Assign actual data to fileData string
-                                String fileData = "fileViewData test";
-                                callback.success(fileData);
-                            } else if (requestedData.equals("tangle")) {
-                                // TODO: Assign actual data to tangleData string
-                                String tangleData = "tangleViewData test";
-                                callback.success(tangleData);
-                            } else {
-                                // Requested data was not a supported datatype
-                                // Must be either feature or tangle
-                                callback.failure(400, requestedData + " is not a valid datatype!");
-                            }
-                            handled = true;
-                        } catch (IndexOutOfBoundsException e) {
-                            // Incorrect syntax
-                            callback.failure(400, cbSyntaxFailureMsg + getDataSyntax);
-                        }
-                        break;
-                    case "OpenFile":
-                        try {
-                            String fileName = temp[1];
-                            // Send handling of file opening to be processed by an EDT thread when available
-                            ApplicationManager.getApplication().invokeLater(() -> {
-                                final VirtualFile vFile = getVirtualFile(fileName);
-                                if (vFile != null) {
-                                    OpenFileDescriptor ofd = new OpenFileDescriptor(project, vFile);
-                                    boolean isDir = vFile.isDirectory();
-                                    ofd.navigate(!isDir);
-                                    String cbMsg = isDir ? "expanded " : "opened ";
-                                    cbMsg += fileName;
-                                    callback.success(cbMsg);
-                                } else {
-                                    // File/Folder not found
-                                    callback.failure(404, fileName + " could not be found!");
-                                }
-                            });
-                            handled = true;
-                        } catch (IndexOutOfBoundsException e) {
-                            // Incorrect syntax
-                            callback.failure(400, cbSyntaxFailureMsg + openSyntax);
-                        }
-                        break;
-                    case "RenameFe":
-                        try {
-                            String oldName = temp[1];
-                            String newName = temp[2];
-                            // TODO: Implement actual renaming of feature (require editing API)
-                            callback.success(oldName + " was renamed to " + newName);
-                            handled = true;
-                        } catch (IndexOutOfBoundsException e) {
-                            // Incorrect syntax
-                            callback.failure(400, cbSyntaxFailureMsg + renameFeSyntax);
-                        }
-                        break;
-                    case "RenameFi":
-                        try {
-                            String oldName = temp[1];
-                            String newName = temp[2];
-                            // Send handling of file renaming to be processed by an EDT thread when available
-                            ApplicationManager.getApplication().invokeLater(() -> {
-                                final VirtualFile vFile = getVirtualFile(oldName);
-                                if (vFile != null) {
-                                    ApplicationManager.getApplication().runWriteAction(() -> {
-                                        try {
-                                            vFile.rename(this, newName);
-                                            callback.success(oldName + " was renamed to " + newName);
-                                        } catch (IOException e) {
-                                            // Failed to rename
-                                            callback.failure(500, oldName + "could not be renamed!");
-                                        }
-                                    });
-                                } else {
-                                    // File/Folder not found
-                                    callback.failure(404, oldName + " could not be found!");
-                                }
-                            });
-                            handled = true;
-                        } catch (IndexOutOfBoundsException e) {
-                            // Incorrect syntax
-                            callback.failure(400, cbSyntaxFailureMsg + renameFiSyntax);
-                        }
-                        break;
-                    case "featureLocation":
-                        try {
-                            String featureLocation = "";
-                            System.out.println(locationFeature);
-                            if(locationFeature.equals("")) {
-                                featureLocation = JSONHandler.toJSONString(iFeatureAnnotationUtil.getFeatureAnnotationLocations(project.getBasePath()));
-                            }
-                            else {
-                                Map<String, ArrayList<Object>> featureMap = new HashMap<>();
-                                ArrayList<Object> locationsForFeature = iFeatureAnnotationUtil.getFeatureAnnotationLocations(project.getBasePath()).get(locationFeature);
-                                featureMap.put(locationFeature, locationsForFeature);
-                                featureLocation = JSONHandler.toJSONString(featureMap);
-                            }
-                            System.out.println(featureLocation);
-                            callback.success(featureLocation);
-                            handled = true;
-                        } catch (IndexOutOfBoundsException | IOException e) {
-                           callback.failure(400, "Could not get feature mappings.");
-                        }
-                        break;
-                    case "OpenTangle":      //Used by featureView.js to get the chosen feature
-                        try {
-                            Map<String, ArrayList<Object>> test = iFeatureAnnotationUtil.getFeatureAnnotationTanglings(project.getBasePath());
-                            Map<String, ArrayList<Object>>mapper = new HashMap<>();
-                            if(test.containsKey(tangleFeature)) {
-                                mapper.put(tangleFeature, test.get(tangleFeature));
-                            } else
-                            {
-                                mapper.put(tangleFeature, new ArrayList<>());
-                            }
-                            String json = JSONHandler.toJSONString(mapper);
-                            System.out.println(json);
-                            callback.success(json);
-                            handled = true;
-                        }  catch (IOException ioException) {
-                            //
-                            ioException.printStackTrace();
-                            callback.failure(400, cbSyntaxFailureMsg + "Wrong with tangling");
-                        }
-                        break;
-                    case "ChooseTangle":    //Should be used from location view to choose the tangle feature
-                        try {
-                            tangleFeature = temp[1];
-                            String url = "http://myapp/html/";
-                            url += "tanglingView.html";
-                            webView.loadURL(url);
-                            callback.success("Choose feature for tangling view success");
-                            handled = true;
-                        } catch (IndexOutOfBoundsException e) {
-                            // Incorrect syntax
-                            callback.failure(400, cbSyntaxFailureMsg + "ChooseTangle <featureName>"); //Syntax for choosing the feature
-                        }
-                        break;
-                    case "OpenLocation":
-                        locationFeature = temp[1];
-                        String url = "http://myapp/html/";
-                        url += "fileView.html";
-                        webView.loadURL(url);
-                        handled = true;
-                        break;
-                    default:
-                        // Command not recognized
-                        callback.failure(400, "Command not recognized!");
-                }
-                return handled;
-            }
-        }, true);
-        client.addMessageRouter(cmr);
-    }*/
 
     /**
      * Searches the project for a file (or folder) with the specified filename

src/main/java/com/github/johmara/hansviz/JSHandler/JSMessageRouterHandler.java

@@ -0,0 +1,27 @@
+package com.github.johmara.hansviz.JSHandler;
+
+import org.cef.browser.CefBrowser;
+import org.cef.browser.CefFrame;
+import org.cef.callback.CefQueryCallback;
+import org.cef.handler.CefMessageRouterHandlerAdapter;
+
+
+public class JSMessageRouterHandler extends CefMessageRouterHandlerAdapter {
+
+    @Override
+    public boolean onQuery(CefBrowser browser, CefFrame frame, long queryId, String request, boolean persistent, CefQueryCallback callback) {
+        System.out.println("Request: " + request); // For testing purposes
+        switch(request) {
+            // Add all queries that need to be handled
+            case "buttonClicked":
+                System.out.println("Button Clicked!");
+                return true;
+            case "refresh":
+                System.out.println("Refreshing!");
+                // return JSON through parameter of success function
+                callback.success("JSON");
+                return true;
+        }
+        return false;
+    }
+}

src/main/resources/webcontent/index.html

@@ -1,29 +1,12 @@
 <!DOCTYPE html>
-<html>
-    <body>
-        <head>
-            <meta charset="utf-8">
-            <title>Katzenblog</title>
-            <table>
-                <tr>
-                    <th>Überschrift Spalte 1</th>
-                    <th>Überschrift Spalte 2</th>
-                </tr>
-                <tr>
-                    <td>Zelle 50</td>
-                    <td rowspan="2">Zelle 2 und 4</td>
-                </tr>
-                <tr>
-                    <td>Zelle 56</td>
-                </tr>
-            </table>
-        </head>
-        <main>
-            <h1>Informationen über Katzen</h1>
-            <p>Ich weiß nicht so ganz was ich sagen soll, außer dass mir sehr langweilig ist</p>
-        </main>
-        <footer>
-            <p>Hier ist es auch echt langweilig</p>
-        </footer>
-    </body>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>HAnS</title>
+</head>
+<body>
+    <button id="myButton">Click me</button>
+    <script src="index.js"></script>
+</body>
 </html>

src/main/resources/webcontent/index.js

@@ -0,0 +1,31 @@
+document.getElementById('myButton').addEventListener('click', function() {
+    // Every button can use requestData(option) to request data from HAnS-Viz
+    // Send message to JCEF
+    requestData("buttonClicked")
+    requestData("refresh")
+});
+
+function requestData(option) {
+    window.java({
+        request: option,
+        persistent: false,
+        success: function(response) {
+            // response should contain JSON
+            handleData(option, response);
+        },
+        failure: function(error_code, error_message) {
+            console.log(error_code, error_message);
+        }
+    })
+}
+
+function handleData(option, response) {
+    switch(option) {
+        case "refresh":
+            // handle refresh data
+            break;
+        case "tanglingdegree":
+            // handle tangling degree data
+            break;
+    }
+}