From 643a7b5bb776dfb05a49e0c0263b2bc4f9bea5ec Mon Sep 17 00:00:00 2001 From: tristen Date: Fri, 27 Mar 2015 11:26:13 -0400 Subject: [PATCH] Set up handler hand off + class toggling --- .editorconfig | 4 + .eslintrc | 31 +++++++ dist/mapboxgl.draw.css | 3 + dist/mapboxgl.draw.js | 183 +++++++++++++++++++++++++++++++---------- index.js | 2 +- package.json | 3 +- src/dom.js | 21 ----- src/draw.js | 75 +++++++++++++---- src/handlers/circle.js | 7 ++ src/handlers/line.js | 7 ++ src/handlers/marker.js | 7 ++ src/handlers/shape.js | 7 ++ src/handlers/square.js | 7 ++ src/util.js | 34 ++++++++ 14 files changed, 309 insertions(+), 82 deletions(-) create mode 100644 .editorconfig create mode 100644 .eslintrc delete mode 100644 src/dom.js create mode 100644 src/handlers/circle.js create mode 100644 src/handlers/line.js create mode 100644 src/handlers/marker.js create mode 100644 src/handlers/shape.js create mode 100644 src/handlers/square.js diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 000000000..76b50b502 --- /dev/null +++ b/.editorconfig @@ -0,0 +1,4 @@ +[*.js] +indent_style = space +indent_size = 2 +trim_trailing_whitespace = true diff --git a/.eslintrc b/.eslintrc new file mode 100644 index 000000000..4c07d4a50 --- /dev/null +++ b/.eslintrc @@ -0,0 +1,31 @@ +{ + "rules": { + "space-after-function-name": 2, + "space-before-blocks": 2, + "space-after-keywords": 2, + "space-unary-ops": 2, + "no-use-before-define": [2, "nofunc"], + "camelcase": 0, + "comma-style": 2, + "eqeqeq": 0, + "new-cap": 2, + "no-multi-spaces": 2, + "brace-style": 2, + "no-underscore-dangle": [0], + "no-self-compare": 2, + "no-void": 2, + "wrap-iife": 2, + "no-eq-null": 2, + "quotes": [0], + "curly": 0, + "dot-notation": [0], + "no-shadow": 0 + }, + "env": { + "node": true, + "browser": true + }, + "globals": { + "mapboxgl": true + } +} diff --git a/dist/mapboxgl.draw.css b/dist/mapboxgl.draw.css index 4cbcc2311..d7dcf7a5a 100644 --- a/dist/mapboxgl.draw.css +++ b/dist/mapboxgl.draw.css @@ -28,3 +28,6 @@ .mapboxgl-ctrl-draw-btn.circle:before { content:'\e602'; } .mapboxgl-ctrl-draw-btn.square:before { content:'\e603'; } .mapboxgl-ctrl-draw-btn.line:before { content:'\e604'; } + +.mapboxgl-ctrl-draw-btn.active, +.mapboxgl-ctrl-draw-btn.active:hover { background-color:rgba(0,0,0,0.10); } diff --git a/dist/mapboxgl.draw.js b/dist/mapboxgl.draw.js index bcf7c06a0..54dc49dad 100644 --- a/dist/mapboxgl.draw.js +++ b/dist/mapboxgl.draw.js @@ -5,7 +5,7 @@ * @class mapbox.Draw * * @param {Object} options - * @param {String} [options.position=topright] A string indicating the control's position on the map. Options are `topright`, `topleft`, `bottomright`, `bottomleft` + * @param {String} [options.position=top-right] A string indicating the control's position on the map. Options are `topright`, `topleft`, `bottomright`, `bottomleft` * @returns {Draw} `this` * @example * var map = new mapboxgl.Map({ @@ -68,36 +68,20 @@ module.exports = { } }; -},{}],"/Users/tristen/dev/mapbox/gl-draw/src/dom.js":[function(require,module,exports){ -'use strict'; - -/* Builds DOM elements - * @param {String} tag Element name - * @param {String} [className] - * @param {Object} [container] DOM element to append to - * @param {Object} [attrbutes] Object containing attributes to apply to an - * element. Attribute name corresponds to the key. - * @returns {el} The dom element - */ -module.exports.create = function(tag, className, container, attributes) { - var el = document.createElement(tag); - if (className) el.className = className; - if (attributes) { - for (var key in attributes) { - el.setAttribute(key, attributes[key]); - } - } - if (container) container.appendChild(el); - return el; -}; - },{}],"/Users/tristen/dev/mapbox/gl-draw/src/draw.js":[function(require,module,exports){ 'use strict'; var extend = require('xtend'); var Control = require('./control'); -var DOM = require('./dom'); var util = require('./util'); +var DOM = util.DOM; + +// Control handlers +var Shape = require('./handlers/shape'); +var Line = require('./handlers/line'); +var Circle = require('./handlers/circle'); +var Square = require('./handlers/square'); +var Marker = require('./handlers/marker'); module.exports = Draw; @@ -107,34 +91,115 @@ function Draw(options) { Draw.prototype = extend(Control, { options: { - position: 'top-left' + position: 'top-left', + controls: { + marker: true, + line: true, + shape: true, + square: true, + circle: true + } }, onAdd: function(map) { - var className = 'mapboxgl-ctrl'; - var container = this._container = DOM.create('div', className + '-group', map.getContainer()); - this._shapeButton = this._createButton('mapboxgl-ctrl-draw-btn shape', 'Shape tool', this._drawShape.bind(map)); - this._lineButton = this._createButton('mapboxgl-ctrl-draw-btn line', 'Line tool', this._drawLine.bind(map)); - this._circleButton = this._createButton('mapboxgl-ctrl-draw-btn circle', 'Circle tool', this._drawCircle.bind(map)); - this._squareButton = this._createButton('mapboxgl-ctrl-draw-btn square', 'Rectangle tool', this._drawSquare.bind(map)); - this._markerButton = this._createButton('mapboxgl-ctrl-draw-btn marker', 'Marker tool', this._drawMarker.bind(map)); + var controlClass = this._controlClass = 'mapboxgl-ctrl-draw-btn'; + var container = this._container = DOM.create('div', 'mapboxgl-ctrl-group', map.getContainer()); + var controls = this.options.controls; + + if (controls.shape) this._createButton(controlClass + ' shape', 'Shape tool', this._drawShape.bind(map)); + if (controls.line) this._createButton(controlClass + ' line', 'Line tool', this._drawLine.bind(map)); + if (controls.circle) this._createButton(controlClass + ' circle', 'Circle tool', this._drawCircle.bind(map)); + if (controls.square) this._createButton(controlClass + ' square', 'Rectangle tool', this._drawSquare.bind(map)); + if (controls.marker) this._createButton(controlClass + ' marker', 'Marker tool', this._drawMarker.bind(map)); return container; }, - _drawShape: function(map) {}, - _drawLine: function(map) {}, - _drawCircle: function(map) {}, - _drawSquare: function(map) {}, - _drawMarker: function(map) {}, + _drawShape: function() { + new Shape(this); + }, + + _drawLine: function() { + new Line(this); + }, + + _drawCircle: function() { + new Circle(this); + }, + + _drawSquare: function() { + new Square(this); + }, + + _drawMarker: function() { + new Marker(this); + }, _createButton: function(className, title, fn) { - var a = DOM.create('button', className, this._container, {title: title}); - a.addEventListener('click', function() { fn(); }); + var a = DOM.create('button', className, this._container, { + title: title + }); + + var controlClass = this._controlClass; + a.addEventListener('click', function(e) { + e.preventDefault(); + + if (!this.classList.contains('active')) { + DOM.removeClass(document.querySelectorAll('.' + controlClass), 'active'); + this.classList.add('active'); + fn(); + } + }); + return a; } }); -},{"./control":"/Users/tristen/dev/mapbox/gl-draw/src/control.js","./dom":"/Users/tristen/dev/mapbox/gl-draw/src/dom.js","./util":"/Users/tristen/dev/mapbox/gl-draw/src/util.js","xtend":"/Users/tristen/dev/mapbox/gl-draw/node_modules/xtend/immutable.js"}],"/Users/tristen/dev/mapbox/gl-draw/src/util.js":[function(require,module,exports){ +},{"./control":"/Users/tristen/dev/mapbox/gl-draw/src/control.js","./handlers/circle":"/Users/tristen/dev/mapbox/gl-draw/src/handlers/circle.js","./handlers/line":"/Users/tristen/dev/mapbox/gl-draw/src/handlers/line.js","./handlers/marker":"/Users/tristen/dev/mapbox/gl-draw/src/handlers/marker.js","./handlers/shape":"/Users/tristen/dev/mapbox/gl-draw/src/handlers/shape.js","./handlers/square":"/Users/tristen/dev/mapbox/gl-draw/src/handlers/square.js","./util":"/Users/tristen/dev/mapbox/gl-draw/src/util.js","xtend":"/Users/tristen/dev/mapbox/gl-draw/node_modules/xtend/immutable.js"}],"/Users/tristen/dev/mapbox/gl-draw/src/handlers/circle.js":[function(require,module,exports){ +'use strict'; + +module.exports = Circle; + +function Circle(map) { + console.log(map); +} + +},{}],"/Users/tristen/dev/mapbox/gl-draw/src/handlers/line.js":[function(require,module,exports){ +'use strict'; + +module.exports = Line; + +function Line(map) { + console.log(map); +} + +},{}],"/Users/tristen/dev/mapbox/gl-draw/src/handlers/marker.js":[function(require,module,exports){ +'use strict'; + +module.exports = Marker; + +function Marker(map) { + console.log(map); +} + +},{}],"/Users/tristen/dev/mapbox/gl-draw/src/handlers/shape.js":[function(require,module,exports){ +'use strict'; + +module.exports = Shape; + +function Shape(map) { + console.log(map); +} + +},{}],"/Users/tristen/dev/mapbox/gl-draw/src/handlers/square.js":[function(require,module,exports){ +'use strict'; + +module.exports = Square; + +function Square(map) { + console.log(map); +} + +},{}],"/Users/tristen/dev/mapbox/gl-draw/src/util.js":[function(require,module,exports){ 'use strict'; module.exports = { @@ -153,8 +218,42 @@ module.exports = { obj.options[i] = options[i]; } return obj.options; + }, + + DOM: { + /* Builds DOM elements + * + * @param {String} tag Element name + * @param {String} [className] + * @param {Object} [container] DOM element to append to + * @param {Object} [attrbutes] Object containing attributes to apply to an + * element. Attribute name corresponds to the key. + * @returns {el} The dom element + */ + create: function(tag, className, container, attributes) { + var el = document.createElement(tag); + if (className) el.className = className; + if (attributes) { + for (var key in attributes) { + el.setAttribute(key, attributes[key]); + } + } + if (container) container.appendChild(el); + return el; + }, + + /* Removes classes from an array of DOM elements + * + * @param {HTMLElement} elements + * @param {String} klass + */ + removeClass: function(elements, klass) { + Array.prototype.forEach.call(elements, function(el) { + el.classList.remove(klass); + }); + } } }; },{}]},{},["/Users/tristen/dev/mapbox/gl-draw/index.js"]) -//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["node_modules/browserify/node_modules/browser-pack/_prelude.js","index.js","node_modules/xtend/immutable.js","src/control.js","src/draw.js","src/handlers/circle.js","src/handlers/line.js","src/handlers/marker.js","src/handlers/shape.js","src/handlers/square.js","src/util.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","`use strict`;\n\n/** A drawing component for mapboxgl\n * @class mapbox.Draw\n *\n * @param {Object} options\n * @param {String} [options.position=top-right] A string indicating the control's position on the map. Options are `topright`, `topleft`, `bottomright`, `bottomleft`\n * @returns {Draw} `this`\n * @example\n * var map = new mapboxgl.Map({\n *   container: 'map',\n *   style: 'https://www.mapbox.com/mapbox-gl-styles/styles/outdoors-v7.json'\n * });\n *\n * // Initialize the drawing component\n * map.addControl(new mapboxgl.Draw());\n */\nmapboxgl.Draw = require('./src/draw.js');\n","module.exports = extend\n\nfunction extend() {\n    var target = {}\n\n    for (var i = 0; i < arguments.length; i++) {\n        var source = arguments[i]\n\n        for (var key in source) {\n            if (source.hasOwnProperty(key)) {\n                target[key] = source[key]\n            }\n        }\n    }\n\n    return target\n}\n","'use strict';\n\nmodule.exports = {\n\n  addTo: function(map) {\n    this._map = map;\n    var container = this._container = this.onAdd(map);\n    if (this.options && this.options.position) {\n      var pos = this.options.position;\n      var corner = map._controlCorners[pos];\n      container.className += ' mapboxgl-ctrl';\n\n      if (pos.indexOf('bottom') !== -1) {\n        corner.insertBefore(container, corner.firstChild);\n      } else {\n        corner.appendChild(container);\n      }\n    }\n\n    return this;\n  },\n\n  remove: function() {\n    this._container.parentNode.removeChild(this._container);\n    if (this.onRemove) this.onRemove(this._map);\n    this._map = null;\n    return this;\n  }\n};\n","'use strict';\n\nvar extend = require('xtend');\nvar Control = require('./control');\nvar util = require('./util');\nvar DOM = util.DOM;\n\n// Control handlers\nvar Shape = require('./handlers/shape');\nvar Line = require('./handlers/line');\nvar Circle = require('./handlers/circle');\nvar Square = require('./handlers/square');\nvar Marker = require('./handlers/marker');\n\nmodule.exports = Draw;\n\nfunction Draw(options) {\n  util.setOptions(this, options);\n}\n\nDraw.prototype = extend(Control, {\n  options: {\n    position: 'top-left',\n    controls: {\n      marker: true,\n      line: true,\n      shape: true,\n      square: true,\n      circle: true\n    }\n  },\n\n  onAdd: function(map) {\n    var controlClass = this._controlClass = 'mapboxgl-ctrl-draw-btn';\n    var container = this._container = DOM.create('div', 'mapboxgl-ctrl-group', map.getContainer());\n    var controls = this.options.controls;\n\n    if (controls.shape) this._createButton(controlClass + ' shape', 'Shape tool', this._drawShape.bind(map));\n    if (controls.line) this._createButton(controlClass + ' line', 'Line tool', this._drawLine.bind(map));\n    if (controls.circle) this._createButton(controlClass + ' circle', 'Circle tool', this._drawCircle.bind(map));\n    if (controls.square) this._createButton(controlClass + ' square', 'Rectangle tool', this._drawSquare.bind(map));\n    if (controls.marker) this._createButton(controlClass + ' marker', 'Marker tool', this._drawMarker.bind(map));\n    return container;\n  },\n\n  _drawShape: function() {\n    new Shape(this);\n  },\n\n  _drawLine: function() {\n    new Line(this);\n  },\n\n  _drawCircle: function() {\n    new Circle(this);\n  },\n\n  _drawSquare: function() {\n    new Square(this);\n  },\n\n  _drawMarker: function() {\n    new Marker(this);\n  },\n\n  _createButton: function(className, title, fn) {\n    var a = DOM.create('button', className, this._container, {\n      title: title\n    });\n\n    var controlClass = this._controlClass;\n    a.addEventListener('click', function(e) {\n      e.preventDefault();\n\n      if (!this.classList.contains('active')) {\n        DOM.removeClass(document.querySelectorAll('.' + controlClass), 'active');\n        this.classList.add('active');\n        fn();\n      }\n    });\n\n    return a;\n  }\n});\n","'use strict';\n\nmodule.exports = Circle;\n\nfunction Circle(map) {\n  console.log(map);\n}\n","'use strict';\n\nmodule.exports = Line;\n\nfunction Line(map) {\n  console.log(map);\n}\n","'use strict';\n\nmodule.exports = Marker;\n\nfunction Marker(map) {\n  console.log(map);\n}\n","'use strict';\n\nmodule.exports = Shape;\n\nfunction Shape(map) {\n  console.log(map);\n}\n","'use strict';\n\nmodule.exports = Square;\n\nfunction Square(map) {\n  console.log(map);\n}\n","'use strict';\n\nmodule.exports = {\n\n  /* Merge user provided options object with a default one\n   *\n   * @param {Object} obj Containing an options key with which to merge\n   * @param {options} options Provided options with which to merge\n   * @returns {Object}\n   */\n  setOptions: function(obj, options) {\n      if (!obj.hasOwnProperty('options')) {\n          obj.options = obj.options ? Object.create(obj.options) : {};\n      }\n      for (var i in options) {\n          obj.options[i] = options[i];\n      }\n      return obj.options;\n  },\n\n  DOM: {\n    /* Builds DOM elements\n     *\n     * @param {String} tag Element name\n     * @param {String} [className]\n     * @param {Object} [container] DOM element to append to\n     * @param {Object} [attrbutes] Object containing attributes to apply to an\n     * element. Attribute name corresponds to the key.\n     * @returns {el} The dom element\n     */\n    create: function(tag, className, container, attributes) {\n      var el = document.createElement(tag);\n      if (className) el.className = className;\n      if (attributes) {\n        for (var key in attributes) {\n          el.setAttribute(key, attributes[key]);\n        }\n      }\n      if (container) container.appendChild(el);\n      return el;\n    },\n\n    /* Removes classes from an array of DOM elements\n     *\n     * @param {HTMLElement} elements\n     * @param {String} klass\n     */\n    removeClass: function(elements, klass) {\n      Array.prototype.forEach.call(elements, function(el) {\n        el.classList.remove(klass);\n      });\n    }\n  }\n};\n"]} diff --git a/index.js b/index.js index de618cb20..17ca45121 100644 --- a/index.js +++ b/index.js @@ -4,7 +4,7 @@ * @class mapbox.Draw * * @param {Object} options - * @param {String} [options.position=topright] A string indicating the control's position on the map. Options are `topright`, `topleft`, `bottomright`, `bottomleft` + * @param {String} [options.position=top-right] A string indicating the control's position on the map. Options are `topright`, `topleft`, `bottomright`, `bottomleft` * @returns {Draw} `this` * @example * var map = new mapboxgl.Map({ diff --git a/package.json b/package.json index e42cf467c..ed72ebef1 100644 --- a/package.json +++ b/package.json @@ -12,8 +12,7 @@ "url": "git://github.com/mapbox/gl-draw.git" }, "keywords": [ - "gl", - "draw", + "webgl", "mapbox", "draw", "drawing" diff --git a/src/dom.js b/src/dom.js deleted file mode 100644 index 384a1201a..000000000 --- a/src/dom.js +++ /dev/null @@ -1,21 +0,0 @@ -'use strict'; - -/* Builds DOM elements - * @param {String} tag Element name - * @param {String} [className] - * @param {Object} [container] DOM element to append to - * @param {Object} [attrbutes] Object containing attributes to apply to an - * element. Attribute name corresponds to the key. - * @returns {el} The dom element - */ -module.exports.create = function(tag, className, container, attributes) { - var el = document.createElement(tag); - if (className) el.className = className; - if (attributes) { - for (var key in attributes) { - el.setAttribute(key, attributes[key]); - } - } - if (container) container.appendChild(el); - return el; -}; diff --git a/src/draw.js b/src/draw.js index 9134b0d61..81eede4ca 100644 --- a/src/draw.js +++ b/src/draw.js @@ -2,8 +2,15 @@ var extend = require('xtend'); var Control = require('./control'); -var DOM = require('./dom'); var util = require('./util'); +var DOM = util.DOM; + +// Control handlers +var Shape = require('./handlers/shape'); +var Line = require('./handlers/line'); +var Circle = require('./handlers/circle'); +var Square = require('./handlers/square'); +var Marker = require('./handlers/marker'); module.exports = Draw; @@ -13,29 +20,65 @@ function Draw(options) { Draw.prototype = extend(Control, { options: { - position: 'top-left' + position: 'top-left', + controls: { + marker: true, + line: true, + shape: true, + square: true, + circle: true + } }, onAdd: function(map) { - var className = 'mapboxgl-ctrl'; - var container = this._container = DOM.create('div', className + '-group', map.getContainer()); - this._shapeButton = this._createButton('mapboxgl-ctrl-draw-btn shape', 'Shape tool', this._drawShape.bind(map)); - this._lineButton = this._createButton('mapboxgl-ctrl-draw-btn line', 'Line tool', this._drawLine.bind(map)); - this._circleButton = this._createButton('mapboxgl-ctrl-draw-btn circle', 'Circle tool', this._drawCircle.bind(map)); - this._squareButton = this._createButton('mapboxgl-ctrl-draw-btn square', 'Rectangle tool', this._drawSquare.bind(map)); - this._markerButton = this._createButton('mapboxgl-ctrl-draw-btn marker', 'Marker tool', this._drawMarker.bind(map)); + var controlClass = this._controlClass = 'mapboxgl-ctrl-draw-btn'; + var container = this._container = DOM.create('div', 'mapboxgl-ctrl-group', map.getContainer()); + var controls = this.options.controls; + + if (controls.shape) this._createButton(controlClass + ' shape', 'Shape tool', this._drawShape.bind(map)); + if (controls.line) this._createButton(controlClass + ' line', 'Line tool', this._drawLine.bind(map)); + if (controls.circle) this._createButton(controlClass + ' circle', 'Circle tool', this._drawCircle.bind(map)); + if (controls.square) this._createButton(controlClass + ' square', 'Rectangle tool', this._drawSquare.bind(map)); + if (controls.marker) this._createButton(controlClass + ' marker', 'Marker tool', this._drawMarker.bind(map)); return container; }, - _drawShape: function(map) {}, - _drawLine: function(map) {}, - _drawCircle: function(map) {}, - _drawSquare: function(map) {}, - _drawMarker: function(map) {}, + _drawShape: function() { + new Shape(this); + }, + + _drawLine: function() { + new Line(this); + }, + + _drawCircle: function() { + new Circle(this); + }, + + _drawSquare: function() { + new Square(this); + }, + + _drawMarker: function() { + new Marker(this); + }, _createButton: function(className, title, fn) { - var a = DOM.create('button', className, this._container, {title: title}); - a.addEventListener('click', function() { fn(); }); + var a = DOM.create('button', className, this._container, { + title: title + }); + + var controlClass = this._controlClass; + a.addEventListener('click', function(e) { + e.preventDefault(); + + if (!this.classList.contains('active')) { + DOM.removeClass(document.querySelectorAll('.' + controlClass), 'active'); + this.classList.add('active'); + fn(); + } + }); + return a; } }); diff --git a/src/handlers/circle.js b/src/handlers/circle.js new file mode 100644 index 000000000..5d9092b0a --- /dev/null +++ b/src/handlers/circle.js @@ -0,0 +1,7 @@ +'use strict'; + +module.exports = Circle; + +function Circle(map) { + console.log(map); +} diff --git a/src/handlers/line.js b/src/handlers/line.js new file mode 100644 index 000000000..7b1f3af4c --- /dev/null +++ b/src/handlers/line.js @@ -0,0 +1,7 @@ +'use strict'; + +module.exports = Line; + +function Line(map) { + console.log(map); +} diff --git a/src/handlers/marker.js b/src/handlers/marker.js new file mode 100644 index 000000000..7b08a887b --- /dev/null +++ b/src/handlers/marker.js @@ -0,0 +1,7 @@ +'use strict'; + +module.exports = Marker; + +function Marker(map) { + console.log(map); +} diff --git a/src/handlers/shape.js b/src/handlers/shape.js new file mode 100644 index 000000000..eed76522f --- /dev/null +++ b/src/handlers/shape.js @@ -0,0 +1,7 @@ +'use strict'; + +module.exports = Shape; + +function Shape(map) { + console.log(map); +} diff --git a/src/handlers/square.js b/src/handlers/square.js new file mode 100644 index 000000000..42aef9d39 --- /dev/null +++ b/src/handlers/square.js @@ -0,0 +1,7 @@ +'use strict'; + +module.exports = Square; + +function Square(map) { + console.log(map); +} diff --git a/src/util.js b/src/util.js index b5b28169c..ae326062a 100644 --- a/src/util.js +++ b/src/util.js @@ -16,5 +16,39 @@ module.exports = { obj.options[i] = options[i]; } return obj.options; + }, + + DOM: { + /* Builds DOM elements + * + * @param {String} tag Element name + * @param {String} [className] + * @param {Object} [container] DOM element to append to + * @param {Object} [attrbutes] Object containing attributes to apply to an + * element. Attribute name corresponds to the key. + * @returns {el} The dom element + */ + create: function(tag, className, container, attributes) { + var el = document.createElement(tag); + if (className) el.className = className; + if (attributes) { + for (var key in attributes) { + el.setAttribute(key, attributes[key]); + } + } + if (container) container.appendChild(el); + return el; + }, + + /* Removes classes from an array of DOM elements + * + * @param {HTMLElement} elements + * @param {String} klass + */ + removeClass: function(elements, klass) { + Array.prototype.forEach.call(elements, function(el) { + el.classList.remove(klass); + }); + } } };