public override ShapeProvider ToShape(SVGElement context, RenderContext renderer, out Css.Value value) { value = this; if (_cachedTarget == null) { string id = this[0].Hash; // Get the target now: SVGElement target = context.document.getElementById(id) as SVGElement; if (target == null) { return(null); } // Get the path from the element (note that it could be a clip path): VectorPath path = target.GetPath(context, renderer); // Create a shape provider for it: _cachedTarget = new ShapeProvider(); _cachedTarget.SetPath(path); } return(_cachedTarget); }
/// <summary> /// Draw the comment icon. /// </summary> /// <param name="group">The icon group.</param> protected override void drawIcon_(SVGElement group) { // Circle. Core.createSvgElement("circle", new Dictionary <string, object>() { { "class", "blocklyIconShape" }, { "r", "8" }, { "cx", "8" }, { "cy", "8" } }, group); // Can't use a real "?" text character since different browsers and operating // systems render it differently. // Body of question mark. Core.createSvgElement("path", new Dictionary <string, object>() { { "class", "blocklyIconSymbol" }, { "d", "m6.8,10h2c0.003,-0.617 0.271,-0.962 0.633,-1.266 2.875,-2.405 0.607,-5.534 -3.765,-3.874v1.7c3.12,-1.657 3.698,0.118 2.336,1.25 -1.201,0.998 -1.201,1.528 -1.204,2.19z" } }, group); // Dot of question point. Core.createSvgElement("rect", new Dictionary <string, object>() { { "class", "blocklyIconSymbol" }, { "x", "6.8" }, { "y", "10.78" }, { "height", "2" }, { "width", "2" } }, group); }
/// <summary> /// Create all the DOM elements required for a scrollbar. /// The resulting widget is not sized. /// </summary> private void createDom_() { /* Create the following DOM: * <g class="blocklyScrollbarHorizontal"> * <rect class="blocklyScrollbarBackground" /> * <rect class="blocklyScrollbarHandle" rx="8" ry="8" /> * </g> */ var className = "blocklyScrollbar" + (this.horizontal_ ? "Horizontal" : "Vertical"); this.svgGroup_ = Core.createSvgElement("g", new Dictionary <string, object>() { { "class", className } }, null); this.svgBackground_ = Core.createSvgElement("rect", new Dictionary <string, object>() { { "class", "blocklyScrollbarBackground" } }, this.svgGroup_); var radius = System.Math.Floor((Scrollbar.scrollbarThickness - 5) / 2); this.svgHandle_ = Core.createSvgElement("rect", new Dictionary <string, object>() { { "class", "blocklyScrollbarHandle" }, { "rx", radius }, { "ry", radius } }, this.svgGroup_); Scrollbar.insertAfter_(this.svgGroup_, this.workspace_.getBubbleCanvas()); }
/// <summary> /// Does this icon get hidden when the block is collapsed. /// </summary> //public bool collapseHidden = false; /// <summary> /// Draw the warning icon. /// </summary> /// <param name="group">The icon group.</param> protected override void drawIcon_(SVGElement group) { // Triangle with rounded corners. Core.createSvgElement("path", new Dictionary <string, object>() { { "class", "blocklyIconShape" }, { "d", "M2,15Q-1,15 0.5,12L6.5,1.7Q8,-1 9.5,1.7L15.5,12Q17,15 14,15z" } }, group); // Can't use a real "!" text character since different browsers and operating // systems render it differently. // Body of exclamation point. Core.createSvgElement("path", new Dictionary <string, object>() { { "class", "blocklyIconSymbol" }, { "d", "m7,4.8v3.16l0.27,2.27h1.46l0.27,-2.27v-3.16z" } }, group); // Dot of exclamation point. Core.createSvgElement("rect", new Dictionary <string, object>() { { "class", "blocklyIconSymbol" }, { "x", "7" }, { "y", "11" }, { "height", "2" }, { "width", "2" } }, group); }
/// <summary> /// Class for an editable angle field. /// </summary> /// <param name="text">The initial content of the field.</param> /// <param name="opt_validator">An optional function that is called /// to validate any constraints on what the user entered. Takes the new /// text as an argument and returns the accepted text or null to abort /// the change.</param> public FieldAngle(string text, Func <Field, string, object> opt_validator = null) : base(text, opt_validator) { // Add degree symbol: "360°" (LTR) or "°360" (RTL) this.symbol_ = Core.createSvgElement("tspan", new Dictionary <string, object>(), null); this.symbol_.AppendChild(Document.CreateTextNode("\u00B0")); }
public Element CreateElementNS(String namespaceURI, String tagName) { Element element = null; if (namespaceURI == Namespaces.Html) { element = HTMLElement.Factory(tagName); } else if (namespaceURI == Namespaces.Svg) { element = SVGElement.Create(tagName); } else if (namespaceURI == Namespaces.MathML) { element = MathMLElement.Create(tagName); } else if (namespaceURI == Namespaces.Xml) { element = XMLElement.Create(tagName); } else { element = new Element { NamespaceURI = namespaceURI, NodeName = tagName } }; element.OwnerDocument = this; return(element); }
/// <summary> /// Dispose of all DOM objects belonging to this text. /// </summary> public override void dispose() { goog.dom.removeNode(this.fieldGroup_); this.fieldGroup_ = null; this.imageElement_ = null; this.rectElement_ = null; }
/// <summary> /// Return the absolute coordinates of the top-left corner of this element, /// scales that after canvas SVG element, if it's a descendant. /// The origin (0,0) is the top-left corner of the Blockly SVG. /// </summary> /// <param name="element">Element to find the coordinates of.</param> /// <param name="workspace">Element must be in this workspace.</param> /// <returns>Object with .x and .y properties.</returns> internal static goog.math.Coordinate getSvgXY_(SVGElement element, WorkspaceSvg workspace) { var x = 0.0; var y = 0.0; var scale = 1.0; if (goog.dom.contains(workspace.getCanvas(), element) || goog.dom.contains(workspace.getBubbleCanvas(), element)) { // Before the SVG canvas, scale the coordinates. scale = workspace.scale; } do { // Loop through this block and every parent. var xy = Core.getRelativeXY_(element); if (element == workspace.getCanvas() || element == workspace.getBubbleCanvas()) { // After the SVG canvas, don't scale the coordinates. scale = 1; } x += xy.x * scale; y += xy.y * scale; element = element.ParentNode as SVGElement; } while (element != null && element != workspace.getParentSvg()); return(new goog.math.Coordinate(x, y)); }
/// <summary> /// Create the icon on the block. /// </summary> internal void createIcon() { if (this.iconGroup_ != null) { // Icon already exists. return; } /* Here's the markup that will be generated: * <g class="blocklyIconGroup"> * ... * </g> */ this.iconGroup_ = Core.createSvgElement("g", new Dictionary <string, object>() { { "class", "blocklyIconGroup" } }, null); if (this.block_.isInFlyout) { Core.addClass_(this.iconGroup_, "blocklyIconGroupReadonly"); } this.drawIcon_(this.iconGroup_); this.block_.getSvgRoot().AppendChild(this.iconGroup_); Core.bindEventWithChecks_(this.iconGroup_, "mouseup", this, new Action <MouseEvent>(this.iconClick_)); this.updateEditable(); }
/// <summary>Gets the shape that this CSS value represents.</summary> public virtual ShapeProvider ToShape(SVGElement context, RenderContext renderer, out Css.Value value) { // Unchanged value: value = this; // Isn't one! return(null); }
public void dispose() { if (this.svgGroup_ != null) { goog.dom.removeNode(this.svgGroup_); this.svgGroup_ = null; } this.workspace_ = null; }
/// <summary> /// Dispose of this icon. /// </summary> public virtual void dispose() { // Dispose of and unlink the icon. goog.dom.removeNode(this.iconGroup_); this.iconGroup_ = null; // Dispose of and unlink the bubble. this.setVisible(false); this.block_ = null; }
/// <summary> /// Dispose of this pair of scrollbars. /// Unlink from all DOM elements to prevent memory leaks. /// </summary> public void dispose() { goog.dom.removeNode(this.corner_); this.corner_ = null; this.workspace_ = null; this.oldHostMetrics_ = null; this.hScroll.dispose(); this.hScroll = null; this.vScroll.dispose(); this.vScroll = null; }
/// <summary> /// Dispose of this trash can. /// Unlink from all DOM elements to prevent memory leaks. /// </summary> public void dispose() { if (this.svgGroup_ != null) { goog.dom.removeNode(this.svgGroup_); this.svgGroup_ = null; } this.svgLid_ = null; this.workspace_ = null; goog.Timer.clear(this.lidTask_); }
public override ShapeProvider ToShape(SVGElement context, RenderContext renderer, out Css.Value value) { // Convert into an SVG rect function so it can store a cached square: SVGRectFunction rect = new SVGRectFunction(); rect.Values = Values; value = rect; Css.Value junk; return(value.ToShape(context, renderer, out junk)); }
public override ShapeProvider ToShape(SVGElement context, RenderContext renderer, out Css.Value value) { // Convert into an SVG url function so it can store a cached square: SVGUrlFunction url = new SVGUrlFunction(); url.Values = Values; value = url; Css.Value junk; return(value.ToShape(context, renderer, out junk)); }
/// <summary> /// Create the button elements. /// </summary> /// <returns>The button's SVG group.</returns> public SVGElement createDom() { this.svgGroup_ = Core.createSvgElement("g", new Dictionary <string, object>() { { "class", this.isLabel_ ? "blocklyFlyoutLabel" : "blocklyFlyoutButton" } }, this.workspace_.getCanvas()); SVGElement shadow = null; if (!this.isLabel_) { // Shadow rectangle (light source does not mirror in RTL). shadow = Core.createSvgElement("rect", new Dictionary <string, object>() { { "class", "blocklyFlyoutButtonShadow" }, { "rx", 4 }, { "ry", 4 }, { "x", 1 }, { "y", 1 } }, this.svgGroup_); } // Background rectangle. var rect = Core.createSvgElement("rect", new Dictionary <string, object>() { { "class", this.isLabel_ ? "blocklyFlyoutLabelBackground" : "blocklyFlyoutButtonBackground" }, { "rx", 4 }, { "ry", 4 } }, this.svgGroup_); var svgText = Core.createSvgElement("text", new Dictionary <string, object>() { { "class", this.isLabel_ ? "blocklyFlyoutLabelText" : "blocklyText" }, { "x", 0 }, { "y", 0 }, { "text-anchor", "middle" } }, this.svgGroup_); svgText.TextContent = this.text_; this.width = svgText.getComputedTextLength() + 2 * FlyoutButton.MARGIN; this.height = 20; // Can't compute it :( if (!this.isLabel_) { shadow.SetAttribute("width", this.width.ToString()); shadow.SetAttribute("height", this.height.ToString()); } rect.SetAttribute("width", this.width.ToString()); rect.SetAttribute("height", this.height.ToString()); svgText.SetAttribute("x", (this.width / 2).ToString()); svgText.SetAttribute("y", (this.height - FlyoutButton.MARGIN).ToString()); this.updateTransform_(); return(this.svgGroup_); }
/// <summary> /// Dispose of this bubble. /// </summary> public void dispose() { Bubble.unbindDragEvents_(); // Dispose of and unlink the bubble. goog.dom.removeNode(this.bubbleGroup_); this.bubbleGroup_ = null; this.bubbleArrow_ = null; this.bubbleBack_ = null; this.resizeGroup_ = null; this.workspace_ = null; this.content_ = null; this.shape_ = null; }
public ScrollbarPair(WorkspaceSvg workspace) { this.workspace_ = workspace; this.hScroll = new Scrollbar(workspace, true, true); this.vScroll = new Scrollbar(workspace, false, true); this.corner_ = Core.createSvgElement("rect", new Dictionary <string, object>() { { "height", Scrollbar.scrollbarThickness }, { "width", Scrollbar.scrollbarThickness }, { "class", "blocklyScrollbarBackground" } }, null); Scrollbar.insertAfter_(this.corner_, workspace.getBubbleCanvas()); }
/// <summary> /// Return the converted coordinates of the given mouse ev. /// The origin (0,0) is the top-left corner of the Blockly svg. /// </summary> /// <param name="e">Mouse ev.</param> /// <param name="svg">SVG element.</param> /// <param name="matrix">Inverted screen CTM to use.</param> /// <returns>Object with .x and .y properties.</returns> public static SVGPoint mouseToSvg(Event e, SVGElement svg, SVGMatrix matrix) { var svgPoint = svg.createSVGPoint(); svgPoint.x = e.ClientX; svgPoint.y = e.ClientY; if (matrix == null) { matrix = svg.getScreenCTM().Inverse(); } return(svgPoint.matrixTransform(matrix)); }
/// <summary> /// Dispose of all DOM objects belonging to this editable field. /// </summary> public virtual void dispose() { if (this.mouseUpWrapper_ != null) { Core.unbindEvent_(this.mouseUpWrapper_); this.mouseUpWrapper_ = null; } this.sourceBlock_ = null; goog.dom.removeNode(this.fieldGroup_); this.fieldGroup_ = null; this.textElement_ = null; this.borderRect_ = null; this.validator_ = null; }
/// <summary> /// Dispose of this scrollbar. /// Unlink from all DOM elements to prevent memory leaks. /// </summary> public void dispose() { this.cleanUp_(); Core.unbindEvent_(this.onMouseDownBarWrapper_); this.onMouseDownBarWrapper_ = null; Core.unbindEvent_(this.onMouseDownHandleWrapper_); this.onMouseDownHandleWrapper_ = null; goog.dom.removeNode(this.svgGroup_); this.svgGroup_ = null; this.svgBackground_ = null; this.svgHandle_ = null; this.workspace_ = null; }
/// <summary> /// Create the editor for the mutator's bubble. /// </summary> /// <returns>The top-level node of the editor.</returns> private SVGElement createEditor_() { /* Create the editor. Here's the markup that will be generated: * <svg> * [Workspace] * </svg> */ this.svgDialog_ = Core.createSvgElement("svg", new Dictionary <string, object>() { { "x", Bubble.BORDER_WIDTH }, { "y", Bubble.BORDER_WIDTH } }, null); // Convert the list of names into a list of XML objects for the flyout. Element quarkXml; if (this.quarkNames_.Length != 0) { quarkXml = (Element)goog.dom.createDom("xml"); foreach (var quarkName in this.quarkNames_) { var block = (Element)goog.dom.createDom("block"); block.SetAttribute("type", quarkName); quarkXml.AppendChild(block); } } else { quarkXml = null; } var workspaceOptions = new Options { languageTree = quarkXml, parentWorkspace = this.block_.workspace, pathToMedia = this.block_.workspace.options.pathToMedia, RTL = this.block_.RTL, toolboxPosition = this.block_.RTL ? Core.TOOLBOX_AT_RIGHT : Core.TOOLBOX_AT_LEFT, horizontalLayout = false, getMetrics = new Func <Metrics>(() => this.getFlyoutMetrics_()), setMetrics = null }; this.workspace_ = new WorkspaceSvg(workspaceOptions); this.workspace_.MAX_UNDO = 0; this.workspace_.isMutator = true; this.svgDialog_.AppendChild( ((WorkspaceSvg)this.workspace_).createDom("blocklyMutatorBackground")); return(this.svgDialog_); }
private SVGElement createEditor_() { /* Create the editor. Here's the markup that will be generated: * <foreignObject x="8" y="8" width="164" height="164"> * <body xmlns="http://www.w3.org/1999/xhtml" class="blocklyMinimalBody"> * <textarea xmlns="http://www.w3.org/1999/xhtml" * class="blocklyCommentTextarea" * style="height: 164px; width: 164px;"></textarea> * </body> * </foreignObject> */ this.foreignObject_ = Core.createSvgElement("foreignObject", new Dictionary <string, object>() { { "x", Bubble.BORDER_WIDTH }, { "y", Bubble.BORDER_WIDTH } }, null); var body = Document.CreateElementNS <HTMLBodyElement>(Core.HTML_NS, "body"); body.SetAttribute("xmlns", Core.HTML_NS); body.ClassName = "blocklyMinimalBody"; var textarea = Document.CreateElementNS <HTMLTextAreaElement>(Core.HTML_NS, "textarea"); textarea.ClassName = "blocklyCommentTextarea"; textarea.SetAttribute("dir", this.block_.RTL ? "RTL" : "LTR"); body.AppendChild(textarea); this.textarea_ = textarea; this.foreignObject_.AppendChild(body); Core.bindEventWithChecks_(textarea, "mouseup", this, new Action <Event>(this.textareaFocus_)); // Don't zoom with mousewheel. Core.bindEventWithChecks_(textarea, "wheel", null, new Action <Event>((e) => { e.StopPropagation(); })); Core.bindEventWithChecks_(textarea, "change", null, new Action <Event>((e) => { if (this.text_ != textarea.Value) { Events.fire(new Events.Change( this.block_, "comment", null, this.text_, textarea.Value)); this.text_ = textarea.Value; } })); Window.SetTimeout(() => { textarea.Focus(); }, 0); return(this.foreignObject_); }
/// <summary> /// Insert a node after a reference node. /// Contrast with node.insertBefore function. /// </summary> /// <param name="newNode">New element to insert.</param> /// <param name="refNode">Existing element to precede new node.</param> internal static void insertAfter_(SVGElement newNode, SVGElement refNode) { var siblingNode = refNode.NextSibling; var parentNode = refNode.ParentNode; if (parentNode == null) { throw new Exception("Reference node has no parent."); } if (siblingNode != null) { parentNode.InsertBefore(newNode, siblingNode); } else { parentNode.AppendChild(newNode); } }
/// <summary> /// Class for UI bubble. /// </summary> /// <param name="workspace">The workspace on which to draw the /// bubble.</param> /// <param name="content">SVG content for the bubble.</param> /// <param name="shape">SVG element to avoid eclipsing.</param> /// <param name="anchorXY">Absolute position of bubble's anchor /// point.</param> /// <param name="bubbleWidth">Width of bubble, or null if not resizable.</param> /// <param name="bubbleHeight">Height of bubble, or null if not resizable.</param> public Bubble(WorkspaceSvg workspace, SVGElement content, SVGElement shape, goog.math.Coordinate anchorXY, double bubbleWidth, double bubbleHeight) { this.workspace_ = workspace; this.content_ = content; this.shape_ = shape; var angle = Bubble.ARROW_ANGLE; if (this.workspace_.RTL) { angle = -angle; } this.arrow_radians_ = goog.math.toRadians(angle); var canvas = workspace.getBubbleCanvas(); canvas.AppendChild(this.createDom_(content, !(bubbleWidth != 0.0 && bubbleHeight != 0.0))); this.setAnchorLocation(anchorXY); if (bubbleWidth == 0.0 || bubbleHeight == 0.0) { var bBox = /** @type {SVGLocatable} */ (this.content_).getBBox(); bubbleWidth = bBox.width + 2 * Bubble.BORDER_WIDTH; bubbleHeight = bBox.height + 2 * Bubble.BORDER_WIDTH; } this.setBubbleSize(bubbleWidth, bubbleHeight); // Render the bubble. this.positionBubble_(); this.renderArrow_(); this.rendered_ = true; if (!workspace.options.readOnly) { Core.bindEventWithChecks_(this.bubbleBack_, "mousedown", this, new Action <MouseEvent>(this.bubbleMouseDown_)); if (this.resizeGroup_ != null) { Core.bindEventWithChecks_(this.resizeGroup_, "mousedown", this, new Action <MouseEvent>(this.resizeMouseDown_)); } } }
/// <summary> /// Show or hide the comment bubble. /// </summary> /// <param name="visible">True if the bubble should be visible.</param> internal override void setVisible(bool visible) { if (visible == this.isVisible()) { // No change. return; } Events.fire( new Events.Ui(this.block_, "commentOpen", (!visible).ToString(), visible.ToString())); if ((!this.block_.isEditable() && this.textarea_ == null) || goog.userAgent.IE) { // Steal the code from warnings to make an uneditable text bubble. // MSIE does not support foreignobject; textareas are impossible. // http://msdn.microsoft.com/en-us/library/hh834675%28v=vs.85%29.aspx // Always treat comments in IE as uneditable. // TODO:Warning.prototype.setVisible.call(this, visible); return; } // Save the bubble stats before the visibility switch. var text = this.getText(); var size = this.getBubbleSize(); if (visible) { // Create the bubble. this.bubble_ = new Bubble((WorkspaceSvg)this.block_.workspace, this.createEditor_(), ((BlockSvg)this.block_).svgPath_, this.iconXY_, this.width_, this.height_); this.bubble_.registerResizeEvent(new Action(this.resizeBubble_)); this.updateColour(); } else { // Dispose of the bubble. this.bubble_.dispose(); this.bubble_ = null; this.textarea_ = null; this.foreignObject_ = null; } // Restore the bubble stats after the visibility switch. this.setText(text); this.setBubbleSize(size.width, size.height); }
/// <summary> /// Install this image on a block. /// </summary> public override void init() { if (this.fieldGroup_ != null) { // Image has already been initialized once. return; } // Build the DOM. /** @type {SVGElement} */ this.fieldGroup_ = Core.createSvgElement("g", new Dictionary <string, object>(), null); if (!this.visible_) { this.fieldGroup_.style.Display = Display.None; } /** @type {SVGElement} */ this.imageElement_ = Core.createSvgElement("image", new Dictionary <string, object>() { { "height", this.height_ + "px" }, { "width", this.width_ + "px" } }, this.fieldGroup_); this.setValue(this.src_); if (goog.userAgent.GECKO) { /** * Due to a Firefox bug which eats mouse events on image elements, * a transparent rectangle needs to be placed on top of the image. * @type {SVGElement} */ this.rectElement_ = Core.createSvgElement("rect", new Dictionary <string, object>() { { "height", this.height_ + "px" }, { "width", this.width_ + "px" }, { "fill-opacity", 0 } }, this.fieldGroup_); } this.sourceBlock_.getSvgRoot().AppendChild(this.fieldGroup_); // Configure the field to be transparent with respect to tooltips. var topElement = this.rectElement_ ?? this.imageElement_; topElement.tooltip = this.sourceBlock_; Tooltip.bindMouseEvents(topElement); }
/// <summary> /// Install this dropdown on a block. /// </summary> public override void init() { if (this.fieldGroup_ != null) { // Dropdown has already been initialized once. return; } // Add dropdown arrow: "option ▾" (LTR) or "▾ אופציה" (RTL) this.arrow_ = Core.createSvgElement("tspan", new Dictionary <string, object>(), null); this.arrow_.AppendChild(Document.CreateTextNode( this.sourceBlock_.RTL ? FieldDropdown.ARROW_CHAR + " " : ' ' + FieldDropdown.ARROW_CHAR)); base.init(); // Force a reset of the text to add the arrow. var text = this.text_; this.text_ = null; this.setText(text); }
public override ShapeProvider ToShape(SVGElement context, RenderContext renderer, out Css.Value value) { value = this; if (_cachedShape == null) { // Create a rectangle: RectangleProvider rect = new RectangleProvider(); // Apply width/height/position to it: rect.X = this[0]; rect.Y = this[1]; rect.Width = this[2]; rect.Height = this[3]; // Cached: _cachedShape = rect; } return(_cachedShape); }
// Parse the file specified by the path parameter public void importSVG(string path) { SVGElement element = new SVGElement(); TextAsset svgTextAsset = (TextAsset)Resources.Load("SVG/"+path); //load svg file as textasset string SVGData = svgTextAsset.text; // Remove superfluos characters SVGData = cleanString (SVGData); // Extract individual elements string[] SVGElements = SVGData.Split('<'); // Parse each element according to its type for (int i = 0; i < SVGElements.Length - 1; i++) { // Extract element type string e = SVGElements[i].Split (' ')[0]; // Ignore empty strings and end tags if(e.Length > 0 && e[0] == '/') continue; switch(e) { case "polygon": element = new SVGPolygon(SVGElements[i]); type = SVGType.polygon; break; //Not supported in sample /*case "path": element = new SVGPath(SVGElements[i]); type = SVGType.path; break; case "circle": element = new SVGCircle(SVGElements[i]); type = SVGType.circle; break; case "ellipse": element = new SVGEllipse(SVGElements[i]); type = SVGType.ellipse; break; case "rect": element = new SVGRect(SVGElements[i]); type = SVGType.rect; break; case "line": element = new SVGLine(SVGElements[i]); type = SVGType.line; break; case "text": element = new SVGText(SVGElements[i]); type = SVGType.text; break;*/ default: if (!(String.IsNullOrEmpty(e) || e != "svg")) break; Debug.Log ("Element '" + SVGElements[i] + "' not recognised"); break; } // Access element points List<Vector2> points = element.points; // Move on if there is no mesh to generate if ((points.Count == 0 && type != SVGType.text) || type == SVGType.none) { continue; } // Call mesh creation functions // Text mesh if(type == SVGType.text) { createText (element.id, element.singlePoint, element.fill, element.opacity, element.textString, element.fontSize, element.fontType, i); } // Line mesh else if(type == SVGType.line) { createMesh (element.strokePoints, element.stroke, element.opacity, i, element.id); } // All others else { // Create primary mesh createMesh (element.points, element.fill, element.opacity, i+1, element.id); // Create stroke mesh only if there are enough points if(element.strokePoints.Count > 2) createMesh (element.strokePoints, element.stroke, element.opacity, i, element.id); } // reset type to default type = SVGType.none; } }