Changeset 767

Timestamp:

01/28/14 17:06:51 (10 years ago)

Author:

ngw8

Message:

Updates to new webparser/converter - now gives a tidier, more usable conversion. A lot of the code is copied from the old parser, so still need to go through and make it more efficient (and tidier) for the new approach.

Location:

trunk/src/org/expeditee

Files:

• io/WebParser.java (modified) (15 diffs)
• items/widgets/JfxBrowser.java (modified) (1 diff)

trunk/src/org/expeditee/io/WebParser.java

@@ -11 +11 @@
 import java.net.MalformedURLException;
 import java.net.URL;
+import java.text.SimpleDateFormat;
 import java.util.Arrays;
 
@@ -22 +23 @@
  */
 
+
+import java.util.Date;
+
 import javafx.animation.AnimationTimer;
 import javafx.application.Platform;
@@ -27 +31 @@
 import javafx.beans.value.ObservableValue;
 import javafx.concurrent.Worker.State;
+import javafx.scene.transform.Rotate;
 import javafx.scene.web.WebEngine;
 
@@ -34 +39 @@
 import netscape.javascript.JSObject;
 
+import org.expeditee.gui.DisplayIO;
 import org.expeditee.gui.Frame;
 import org.expeditee.gui.FrameCreator;
+import org.expeditee.gui.FrameGraphics;
 import org.expeditee.gui.FrameIO;
 import org.expeditee.gui.FrameUtils;
 import org.expeditee.gui.MessageBay;
 import org.expeditee.gui.MessageBay.Progress;
+import org.expeditee.importer.FrameDNDTransferHandler;
 import org.expeditee.items.ItemUtils;
 import org.expeditee.items.Justification;
@@ -46 +54 @@
 import org.w3c.dom.Node;
 import org.w3c.dom.html.HTMLBodyElement;
