1 files changed, 390 insertions, 0 deletions
diff --git a/src/com/isode/stroke/parser/payloadparsers/WhiteboardParser.java b/src/com/isode/stroke/parser/payloadparsers/WhiteboardParser.java
new file mode 100644
index 0000000..3cbe8d8
--- /dev/null
+++ b/src/com/isode/stroke/parser/payloadparsers/WhiteboardParser.java
@@ -0,0 +1,390 @@
+/*  Copyright (c) 2016, Isode Limited, London, England.
+ *  All rights reserved.
+ *
+ *  Acquisition and use of this software and related materials for any
+ *  purpose requires a written license agreement from Isode Limited,
+ *  or a written license from an organisation licensed by Isode Limited
+ *  to grant such a license.
+ *
+ */
+package com.isode.stroke.parser.payloadparsers;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.isode.stroke.elements.WhiteboardColor;
+import com.isode.stroke.elements.WhiteboardDeleteOperation;
+import com.isode.stroke.elements.WhiteboardElement;
+import com.isode.stroke.elements.WhiteboardEllipseElement;
+import com.isode.stroke.elements.WhiteboardFreehandPathElement;
+import com.isode.stroke.elements.WhiteboardInsertOperation;
+import com.isode.stroke.elements.WhiteboardLineElement;
+import com.isode.stroke.elements.WhiteboardOperation;
+import com.isode.stroke.elements.WhiteboardPayload;
+import com.isode.stroke.elements.WhiteboardPolygonElement;
+import com.isode.stroke.elements.WhiteboardRectElement;
+import com.isode.stroke.elements.WhiteboardUpdateOperation;
+import com.isode.stroke.elements.WhiteboardPayload.Type;
+import com.isode.stroke.elements.WhiteboardTextElement;
+import com.isode.stroke.parser.AttributeMap;
+import com.isode.stroke.parser.GenericPayloadParser;
+
+public class WhiteboardParser extends GenericPayloadParser<WhiteboardPayload> {
+    
+    private boolean actualIsText;
+    private int level_;
+    private String data_;
+    private WhiteboardElement wbElement;
+    private WhiteboardOperation operation;
+
+    public WhiteboardParser() {
+        super(new WhiteboardPayload());
+    }
+
+    @Override
+    public void handleStartElement(String element, String ns,
+            AttributeMap attributes) {
+        if (level_ == 0) {
+            getPayloadInternal().setType(stringToType(getAttributeOr(attributes, "type", "")));
+        } 
+        else if (level_ == 1) {
+            String type = getAttributeOr(attributes, "type", "");
+            if (type.equals("insert")) {
+                operation = new WhiteboardInsertOperation();
+            }
+            else if (type.equals("update")) {
+                WhiteboardUpdateOperation updateOp = new WhiteboardUpdateOperation();
+                String move = getAttributeOr(attributes, "newpos", "0");
+                updateOp.setNewPos(Integer.parseInt(move));
+                operation = updateOp;
+            }
+            else if (type.equals("delete")) {
+                WhiteboardDeleteOperation deleteOp = new WhiteboardDeleteOperation();
+                deleteOp.setElementID(getAttributeOr(attributes, "elementid", ""));
+                operation = deleteOp;
+            }
+            if (operation != null) {
+                operation.setID(getAttributeOr(attributes, "id", ""));
+                operation.setParentID(getAttributeOr(attributes, "parentid", ""));
+                try {
+                    operation.setPos(getIntAttribute(attributes, "pos", 0));
+                } catch (NumberFormatException e) {
+                    // Dont set pos
+                }
+            }
+
+        } 
+        else if (level_ == 2) {
+            if ("line".equals(element)) {
+                int x1 = 0, y1 = 0, x2 = 0, y2 = 0;
+                try {
+                    x1 = getIntAttribute(attributes, "x1", 0);
+                    y1 = getIntAttribute(attributes, "y1", 0);
+                    x2 = getIntAttribute(attributes, "x2", 0);
+                    y2 = getIntAttribute(attributes, "y2", 0);
+                } catch (NumberFormatException e) {
+                }
+                WhiteboardLineElement whiteboardElement = new WhiteboardLineElement(x1, y1, x2, y2);
+
+                WhiteboardColor color = new WhiteboardColor(getAttributeOr(attributes, "stroke", "#000000"));
+                color.setAlpha(opacityToAlpha(getAttributeOr(attributes, "opacity", "1")));
+                whiteboardElement.setColor(color);
+
+                int penWidth = 1;
+                try {
+                    penWidth = getIntAttribute(attributes, "stroke-width", 1);
+                } catch (NumberFormatException e) {
+                    // Empty Catch
+                }
+
+                whiteboardElement.setPenWidth(penWidth);
+                whiteboardElement.setID(getAttributeOr(attributes,"id",""));
+                getPayloadInternal().setElement(whiteboardElement);
+                wbElement = whiteboardElement;
+            }
+            else if ("path".equals(element)) {
+                WhiteboardFreehandPathElement whiteboardElement = new WhiteboardFreehandPathElement();
+                String pathData = getAttributeOr(attributes, "d", "");
+                List<WhiteboardFreehandPathElement.Point> points =
+                        new ArrayList<WhiteboardFreehandPathElement.Point>();
+                if (!pathData.isEmpty() && pathData.charAt(0) == 'M') {
+                    try {
+                        int pos = 1, npos;
+                        int x, y;
+                        if (pathData.charAt(pos) == ' ') {
+                            pos++;
+                        }
+                        npos = pathData.indexOf(' ',pos);
+                        x = Integer.parseInt(pathData.substring(pos, npos));
+                        pos = npos+1;
+                        npos = pathData.indexOf('L',pos);
+                        y = Integer.parseInt(pathData.substring(pos,npos));
+                        pos = npos+1;
+                        if (pos < pathData.length() && pathData.charAt(pos) == ' ') {
+                            pos++;
+                        }
+                        points.add(new WhiteboardFreehandPathElement.Point(x,y));
+                        while (pos < pathData.length()) {
+                            npos = pathData.indexOf(' ',pos);
+                            x = Integer.parseInt(pathData.substring(pos, npos));
+                            pos = npos+1;
+                            npos = pathData.indexOf(' ',pos);
+                            y = Integer.parseInt(pathData.substring(pos, npos));
+                            pos = npos+1;
+                            points.add(new WhiteboardFreehandPathElement.Point(x,y));
+                        }
+                    } 
+                    catch (NumberFormatException e) {
+                        // Empty catch
+                    }
+                }
+                whiteboardElement.setPoints(points);
+
+                int penWidth = 1;
+                try {
+                    penWidth = getIntAttribute(attributes, "stroke-width", 1);
+                } catch (NumberFormatException e) {
+                    // Empty Catch
+                }
+                whiteboardElement.setPenWidth(penWidth);
+                
+                WhiteboardColor color = new WhiteboardColor(getAttributeOr(attributes, "stroke", "#000000"));
+                color.setAlpha(opacityToAlpha(getAttributeOr(attributes, "opacity", "1")));
+                whiteboardElement.setColor(color);
+                whiteboardElement.setID(getAttributeOr(attributes,"id",""));
+                getPayloadInternal().setElement(whiteboardElement);
+                wbElement = whiteboardElement;
+            }
+            else if ("rect".equals(element)) {
+                int x = 0, y = 0, width = 0, height = 0;
+                try {
+                    x = getIntAttribute(attributes, "x", 0);
+                    y = getIntAttribute(attributes, "y", 0);
+                    width = getIntAttribute(attributes, "width", 0);
+                    height = getIntAttribute(attributes, "height", 0);
+                } catch (Exception e) {
+                    // Empty Catch
+                }
+                
+                WhiteboardRectElement whiteboardElement = new WhiteboardRectElement(x,y,width,height);
+                
+                int penWidth = 1;
+                try {
+                    penWidth = getIntAttribute(attributes, "stroke-width", 1);
+                } catch (NumberFormatException e) {
+                    // Empty Catch Block
+                }
+                whiteboardElement.setPenWidth(penWidth);
+                
+                WhiteboardColor penColor = new WhiteboardColor(getAttributeOr(attributes, "stroke", "#000000"));
+                WhiteboardColor brushColor = new WhiteboardColor(getAttributeOr(attributes, "fill", "#000000"));
+                penColor.setAlpha(opacityToAlpha(getAttributeOr(attributes, "opacity", "1")));
+                brushColor.setAlpha(opacityToAlpha(getAttributeOr(attributes, "fill-opacity", "1")));
+                whiteboardElement.setPenColor(penColor);
+                whiteboardElement.setBrushColor(brushColor);;
+                whiteboardElement.setID(getAttributeOr(attributes, "id", ""));
+                getPayloadInternal().setElement(whiteboardElement);
+                wbElement = whiteboardElement;
+            }
+            else if ("polygon".equals(element)) {
+                WhiteboardPolygonElement whiteboardElement = new WhiteboardPolygonElement();
+                
+                String pointsData = getAttributeOr(attributes, "points", "");
+                List<WhiteboardPolygonElement.Point> points = new ArrayList<WhiteboardPolygonElement.Point>();
+                int pos = 0;
+                int npos;
+                int x,y;
+                try {
+                    while (pos < pointsData.length()) {
+                        npos = pointsData.indexOf(',', pos);
+                        if (npos == -1) {
+                            break;
+                        }
+                        x = Integer.parseInt(pointsData.substring(pos, npos));
+                        pos = npos+1;
+                        npos = pointsData.indexOf(' ',pos);
+                        if (npos == -1) {
+                            npos = pointsData.length();
+                        }
+                        y = Integer.parseInt(pointsData.substring(pos,npos));
+                        pos = npos+1;
+                        points.add(new WhiteboardPolygonElement.Point(x,y));
+                    }
+                } catch (NumberFormatException e) {
+                    // Empty catch 
+                }
+                
+                whiteboardElement.setPoints(points);
+                
+                int penWidth = 0;
+                try {
+                    penWidth = getIntAttribute(attributes, "stroke-width", 1);
+                } catch (Exception e) {
+                    // Empty catch
+                }
+                
+                WhiteboardColor penColor = new WhiteboardColor(getAttributeOr(attributes, "stroke", "#000000"));
+                WhiteboardColor brushColor = new WhiteboardColor(getAttributeOr(attributes, "fill", "#000000"));
+                penColor.setAlpha(opacityToAlpha(getAttributeOr(attributes, "opacity", "1")));
+                brushColor.setAlpha(opacityToAlpha(getAttributeOr(attributes, "fill-opacity", "1")));
+                
+                whiteboardElement.setPenColor(penColor);
+                whiteboardElement.setBrushColor(brushColor);
+                whiteboardElement.setID(getAttributeOr(attributes, "id", ""));
+                getPayloadInternal().setElement(whiteboardElement);
+                wbElement = whiteboardElement;
+            }
+            else if ("text".equals(element)) {
+                int x = 0, y = 0;
+                try {
+                    x = getIntAttribute(attributes, "x", 0);
+                    y = getIntAttribute(attributes, "y", 0);
+                } catch (NumberFormatException e) {
+                    // Empty Catch
+                }
+                
+                WhiteboardTextElement whiteboardElement = new WhiteboardTextElement(x, y);
+                
+                actualIsText = true;
+                WhiteboardColor color = new WhiteboardColor(getAttributeOr(attributes, "fill", "#000000"));
+                color.setAlpha(opacityToAlpha(getAttributeOr(attributes, "opacity", "1")));
+                whiteboardElement.setColor(color);
+                
+                int fontSize = 1;
+                try {
+                    fontSize = getIntAttribute(attributes, "font-size", 12);
+                } catch (NumberFormatException e) {
+                   // Empty Catch
+                }
+                
+                whiteboardElement.setSize(fontSize);
+                whiteboardElement.setID(getAttributeOr(attributes, "id", ""));
+                getPayloadInternal().setElement(whiteboardElement);
+                wbElement = whiteboardElement;
+            }
+            else if ("ellipse".equals(element)) {
+                int cx = 0, cy = 0, rx = 0, ry = 0;
+                try {
+                    cx = getIntAttribute(attributes, "cx", 0);
+                    cy = getIntAttribute(attributes, "cy", 0);
+                    rx = getIntAttribute(attributes, "rx", 0);
+                    ry = getIntAttribute(attributes, "ry", 0);
+                } catch (NumberFormatException e) {
+                    // Empty Catch
+                }
+                
+                WhiteboardEllipseElement whiteboardElement = new WhiteboardEllipseElement(cx, cy, rx, ry);
+                
+                int penWidth = 1;
+                try {
+                    penWidth = getIntAttribute(attributes, "stroke-width", 1);
+                } catch (NumberFormatException e) {
+                    // Empty Catch
+                }
+                whiteboardElement.setPenWidth(penWidth);
+                
+                WhiteboardColor penColor = new WhiteboardColor(getAttributeOr(attributes, "stroke", "#000000"));
+                WhiteboardColor brushColor  = new WhiteboardColor(getAttributeOr(attributes,"fill","#000000"));
+                penColor.setAlpha(opacityToAlpha(getAttributeOr(attributes, "opacity", "1")));
+                brushColor.setAlpha(opacityToAlpha(getAttributeOr(attributes, "fill-opacity", "1")));
+                whiteboardElement.setPenColor(penColor);
+                whiteboardElement.setBrushColor(brushColor);
+                whiteboardElement.setID(getAttributeOr(attributes, "id", ""));
+                getPayloadInternal().setElement(whiteboardElement);
+                wbElement = whiteboardElement;
+            }
+        }
+        ++level_;
+    }
+
+    public void handleEndElement(String element, String ns) {
+        --level_;
+        if (level_ == 0) {
+            getPayloadInternal().setData(data_);
+        } else if (level_ == 1) {
+            if (operation instanceof WhiteboardInsertOperation) {
+                WhiteboardInsertOperation insertOp = (WhiteboardInsertOperation) operation;
+                insertOp.setElement(wbElement);
+            }
+            if (operation instanceof WhiteboardUpdateOperation) {
+                WhiteboardUpdateOperation updateOp = (WhiteboardUpdateOperation) operation;
+                updateOp.setElement(wbElement);
+            }
+            getPayloadInternal().setOperation(operation);
+        } else if (level_ == 2) {
+            if (element == "text") {
+                actualIsText = false;
+            }
+        }
+        
+    }
+
+    @Override
+    public void handleCharacterData(String data) {
+        if (level_ == 3 && actualIsText) {
+            WhiteboardTextElement element = (WhiteboardTextElement) getPayloadInternal().getElement();
+            element.setText(data);
+        }
+    }
+
+    private WhiteboardPayload.Type stringToType(String type) {
+        if (type == "data") {
+            return Type.Data;
+        } else if (type == "session-request") {
+            return Type.SessionRequest;
+        } else if (type == "session-accept") {
+            return Type.SessionAccept;
+        } else if (type == "session-terminate") {
+            return Type.SessionTerminate;
+        } else {
+            return Type.UnknownType;
+        }
+    }
+    
+    private int opacityToAlpha(String opacity) {
+        int value = 255;
+        int location = opacity.indexOf('.');
+        if (location != -1 && opacity.length() > (3+location)) {
+            String stringValue = opacity.substring(location+1,location+3);
+            try {
+                value = Integer.parseInt(stringValue)*255/100;
+            } catch (NumberFormatException nfe) {
+                value = 255;
+            }
+        }
+        return value;
+    }
+    
+    /**
+     * Gets the given attribute from a {@link AttributeMap} if it is set and none
+     * {@code null}, otherwise returns a default value.
+     * @param attributeMap An {@link AttributeMap}
+     * @param attribute The name of the attribute to get from the map.
+     * @param defaultValue Default value to return if the attribute is not set
+     * (or is set to {@code null}) in the {@link AttributeMap}
+     * @return The value of the attribute in the {@link AttributeMap} if it is
+     * none {@code null} or {@code defaultValue}
+     */
+    private String getAttributeOr(AttributeMap attributeMap,String attribute,String defaultValue) {
+        String value = attributeMap.getAttribute(attribute);
+        if (value == null) {
+            return defaultValue;
+        }
+        return value;
+    }
+    
+    /**
+     * Gets an int value for a given attribute in an attirbute map, or a default value
+     * if that attribute is not set.
+     * @param attributeMap An {@link AttributeMap}
+     * @param attribute The name of the attribute to get from the map
+     * @param defaultValue The default value to return if the attribute is not set.
+     * @throws NumberFormatException if the attribute value can not be passed into an integer.
+     * @return The value of the attribute as an int or defaultValue if it was not set.
+     */
+    private int getIntAttribute(AttributeMap attributeMap,String attribute,int defaultValue) throws NumberFormatException {
+        String stringValue = getAttributeOr(attributeMap, attribute, String.valueOf(defaultValue));
+        return Integer.parseInt(stringValue);
+    }
+    
+}