DrawingManager.js

/**
 * @fileoverview 百度地图的鼠标绘制工具，对外开放。
 * 允许用户在地图上点击完成鼠标绘制的功能。
 * 使用者可以自定义所绘制结果的相关样式，例如线宽、颜色、测线段距离、面积等等。
 * 主入口类是<a href="symbols/BMapLib.DrawingManager.html">DrawingManager</a>，
 * 基于Baidu Map API 1.4。
 *
 * @author Baidu Map Api Group
 * @version 1.4
 */

/**
 * @namespace BMap的所有library类均放在BMapLib命名空间下
 */
var BMapLib = window.BMapLib = BMapLib || {};

/**
 * 定义常量, 绘制的模式
 * @final {Number} DrawingType
 */
var BMAP_DRAWING_MARKER    = "marker",     // 鼠标画点模式
    BMAP_DRAWING_POLYLINE  = "polyline",   // 鼠标画线模式
    BMAP_DRAWING_CIRCLE    = "circle",     // 鼠标画圆模式
    BMAP_DRAWING_RECTANGLE = "rectangle",  // 鼠标画矩形模式
    BMAP_DRAWING_POLYGON   = "polygon";    // 鼠标画多边形模式

(function() {

    // 自动检测当前脚本所在目录，用于拼接资源路径
    var _scriptPath = (function() {
        var scripts = document.getElementsByTagName('script');
        var src = document.currentScript
            ? document.currentScript.src
            : scripts[scripts.length - 1].src;
        return src.substring(0, src.lastIndexOf('/') + 1);
    })();

    /**
     * 声明baidu包
     */
    var baidu = baidu || { guid: '$BAIDU$' };
    (function () {
        // 一些页面级别唯一的属性，需要挂载在window[baidu.guid]上
        window[baidu.guid] = {};

        /**
         * 将源对象的所有属性拷贝到目标对象中
         * @name baidu.extend
         * @function
         * @grammar baidu.extend(target, source)
         * @param {Object} target 目标对象
         * @param {Object} source 源对象
         * @returns {Object} 目标对象
         */
        baidu.extend = function (target, source) {
            for (var p in source) {
                if (source.hasOwnProperty(p)) {
                    target[p] = source[p];
                }
            }
            return target;
        };

        /**
         * @ignore
         * @namespace
         * @baidu.lang 对语言层面的封装，包括类型判断、模块扩展、继承基类以及对象自定义事件的支持。
         * @property guid 对象的唯一标识
         */
        baidu.lang = baidu.lang || {};

        /**
         * 返回一个当前页面的唯一标识字符串。
         * @function
         * @grammar baidu.lang.guid()
         * @returns {String} 当前页面的唯一标识字符串
         */
        baidu.lang.guid = function () {
            return 'TANGRAM__' + (window[baidu.guid]._counter++).toString(36);
        };

        window[baidu.guid]._counter = window[baidu.guid]._counter || 1;

        /**
         * 所有类的实例的容器
         * key为每个实例的guid
         */
        window[baidu.guid]._instances = window[baidu.guid]._instances || {};

        /**
         * Tangram继承机制提供的一个基类，用户可以通过继承baidu.lang.Class来获取它的属性及方法。
         * @function
         * @name baidu.lang.Class
         * @grammar baidu.lang.Class(guid)
         * @param {string} guid 对象的唯一标识
         * @meta standard
         * @remark baidu.lang.Class和它的子类的实例均包含一个全局唯一的标识guid。
         * guid是在构造函数中生成的，因此，继承自baidu.lang.Class的类应该直接或者间接调用它的构造函数。<br>
         * baidu.lang.Class的构造函数中产生guid的方式可以保证guid的唯一性，及每个实例都有一个全局唯一的guid。
         */
        baidu.lang.Class = function (guid) {
            this.guid = guid || baidu.lang.guid();
            window[baidu.guid]._instances[this.guid] = this;
        };

        window[baidu.guid]._instances = window[baidu.guid]._instances || {};

        /**
         * 判断目标参数是否string类型或String对象
         * @name baidu.lang.isString
         * @function
         * @grammar baidu.lang.isString(source)
         * @param {Any} source 目标参数
         * @shortcut isString
         * @meta standard
         *
         * @returns {boolean} 类型判断结果
         */
        baidu.lang.isString = function (source) {
            return '[object String]' == Object.prototype.toString.call(source);
        };

        /**
         * 判断目标参数是否为function或Function实例
         * @name baidu.lang.isFunction
         * @function
         * @grammar baidu.lang.isFunction(source)
         * @param {Any} source 目标参数
         * @returns {boolean} 类型判断结果
         */
        baidu.lang.isFunction = function (source) {
            return '[object Function]' == Object.prototype.toString.call(source);
        };

        /**
         * 重载了默认的toString方法，使得返回信息更加准确一些。
         * @return {string} 对象的String表示形式
         */
        baidu.lang.Class.prototype.toString = function () {
            return '[object ' + (this._className || 'Object') + ']';
        };

        /**
         * 释放对象所持有的资源，主要是自定义事件。
         * @name dispose
         * @grammar obj.dispose()
         */
        baidu.lang.Class.prototype.dispose = function () {
            delete window[baidu.guid]._instances[this.guid];
            for (var property in this) {
                if (!baidu.lang.isFunction(this[property])) {
                    delete this[property];
                }
            }
            this.disposed = true;
        };

        /**
         * 自定义的事件对象。
         * @function
         * @name baidu.lang.Event
         * @grammar baidu.lang.Event(type[, target])
         * @param {string} type  事件类型名称。为了方便区分事件和一个普通的方法，事件类型名称必须以"on"(小写)开头。
         * @param {Object} [target]触发事件的对象
         * @meta standard
         * @remark 引入该模块，会自动为Class引入3个事件扩展方法：addEventListener、removeEventListener和dispatchEvent。
         * @see baidu.lang.Class
         */
        baidu.lang.Event = function (type, target) {
            this.type = type;
            this.returnValue = true;
            this.target = target || null;
            this.currentTarget = null;
        };

        /**
         * 注册对象的事件监听器。引入baidu.lang.Event后，Class的子类实例才会获得该方法。
         * @grammar obj.addEventListener(type, handler[, key])
         * @param   {string}   type         自定义事件的名称
         * @param   {Function} handler      自定义事件被触发时应该调用的回调函数
         * @param   {string}   [key]        为事件监听函数指定的名称，可在移除时使用。如果不提供，方法会默认为它生成一个全局唯一的key。
         * @remark  事件类型区分大小写。如果自定义事件名称不是以小写"on"开头，该方法会给它加上"on"再进行判断，即"click"和"onclick"会被认为是同一种事件。 
         */
        baidu.lang.Class.prototype.addEventListener = function (type, handler, key) {
            if (!baidu.lang.isFunction(handler)) {
                return;
            }
            !this.__listeners && (this.__listeners = {});
            var t = this.__listeners,
                id;
            if (typeof key == 'string' && key) {
                if (/[^\w\-]/.test(key)) {
                    throw ('nonstandard key:' + key);
                } else {
                    handler.hashCode = key;
                    id = key;
                }
            }

            type.indexOf('on') != 0 && (type = 'on' + type);
            typeof t[type] != 'object' && (t[type] = {});
            id = id || baidu.lang.guid();
            handler.hashCode = id;
            t[type][id] = handler;
        };

        /**
         * 移除对象的事件监听器。引入baidu.lang.Event后，Class的子类实例才会获得该方法。
         * @grammar obj.removeEventListener(type, handler)
         * @param {string}   type     事件类型
         * @param {Function|string} handler  要移除的事件监听函数或者监听函数的key
         * @remark  如果第二个参数handler没有被绑定到对应的自定义事件中，什么也不做。
         */
        baidu.lang.Class.prototype.removeEventListener = function (type, handler) {
            if (baidu.lang.isFunction(handler)) {
                handler = handler.hashCode;
            } else if (!baidu.lang.isString(handler)) {
                return;
            }
            !this.__listeners && (this.__listeners = {});
            type.indexOf('on') != 0 && (type = 'on' + type);
            var t = this.__listeners;
            if (!t[type]) {
                return;
            }
            t[type][handler] && delete t[type][handler];
        };

        /**
         * 派发自定义事件，使得绑定到自定义事件上面的函数都会被执行。引入baidu.lang.Event后，Class的子类实例才会获得该方法。
         * @grammar obj.dispatchEvent(event, options)
         * @param {baidu.lang.Event|String} event   Event对象，或事件名称(1.1.1起支持)
         * @param {Object} options 扩展参数,所含属性键值会扩展到Event对象上(1.2起支持)
         * @remark 处理会调用通过addEventListenr绑定的自定义事件回调函数之外，还会调用直接绑定到对象上面的自定义事件。
         * 例如：<br>
         * myobj.onMyEvent = function(){}<br>
         * myobj.addEventListener("onMyEvent", function(){});
         */
        baidu.lang.Class.prototype.dispatchEvent = function (event, options) {
            if (baidu.lang.isString(event)) {
                event = new baidu.lang.Event(event);
            }
            !this.__listeners && (this.__listeners = {});
            options = options || {};
            for (var i in options) {
                event[i] = options[i];
            }
            var i,
                t = this.__listeners,
                p = event.type;
            event.target = event.target || this;
            event.currentTarget = this;
            p.indexOf('on') != 0 && (p = 'on' + p);
            baidu.lang.isFunction(this[p]) && this[p].apply(this, arguments);
            if (typeof t[p] == 'object') {
                for (i in t[p]) {
                    t[p][i].apply(this, arguments);
                }
            }
            return event.returnValue;
        };

        /**
         * 为类型构造器建立继承关系
         * @name baidu.lang.inherits
         * @function
         * @grammar baidu.lang.inherits(subClass, superClass[, className])
         * @param {Function} subClass 子类构造器
         * @param {Function} superClass 父类构造器
         * @param {string} className 类名标识
         * @remark 使subClass继承superClass的prototype，
         * 因此subClass的实例能够使用superClass的prototype中定义的所有属性和方法。<br>
         * 这个函数实际上是建立了subClass和superClass的原型链集成，并对subClass进行了constructor修正。<br>
         * <strong>注意：如果要继承构造函数，需要在subClass里面call一下，具体见下面的demo例子</strong>
         * @shortcut inherits
         * @meta standard
         * @see baidu.lang.Class
         */
        baidu.lang.inherits = function (subClass, superClass, className) {
            var key,
                proto,
                selfProps = subClass.prototype,
                clazz = new Function();
            clazz.prototype = superClass.prototype;
            proto = subClass.prototype = new clazz();
            for (key in selfProps) {
                proto[key] = selfProps[key];
            }
            subClass.prototype.constructor = subClass;
            subClass.superClass = superClass.prototype;

            if ('string' == typeof className) {
                proto._className = className;
            }
        };

        /**
         * @ignore
         * @namespace baidu.dom 操作dom的方法。
         */
        baidu.dom = baidu.dom || {};

        /**
         * 从文档中获取指定的DOM元素
         *
         * @param {string|HTMLElement} id 元素的id或DOM元素
         * @meta standard
         * @return {HTMLElement} DOM元素，如果不存在，返回null，如果参数不合法，直接返回参数
         */
        baidu._g = baidu.dom._g = function (id) {
            if (baidu.lang.isString(id)) {
                return document.getElementById(id);
            }
            return id;
        };

        /**
         * 从文档中获取指定的DOM元素
         * @name baidu.dom.g
         * @function
         * @grammar baidu.dom.g(id)
         * @param {string|HTMLElement} id 元素的id或DOM元素
         * @meta standard
         *
         * @returns {HTMLElement|null} 获取的元素，查找不到时返回null,如果参数不合法，直接返回参数
         */
        baidu.g = baidu.dom.g = function (id) {
            if ('string' == typeof id || id instanceof String) {
                return document.getElementById(id);
            } else if (id && id.nodeName && (id.nodeType == 1 || id.nodeType == 9)) {
                return id;
            }
            return null;
        };

        /**
         * 在目标元素的指定位置插入HTML代码
         * @name baidu.dom.insertHTML
         * @function
         * @grammar baidu.dom.insertHTML(element, position, html)
         * @param {HTMLElement|string} element 目标元素或目标元素的id
         * @param {string} position 插入html的位置信息，取值为beforeBegin,afterBegin,beforeEnd,afterEnd
         * @param {string} html 要插入的html
         * @remark
         *
         * 对于position参数，大小写不敏感<br>
         * 参数的意思：beforeBegin&lt;span&gt;afterBegin   this is span! beforeEnd&lt;/span&gt; afterEnd <br />
         * 此外，如果使用本函数插入带有script标签的HTML字符串，script标签对应的脚本将不会被执行。
         *
         * @shortcut insertHTML
         * @meta standard
         *
         * @returns {HTMLElement} 目标元素
         */
        baidu.insertHTML = baidu.dom.insertHTML = function (element, position, html) {
            element = baidu.dom.g(element);
            var range,
                begin;

            if (element.insertAdjacentHTML) {
                element.insertAdjacentHTML(position, html);
            } else {
                // 这里不做"undefined" != typeof(HTMLElement) && !window.opera判断，其它浏览器将出错？！
                // 但是其实做了判断，其它浏览器下等于这个函数就不能执行了
                range = element.ownerDocument.createRange();
                // FF下range的位置设置错误可能导致创建出来的fragment在插入dom树之后html结构乱掉
                // 改用range.insertNode来插入html, by wenyuxiang @ 2010-12-14.
                position = position.toUpperCase();
                if (position == 'AFTERBEGIN' || position == 'BEFOREEND') {
                    range.selectNodeContents(element);
                    range.collapse(position == 'AFTERBEGIN');
                } else {
                    begin = position == 'BEFOREBEGIN';
                    range[begin ? 'setStartBefore' : 'setEndAfter'](element);
                    range.collapse(begin);
                }
                range.insertNode(range.createContextualFragment(html));
            }
            return element;
        };

        /**
         * 为目标元素添加className
         * @name baidu.dom.addClass
         * @function
         * @grammar baidu.dom.addClass(element, className)
         * @param {HTMLElement|string} element 目标元素或目标元素的id
         * @param {string} className 要添加的className，允许同时添加多个class，中间使用空白符分隔
         * @remark
         * 使用者应保证提供的className合法性，不应包含不合法字符，className合法字符参考：http://www.w3.org/TR/CSS2/syndata.html。
         * @shortcut addClass
         * @meta standard
         *
         * @returns {HTMLElement} 目标元素
         */
        baidu.ac = baidu.dom.addClass = function (element, className) {
            element = baidu.dom.g(element);
            var classArray = className.split(/\s+/),
                result = element.className,
                classMatch = ' ' + result + ' ',
                i = 0,
                l = classArray.length;

            for (; i < l; i++) {
                if (classMatch.indexOf(' ' + classArray[i] + ' ') < 0) {
                    result += (result ? ' ' : '') + classArray[i];
                }
            }

            element.className = result;
            return element;
        };

        /**
         * @ignore
         * @namespace baidu.event 屏蔽浏览器差异性的事件封装。
         * @property target     事件的触发元素
         * @property pageX      鼠标事件的鼠标x坐标
         * @property pageY      鼠标事件的鼠标y坐标
         * @property keyCode    键盘事件的键值
         */
        baidu.event = baidu.event || {};

        /**
         * 事件监听器的存储表
         * @private
         * @meta standard
         */
        baidu.event._listeners = baidu.event._listeners || [];

        /**
         * 为目标元素添加事件监听器
         * @name baidu.event.on
         * @function
         * @grammar baidu.event.on(element, type, listener)
         * @param {HTMLElement|string|window} element 目标元素或目标元素id
         * @param {string} type 事件类型
         * @param {Function} listener 需要添加的监听器
         * @remark
         *  1. 不支持跨浏览器的鼠标滚轮事件监听器添加<br>
         *  2. 改方法不为监听器灌入事件对象，以防止跨iframe事件挂载的事件对象获取失败
         * @shortcut on
         * @meta standard
         * @see baidu.event.un
         *
         * @returns {HTMLElement|window} 目标元素
         */
        baidu.on = baidu.event.on = function (element, type, listener) {
            type = type.replace(/^on/i, '');
            element = baidu._g(element);
            var realListener = function (ev) {
                    // 1. 这里不支持EventArgument,  原因是跨frame的事件挂载
                    // 2. element是为了修正this
                    listener.call(element, ev);
                },
                lis = baidu.event._listeners,
                filter = baidu.event._eventFilter,
                afterFilter,
                realType = type;
            type = type.toLowerCase();
            // filter过滤
            if (filter && filter[type]) {
                afterFilter = filter[type](element, type, realListener);
                realType = afterFilter.type;
                realListener = afterFilter.listener;
            }

            // 事件监听器挂载
            if (element.addEventListener) {
                element.addEventListener(realType, realListener, false);
            } else if (element.attachEvent) {
                element.attachEvent('on' + realType, realListener);
            }

            // 将监听器存储到数组中
            lis[lis.length] = [element, type, listener, realListener, realType];
            return element;
        };

        /**
         * 为目标元素移除事件监听器
         * @name baidu.event.un
         * @function
         * @grammar baidu.event.un(element, type, listener)
         * @param {HTMLElement|string|window} element 目标元素或目标元素id
         * @param {string} type 事件类型
         * @param {Function} listener 需要移除的监听器
         * @shortcut un
         * @meta standard
         *
         * @returns {HTMLElement|window} 目标元素
         */
        baidu.un = baidu.event.un = function (element, type, listener) {
            element = baidu._g(element);
            type = type.replace(/^on/i, '').toLowerCase();

            var lis = baidu.event._listeners,
                len = lis.length,
                isRemoveAll = !listener,
                item,
                realType,
                realListener;

            // 如果将listener的结构改成json
            // 可以节省掉这个循环，优化性能
            // 但是由于un的使用频率并不高，同时在listener不多的时候
            // 遍历数组的性能消耗不会对代码产生影响
            // 暂不考虑此优化
            while (len--) {
                item = lis[len];

                // listener存在时，移除element的所有以listener监听的type类型事件
                // listener不存在时，移除element的所有type类型事件
                if (item[1] === type 
                    && item[0] === element 
                    && (isRemoveAll || item[2] === listener)) {
                    realType = item[4];
                    realListener = item[3];
                    if (element.removeEventListener) {
                        element.removeEventListener(realType, realListener, false);
                    } else if (element.detachEvent) {
                        element.detachEvent('on' + realType, realListener);
                    }
                    lis.splice(len, 1);
                }
            }
            return element;
        };

        /**
         * 获取event事件,解决不同浏览器兼容问题
         * @param {Event}
         * @return {Event}
         */
        baidu.getEvent = baidu.event.getEvent = function (event) {
            return window.event || event;
        };

        /**
         * 获取event.target,解决不同浏览器兼容问题
         * @param {Event}
         * @return {Target}
         */
        baidu.getTarget = baidu.event.getTarget = function (event) {
            var event = baidu.getEvent(event);
            return event.target || event.srcElement;
        };

        /**
         * 阻止事件的默认行为
         * @name baidu.event.preventDefault
         * @function
         * @grammar baidu.event.preventDefault(event)
         * @param {Event} event 事件对象
         * @meta standard
         */
        baidu.preventDefault = baidu.event.preventDefault = function (event) {
            var event = baidu.getEvent(event);
            if (event.preventDefault) {
                event.preventDefault();
            } else {
                event.returnValue = false;
            }
        };

        /**
         * 停止事件冒泡传播
         * @param {Event}
         */
        baidu.stopBubble = baidu.event.stopBubble = function (event) {
            event = baidu.getEvent(event);
            event.stopPropagation ? event.stopPropagation() : event.cancelBubble = true;
        };

        /**
         * 判断是否为ie浏览器
         * @property ie ie版本号
         * @grammar baidu.browser.ie
         * @meta standard
         * @shortcut ie
         * @see baidu.browser.firefox,baidu.browser.safari,baidu.browser.opera,baidu.browser.chrome,baidu.browser.maxthon 
         */
        baidu.browser = baidu.browser || {};
        if (/msie (\d+\.\d)/i.test(navigator.userAgent)) {
            //IE 8下，以documentMode为准
            //在百度模板中，可能会有$，防止冲突，将$1 写成 \x241
            baidu.browser.ie = baidu.ie = document.documentMode || + RegExp['\x241'];
        }

    })();

    /**
     * @exports DrawingManager as BMapLib.DrawingManager
     */
    var DrawingManager =

    /**
     * DrawingManager类的构造函数
     * @class 鼠标绘制管理类，实现鼠标绘制管理的<b>入口</b>。
     * 实例化该类后，即可调用该类提供的open
     * 方法开启绘制模式状态。
     * 也可加入工具栏进行选择操作。
     *
     * @constructor
     * @param {Map} map Baidu map的实例对象
     * @param {Json Object} opts 可选的输入参数，非必填项。可输入选项包括：<br />
     * {"<b>isOpen</b>" : {Boolean} 是否开启绘制模式
     * <br />"<b>enableDrawingTool</b>" : {Boolean} 是否添加绘制工具栏控件，默认不添加
     * <br />"<b>drawingToolOptions</b>" : {Json Object} 可选的输入参数，非必填项。可输入选项包括
     * <br />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;"<b>anchor</b>" : {ControlAnchor} 停靠位置、默认左上角
     * <br />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;"<b>offset</b>" : {Size} 偏移值。
     * <br />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;"<b>scale</b>" : {Number} 工具栏的缩放比例,默认为1
     * <br />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;"<b>drawingModes</b>" : {DrawingType<Array>} 工具栏上可以选择出现的绘制模式,将需要显示的DrawingType以数组型形式传入，如[BMAP_DRAWING_MARKER, BMAP_DRAWING_CIRCLE] 将只显示画点和画圆的选项
     * <br />"<b>enableCalculate</b>" : {Boolean} 绘制是否进行测距(画线时候)、测面(画圆、多边形、矩形)
     * <br />"<b>markerOptions</b>" : {CircleOptions} 所画的点的可选参数，参考api中的<a href="http://developer.baidu.com/map/reference/index.php?title=Class:%E6%80%BB%E7%B1%BB/%E8%A6%86%E7%9B%96%E7%89%A9%E7%B1%BB">对应类</a>
     * <br />"<b>circleOptions</b>" : {CircleOptions} 所画的圆的可选参数，参考api中的<a href="http://developer.baidu.com/map/reference/index.php?title=Class:%E6%80%BB%E7%B1%BB/%E8%A6%86%E7%9B%96%E7%89%A9%E7%B1%BB">对应类</a>
     * <br />"<b>polylineOptions</b>" : {CircleOptions} 所画的线的可选参数，参考api中的<a href="http://developer.baidu.com/map/reference/index.php?title=Class:%E6%80%BB%E7%B1%BB/%E8%A6%86%E7%9B%96%E7%89%A9%E7%B1%BB">对应类</a>
     * <br />"<b>polygonOptions</b>" : {PolygonOptions} 所画的多边形的可选参数，参考api中的<a href="http://developer.baidu.com/map/reference/index.php?title=Class:%E6%80%BB%E7%B1%BB/%E8%A6%86%E7%9B%96%E7%89%A9%E7%B1%BB">对应类</a>
     * <br />"<b>rectangleOptions</b>" : {PolygonOptions} 所画的矩形的可选参数，参考api中的<a href="http://developer.baidu.com/map/reference/index.php?title=Class:%E6%80%BB%E7%B1%BB/%E8%A6%86%E7%9B%96%E7%89%A9%E7%B1%BB">对应类</a>
     *
     * @example <b>参考示例：</b><br />
     * var map = new BMap.Map("container");<br />map.centerAndZoom(new BMap.Point(116.404, 39.915), 15);<br />
     * var myDrawingManagerObject = new BMapLib.DrawingManager(map, {isOpen: true,
     *     drawingType: BMAP_DRAWING_MARKER, enableDrawingTool: true,
     *     enableCalculate: false,
     *     drawingToolOptions: {
     *         anchor: BMAP_ANCHOR_TOP_LEFT,
     *         offset: new BMap.Size(5, 5),
     *         drawingModes : [
     *             BMAP_DRAWING_MARKER,
     *             BMAP_DRAWING_CIRCLE,
     *             BMAP_DRAWING_POLYLINE,
     *             BMAP_DRAWING_POLYGON,
     *             BMAP_DRAWING_RECTANGLE
     *          ]
     *     },
     *     polylineOptions: {
     *         strokeColor: "#333"
     *     });
     */
    BMapLib.DrawingManager = function (map, opts) {
        if (!map) {
            return;
        }

        instances.push(this);

        opts = opts || {};
        this.overlays = []; // 用来存储覆盖物

        this._initialize(map, opts);
    };

    // 通过baidu.lang下的inherits方法，让DrawingManager继承baidu.lang.Class
    baidu.lang.inherits(DrawingManager, baidu.lang.Class, 'DrawingManager');

    /**
     * 开启地图的绘制模式
     *
     * @example <b>参考示例：</b><br />
     * myDrawingManagerObject.open();
     */
    DrawingManager.prototype.open = function () {
        // 判断绘制状态是否已经开启
        if (this._isOpen == true) {
            return true;
        }

        closeInstanceExcept(this);

        this._open();
    };

    /**
     * 关闭地图的绘制状态
     *
     * @example <b>参考示例：</b><br />
     * myDrawingManagerObject.close();
     */
    DrawingManager.prototype.close = function () {

        // 判断绘制状态是否已经开启
        if (this._isOpen == false) {
            return true;
        }

        var me = this;
        this._close();
        me._map.removeOverlay(tip_label);
        setTimeout(function () {
            me._map.enableDoubleClickZoom();
        }, 2000);

    };

    /**
     * 设置当前的绘制模式，参数DrawingType，为5个可选常量:
     * <br/>BMAP_DRAWING_MARKER    画点
     * <br/>BMAP_DRAWING_CIRCLE    画圆
     * <br/>BMAP_DRAWING_POLYLINE  画线
     * <br/>BMAP_DRAWING_POLYGON   画多边形
     * <br/>BMAP_DRAWING_RECTANGLE 画矩形
     * @param {DrawingType} DrawingType
     * @return {Boolean}
     *
     * @example <b>参考示例：</b><br />
     * myDrawingManagerObject.setDrawingMode(BMAP_DRAWING_POLYLINE);
     */
    DrawingManager.prototype.setDrawingMode = function (drawingType) {
        // 与当前模式不一样时候才进行重新绑定事件
        if (this._drawingType != drawingType) {
            closeInstanceExcept(this);
            this._setDrawingMode(drawingType);
        }

    };

    /**
     * 获取当前的绘制模式
     * @return {DrawingType} 绘制的模式
     *
     * @example <b>参考示例：</b><br />
     * alert(myDrawingManagerObject.getDrawingMode());
     */
    DrawingManager.prototype.getDrawingMode = function () {
        return this._drawingType;
    };

    /**
     * 打开距离或面积计算
     *
     * @example <b>参考示例：</b><br />
     * myDrawingManagerObject.enableCalculate();
     */
    DrawingManager.prototype.enableCalculate = function () {
        this._enableCalculate = true;
        this._addGeoUtilsLibrary();  // 异步调用GeoUtils
    };

    /**
     * 关闭距离或面积计算
     *
     * @example <b>参考示例：</b><br />
     * myDrawingManagerObject.disableCalculate();
     */
    DrawingManager.prototype.disableCalculate = function () {
        this._enableCalculate = false;
    };

    /**
     * 打开吸附功能
     */
    DrawingManager.prototype.enableSorption = function() {
        this._enableSorption = true;
    };

    /**
     * 关闭吸附功能
     */
    DrawingManager.prototype.disableSorption = function() {
        this._enableSorption = false;
    };


    /**
     * 打开gpc功能
     */
    DrawingManager.prototype.enableGpc = function() {
        this._enableGpc = true;
    };

    /**
     * 关闭gpc功能
     */
    DrawingManager.prototype.disableGpc = function() {
        this._enableGpc = false;
    };

    /** 
     * 获取所有绘制的覆盖物
     */
    DrawingManager.prototype.getOverlays = function() {
        return this.overlays;
    };

    DrawingManager.prototype.addOverlayData = function(overlay) {
        return this.overlays.push(overlay);
    };

    DrawingManager.prototype.setOverlaysData = function(overlays) {
        return this.overlays = overlays;
    };

    /**
     * 清除指定覆盖物数据
     */
    DrawingManager.prototype.clearOverlayData = function(overlay) {
        var map = this._map;
        for (var i = 0; i < this.overlays.length; i++) {
            if (this.overlays[i] === overlay) {
                this.overlays.splice(i, 1);
                return overlay;
            }
        }
    };

    /**
     * 清除指定覆盖物
     */
    DrawingManager.prototype.clearOverlay = function(overlay) {
        var map = this._map;
        var overlay = this.clearOverlayData(overlay);
        if (overlay) {
            map.removeOverlay(overlay);
        }
    };

    /** 
     * 清除所有绘制的覆盖物
     */
    DrawingManager.prototype.clearOverlays = function() {
        var map = this._map;
        this.overlays.forEach(function (overlay) {
            map.removeOverlay(overlay);
        });
        this.overlays.length = 0;
    };

    /**
     * 鼠标绘制完成后，派发总事件的接口
     * @name DrawingManager#overlaycomplete
     * @event
     * @param {Event Object} e 回调函数会返回event参数，包括以下返回值：
     * <br />{"<b>drawingMode</b> : {DrawingType} 当前的绘制模式
     * <br />"<b>overlay</b>：{Marker||Polyline||Polygon||Circle} 对应的绘制模式返回对应的覆盖物
     * <br />"<b>calculate</b>：{Number} 需要开启计算模式才会返回这个值，当绘制线的时候返回距离、绘制多边形、圆、矩形时候返回面积，单位为米，
     * <br />"<b>label</b>：{Label} 计算面积时候出现在Map上的Label对象
     *
     * @example <b>参考示例：</b>
     * myDrawingManagerObject.addEventListener("overlaycomplete", function(e) {
     *     alert(e.drawingMode);
     *     alert(e.overlay);
     *     alert(e.calculate);
     *     alert(e.label);
     * });
     */

    /**
     * 绘制点完成后，派发的事件接口
     * @name DrawingManager#markercomplete
     * @event
     * @param {Marker} overlay 回调函数会返回相应的覆盖物，
     * <br />{"<b>overlay</b> : {Marker}
     *
     * @example <b>参考示例：</b>
     * myDrawingManagerObject.addEventListener("circlecomplete", function(e, overlay) {
     *     alert(overlay);
     * });
     */

    /**
     * 绘制圆完成后，派发的事件接口
     * @name DrawingManager#circlecomplete
     * @event
     * @param {Circle} overlay 回调函数会返回相应的覆盖物，
     * <br />{"<b>overlay</b> : {Circle}
     */

    /**
     * 绘制线完成后，派发的事件接口
     * @name DrawingManager#polylinecomplete
     * @event
     * @param {Polyline} overlay 回调函数会返回相应的覆盖物，
     * <br />{"<b>overlay</b> : {Polyline}
     */

    /**
     * 绘制多边形完成后，派发的事件接口
     * @name DrawingManager#polygoncomplete
     * @event
     * @param {Polygon} overlay 回调函数会返回相应的覆盖物，
     * <br />{"<b>overlay</b> : {Polygon}
     */

    /**
     * 绘制矩形完成后，派发的事件接口
     * @name DrawingManager#rectanglecomplete
     * @event
     * @param {Polygon} overlay 回调函数会返回相应的覆盖物，
     * <br />{"<b>overlay</b> : {Polygon}
     */

    /**
     * 初始化状态
     * @param {Map} 地图实例
     * @param {Object} 参数
     */
    DrawingManager.prototype._initialize = function (map, opts) {

        /**
         * map对象
         * @private
         * @type {Map}
         */
        this._map = map;

        /**
         * 配置对象
         * @private
         * @type {Object}
         */
        this._opts = opts;

        /**
         * 当前的绘制模式, 默认是绘制点
         * @private
         * @type {DrawingType}
         */
        this._drawingType = opts.drawingMode || BMAP_DRAWING_MARKER;

        /**
         * 是否添加添加鼠标绘制工具栏面板
         */
        if (opts.enableDrawingTool) {
            this.enableDrawingTool();
        }

        if (opts.sorptionDistance !== undefined) {
            this.setSorptionDistance(opts.sorptionDistance);
        }
        if (opts.enableDrawingTool) {
            var drawingTool = new DrawingTool(this, opts.drawingToolOptions);
            this._drawingTool = drawingTool;
            map.addControl(drawingTool);
        }

        // 是否计算绘制出的面积
        if (opts.enableCalculate === true) {
            this.enableCalculate();
        } else {
            this.disableCalculate();
        }

        // 是否开启超限提示
        if (opts.enableLimit === true) {
            var limit = opts.limitOptions;
            this.limit = limit;
        }

        // 是否显示确认操作面板，默认关闭
        this._opts.confirmVisible = opts.confirmVisible === true;

        // 是否开启吸附功能
        if (opts.enableSorption === true) {
            this.enableSorption();
        } else {
            this.disableSorption();
        }

        // 是否开启gpc功能
        if (opts.enableGpc === true) {
            this.enableGpc();
        } else {
            this.disableGpc();
        }

        /**
         * 是否已经开启了绘制状态
         * @private
         * @type {Boolean}
         */
        this._isOpen = !!(opts.isOpen === true);
        if (this._isOpen) {
            this._open();
        }

        this.setPolygonOptions(opts.polygonOptions);
        this.setMarkerOptions(opts.markerOptions);
        this.setCircleOptions(opts.circleOptions);
        this.setPolylineOptions(opts.polylineOptions);
        this.setRectangleOptions(opts.rectangleOptions);
        this.setLabelOptions(opts.labelOptions);
        this.controlButton = opts.controlButton == 'right' ? 'right' : 'left';

    };

    DrawingManager.prototype.enableDrawingTool = function() {
        var opts = this._opts;
        if (!this._drawingTool) {
            var drawingTool  = new DrawingTool(this, opts.drawingToolOptions);
            this._drawingTool = drawingTool;
        }
        this._map.addControl(this._drawingTool);
    };

    DrawingManager.prototype.disableDrawingTool = function() {
        if (this._drawingTool) {
            this._map.removeControl(this._drawingTool);
        }
    };

    DrawingManager.prototype.setSorptionDistance = function(distance) {
        this._sorptionDistance = distance || 0;
    };

    DrawingManager.prototype.setPolygonOptions = function(options) {
        this.polygonOptions = options || {};
    };

    DrawingManager.prototype.setMarkerOptions = function(options) {
        this.markerOptions = options || {};
    };

    DrawingManager.prototype.setCircleOptions = function(options) {
        this.circleOptions = options || {};
    };

    DrawingManager.prototype.setPolylineOptions = function(options) {
        this.polylineOptions = options || {};
    };

    DrawingManager.prototype.setRectangleOptions = function(options) {
        this.rectangleOptions = options || {};
    };

    DrawingManager.prototype.setLabelOptions = function(options) {
        this.labelOptions = options || {};
    };

    /**
     * 开启地图的绘制状态
     * @return {Boolean}，开启绘制状态成功，返回true；否则返回false。
     */
    DrawingManager.prototype._open = function () {

        this._isOpen = true;

        // 添加遮罩，所有鼠标操作都在这个遮罩上完成
        if (!this._mask) {
            this._mask = new Mask();
        }

        this._map.addOverlay(this._mask);
        this._setDrawingMode(this._drawingType);

    };

    /**
     * 设置当前的绘制模式
     * @param {DrawingType}
     */
    DrawingManager.prototype._setDrawingMode = function (drawingType) {

        this._drawingType = drawingType;

        /**
         * 开启编辑状态时候才重新进行事件绑定
         */
        if (this._isOpen) {

            // 清空之前的自定义事件
            this._mask.__listeners = {};

            switch (drawingType) {
                case BMAP_DRAWING_MARKER:
                    this._bindMarker();
                    break;
                case BMAP_DRAWING_CIRCLE:
                    this._bindCircle();
                    break;
                case BMAP_DRAWING_POLYLINE:
                case BMAP_DRAWING_POLYGON:
                    this._bindPolylineOrPolygon();
                    break;
                case BMAP_DRAWING_RECTANGLE:
                    this._bindRectangle();
                    break;
            }
        }

        /**
         * 如果添加了工具栏，则也需要改变工具栏的样式
         */
        if (this._drawingTool && this._isOpen) {
            this._drawingTool.setStyleByDrawingMode(drawingType);
        }

    };

    /**
     * 关闭地图的绘制状态
     * @return {Boolean}，关闭绘制状态成功，返回true；否则返回false。
     */
    DrawingManager.prototype._close = function () {

        this._isOpen = false;

        if (this._mask) {
            this._map.removeOverlay(this._mask);
        }

        /**
         * 如果添加了工具栏，则关闭时候将工具栏样式设置为拖拽地图
         */
        if (this._drawingTool) {
            this._drawingTool.setStyleByDrawingMode('hander');
        }

    };

    /**
     * 绑定鼠标画点的事件
     */
    DrawingManager.prototype._bindMarker = function () {

        var me = this,
            map = this._map,
            mask = this._mask;

        /**
         * 鼠标点击的事件
         */
        var clickAction = function (e) {
            // 往地图上添加marker
            var marker = new BMap.Marker(e.point, me.markerOptions);
            map.addOverlay(marker);
            me._dispatchOverlayComplete(marker);
        };

        mask.addEventListener('click', clickAction);
    };

    /**
     * 绑定鼠标画圆的事件
     */
    var tip_label = null;
    DrawingManager.prototype._bindCircle = function () {

        var me = this,
            map = this._map,
            mask = this._mask,
            circle = null,
            overlays = [],
            centerPoint = null; // 圆的中心点

        var radius = null;
        var moveMarker = null;
        var polyline = null;
        var radiusWindow = null;
        var operateWindow = null;

        var lineStyel = {
            strokeColor: '#4E6DF1', // 边线颜色。
            strokeWeight: 2 // 边线的宽度，以像素为单位。
        };

        var centerIcon = new BMap.Icon(_scriptPath + 'circenter.png', new BMap.Size(20, 20));
        var shadow = new BMap.Icon('//huiyan.baidu.com/cms/images/DrawingManager/maker-shadow.png', new BMap.Size(21, 33));

        /**
         * 开始绘制圆形
         */

        var startAction = function (e) {
            if (me.controlButton == 'right' && (e.button == 1 || e.button == 0)) {
                return;
            }

            centerPoint = e.point;

            var centerMarker = new BMap.Marker(centerPoint);
            centerIcon.setImageSize(new BMap.Size(20, 20));
            centerMarker.setIcon(centerIcon);
            centerMarker.setShadow(shadow);
            centerMarker.enableDragging();
            centerMarker.addEventListener('dragstart', centerDragstart);
            centerMarker.addEventListener('dragging', centerDragging);
            centerMarker.addEventListener('dragend', centerDragend);
            map.addOverlay(centerMarker);

            overlays.push(centerMarker);

            circle = new BMap.Circle(centerPoint, 0.01, me.circleOptions);
            map.addOverlay(circle);
            mask.enableEdgeMove();
            mask.addEventListener('mousemove', moveAction);
            baidu.on(document, 'mouseup', endAction);
        };

        /**
         * 绘制圆形过程中，鼠标移动过程的事件
         */
        var moveAction = function (e) {
            radius = me._map.getDistance(centerPoint, e.point).toFixed(0);
            circle.setRadius(me._map.getDistance(centerPoint, e.point));

            map.removeOverlay(tip_label);

            tip_label = new BMap.Label('半径：' + radius + '米<br>松开完成绘制', {
                position: e.point, // 指定文本标注所在的地理位置
                offset: new BMap.Size(10, 10) // 设置文本偏移量
            });
            tip_label.setStyle(me.labelOptions);
            map.addOverlay(tip_label);
        };

        /**
         * 绘制圆形结束
         */
        var endAction = function (e) {
            var cz = map.getViewport(circle.getBounds());
            cz.zoom -= 1;
            map.setViewport(cz);
            map.removeOverlay(tip_label);

            mask.disableEdgeMove();
            mask.removeEventListener('mousemove', moveAction);
            baidu.un(document, 'mouseup', endAction);

            if (!me._opts.confirmVisible) {
                // 移除编辑相关的覆盖物（中心点marker等）
                for (var i = 0; i < overlays.length; i++) {
                    map.removeOverlay(overlays[i]);
                }
                var calculate = me._calculate(circle, centerPoint);
                me._dispatchOverlayComplete(circle, calculate);
                me.close();
                return;
            }

            var endPoint = new BMap.Point(circle.getBounds().getNorthEast().lng, centerPoint.lat);
            mask.hide();

            moveMarker = new BMap.Marker(endPoint);
            var moveIcon = new BMap.Icon(_scriptPath + 'nbsearch.png', new BMap.Size(40, 20));
            moveIcon.setImageSize(new BMap.Size(40, 40));
            moveIcon.setImageOffset(new BMap.Size(0, -10));
            moveMarker.setIcon(moveIcon);
            moveMarker.setShadow(shadow);
            moveMarker.enableDragging();

            polyline = new BMap.Polyline([centerPoint, endPoint], lineStyel);

            var midPoint = new BMap.Point((circle.getBounds().getNorthEast().lng + centerPoint.lng) / 2, centerPoint.lat);
            radiusWindow = new Screenshot('circle', midPoint, radius, circle, me);
            
            overlays = overlays.concat([moveMarker, polyline, radiusWindow]);
            var limit = null;
            if (me.limit) {
                limit = me.limit.area;
            }

            var targetOverlay = {
                limit: limit,
                type: 'circle',
                point: endPoint,
                overlay: circle,
                overlays: overlays
            };
            operateWindow = new Operate(targetOverlay, me);

            map.addOverlay(moveMarker);
            map.addOverlay(polyline);
            map.addOverlay(radiusWindow);
            if (me._opts.confirmVisible) {
                map.addOverlay(operateWindow);
            }

            radiusWindow.addEventListener('radiuschange', function (e) {
                var radius = e.radius;
                circle.setRadius(radius);
                var ePoint = getPointByDistance(centerPoint, radius, 'east');
                var dragLeftPoint = new BMap.Point(ePoint.lng, centerPoint.lat);
                var halflng = ePoint.lng > centerPoint.lng ? (circle.getBounds().getNorthEast().lng + centerPoint.lng) / 2 : (circle.getBounds().getSouthWest().lng + centerPoint.lng) / 2;
                var halfLeftPoint = new BMap.Point(halflng, centerPoint.lat);
                moveMarker.setPosition(dragLeftPoint);
                radiusWindow.setInfo(halfLeftPoint, radius);
                if (me._opts.confirmVisible) {
                    operateWindow.setPosition(dragLeftPoint, true);
                    operateWindow.updateWindow();
                }
                polyline.setPath([centerPoint, dragLeftPoint]);

                var cz = map.getViewport(circle.getBounds());
                cz.zoom -= 1;
                map.setViewport(cz);
            });

            moveMarker.addEventListener('dragging', function (e) {
                var dragLeftPoint = new BMap.Point(e.point.lng, centerPoint.lat);
                var halflng = e.point.lng > centerPoint.lng ? (circle.getBounds().getNorthEast().lng + centerPoint.lng) / 2 : (circle.getBounds().getSouthWest().lng + centerPoint.lng) / 2;
                var isright = e.point.lng > centerPoint.lng ? true : false;
                var halfLeftPoint = new BMap.Point(halflng, centerPoint.lat);

                e.target.setPosition(dragLeftPoint);
                radiusWindow.setInfo(halfLeftPoint, me._map.getDistance(centerPoint, e.point).toFixed(0));
                if (me._opts.confirmVisible) {
                    operateWindow.setPosition(dragLeftPoint, isright);
                }
                polyline.setPath([centerPoint, dragLeftPoint]);
                radius = me._map.getDistance(centerPoint, e.point).toFixed(0);
                circle.setRadius(me._map.getDistance(centerPoint, e.point));
            });

            moveMarker.addEventListener('dragend', function (e) {
                if (me._opts.confirmVisible) {
                    operateWindow.updateWindow();
                }
                var cz = map.getViewport(circle.getBounds());
                cz.zoom -= 1;
                map.setViewport(cz);
            });

            mask.disableEdgeMove();
            mask.removeEventListener('mousemove', moveAction);
            mask.removeEventListener('mousemove', mousedownAction);
            baidu.un(document, 'mouseup', endAction);
        };

        /**
         * 鼠标点击起始点
         */
        var mousedownAction = function (e) {
            baidu.preventDefault(e);
            baidu.stopBubble(e);

            if (me.controlButton == 'right' && e.button == 1) {
                return;
            }

            if (centerPoint == null) {
                startAction(e);
            }

        };

        /**
         * 非绘制圆形过程中，鼠标移动过程的事件
         */
        var mousemoveAction = function (e) {
            baidu.preventDefault(e);
            baidu.stopBubble(e);

            map.removeOverlay(tip_label);

            tip_label = new BMap.Label('按下确认中心点，拖拽确认半径', {
                position: e.point, // 指定文本标注所在的地理位置
                offset: new BMap.Size(10, 10) // 设置文本偏移量
            });
            tip_label.setStyle(me.labelOptions);
            map.addOverlay(tip_label);

        };

        var centerDragstart = function (e) {
            map.removeOverlay(moveMarker);
            map.removeOverlay(polyline);
            map.removeOverlay(radiusWindow);
            if (me._opts.confirmVisible) {
                map.removeOverlay(operateWindow);
            }
        };
        var centerDragging = function (e) {

            centerPoint = e.point;
            circle.setCenter(e.point);
        };
        var centerDragend = function (e) {
            centerPoint = e.point;
            endAction(e);
        };


        mask.addEventListener('mousedown', mousedownAction);
        mask.addEventListener('mousemove', mousemoveAction);
    };

    /**
     * 画线和画多边形相似性比较大，公用一个方法
     */
    DrawingManager.prototype._bindPolylineOrPolygon = function () {

        var me = this,
            map = this._map,
            mask = this._mask,
            points = [], // 用户绘制的点
            drawPoint = null, // 实际需要画在地图上的点
            overlay = null,
            match = null,
            isBinded = false;

        function getNorthEast() {
            var bound = arguments[0];
            var maxlng = 0;
            var index = 0;
            for (var j = 0; j < bound.length; j++) {
                if (maxlng < bound[j].lng) {
                    maxlng = bound[j].lng;
                    index = j;
                }
            }
            return bound[index];
        }

        /**
         * 鼠标点击的事件
         */
        var startAction = function (e) {
            if (me.controlButton == 'right' && (e.button == 1 || e.button == 0)) {
                return;
            }

            var point = e.point;
            if (match) {
                point = match;
            }
            points.push(point);
            drawPoint = points.concat(points[points.length - 1]);
            if (points.length == 1) {
                if (me._drawingType == BMAP_DRAWING_POLYLINE) {

                    overlay = new BMap.Polyline(drawPoint, me.polylineOptions);
                } else if (me._drawingType == BMAP_DRAWING_POLYGON) {
                    overlay = new BMap.Polygon(drawPoint, me.polygonOptions);
                }

                map.addOverlay(overlay);
            } else {
                overlay.setPath(drawPoint);
            }
            if (!isBinded) {
                isBinded = true;
                mask.enableEdgeMove();
                mask.removeEventListener('mousemove', mousemoveAction);
                mask.addEventListener('mousemove', moveAction);
                mask.addEventListener('dblclick', dblclickAction);
            }

        };

        /**
         * 鼠标移动过程的事件
         */
        var moveAction = function (e) {
            var point = e.point;
            if (me._enableSorption) {
                var matchs = me.getSorptionMatch(point, me.overlays, me._sorptionDistance);
                if (matchs && matchs.length > 0) {
                    match = matchs[0].point;
                    overlay.setPositionAt(drawPoint.length - 1, matchs[0].point);
                    return;
                }
            }
            match = null;

            overlay.setPositionAt(drawPoint.length - 1, e.point);

            map.removeOverlay(tip_label);

            tip_label = new BMap.Label('单击绘制下一个点，双击完成绘制', {
                position: e.point, // 指定文本标注所在的地理位置
                offset: new BMap.Size(10, 10) // 设置文本偏移量
            });
            tip_label.setStyle(me.labelOptions);
            map.addOverlay(tip_label);
        };

        /**
         * 鼠标双击的事件
         */
        var dblclickAction = function (e) {
            baidu.stopBubble(e);
            isBinded = false;
            map.removeOverlay(tip_label);
            mask.disableEdgeMove();
            mask.removeEventListener('mousedown',startAction);
            mask.removeEventListener('mousemove', moveAction);
            mask.removeEventListener('mousemove', mousemoveAction);
            mask.removeEventListener('dblclick', dblclickAction);
            if (me.controlButton == 'right') {
                points.push(e.point);
            } else if (baidu.ie <= 8) {
                
            } else {
                points.pop();
            }

            // 裁剪
            try {
                if (me._enableGpc && window.gpcas) {
                    var res = new gpcas.geometry.PolyDefault();
                    for (var i = 0; i < points.length; i++) {
                        res.addPoint(new gpcas.Point(points[i].lng, points[i].lat));
                    }
                    for (var j = 0; j < me.overlays.length; j++) {
                        var path = me.overlays[j].getPath();
                        var target = new gpcas.geometry.PolyDefault();
                        for (var i = 0; i < path.length; i++) {
                            target.addPoint(new gpcas.Point(path[i].lng, path[i].lat));
                        }
                        var diff = res.difference(target);
                        var newPoints = diff.getPoints();
                        var outPoints = [];
                        for (var i = 0; i < newPoints.length; i++) {
                            outPoints.push(new BMap.Point(newPoints[i].x, newPoints[i].y));
                        }
                        res = new gpcas.geometry.PolyDefault();
                        for (var i = 0; i < newPoints.length; i++) {
                            res.addPoint(new gpcas.Point(newPoints[i].x, newPoints[i].y));
                        }
                        points = outPoints;
                    }
                }
            } catch(e) {
            }

            overlay.setPath(points);
            var cz = map.getViewport(points);
            cz.zoom -= 1;
            map.setViewport(cz);

            var mar = new BMap.Marker(e.point);

            if (me._opts.confirmVisible) {
                overlay.enableEditing();
                var limit = null;
                if (me.limit) {
                    limit = me.limit.area;
                }

                var targetOverlay = {
                    limit: limit,
                    type: 'polygon',
                    point: getNorthEast(points),
                    overlay: overlay,
                    overlays: []
                };

                var operateWindow = new Operate(targetOverlay, me);
                map.addOverlay(operateWindow);

                overlay.addEventListener('lineupdate', function (e) {
                    var point = getNorthEast(e.currentTarget.getPath());
                    operateWindow.setPosition(point, true);
                    operateWindow.updateWindow();
                });
            } else {
                var calculate = me._calculate(overlay, overlay.getPath());
                me._dispatchOverlayComplete(overlay, calculate);
            }

            points.length = 0;
            drawPoint.length = 0;
            me.close();

        };

        /**
         * 非绘制多边形过程中，鼠标移动过程的事件
         */
        var mousemoveAction = function (e) {
            baidu.preventDefault(e);
            baidu.stopBubble(e);

            map.removeOverlay(tip_label);

            tip_label = new BMap.Label('单击确认起点', {
                position: e.point, // 指定文本标注所在的地理位置
                offset: new BMap.Size(10, 10) // 设置文本偏移量
            });
            tip_label.setStyle(me.labelOptions);
            map.addOverlay(tip_label);
        };

        mask.addEventListener('mousemove', mousemoveAction);

        // mask.addEventListener('mouseup', startAction);
        mask.addEventListener('mousedown', startAction);

        // 双击时候不放大地图级别
        mask.addEventListener('dblclick', function (e) {

            baidu.stopBubble(e);
        });
    };

    /**
     * 绑定鼠标画矩形的事件
     */

    DrawingManager.prototype._bindRectangle = function () {

        var me = this,
            map = this._map,
            mask = this._mask,
            polygon = null,
            startPoint = null,
            lastPoint = null; // 绘制过程中，鼠标拖动到地图之外，endAction会丢失坐标，需要移动时记录下来。

        // 获取4个顶点和4条边中点的坐标
        function getRectAllPoints(pointA, pointB) {
            var pointLT = new BMap.Point(pointA.lng, pointA.lat); // 左上角
            var pointRT = new BMap.Point(pointB.lng, pointA.lat); // 右上角
            var pointRB = new BMap.Point(pointB.lng, pointB.lat); // 右下角
            var pointLB = new BMap.Point(pointA.lng, pointB.lat); // 左上角

            var pointTC = new BMap.Point((pointA.lng + pointB.lng) / 2, pointA.lat);
            var pointRC = new BMap.Point(pointB.lng, (pointA.lat + pointB.lat) / 2);
            var pointBC = new BMap.Point((pointA.lng + pointB.lng) / 2, pointB.lat);
            var pointLC = new BMap.Point(pointA.lng, (pointA.lat + pointB.lat) / 2);

            return [pointLT, pointTC, pointRT, pointRC, pointRB, pointBC, pointLB, pointLC];
        }
        // 对象深拷贝
        function copy(o) {
            var output,
                v,
                key;
            output = Array.isArray(o) ? [] : {};
            for (key in o) {
                v = o[key];
                output[key] = (typeof v === 'object') ? copy(v) : v;
            }
            return output;
        }

        var moveIcon = new BMap.Icon(_scriptPath + 'bullet.png', new BMap.Size(10, 10));
        var shadow = new BMap.Icon('//huiyan.baidu.com/cms/images/DrawingManager/maker-shadow.png', new BMap.Size(20, 20));
        moveIcon.setImageSize(new BMap.Size(10, 10));

        /**
         * 开始绘制矩形
         */
        var startAction = function (e) {

            baidu.stopBubble(e);
            baidu.preventDefault(e);
            if (me.controlButton == 'right' && (e.button == 1 || e.button == 0)) {
                return;
            }

            startPoint = e.point;

            var endPoint = startPoint;
            polygon = new BMap.Polygon(me._getRectanglePoint(startPoint, endPoint), me.rectangleOptions);
            map.addOverlay(polygon);
            mask.enableEdgeMove();
            mask.addEventListener('mousemove', moveAction);
            baidu.on(document, 'mouseup', endAction);
        };

        /**
         * 绘制矩形过程中，鼠标移动过程的事件
         */
        var moveAction = function (e) {
            map.removeOverlay(tip_label);
            polygon.setPath(me._getRectanglePoint(startPoint, e.point));

            var points = getRectAllPoints(startPoint, e.point);
            var width = me._map.getDistance(startPoint, points[2]).toFixed(0);
            var height = me._map.getDistance(startPoint, points[6]).toFixed(0);
            tip_label = new BMap.Label('尺寸：' + width + '米 x ' + height + '米<br>松开结束绘制', {
                position: e.point, // 指定文本标注所在的地理位置
                offset: new BMap.Size(10, 10) // 设置文本偏移量
            });
            tip_label.setStyle(me.labelOptions);
            map.addOverlay(tip_label);
        };

        /**
         * 绘制矩形结束
         */
        var endAction = function (e) {
            mask.hide();
            var points = getRectAllPoints(startPoint, e.point || lastPoint);
            var cz = map.getViewport(points);
            cz.zoom -= 1;
            map.setViewport(cz);
            map.removeOverlay(tip_label);

            mask.disableEdgeMove();
            mask.removeEventListener('mousemove', moveAction);
            mask.removeEventListener('mousemove', mousemoveAction);
            baidu.un(document, 'mouseup', endAction);

            if (!me._opts.confirmVisible) {
                var calculate = me._calculate(polygon, polygon.getPath());
                me._dispatchOverlayComplete(polygon, calculate);
                me.close();
                return;
            }

            var endPoint = null;
            var markers = [];
            var pointsTmp = copy(points);

            var width = me._map.getDistance(startPoint, points[2]).toFixed(0);
            var height = me._map.getDistance(startPoint, points[6]).toFixed(0);
            var rectInfo = new Screenshot('rectangle', points[0], {
                width: width,
                height: height
            }, polygon, me);

            for (var i = 0; i < points.length; i++) {
                var marker = new BMap.Marker(points[i]);
                marker.point = points[i];
                marker.enableDragging();
                marker.setIcon(moveIcon);
                marker.setShadow(shadow);
                markers.push(marker);
                map.addOverlay(marker);

                marker.addEventListener('mousedown', function (e) {
                    endPoint = e.target.point;
                });
                marker.addEventListener('dragging', function (e) {
                    var point = e.point;
                    for (var i = 0; i < pointsTmp.length; i++) {
                        if (endPoint.lng == pointsTmp[i].lng) {
                            points[i].lng = point.lng;
                        }

                        if (endPoint.lat == pointsTmp[i].lat) {
                            points[i].lat = point.lat;
                        }

                    }
                    points = getRectAllPoints(points[0], points[4]);
                    for (var j = 0; j < markers.length; j++) {
                        markers[j].setPosition(points[j]);
                    }
                    width = me._map.getDistance(points[0], points[2]).toFixed(0);
                    height = me._map.getDistance(points[0], points[6]).toFixed(0);
                    rectInfo.setInfo(points[0], {
                        width: width,
                        height: height
                    });
                    if (me._opts.confirmVisible) {
                        operateWindow.setPosition(points[3], true);
                    }
                    polygon.setPath(points);
                });
                marker.addEventListener('dragend', function (e) {
                    pointsTmp = copy(points);
                    if (me._opts.confirmVisible) {
                        operateWindow.updateWindow();
                    }
                    var cz = map.getViewport(points);
                    cz.zoom -= 1;
                    map.setViewport(cz);
                });
            }

            rectInfo.addEventListener('rectwhchange', function (e) {
                var width = e.width;
                var height = e.height;
                var pointx = getPointByDistance(points[0], width, 'east');
                var pointy = getPointByDistance(points[0], height, 'south');
                points[4].lng = pointx.lng;
                points[4].lat = pointy.lat;
                points = getRectAllPoints(points[0], points[4]);
                for (var j = 0; j < markers.length; j++) {
                    markers[j].setPosition(points[j]);
                }
                rectInfo.setInfo(points[0], {
                    width: width,
                    height: height
                });
                if (me._opts.confirmVisible) {
                    operateWindow.setPosition(points[3], true);
                }
                polygon.setPath(points);
                pointsTmp = copy(points);
                if (me._opts.confirmVisible) {
                    operateWindow.updateWindow();
                }

                var cz = map.getViewport(points);
                cz.zoom -= 1;
                map.setViewport(cz);
            });

            var overlays = [markers, rectInfo];
            var limit = null;
            if (me.limit) {
                limit = me.limit.area;
            }

            var overlay = {
                limit: limit,
                type: 'rectangle',
                point: points[3],
                overlay: polygon,
                overlays: overlays
            };

            if (me._opts.confirmVisible) {
                var operateWindow = new Operate(overlay, me);
                map.addOverlay(operateWindow);
                map.addOverlay(rectInfo);
            } else {
                // 清除编辑点markers
                for (var k = 0; k < markers.length; k++) {
                    map.removeOverlay(markers[k]);
                }
                var calculate = me._calculate(polygon, polygon.getPath());
                me._dispatchOverlayComplete(polygon, calculate);
            }
        };

        /**
         * 非绘制矩形过程中，鼠标移动过程的事件
         */
        var mousemoveAction = function (e) {
            baidu.preventDefault(e);
            baidu.stopBubble(e);
            lastPoint = e.point;

            map.removeOverlay(tip_label);

            tip_label = new BMap.Label('按住确认起点，拖拽进行绘制', {
                position: e.point, // 指定文本标注所在的地理位置
                offset: new BMap.Size(10, 10) // 设置文本偏移量
            });
            tip_label.setStyle(me.labelOptions);
            map.addOverlay(tip_label);
        };

        mask.addEventListener('mousedown', startAction);
        mask.addEventListener('mousemove', mousemoveAction);
    };

    /**
     * 添加显示所绘制图形的面积或者长度
     * @param {overlay} 覆盖物
     * @param {point} 显示的位置
     */
    DrawingManager.prototype._calculate = function (overlay, point) {
        var result = {
            data: 0, // 计算出来的长度或面积
            label: null // 显示长度或面积的label对象
        };
        if (this._enableCalculate && BMapLib.GeoUtils) {
            var type = overlay.toString();
            // 不同覆盖物调用不同的计算方法
            switch (type) {
                case '[object Polyline]':
                    result.data = BMapLib.GeoUtils.getPolylineDistance(overlay);
                    break;
                case '[object Polygon]':
                    result.data = BMapLib.GeoUtils.getPolygonArea(overlay);
                    break;
                case '[object Circle]':
                    var radius = overlay.getRadius();
                    result.data = Math.PI * radius * radius;
                    break;
            }
            // 异常情况处理
            if (!result.data || result.data < 0) {
                result.data = 0;
            } else {
                // 保留2位小数位
                result.data = result.data.toFixed(2);
            }

            /**
             * 这里我们只需要开启计算面积功能，但并不需要在地图上添加显示面积的label，所以注释掉
             */
            // result.label = this._addLabel(point, result.data);
        }

        return result;
    };

    /**
     * 开启测距和测面功能需要依赖于GeoUtils库
     * 所以这里判断用户是否已经加载,若未加载则用js动态加载
     */
    DrawingManager.prototype._addGeoUtilsLibrary = function () {
        if (!BMapLib.GeoUtils) {
            var script = document.createElement('script');
            script.setAttribute('type', 'text/javascript');
            script.setAttribute('src', '//huiyan.baidu.com/github/BMap-JavaScript-library/src/GeoUtils/GeoUtils.min.js');
            document.body.appendChild(script);
        }

    };

    /**
     * 向地图中添加文本标注
     * @param {Point}
     * @param {String} 所以显示的内容
     */
    DrawingManager.prototype._addLabel = function (point, content) {
        var label = new BMap.Label(content, {
            position: point
        });
        this._map.addOverlay(label);
        return label;
    };

    /**
     * 根据起终点获取矩形的四个顶点
     * @param {Point} 起点
     * @param {Point} 终点
     */
    DrawingManager.prototype._getRectanglePoint = function (startPoint, endPoint) {
        return [
            new BMap.Point(startPoint.lng, startPoint.lat),
            new BMap.Point(endPoint.lng, startPoint.lat),
            new BMap.Point(endPoint.lng, endPoint.lat),
            new BMap.Point(startPoint.lng, endPoint.lat)
        ];
    };

    /**
     * 派发事件
     */
    DrawingManager.prototype._dispatchOverlayComplete = function (overlay, calculate) {
        var options = {
            overlay: overlay,
            drawingMode: this._drawingType
        };
        if (calculate) {
            options.calculate = calculate.data || null;
            options.label = calculate.label || null;
        }

        this.dispatchEvent(this._drawingType + 'complete', overlay);
        this.dispatchEvent('overlaycomplete', options);
    };

    // 判断吸附算法
    DrawingManager.prototype.getSorptionMatch = function (point, polygons, distance) {
        distance = distance || 20;
        var map = this._map;
        var P = map.pointToPixel(point); // point.pixel;
        var match = [];
        for (var j = 0; j < polygons.length; j++) {
            var pixels = polygons[j].getPath();
            var first = pixels[0];
            var last = pixels[pixels.length - 1];
            if (!first.equals(last)) {
                pixels.push(pixels[0]);
            }
            for (var i = 1; i < pixels.length; i++) {
                var A = map.pointToPixel(pixels[i - 1]);
                var B = map.pointToPixel(pixels[i]);
                var vAP = [P.x - A.x, P.y - A.y];
                var vAB = [B.x - A.x, B.y - A.y];
                var vPB = [B.x - P.x, B.y - P.y];
                var cAPAB = vAP[0] * vAB[0] + vAP[1] * vAB[1];
                var lAPAB = Math.sqrt(Math.pow(vAP[0], 2) + Math.pow(vAP[1], 2)) * Math.sqrt(Math.pow(vAB[0], 2) + Math.pow(vAB[1], 2));
                var rPAB = Math.acos(cAPAB / lAPAB);
                var cABPB = vAB[0] * vPB[0] + vAB[1] * vPB[1];
                var lABPB = Math.sqrt(Math.pow(vAB[0], 2) + Math.pow(vAB[1], 2)) * Math.sqrt(Math.pow(vPB[0], 2) + Math.pow(vPB[1], 2));
                var rPBA = Math.acos(cABPB / lABPB);
                if (rPAB < Math.PI / 2 && rPBA < Math.PI / 2) {
                    var lAP = Math.sqrt(Math.pow(vAP[0], 2) + Math.pow(vAP[1], 2));
                    var lAB = Math.sqrt(Math.pow(vAB[0], 2) + Math.pow(vAB[1], 2));
                    var lAO = Math.cos(rPAB) * lAP;
                    var pAOAB = lAO / lAB;
                    var lPO = Math.sin(rPAB) * lAP;
                    var O = [A.x + vAB[0] * pAOAB, A.y + vAB[1] * pAOAB];
                    if (lPO < distance) {
                        match.push({
                            point: map.pixelToPoint({
                                x: O[0],
                                y: O[1]
                            }),
                            length: lPO
                        });
                    }
                }
            }
        }
        match.sort(function (a, b) {
            return a.length - b.length;
        });
        var ret = match.length > 0 ? match : null;
        return ret;
    }

    // 确认,取消操作覆盖物
    function Operate(data, DrawingManager) {
        this.limit = data.limit;
        this.type = data.type;
        this.point = data.point;
        this.overlay = data.overlay;
        this.overlays = data.overlays;
        this.DrawingManager = DrawingManager;
    }

    Operate.prototype = new BMap.Overlay();
    Operate.prototype.dispatchEvent = baidu.lang.Class.prototype.dispatchEvent;
    Operate.prototype.addEventListener = baidu.lang.Class.prototype.addEventListener;
    Operate.prototype.removeEventListener = baidu.lang.Class.prototype.removeEventListener;

    Operate.prototype.initialize = function (map) {
        var me = this;
        this._map = map;
        var div = this.div = document.createElement('div');
        div.className = 'operateWindow';
        var html = '<div><span id="confirmOperate"></span><span id="cancelOperate"></span><span id="warnOperate">面积不超过' + this.limit / 10000 + '万平方米！</span></div>';
        div.innerHTML = html;
        this._map.addEventListener('resize', function (e) {
            me._adjustSize(e.size);
        });
        this._map.getPanes().markerPane.appendChild(div);
        this.updateWindow();
        this._bind();
        return div;
    };

    Operate.prototype._bind = function () {
        var that = this;
        var map = this._map;
        var overlay = this.overlay;
        var overlays = this.overlays;
        document.getElementById('confirmOperate').addEventListener('click', function (e) {
            map.removeOverlay(that);

            if (that.type == 'rectangle') {
                var calculate = that.DrawingManager._calculate(overlay, overlay.getPath());
            }
            else if (that.type == 'circle') {
                var calculate = that.DrawingManager._calculate(overlay, that.point);
            }
            else if (that.type == 'polygon') {
                var calculate = that.DrawingManager._calculate(overlay, (overlay.getPath()));
                that.DrawingManager.overlays.push(overlay);
                overlay.disableEditing();
            }

            that.DrawingManager._dispatchOverlayComplete(overlay, calculate);

            for (var i = 0; i < overlays.length; i++) {
                if (Array.isArray(overlays[i])) {
                    for (var k in overlays[i]) {
                        map.removeOverlay(overlays[i][k]);
                    }
                } else {
                    map.removeOverlay(overlays[i]);
                }
            }
            that.DrawingManager.close();
        });
        document.getElementById('cancelOperate').addEventListener('click', function (e) {
            map.removeOverlay(that);
            for (var i = 0; i < overlays.length; i++) {
                if (Array.isArray(overlays[i])) {
                    for (var k in overlays[i]) {
                        map.removeOverlay(overlays[i][k]);
                    }
                } else {
                    map.removeOverlay(overlays[i]);
                }
            }
            map.removeOverlay(overlay);
            that.DrawingManager._mask.show();
            that.DrawingManager._setDrawingMode(that.type);
        });
    };

    Operate.prototype.updateWindow = function () {
        if (this.domElement === null) {
            return;
        }
        var overlay = this.overlay;
        var overlays = this.overlays;
        var limit = this.limit;
        var calculate;
        if (this.type == 'rectangle') {
            calculate = this.DrawingManager._calculate(overlay, overlay.getPath());
        }
        else if (this.type == 'circle') {
            calculate = this.DrawingManager._calculate(overlay, this.point);
        }
        else if (this.type == 'polygon') {
            calculate = this.DrawingManager._calculate(overlay, (overlay.getPath()));
        }

        var confirmEl = document.getElementById('confirmOperate');
        var warnEl = document.getElementById('warnOperate');
        if (!confirmEl || !warnEl) {
            return;
        }

        if (Object.prototype.toString.call(limit) === '[object Number]' && calculate.data > limit) {
            confirmEl.style.display = 'none';
            warnEl.style.display = 'block';
        }
        else {
            confirmEl.style.display = 'block';
            warnEl.style.display = 'none';
        }
    };

    Operate.prototype.setPosition = function (point, isright) {
        this.point = point;
        var map = this._map,
            pixel = map.pointToOverlayPixel(this.point);
        if (isright) {
            this.div.classList.remove('operateLeft');
            this.div.style.left = pixel.x + 15 + 'px';
        }
        else {
            this.div.classList.add('operateLeft');
            this.div.style.left = pixel.x - 105 + 'px';
        }
        this.div.style.top = pixel.y - 16 + 'px';
    };

    Operate.prototype.draw = function () {
        var map = this._map,
            pixel = map.pointToOverlayPixel(this.point);
        this.div.style.left = pixel.x + 15 + 'px';
        this.div.style.top = pixel.y - 16 + 'px';
    };

    // 显示,编辑半径覆盖物
    function Screenshot(type, point, number, overlay, DrawingManager) {
        this.type = type;
        this.point = point;
        this.number = number;
        this.overlay = overlay;
        this.DrawingManager = DrawingManager;
    }

    Screenshot.prototype = new BMap.Overlay();

    Screenshot.prototype.dispatchEvent = baidu.lang.Class.prototype.dispatchEvent;
    Screenshot.prototype.addEventListener = baidu.lang.Class.prototype.addEventListener;
    Screenshot.prototype.removeEventListener = baidu.lang.Class.prototype.removeEventListener;

    Screenshot.prototype.initialize = function (map) {
        var me = this;
        this._map = map;
        var div = this.div = document.createElement('div');
        div.className = 'screenshot';
        if (this.type == 'circle') {
            var html = '<div class="circlShot"><span id="screenshotNum">' + this.number + '</span><input id="circleInput" type="text" /><span class="unit">米</span></div>';
        }
        else if (this.type == 'rectangle') {
            var html = '<div class="rectWH"><div class="wh"><span id="rectWidth">' + this.number.width + '</span><input id="rectWidthInput" type="text" /></div><span class="multiple">x</span><div class="wh"><span id="rectHeight">' + this.number.height + '</span><input id="rectHeightInput" type="text" /></div><span class="unit">米</span></div>';
        }

        div.innerHTML = html;
        this._map.addEventListener('resize', function (e) {
            me._adjustSize(e.size);
        });
        this._map.getPanes().markerPane.appendChild(div);
        this._bind();
        return div;
    };

    Screenshot.prototype._bind = function () {
        this.setNumber(this.number);

        if (this.type == 'circle') {
            this.bindCircleEvent();
        } else {
            this.bindRectEvent();
        }
    };

    Screenshot.prototype.bindCircleEvent = function () {
        var that = this;
        var circleSpn = document.getElementById('screenshotNum');
        var circleInput = document.getElementById('circleInput');
        circleSpn.addEventListener('click', function (e) {
            var val = circleSpn.innerText;
            circleSpn.style.display = 'none';
            circleInput.value = val;
            circleInput.style.display = 'inline-block';
            circleInput.focus();
        });
        circleInput.addEventListener('click', function (e) {
            circleInput.focus();
        });
        circleInput.addEventListener('keydown', function (e) {
            if (e.keyCode === 13) {
                var val = circleInput.value;
                circleInput.style.display = 'none';
                circleSpn.style.display = 'inline-block';
                circleSpn.innerText = val;
                var opt = {
                    radius: val,
                    overlay: that.overlay
                };
                that._dispatchRadiusChange(opt);
            }
        });
        circleInput.addEventListener('blur', function (e) {
            var val = circleInput.value;
            circleInput.style.display = 'none';
            circleSpn.style.display = 'inline-block';
            circleSpn.innerText = val;
            var opt = {
                radius: val,
                overlay: that.overlay
            };
            that._dispatchRadiusChange(opt);
        });
    };

    Screenshot.prototype.bindRectEvent = function () {
        var that = this;
        var rectWidthSpn = document.getElementById('rectWidth');
        var rectWidthInput = document.getElementById('rectWidthInput');
        var rectHeightSpn = document.getElementById('rectHeight');
        var rectHeightInput = document.getElementById('rectHeightInput');
        rectWidthInput.value = rectWidthSpn.innerText;
        rectHeightInput.value = rectHeightSpn.innerText;
        rectWidthSpn.addEventListener('click', function (e) {
            var val = rectWidthSpn.innerText;
            rectWidthSpn.style.display = 'none';
            rectWidthInput.value = val;
            rectWidthInput.style.display = 'inline-block';
            rectWidthInput.focus();
        });
        rectHeightSpn.addEventListener('click', function (e) {
            var val = rectHeightSpn.innerText;
            rectHeightSpn.style.display = 'none';
            rectHeightInput.value = val;
            rectHeightInput.style.display = 'inline-block';
            rectHeightInput.focus();
        });
        rectWidthInput.addEventListener('click', function (e) {
            rectWidthInput.focus();
        });
        rectHeightInput.addEventListener('click', function (e) {
            rectHeightInput.focus();
        });
        rectWidthInput.addEventListener('keydown', function (e) {
            if (e.keyCode === 13) {
                var widthVal = rectWidthInput.value;
                var heightVal = rectHeightInput.value;
                rectWidthInput.style.display = 'none';
                rectHeightInput.style.display = 'none';
                rectWidthSpn.style.display = 'inline-block';
                rectHeightSpn.style.display = 'inline-block';
                rectWidthSpn.innerText = widthVal;
                rectHeightSpn.innerText = heightVal;
                var opt = {
                    width: widthVal,
                    height: heightVal,
                    overlay: that.overlay
                };
                that._dispatchRectWHChange(opt);
            }
        });
        rectHeightInput.addEventListener('keydown', function (e) {
            if (e.keyCode === 13) {
                var widthVal = rectWidthInput.value;
                var heightVal = rectHeightInput.value;
                rectWidthInput.style.display = 'none';
                rectHeightInput.style.display = 'none';
                rectWidthSpn.style.display = 'inline-block';
                rectHeightSpn.style.display = 'inline-block';
                rectWidthSpn.innerText = widthVal;
                rectHeightSpn.innerText = heightVal;
                var opt = {
                    width: widthVal,
                    height: heightVal,
                    overlay: that.overlay
                };
                that._dispatchRectWHChange(opt);
            }
        });
    };

    Screenshot.prototype.setInfo = function (point, number) {
        this.setNumber(number);
        this.setPosition(point);
    };

    Screenshot.prototype.setNumber = function (number) {
        if (this.type == 'circle') {
            document.getElementById('screenshotNum').textContent = number;
        }
        else {
            document.getElementById('rectWidth').textContent = number.width;
            document.getElementById('rectHeight').textContent = number.height;
        }
    };

    Screenshot.prototype.setPosition = function (point) {
        this.point = point;
        var map = this._map,
            type = this.type,
            pixel = map.pointToOverlayPixel(this.point);
        if (type == 'circle') {
            this.div.style.left = pixel.x - 30 + 'px';
            this.div.style.top = pixel.y - 40 + 'px';
        }
        else if (type == 'rectangle') {
            this.div.style.left = pixel.x + 'px';
            this.div.style.top = pixel.y - 45 + 'px';
        }

    };

    Screenshot.prototype.draw = function () {
        var map = this._map,
            type = this.type,
            pixel = map.pointToOverlayPixel(this.point);
        if (type == 'circle') {
            this.div.style.left = pixel.x - 30 + 'px';
            this.div.style.top = pixel.y - 40 + 'px';
        }
        else if (type == 'rectangle') {
            this.div.style.left = pixel.x + 'px';
            this.div.style.top = pixel.y - 45 + 'px';
        }

    };

    /**
     * 派发事件
     */
    Screenshot.prototype._dispatchRadiusChange = function (opt) {        
        this.dispatchEvent('radiuschange', opt);
    };

    /**
     * 派发事件
     */
    Screenshot.prototype._dispatchRectWHChange = function (opt) {
        this.dispatchEvent('rectwhchange', opt);
    };

    /**
     * 创建遮罩对象
     */
    function Mask() {

        /**
         * 鼠标到地图边缘的时候是否自动平移地图
         */
        this._enableEdgeMove = false;
    }

    Mask.prototype = new BMap.Overlay();

    /**
     * 这里不使用api中的自定义事件，是为了更灵活使用
     */
    Mask.prototype.dispatchEvent = baidu.lang.Class.prototype.dispatchEvent;
    Mask.prototype.addEventListener = baidu.lang.Class.prototype.addEventListener;
    Mask.prototype.removeEventListener = baidu.lang.Class.prototype.removeEventListener;

    Mask.prototype.initialize = function (map) {
        var me = this;
        this._map = map;
        var div = this.container = document.createElement('div');
        var size = this._map.getSize();
        div.style.cssText = 'position:absolute;background:url(about:blank);cursor:crosshair;width:' + size.width + 'px;height:' + size.height + 'px';
        this._map.addEventListener('resize', function (e) {
            me._adjustSize(e.size);
        });
        this._map.getPanes().floatPane.appendChild(div);
        this._bind();
        return div;
    };

    Mask.prototype.draw = function () {
        var map = this._map,
            point = map.pixelToPoint(new BMap.Pixel(0, 0)),
            pixel = map.pointToOverlayPixel(point);
        this.container.style.left = pixel.x + 'px';
        this.container.style.top = pixel.y + 'px';
    };

    /**
     * 开启鼠标到地图边缘，自动平移地图
     */
    Mask.prototype.enableEdgeMove = function () {
        this._enableEdgeMove = true;
    };

    /**
     * 关闭鼠标到地图边缘，自动平移地图
     */
    Mask.prototype.disableEdgeMove = function () {
        clearInterval(this._edgeMoveTimer);
        this._enableEdgeMove = false;
    };

    /**
     * 绑定事件,派发自定义事件
     */
    Mask.prototype._bind = function () {

        var me = this,
            map = this._map,
            container = this.container,
            lastMousedownXY = null,
            lastClickXY = null;

        /**
         * 根据event对象获取鼠标的xy坐标对象
         * @param {Event}
         * @return {Object} {x:e.x, y:e.y}
         */
        var getXYbyEvent = function (e) {
            return {
                x: e.clientX,
                y: e.clientY
            };
        };

        var domEvent = function (e) {
            var type = e.type;
            e = baidu.getEvent(e);
            point = me.getDrawPoint(e); // 当前鼠标所在点的地理坐标

            var dispatchEvent = function (type) {
                e.point = point;
                me.dispatchEvent(e);
            };

            if (type == 'mousedown') {
                lastMousedownXY = getXYbyEvent(e);
            }

            var nowXY = getXYbyEvent(e);
            // click经过一些特殊处理派发，其他同事件按正常的dom事件派发
            if (type == 'click') {
                // 鼠标点击过程不进行移动才派发click和dblclick
                if (Math.abs(nowXY.x - lastMousedownXY.x) < 5 && Math.abs(nowXY.y - lastMousedownXY.y) < 5) {
                    if (!lastClickXY || !(Math.abs(nowXY.x - lastClickXY.x) < 5 && Math.abs(nowXY.y - lastClickXY.y) < 5)) {
                        dispatchEvent('click');
                        lastClickXY = getXYbyEvent(e);
                    } else {
                        lastClickXY = null;
                    }
                }
            } else {
                dispatchEvent(type);
            }
        };

        /**
         * 将事件都遮罩层的事件都绑定到domEvent来处理
         */
        var events = ['click', 'mousedown', 'mousemove', 'mouseup', 'dblclick'],
            index = events.length;
        while (index--) {
            baidu.on(container, events[index], domEvent);
        }

        // 鼠标移动过程中，到地图边缘后自动平移地图
        baidu.on(container, 'mousemove', function (e) {
            if (me._enableEdgeMove) {
                me.mousemoveAction(e);
            }

        });
    };

    // 鼠标移动过程中，到地图边缘后自动平移地图
    Mask.prototype.mousemoveAction = function (e) {
        function getClientPosition(e) {
            var clientX = e.clientX,
                clientY = e.clientY;
            if (e.changedTouches) {
                clientX = e.changedTouches[0].clientX;
                clientY = e.changedTouches[0].clientY;
            }

            return new BMap.Pixel(clientX, clientY);
        }

        var map = this._map,
            me = this,
            pixel = map.pointToPixel(this.getDrawPoint(e)),
            clientPos = getClientPosition(e),
            offsetX = clientPos.x - pixel.x,
            offsetY = clientPos.y - pixel.y;
        pixel = new BMap.Pixel((clientPos.x - offsetX), (clientPos.y - offsetY));
        this._draggingMovePixel = pixel;
        var point = map.pixelToPoint(pixel),
            eventObj = {
                pixel: pixel,
                point: point
            };
        // 拖拽到地图边缘移动地图
        this._panByX = this._panByY = 0;
        if (pixel.x <= 20 || pixel.x >= map.width - 20 ||
            pixel.y <= 50 || pixel.y >= map.height - 10) {
            if (pixel.x <= 20) {
                this._panByX = 8;
            }
            else if (pixel.x >= map.width - 20) {
                this._panByX = -8;
            }

            if (pixel.y <= 50) {
                this._panByY = 8;
            }
            else if (pixel.y >= map.height - 10) {
                this._panByY = -8;
            }

            if (!this._edgeMoveTimer) {
                this._edgeMoveTimer = setInterval(function () {
                    map.panBy(me._panByX, me._panByY, {
                        noAnimation: true
                    });
                }, 30);
            }
        } else {
            if (this._edgeMoveTimer) {
                clearInterval(this._edgeMoveTimer);
                this._edgeMoveTimer = null;
            }
        }
    };

    /*
     * 调整大小
     * @param {Size}
     */
    Mask.prototype._adjustSize = function (size) {
        this.container.style.width = size.width + 'px';
        this.container.style.height = size.height + 'px';
    };

    /**
     * 获取当前绘制点的地理坐标
     *
     * @param {Event} e e对象
     * @return Point对象的位置信息
     */
    Mask.prototype.getDrawPoint = function (e) {

        var map = this._map,
            trigger = baidu.getTarget(e),
            x = e.offsetX || e.layerX || 0,
            y = e.offsetY || e.layerY || 0;
        if (trigger.nodeType != 1) {
            trigger = trigger.parentNode;
        }

        while (trigger && trigger != map.getContainer()) {
            if (!(trigger.clientWidth == 0 &&
                trigger.clientHeight == 0 &&
                trigger.offsetParent && trigger.offsetParent.nodeName == 'TD')) {
                x += trigger.offsetLeft || 0;
                y += trigger.offsetTop || 0;
            }

            trigger = trigger.offsetParent;
        }
        var pixel = new BMap.Pixel(x, y);
        var point = map.pixelToPoint(pixel);
        return point;

    };

    /**
     * 绘制工具面板，自定义控件
     */
    function DrawingTool(drawingManager, drawingToolOptions) {
        this.drawingManager = drawingManager;

        drawingToolOptions = this.drawingToolOptions = drawingToolOptions || {};
        // 默认停靠位置和偏移量
        if (!drawingToolOptions.hasCustomStyle) {
            this.defaultAnchor = drawingToolOptions.anchor !== undefined ? drawingToolOptions.anchor : BMAP_ANCHOR_TOP_LEFT;
            this.defaultOffset = drawingToolOptions.offset || new BMap.Size(10, 10);
        }

        // 默认所有工具栏都显示
        this.defaultDrawingModes = [
            BMAP_DRAWING_MARKER,
            BMAP_DRAWING_CIRCLE,
            BMAP_DRAWING_POLYLINE,
            BMAP_DRAWING_POLYGON,
            BMAP_DRAWING_RECTANGLE
        ];
        // 工具栏可显示的绘制模式
        if (drawingToolOptions.drawingModes) {
            this.drawingModes = drawingToolOptions.drawingModes;
        } else {
            this.drawingModes = this.defaultDrawingModes;
        }

        // 用户设置停靠位置和偏移量
        if (drawingToolOptions.hasCustomStyle) {
            if (drawingToolOptions.anchor) {
                this.setAnchor(drawingToolOptions.anchor);
            }

            if (drawingToolOptions.offset) {
                this.setOffset(drawingToolOptions.offset);
            }
        }
    }

    // 通过JavaScript的prototype属性继承于BMap.Control
    DrawingTool.prototype = new BMap.Control();

    // 自定义控件必须实现自己的initialize方法,并且将控件的DOM元素返回
    // 在本方法中创建个div元素作为控件的容器,并将其添加到地图容器中
    DrawingTool.prototype.initialize = function (map) {
        // 创建一个DOM元素
        var container = this.container = document.createElement('div');
        container.className = 'BMapLib_Drawing';
        // 用来设置外层边框阴影
        var panel = this.panel = document.createElement('div');
        panel.className = 'BMapLib_Drawing_panel';
        if (this.drawingToolOptions && !this.drawingToolOptions.hasCustomStyle && this.drawingToolOptions.scale) {
            this._setScale(this.drawingToolOptions.scale);
        }

        container.appendChild(panel);
        // 添加内容
        var content = this._generalHtml();
        panel.appendChild(content);
        // 添加tip
        var tip = this.tip = document.createElement('div');
        tip.className = 'BMapLib_tip';
        tip.innerHTML = '<p class="BMapLib_tip_title"></p><p class="BMapLib_tip_text"></p>';
        if (this.drawingToolOptions.enableTips === true) {
            panel.appendChild(tip);
        }
        // 绑定事件
        this._bind(panel);
        // 添加DOM元素到地图中
        if (this.drawingToolOptions.customContainer) {
            baidu.g(this.drawingToolOptions.customContainer).appendChild(container);
        } else {
            map.getContainer().appendChild(container);
        }
        // 将DOM元素返回
        return container;
    };

    // 生成工具栏的html元素
    DrawingTool.prototype._generalHtml = function (map) {
        var that = this;
        // 鼠标经过工具栏上的提示信息
        var tips = {};
        tips.hander = '拖动地图';
        tips[BMAP_DRAWING_MARKER] = '画点';
        tips[BMAP_DRAWING_CIRCLE] = '圆形工具';
        tips[BMAP_DRAWING_POLYLINE] = '画折线';
        tips[BMAP_DRAWING_POLYGON] = '多边形工具';
        tips[BMAP_DRAWING_RECTANGLE] = '矩形工具';

        var getItem = function (className, drawingType) {
            var ele = document.createElement('a');
            ele.className = className;
            ele.href = 'javascript:void(0)';
            ele.setAttribute('drawingType', drawingType);
            ele.setAttribute('onfocus', 'this.blur()');
            ele.addEventListener('mouseenter', function (e) {
                var drawingType = e.target.getAttribute('drawingType');
                var title = tips[drawingType];
                if (drawingType === 'hander') {
                    that.tip.children[0].innerText = title;
                    that.tip.children[1].innerText = '使用鼠标拖动地图';
                } else {
                    that.tip.className += ' ' + drawingType;
                    that.tip.children[0].innerText = title;
                    that.tip.children[1].innerText = '使用' + title + '选出目标区域';
                }
                that.tip.style.display = 'block';
            });
            ele.addEventListener('mouseleave', function (e) {
                // remove class drawingType
                var drawingType = e.target.getAttribute('drawingType');
                var newClass = ' ' + that.tip.className.replace(/[\t\r\n]/g, '') + ' ';
                while (newClass.indexOf(' ' + drawingType + ' ') >= 0) {
                    newClass = newClass.replace(' ' + drawingType + ' ', ' ');
                }
                that.tip.className = newClass.replace(/^\s+|\s+$/g, '');

                that.tip.style.display = 'none';
            });
            return ele;
        };

        // 生成工具
        var fragment = document.createDocumentFragment();
        // 取消hander工具的展示，交互改为再次点击tool取消active功能
        // fragment.appendChild(getItem('BMapLib_box BMapLib_hander', 'hander'));
        for (var i = 0, len = this.drawingModes.length; i < len; i++) {
            var classStr = 'BMapLib_box BMapLib_' + this.drawingModes[i];
            if (i == len - 1) {
                classStr += ' BMapLib_last';
            }

            fragment.appendChild(getItem(classStr, this.drawingModes[i]));
        }

        return fragment;
    };

    /**
     * 设置工具栏的缩放比例
     */
    DrawingTool.prototype._setScale = function (scale) {
        var width = 390,
            height = 50,
            ml = -parseInt((width - width * scale) / 2, 10),
            mt = -parseInt((height - height * scale) / 2, 10);
        this.container.style.cssText = [
            '-moz-transform: scale(' + scale + ');',
            '-o-transform: scale(' + scale + ');',
            '-webkit-transform: scale(' + scale + ');',
            'transform: scale(' + scale + ');',
            'margin-left:' + ml + 'px;',
            'margin-top:' + mt + 'px;',
            '*margin-left:0px;', // ie6、7
            '*margin-top:0px;', // ie6、7
            'margin-left:0px\\0;', // ie8
            'margin-top:0px\\0;', // ie8
            // ie下使用滤镜
            'filter: progid:DXImageTransform.Microsoft.Matrix(',
            'M11=' + scale + ',',
            'M12=0,',
            'M21=0,',
            'M22=' + scale + ',',
            'SizingMethod=\'auto expand\');'
        ].join('');
    };

    // 绑定工具栏的事件
    DrawingTool.prototype._bind = function (panel) {
        var me = this;
        baidu.on(this.panel, 'click', function (e) {
            var target = baidu.getTarget(e);
            var drawingType = target.getAttribute('drawingType');
            me.setStyleByDrawingMode(drawingType);
            me._bindEventByDraingMode(drawingType);
        });
    };

    // 设置工具栏当前选中的项样式
    DrawingTool.prototype.setStyleByDrawingMode = function (drawingType) {
        if (!drawingType) {
            return;
        }

        var boxs = this.panel.getElementsByTagName('a');
        for (var i = 0, len = boxs.length; i < len; i++) {
            var box = boxs[i];
            if (box.getAttribute('drawingType') == drawingType) {
                var classStr = 'BMapLib_box BMapLib_' + drawingType + '_hover';
                if (i == len - 1) {
                    classStr += ' BMapLib_last';
                }

                box.className = classStr;
            } else {
                box.className = box.className.replace(/_hover/, '');
            }
        }
    };

    // 设置工具栏当前选中的项样式
    DrawingTool.prototype._bindEventByDraingMode = function (drawingType) {
        var me = this;
        var drawingManager = this.drawingManager;
        // 点在拖拽地图的按钮上
        // hander工具的逻辑
        // if (drawingType == 'hander') {
        //     drawingManager.close();
        //     drawingManager._map.enableDoubleClickZoom();
        // }
        // else {
        //     drawingManager.setDrawingMode(drawingType);
        //     drawingManager.open();
        //     drawingManager._map.disableDoubleClickZoom();
        // }

        // 关闭hander工具的逻辑
        if (drawingManager._isOpen && drawingManager.getDrawingMode() === drawingType) {
            drawingManager.close();
            drawingManager._map.enableDoubleClickZoom();
        } else {
            drawingManager.setDrawingMode(drawingType);
            drawingManager.open();
            drawingManager._map.disableDoubleClickZoom();
        }
    };

    // 用来存储用户实例化出来的drawingmanager对象
    var instances = [];

    /*
     * 关闭其他实例的绘制模式
     * @param {DrawingManager} 当前的实例
     */
    function closeInstanceExcept(instance) {
        var index = instances.length;
        while (index--) {
            if (instances[index] != instance) {
                instances[index].close();
            }

        }
    }

    function drawcircle(center, radius) {
        var points = [];
        var cx = center["lng"],
            cy = center["lat"];
        var d = radius / 6378800, // circle radius / meters of Earth radius = radians
            lat1 = (Math.PI / 180) * cy,
            lng1 = (Math.PI / 180) * cx;

        for (var i = 0; i < 271; i += 9) {
            var tc = (Math.PI / 180) * i,
                y = Math.asin(Math.sin(lat1) * Math.cos(d) + Math.cos(lat1) * Math.sin(d) * Math.cos(tc)),
                dlng = Math.atan2(Math.sin(tc) * Math.sin(d) * Math.cos(lat1), Math.cos(d) - Math.sin(lat1) * Math.sin(y)),
                x = ((lng1 - dlng + Math.PI) % (2 * Math.PI)) - Math.PI,
                point = new BMap.Point(x * (180 / Math.PI), y * (180 / Math.PI));
            points.push(point);
        }

        var fstPoint = points[0];
        points.push(new BMap.Point(fstPoint["lng"], fstPoint["lat"]));
        return points;
    }

    function getPointByDistance(srcPoint, distance, direction) {
        var cx = srcPoint["lng"],
            cy = srcPoint["lat"];
        var d = distance / 6378800, // circle radius / meters of Earth radius = radians
            lat1 = (Math.PI / 180) * cy,
            lng1 = (Math.PI / 180) * cx;
        var i,tmplng,tmplat;
        switch (direction) {
            case 'North':
            case 'north':
            case 'N':
            case 'n':
                i = 0;
                tmplng = srcPoint.lng;
                break;
            case 'West':
            case 'west':
            case 'W':
            case 'w':
                i = 90;
                tmplat = srcPoint.lat;
                break;
            case 'South':
            case 'south':
            case 'S':
            case 's':
                i = 180;
                tmplng = srcPoint.lng;
                break;
            case 'East':
            case 'east':
            case 'E':
            case 'e':
                i = 270;
                tmplat = srcPoint.lat;
                break;
            default:
                i = ~~direction;
                break;
        }
        var tc = (Math.PI / 180) * i,
            y = Math.asin(Math.sin(lat1) * Math.cos(d) + Math.cos(lat1) * Math.sin(d) * Math.cos(tc)),
            dlng = Math.atan2(Math.sin(tc) * Math.sin(d) * Math.cos(lat1), Math.cos(d) - Math.sin(lat1) * Math.sin(y)),
            x = ((lng1 - dlng + Math.PI) % (2 * Math.PI)) - Math.PI,
            point = new BMap.Point(tmplng || x * (180 / Math.PI), tmplat || y * (180 / Math.PI));
        point.lng = parseFloat(point.lng.toFixed(6));
        point.lat = parseFloat(point.lat.toFixed(6));
        return point;
    }

})();