+
+import com.sun.org.apache.bcel.internal.generic.NEW;
 
 /**
@@ -282 +292 @@
                         final MutableBool bottomReached = new MutableBool(false);
 
+                        String pageTitle = webEngine.getTitle();
+
+                        String framesetName = FrameIO.ConvertToValidFramesetName((new SimpleDateFormat("yy-MM-dd-HH-mm-ss").format(new Date())) + pageTitle);
+
                         final Progress progressBar = MessageBay.displayProgress("Converting web page");
 
+                        final Frame frameset = FrameIO.CreateNewFrameset(framesetName);
+
+                        frameset.setTitle(pageTitle);
+                        frameset.getTitleItem().setSize(14);
+
+                        Text link = new Text(DisplayIO.getCurrentFrame().getNextItemID(), webEngine.getTitle());
+
+                        link.setPosition(100, 100);
+
+                        DisplayIO.getCurrentFrame().addItem(link);
+
+                        link.setLink(framesetName + "1");
+
+                        // Timer that fires every time JFX is redrawn. After a few redraws, the handle method of this takes a screenshot of the page,
+                        // adds it to the frame, then adds the text on top
                         AnimationTimer timer = new AnimationTimer() {
 
                                 int frameCount = 0;
-                                Frame frameToAddTo = frame;
+                                Frame frameToAddTo = frameset;
 
                                 @Override
                                 public void handle(long arg0) {
+                                        System.out.println(frameCount);
                                         // Must wait 2 frames before taking a snapshot of the webview, otherwise JavaFX won't have redrawn
-                                        if (frameCount++ > 1) {
+                                        if (frameCount++ > 3) {
                                                 frameCount = 0;
                                                 this.stop();
@@ -304 +334 @@
 
                                                 try {
+                                                        frameToAddTo = FrameIO.CreateFrame(frameToAddTo.getFramesetName(), null, null);
+
                                                         int hashcode = Arrays.hashCode(image.getData().getPixels(0, 0, image.getWidth(), image.getHeight(), (int[]) null));
 
@@ -310 +342 @@
                                                         ImageIO.write(image, "png", out);
 
-                                                        Text link = new Text("Next");
-                                                        link.setPosition(500, 20);
-                                                        frameToAddTo.addItem(link);
-
-                                                        FrameIO.SaveFrame(frameToAddTo);
-
-                                                        frameToAddTo = FrameIO.CreateFrame(frame.getFramesetName(), Integer.toHexString(hashcode), null);
-
-                                                        link.setLink(frameToAddTo.getName());
-
                                                         // Adding the image
                                                         frameToAddTo.addText(0, 0, "@i: " + out.getName(), null);
+
+                                                        Text thumb = frameset.addText(100, 100, "@i: " + out.getName() + " " + 200, null);
+                                                        thumb.setLink(frameToAddTo.getName());
 
                                                         // Button to go to the next page
@@ -330 +355 @@
 
                                                         FrameIO.SaveFrame(frameToAddTo);
-                                                        System.out.println("C");
+                                                        FrameIO.SaveFrame(frameset);
+
+                                                        System.out.println("Screenshot taken and added " + frameToAddTo.getName());
 
                                                 } catch (IOException e) {
@@ -336 +363 @@
                                                 }
 
-
                                                 graphics.dispose();
                                                 image.flush();
-
-                                                synchronized (notifier) {
-                                                        notifier.notify();
-                                                }
 
                                                 try {
@@ -353 +375 @@
                                                                                 JSObject window = (JSObject) webEngine.executeScript("window");
 
-                                                                                System.out.println("adding");
-                                                                                WebParser.addPageToFrame(doc, window, webEngine, frameToAddTo);
+                                                                                int visibleWidth = (int) webEngine.executeScript("window.innerWidth");
+                                                                                int visibleHeight = (int) webEngine.executeScript("window.innerHeight");
+
+                                                                                System.out.println("Adding text " + frameToAddTo.getName());
+                                                                                WebParser.addTextToFrame(doc, visibleWidth, visibleHeight, window, webEngine, frameToAddTo);
+                                                                                FrameIO.SaveFrame(frameToAddTo);
+                                                                                System.out.println("Added text " + frameToAddTo.getName());
                                                                         } catch (Exception ex) {
                                                                                 ex.printStackTrace();
+                                                                        }
+
+                                                                        synchronized (notifier) {
+                                                                                notifier.notify();
                                                                         }
                                                                 }
@@ -371 +402 @@
                                 public void run() {
                                         try {
-                                                
                                                 webEngine.executeScript(""
                                                                 // Initializing the counter used when scrolling the page
@@ -521 +551 @@
                                                         // Scrolling down the page
                                                         webEngine.executeScript(""
-                                                                        + "window.scrollTo(0, scrollCounter * window.innerHeight);"
+                                                                        + "window.scrollTo(0, scrollCounter * 0.9 * window.innerHeight);"
                                                                         + "scrollCounter = scrollCounter+1;");
 
-                                                        System.out.println('B');
+                                                        System.out.println("Scrolling");
 
                                                         bottomReached.setValue((Boolean) webEngine.executeScript("(window.pageYOffset + window.innerHeight >= document.documentElement.scrollHeight)"));
@@ -918 +948 @@
 
         private static boolean elementVisible(float x, float y, float width, float height, JSObject style) {
-                try {
-                        if (width <= 0 || height <= 0 || x + width <= 0 || y + height <= 0 || ((String) style.call("getPropertyValue", new Object[] { "visibility" })).equals("hidden")
-                                        || ((String) style.call("getPropertyValue", new Object[] { "display" })).equals("none")) {
-                                return false;
-                        } else {
-                                return true;
-                        }
-                } catch (Exception e) {
-                        e.printStackTrace();
+                if (width <= 0 || height <= 0 || x + width <= 0 || y + height <= 0 || ((String) style.call("getPropertyValue", new Object[] { "visibility" })).equals("hidden")
+                                || ((String) style.call("getPropertyValue", new Object[] { "display" })).equals("none")) {
                         return false;
+                } else {
+                        return true;
                 }
         }
@@ -1063 +1088 @@
         }
 
+        /**
+         * @param rootElement
+         *            Element that will be converted (including all sub-elements)
+         * @param backgroundColor
+         *            String to be used as the background color of this element when added. In the format "rgb(x,x,x)" or "rgba(x,x,x,x)"
+         * @param window
+         *            'window' from Javascript
+         * @param webEngine
+         *            Web engine that the page is loaded in
+         * @param frame
+         *            Expeditee frame to add the converted page to
+         * @throws IllegalArgumentException
+         * @throws IllegalAccessException
+         */
+        private static void addTextToFrame(Node rootElement, int visibleWidth, int visibleHeight, JSObject window, WebEngine webEngine, Frame frame) throws InvocationTargetException,
+                        IllegalAccessException, IllegalArgumentException {
+
+                Node currentNode = rootElement;
+
+                if (currentNode.getNodeType() == Node.TEXT_NODE) {
+
+                        JSObject style;
+                        JSObject bounds;
+
+
+                        // CSS style for the element
+                        style = (JSObject) window.call("getComputedStyle", new Object[] { currentNode.getParentNode() });
+
+                        // Getting a rectangle that represents the area and position of the element
+                        bounds = (JSObject) ((JSObject) currentNode.getParentNode()).call("getBoundingClientRect", new Object[] {});
+
+
+                        // Bounding rectangle position is relative to the current view, so scroll position must be added to x/y
+                        // TODO: This doesn't check if an element or any of its parent elements have position:fixed set - the only
+                        // way to check seems to be to walking through the element's parents until the document root is reached
+                        float x = Float.valueOf(bounds.getMember("left").toString());
+                        float y = Float.valueOf(bounds.getMember("top").toString());
+
+                        float width = Float.valueOf(bounds.getMember("width").toString());
+                        float height = Float.valueOf(bounds.getMember("height").toString());
+
+                        // Checking if the element is actually visible on the page
+                        if (width > 0 && height > 0 && x + width > 0 && y + height > 0 && x <= visibleWidth && y <= visibleHeight
+                                        && !(((String) style.call("getPropertyValue", new Object[] { "display" })).equals("none"))) {
+
+                                String fontSize = ((String) style.call("getPropertyValue", new Object[] { "font-size" }));
+
+                                // Trimming off the units (always px) from the font size
+                                fontSize = fontSize.substring(0, fontSize.length() - 2);
+
+                                // Always returns in format "rgb(x,x,x)" or "rgba(x,x,x,x)"
+                                String color = (String) style.call("getPropertyValue", new Object[] { "color" });
+
+                                // Always returns in format "rgb(x,x,x)" or "rgba(x,x,x,x)"
+                                String bgColorString = (String) style.call("getPropertyValue", new Object[] { "background-color" });
+
+                                String align = (String) style.call("getPropertyValue", new Object[] { "text-align" });
+
+                                // Returns comma-separated list of typefaces
+                                String typeface = (String) style.call("getPropertyValue", new Object[] { "font-family" });
+
+                                String[] typefaces = typeface.split(", |,");
+
+                                String weight = (String) style.call("getPropertyValue", new Object[] { "font-weight" });
+
+                                String fontStyle = (String) style.call("getPropertyValue", new Object[] { "font-style" });
+
+                                // Returns "normal" or a value in pixels (e.g. "10px")
+                                String letterSpacing = (String) style.call("getPropertyValue", new Object[] { "letter-spacing" });
+
+                                // Returns a value in pixels (e.g. "10px")
+                                String lineHeight = (String) style.call("getPropertyValue", new Object[] { "line-height" });
+
+                                String textTransform = (String) style.call("getPropertyValue", new Object[] { "text-transform" });
+
+                                String linkUrl = (String) ((JSObject) currentNode.getParentNode()).getMember("href");
+
+                                Boolean fontFound = false;
+                                Font font = new Font(null);
+
+                                // Looping through all font-families listed in the element's CSS until one that is installed is
+                                // found, or the end of the list is reached, in which case the default font is used
+                                for (int j = 0; j < typefaces.length && !fontFound; j++) {
+                                        if (typefaces[j].toLowerCase().equals("sans-serif")) {
+                                                typefaces[j] = "Arial Unicode MS";
+                                        } else if (typefaces[j].toLowerCase().equals("serif")) {
+                                                typefaces[j] = "Times New Roman";
+                                        } else if ((typefaces[j].toLowerCase().equals("arial"))) {
+                                                // Have to use Arial Unicode, otherwise unicode characters display incorrectly
+                                                typefaces[j] = "Arial Unicode MS";
+                                        }
+
+                                        // Regex will remove any inverted commas surrounding multi-word typeface names
+                                        font = new Font(typefaces[j].replaceAll("^'|'$", ""), Font.PLAIN, 12);
+
+                                        // If the font isn't found, Java just uses Font.DIALOG, so this check checks whether the font was found
+                                        if (!(font.getFamily().toLowerCase().equals(Font.DIALOG.toLowerCase()))) {
+                                                fontFound = true;
+                                        }
+                                }
+
+                                if (font.getFamily().toLowerCase().equals(Font.DIALOG.toLowerCase())) {
+                                        font = new Font("Times New Roman", Font.PLAIN, 12);
+                                }
+
+                                String fontStyleComplete = "";
+
+                                int weightInt = 0;
+
+                                try {
+                                        weightInt = Integer.parseInt(weight);
+                                } catch (NumberFormatException nfe) {
+                                        // Use default value as set above
+                                }
+
+                                // checking if font is bold - i.e. 'bold', 'bolder' or weight over 500
+                                if (weight.toLowerCase().startsWith("bold") || weightInt > 500) {
+                                        fontStyleComplete = fontStyleComplete.concat("bold");
+                                }
+
+                                if (fontStyle.toLowerCase().equals("italic") || fontStyle.toLowerCase().equals("oblique")) {
+                                        fontStyleComplete = fontStyleComplete.concat("italic");
+                                }
+
+                                float fontSizeFloat = 12;
+
+                                try {
+                                        fontSizeFloat = Float.valueOf(fontSize);
+                                } catch (NumberFormatException nfe) {
+                                        // Use default value as set above
+                                }
+
+                                float letterSpacingFloat = -0.008f;
+
+                                try {
+                                        letterSpacingFloat = (Integer.parseInt(letterSpacing.substring(0, letterSpacing.length() - 2)) / (fontSizeFloat));
+                                } catch (NumberFormatException nfe) {
+                                        // Use default value as set above
+                                }
+
+                                float lineHeightInt = -1;
+
+                                try {
+                                        lineHeightInt = (Float.parseFloat(lineHeight.substring(0, lineHeight.length() - 2)));
+                                } catch (NumberFormatException nfe) {
+                                        // Use default value as set above
+                                }
+
+                                Text t;
+
+                                String textContent = currentNode.getTextContent().replaceAll("[^\\S\\n]+", " ");
+                                textContent = textContent.replaceAll("^(\\s)(\\n|\\r)", "");
+
+                                if (textTransform.equals("uppercase")) {
+                                        textContent = textContent.toUpperCase();
+                                } else if (textTransform.equals("lowercase")) {
+                                        textContent = textContent.toUpperCase();
+                                }
+
+                                // Adding the text to the frame. Expeditee text seems to be positioned relative to the baseline of the first line, so
+                                // the font size has to be added to the y-position
+                                t = frame.addText(Math.round(x), Math.round(y + fontSizeFloat), textContent, null);
+
+                                t.setColor(rgbStringToColor(color));
+                                t.setBackgroundColor(rgbStringToColor(bgColorString));
+                                t.setFont(font);
+                                t.setSize(fontSizeFloat);
+                                t.setFontStyle(fontStyleComplete);
+                                t.setLetterSpacing(letterSpacingFloat);
+
+                                // Removing any spacing between lines allowing t.getLineHeight() to be used to get the actual height
+                                // of just the characters (i.e. distance from ascenders to descenders)
+                                t.setSpacing(0);
+
+                                t.setSpacing(lineHeightInt - t.getLineHeight());
+
+                                if (align.equals("left")) {
+                                        t.setJustification(Justification.left);
+                                } else if (align.equals("right")) {
+                                        t.setJustification(Justification.right);
+                                } else if (align.equals("center")) {
+                                        t.setJustification(Justification.center);
+                                } else if (align.equals("justify")) {
+                                        t.setJustification(Justification.full);
+                                }
+
+                                // Font size is added to the item width to give a little breathing room
+                                t.setWidth(Math.round(width + (t.getSize())));
+
+                                if (!linkUrl.equals("undefined")) {
+                                        t.setAction("gotourl " + linkUrl);
+                                        t.setActionMark(false);
+                                }
+                        }
+
+                } else if (currentNode.getNodeType() == Node.ELEMENT_NODE) {
+                        Node childNode = currentNode.getFirstChild();
+
+                        while (childNode != null) {
+                                addTextToFrame(childNode, visibleWidth, visibleHeight, window, webEngine, frame);
+                                childNode = childNode.getNextSibling();
+                        }
+                }
+        }
+
         private static class MutableBool {
                 private boolean value;

trunk/src/org/expeditee/items/widgets/JfxBrowser.java

@@ -528 +528 @@
 
         public void getFrameNew() {
-                // this.setSize(1000, 100000);
+                // this.setSize(1000, 1000);
                 // this._browser.setBounds(getX(), getY(), getWidth(), getHeight());
-
                 // this.layout(this._browser);
+
                 try {
-                        WebParser.parsePageSimple(this._browser.webEngine, this._browser.webview, (JComponent) this._browser.jfxPanel, DisplayIO.getCurrentFrame());
+                        WebParser.parsePageSimple(JfxBrowser.this._browser.webEngine, JfxBrowser.this._browser.webview, (JComponent) JfxBrowser.this._browser.jfxPanel, DisplayIO.getCurrentFrame());
                 } catch (Exception e) {
                         e.printStackTrace();