svgjs-draw 2.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9cdce64e25e6ca33a9c3e561ab6b2ffbaf2cf65c
+  data.tar.gz: 427e43ad7f3b2975a07d8e8bbf85325112389c2c
+SHA512:
+  metadata.gz: cccd36733bda53f038361f919f2b6d73a13e569b6e4e34c002d5eedd83795c220fdd6776eb677fb0576b55604db705fba4491e25d1607c96d418557f893d6cdf
+  data.tar.gz: 77f9de474f3edcfe8c6703a08579ae3b9d7cb94ee4ede274220942895cd9d82edd8bfbdae48d09268cd91c7606b0aaf51f179b20112c3e6f87f427b906408f3c

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in svgjs-draw.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright (c) 2018,  koparo.com <info@koparo.com>
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

data/README.md

@@ -0,0 +1,46 @@
+# Svgjs::Draw
+
+An extension of svg.js which allows to draw elements with mouse
+
+This gem bundles the upstream distribution for use with the Ruby on Rails framework. The version number of
+the gem always tracks the upstream javascript release and the gem itself doesn't provide any additional
+methods or helpers. If a need for helpers arises in the future they will be developed as a separate gem
+with this one as its dependency. Should a gem bug be discovered an additional version identifier will be
+appended and incremented after the upstream version number.
+
+The gem is developed and tested against Rails 5
+
+## License
+svgjs-draw and changes made to svg.draw.js required for rails are licensed under ISC.
+
+The original svg.draw.js code distributed with this gem is licensed under [MIT](https://tldrlegal.com/license/mit-license)
+You can find the svg.draw.js license file in the vendor directory, changes made to the original code base are as follows:
+
+* for consistency with other includes the following renames have been done
+** `svg.draw.js` to `svg-draw.js`
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'svgjs-draw'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install svgjs-draw
+
+## Usage
+
+Add the following directive to your JavaScript manifest file (application.js):
+
+    //= require svg-draw
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/koparo/svgjs-draw.

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/lib/svgjs/draw.rb

@@ -0,0 +1,8 @@
+require "svgjs/draw/version"
+
+module Svgjs
+  module Draw
+    class Engine < ::Rails::Engine
+    end
+  end
+end

data/lib/svgjs/draw/version.rb

@@ -0,0 +1,5 @@
+module Svgjs
+  module Draw
+    VERSION = "2.0.3"
+  end
+end

data/svgjs-draw.gemspec

@@ -0,0 +1,28 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "svgjs/draw/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "svgjs-draw"
+  spec.version       = Svgjs::Draw::VERSION
+  spec.authors       = ["Adam Wolk"]
+  spec.email         = ["adam.wolk@koparo.com"]
+
+  spec.summary       = %q{svg.draw.js javascript bundle}
+  spec.description   = %q{An extension of svg.js which allows to draw elements with mouse}
+  spec.homepage      = "https://github.com/svgdotjs/svg.js"
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+
+  spec.add_dependency "svgjs", "~> 2.6.4"
+end

data/vendor/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Fuzzy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/vendor/assets/javascripts/svg-draw.js

@@ -0,0 +1,442 @@
+/*! svg.draw.js - v2.0.3 - 2017-06-19
+* https://github.com/svgdotjs/svg.draw.js
+* Copyright (c) 2017 Ulrich-Matthias Schäfer; Licensed MIT */
+
+;(function () {
+    // Our Object which manages drawing
+    function PaintHandler(el, event, options) {
+
+        this.el = el;
+        el.remember('_paintHandler', this);
+    
+        var _this = this,
+            plugin = this.getPlugin();
+
+        this.parent = el.parent(SVG.Nested) || el.parent(SVG.Doc);
+        this.p = this.parent.node.createSVGPoint(); // Helping point for coord transformation
+        this.m = null;  // transformation matrix. We get it when drawing starts
+        this.startPoint = null;
+        this.lastUpdateCall = null;
+        this.options = {};
+
+        // Merge options and defaults
+        for (var i in this.el.draw.defaults) {
+            this.options[i] = this.el.draw.defaults[i];
+            if (typeof options[i] !== 'undefined') {
+                this.options[i] = options[i];
+            }
+        }
+        
+        if(plugin.point) {
+          plugin['pointPlugin'] = plugin.point;
+          delete plugin.point;
+        }
+        
+        // Import all methods from plugin into object
+        for (var i in plugin){
+            this[i] = plugin[i];
+        }
+        
+        // When we got an event, we use this for start, otherwise we use the click-event as default
+        if (!event) {
+            this.parent.on('click.draw', function (e) {
+                _this.start(e);
+            });
+
+        }
+
+    }
+
+    PaintHandler.prototype.transformPoint = function(x, y){
+
+        this.p.x = x - (this.offset.x - window.pageXOffset);
+        this.p.y = y - (this.offset.y - window.pageYOffset);
+        
+        return this.p.matrixTransform(this.m);
+    
+    }
+    
+    PaintHandler.prototype.start = function (event) {
+    
+        var _this = this;
+    
+        // get the current transform matrix from screen to element (offset corrected)
+        this.m = this.el.node.getScreenCTM().inverse();
+
+        // we save the current scrolling-offset here
+        this.offset = { x: window.pageXOffset, y: window.pageYOffset };
+
+        // we want to snap in screen-coords, so we have to scale the snapToGrid accordingly
+        this.options.snapToGrid *= Math.sqrt(this.m.a * this.m.a + this.m.b * this.m.b)
+
+        // save the startpoint
+        this.startPoint = this.snapToGrid(this.transformPoint(event.clientX, event.clientY));
+
+        // the plugin may do some initial work
+        if(this.init){ this.init(event); }
+
+        // Fire our `drawstart`-event. We send the offset-corrected cursor-position along
+        this.el.fire('drawstart', {event:event, p:this.p, m:this.m});
+
+        // We need to bind the update-function to the mousemove event to keep track of the cursor
+        SVG.on(window, 'mousemove.draw', function (e) {
+            _this.update(e);
+        });
+
+        // Every consecutive call to start should map to point now
+        this.start = this.point;
+
+
+    };
+
+    // This function draws a point if the element is a polyline or polygon
+    // Otherwise it will just stop drawing the shape cause we are done
+    PaintHandler.prototype.point = function (event) {
+        if (this.point != this.start) return this.start(event);
+        
+        if (this.pointPlugin) {
+            return this.pointPlugin(event);
+        }
+    
+        // If this function is not overwritten we just call stop
+        this.stop(event);
+    };
+
+
+    // The stop-function does the cleanup work
+    PaintHandler.prototype.stop = function (event) {
+        if (event) {
+            this.update(event);
+        }
+        
+        // Plugin may want to clean something
+        if(this.clean){ this.clean(); }
+
+        // Unbind from all events
+        SVG.off(window, 'mousemove.draw');
+        this.parent.off('click.draw');
+
+        // remove Refernce to PaintHandler
+        this.el.forget('_paintHandler');
+
+        // overwrite draw-function since we never need it again for this element
+        this.el.draw = function () {
+        };
+
+        // Fire the `drawstop`-event
+        this.el.fire('drawstop');
+    };
+
+    // Updates the element while moving the cursor
+    PaintHandler.prototype.update = function (event) {
+
+        if(!event && this.lastUpdateCall){
+            event = this.lastUpdateCall;
+        }
+        
+        this.lastUpdateCall = event;
+    
+        // Call the calc-function which calculates the new position and size
+        this.calc(event);
+
+        // Fire the `drawupdate`-event
+        this.el.fire('drawupdate', {event:event, p:this.p, m:this.m});
+    };
+
+    // Called from outside. Finishs a poly-element
+    PaintHandler.prototype.done = function () {
+        this.calc();
+        this.stop();
+
+        this.el.fire('drawdone');
+    };
+
+    // Called from outside. Cancels a poly-element
+    PaintHandler.prototype.cancel = function () {
+        // stop drawing and remove the element
+        this.stop();
+        this.el.remove();
+
+        this.el.fire('drawcancel');
+    };
+
+    // Calculate the corrected position when using `snapToGrid`
+    PaintHandler.prototype.snapToGrid = function (draw) {
+
+        var temp = null;
+
+        // An array was given. Loop through every element
+        if (draw.length) {
+            temp = [draw[0] % this.options.snapToGrid, draw[1] % this.options.snapToGrid];
+            draw[0] -= temp[0] < this.options.snapToGrid / 2 ? temp[0] : temp[0] - this.options.snapToGrid;
+            draw[1] -= temp[1] < this.options.snapToGrid / 2 ? temp[1] : temp[1] - this.options.snapToGrid;
+            return draw;
+        }
+
+        // Properties of element were given. Snap them all
+        for (var i in draw) {
+            temp = draw[i] % this.options.snapToGrid;
+            draw[i] -= (temp < this.options.snapToGrid / 2 ? temp : temp - this.options.snapToGrid) + (temp < 0 ? this.options.snapToGrid : 0);
+        }
+
+        return draw;
+    };
+
+    PaintHandler.prototype.param = function (key, value) {
+        this.options[key] = value === null ? this.el.draw.defaults[key] : value;
+        this.update();
+    };
+
+    // Returns the plugin
+    PaintHandler.prototype.getPlugin = function () {
+        return this.el.draw.plugins[this.el.type];
+    };
+
+    SVG.extend(SVG.Element, {
+        // Draw element with mouse
+        draw: function (event, options, value) {
+
+            // sort the parameters
+            if (!(event instanceof Event || typeof event === 'string')) {
+                options = event;
+                event = null;
+            }
+
+            // get the old Handler or create a new one from event and options
+            var paintHandler = this.remember('_paintHandler') || new PaintHandler(this, event, options || {});
+
+            // When we got an event we have to start/continue drawing
+            if (event instanceof Event) {
+                paintHandler['start'](event);
+            }
+
+            // if event is located in our PaintHandler we handle it as method
+            if (paintHandler[event]) {
+                paintHandler[event](options, value);
+            }
+
+            return this;
+        }
+
+    });
+
+    // Default values. Can be changed for the whole project if needed
+    SVG.Element.prototype.draw.defaults = {
+        snapToGrid: 1        // Snaps to a grid of `snapToGrid` px
+    };
+
+    SVG.Element.prototype.draw.extend = function(name, obj){
+
+        var plugins = {};
+        if(typeof name === 'string'){
+            plugins[name] = obj;
+        }else{
+            plugins = name;
+        }
+
+        for(var shapes in plugins){
+            var shapesArr = shapes.trim().split(/\s+/);
+
+            for(var i in shapesArr){
+                SVG.Element.prototype.draw.plugins[shapesArr[i]] = plugins[shapes];
+            }
+        }
+
+    };
+
+    // Container for all types not specified here
+    SVG.Element.prototype.draw.plugins = {};
+
+    SVG.Element.prototype.draw.extend('rect image', {
+    
+        init:function(e){
+
+            var p = this.startPoint;
+            
+            this.el.attr({ x: p.x, y: p.y, height: 0, width: 0 });
+        },
+        
+        calc:function (e) {
+
+            var rect = {
+                x: this.startPoint.x,
+                y: this.startPoint.y
+            },  p = this.transformPoint(e.clientX, e.clientY);
+
+            rect.width = p.x - rect.x;
+            rect.height = p.y - rect.y;
+
+            // Snap the params to the grid we specified
+            this.snapToGrid(rect);
+
+            // When width is less than zero, we have to draw to the left
+            // which means we have to move the start-point to the left
+            if (rect.width < 0) {
+                rect.x = rect.x + rect.width;
+                rect.width = -rect.width;
+            }
+
+            // ...same with height
+            if (rect.height < 0) {
+                rect.y = rect.y + rect.height;
+                rect.height = -rect.height;
+            }
+
+            // draw the element
+            this.el.attr(rect);
+        }
+    
+    });
+
+
+    SVG.Element.prototype.draw.extend('line polyline polygon', {
+
+        init:function(e){
+            // When we draw a polygon, we immediately need 2 points.
+            // One start-point and one point at the mouse-position
+
+            this.set = new SVG.Set();
+
+            var p = this.startPoint,
+                arr = [
+                    [p.x, p.y],
+                    [p.x, p.y]
+                ];
+
+            this.el.plot(arr);
+
+            // We draw little circles around each point
+            // This is absolutely not needed and maybe removed in a later release
+            this.drawCircles();
+
+        },
+
+
+        // The calc-function sets the position of the last point to the mouse-position (with offset ofc)
+        calc:function (e) {
+            var arr = this.el.array().valueOf();
+            arr.pop();
+
+            if (e) {
+                var p = this.transformPoint(e.clientX, e.clientY);
+                arr.push(this.snapToGrid([p.x, p.y]));
+            }
+
+            this.el.plot(arr);
+
+        },
+
+        point:function(e){
+
+            if (this.el.type.indexOf('poly') > -1) {
+                // Add the new Point to the point-array
+                var p = this.transformPoint(e.clientX, e.clientY),
+                    arr = this.el.array().valueOf();
+
+                arr.push(this.snapToGrid([p.x, p.y]));
+
+                this.el.plot(arr);
+                this.drawCircles();
+
+                // Fire the `drawpoint`-event, which holds the coords of the new Point
+                this.el.fire('drawpoint', {event:e, p:{x:p.x, y:p.y}, m:this.m});
+
+                return;
+            }
+
+            // We are done, if the element is no polyline or polygon
+            this.stop(e);
+
+        },
+
+        clean:function(){
+
+            // Remove all circles
+            this.set.each(function () {
+                this.remove();
+            });
+
+            this.set.clear();
+
+            delete this.set;
+
+        },
+
+        drawCircles:function () {
+            var array = this.el.array().valueOf()
+
+            this.set.each(function () {
+                this.remove();
+            });
+
+            this.set.clear();
+
+            for (var i = 0; i < array.length; ++i) {
+
+                this.p.x = array[i][0]
+                this.p.y = array[i][1]
+
+                var p = this.p.matrixTransform(this.parent.node.getScreenCTM().inverse().multiply(this.el.node.getScreenCTM()));
+
+                this.set.add(this.parent.circle(5).stroke({width: 1}).fill('#ccc').center(p.x, p.y));
+            }
+        }
+
+    });
+
+    SVG.Element.prototype.draw.extend('circle', {
+    
+        init:function(e){
+        
+            var p = this.startPoint;
+
+            this.el.attr({ cx: p.x, cy: p.y, r: 1 });
+        },
+
+        // We determine the radius by the cursor position
+        calc:function (e) {
+            
+            var p = this.transformPoint(e.clientX, e.clientY),
+                circle = {
+                    cx: this.startPoint.x,
+                    cy: this.startPoint.y,
+
+                    // calculating the radius
+                    r: Math.sqrt(
+                        (p.x - this.startPoint.x) * (p.x - this.startPoint.x) +
+                        (p.y - this.startPoint.y) * (p.y - this.startPoint.y)
+                    )
+            };
+            
+            this.snapToGrid(circle);
+            this.el.attr(circle);
+        }
+        
+    });
+
+    SVG.Element.prototype.draw.extend('ellipse', {
+    
+        init:function(e){
+            // We start with a circle with radius 1 at the position of the cursor
+            var p = this.startPoint;
+
+            this.el.attr({ cx: p.x, cy: p.y, rx: 1, ry: 1 });
+            
+        },
+
+        calc:function (e) {
+            var p = this.transformPoint(e.clientX, e.clientY);
+        
+            var ellipse = {
+                cx: this.startPoint.x,
+                cy: this.startPoint.y,
+                rx: Math.abs(p.x - this.startPoint.x),
+                ry: Math.abs(p.y - this.startPoint.y)
+            };
+            
+            this.snapToGrid(ellipse);
+            this.el.attr(ellipse);
+        }
+        
+    });
+}).call(this);

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: svgjs-draw
+version: !ruby/object:Gem::Version
+  version: 2.0.3
+platform: ruby
+authors:
+- Adam Wolk
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-04-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: svgjs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.6.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.6.4
+description: An extension of svg.js which allows to draw elements with mouse
+email:
+- adam.wolk@koparo.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/svgjs/draw.rb
+- lib/svgjs/draw/version.rb
+- svgjs-draw.gemspec
+- vendor/LICENSE
+- vendor/assets/javascripts/svg-draw.js
+homepage: https://github.com/svgdotjs/svg.js
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14.1
+signing_key: 
+specification_version: 4
+summary: svg.draw.js javascript bundle
+test_files: []