+ // get keys via $(element).data('amObserve')
+ // call functions store with these keys
+ $.each(UI.DOMWatchers, function(i, watcher) {
+ watcher(element);
+ });
+ });
+
+ $(function() {
+ var $body = $(document.body);
+
+ UI.DOMReady = true;
+
+ // Run default init
+ $.each(UI.DOMWatchers, function(i, watcher) {
+ watcher(document);
+ });
+
+ // watches DOM
+ /* eslint-disable new-cap */
+ UI.DOMObserve('[data-am-observe]');
+ /* eslint-enable */
+
+ $html.removeClass('no-js').addClass('js');
+
+ UI.support.animation && $html.addClass('cssanimations');
+
+ // iOS standalone mode
+ if (window.navigator.standalone) {
+ $html.addClass('am-standalone');
+ }
+
+ $('.am-topbar-fixed-top').length &&
+ $body.addClass('am-with-topbar-fixed-top');
+
+ $('.am-topbar-fixed-bottom').length &&
+ $body.addClass('am-with-topbar-fixed-bottom');
+
+ // Remove responsive classes in .am-layout
+ var $layout = $('.am-layout');
+ $layout.find('[class*="md-block-grid"]').alterClass('md-block-grid-*');
+ $layout.find('[class*="lg-block-grid"]').alterClass('lg-block-grid');
+
+ // widgets not in .am-layout
+ $('[data-am-widget]').each(function() {
+ var $widget = $(this);
+ // console.log($widget.parents('.am-layout').length)
+ if ($widget.parents('.am-layout').length === 0) {
+ $widget.addClass('am-no-layout');
+ }
+ });
+ });
+
+ module.exports = UI;
+
+
+/***/ },
+/* 3 */
+/***/ function(module, exports, __webpack_require__) {
+
+ /*! Hammer.JS - v2.0.8 - 2016-04-22
+ * http://hammerjs.github.io/
+ *
+ * Copyright (c) 2016 Jorik Tangelder;
+ * Licensed under the MIT license */
+
+ 'use strict';
+
+ var $ = __webpack_require__(1);
+ var UI = __webpack_require__(2);
+
+ var VENDOR_PREFIXES = ['', 'webkit', 'Moz', 'MS', 'ms', 'o'];
+ var TEST_ELEMENT = document.createElement('div');
+
+ var TYPE_FUNCTION = 'function';
+
+ var round = Math.round;
+ var abs = Math.abs;
+ var now = Date.now;
+
+ /**
+ * set a timeout with a given scope
+ * @param {Function} fn
+ * @param {Number} timeout
+ * @param {Object} context
+ * @returns {number}
+ */
+ function setTimeoutContext(fn, timeout, context) {
+ return setTimeout(bindFn(fn, context), timeout);
+ }
+
+ /**
+ * if the argument is an array, we want to execute the fn on each entry
+ * if it aint an array we don't want to do a thing.
+ * this is used by all the methods that accept a single and array argument.
+ * @param {*|Array} arg
+ * @param {String} fn
+ * @param {Object} [context]
+ * @returns {Boolean}
+ */
+ function invokeArrayArg(arg, fn, context) {
+ if (Array.isArray(arg)) {
+ each(arg, context[fn], context);
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * walk objects and arrays
+ * @param {Object} obj
+ * @param {Function} iterator
+ * @param {Object} context
+ */
+ function each(obj, iterator, context) {
+ var i;
+
+ if (!obj) {
+ return;
+ }
+
+ if (obj.forEach) {
+ obj.forEach(iterator, context);
+ } else if (obj.length !== undefined) {
+ i = 0;
+ while (i < obj.length) {
+ iterator.call(context, obj[i], i, obj);
+ i++;
+ }
+ } else {
+ for (i in obj) {
+ obj.hasOwnProperty(i) && iterator.call(context, obj[i], i, obj);
+ }
+ }
+ }
+
+ /**
+ * wrap a method with a deprecation warning and stack trace
+ * @param {Function} method
+ * @param {String} name
+ * @param {String} message
+ * @returns {Function} A new function wrapping the supplied method.
+ */
+ function deprecate(method, name, message) {
+ var deprecationMessage = 'DEPRECATED METHOD: ' + name + '\n' + message + ' AT \n';
+ return function() {
+ var e = new Error('get-stack-trace');
+ var stack = e && e.stack ? e.stack.replace(/^[^\(]+?[\n$]/gm, '')
+ .replace(/^\s+at\s+/gm, '')
+ .replace(/^Object.\s*\(/gm, '{anonymous}()@') : 'Unknown Stack Trace';
+
+ var log = window.console && (window.console.warn || window.console.log);
+ if (log) {
+ log.call(window.console, deprecationMessage, stack);
+ }
+ return method.apply(this, arguments);
+ };
+ }
+
+ /**
+ * extend object.
+ * means that properties in dest will be overwritten by the ones in src.
+ * @param {Object} target
+ * @param {...Object} objects_to_assign
+ * @returns {Object} target
+ */
+ var assign;
+ if (typeof Object.assign !== 'function') {
+ assign = function assign(target) {
+ if (target === undefined || target === null) {
+ throw new TypeError('Cannot convert undefined or null to object');
+ }
+
+ var output = Object(target);
+ for (var index = 1; index < arguments.length; index++) {
+ var source = arguments[index];
+ if (source !== undefined && source !== null) {
+ for (var nextKey in source) {
+ if (source.hasOwnProperty(nextKey)) {
+ output[nextKey] = source[nextKey];
+ }
+ }
+ }
+ }
+ return output;
+ };
+ } else {
+ assign = Object.assign;
+ }
+
+ /**
+ * extend object.
+ * means that properties in dest will be overwritten by the ones in src.
+ * @param {Object} dest
+ * @param {Object} src
+ * @param {Boolean} [merge=false]
+ * @returns {Object} dest
+ */
+ var extend = deprecate(function extend(dest, src, merge) {
+ var keys = Object.keys(src);
+ var i = 0;
+ while (i < keys.length) {
+ if (!merge || (merge && dest[keys[i]] === undefined)) {
+ dest[keys[i]] = src[keys[i]];
+ }
+ i++;
+ }
+ return dest;
+ }, 'extend', 'Use `assign`.');
+
+ /**
+ * merge the values from src in the dest.
+ * means that properties that exist in dest will not be overwritten by src
+ * @param {Object} dest
+ * @param {Object} src
+ * @returns {Object} dest
+ */
+ var merge = deprecate(function merge(dest, src) {
+ return extend(dest, src, true);
+ }, 'merge', 'Use `assign`.');
+
+ /**
+ * simple class inheritance
+ * @param {Function} child
+ * @param {Function} base
+ * @param {Object} [properties]
+ */
+ function inherit(child, base, properties) {
+ var baseP = base.prototype,
+ childP;
+
+ childP = child.prototype = Object.create(baseP);
+ childP.constructor = child;
+ childP._super = baseP;
+
+ if (properties) {
+ assign(childP, properties);
+ }
+ }
+
+ /**
+ * simple function bind
+ * @param {Function} fn
+ * @param {Object} context
+ * @returns {Function}
+ */
+ function bindFn(fn, context) {
+ return function boundFn() {
+ return fn.apply(context, arguments);
+ };
+ }
+
+ /**
+ * let a boolean value also be a function that must return a boolean
+ * this first item in args will be used as the context
+ * @param {Boolean|Function} val
+ * @param {Array} [args]
+ * @returns {Boolean}
+ */
+ function boolOrFn(val, args) {
+ if (typeof val == TYPE_FUNCTION) {
+ return val.apply(args ? args[0] || undefined : undefined, args);
+ }
+ return val;
+ }
+
+ /**
+ * use the val2 when val1 is undefined
+ * @param {*} val1
+ * @param {*} val2
+ * @returns {*}
+ */
+ function ifUndefined(val1, val2) {
+ return (val1 === undefined) ? val2 : val1;
+ }
+
+ /**
+ * addEventListener with multiple events at once
+ * @param {EventTarget} target
+ * @param {String} types
+ * @param {Function} handler
+ */
+ function addEventListeners(target, types, handler) {
+ each(splitStr(types), function(type) {
+ target.addEventListener(type, handler, false);
+ });
+ }
+
+ /**
+ * removeEventListener with multiple events at once
+ * @param {EventTarget} target
+ * @param {String} types
+ * @param {Function} handler
+ */
+ function removeEventListeners(target, types, handler) {
+ each(splitStr(types), function(type) {
+ target.removeEventListener(type, handler, false);
+ });
+ }
+
+ /**
+ * find if a node is in the given parent
+ * @method hasParent
+ * @param {HTMLElement} node
+ * @param {HTMLElement} parent
+ * @return {Boolean} found
+ */
+ function hasParent(node, parent) {
+ while (node) {
+ if (node == parent) {
+ return true;
+ }
+ node = node.parentNode;
+ }
+ return false;
+ }
+
+ /**
+ * small indexOf wrapper
+ * @param {String} str
+ * @param {String} find
+ * @returns {Boolean} found
+ */
+ function inStr(str, find) {
+ return str.indexOf(find) > -1;
+ }
+
+ /**
+ * split string on whitespace
+ * @param {String} str
+ * @returns {Array} words
+ */
+ function splitStr(str) {
+ return str.trim().split(/\s+/g);
+ }
+
+ /**
+ * find if a array contains the object using indexOf or a simple polyFill
+ * @param {Array} src
+ * @param {String} find
+ * @param {String} [findByKey]
+ * @return {Boolean|Number} false when not found, or the index
+ */
+ function inArray(src, find, findByKey) {
+ if (src.indexOf && !findByKey) {
+ return src.indexOf(find);
+ } else {
+ var i = 0;
+ while (i < src.length) {
+ if ((findByKey && src[i][findByKey] == find) || (!findByKey && src[i] === find)) {
+ return i;
+ }
+ i++;
+ }
+ return -1;
+ }
+ }
+
+ /**
+ * convert array-like objects to real arrays
+ * @param {Object} obj
+ * @returns {Array}
+ */
+ function toArray(obj) {
+ return Array.prototype.slice.call(obj, 0);
+ }
+
+ /**
+ * unique array with objects based on a key (like 'id') or just by the array's value
+ * @param {Array} src [{id:1},{id:2},{id:1}]
+ * @param {String} [key]
+ * @param {Boolean} [sort=False]
+ * @returns {Array} [{id:1},{id:2}]
+ */
+ function uniqueArray(src, key, sort) {
+ var results = [];
+ var values = [];
+ var i = 0;
+
+ while (i < src.length) {
+ var val = key ? src[i][key] : src[i];
+ if (inArray(values, val) < 0) {
+ results.push(src[i]);
+ }
+ values[i] = val;
+ i++;
+ }
+
+ if (sort) {
+ if (!key) {
+ results = results.sort();
+ } else {
+ results = results.sort(function sortUniqueArray(a, b) {
+ return a[key] > b[key];
+ });
+ }
+ }
+
+ return results;
+ }
+
+ /**
+ * get the prefixed property
+ * @param {Object} obj
+ * @param {String} property
+ * @returns {String|Undefined} prefixed
+ */
+ function prefixed(obj, property) {
+ var prefix, prop;
+ var camelProp = property[0].toUpperCase() + property.slice(1);
+
+ var i = 0;
+ while (i < VENDOR_PREFIXES.length) {
+ prefix = VENDOR_PREFIXES[i];
+ prop = (prefix) ? prefix + camelProp : property;
+
+ if (prop in obj) {
+ return prop;
+ }
+ i++;
+ }
+ return undefined;
+ }
+
+ /**
+ * get a unique id
+ * @returns {number} uniqueId
+ */
+ var _uniqueId = 1;
+ function uniqueId() {
+ return _uniqueId++;
+ }
+
+ /**
+ * get the window object of an element
+ * @param {HTMLElement} element
+ * @returns {DocumentView|Window}
+ */
+ function getWindowForElement(element) {
+ var doc = element.ownerDocument || element;
+ return (doc.defaultView || doc.parentWindow || window);
+ }
+
+ var MOBILE_REGEX = /mobile|tablet|ip(ad|hone|od)|android/i;
+
+ var SUPPORT_TOUCH = ('ontouchstart' in window);
+ var SUPPORT_POINTER_EVENTS = prefixed(window, 'PointerEvent') !== undefined;
+ var SUPPORT_ONLY_TOUCH = SUPPORT_TOUCH && MOBILE_REGEX.test(navigator.userAgent);
+
+ var INPUT_TYPE_TOUCH = 'touch';
+ var INPUT_TYPE_PEN = 'pen';
+ var INPUT_TYPE_MOUSE = 'mouse';
+ var INPUT_TYPE_KINECT = 'kinect';
+
+ var COMPUTE_INTERVAL = 25;
+
+ var INPUT_START = 1;
+ var INPUT_MOVE = 2;
+ var INPUT_END = 4;
+ var INPUT_CANCEL = 8;
+
+ var DIRECTION_NONE = 1;
+ var DIRECTION_LEFT = 2;
+ var DIRECTION_RIGHT = 4;
+ var DIRECTION_UP = 8;
+ var DIRECTION_DOWN = 16;
+
+ var DIRECTION_HORIZONTAL = DIRECTION_LEFT | DIRECTION_RIGHT;
+ var DIRECTION_VERTICAL = DIRECTION_UP | DIRECTION_DOWN;
+ var DIRECTION_ALL = DIRECTION_HORIZONTAL | DIRECTION_VERTICAL;
+
+ var PROPS_XY = ['x', 'y'];
+ var PROPS_CLIENT_XY = ['clientX', 'clientY'];
+
+ /**
+ * create new input type manager
+ * @param {Manager} manager
+ * @param {Function} callback
+ * @returns {Input}
+ * @constructor
+ */
+ function Input(manager, callback) {
+ var self = this;
+ this.manager = manager;
+ this.callback = callback;
+ this.element = manager.element;
+ this.target = manager.options.inputTarget;
+
+ // smaller wrapper around the handler, for the scope and the enabled state of the manager,
+ // so when disabled the input events are completely bypassed.
+ this.domHandler = function(ev) {
+ if (boolOrFn(manager.options.enable, [manager])) {
+ self.handler(ev);
+ }
+ };
+
+ this.init();
+
+ }
+
+ Input.prototype = {
+ /**
+ * should handle the inputEvent data and trigger the callback
+ * @virtual
+ */
+ handler: function() { },
+
+ /**
+ * bind the events
+ */
+ init: function() {
+ this.evEl && addEventListeners(this.element, this.evEl, this.domHandler);
+ this.evTarget && addEventListeners(this.target, this.evTarget, this.domHandler);
+ this.evWin && addEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);
+ },
+
+ /**
+ * unbind the events
+ */
+ destroy: function() {
+ this.evEl && removeEventListeners(this.element, this.evEl, this.domHandler);
+ this.evTarget && removeEventListeners(this.target, this.evTarget, this.domHandler);
+ this.evWin && removeEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);
+ }
+ };
+
+ /**
+ * create new input type manager
+ * called by the Manager constructor
+ * @param {Hammer} manager
+ * @returns {Input}
+ */
+ function createInputInstance(manager) {
+ var Type;
+ var inputClass = manager.options.inputClass;
+
+ if (inputClass) {
+ Type = inputClass;
+ } else if (SUPPORT_POINTER_EVENTS) {
+ Type = PointerEventInput;
+ } else if (SUPPORT_ONLY_TOUCH) {
+ Type = TouchInput;
+ } else if (!SUPPORT_TOUCH) {
+ Type = MouseInput;
+ } else {
+ Type = TouchMouseInput;
+ }
+ return new (Type)(manager, inputHandler);
+ }
+
+ /**
+ * handle input events
+ * @param {Manager} manager
+ * @param {String} eventType
+ * @param {Object} input
+ */
+ function inputHandler(manager, eventType, input) {
+ var pointersLen = input.pointers.length;
+ var changedPointersLen = input.changedPointers.length;
+ var isFirst = (eventType & INPUT_START && (pointersLen - changedPointersLen === 0));
+ var isFinal = (eventType & (INPUT_END | INPUT_CANCEL) && (pointersLen - changedPointersLen === 0));
+
+ input.isFirst = !!isFirst;
+ input.isFinal = !!isFinal;
+
+ if (isFirst) {
+ manager.session = {};
+ }
+
+ // source event is the normalized value of the domEvents
+ // like 'touchstart, mouseup, pointerdown'
+ input.eventType = eventType;
+
+ // compute scale, rotation etc
+ computeInputData(manager, input);
+
+ // emit secret event
+ manager.emit('hammer.input', input);
+
+ manager.recognize(input);
+ manager.session.prevInput = input;
+ }
+
+ /**
+ * extend the data with some usable properties like scale, rotate, velocity etc
+ * @param {Object} manager
+ * @param {Object} input
+ */
+ function computeInputData(manager, input) {
+ var session = manager.session;
+ var pointers = input.pointers;
+ var pointersLength = pointers.length;
+
+ // store the first input to calculate the distance and direction
+ if (!session.firstInput) {
+ session.firstInput = simpleCloneInputData(input);
+ }
+
+ // to compute scale and rotation we need to store the multiple touches
+ if (pointersLength > 1 && !session.firstMultiple) {
+ session.firstMultiple = simpleCloneInputData(input);
+ } else if (pointersLength === 1) {
+ session.firstMultiple = false;
+ }
+
+ var firstInput = session.firstInput;
+ var firstMultiple = session.firstMultiple;
+ var offsetCenter = firstMultiple ? firstMultiple.center : firstInput.center;
+
+ var center = input.center = getCenter(pointers);
+ input.timeStamp = now();
+ input.deltaTime = input.timeStamp - firstInput.timeStamp;
+
+ input.angle = getAngle(offsetCenter, center);
+ input.distance = getDistance(offsetCenter, center);
+
+ computeDeltaXY(session, input);
+ input.offsetDirection = getDirection(input.deltaX, input.deltaY);
+
+ var overallVelocity = getVelocity(input.deltaTime, input.deltaX, input.deltaY);
+ input.overallVelocityX = overallVelocity.x;
+ input.overallVelocityY = overallVelocity.y;
+ input.overallVelocity = (abs(overallVelocity.x) > abs(overallVelocity.y)) ? overallVelocity.x : overallVelocity.y;
+
+ input.scale = firstMultiple ? getScale(firstMultiple.pointers, pointers) : 1;
+ input.rotation = firstMultiple ? getRotation(firstMultiple.pointers, pointers) : 0;
+
+ input.maxPointers = !session.prevInput ? input.pointers.length : ((input.pointers.length >
+ session.prevInput.maxPointers) ? input.pointers.length : session.prevInput.maxPointers);
+
+ computeIntervalInputData(session, input);
+
+ // find the correct target
+ var target = manager.element;
+ if (hasParent(input.srcEvent.target, target)) {
+ target = input.srcEvent.target;
+ }
+ input.target = target;
+ }
+
+ function computeDeltaXY(session, input) {
+ var center = input.center;
+ var offset = session.offsetDelta || {};
+ var prevDelta = session.prevDelta || {};
+ var prevInput = session.prevInput || {};
+
+ if (input.eventType === INPUT_START || prevInput.eventType === INPUT_END) {
+ prevDelta = session.prevDelta = {
+ x: prevInput.deltaX || 0,
+ y: prevInput.deltaY || 0
+ };
+
+ offset = session.offsetDelta = {
+ x: center.x,
+ y: center.y
+ };
+ }
+
+ input.deltaX = prevDelta.x + (center.x - offset.x);
+ input.deltaY = prevDelta.y + (center.y - offset.y);
+ }
+
+ /**
+ * velocity is calculated every x ms
+ * @param {Object} session
+ * @param {Object} input
+ */
+ function computeIntervalInputData(session, input) {
+ var last = session.lastInterval || input,
+ deltaTime = input.timeStamp - last.timeStamp,
+ velocity, velocityX, velocityY, direction;
+
+ if (input.eventType != INPUT_CANCEL && (deltaTime > COMPUTE_INTERVAL || last.velocity === undefined)) {
+ var deltaX = input.deltaX - last.deltaX;
+ var deltaY = input.deltaY - last.deltaY;
+
+ var v = getVelocity(deltaTime, deltaX, deltaY);
+ velocityX = v.x;
+ velocityY = v.y;
+ velocity = (abs(v.x) > abs(v.y)) ? v.x : v.y;
+ direction = getDirection(deltaX, deltaY);
+
+ session.lastInterval = input;
+ } else {
+ // use latest velocity info if it doesn't overtake a minimum period
+ velocity = last.velocity;
+ velocityX = last.velocityX;
+ velocityY = last.velocityY;
+ direction = last.direction;
+ }
+
+ input.velocity = velocity;
+ input.velocityX = velocityX;
+ input.velocityY = velocityY;
+ input.direction = direction;
+ }
+
+ /**
+ * create a simple clone from the input used for storage of firstInput and firstMultiple
+ * @param {Object} input
+ * @returns {Object} clonedInputData
+ */
+ function simpleCloneInputData(input) {
+ // make a simple copy of the pointers because we will get a reference if we don't
+ // we only need clientXY for the calculations
+ var pointers = [];
+ var i = 0;
+ while (i < input.pointers.length) {
+ pointers[i] = {
+ clientX: round(input.pointers[i].clientX),
+ clientY: round(input.pointers[i].clientY)
+ };
+ i++;
+ }
+
+ return {
+ timeStamp: now(),
+ pointers: pointers,
+ center: getCenter(pointers),
+ deltaX: input.deltaX,
+ deltaY: input.deltaY
+ };
+ }
+
+ /**
+ * get the center of all the pointers
+ * @param {Array} pointers
+ * @return {Object} center contains `x` and `y` properties
+ */
+ function getCenter(pointers) {
+ var pointersLength = pointers.length;
+
+ // no need to loop when only one touch
+ if (pointersLength === 1) {
+ return {
+ x: round(pointers[0].clientX),
+ y: round(pointers[0].clientY)
+ };
+ }
+
+ var x = 0, y = 0, i = 0;
+ while (i < pointersLength) {
+ x += pointers[i].clientX;
+ y += pointers[i].clientY;
+ i++;
+ }
+
+ return {
+ x: round(x / pointersLength),
+ y: round(y / pointersLength)
+ };
+ }
+
+ /**
+ * calculate the velocity between two points. unit is in px per ms.
+ * @param {Number} deltaTime
+ * @param {Number} x
+ * @param {Number} y
+ * @return {Object} velocity `x` and `y`
+ */
+ function getVelocity(deltaTime, x, y) {
+ return {
+ x: x / deltaTime || 0,
+ y: y / deltaTime || 0
+ };
+ }
+
+ /**
+ * get the direction between two points
+ * @param {Number} x
+ * @param {Number} y
+ * @return {Number} direction
+ */
+ function getDirection(x, y) {
+ if (x === y) {
+ return DIRECTION_NONE;
+ }
+
+ if (abs(x) >= abs(y)) {
+ return x < 0 ? DIRECTION_LEFT : DIRECTION_RIGHT;
+ }
+ return y < 0 ? DIRECTION_UP : DIRECTION_DOWN;
+ }
+
+ /**
+ * calculate the absolute distance between two points
+ * @param {Object} p1 {x, y}
+ * @param {Object} p2 {x, y}
+ * @param {Array} [props] containing x and y keys
+ * @return {Number} distance
+ */
+ function getDistance(p1, p2, props) {
+ if (!props) {
+ props = PROPS_XY;
+ }
+ var x = p2[props[0]] - p1[props[0]],
+ y = p2[props[1]] - p1[props[1]];
+
+ return Math.sqrt((x * x) + (y * y));
+ }
+
+ /**
+ * calculate the angle between two coordinates
+ * @param {Object} p1
+ * @param {Object} p2
+ * @param {Array} [props] containing x and y keys
+ * @return {Number} angle
+ */
+ function getAngle(p1, p2, props) {
+ if (!props) {
+ props = PROPS_XY;
+ }
+ var x = p2[props[0]] - p1[props[0]],
+ y = p2[props[1]] - p1[props[1]];
+ return Math.atan2(y, x) * 180 / Math.PI;
+ }
+
+ /**
+ * calculate the rotation degrees between two pointersets
+ * @param {Array} start array of pointers
+ * @param {Array} end array of pointers
+ * @return {Number} rotation
+ */
+ function getRotation(start, end) {
+ return getAngle(end[1], end[0], PROPS_CLIENT_XY) + getAngle(start[1], start[0], PROPS_CLIENT_XY);
+ }
+
+ /**
+ * calculate the scale factor between two pointersets
+ * no scale is 1, and goes down to 0 when pinched together, and bigger when pinched out
+ * @param {Array} start array of pointers
+ * @param {Array} end array of pointers
+ * @return {Number} scale
+ */
+ function getScale(start, end) {
+ return getDistance(end[0], end[1], PROPS_CLIENT_XY) / getDistance(start[0], start[1], PROPS_CLIENT_XY);
+ }
+
+ var MOUSE_INPUT_MAP = {
+ mousedown: INPUT_START,
+ mousemove: INPUT_MOVE,
+ mouseup: INPUT_END
+ };
+
+ var MOUSE_ELEMENT_EVENTS = 'mousedown';
+ var MOUSE_WINDOW_EVENTS = 'mousemove mouseup';
+
+ /**
+ * Mouse events input
+ * @constructor
+ * @extends Input
+ */
+ function MouseInput() {
+ this.evEl = MOUSE_ELEMENT_EVENTS;
+ this.evWin = MOUSE_WINDOW_EVENTS;
+
+ this.pressed = false; // mousedown state
+
+ Input.apply(this, arguments);
+ }
+
+ inherit(MouseInput, Input, {
+ /**
+ * handle mouse events
+ * @param {Object} ev
+ */
+ handler: function MEhandler(ev) {
+ var eventType = MOUSE_INPUT_MAP[ev.type];
+
+ // on start we want to have the left mouse button down
+ if (eventType & INPUT_START && ev.button === 0) {
+ this.pressed = true;
+ }
+
+ if (eventType & INPUT_MOVE && ev.which !== 1) {
+ eventType = INPUT_END;
+ }
+
+ // mouse must be down
+ if (!this.pressed) {
+ return;
+ }
+
+ if (eventType & INPUT_END) {
+ this.pressed = false;
+ }
+
+ this.callback(this.manager, eventType, {
+ pointers: [ev],
+ changedPointers: [ev],
+ pointerType: INPUT_TYPE_MOUSE,
+ srcEvent: ev
+ });
+ }
+ });
+
+ var POINTER_INPUT_MAP = {
+ pointerdown: INPUT_START,
+ pointermove: INPUT_MOVE,
+ pointerup: INPUT_END,
+ pointercancel: INPUT_CANCEL,
+ pointerout: INPUT_CANCEL
+ };
+
+ // in IE10 the pointer types is defined as an enum
+ var IE10_POINTER_TYPE_ENUM = {
+ 2: INPUT_TYPE_TOUCH,
+ 3: INPUT_TYPE_PEN,
+ 4: INPUT_TYPE_MOUSE,
+ 5: INPUT_TYPE_KINECT // see https://twitter.com/jacobrossi/status/480596438489890816
+ };
+
+ var POINTER_ELEMENT_EVENTS = 'pointerdown';
+ var POINTER_WINDOW_EVENTS = 'pointermove pointerup pointercancel';
+
+ // IE10 has prefixed support, and case-sensitive
+ if (window.MSPointerEvent && !window.PointerEvent) {
+ POINTER_ELEMENT_EVENTS = 'MSPointerDown';
+ POINTER_WINDOW_EVENTS = 'MSPointerMove MSPointerUp MSPointerCancel';
+ }
+
+ /**
+ * Pointer events input
+ * @constructor
+ * @extends Input
+ */
+ function PointerEventInput() {
+ this.evEl = POINTER_ELEMENT_EVENTS;
+ this.evWin = POINTER_WINDOW_EVENTS;
+
+ Input.apply(this, arguments);
+
+ this.store = (this.manager.session.pointerEvents = []);
+ }
+
+ inherit(PointerEventInput, Input, {
+ /**
+ * handle mouse events
+ * @param {Object} ev
+ */
+ handler: function PEhandler(ev) {
+ var store = this.store;
+ var removePointer = false;
+
+ var eventTypeNormalized = ev.type.toLowerCase().replace('ms', '');
+ var eventType = POINTER_INPUT_MAP[eventTypeNormalized];
+ var pointerType = IE10_POINTER_TYPE_ENUM[ev.pointerType] || ev.pointerType;
+
+ var isTouch = (pointerType == INPUT_TYPE_TOUCH);
+
+ // get index of the event in the store
+ var storeIndex = inArray(store, ev.pointerId, 'pointerId');
+
+ // start and mouse must be down
+ if (eventType & INPUT_START && (ev.button === 0 || isTouch)) {
+ if (storeIndex < 0) {
+ store.push(ev);
+ storeIndex = store.length - 1;
+ }
+ } else if (eventType & (INPUT_END | INPUT_CANCEL)) {
+ removePointer = true;
+ }
+
+ // it not found, so the pointer hasn't been down (so it's probably a hover)
+ if (storeIndex < 0) {
+ return;
+ }
+
+ // update the event in the store
+ store[storeIndex] = ev;
+
+ this.callback(this.manager, eventType, {
+ pointers: store,
+ changedPointers: [ev],
+ pointerType: pointerType,
+ srcEvent: ev
+ });
+
+ if (removePointer) {
+ // remove from the store
+ store.splice(storeIndex, 1);
+ }
+ }
+ });
+
+ var SINGLE_TOUCH_INPUT_MAP = {
+ touchstart: INPUT_START,
+ touchmove: INPUT_MOVE,
+ touchend: INPUT_END,
+ touchcancel: INPUT_CANCEL
+ };
+
+ var SINGLE_TOUCH_TARGET_EVENTS = 'touchstart';
+ var SINGLE_TOUCH_WINDOW_EVENTS = 'touchstart touchmove touchend touchcancel';
+
+ /**
+ * Touch events input
+ * @constructor
+ * @extends Input
+ */
+ function SingleTouchInput() {
+ this.evTarget = SINGLE_TOUCH_TARGET_EVENTS;
+ this.evWin = SINGLE_TOUCH_WINDOW_EVENTS;
+ this.started = false;
+
+ Input.apply(this, arguments);
+ }
+
+ inherit(SingleTouchInput, Input, {
+ handler: function TEhandler(ev) {
+ var type = SINGLE_TOUCH_INPUT_MAP[ev.type];
+
+ // should we handle the touch events?
+ if (type === INPUT_START) {
+ this.started = true;
+ }
+
+ if (!this.started) {
+ return;
+ }
+
+ var touches = normalizeSingleTouches.call(this, ev, type);
+
+ // when done, reset the started state
+ if (type & (INPUT_END | INPUT_CANCEL) && touches[0].length - touches[1].length === 0) {
+ this.started = false;
+ }
+
+ this.callback(this.manager, type, {
+ pointers: touches[0],
+ changedPointers: touches[1],
+ pointerType: INPUT_TYPE_TOUCH,
+ srcEvent: ev
+ });
+ }
+ });
+
+ /**
+ * @this {TouchInput}
+ * @param {Object} ev
+ * @param {Number} type flag
+ * @returns {undefined|Array} [all, changed]
+ */
+ function normalizeSingleTouches(ev, type) {
+ var all = toArray(ev.touches);
+ var changed = toArray(ev.changedTouches);
+
+ if (type & (INPUT_END | INPUT_CANCEL)) {
+ all = uniqueArray(all.concat(changed), 'identifier', true);
+ }
+
+ return [all, changed];
+ }
+
+ var TOUCH_INPUT_MAP = {
+ touchstart: INPUT_START,
+ touchmove: INPUT_MOVE,
+ touchend: INPUT_END,
+ touchcancel: INPUT_CANCEL
+ };
+
+ var TOUCH_TARGET_EVENTS = 'touchstart touchmove touchend touchcancel';
+
+ /**
+ * Multi-user touch events input
+ * @constructor
+ * @extends Input
+ */
+ function TouchInput() {
+ this.evTarget = TOUCH_TARGET_EVENTS;
+ this.targetIds = {};
+
+ Input.apply(this, arguments);
+ }
+
+ inherit(TouchInput, Input, {
+ handler: function MTEhandler(ev) {
+ var type = TOUCH_INPUT_MAP[ev.type];
+ var touches = getTouches.call(this, ev, type);
+ if (!touches) {
+ return;
+ }
+
+ this.callback(this.manager, type, {
+ pointers: touches[0],
+ changedPointers: touches[1],
+ pointerType: INPUT_TYPE_TOUCH,
+ srcEvent: ev
+ });
+ }
+ });
+
+ /**
+ * @this {TouchInput}
+ * @param {Object} ev
+ * @param {Number} type flag
+ * @returns {undefined|Array} [all, changed]
+ */
+ function getTouches(ev, type) {
+ var allTouches = toArray(ev.touches);
+ var targetIds = this.targetIds;
+
+ // when there is only one touch, the process can be simplified
+ if (type & (INPUT_START | INPUT_MOVE) && allTouches.length === 1) {
+ targetIds[allTouches[0].identifier] = true;
+ return [allTouches, allTouches];
+ }
+
+ var i,
+ targetTouches,
+ changedTouches = toArray(ev.changedTouches),
+ changedTargetTouches = [],
+ target = this.target;
+
+ // get target touches from touches
+ targetTouches = allTouches.filter(function(touch) {
+ return hasParent(touch.target, target);
+ });
+
+ // collect touches
+ if (type === INPUT_START) {
+ i = 0;
+ while (i < targetTouches.length) {
+ targetIds[targetTouches[i].identifier] = true;
+ i++;
+ }
+ }
+
+ // filter changed touches to only contain touches that exist in the collected target ids
+ i = 0;
+ while (i < changedTouches.length) {
+ if (targetIds[changedTouches[i].identifier]) {
+ changedTargetTouches.push(changedTouches[i]);
+ }
+
+ // cleanup removed touches
+ if (type & (INPUT_END | INPUT_CANCEL)) {
+ delete targetIds[changedTouches[i].identifier];
+ }
+ i++;
+ }
+
+ if (!changedTargetTouches.length) {
+ return;
+ }
+
+ return [
+ // merge targetTouches with changedTargetTouches so it contains ALL touches, including 'end' and 'cancel'
+ uniqueArray(targetTouches.concat(changedTargetTouches), 'identifier', true),
+ changedTargetTouches
+ ];
+ }
+
+ /**
+ * Combined touch and mouse input
+ *
+ * Touch has a higher priority then mouse, and while touching no mouse events are allowed.
+ * This because touch devices also emit mouse events while doing a touch.
+ *
+ * @constructor
+ * @extends Input
+ */
+
+ var DEDUP_TIMEOUT = 2500;
+ var DEDUP_DISTANCE = 25;
+
+ function TouchMouseInput() {
+ Input.apply(this, arguments);
+
+ var handler = bindFn(this.handler, this);
+ this.touch = new TouchInput(this.manager, handler);
+ this.mouse = new MouseInput(this.manager, handler);
+
+ this.primaryTouch = null;
+ this.lastTouches = [];
+ }
+
+ inherit(TouchMouseInput, Input, {
+ /**
+ * handle mouse and touch events
+ * @param {Hammer} manager
+ * @param {String} inputEvent
+ * @param {Object} inputData
+ */
+ handler: function TMEhandler(manager, inputEvent, inputData) {
+ var isTouch = (inputData.pointerType == INPUT_TYPE_TOUCH),
+ isMouse = (inputData.pointerType == INPUT_TYPE_MOUSE);
+
+ if (isMouse && inputData.sourceCapabilities && inputData.sourceCapabilities.firesTouchEvents) {
+ return;
+ }
+
+ // when we're in a touch event, record touches to de-dupe synthetic mouse event
+ if (isTouch) {
+ recordTouches.call(this, inputEvent, inputData);
+ } else if (isMouse && isSyntheticEvent.call(this, inputData)) {
+ return;
+ }
+
+ this.callback(manager, inputEvent, inputData);
+ },
+
+ /**
+ * remove the event listeners
+ */
+ destroy: function destroy() {
+ this.touch.destroy();
+ this.mouse.destroy();
+ }
+ });
+
+ function recordTouches(eventType, eventData) {
+ if (eventType & INPUT_START) {
+ this.primaryTouch = eventData.changedPointers[0].identifier;
+ setLastTouch.call(this, eventData);
+ } else if (eventType & (INPUT_END | INPUT_CANCEL)) {
+ setLastTouch.call(this, eventData);
+ }
+ }
+
+ function setLastTouch(eventData) {
+ var touch = eventData.changedPointers[0];
+
+ if (touch.identifier === this.primaryTouch) {
+ var lastTouch = {x: touch.clientX, y: touch.clientY};
+ this.lastTouches.push(lastTouch);
+ var lts = this.lastTouches;
+ var removeLastTouch = function() {
+ var i = lts.indexOf(lastTouch);
+ if (i > -1) {
+ lts.splice(i, 1);
+ }
+ };
+ setTimeout(removeLastTouch, DEDUP_TIMEOUT);
+ }
+ }
+
+ function isSyntheticEvent(eventData) {
+ var x = eventData.srcEvent.clientX, y = eventData.srcEvent.clientY;
+ for (var i = 0; i < this.lastTouches.length; i++) {
+ var t = this.lastTouches[i];
+ var dx = Math.abs(x - t.x), dy = Math.abs(y - t.y);
+ if (dx <= DEDUP_DISTANCE && dy <= DEDUP_DISTANCE) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ var PREFIXED_TOUCH_ACTION = prefixed(TEST_ELEMENT.style, 'touchAction');
+ var NATIVE_TOUCH_ACTION = PREFIXED_TOUCH_ACTION !== undefined;
+
+ // magical touchAction value
+ var TOUCH_ACTION_COMPUTE = 'compute';
+ var TOUCH_ACTION_AUTO = 'auto';
+ var TOUCH_ACTION_MANIPULATION = 'manipulation'; // not implemented
+ var TOUCH_ACTION_NONE = 'none';
+ var TOUCH_ACTION_PAN_X = 'pan-x';
+ var TOUCH_ACTION_PAN_Y = 'pan-y';
+ var TOUCH_ACTION_MAP = getTouchActionProps();
+
+ /**
+ * Touch Action
+ * sets the touchAction property or uses the js alternative
+ * @param {Manager} manager
+ * @param {String} value
+ * @constructor
+ */
+ function TouchAction(manager, value) {
+ this.manager = manager;
+ this.set(value);
+ }
+
+ TouchAction.prototype = {
+ /**
+ * set the touchAction value on the element or enable the polyfill
+ * @param {String} value
+ */
+ set: function(value) {
+ // find out the touch-action by the event handlers
+ if (value == TOUCH_ACTION_COMPUTE) {
+ value = this.compute();
+ }
+
+ if (NATIVE_TOUCH_ACTION && this.manager.element.style && TOUCH_ACTION_MAP[value]) {
+ this.manager.element.style[PREFIXED_TOUCH_ACTION] = value;
+ }
+ this.actions = value.toLowerCase().trim();
+ },
+
+ /**
+ * just re-set the touchAction value
+ */
+ update: function() {
+ this.set(this.manager.options.touchAction);
+ },
+
+ /**
+ * compute the value for the touchAction property based on the recognizer's settings
+ * @returns {String} value
+ */
+ compute: function() {
+ var actions = [];
+ each(this.manager.recognizers, function(recognizer) {
+ if (boolOrFn(recognizer.options.enable, [recognizer])) {
+ actions = actions.concat(recognizer.getTouchAction());
+ }
+ });
+ return cleanTouchActions(actions.join(' '));
+ },
+
+ /**
+ * this method is called on each input cycle and provides the preventing of the browser behavior
+ * @param {Object} input
+ */
+ preventDefaults: function(input) {
+ var srcEvent = input.srcEvent;
+ var direction = input.offsetDirection;
+
+ // if the touch action did prevented once this session
+ if (this.manager.session.prevented) {
+ srcEvent.preventDefault();
+ return;
+ }
+
+ var actions = this.actions;
+ var hasNone = inStr(actions, TOUCH_ACTION_NONE) && !TOUCH_ACTION_MAP[TOUCH_ACTION_NONE];
+ var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_Y];
+ var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_X];
+
+ if (hasNone) {
+ //do not prevent defaults if this is a tap gesture
+
+ var isTapPointer = input.pointers.length === 1;
+ var isTapMovement = input.distance < 2;
+ var isTapTouchTime = input.deltaTime < 250;
+
+ if (isTapPointer && isTapMovement && isTapTouchTime) {
+ return;
+ }
+ }
+
+ if (hasPanX && hasPanY) {
+ // `pan-x pan-y` means browser handles all scrolling/panning, do not prevent
+ return;
+ }
+
+ if (hasNone ||
+ (hasPanY && direction & DIRECTION_HORIZONTAL) ||
+ (hasPanX && direction & DIRECTION_VERTICAL)) {
+ return this.preventSrc(srcEvent);
+ }
+ },
+
+ /**
+ * call preventDefault to prevent the browser's default behavior (scrolling in most cases)
+ * @param {Object} srcEvent
+ */
+ preventSrc: function(srcEvent) {
+ this.manager.session.prevented = true;
+ srcEvent.preventDefault();
+ }
+ };
+
+ /**
+ * when the touchActions are collected they are not a valid value, so we need to clean things up. *
+ * @param {String} actions
+ * @returns {*}
+ */
+ function cleanTouchActions(actions) {
+ // none
+ if (inStr(actions, TOUCH_ACTION_NONE)) {
+ return TOUCH_ACTION_NONE;
+ }
+
+ var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X);
+ var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y);
+
+ // if both pan-x and pan-y are set (different recognizers
+ // for different directions, e.g. horizontal pan but vertical swipe?)
+ // we need none (as otherwise with pan-x pan-y combined none of these
+ // recognizers will work, since the browser would handle all panning
+ if (hasPanX && hasPanY) {
+ return TOUCH_ACTION_NONE;
+ }
+
+ // pan-x OR pan-y
+ if (hasPanX || hasPanY) {
+ return hasPanX ? TOUCH_ACTION_PAN_X : TOUCH_ACTION_PAN_Y;
+ }
+
+ // manipulation
+ if (inStr(actions, TOUCH_ACTION_MANIPULATION)) {
+ return TOUCH_ACTION_MANIPULATION;
+ }
+
+ return TOUCH_ACTION_AUTO;
+ }
+
+ function getTouchActionProps() {
+ if (!NATIVE_TOUCH_ACTION) {
+ return false;
+ }
+ var touchMap = {};
+ var cssSupports = window.CSS && window.CSS.supports;
+ ['auto', 'manipulation', 'pan-y', 'pan-x', 'pan-x pan-y', 'none'].forEach(function(val) {
+
+ // If css.supports is not supported but there is native touch-action assume it supports
+ // all values. This is the case for IE 10 and 11.
+ touchMap[val] = cssSupports ? window.CSS.supports('touch-action', val) : true;
+ });
+ return touchMap;
+ }
+
+ /**
+ * Recognizer flow explained; *
+ * All recognizers have the initial state of POSSIBLE when a input session starts.
+ * The definition of a input session is from the first input until the last input, with all it's movement in it. *
+ * Example session for mouse-input: mousedown -> mousemove -> mouseup
+ *
+ * On each recognizing cycle (see Manager.recognize) the .recognize() method is executed
+ * which determines with state it should be.
+ *
+ * If the recognizer has the state FAILED, CANCELLED or RECOGNIZED (equals ENDED), it is reset to
+ * POSSIBLE to give it another change on the next cycle.
+ *
+ * Possible
+ * |
+ * +-----+---------------+
+ * | |
+ * +-----+-----+ |
+ * | | |
+ * Failed Cancelled |
+ * +-------+------+
+ * | |
+ * Recognized Began
+ * |
+ * Changed
+ * |
+ * Ended/Recognized
+ */
+ var STATE_POSSIBLE = 1;
+ var STATE_BEGAN = 2;
+ var STATE_CHANGED = 4;
+ var STATE_ENDED = 8;
+ var STATE_RECOGNIZED = STATE_ENDED;
+ var STATE_CANCELLED = 16;
+ var STATE_FAILED = 32;
+
+ /**
+ * Recognizer
+ * Every recognizer needs to extend from this class.
+ * @constructor
+ * @param {Object} options
+ */
+ function Recognizer(options) {
+ this.options = assign({}, this.defaults, options || {});
+
+ this.id = uniqueId();
+
+ this.manager = null;
+
+ // default is enable true
+ this.options.enable = ifUndefined(this.options.enable, true);
+
+ this.state = STATE_POSSIBLE;
+
+ this.simultaneous = {};
+ this.requireFail = [];
+ }
+
+ Recognizer.prototype = {
+ /**
+ * @virtual
+ * @type {Object}
+ */
+ defaults: {},
+
+ /**
+ * set options
+ * @param {Object} options
+ * @return {Recognizer}
+ */
+ set: function(options) {
+ assign(this.options, options);
+
+ // also update the touchAction, in case something changed about the directions/enabled state
+ this.manager && this.manager.touchAction.update();
+ return this;
+ },
+
+ /**
+ * recognize simultaneous with an other recognizer.
+ * @param {Recognizer} otherRecognizer
+ * @returns {Recognizer} this
+ */
+ recognizeWith: function(otherRecognizer) {
+ if (invokeArrayArg(otherRecognizer, 'recognizeWith', this)) {
+ return this;
+ }
+
+ var simultaneous = this.simultaneous;
+ otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
+ if (!simultaneous[otherRecognizer.id]) {
+ simultaneous[otherRecognizer.id] = otherRecognizer;
+ otherRecognizer.recognizeWith(this);
+ }
+ return this;
+ },
+
+ /**
+ * drop the simultaneous link. it doesnt remove the link on the other recognizer.
+ * @param {Recognizer} otherRecognizer
+ * @returns {Recognizer} this
+ */
+ dropRecognizeWith: function(otherRecognizer) {
+ if (invokeArrayArg(otherRecognizer, 'dropRecognizeWith', this)) {
+ return this;
+ }
+
+ otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
+ delete this.simultaneous[otherRecognizer.id];
+ return this;
+ },
+
+ /**
+ * recognizer can only run when an other is failing
+ * @param {Recognizer} otherRecognizer
+ * @returns {Recognizer} this
+ */
+ requireFailure: function(otherRecognizer) {
+ if (invokeArrayArg(otherRecognizer, 'requireFailure', this)) {
+ return this;
+ }
+
+ var requireFail = this.requireFail;
+ otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
+ if (inArray(requireFail, otherRecognizer) === -1) {
+ requireFail.push(otherRecognizer);
+ otherRecognizer.requireFailure(this);
+ }
+ return this;
+ },
+
+ /**
+ * drop the requireFailure link. it does not remove the link on the other recognizer.
+ * @param {Recognizer} otherRecognizer
+ * @returns {Recognizer} this
+ */
+ dropRequireFailure: function(otherRecognizer) {
+ if (invokeArrayArg(otherRecognizer, 'dropRequireFailure', this)) {
+ return this;
+ }
+
+ otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
+ var index = inArray(this.requireFail, otherRecognizer);
+ if (index > -1) {
+ this.requireFail.splice(index, 1);
+ }
+ return this;
+ },
+
+ /**
+ * has require failures boolean
+ * @returns {boolean}
+ */
+ hasRequireFailures: function() {
+ return this.requireFail.length > 0;
+ },
+
+ /**
+ * if the recognizer can recognize simultaneous with an other recognizer
+ * @param {Recognizer} otherRecognizer
+ * @returns {Boolean}
+ */
+ canRecognizeWith: function(otherRecognizer) {
+ return !!this.simultaneous[otherRecognizer.id];
+ },
+
+ /**
+ * You should use `tryEmit` instead of `emit` directly to check
+ * that all the needed recognizers has failed before emitting.
+ * @param {Object} input
+ */
+ emit: function(input) {
+ var self = this;
+ var state = this.state;
+
+ function emit(event) {
+ self.manager.emit(event, input);
+ }
+
+ // 'panstart' and 'panmove'
+ if (state < STATE_ENDED) {
+ emit(self.options.event + stateStr(state));
+ }
+
+ emit(self.options.event); // simple 'eventName' events
+
+ if (input.additionalEvent) { // additional event(panleft, panright, pinchin, pinchout...)
+ emit(input.additionalEvent);
+ }
+
+ // panend and pancancel
+ if (state >= STATE_ENDED) {
+ emit(self.options.event + stateStr(state));
+ }
+ },
+
+ /**
+ * Check that all the require failure recognizers has failed,
+ * if true, it emits a gesture event,
+ * otherwise, setup the state to FAILED.
+ * @param {Object} input
+ */
+ tryEmit: function(input) {
+ if (this.canEmit()) {
+ return this.emit(input);
+ }
+ // it's failing anyway
+ this.state = STATE_FAILED;
+ },
+
+ /**
+ * can we emit?
+ * @returns {boolean}
+ */
+ canEmit: function() {
+ var i = 0;
+ while (i < this.requireFail.length) {
+ if (!(this.requireFail[i].state & (STATE_FAILED | STATE_POSSIBLE))) {
+ return false;
+ }
+ i++;
+ }
+ return true;
+ },
+
+ /**
+ * update the recognizer
+ * @param {Object} inputData
+ */
+ recognize: function(inputData) {
+ // make a new copy of the inputData
+ // so we can change the inputData without messing up the other recognizers
+ var inputDataClone = assign({}, inputData);
+
+ // is is enabled and allow recognizing?
+ if (!boolOrFn(this.options.enable, [this, inputDataClone])) {
+ this.reset();
+ this.state = STATE_FAILED;
+ return;
+ }
+
+ // reset when we've reached the end
+ if (this.state & (STATE_RECOGNIZED | STATE_CANCELLED | STATE_FAILED)) {
+ this.state = STATE_POSSIBLE;
+ }
+
+ this.state = this.process(inputDataClone);
+
+ // the recognizer has recognized a gesture
+ // so trigger an event
+ if (this.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED | STATE_CANCELLED)) {
+ this.tryEmit(inputDataClone);
+ }
+ },
+
+ /**
+ * return the state of the recognizer
+ * the actual recognizing happens in this method
+ * @virtual
+ * @param {Object} inputData
+ * @returns {Const} STATE
+ */
+ process: function(inputData) { }, // jshint ignore:line
+
+ /**
+ * return the preferred touch-action
+ * @virtual
+ * @returns {Array}
+ */
+ getTouchAction: function() { },
+
+ /**
+ * called when the gesture isn't allowed to recognize
+ * like when another is being recognized or it is disabled
+ * @virtual
+ */
+ reset: function() { }
+ };
+
+ /**
+ * get a usable string, used as event postfix
+ * @param {Const} state
+ * @returns {String} state
+ */
+ function stateStr(state) {
+ if (state & STATE_CANCELLED) {
+ return 'cancel';
+ } else if (state & STATE_ENDED) {
+ return 'end';
+ } else if (state & STATE_CHANGED) {
+ return 'move';
+ } else if (state & STATE_BEGAN) {
+ return 'start';
+ }
+ return '';
+ }
+
+ /**
+ * direction cons to string
+ * @param {Const} direction
+ * @returns {String}
+ */
+ function directionStr(direction) {
+ if (direction == DIRECTION_DOWN) {
+ return 'down';
+ } else if (direction == DIRECTION_UP) {
+ return 'up';
+ } else if (direction == DIRECTION_LEFT) {
+ return 'left';
+ } else if (direction == DIRECTION_RIGHT) {
+ return 'right';
+ }
+ return '';
+ }
+
+ /**
+ * get a recognizer by name if it is bound to a manager
+ * @param {Recognizer|String} otherRecognizer
+ * @param {Recognizer} recognizer
+ * @returns {Recognizer}
+ */
+ function getRecognizerByNameIfManager(otherRecognizer, recognizer) {
+ var manager = recognizer.manager;
+ if (manager) {
+ return manager.get(otherRecognizer);
+ }
+ return otherRecognizer;
+ }
+
+ /**
+ * This recognizer is just used as a base for the simple attribute recognizers.
+ * @constructor
+ * @extends Recognizer
+ */
+ function AttrRecognizer() {
+ Recognizer.apply(this, arguments);
+ }
+
+ inherit(AttrRecognizer, Recognizer, {
+ /**
+ * @namespace
+ * @memberof AttrRecognizer
+ */
+ defaults: {
+ /**
+ * @type {Number}
+ * @default 1
+ */
+ pointers: 1
+ },
+
+ /**
+ * Used to check if it the recognizer receives valid input, like input.distance > 10.
+ * @memberof AttrRecognizer
+ * @param {Object} input
+ * @returns {Boolean} recognized
+ */
+ attrTest: function(input) {
+ var optionPointers = this.options.pointers;
+ return optionPointers === 0 || input.pointers.length === optionPointers;
+ },
+
+ /**
+ * Process the input and return the state for the recognizer
+ * @memberof AttrRecognizer
+ * @param {Object} input
+ * @returns {*} State
+ */
+ process: function(input) {
+ var state = this.state;
+ var eventType = input.eventType;
+
+ var isRecognized = state & (STATE_BEGAN | STATE_CHANGED);
+ var isValid = this.attrTest(input);
+
+ // on cancel input and we've recognized before, return STATE_CANCELLED
+ if (isRecognized && (eventType & INPUT_CANCEL || !isValid)) {
+ return state | STATE_CANCELLED;
+ } else if (isRecognized || isValid) {
+ if (eventType & INPUT_END) {
+ return state | STATE_ENDED;
+ } else if (!(state & STATE_BEGAN)) {
+ return STATE_BEGAN;
+ }
+ return state | STATE_CHANGED;
+ }
+ return STATE_FAILED;
+ }
+ });
+
+ /**
+ * Pan
+ * Recognized when the pointer is down and moved in the allowed direction.
+ * @constructor
+ * @extends AttrRecognizer
+ */
+ function PanRecognizer() {
+ AttrRecognizer.apply(this, arguments);
+
+ this.pX = null;
+ this.pY = null;
+ }
+
+ inherit(PanRecognizer, AttrRecognizer, {
+ /**
+ * @namespace
+ * @memberof PanRecognizer
+ */
+ defaults: {
+ event: 'pan',
+ threshold: 10,
+ pointers: 1,
+ direction: DIRECTION_ALL
+ },
+
+ getTouchAction: function() {
+ var direction = this.options.direction;
+ var actions = [];
+ if (direction & DIRECTION_HORIZONTAL) {
+ actions.push(TOUCH_ACTION_PAN_Y);
+ }
+ if (direction & DIRECTION_VERTICAL) {
+ actions.push(TOUCH_ACTION_PAN_X);
+ }
+ return actions;
+ },
+
+ directionTest: function(input) {
+ var options = this.options;
+ var hasMoved = true;
+ var distance = input.distance;
+ var direction = input.direction;
+ var x = input.deltaX;
+ var y = input.deltaY;
+
+ // lock to axis?
+ if (!(direction & options.direction)) {
+ if (options.direction & DIRECTION_HORIZONTAL) {
+ direction = (x === 0) ? DIRECTION_NONE : (x < 0) ? DIRECTION_LEFT : DIRECTION_RIGHT;
+ hasMoved = x != this.pX;
+ distance = Math.abs(input.deltaX);
+ } else {
+ direction = (y === 0) ? DIRECTION_NONE : (y < 0) ? DIRECTION_UP : DIRECTION_DOWN;
+ hasMoved = y != this.pY;
+ distance = Math.abs(input.deltaY);
+ }
+ }
+ input.direction = direction;
+ return hasMoved && distance > options.threshold && direction & options.direction;
+ },
+
+ attrTest: function(input) {
+ return AttrRecognizer.prototype.attrTest.call(this, input) &&
+ (this.state & STATE_BEGAN || (!(this.state & STATE_BEGAN) && this.directionTest(input)));
+ },
+
+ emit: function(input) {
+
+ this.pX = input.deltaX;
+ this.pY = input.deltaY;
+
+ var direction = directionStr(input.direction);
+
+ if (direction) {
+ input.additionalEvent = this.options.event + direction;
+ }
+ this._super.emit.call(this, input);
+ }
+ });
+
+ /**
+ * Pinch
+ * Recognized when two or more pointers are moving toward (zoom-in) or away from each other (zoom-out).
+ * @constructor
+ * @extends AttrRecognizer
+ */
+ function PinchRecognizer() {
+ AttrRecognizer.apply(this, arguments);
+ }
+
+ inherit(PinchRecognizer, AttrRecognizer, {
+ /**
+ * @namespace
+ * @memberof PinchRecognizer
+ */
+ defaults: {
+ event: 'pinch',
+ threshold: 0,
+ pointers: 2
+ },
+
+ getTouchAction: function() {
+ return [TOUCH_ACTION_NONE];
+ },
+
+ attrTest: function(input) {
+ return this._super.attrTest.call(this, input) &&
+ (Math.abs(input.scale - 1) > this.options.threshold || this.state & STATE_BEGAN);
+ },
+
+ emit: function(input) {
+ if (input.scale !== 1) {
+ var inOut = input.scale < 1 ? 'in' : 'out';
+ input.additionalEvent = this.options.event + inOut;
+ }
+ this._super.emit.call(this, input);
+ }
+ });
+
+ /**
+ * Press
+ * Recognized when the pointer is down for x ms without any movement.
+ * @constructor
+ * @extends Recognizer
+ */
+ function PressRecognizer() {
+ Recognizer.apply(this, arguments);
+
+ this._timer = null;
+ this._input = null;
+ }
+
+ inherit(PressRecognizer, Recognizer, {
+ /**
+ * @namespace
+ * @memberof PressRecognizer
+ */
+ defaults: {
+ event: 'press',
+ pointers: 1,
+ time: 251, // minimal time of the pointer to be pressed
+ threshold: 9 // a minimal movement is ok, but keep it low
+ },
+
+ getTouchAction: function() {
+ return [TOUCH_ACTION_AUTO];
+ },
+
+ process: function(input) {
+ var options = this.options;
+ var validPointers = input.pointers.length === options.pointers;
+ var validMovement = input.distance < options.threshold;
+ var validTime = input.deltaTime > options.time;
+
+ this._input = input;
+
+ // we only allow little movement
+ // and we've reached an end event, so a tap is possible
+ if (!validMovement || !validPointers || (input.eventType & (INPUT_END | INPUT_CANCEL) && !validTime)) {
+ this.reset();
+ } else if (input.eventType & INPUT_START) {
+ this.reset();
+ this._timer = setTimeoutContext(function() {
+ this.state = STATE_RECOGNIZED;
+ this.tryEmit();
+ }, options.time, this);
+ } else if (input.eventType & INPUT_END) {
+ return STATE_RECOGNIZED;
+ }
+ return STATE_FAILED;
+ },
+
+ reset: function() {
+ clearTimeout(this._timer);
+ },
+
+ emit: function(input) {
+ if (this.state !== STATE_RECOGNIZED) {
+ return;
+ }
+
+ if (input && (input.eventType & INPUT_END)) {
+ this.manager.emit(this.options.event + 'up', input);
+ } else {
+ this._input.timeStamp = now();
+ this.manager.emit(this.options.event, this._input);
+ }
+ }
+ });
+
+ /**
+ * Rotate
+ * Recognized when two or more pointer are moving in a circular motion.
+ * @constructor
+ * @extends AttrRecognizer
+ */
+ function RotateRecognizer() {
+ AttrRecognizer.apply(this, arguments);
+ }
+
+ inherit(RotateRecognizer, AttrRecognizer, {
+ /**
+ * @namespace
+ * @memberof RotateRecognizer
+ */
+ defaults: {
+ event: 'rotate',
+ threshold: 0,
+ pointers: 2
+ },
+
+ getTouchAction: function() {
+ return [TOUCH_ACTION_NONE];
+ },
+
+ attrTest: function(input) {
+ return this._super.attrTest.call(this, input) &&
+ (Math.abs(input.rotation) > this.options.threshold || this.state & STATE_BEGAN);
+ }
+ });
+
+ /**
+ * Swipe
+ * Recognized when the pointer is moving fast (velocity), with enough distance in the allowed direction.
+ * @constructor
+ * @extends AttrRecognizer
+ */
+ function SwipeRecognizer() {
+ AttrRecognizer.apply(this, arguments);
+ }
+
+ inherit(SwipeRecognizer, AttrRecognizer, {
+ /**
+ * @namespace
+ * @memberof SwipeRecognizer
+ */
+ defaults: {
+ event: 'swipe',
+ threshold: 10,
+ velocity: 0.3,
+ direction: DIRECTION_HORIZONTAL | DIRECTION_VERTICAL,
+ pointers: 1
+ },
+
+ getTouchAction: function() {
+ return PanRecognizer.prototype.getTouchAction.call(this);
+ },
+
+ attrTest: function(input) {
+ var direction = this.options.direction;
+ var velocity;
+
+ if (direction & (DIRECTION_HORIZONTAL | DIRECTION_VERTICAL)) {
+ velocity = input.overallVelocity;
+ } else if (direction & DIRECTION_HORIZONTAL) {
+ velocity = input.overallVelocityX;
+ } else if (direction & DIRECTION_VERTICAL) {
+ velocity = input.overallVelocityY;
+ }
+
+ return this._super.attrTest.call(this, input) &&
+ direction & input.offsetDirection &&
+ input.distance > this.options.threshold &&
+ input.maxPointers == this.options.pointers &&
+ abs(velocity) > this.options.velocity && input.eventType & INPUT_END;
+ },
+
+ emit: function(input) {
+ var direction = directionStr(input.offsetDirection);
+ if (direction) {
+ this.manager.emit(this.options.event + direction, input);
+ }
+
+ this.manager.emit(this.options.event, input);
+ }
+ });
+
+ /**
+ * A tap is ecognized when the pointer is doing a small tap/click. Multiple taps are recognized if they occur
+ * between the given interval and position. The delay option can be used to recognize multi-taps without firing
+ * a single tap.
+ *
+ * The eventData from the emitted event contains the property `tapCount`, which contains the amount of
+ * multi-taps being recognized.
+ * @constructor
+ * @extends Recognizer
+ */
+ function TapRecognizer() {
+ Recognizer.apply(this, arguments);
+
+ // previous time and center,
+ // used for tap counting
+ this.pTime = false;
+ this.pCenter = false;
+
+ this._timer = null;
+ this._input = null;
+ this.count = 0;
+ }
+
+ inherit(TapRecognizer, Recognizer, {
+ /**
+ * @namespace
+ * @memberof PinchRecognizer
+ */
+ defaults: {
+ event: 'tap',
+ pointers: 1,
+ taps: 1,
+ interval: 300, // max time between the multi-tap taps
+ time: 250, // max time of the pointer to be down (like finger on the screen)
+ threshold: 9, // a minimal movement is ok, but keep it low
+ posThreshold: 10 // a multi-tap can be a bit off the initial position
+ },
+
+ getTouchAction: function() {
+ return [TOUCH_ACTION_MANIPULATION];
+ },
+
+ process: function(input) {
+ var options = this.options;
+
+ var validPointers = input.pointers.length === options.pointers;
+ var validMovement = input.distance < options.threshold;
+ var validTouchTime = input.deltaTime < options.time;
+
+ this.reset();
+
+ if ((input.eventType & INPUT_START) && (this.count === 0)) {
+ return this.failTimeout();
+ }
+
+ // we only allow little movement
+ // and we've reached an end event, so a tap is possible
+ if (validMovement && validTouchTime && validPointers) {
+ if (input.eventType != INPUT_END) {
+ return this.failTimeout();
+ }
+
+ var validInterval = this.pTime ? (input.timeStamp - this.pTime < options.interval) : true;
+ var validMultiTap = !this.pCenter || getDistance(this.pCenter, input.center) < options.posThreshold;
+
+ this.pTime = input.timeStamp;
+ this.pCenter = input.center;
+
+ if (!validMultiTap || !validInterval) {
+ this.count = 1;
+ } else {
+ this.count += 1;
+ }
+
+ this._input = input;
+
+ // if tap count matches we have recognized it,
+ // else it has began recognizing...
+ var tapCount = this.count % options.taps;
+ if (tapCount === 0) {
+ // no failing requirements, immediately trigger the tap event
+ // or wait as long as the multitap interval to trigger
+ if (!this.hasRequireFailures()) {
+ return STATE_RECOGNIZED;
+ } else {
+ this._timer = setTimeoutContext(function() {
+ this.state = STATE_RECOGNIZED;
+ this.tryEmit();
+ }, options.interval, this);
+ return STATE_BEGAN;
+ }
+ }
+ }
+ return STATE_FAILED;
+ },
+
+ failTimeout: function() {
+ this._timer = setTimeoutContext(function() {
+ this.state = STATE_FAILED;
+ }, this.options.interval, this);
+ return STATE_FAILED;
+ },
+
+ reset: function() {
+ clearTimeout(this._timer);
+ },
+
+ emit: function() {
+ if (this.state == STATE_RECOGNIZED) {
+ this._input.tapCount = this.count;
+ this.manager.emit(this.options.event, this._input);
+ }
+ }
+ });
+
+ /**
+ * Simple way to create a manager with a default set of recognizers.
+ * @param {HTMLElement} element
+ * @param {Object} [options]
+ * @constructor
+ */
+ function Hammer(element, options) {
+ options = options || {};
+ options.recognizers = ifUndefined(options.recognizers, Hammer.defaults.preset);
+ return new Manager(element, options);
+ }
+
+ /**
+ * @const {string}
+ */
+ Hammer.VERSION = '2.0.7';
+
+ /**
+ * default settings
+ * @namespace
+ */
+ Hammer.defaults = {
+ /**
+ * set if DOM events are being triggered.
+ * But this is slower and unused by simple implementations, so disabled by default.
+ * @type {Boolean}
+ * @default false
+ */
+ domEvents: false,
+
+ /**
+ * The value for the touchAction property/fallback.
+ * When set to `compute` it will magically set the correct value based on the added recognizers.
+ * @type {String}
+ * @default compute
+ */
+ touchAction: TOUCH_ACTION_COMPUTE,
+
+ /**
+ * @type {Boolean}
+ * @default true
+ */
+ enable: true,
+
+ /**
+ * EXPERIMENTAL FEATURE -- can be removed/changed
+ * Change the parent input target element.
+ * If Null, then it is being set the to main element.
+ * @type {Null|EventTarget}
+ * @default null
+ */
+ inputTarget: null,
+
+ /**
+ * force an input class
+ * @type {Null|Function}
+ * @default null
+ */
+ inputClass: null,
+
+ /**
+ * Default recognizer setup when calling `Hammer()`
+ * When creating a new Manager these will be skipped.
+ * @type {Array}
+ */
+ preset: [
+ // RecognizerClass, options, [recognizeWith, ...], [requireFailure, ...]
+ [RotateRecognizer, {enable: false}],
+ [PinchRecognizer, {enable: false}, ['rotate']],
+ [SwipeRecognizer, {direction: DIRECTION_HORIZONTAL}],
+ [PanRecognizer, {direction: DIRECTION_HORIZONTAL}, ['swipe']],
+ [TapRecognizer],
+ [TapRecognizer, {event: 'doubletap', taps: 2}, ['tap']],
+ [PressRecognizer]
+ ],
+
+ /**
+ * Some CSS properties can be used to improve the working of Hammer.
+ * Add them to this method and they will be set when creating a new Manager.
+ * @namespace
+ */
+ cssProps: {
+ /**
+ * Disables text selection to improve the dragging gesture. Mainly for desktop browsers.
+ * @type {String}
+ * @default 'none'
+ */
+ userSelect: 'none',
+
+ /**
+ * Disable the Windows Phone grippers when pressing an element.
+ * @type {String}
+ * @default 'none'
+ */
+ touchSelect: 'none',
+
+ /**
+ * Disables the default callout shown when you touch and hold a touch target.
+ * On iOS, when you touch and hold a touch target such as a link, Safari displays
+ * a callout containing information about the link. This property allows you to disable that callout.
+ * @type {String}
+ * @default 'none'
+ */
+ touchCallout: 'none',
+
+ /**
+ * Specifies whether zooming is enabled. Used by IE10>
+ * @type {String}
+ * @default 'none'
+ */
+ contentZooming: 'none',
+
+ /**
+ * Specifies that an entire element should be draggable instead of its contents. Mainly for desktop browsers.
+ * @type {String}
+ * @default 'none'
+ */
+ userDrag: 'none',
+
+ /**
+ * Overrides the highlight color shown when the user taps a link or a JavaScript
+ * clickable element in iOS. This property obeys the alpha value, if specified.
+ * @type {String}
+ * @default 'rgba(0,0,0,0)'
+ */
+ tapHighlightColor: 'rgba(0,0,0,0)'
+ }
+ };
+
+ var STOP = 1;
+ var FORCED_STOP = 2;
+
+ /**
+ * Manager
+ * @param {HTMLElement} element
+ * @param {Object} [options]
+ * @constructor
+ */
+ function Manager(element, options) {
+ this.options = assign({}, Hammer.defaults, options || {});
+
+ this.options.inputTarget = this.options.inputTarget || element;
+
+ this.handlers = {};
+ this.session = {};
+ this.recognizers = [];
+ this.oldCssProps = {};
+
+ this.element = element;
+ this.input = createInputInstance(this);
+ this.touchAction = new TouchAction(this, this.options.touchAction);
+
+ toggleCssProps(this, true);
+
+ each(this.options.recognizers, function(item) {
+ var recognizer = this.add(new (item[0])(item[1]));
+ item[2] && recognizer.recognizeWith(item[2]);
+ item[3] && recognizer.requireFailure(item[3]);
+ }, this);
+ }
+
+ Manager.prototype = {
+ /**
+ * set options
+ * @param {Object} options
+ * @returns {Manager}
+ */
+ set: function(options) {
+ assign(this.options, options);
+
+ // Options that need a little more setup
+ if (options.touchAction) {
+ this.touchAction.update();
+ }
+ if (options.inputTarget) {
+ // Clean up existing event listeners and reinitialize
+ this.input.destroy();
+ this.input.target = options.inputTarget;
+ this.input.init();
+ }
+ return this;
+ },
+
+ /**
+ * stop recognizing for this session.
+ * This session will be discarded, when a new [input]start event is fired.
+ * When forced, the recognizer cycle is stopped immediately.
+ * @param {Boolean} [force]
+ */
+ stop: function(force) {
+ this.session.stopped = force ? FORCED_STOP : STOP;
+ },
+
+ /**
+ * run the recognizers!
+ * called by the inputHandler function on every movement of the pointers (touches)
+ * it walks through all the recognizers and tries to detect the gesture that is being made
+ * @param {Object} inputData
+ */
+ recognize: function(inputData) {
+ var session = this.session;
+ if (session.stopped) {
+ return;
+ }
+
+ // run the touch-action polyfill
+ this.touchAction.preventDefaults(inputData);
+
+ var recognizer;
+ var recognizers = this.recognizers;
+
+ // this holds the recognizer that is being recognized.
+ // so the recognizer's state needs to be BEGAN, CHANGED, ENDED or RECOGNIZED
+ // if no recognizer is detecting a thing, it is set to `null`
+ var curRecognizer = session.curRecognizer;
+
+ // reset when the last recognizer is recognized
+ // or when we're in a new session
+ if (!curRecognizer || (curRecognizer && curRecognizer.state & STATE_RECOGNIZED)) {
+ curRecognizer = session.curRecognizer = null;
+ }
+
+ var i = 0;
+ while (i < recognizers.length) {
+ recognizer = recognizers[i];
+
+ // find out if we are allowed try to recognize the input for this one.
+ // 1. allow if the session is NOT forced stopped (see the .stop() method)
+ // 2. allow if we still haven't recognized a gesture in this session, or the this recognizer is the one
+ // that is being recognized.
+ // 3. allow if the recognizer is allowed to run simultaneous with the current recognized recognizer.
+ // this can be setup with the `recognizeWith()` method on the recognizer.
+ if (session.stopped !== FORCED_STOP && ( // 1
+ !curRecognizer || recognizer == curRecognizer || // 2
+ recognizer.canRecognizeWith(curRecognizer))) { // 3
+ recognizer.recognize(inputData);
+ } else {
+ recognizer.reset();
+ }
+
+ // if the recognizer has been recognizing the input as a valid gesture, we want to store this one as the
+ // current active recognizer. but only if we don't already have an active recognizer
+ if (!curRecognizer && recognizer.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED)) {
+ curRecognizer = session.curRecognizer = recognizer;
+ }
+ i++;
+ }
+ },
+
+ /**
+ * get a recognizer by its event name.
+ * @param {Recognizer|String} recognizer
+ * @returns {Recognizer|Null}
+ */
+ get: function(recognizer) {
+ if (recognizer instanceof Recognizer) {
+ return recognizer;
+ }
+
+ var recognizers = this.recognizers;
+ for (var i = 0; i < recognizers.length; i++) {
+ if (recognizers[i].options.event == recognizer) {
+ return recognizers[i];
+ }
+ }
+ return null;
+ },
+
+ /**
+ * add a recognizer to the manager
+ * existing recognizers with the same event name will be removed
+ * @param {Recognizer} recognizer
+ * @returns {Recognizer|Manager}
+ */
+ add: function(recognizer) {
+ if (invokeArrayArg(recognizer, 'add', this)) {
+ return this;
+ }
+
+ // remove existing
+ var existing = this.get(recognizer.options.event);
+ if (existing) {
+ this.remove(existing);
+ }
+
+ this.recognizers.push(recognizer);
+ recognizer.manager = this;
+
+ this.touchAction.update();
+ return recognizer;
+ },
+
+ /**
+ * remove a recognizer by name or instance
+ * @param {Recognizer|String} recognizer
+ * @returns {Manager}
+ */
+ remove: function(recognizer) {
+ if (invokeArrayArg(recognizer, 'remove', this)) {
+ return this;
+ }
+
+ recognizer = this.get(recognizer);
+
+ // let's make sure this recognizer exists
+ if (recognizer) {
+ var recognizers = this.recognizers;
+ var index = inArray(recognizers, recognizer);
+
+ if (index !== -1) {
+ recognizers.splice(index, 1);
+ this.touchAction.update();
+ }
+ }
+
+ return this;
+ },
+
+ /**
+ * bind event
+ * @param {String} events
+ * @param {Function} handler
+ * @returns {EventEmitter} this
+ */
+ on: function(events, handler) {
+ if (events === undefined) {
+ return;
+ }
+ if (handler === undefined) {
+ return;
+ }
+
+ var handlers = this.handlers;
+ each(splitStr(events), function(event) {
+ handlers[event] = handlers[event] || [];
+ handlers[event].push(handler);
+ });
+ return this;
+ },
+
+ /**
+ * unbind event, leave emit blank to remove all handlers
+ * @param {String} events
+ * @param {Function} [handler]
+ * @returns {EventEmitter} this
+ */
+ off: function(events, handler) {
+ if (events === undefined) {
+ return;
+ }
+
+ var handlers = this.handlers;
+ each(splitStr(events), function(event) {
+ if (!handler) {
+ delete handlers[event];
+ } else {
+ handlers[event] && handlers[event].splice(inArray(handlers[event], handler), 1);
+ }
+ });
+ return this;
+ },
+
+ /**
+ * emit event to the listeners
+ * @param {String} event
+ * @param {Object} data
+ */
+ emit: function(event, data) {
+ // we also want to trigger dom events
+ if (this.options.domEvents) {
+ triggerDomEvent(event, data);
+ }
+
+ // no handlers, so skip it all
+ var handlers = this.handlers[event] && this.handlers[event].slice();
+ if (!handlers || !handlers.length) {
+ return;
+ }
+
+ data.type = event;
+ data.preventDefault = function() {
+ data.srcEvent.preventDefault();
+ };
+
+ var i = 0;
+ while (i < handlers.length) {
+ handlers[i](data);
+ i++;
+ }
+ },
+
+ /**
+ * destroy the manager and unbinds all events
+ * it doesn't unbind dom events, that is the user own responsibility
+ */
+ destroy: function() {
+ this.element && toggleCssProps(this, false);
+
+ this.handlers = {};
+ this.session = {};
+ this.input.destroy();
+ this.element = null;
+ }
+ };
+
+ /**
+ * add/remove the css properties as defined in manager.options.cssProps
+ * @param {Manager} manager
+ * @param {Boolean} add
+ */
+ function toggleCssProps(manager, add) {
+ var element = manager.element;
+ if (!element.style) {
+ return;
+ }
+ var prop;
+ each(manager.options.cssProps, function(value, name) {
+ prop = prefixed(element.style, name);
+ if (add) {
+ manager.oldCssProps[prop] = element.style[prop];
+ element.style[prop] = value;
+ } else {
+ element.style[prop] = manager.oldCssProps[prop] || '';
+ }
+ });
+ if (!add) {
+ manager.oldCssProps = {};
+ }
+ }
+
+ /**
+ * trigger dom event
+ * @param {String} event
+ * @param {Object} data
+ */
+ function triggerDomEvent(event, data) {
+ var gestureEvent = document.createEvent('Event');
+ gestureEvent.initEvent(event, true, true);
+ gestureEvent.gesture = data;
+ data.target.dispatchEvent(gestureEvent);
+ }
+
+ assign(Hammer, {
+ INPUT_START: INPUT_START,
+ INPUT_MOVE: INPUT_MOVE,
+ INPUT_END: INPUT_END,
+ INPUT_CANCEL: INPUT_CANCEL,
+
+ STATE_POSSIBLE: STATE_POSSIBLE,
+ STATE_BEGAN: STATE_BEGAN,
+ STATE_CHANGED: STATE_CHANGED,
+ STATE_ENDED: STATE_ENDED,
+ STATE_RECOGNIZED: STATE_RECOGNIZED,
+ STATE_CANCELLED: STATE_CANCELLED,
+ STATE_FAILED: STATE_FAILED,
+
+ DIRECTION_NONE: DIRECTION_NONE,
+ DIRECTION_LEFT: DIRECTION_LEFT,
+ DIRECTION_RIGHT: DIRECTION_RIGHT,
+ DIRECTION_UP: DIRECTION_UP,
+ DIRECTION_DOWN: DIRECTION_DOWN,
+ DIRECTION_HORIZONTAL: DIRECTION_HORIZONTAL,
+ DIRECTION_VERTICAL: DIRECTION_VERTICAL,
+ DIRECTION_ALL: DIRECTION_ALL,
+
+ Manager: Manager,
+ Input: Input,
+ TouchAction: TouchAction,
+
+ TouchInput: TouchInput,
+ MouseInput: MouseInput,
+ PointerEventInput: PointerEventInput,
+ TouchMouseInput: TouchMouseInput,
+ SingleTouchInput: SingleTouchInput,
+
+ Recognizer: Recognizer,
+ AttrRecognizer: AttrRecognizer,
+ Tap: TapRecognizer,
+ Pan: PanRecognizer,
+ Swipe: SwipeRecognizer,
+ Pinch: PinchRecognizer,
+ Rotate: RotateRecognizer,
+ Press: PressRecognizer,
+
+ on: addEventListeners,
+ off: removeEventListeners,
+ each: each,
+ merge: merge,
+ extend: extend,
+ assign: assign,
+ inherit: inherit,
+ bindFn: bindFn,
+ prefixed: prefixed
+ });
+
+ // jquery.hammer.js
+ // This jQuery plugin is just a small wrapper around the Hammer() class.
+ // It also extends the Manager.emit method by triggering jQuery events.
+ // $(element).hammer(options).bind("pan", myPanHandler);
+ // The Hammer instance is stored at $element.data("hammer").
+ // https://github.com/hammerjs/jquery.hammer.js
+
+ (function($, Hammer) {
+ function hammerify(el, options) {
+ var $el = $(el);
+ if (!$el.data('hammer')) {
+ $el.data('hammer', new Hammer($el[0], options));
+ }
+ }
+
+ $.fn.hammer = function(options) {
+ return this.each(function() {
+ hammerify(this, options);
+ });
+ };
+
+ // extend the emit method to also trigger jQuery events
+ Hammer.Manager.prototype.emit = (function(originalEmit) {
+ return function(type, data) {
+ originalEmit.call(this, type, data);
+ $(this.element).trigger({
+ type: type,
+ gesture: data
+ });
+ };
+ })(Hammer.Manager.prototype.emit);
+ })($, Hammer);
+
+ module.exports = UI.Hammer = Hammer;
+
+
+/***/ },
+/* 4 */
+/***/ function(module, exports, __webpack_require__) {
+
+ 'use strict';
+
+ var UI = __webpack_require__(2);
+
+ /**
+ * Add to Homescreen v3.2.2
+ * (c) 2015 Matteo Spinelli
+ * @license: http://cubiq.org/license
+ */
+
+ // Check for addEventListener browser support (prevent errors in IE<9)
+ var _eventListener = 'addEventListener' in window;
+
+ // Check if document is loaded, needed by autostart
+ var _DOMReady = false;
+ if (document.readyState === 'complete') {
+ _DOMReady = true;
+ } else if (_eventListener) {
+ window.addEventListener('load', loaded, false);
+ }
+
+ function loaded() {
+ window.removeEventListener('load', loaded, false);
+ _DOMReady = true;
+ }
+
+ // regex used to detect if app has been added to the homescreen
+ var _reSmartURL = /\/ath(\/)?$/;
+ var _reQueryString = /([\?&]ath=[^&]*$|&ath=[^&]*(&))/;
+
+ // singleton
+ var _instance;
+ function ath(options) {
+ _instance = _instance || new ath.Class(options);
+
+ return _instance;
+ }
+
+ // message in all supported languages
+ ath.intl = {
+ en_us: {
+ ios: 'To add this web app to the home screen: tap %icon and then Add to Home Screen.',
+ android: 'To add this web app to the home screen open the browser option menu and tap on Add to homescreen. The menu can be accessed by pressing the menu hardware button if your device has one, or by tapping the top right menu icon .'
+ },
+
+ zh_cn: {
+ ios: '如要把应用程式加至主屏幕,请点击%icon, 然后加至主屏幕',
+ android: 'To add this web app to the home screen open the browser option menu and tap on Add to homescreen. The menu can be accessed by pressing the menu hardware button if your device has one, or by tapping the top right menu icon .'
+ },
+
+ zh_tw: {
+ ios: '如要把應用程式加至主屏幕, 請點擊%icon, 然後加至主屏幕.',
+ android: 'To add this web app to the home screen open the browser option menu and tap on Add to homescreen. The menu can be accessed by pressing the menu hardware button if your device has one, or by tapping the top right menu icon .'
+ }
+ };
+
+ // Add 2 characters language support (Android mostly)
+ for (var lang in ath.intl) {
+ ath.intl[lang.substr(0, 2)] = ath.intl[lang];
+ }
+
+ // default options
+ ath.defaults = {
+ appID: 'org.cubiq.addtohome', // local storage name (no need to change)
+ fontSize: 15, // base font size, used to properly resize the popup based on viewport scale factor
+ debug: false, // override browser checks
+ logging: false, // log reasons for showing or not showing to js console; defaults to true when debug is true
+ modal: false, // prevent further actions until the message is closed
+ mandatory: false, // you can't proceed if you don't add the app to the homescreen
+ autostart: true, // show the message automatically
+ skipFirstVisit: false, // show only to returning visitors (ie: skip the first time you visit)
+ startDelay: 1, // display the message after that many seconds from page load
+ lifespan: 15, // life of the message in seconds
+ displayPace: 1440, // minutes before the message is shown again (0: display every time, default 24 hours)
+ maxDisplayCount: 0, // absolute maximum number of times the message will be shown to the user (0: no limit)
+ icon: true, // add touch icon to the message
+ message: '', // the message can be customized
+ validLocation: [], // list of pages where the message will be shown (array of regexes)
+ onInit: null, // executed on instance creation
+ onShow: null, // executed when the message is shown
+ onRemove: null, // executed when the message is removed
+ onAdd: null, // when the application is launched the first time from the homescreen (guesstimate)
+ onPrivate: null, // executed if user is in private mode
+ privateModeOverride: false, // show the message even in private mode (very rude)
+ detectHomescreen: false // try to detect if the site has been added to the homescreen (false | true | 'hash' | 'queryString' | 'smartURL')
+ };
+
+ // browser info and capability
+ var _ua = window.navigator.userAgent;
+
+ var _nav = window.navigator;
+ _extend(ath, {
+ hasToken: document.location.hash == '#ath' || _reSmartURL.test(document.location.href) || _reQueryString.test(document.location.search),
+ isRetina: window.devicePixelRatio && window.devicePixelRatio > 1,
+ isIDevice: (/iphone|ipod|ipad/i).test(_ua),
+ isMobileChrome: _ua.indexOf('Android') > -1 && (/Chrome\/[.0-9]*/).test(_ua) && _ua.indexOf("Version") == -1,
+ isMobileIE: _ua.indexOf('Windows Phone') > -1,
+ language: _nav.language && _nav.language.toLowerCase().replace('-', '_') || ''
+ });
+
+ // falls back to en_us if language is unsupported
+ ath.language = ath.language && ath.language in ath.intl ? ath.language : 'en_us';
+
+ ath.isMobileSafari = ath.isIDevice && _ua.indexOf('Safari') > -1 && _ua.indexOf('CriOS') < 0;
+ ath.OS = ath.isIDevice ? 'ios' : ath.isMobileChrome ? 'android' : ath.isMobileIE ? 'windows' : 'unsupported';
+
+ ath.OSVersion = _ua.match(/(OS|Android) (\d+[_\.]\d+)/);
+ ath.OSVersion = ath.OSVersion && ath.OSVersion[2] ? +ath.OSVersion[2].replace('_', '.') : 0;
+
+ ath.isStandalone = 'standalone' in window.navigator && window.navigator.standalone;
+ ath.isTablet = (ath.isMobileSafari && _ua.indexOf('iPad') > -1) || (ath.isMobileChrome && _ua.indexOf('Mobile') < 0);
+
+ ath.isCompatible = (ath.isMobileSafari && ath.OSVersion >= 6) || ath.isMobileChrome; // TODO: add winphone
+
+ var _defaultSession = {
+ lastDisplayTime: 0, // last time we displayed the message
+ returningVisitor: false, // is this the first time you visit
+ displayCount: 0, // number of times the message has been shown
+ optedout: false, // has the user opted out
+ added: false // has been actually added to the homescreen
+ };
+
+ ath.removeSession = function(appID) {
+ try {
+ if (!localStorage) {
+ throw new Error('localStorage is not defined');
+ }
+
+ localStorage.removeItem(appID || ath.defaults.appID);
+ } catch (e) {
+ // we are most likely in private mode
+ }
+ };
+
+ ath.doLog = function(logStr) {
+ if (this.options.logging) {
+ console.log(logStr);
+ }
+ };
+
+ ath.Class = function(options) {
+ // class methods
+ this.doLog = ath.doLog;
+
+ // merge default options with user config
+ this.options = _extend({}, ath.defaults);
+ _extend(this.options, options);
+ // override defaults that are dependent on each other
+ if (this.options.debug) {
+ this.options.logging = true;
+ }
+
+ // IE<9 so exit (I hate you, really)
+ if (!_eventListener) {
+ return;
+ }
+
+ // normalize some options
+ this.options.mandatory = this.options.mandatory && ( 'standalone' in window.navigator || this.options.debug );
+ this.options.modal = this.options.modal || this.options.mandatory;
+ if (this.options.mandatory) {
+ this.options.startDelay = -0.5; // make the popup hasty
+ }
+ this.options.detectHomescreen = this.options.detectHomescreen === true ? 'hash' : this.options.detectHomescreen;
+
+ // setup the debug environment
+ if (this.options.debug) {
+ ath.isCompatible = true;
+ ath.OS = typeof this.options.debug == 'string' ? this.options.debug : ath.OS == 'unsupported' ? 'android' : ath.OS;
+ ath.OSVersion = ath.OS == 'ios' ? '8' : '4';
+ }
+
+ // the element the message will be appended to
+ this.container = document.documentElement;
+
+ // load session
+ this.session = this.getItem(this.options.appID);
+ this.session = this.session ? JSON.parse(this.session) : undefined;
+
+ // user most likely came from a direct link containing our token, we don't need it and we remove it
+ if (ath.hasToken && ( !ath.isCompatible || !this.session )) {
+ ath.hasToken = false;
+ _removeToken();
+ }
+
+ // the device is not supported
+ if (!ath.isCompatible) {
+ this.doLog("Add to homescreen: not displaying callout because device not supported");
+ return;
+ }
+
+ this.session = this.session || _defaultSession;
+
+ // check if we can use the local storage
+ try {
+ if (!localStorage) {
+ throw new Error('localStorage is not defined');
+ }
+
+ localStorage.setItem(this.options.appID, JSON.stringify(this.session));
+ ath.hasLocalStorage = true;
+ } catch (e) {
+ // we are most likely in private mode
+ ath.hasLocalStorage = false;
+
+ if (this.options.onPrivate) {
+ this.options.onPrivate.call(this);
+ }
+ }
+
+ // check if this is a valid location
+ var isValidLocation = !this.options.validLocation.length;
+ for (var i = this.options.validLocation.length; i--;) {
+ if (this.options.validLocation[i].test(document.location.href)) {
+ isValidLocation = true;
+ break;
+ }
+ }
+
+ // check compatibility with old versions of add to homescreen. Opt-out if an old session is found
+ if (this.getItem('addToHome')) {
+ this.optOut();
+ }
+
+ // critical errors:
+ if (this.session.optedout) {
+ this.doLog("Add to homescreen: not displaying callout because user opted out");
+ return;
+ }
+ if (this.session.added) {
+ this.doLog("Add to homescreen: not displaying callout because already added to the homescreen");
+ return;
+ }
+ if (!isValidLocation) {
+ this.doLog("Add to homescreen: not displaying callout because not a valid location");
+ return;
+ }
+
+ // check if the app is in stand alone mode
+ if (ath.isStandalone) {
+ // execute the onAdd event if we haven't already
+ if (!this.session.added) {
+ this.session.added = true;
+ this.updateSession();
+
+ if (this.options.onAdd && ath.hasLocalStorage) { // double check on localstorage to avoid multiple calls to the custom event
+ this.options.onAdd.call(this);
+ }
+ }
+
+ this.doLog("Add to homescreen: not displaying callout because in standalone mode");
+ return;
+ }
+
+ // (try to) check if the page has been added to the homescreen
+ if (this.options.detectHomescreen) {
+ // the URL has the token, we are likely coming from the homescreen
+ if (ath.hasToken) {
+ _removeToken(); // we don't actually need the token anymore, we remove it to prevent redistribution
+
+ // this is called the first time the user opens the app from the homescreen
+ if (!this.session.added) {
+ this.session.added = true;
+ this.updateSession();
+
+ if (this.options.onAdd && ath.hasLocalStorage) { // double check on localstorage to avoid multiple calls to the custom event
+ this.options.onAdd.call(this);
+ }
+ }
+
+ this.doLog("Add to homescreen: not displaying callout because URL has token, so we are likely coming from homescreen");
+ return;
+ }
+
+ // URL doesn't have the token, so add it
+ if (this.options.detectHomescreen == 'hash') {
+ history.replaceState('', window.document.title, document.location.href + '#ath');
+ } else if (this.options.detectHomescreen == 'smartURL') {
+ history.replaceState('', window.document.title, document.location.href.replace(/(\/)?$/, '/ath$1'));
+ } else {
+ history.replaceState('', window.document.title, document.location.href + (document.location.search ? '&' : '?' ) + 'ath=');
+ }
+ }
+
+ // check if this is a returning visitor
+ if (!this.session.returningVisitor) {
+ this.session.returningVisitor = true;
+ this.updateSession();
+
+ // we do not show the message if this is your first visit
+ if (this.options.skipFirstVisit) {
+ this.doLog("Add to homescreen: not displaying callout because skipping first visit");
+ return;
+ }
+ }
+
+ // we do no show the message in private mode
+ if (!this.options.privateModeOverride && !ath.hasLocalStorage) {
+ this.doLog("Add to homescreen: not displaying callout because browser is in private mode");
+ return;
+ }
+
+ // all checks passed, ready to display
+ this.ready = true;
+
+ if (this.options.onInit) {
+ this.options.onInit.call(this);
+ }
+
+ if (this.options.autostart) {
+ this.doLog("Add to homescreen: autostart displaying callout");
+ this.show();
+ }
+ };
+
+ ath.Class.prototype = {
+ // event type to method conversion
+ events: {
+ load: '_delayedShow',
+ error: '_delayedShow',
+ orientationchange: 'resize',
+ resize: 'resize',
+ scroll: 'resize',
+ click: 'remove',
+ touchmove: '_preventDefault',
+ transitionend: '_removeElements',
+ webkitTransitionEnd: '_removeElements',
+ MSTransitionEnd: '_removeElements'
+ },
+
+ handleEvent: function(e) {
+ var type = this.events[e.type];
+ if (type) {
+ this[type](e);
+ }
+ },
+
+ show: function(force) {
+ // in autostart mode wait for the document to be ready
+ if (this.options.autostart && !_DOMReady) {
+ setTimeout(this.show.bind(this), 50);
+ // we are not displaying callout because DOM not ready, but don't log that because
+ // it would log too frequently
+ return;
+ }
+
+ // message already on screen
+ if (this.shown) {
+ this.doLog("Add to homescreen: not displaying callout because already shown on screen");
+ return;
+ }
+
+ var now = Date.now();
+ var lastDisplayTime = this.session.lastDisplayTime;
+
+ if (force !== true) {
+ // this is needed if autostart is disabled and you programmatically call the show() method
+ if (!this.ready) {
+ this.doLog("Add to homescreen: not displaying callout because not ready");
+ return;
+ }
+
+ // we obey the display pace (prevent the message to popup too often)
+ if (now - lastDisplayTime < this.options.displayPace * 60000) {
+ this.doLog("Add to homescreen: not displaying callout because displayed recently");
+ return;
+ }
+
+ // obey the maximum number of display count
+ if (this.options.maxDisplayCount && this.session.displayCount >= this.options.maxDisplayCount) {
+ this.doLog("Add to homescreen: not displaying callout because displayed too many times already");
+ return;
+ }
+ }
+
+ this.shown = true;
+
+ // increment the display count
+ this.session.lastDisplayTime = now;
+ this.session.displayCount++;
+ this.updateSession();
+
+ // try to get the highest resolution application icon
+ if (!this.applicationIcon) {
+ if (ath.OS == 'ios') {
+ this.applicationIcon = document.querySelector('head link[rel^=apple-touch-icon][sizes="152x152"],head link[rel^=apple-touch-icon][sizes="144x144"],head link[rel^=apple-touch-icon][sizes="120x120"],head link[rel^=apple-touch-icon][sizes="114x114"],head link[rel^=apple-touch-icon]');
+ } else {
+ this.applicationIcon = document.querySelector('head link[rel^="shortcut icon"][sizes="196x196"],head link[rel^=apple-touch-icon]');
+ }
+ }
+
+ var message = '';
+
+ if (typeof this.options.message == 'object' && ath.language in this.options.message) { // use custom language message
+ message = this.options.message[ath.language][ath.OS];
+ } else if (typeof this.options.message == 'object' && ath.OS in this.options.message) { // use custom os message
+ message = this.options.message[ath.OS];
+ } else if (this.options.message in ath.intl) { // you can force the locale
+ message = ath.intl[this.options.message][ath.OS];
+ } else if (this.options.message !== '') { // use a custom message
+ message = this.options.message;
+ } else if (ath.OS in ath.intl[ath.language]) { // otherwise we use our message
+ message = ath.intl[ath.language][ath.OS];
+ }
+
+ // add the action icon
+ message = '';
+ while (dowCount < this.weekStart + 7) {
+ // NOTE: do % then add 1
+ html += '' +
+ Datepicker.locales[this.language].daysMin[(dowCount++) % 7] +
+ ' ';
+ }
+ html += ' ';
+
+ this.$picker.find('.am-datepicker-days thead').append(html);
+ };
+
+ Datepicker.prototype.fillMonths = function() {
+ var html = '';
+ var i = 0;
+ while (i < 12) {
+ html += '' +
+ Datepicker.locales[this.language].monthsShort[i++] + '';
+ }
+ this.$picker.find('.am-datepicker-months td').append(html);
+ };
+
+ Datepicker.prototype.fill = function() {
+ var d = new Date(this.viewDate);
+ var year = d.getFullYear();
+ var month = d.getMonth();
+ var currentDate = this.date.valueOf();
+
+ var prevMonth = new Date(year, month - 1, 28, 0, 0, 0, 0);
+ var day = DPGlobal
+ .getDaysInMonth(prevMonth.getFullYear(), prevMonth.getMonth());
+
+ var daysSelect = this.$picker
+ .find('.am-datepicker-days .am-datepicker-select');
+
+ if (this.language === 'zh_CN') {
+ daysSelect.text(year + Datepicker.locales[this.language].year[0] +
+ ' ' + Datepicker.locales[this.language].months[month]);
+ } else {
+ daysSelect.text(Datepicker.locales[this.language].months[month] +
+ ' ' + year);
+ }
+
+ prevMonth.setDate(day);
+ prevMonth.setDate(day - (prevMonth.getDay() - this.weekStart + 7) % 7);
+
+ var nextMonth = new Date(prevMonth);
+ nextMonth.setDate(nextMonth.getDate() + 42);
+ nextMonth = nextMonth.valueOf();
+ var html = [];
+
+ var className;
+ var prevY;
+ var prevM;
+
+ while (prevMonth.valueOf() < nextMonth) {
+ if (prevMonth.getDay() === this.weekStart) {
+ html.push('');
+ }
+
+ className = this.onRender(prevMonth, 0);
+ prevY = prevMonth.getFullYear();
+ prevM = prevMonth.getMonth();
+
+ if ((prevM < month && prevY === year) || prevY < year) {
+ className += ' am-datepicker-old';
+ } else if ((prevM > month && prevY === year) || prevY > year) {
+ className += ' am-datepicker-new';
+ }
+
+ if (prevMonth.valueOf() === currentDate) {
+ className += ' am-active';
+ }
+ html.push('' + prevMonth.getDate() + ' ');
+
+ if (prevMonth.getDay() === this.weekEnd) {
+ html.push(' ');
+ }
+
+ prevMonth.setDate(prevMonth.getDate() + 1);
+ }
+
+ this.$picker.find('.am-datepicker-days tbody')
+ .empty().append(html.join(''));
+
+ var currentYear = this.date.getFullYear();
+ var months = this.$picker.find('.am-datepicker-months')
+ .find('.am-datepicker-select')
+ .text(year);
+ months = months.end()
+ .find('span').removeClass('am-active').removeClass('am-disabled');
+
+ var monthLen = 0;
+
+ while (monthLen < 12) {
+ if (this.onRender(d.setFullYear(year, monthLen), 1)) {
+ months.eq(monthLen).addClass('am-disabled');
+ }
+ monthLen++;
+ }
+
+ if (currentYear === year) {
+ months.eq(this.date.getMonth())
+ .removeClass('am-disabled')
+ .addClass('am-active');
+ }
+
+ html = '';
+ year = parseInt(year / 10, 10) * 10;
+ var yearCont = this.$picker
+ .find('.am-datepicker-years')
+ .find('.am-datepicker-select')
+ .text(year + '-' + (year + 9))
+ .end()
+ .find('td');
+ var yearClassName;
+ // fixes https://github.com/amazeui/amazeui/issues/770
+ // maybe not need now
+ var viewDate = new Date(this.viewDate);
+
+ year -= 1;
+
+ for (var i = -1; i < 11; i++) {
+ yearClassName = this.onRender(viewDate.setFullYear(year), 2);
+ html += '' + year + '';
+ year += 1;
+ }
+ yearCont.html(html);
+ };
+
+ Datepicker.prototype.click = function(event) {
+ event.stopPropagation();
+ event.preventDefault();
+ var month;
+ var year;
+ var $dayActive = this.$picker.find('.am-datepicker-days').find('.am-active');
+ var $months = this.$picker.find('.am-datepicker-months');
+ var $monthIndex = $months.find('.am-active').index();
+
+ var $target = $(event.target).closest('span, td, th');
+ if ($target.length === 1) {
+ switch ($target[0].nodeName.toLowerCase()) {
+ case 'th':
+ switch ($target[0].className) {
+ case 'am-datepicker-switch':
+ this.showMode(1);
+ break;
+ case 'am-datepicker-prev':
+ case 'am-datepicker-next':
+ this.viewDate['set' + DPGlobal.modes[this.viewMode].navFnc].call(
+ this.viewDate,
+ this.viewDate
+ ['get' + DPGlobal.modes[this.viewMode].navFnc]
+ .call(this.viewDate) +
+ DPGlobal.modes[this.viewMode].navStep *
+ ($target[0].className === 'am-datepicker-prev' ? -1 : 1)
+ );
+ this.fill();
+ this.set();
+ break;
+ }
+ break;
+ case 'span':
+ if ($target.is('.am-disabled')) {
+ return;
+ }
+
+ if ($target.is('.am-datepicker-month')) {
+ month = $target.parent().find('span').index($target);
+
+ if ($target.is('.am-active')) {
+ this.viewDate.setMonth(month, $dayActive.text());
+ } else {
+ this.viewDate.setMonth(month);
+ }
+
+ } else {
+ year = parseInt($target.text(), 10) || 0;
+ if ($target.is('.am-active')) {
+ this.viewDate.setFullYear(year, $monthIndex, $dayActive.text());
+ } else {
+ this.viewDate.setFullYear(year);
+ }
+
+ }
+
+ if (this.viewMode !== 0) {
+ this.date = new Date(this.viewDate);
+ this.$element.trigger({
+ type: 'changeDate.datepicker.amui',
+ date: this.date,
+ viewMode: DPGlobal.modes[this.viewMode].clsName
+ });
+ }
+
+ this.showMode(-1);
+ this.fill();
+ this.set();
+ break;
+ case 'td':
+ if ($target.is('.am-datepicker-day') && !$target.is('.am-disabled')) {
+ var day = parseInt($target.text(), 10) || 1;
+ month = this.viewDate.getMonth();
+ if ($target.is('.am-datepicker-old')) {
+ month -= 1;
+ } else if ($target.is('.am-datepicker-new')) {
+ month += 1;
+ }
+ year = this.viewDate.getFullYear();
+ this.date = new Date(year, month, day, 0, 0, 0, 0);
+ this.viewDate = new Date(year, month, Math.min(28, day), 0, 0, 0, 0);
+ this.fill();
+ this.set();
+ this.$element.trigger({
+ type: 'changeDate.datepicker.amui',
+ date: this.date,
+ viewMode: DPGlobal.modes[this.viewMode].clsName
+ });
+
+ this.options.autoClose && this.close();
+ }
+ break;
+ }
+ }
+ };
+
+ Datepicker.prototype.mousedown = function(event) {
+ event.stopPropagation();
+ event.preventDefault();
+ };
+
+ Datepicker.prototype.showMode = function(dir) {
+ if (dir) {
+ this.viewMode = Math.max(this.minViewMode,
+ Math.min(2, this.viewMode + dir));
+ }
+
+ this.$picker.find('>div').hide().
+ filter('.am-datepicker-' + DPGlobal.modes[this.viewMode].clsName).show();
+ };
+
+ Datepicker.prototype.isOutView = function() {
+ var offset = this.component ?
+ this.component.offset() : this.$element.offset();
+ var isOutView = {
+ outRight: false,
+ outBottom: false
+ };
+ var $picker = this.$picker;
+ var width = offset.left + $picker.outerWidth(true);
+ var height = offset.top + $picker.outerHeight(true) +
+ this.$element.innerHeight();
+
+ if (width > $doc.width()) {
+ isOutView.outRight = true;
+ }
+ if (height > $doc.height()) {
+ isOutView.outBottom = true;
+ }
+ return isOutView;
+ };
+
+ Datepicker.prototype.getLocale = function(locale) {
+ if (!locale) {
+ locale = navigator.language && navigator.language.split('-');
+ locale[1] = locale[1].toUpperCase();
+ locale = locale.join('_');
+ }
+
+ if (!Datepicker.locales[locale]) {
+ locale = 'en_US';
+ }
+ return locale;
+ };
+
+ Datepicker.prototype.setTheme = function() {
+ if (this.theme) {
+ this.$picker.addClass('am-datepicker-' + this.theme);
+ }
+ };
+
+ // Datepicker locales
+ Datepicker.locales = {
+ en_US: {
+ days: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday',
+ 'Friday', 'Saturday'],
+ daysShort: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],
+ daysMin: ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'],
+ months: ['January', 'February', 'March', 'April', 'May', 'June',
+ 'July', 'August', 'September', 'October', 'November', 'December'],
+ monthsShort: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
+ 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],
+ weekStart: 0
+ },
+ zh_CN: {
+ days: ['星期日', '星期一', '星期二', '星期三', '星期四', '星期五', '星期六'],
+ daysShort: ['周日', '周一', '周二', '周三', '周四', '周五', '周六'],
+ daysMin: ['日', '一', '二', '三', '四', '五', '六'],
+ months: ['一月', '二月', '三月', '四月', '五月', '六月', '七月',
+ '八月', '九月', '十月', '十一月', '十二月'],
+ monthsShort: ['一月', '二月', '三月', '四月', '五月', '六月',
+ '七月', '八月', '九月', '十月', '十一月', '十二月'],
+ weekStart: 1,
+ year: ['年']
+ }
+ };
+
+ var DPGlobal = {
+ modes: [
+ {
+ clsName: 'days',
+ navFnc: 'Month',
+ navStep: 1
+ },
+ {
+ clsName: 'months',
+ navFnc: 'FullYear',
+ navStep: 1
+ },
+ {
+ clsName: 'years',
+ navFnc: 'FullYear',
+ navStep: 10
+ }
+ ],
+
+ isLeapYear: function(year) {
+ return (((year % 4 === 0) && (year % 100 !== 0)) || (year % 400 === 0));
+ },
+
+ getDaysInMonth: function(year, month) {
+ return [31, (DPGlobal.isLeapYear(year) ? 29 : 28),
+ 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month];
+ },
+
+ parseFormat: function(format) {
+ var separator = format.match(/[.\/\-\s].*?/);
+ var parts = format.split(/\W+/);
+
+ if (!separator || !parts || parts.length === 0) {
+ throw new Error('Invalid date format.');
+ }
+
+ return {
+ separator: separator,
+ parts: parts
+ };
+ },
+
+ parseDate: function(date, format) {
+ var parts = date.split(format.separator);
+ var val;
+ date = new Date();
+
+ date.setHours(0);
+ date.setMinutes(0);
+ date.setSeconds(0);
+ date.setMilliseconds(0);
+
+ if (parts.length === format.parts.length) {
+ var year = date.getFullYear();
+ var day = date.getDate();
+ var month = date.getMonth();
+
+ for (var i = 0, cnt = format.parts.length; i < cnt; i++) {
+ val = parseInt(parts[i], 10) || 1;
+ switch (format.parts[i]) {
+ case 'dd':
+ case 'd':
+ day = val;
+ date.setDate(val);
+ break;
+ case 'mm':
+ case 'm':
+ month = val - 1;
+ date.setMonth(val - 1);
+ break;
+ case 'yy':
+ year = 2000 + val;
+ date.setFullYear(2000 + val);
+ break;
+ case 'yyyy':
+ year = val;
+ date.setFullYear(val);
+ break;
+ }
+ }
+ date = new Date(year, month, day, 0, 0, 0);
+ }
+ return date;
+ },
+
+ formatDate: function(date, format) {
+ var val = {
+ d: date.getDate(),
+ m: date.getMonth() + 1,
+ yy: date.getFullYear().toString().substring(2),
+ yyyy: date.getFullYear()
+ };
+ var dateArray = [];
+
+ val.dd = (val.d < 10 ? '0' : '') + val.d;
+ val.mm = (val.m < 10 ? '0' : '') + val.m;
+
+ for (var i = 0, cnt = format.parts.length; i < cnt; i++) {
+ dateArray.push(val[format.parts[i]]);
+ }
+ return dateArray.join(format.separator);
+ },
+
+ headTemplate: '' +
+ '' +
+ '' +
+ ' ' +
+ '' +
+ ' ' +
+ '' +
+ ' ',
+
+ contTemplate: ' + ')
' : '' + j + '';
+ if ('thumbnails' === slider.vars.controlNav && true === slider.vars.thumbCaptions) {
+ var captn = slide.attr('data-thumbcaption');
+ if ('' !== captn && undefined !== captn) {item += '' + captn + '';}
+ }
+ // slider.controlNavScaffold.append('' + item + ' ');
+ slider.controlNavScaffold.append('' + item + ' ');
+ j++;
+ }
+ }
+
+ // CONTROLSCONTAINER:
+ (slider.controlsContainer) ? $(slider.controlsContainer).append(slider.controlNavScaffold) : slider.append(slider.controlNavScaffold);
+ methods.controlNav.set();
+
+ methods.controlNav.active();
+
+ slider.controlNavScaffold.delegate('a, img', eventType, function(event) {
+ event.preventDefault();
+
+ if (watchedEvent === "" || watchedEvent === event.type) {
+ var $this = $(this),
+ target = slider.controlNav.index($this);
+
+ if (!$this.hasClass(namespace + 'active')) {
+ slider.direction = (target > slider.currentSlide) ? "next" : "prev";
+ slider.flexAnimate(target, slider.vars.pauseOnAction);
+ }
+ }
+
+ // setup flags to prevent event duplication
+ if (watchedEvent === "") {
+ watchedEvent = event.type;
+ }
+ methods.setToClearWatchedEvent();
+
+ });
+ },
+ setupManual: function() {
+ slider.controlNav = slider.manualControls;
+ methods.controlNav.active();
+
+ slider.controlNav.bind(eventType, function(event) {
+ event.preventDefault();
+
+ if (watchedEvent === "" || watchedEvent === event.type) {
+ var $this = $(this),
+ target = slider.controlNav.index($this);
+
+ if (!$this.hasClass(namespace + 'active')) {
+ (target > slider.currentSlide) ? slider.direction = "next" : slider.direction = "prev";
+ slider.flexAnimate(target, slider.vars.pauseOnAction);
+ }
+ }
+
+ // setup flags to prevent event duplication
+ if (watchedEvent === "") {
+ watchedEvent = event.type;
+ }
+ methods.setToClearWatchedEvent();
+ });
+ },
+ set: function() {
+ var selector = (slider.vars.controlNav === "thumbnails") ? 'img' : 'a';
+ slider.controlNav = $('.' + namespace + 'control-nav li ' + selector, (slider.controlsContainer) ? slider.controlsContainer : slider);
+ },
+ active: function() {
+ slider.controlNav.removeClass(namespace + "active").eq(slider.animatingTo).addClass(namespace + "active");
+ },
+ update: function(action, pos) {
+ if (slider.pagingCount > 1 && action === "add") {
+ slider.controlNavScaffold.append($('' + slider.count + ' '));
+ } else if (slider.pagingCount === 1) {
+ slider.controlNavScaffold.find('li').remove();
+ } else {
+ slider.controlNav.eq(pos).closest('li').remove();
+ }
+ methods.controlNav.set();
+ (slider.pagingCount > 1 && slider.pagingCount !== slider.controlNav.length) ? slider.update(pos, action) : methods.controlNav.active();
+ }
+ },
+ directionNav: {
+ setup: function() {
+ var directionNavScaffold = $('');
+
+ // CUSTOM DIRECTION NAV:
+ if (slider.customDirectionNav) {
+ slider.directionNav = slider.customDirectionNav;
+ } else if (slider.controlsContainer) { // CONTROLSCONTAINER:
+ $(slider.controlsContainer).append(directionNavScaffold);
+ slider.directionNav = $('.' + namespace + 'direction-nav li a', slider.controlsContainer);
+ } else {
+ slider.append(directionNavScaffold);
+ slider.directionNav = $('.' + namespace + 'direction-nav li a', slider);
+ }
+
+ methods.directionNav.update();
+
+ slider.directionNav.bind(eventType, function(event) {
+ event.preventDefault();
+ var target;
+
+ if (watchedEvent === "" || watchedEvent === event.type) {
+ target = ($(this).hasClass(namespace + 'next')) ? slider.getTarget('next') : slider.getTarget('prev');
+ slider.flexAnimate(target, slider.vars.pauseOnAction);
+ }
+
+ // setup flags to prevent event duplication
+ if (watchedEvent === "") {
+ watchedEvent = event.type;
+ }
+ methods.setToClearWatchedEvent();
+ });
+ },
+ update: function() {
+ var disabledClass = namespace + 'disabled';
+ if (slider.pagingCount === 1) {
+ slider.directionNav.addClass(disabledClass).attr('tabindex', '-1');
+ } else if (!slider.vars.animationLoop) {
+ if (slider.animatingTo === 0) {
+ slider.directionNav.removeClass(disabledClass).filter('.' + namespace + "prev").addClass(disabledClass).attr('tabindex', '-1');
+ } else if (slider.animatingTo === slider.last) {
+ slider.directionNav.removeClass(disabledClass).filter('.' + namespace + "next").addClass(disabledClass).attr('tabindex', '-1');
+ } else {
+ slider.directionNav.removeClass(disabledClass).removeAttr('tabindex');
+ }
+ } else {
+ slider.directionNav.removeClass(disabledClass).removeAttr('tabindex');
+ }
+ }
+ },
+ pausePlay: {
+ setup: function() {
+ var pausePlayScaffold = $('');
+
+ // CONTROLSCONTAINER:
+ if (slider.controlsContainer) {
+ slider.controlsContainer.append(pausePlayScaffold);
+ slider.pausePlay = $('.' + namespace + 'pauseplay a', slider.controlsContainer);
+ } else {
+ slider.append(pausePlayScaffold);
+ slider.pausePlay = $('.' + namespace + 'pauseplay a', slider);
+ }
+
+ methods.pausePlay.update((slider.vars.slideshow) ? namespace + 'pause' : namespace + 'play');
+
+ slider.pausePlay.bind(eventType, function(event) {
+ event.preventDefault();
+
+ if (watchedEvent === "" || watchedEvent === event.type) {
+ if ($(this).hasClass(namespace + 'pause')) {
+ slider.manualPause = true;
+ slider.manualPlay = false;
+ slider.pause();
+ } else {
+ slider.manualPause = false;
+ slider.manualPlay = true;
+ slider.play();
+ }
+ }
+
+ // setup flags to prevent event duplication
+ if (watchedEvent === "") {
+ watchedEvent = event.type;
+ }
+ methods.setToClearWatchedEvent();
+ });
+ },
+ update: function(state) {
+ (state === "play") ? slider.pausePlay.removeClass(namespace + 'pause').addClass(namespace + 'play').html(slider.vars.playText) : slider.pausePlay.removeClass(namespace + 'play').addClass(namespace + 'pause').html(slider.vars.pauseText);
+ }
+ },
+ touch: function() {
+ var startX,
+ startY,
+ offset,
+ cwidth,
+ dx,
+ startT,
+ onTouchStart,
+ onTouchMove,
+ onTouchEnd,
+ scrolling = false,
+ localX = 0,
+ localY = 0,
+ accDx = 0;
+
+ if (!msGesture) {
+ onTouchStart = function(e) {
+ if (slider.animating) {
+ e.preventDefault();
+ } else if (( window.navigator.msPointerEnabled ) || e.touches.length === 1) {
+ slider.pause();
+ // CAROUSEL:
+ cwidth = (vertical) ? slider.h : slider.w;
+ startT = Number(new Date());
+ // CAROUSEL:
+
+ // Local vars for X and Y points.
+ localX = e.touches[0].pageX;
+ localY = e.touches[0].pageY;
+
+ offset = (carousel && reverse && slider.animatingTo === slider.last) ? 0 :
+ (carousel && reverse) ? slider.limit - (((slider.itemW + slider.vars.itemMargin) * slider.move) * slider.animatingTo) :
+ (carousel && slider.currentSlide === slider.last) ? slider.limit :
+ (carousel) ? ((slider.itemW + slider.vars.itemMargin) * slider.move) * slider.currentSlide :
+ (reverse) ? (slider.last - slider.currentSlide + slider.cloneOffset) * cwidth : (slider.currentSlide + slider.cloneOffset) * cwidth;
+ startX = (vertical) ? localY : localX;
+ startY = (vertical) ? localX : localY;
+
+ el.addEventListener('touchmove', onTouchMove, false);
+ el.addEventListener('touchend', onTouchEnd, false);
+ }
+ };
+
+ onTouchMove = function(e) {
+ // Local vars for X and Y points.
+
+ localX = e.touches[0].pageX;
+ localY = e.touches[0].pageY;
+
+ dx = (vertical) ? startX - localY : startX - localX;
+ scrolling = (vertical) ? (Math.abs(dx) < Math.abs(localX - startY)) : (Math.abs(dx) < Math.abs(localY - startY));
+
+ var fxms = 500;
+
+ if (!scrolling || Number(new Date()) - startT > fxms) {
+ e.preventDefault();
+ if (!fade && slider.transitions) {
+ if (!slider.vars.animationLoop) {
+ dx = dx / ((slider.currentSlide === 0 && dx < 0 || slider.currentSlide === slider.last && dx > 0) ? (Math.abs(dx) / cwidth + 2) : 1);
+ }
+ slider.setProps(offset + dx, "setTouch");
+ }
+ }
+ };
+
+ onTouchEnd = function(e) {
+ // finish the touch by undoing the touch session
+ el.removeEventListener('touchmove', onTouchMove, false);
+
+ if (slider.animatingTo === slider.currentSlide && !scrolling && !(dx === null)) {
+ var updateDx = (reverse) ? -dx : dx,
+ target = (updateDx > 0) ? slider.getTarget('next') : slider.getTarget('prev');
+
+ if (slider.canAdvance(target) && (Number(new Date()) - startT < 550 && Math.abs(updateDx) > 50 || Math.abs(updateDx) > cwidth / 2)) {
+ slider.flexAnimate(target, slider.vars.pauseOnAction);
+ } else {
+ if (!fade) {slider.flexAnimate(slider.currentSlide, slider.vars.pauseOnAction, true);}
+ }
+ }
+ el.removeEventListener('touchend', onTouchEnd, false);
+
+ startX = null;
+ startY = null;
+ dx = null;
+ offset = null;
+ };
+
+ el.addEventListener('touchstart', onTouchStart, false);
+ } else {
+ el.style.msTouchAction = "none";
+ el._gesture = new MSGesture();
+ el._gesture.target = el;
+ el.addEventListener("MSPointerDown", onMSPointerDown, false);
+ el._slider = slider;
+ el.addEventListener("MSGestureChange", onMSGestureChange, false);
+ el.addEventListener("MSGestureEnd", onMSGestureEnd, false);
+
+ function onMSPointerDown(e) {
+ e.stopPropagation();
+ if (slider.animating) {
+ e.preventDefault();
+ } else {
+ slider.pause();
+ el._gesture.addPointer(e.pointerId);
+ accDx = 0;
+ cwidth = (vertical) ? slider.h : slider.w;
+ startT = Number(new Date());
+ // CAROUSEL:
+
+ offset = (carousel && reverse && slider.animatingTo === slider.last) ? 0 :
+ (carousel && reverse) ? slider.limit - (((slider.itemW + slider.vars.itemMargin) * slider.move) * slider.animatingTo) :
+ (carousel && slider.currentSlide === slider.last) ? slider.limit :
+ (carousel) ? ((slider.itemW + slider.vars.itemMargin) * slider.move) * slider.currentSlide :
+ (reverse) ? (slider.last - slider.currentSlide + slider.cloneOffset) * cwidth : (slider.currentSlide + slider.cloneOffset) * cwidth;
+ }
+ }
+
+ function onMSGestureChange(e) {
+ e.stopPropagation();
+ var slider = e.target._slider;
+ if (!slider) {
+ return;
+ }
+ var transX = -e.translationX,
+ transY = -e.translationY;
+
+ //Accumulate translations.
+ accDx = accDx + ((vertical) ? transY : transX);
+ dx = accDx;
+ scrolling = (vertical) ? (Math.abs(accDx) < Math.abs(-transX)) : (Math.abs(accDx) < Math.abs(-transY));
+
+ if (e.detail === e.MSGESTURE_FLAG_INERTIA) {
+ setImmediate(function() {
+ el._gesture.stop();
+ });
+
+ return;
+ }
+
+ if (!scrolling || Number(new Date()) - startT > 500) {
+ e.preventDefault();
+ if (!fade && slider.transitions) {
+ if (!slider.vars.animationLoop) {
+ dx = accDx / ((slider.currentSlide === 0 && accDx < 0 || slider.currentSlide === slider.last && accDx > 0) ? (Math.abs(accDx) / cwidth + 2) : 1);
+ }
+ slider.setProps(offset + dx, "setTouch");
+ }
+ }
+ }
+
+ function onMSGestureEnd(e) {
+ e.stopPropagation();
+ var slider = e.target._slider;
+ if (!slider) {
+ return;
+ }
+ if (slider.animatingTo === slider.currentSlide && !scrolling && !(dx === null)) {
+ var updateDx = (reverse) ? -dx : dx,
+ target = (updateDx > 0) ? slider.getTarget('next') : slider.getTarget('prev');
+
+ if (slider.canAdvance(target) && (Number(new Date()) - startT < 550 && Math.abs(updateDx) > 50 || Math.abs(updateDx) > cwidth / 2)) {
+ slider.flexAnimate(target, slider.vars.pauseOnAction);
+ } else {
+ if (!fade) {slider.flexAnimate(slider.currentSlide, slider.vars.pauseOnAction, true);}
+ }
+ }
+
+ startX = null;
+ startY = null;
+ dx = null;
+ offset = null;
+ accDx = 0;
+ }
+ }
+ },
+ resize: function() {
+ if (!slider.animating && slider.is(':visible')) {
+ if (!carousel) {slider.doMath()};
+
+ if (fade) {
+ // SMOOTH HEIGHT:
+ methods.smoothHeight();
+ } else if (carousel) { //CAROUSEL:
+ slider.slides.width(slider.computedW);
+ slider.update(slider.pagingCount);
+ slider.setProps();
+ }
+ else if (vertical) { //VERTICAL:
+ slider.viewport.height(slider.h);
+ slider.setProps(slider.h, "setTotal");
+ } else {
+ // SMOOTH HEIGHT:
+ if (slider.vars.smoothHeight) {methods.smoothHeight();}
+ slider.newSlides.width(slider.computedW);
+ slider.setProps(slider.computedW, "setTotal");
+ }
+ }
+ },
+ smoothHeight: function(dur) {
+ if (!vertical || fade) {
+ var $obj = (fade) ? slider : slider.viewport;
+ (dur) ? $obj.animate({"height": slider.slides.eq(slider.animatingTo).innerHeight()}, dur) : $obj.innerHeight(slider.slides.eq(slider.animatingTo).innerHeight());
+ }
+ },
+ sync: function(action) {
+ var $obj = $(slider.vars.sync).data("flexslider"),
+ target = slider.animatingTo;
+
+ switch (action) {
+ case "animate":
+ $obj.flexAnimate(target, slider.vars.pauseOnAction, false, true);
+ break;
+ case "play":
+ if (!$obj.playing && !$obj.asNav) {
+ $obj.play();
+ }
+ break;
+ case "pause":
+ $obj.pause();
+ break;
+ }
+ },
+ uniqueID: function($clone) {
+ // Append _clone to current level and children elements with id attributes
+ $clone.filter('[id]').add($clone.find('[id]')).each(function() {
+ var $this = $(this);
+ $this.attr('id', $this.attr('id') + '_clone');
+ });
+ return $clone;
+ },
+ pauseInvisible: {
+ visProp: null,
+ init: function() {
+ var visProp = methods.pauseInvisible.getHiddenProp();
+ if (visProp) {
+ var evtname = visProp.replace(/[H|h]idden/,'') + 'visibilitychange';
+ document.addEventListener(evtname, function() {
+ if (methods.pauseInvisible.isHidden()) {
+ if(slider.startTimeout) {
+ clearTimeout(slider.startTimeout); //If clock is ticking, stop timer and prevent from starting while invisible
+ } else {
+ slider.pause(); //Or just pause
+ }
+ }
+ else {
+ if(slider.started) {
+ slider.play(); //Initiated before, just play
+ } else {
+ if (slider.vars.initDelay > 0) {
+ setTimeout(slider.play, slider.vars.initDelay);
+ } else {
+ slider.play(); //Didn't init before: simply init or wait for it
+ }
+ }
+ }
+ });
+ }
+ },
+ isHidden: function() {
+ var prop = methods.pauseInvisible.getHiddenProp();
+ if (!prop) {
+ return false;
+ }
+ return document[prop];
+ },
+ getHiddenProp: function() {
+ var prefixes = ['webkit','moz','ms','o'];
+ // if 'hidden' is natively supported just return it
+ if ('hidden' in document) {
+ return 'hidden';
+ }
+ // otherwise loop over all the known prefixes until we find one
+ for (var i = 0; i < prefixes.length; i++ ) {
+ if ((prefixes[i] + 'Hidden') in document) {
+ return prefixes[i] + 'Hidden';
+ }
+ }
+ // otherwise it's not supported
+ return null;
+ }
+ },
+ setToClearWatchedEvent: function() {
+ clearTimeout(watchedEventClearTimer);
+ watchedEventClearTimer = setTimeout(function() {
+ watchedEvent = "";
+ }, 3000);
+ }
+ };
+
+ // public methods
+ slider.flexAnimate = function(target, pause, override, withSync, fromNav) {
+ if (!slider.vars.animationLoop && target !== slider.currentSlide) {
+ slider.direction = (target > slider.currentSlide) ? "next" : "prev";
+ }
+
+ if (asNav && slider.pagingCount === 1) slider.direction = (slider.currentItem < target) ? "next" : "prev";
+
+ if (!slider.animating && (slider.canAdvance(target, fromNav) || override) && slider.is(":visible")) {
+ if (asNav && withSync) {
+ var master = $(slider.vars.asNavFor).data('flexslider');
+ slider.atEnd = target === 0 || target === slider.count - 1;
+ master.flexAnimate(target, true, false, true, fromNav);
+ slider.direction = (slider.currentItem < target) ? "next" : "prev";
+ master.direction = slider.direction;
+
+ if (Math.ceil((target + 1) / slider.visible) - 1 !== slider.currentSlide && target !== 0) {
+ slider.currentItem = target;
+ slider.slides.removeClass(namespace + "active-slide").eq(target).addClass(namespace + "active-slide");
+ target = Math.floor(target / slider.visible);
+ } else {
+ slider.currentItem = target;
+ slider.slides.removeClass(namespace + "active-slide").eq(target).addClass(namespace + "active-slide");
+ return false;
+ }
+ }
+
+ slider.animating = true;
+ slider.animatingTo = target;
+
+ // SLIDESHOW:
+ if (pause) {slider.pause();}
+
+ // API: before() animation Callback
+ slider.vars.before(slider);
+
+ // SYNC:
+ if (slider.syncExists && !fromNav) {methods.sync("animate");}
+
+ // CONTROLNAV
+ if (slider.vars.controlNav) {methods.controlNav.active();}
+
+ // !CAROUSEL:
+ // CANDIDATE: slide active class (for add/remove slide)
+ if (!carousel) {slider.slides.removeClass(namespace + 'active-slide').eq(target).addClass(namespace + 'active-slide');}
+
+ // INFINITE LOOP:
+ // CANDIDATE: atEnd
+ slider.atEnd = target === 0 || target === slider.last;
+
+ // DIRECTIONNAV:
+ if (slider.vars.directionNav) {methods.directionNav.update();}
+
+ if (target === slider.last) {
+ // API: end() of cycle Callback
+ slider.vars.end(slider);
+ // SLIDESHOW && !INFINITE LOOP:
+ if (!slider.vars.animationLoop) {slider.pause();}
+ }
+
+ // SLIDE:
+ if (!fade) {
+ var dimension = (vertical) ? slider.slides.filter(':first').height() : slider.computedW,
+ margin, slideString, calcNext;
+
+ // INFINITE LOOP / REVERSE:
+ if (carousel) {
+ //margin = (slider.vars.itemWidth > slider.w) ? slider.vars.itemMargin * 2 : slider.vars.itemMargin;
+ margin = slider.vars.itemMargin;
+ calcNext = ((slider.itemW + margin) * slider.move) * slider.animatingTo;
+ slideString = (calcNext > slider.limit && slider.visible !== 1) ? slider.limit : calcNext;
+ } else if (slider.currentSlide === 0 && target === slider.count - 1 && slider.vars.animationLoop && slider.direction !== "next") {
+ slideString = (reverse) ? (slider.count + slider.cloneOffset) * dimension : 0;
+ } else if (slider.currentSlide === slider.last && target === 0 && slider.vars.animationLoop && slider.direction !== "prev") {
+ slideString = (reverse) ? 0 : (slider.count + 1) * dimension;
+ } else {
+ slideString = (reverse) ? ((slider.count - 1) - target + slider.cloneOffset) * dimension : (target + slider.cloneOffset) * dimension;
+ }
+ slider.setProps(slideString, "", slider.vars.animationSpeed);
+ if (slider.transitions) {
+ if (!slider.vars.animationLoop || !slider.atEnd) {
+ slider.animating = false;
+ slider.currentSlide = slider.animatingTo;
+ }
+
+ // Unbind previous transitionEnd events and re-bind new transitionEnd event
+ slider.container.unbind("webkitTransitionEnd transitionend");
+ slider.container.bind("webkitTransitionEnd transitionend", function() {
+ clearTimeout(slider.ensureAnimationEnd);
+ slider.wrapup(dimension);
+ });
+
+ // Insurance for the ever-so-fickle transitionEnd event
+ clearTimeout(slider.ensureAnimationEnd);
+ slider.ensureAnimationEnd = setTimeout(function() {
+ slider.wrapup(dimension);
+ }, slider.vars.animationSpeed + 100);
+
+ } else {
+ slider.container.animate(slider.args, slider.vars.animationSpeed, slider.vars.easing, function(){
+ slider.wrapup(dimension);
+ });
+ }
+ } else { // FADE:
+ if (!touch) {
+ //slider.slides.eq(slider.currentSlide).fadeOut(slider.vars.animationSpeed, slider.vars.easing);
+ //slider.slides.eq(target).fadeIn(slider.vars.animationSpeed, slider.vars.easing, slider.wrapup);
+
+ slider.slides.eq(slider.currentSlide).css({"zIndex": 1}).animate({"opacity": 0}, slider.vars.animationSpeed, slider.vars.easing);
+ slider.slides.eq(target).css({"zIndex": 2}).animate({"opacity": 1}, slider.vars.animationSpeed, slider.vars.easing, slider.wrapup);
+
+ } else {
+ slider.slides.eq(slider.currentSlide).css({
+ "opacity": 0,
+ "zIndex": 1
+ });
+ slider.slides.eq(target).css({"opacity": 1, "zIndex": 2});
+ slider.wrapup(dimension);
+ }
+ }
+ // SMOOTH HEIGHT:
+ if (slider.vars.smoothHeight) {methods.smoothHeight(slider.vars.animationSpeed)};
+ }
+ };
+ slider.wrapup = function(dimension) {
+ // SLIDE:
+ if (!fade && !carousel) {
+ if (slider.currentSlide === 0 && slider.animatingTo === slider.last && slider.vars.animationLoop) {
+ slider.setProps(dimension, "jumpEnd");
+ } else if (slider.currentSlide === slider.last && slider.animatingTo === 0 && slider.vars.animationLoop) {
+ slider.setProps(dimension, "jumpStart");
+ }
+ }
+ slider.animating = false;
+ slider.currentSlide = slider.animatingTo;
+ // API: after() animation Callback
+ slider.vars.after(slider);
+ };
+
+ // SLIDESHOW:
+ slider.animateSlides = function() {
+ if (!slider.animating && focused) {slider.flexAnimate(slider.getTarget("next"));}
+ };
+ // SLIDESHOW:
+ slider.pause = function() {
+ clearInterval(slider.animatedSlides);
+ slider.animatedSlides = null;
+ slider.playing = false;
+ // PAUSEPLAY:
+ if (slider.vars.pausePlay) {methods.pausePlay.update("play");}
+ // SYNC:
+ if (slider.syncExists) {methods.sync("pause");}
+ };
+ // SLIDESHOW:
+ slider.play = function() {
+ if (slider.playing) {clearInterval(slider.animatedSlides);}
+ slider.animatedSlides = slider.animatedSlides || setInterval(slider.animateSlides, slider.vars.slideshowSpeed);
+ slider.started = slider.playing = true;
+ // PAUSEPLAY:
+ if (slider.vars.pausePlay) {methods.pausePlay.update("pause");}
+ // SYNC:
+ if (slider.syncExists) {methods.sync("play");}
+ };
+ // STOP:
+ slider.stop = function() {
+ slider.pause();
+ slider.stopped = true;
+ };
+ slider.canAdvance = function(target, fromNav) {
+ // ASNAV:
+ var last = (asNav) ? slider.pagingCount - 1 : slider.last;
+ return (fromNav) ? true :
+ (asNav && slider.currentItem === slider.count - 1 && target === 0 && slider.direction === "prev") ? true :
+ (asNav && slider.currentItem === 0 && target === slider.pagingCount - 1 && slider.direction !== "next") ? false :
+ (target === slider.currentSlide && !asNav) ? false :
+ (slider.vars.animationLoop) ? true :
+ (slider.atEnd && slider.currentSlide === 0 && target === last && slider.direction !== "next") ? false :
+ (slider.atEnd && slider.currentSlide === last && target === 0 && slider.direction === "next") ? false :
+ true;
+ };
+ slider.getTarget = function(dir) {
+ slider.direction = dir;
+ if (dir === "next") {
+ return (slider.currentSlide === slider.last) ? 0 : slider.currentSlide + 1;
+ } else {
+ return (slider.currentSlide === 0) ? slider.last : slider.currentSlide - 1;
+ }
+ };
+
+ // SLIDE:
+ slider.setProps = function(pos, special, dur) {
+ var target = (function() {
+ var posCheck = (pos) ? pos : ((slider.itemW + slider.vars.itemMargin) * slider.move) * slider.animatingTo,
+ posCalc = (function() {
+ if (carousel) {
+ return (special === "setTouch") ? pos :
+ (reverse && slider.animatingTo === slider.last) ? 0 :
+ (reverse) ? slider.limit - (((slider.itemW + slider.vars.itemMargin) * slider.move) * slider.animatingTo) :
+ (slider.animatingTo === slider.last) ? slider.limit : posCheck;
+ } else {
+ switch (special) {
+ case "setTotal":
+ return (reverse) ? ((slider.count - 1) - slider.currentSlide + slider.cloneOffset) * pos : (slider.currentSlide + slider.cloneOffset) * pos;
+ case "setTouch":
+ return (reverse) ? pos : pos;
+ case "jumpEnd":
+ return (reverse) ? pos : slider.count * pos;
+ case "jumpStart":
+ return (reverse) ? slider.count * pos : pos;
+ default:
+ return pos;
+ }
+ }
+ }());
+
+ return (posCalc * -1) + "px";
+ }());
+
+ if (slider.transitions) {
+ target = (vertical) ? "translate3d(0," + target + ",0)" : "translate3d(" + target + ",0,0)";
+ dur = (dur !== undefined) ? (dur / 1000) + "s" : "0s";
+ slider.container.css("-" + slider.pfx + "-transition-duration", dur);
+ slider.container.css("transition-duration", dur);
+ }
+
+ slider.args[slider.prop] = target;
+ if (slider.transitions || dur === undefined) {slider.container.css(slider.args);}
+
+ slider.container.css('transform', target);
+ };
+
+ slider.setup = function(type) {
+ // SLIDE:
+ if (!fade) {
+ var sliderOffset, arr;
+
+ if (type === "init") {
+ slider.viewport = $('').css({
+ "overflow": "hidden",
+ "position": "relative"
+ }).appendTo(slider).append(slider.container);
+ // INFINITE LOOP:
+ slider.cloneCount = 0;
+ slider.cloneOffset = 0;
+ // REVERSE:
+ if (reverse) {
+ arr = $.makeArray(slider.slides).reverse();
+ slider.slides = $(arr);
+ slider.container.empty().append(slider.slides);
+ }
+ }
+ // INFINITE LOOP && !CAROUSEL:
+ if (slider.vars.animationLoop && !carousel) {
+ slider.cloneCount = 2;
+ slider.cloneOffset = 1;
+ // clear out old clones
+ if (type !== "init") { slider.container.find('.clone').remove(); }
+ slider.container.append(methods.uniqueID(slider.slides.first().clone().addClass('clone')).attr('aria-hidden', 'true'))
+ .prepend(methods.uniqueID(slider.slides.last().clone().addClass('clone')).attr('aria-hidden', 'true'));
+ }
+ slider.newSlides = $(slider.vars.selector, slider);
+
+ sliderOffset = (reverse) ? slider.count - 1 - slider.currentSlide + slider.cloneOffset : slider.currentSlide + slider.cloneOffset;
+ // VERTICAL:
+ if (vertical && !carousel) {
+ slider.container.height((slider.count + slider.cloneCount) * 200 + "%").css("position", "absolute").width("100%");
+ setTimeout(function() {
+ slider.newSlides.css({"display": "block"});
+ slider.doMath();
+ slider.viewport.height(slider.h);
+ slider.setProps(sliderOffset * slider.h, "init");
+ }, (type === "init") ? 100 : 0);
+ } else {
+ slider.container.width((slider.count + slider.cloneCount) * 200 + "%");
+ slider.setProps(sliderOffset * slider.computedW, "init");
+ setTimeout(function() {
+ slider.doMath();
+ slider.newSlides.css({"width": slider.computedW, "marginRight" : slider.computedM, "float": "left", "display": "block"});
+
+ // SMOOTH HEIGHT:
+ if (slider.vars.smoothHeight) {methods.smoothHeight();}
+ }, (type === "init") ? 100 : 0);
+ }
+ } else { // FADE:
+ slider.slides.css({
+ "width": "100%",
+ "float": "left",
+ "marginRight": "-100%",
+ "position": "relative"
+ });
+ if (type === "init") {
+ if (!touch) {
+ //slider.slides.eq(slider.currentSlide).fadeIn(slider.vars.animationSpeed, slider.vars.easing);
+ if (slider.vars.fadeFirstSlide == false) {
+ slider.slides.css({ "opacity": 0, "display": "block", "zIndex": 1 }).eq(slider.currentSlide).css({"zIndex": 2}).css({"opacity": 1});
+ } else {
+ slider.slides.css({ "opacity": 0, "display": "block", "zIndex": 1 }).eq(slider.currentSlide).css({"zIndex": 2}).animate({"opacity": 1},slider.vars.animationSpeed,slider.vars.easing);
+ }
+ } else {
+ slider.slides.css({ "opacity": 0, "display": "block", "webkitTransition": "opacity " + slider.vars.animationSpeed / 1000 + "s ease", "zIndex": 1 }).eq(slider.currentSlide).css({ "opacity": 1, "zIndex": 2});
+ }
+ }
+ // SMOOTH HEIGHT:
+ if (slider.vars.smoothHeight) {methods.smoothHeight();}
+ }
+ // !CAROUSEL:
+ // CANDIDATE: active slide
+ if (!carousel) {slider.slides.removeClass(namespace + "active-slide").eq(slider.currentSlide).addClass(namespace + "active-slide");}
+
+ //FlexSlider: init() Callback
+ slider.vars.init(slider);
+ };
+
+ slider.doMath = function() {
+ var slide = slider.slides.first(),
+ slideMargin = slider.vars.itemMargin,
+ minItems = slider.vars.minItems,
+ maxItems = slider.vars.maxItems;
+
+ slider.w = (slider.viewport === undefined) ? slider.width() : slider.viewport.width();
+ slider.h = slide.height();
+ slider.boxPadding = slide.outerWidth() - slide.width();
+
+ // CAROUSEL:
+ if (carousel) {
+ slider.itemT = slider.vars.itemWidth + slideMargin;
+ slider.itemM = slideMargin;
+ slider.minW = (minItems) ? minItems * slider.itemT : slider.w;
+ slider.maxW = (maxItems) ? (maxItems * slider.itemT) - slideMargin : slider.w;
+ slider.itemW = (slider.minW > slider.w) ? (slider.w - (slideMargin * (minItems - 1))) / minItems :
+ (slider.maxW < slider.w) ? (slider.w - (slideMargin * (maxItems - 1))) / maxItems :
+ (slider.vars.itemWidth > slider.w) ? slider.w : slider.vars.itemWidth;
+
+ slider.visible = Math.floor(slider.w / (slider.itemW));
+ slider.move = (slider.vars.move > 0 && slider.vars.move < slider.visible ) ? slider.vars.move : slider.visible;
+ slider.pagingCount = Math.ceil(((slider.count - slider.visible) / slider.move) + 1);
+ slider.last = slider.pagingCount - 1;
+ slider.limit = (slider.pagingCount === 1) ? 0 :
+ (slider.vars.itemWidth > slider.w) ? (slider.itemW * (slider.count - 1)) + (slideMargin * (slider.count - 1)) : ((slider.itemW + slideMargin) * slider.count) - slider.w - slideMargin;
+ } else {
+ slider.itemW = slider.w;
+ slider.itemM = slideMargin;
+ slider.pagingCount = slider.count;
+ slider.last = slider.count - 1;
+ }
+ slider.computedW = slider.itemW - slider.boxPadding;
+ slider.computedM = slider.itemM;
+ };
+
+ slider.update = function(pos, action) {
+ slider.doMath();
+
+ // update currentSlide and slider.animatingTo if necessary
+ if (!carousel) {
+ if (pos < slider.currentSlide) {
+ slider.currentSlide += 1;
+ } else if (pos <= slider.currentSlide && pos !== 0) {
+ slider.currentSlide -= 1;
+ }
+ slider.animatingTo = slider.currentSlide;
+ }
+
+ // update controlNav
+ if (slider.vars.controlNav && !slider.manualControls) {
+ if ((action === "add" && !carousel) || slider.pagingCount > slider.controlNav.length) {
+ methods.controlNav.update("add");
+ } else if ((action === "remove" && !carousel) || slider.pagingCount < slider.controlNav.length) {
+ if (carousel && slider.currentSlide > slider.last) {
+ slider.currentSlide -= 1;
+ slider.animatingTo -= 1;
+ }
+ methods.controlNav.update("remove", slider.last);
+ }
+ }
+ // update directionNav
+ if (slider.vars.directionNav) {methods.directionNav.update();}
+
+ };
+
+ slider.addSlide = function(obj, pos) {
+ var $obj = $(obj);
+
+ slider.count += 1;
+ slider.last = slider.count - 1;
+
+ // append new slide
+ if (vertical && reverse) {
+ (pos !== undefined) ? slider.slides.eq(slider.count - pos).after($obj) : slider.container.prepend($obj);
+ } else {
+ (pos !== undefined) ? slider.slides.eq(pos).before($obj) : slider.container.append($obj);
+ }
+
+ // update currentSlide, animatingTo, controlNav, and directionNav
+ slider.update(pos, "add");
+
+ // update slider.slides
+ slider.slides = $(slider.vars.selector + ':not(.clone)', slider);
+ // re-setup the slider to accomdate new slide
+ slider.setup();
+
+ //FlexSlider: added() Callback
+ slider.vars.added(slider);
+ };
+ slider.removeSlide = function(obj) {
+ var pos = (isNaN(obj)) ? slider.slides.index($(obj)) : obj;
+
+ // update count
+ slider.count -= 1;
+ slider.last = slider.count - 1;
+
+ // remove slide
+ if (isNaN(obj)) {
+ $(obj, slider.slides).remove();
+ } else {
+ (vertical && reverse) ? slider.slides.eq(slider.last).remove() : slider.slides.eq(obj).remove();
+ }
+
+ // update currentSlide, animatingTo, controlNav, and directionNav
+ slider.doMath();
+ slider.update(pos, "remove");
+
+ // update slider.slides
+ slider.slides = $(slider.vars.selector + ':not(.clone)', slider);
+ // re-setup the slider to accomdate new slide
+ slider.setup();
+
+ // FlexSlider: removed() Callback
+ slider.vars.removed(slider);
+ };
+
+ //FlexSlider: Initialize
+ methods.init();
+ };
+
+ // Ensure the slider isn't focussed if the window loses focus.
+ $(window).blur(function(e) {
+ focused = false;
+ }).focus(function(e) {
+ focused = true;
+ });
+
+ // FlexSlider: Default Settings
+ $.flexslider.defaults = {
+ namespace: 'am-', // {NEW} String: Prefix string attached to the class of every element generated by the plugin
+ selector: '.am-slides > li', // {NEW} Selector: Must match a simple pattern. '{container} > {slide}' -- Ignore pattern at your own peril
+ animation: 'slide', // String: Select your animation type, 'fade' or 'slide'
+ easing: 'swing', // {NEW} String: Determines the easing method used in jQuery transitions. jQuery easing plugin is supported!
+ direction: 'horizontal', // String: Select the sliding direction, "horizontal" or "vertical"
+ reverse: false, // {NEW} Boolean: Reverse the animation direction
+ animationLoop: true, // Boolean: Should the animation loop? If false, directionNav will received "disable" classes at either end
+ smoothHeight: false, // {NEW} Boolean: Allow height of the slider to animate smoothly in horizontal mode
+ startAt: 0, // Integer: The slide that the slider should start on. Array notation (0 = first slide)
+ slideshow: true, // Boolean: Animate slider automatically
+ slideshowSpeed: 5000, // Integer: Set the speed of the slideshow cycling, in milliseconds
+ animationSpeed: 600, // Integer: Set the speed of animations, in milliseconds
+ initDelay: 0, // {NEW} Integer: Set an initialization delay, in milliseconds
+ randomize: false, // Boolean: Randomize slide order
+ fadeFirstSlide: true, // Boolean: Fade in the first slide when animation type is "fade"
+ thumbCaptions: false, // Boolean: Whether or not to put captions on thumbnails when using the "thumbnails" controlNav.
+
+ // Usability features
+ pauseOnAction: true, // Boolean: Pause the slideshow when interacting with control elements, highly recommended.
+ pauseOnHover: false, // Boolean: Pause the slideshow when hovering over slider, then resume when no longer hovering
+ pauseInvisible: true, // {NEW} Boolean: Pause the slideshow when tab is invisible, resume when visible. Provides better UX, lower CPU usage.
+ useCSS: true, // {NEW} Boolean: Slider will use CSS3 transitions if available
+ touch: true, // {NEW} Boolean: Allow touch swipe navigation of the slider on touch-enabled devices
+ video: false, // {NEW} Boolean: If using video in the slider, will prevent CSS3 3D Transforms to avoid graphical glitches
+
+ // Primary Controls
+ controlNav: true, // Boolean: Create navigation for paging control of each slide? Note: Leave true for manualControls usage
+ directionNav: true, // Boolean: Create navigation for previous/next navigation? (true/false)
+ prevText: ' ', // String: Set the text for the "previous" directionNav item
+ nextText: ' ', // String: Set the text for the "next" directionNav item
+
+ // Secondary Navigation
+ keyboard: true, // Boolean: Allow slider navigating via keyboard left/right keys
+ multipleKeyboard: false, // {NEW} Boolean: Allow keyboard navigation to affect multiple sliders. Default behavior cuts out keyboard navigation with more than one slider present.
+ mousewheel: false, // {UPDATED} Boolean: Requires jquery.mousewheel.js (https://github.com/brandonaaron/jquery-mousewheel) - Allows slider navigating via mousewheel
+ pausePlay: false, // Boolean: Create pause/play dynamic element
+ pauseText: 'Pause', // String: Set the text for the 'pause' pausePlay item
+ playText: 'Play', // String: Set the text for the 'play' pausePlay item
+
+ // Special properties
+ controlsContainer: '', // {UPDATED} jQuery Object/Selector: Declare which container the navigation elements should be appended too. Default container is the FlexSlider element. Example use would be $('.flexslider-container'). Property is ignored if given element is not found.
+ manualControls: '', // {UPDATED} jQuery Object/Selector: Declare custom control navigation. Examples would be $(".flex-control-nav li") or "#tabs-nav li img", etc. The number of elements in your controlNav should match the number of slides/tabs.
+ customDirectionNav: '', // {NEW} jQuery Object/Selector: Custom prev / next button. Must be two jQuery elements. In order to make the events work they have to have the classes "prev" and "next" (plus namespace)
+ sync: '', // {NEW} Selector: Mirror the actions performed on this slider with another slider. Use with care.
+ asNavFor: '', // {NEW} Selector: Internal property exposed for turning the slider into a thumbnail navigation for another slider
+
+ // Carousel Options
+ itemWidth: 0, // {NEW} Integer: Box-model width of individual carousel items, including horizontal borders and padding.
+ itemMargin: 0, // {NEW} Integer: Margin between carousel items.
+ minItems: 1, // {NEW} Integer: Minimum number of carousel items that should be visible. Items will resize fluidly when below this.
+ maxItems: 0, // {NEW} Integer: Maxmimum number of carousel items that should be visible. Items will resize fluidly when above this limit.
+ move: 0, // {NEW} Integer: Number of carousel items that should move on animation. If 0, slider will move all visible items.
+ allowOneSlide: true, // {NEW} Boolean: Whether or not to allow a slider comprised of a single slide
+
+ // Callback API
+ start: function() {
+ }, // Callback: function(slider) - Fires when the slider loads the first slide
+ before: function() {
+ }, // Callback: function(slider) - Fires asynchronously with each slider animation
+ after: function() {
+ }, // Callback: function(slider) - Fires after each slider animation completes
+ end: function() {
+ }, // Callback: function(slider) - Fires when the slider reaches the last slide (asynchronous)
+ added: function() {
+ }, // {NEW} Callback: function(slider) - Fires after a slide is added
+ removed: function() {
+ }, // {NEW} Callback: function(slider) - Fires after a slide is removed
+ init: function() {
+ } // {NEW} Callback: function(slider) - Fires after the slider is initially setup
+ };
+
+ // FlexSlider: Plugin Function
+ $.fn.flexslider = function(options) {
+ var args = Array.prototype.slice.call(arguments, 1);
+ if (options === undefined) {options = {};}
+
+ if (typeof options === 'object') {
+ return this.each(function() {
+ var $this = $(this);
+ var selector = (options.selector) ? options.selector : '.am-slides > li';
+ var $slides = $this.find(selector);
+
+ if (( $slides.length === 1 && options.allowOneSlide === false) || $slides.length === 0) {
+ $slides.fadeIn(400);
+ if (options.start) {options.start($this);}
+ } else if ($this.data('flexslider') === undefined) {
+ new $.flexslider(this, options);
+ }
+ });
+ } else {
+ // Helper strings to quickly pecdrform functions on the slider
+ var $slider = $(this).data('flexslider');
+ var methodReturn;
+ switch (options) {
+ case 'next':
+ $slider.flexAnimate($slider.getTarget('next'), true);
+ break;
+ case 'prev':
+ case 'previous':
+ $slider.flexAnimate($slider.getTarget('prev'), true);
+ break;
+ default:
+ if (typeof options === 'number') {
+ $slider.flexAnimate(options, true);
+ } else if (typeof options === 'string') {
+ methodReturn = (typeof $slider[options] === 'function') ?
+ $slider[options].apply($slider, args) : $slider[options];
+ }
+ }
+
+ return methodReturn === undefined ? this : methodReturn;
+ }
+ };
+
+ // Init code
+ UI.ready(function(context) {
+ $('[data-am-flexslider]', context).each(function(i, item) {
+ var $slider = $(item);
+ var options = UI.utils.parseOptions($slider.data('amFlexslider'));
+
+ options.before = function(slider) {
+ if (slider._pausedTimer) {
+ window.clearTimeout(slider._pausedTimer);
+ slider._pausedTimer = null;
+ }
+ };
+
+ options.after = function(slider) {
+ var pauseTime = slider.vars.playAfterPaused;
+ if (pauseTime && !isNaN(pauseTime) && !slider.playing) {
+ if (!slider.manualPause && !slider.manualPlay && !slider.stopped) {
+ slider._pausedTimer = window.setTimeout(function() {
+ slider.play();
+ }, pauseTime);
+ }
+ }
+ };
+
+ $slider.flexslider(options);
+ });
+ });
+
+ module.exports = $.flexslider;
+
+ /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(12).setImmediate))
+
+/***/ },
+/* 12 */
+/***/ function(module, exports, __webpack_require__) {
+
+ /* WEBPACK VAR INJECTION */(function(setImmediate, clearImmediate) {var nextTick = __webpack_require__(13).nextTick;
+ var apply = Function.prototype.apply;
+ var slice = Array.prototype.slice;
+ var immediateIds = {};
+ var nextImmediateId = 0;
+
+ // DOM APIs, for completeness
+
+ exports.setTimeout = function() {
+ return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout);
+ };
+ exports.setInterval = function() {
+ return new Timeout(apply.call(setInterval, window, arguments), clearInterval);
+ };
+ exports.clearTimeout =
+ exports.clearInterval = function(timeout) { timeout.close(); };
+
+ function Timeout(id, clearFn) {
+ this._id = id;
+ this._clearFn = clearFn;
+ }
+ Timeout.prototype.unref = Timeout.prototype.ref = function() {};
+ Timeout.prototype.close = function() {
+ this._clearFn.call(window, this._id);
+ };
+
+ // Does not start the time, just sets up the members needed.
+ exports.enroll = function(item, msecs) {
+ clearTimeout(item._idleTimeoutId);
+ item._idleTimeout = msecs;
+ };
+
+ exports.unenroll = function(item) {
+ clearTimeout(item._idleTimeoutId);
+ item._idleTimeout = -1;
+ };
+
+ exports._unrefActive = exports.active = function(item) {
+ clearTimeout(item._idleTimeoutId);
+
+ var msecs = item._idleTimeout;
+ if (msecs >= 0) {
+ item._idleTimeoutId = setTimeout(function onTimeout() {
+ if (item._onTimeout)
+ item._onTimeout();
+ }, msecs);
+ }
+ };
+
+ // That's not how node.js implements it but the exposed api is the same.
+ exports.setImmediate = typeof setImmediate === "function" ? setImmediate : function(fn) {
+ var id = nextImmediateId++;
+ var args = arguments.length < 2 ? false : slice.call(arguments, 1);
+
+ immediateIds[id] = true;
+
+ nextTick(function onNextTick() {
+ if (immediateIds[id]) {
+ // fn.call() is faster so we optimize for the common use-case
+ // @see http://jsperf.com/call-apply-segu
+ if (args) {
+ fn.apply(null, args);
+ } else {
+ fn.call(null);
+ }
+ // Prevent ids from leaking
+ exports.clearImmediate(id);
+ }
+ });
+
+ return id;
+ };
+
+ exports.clearImmediate = typeof clearImmediate === "function" ? clearImmediate : function(id) {
+ delete immediateIds[id];
+ };
+ /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(12).setImmediate, __webpack_require__(12).clearImmediate))
+
+/***/ },
+/* 13 */
+/***/ function(module, exports) {
+
+ // shim for using process in browser
+ var process = module.exports = {};
+
+ // cached from whatever global is present so that test runners that stub it
+ // don't break things. But we need to wrap it in a try catch in case it is
+ // wrapped in strict mode code which doesn't define any globals. It's inside a
+ // function because try/catches deoptimize in certain engines.
+
+ var cachedSetTimeout;
+ var cachedClearTimeout;
+
+ (function () {
+ try {
+ cachedSetTimeout = setTimeout;
+ } catch (e) {
+ cachedSetTimeout = function () {
+ throw new Error('setTimeout is not defined');
+ }
+ }
+ try {
+ cachedClearTimeout = clearTimeout;
+ } catch (e) {
+ cachedClearTimeout = function () {
+ throw new Error('clearTimeout is not defined');
+ }
+ }
+ } ())
+ function runTimeout(fun) {
+ if (cachedSetTimeout === setTimeout) {
+ //normal enviroments in sane situations
+ return setTimeout(fun, 0);
+ }
+ try {
+ // when when somebody has screwed with setTimeout but no I.E. maddness
+ return cachedSetTimeout(fun, 0);
+ } catch(e){
+ try {
+ // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
+ return cachedSetTimeout.call(null, fun, 0);
+ } catch(e){
+ // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
+ return cachedSetTimeout.call(this, fun, 0);
+ }
+ }
+
+
+ }
+ function runClearTimeout(marker) {
+ if (cachedClearTimeout === clearTimeout) {
+ //normal enviroments in sane situations
+ return clearTimeout(marker);
+ }
+ try {
+ // when when somebody has screwed with setTimeout but no I.E. maddness
+ return cachedClearTimeout(marker);
+ } catch (e){
+ try {
+ // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
+ return cachedClearTimeout.call(null, marker);
+ } catch (e){
+ // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
+ // Some versions of I.E. have different rules for clearTimeout vs setTimeout
+ return cachedClearTimeout.call(this, marker);
+ }
+ }
+
+
+
+ }
+ var queue = [];
+ var draining = false;
+ var currentQueue;
+ var queueIndex = -1;
+
+ function cleanUpNextTick() {
+ if (!draining || !currentQueue) {
+ return;
+ }
+ draining = false;
+ if (currentQueue.length) {
+ queue = currentQueue.concat(queue);
+ } else {
+ queueIndex = -1;
+ }
+ if (queue.length) {
+ drainQueue();
+ }
+ }
+
+ function drainQueue() {
+ if (draining) {
+ return;
+ }
+ var timeout = runTimeout(cleanUpNextTick);
+ draining = true;
+
+ var len = queue.length;
+ while(len) {
+ currentQueue = queue;
+ queue = [];
+ while (++queueIndex < len) {
+ if (currentQueue) {
+ currentQueue[queueIndex].run();
+ }
+ }
+ queueIndex = -1;
+ len = queue.length;
+ }
+ currentQueue = null;
+ draining = false;
+ runClearTimeout(timeout);
+ }
+
+ process.nextTick = function (fun) {
+ var args = new Array(arguments.length - 1);
+ if (arguments.length > 1) {
+ for (var i = 1; i < arguments.length; i++) {
+ args[i - 1] = arguments[i];
+ }
+ }
+ queue.push(new Item(fun, args));
+ if (queue.length === 1 && !draining) {
+ runTimeout(drainQueue);
+ }
+ };
+
+ // v8 likes predictible objects
+ function Item(fun, array) {
+ this.fun = fun;
+ this.array = array;
+ }
+ Item.prototype.run = function () {
+ this.fun.apply(null, this.array);
+ };
+ process.title = 'browser';
+ process.browser = true;
+ process.env = {};
+ process.argv = [];
+ process.version = ''; // empty string to avoid regexp issues
+ process.versions = {};
+
+ function noop() {}
+
+ process.on = noop;
+ process.addListener = noop;
+ process.once = noop;
+ process.off = noop;
+ process.removeListener = noop;
+ process.removeAllListeners = noop;
+ process.emit = noop;
+
+ process.binding = function (name) {
+ throw new Error('process.binding is not supported');
+ };
+
+ process.cwd = function () { return '/' };
+ process.chdir = function (dir) {
+ throw new Error('process.chdir is not supported');
+ };
+ process.umask = function() { return 0; };
+
+
+/***/ },
+/* 14 */
+/***/ function(module, exports, __webpack_require__) {
+
+ 'use strict';
+
+ var UI = __webpack_require__(2);
+
+ /*! iScroll v5.2.0
+ * (c) 2008-2016 Matteo Spinelli
+ * http://cubiq.org/license
+ */
+
+ var rAF = UI.utils.rAF;
+
+ var utils = (function() {
+ var me = {};
+
+ var _elementStyle = document.createElement('div').style;
+ var _vendor = (function() {
+ var vendors = ['t', 'webkitT', 'MozT', 'msT', 'OT'],
+ transform,
+ i = 0,
+ l = vendors.length;
+
+ for (; i < l; i++) {
+ transform = vendors[i] + 'ransform';
+ if (transform in _elementStyle) return vendors[i].substr(0, vendors[i].length - 1);
+ }
+
+ return false;
+ })();
+
+ function _prefixStyle(style) {
+ if (_vendor === false) return false;
+ if (_vendor === '') return style;
+ return _vendor + style.charAt(0).toUpperCase() + style.substr(1);
+ }
+
+ me.getTime = Date.now || function getTime() {
+ return new Date().getTime();
+ };
+
+ me.extend = function(target, obj) {
+ for (var i in obj) {
+ target[i] = obj[i];
+ }
+ };
+
+ me.addEvent = function(el, type, fn, capture) {
+ el.addEventListener(type, fn, !!capture);
+ };
+
+ me.removeEvent = function(el, type, fn, capture) {
+ el.removeEventListener(type, fn, !!capture);
+ };
+
+ me.prefixPointerEvent = function(pointerEvent) {
+ return window.MSPointerEvent ?
+ 'MSPointer' + pointerEvent.charAt(7)
+ .toUpperCase() + pointerEvent.substr(8) :
+ pointerEvent;
+ };
+
+ me.momentum = function(current, start, time, lowerMargin, wrapperSize, deceleration) {
+ var distance = current - start,
+ speed = Math.abs(distance) / time,
+ destination,
+ duration;
+
+ deceleration = deceleration === undefined ? 0.0006 : deceleration;
+
+ destination = current + ( speed * speed ) / ( 2 * deceleration ) * ( distance < 0 ? -1 : 1 );
+ duration = speed / deceleration;
+
+ if (destination < lowerMargin) {
+ destination = wrapperSize ? lowerMargin - ( wrapperSize / 2.5 * ( speed / 8 ) ) : lowerMargin;
+ distance = Math.abs(destination - current);
+ duration = distance / speed;
+ } else if (destination > 0) {
+ destination = wrapperSize ? wrapperSize / 2.5 * ( speed / 8 ) : 0;
+ distance = Math.abs(current) + destination;
+ duration = distance / speed;
+ }
+
+ return {
+ destination: Math.round(destination),
+ duration: duration
+ };
+ };
+
+ var _transform = _prefixStyle('transform');
+
+ me.extend(me, {
+ hasTransform: _transform !== false,
+ hasPerspective: _prefixStyle('perspective') in _elementStyle,
+ hasTouch: 'ontouchstart' in window,
+ hasPointer: !!(window.PointerEvent || window.MSPointerEvent), // IE10 is prefixed
+ hasTransition: _prefixStyle('transition') in _elementStyle
+ });
+
+ /*
+ This should find all Android browsers lower than build 535.19 (both stock browser and webview)
+ - galaxy S2 is ok
+ - 2.3.6 : `AppleWebKit/533.1 (KHTML, like Gecko) Version/4.0 Mobile Safari/533.1`
+ - 4.0.4 : `AppleWebKit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30`
+ - galaxy S3 is badAndroid (stock brower, webview)
+ `AppleWebKit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30`
+ - galaxy S4 is badAndroid (stock brower, webview)
+ `AppleWebKit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30`
+ - galaxy S5 is OK
+ `AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Mobile Safari/537.36 (Chrome/)`
+ - galaxy S6 is OK
+ `AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Mobile Safari/537.36 (Chrome/)`
+ */
+ me.isBadAndroid = (function() {
+ var appVersion = window.navigator.appVersion;
+ // Android browser is not a chrome browser.
+ if (/Android/.test(appVersion) && !(/Chrome\/\d/.test(appVersion))) {
+ var safariVersion = appVersion.match(/Safari\/(\d+.\d)/);
+ if (safariVersion && typeof safariVersion === "object" && safariVersion.length >= 2) {
+ return parseFloat(safariVersion[1]) < 535.19;
+ } else {
+ return true;
+ }
+ } else {
+ return false;
+ }
+ })();
+
+ me.extend(me.style = {}, {
+ transform: _transform,
+ transitionTimingFunction: _prefixStyle('transitionTimingFunction'),
+ transitionDuration: _prefixStyle('transitionDuration'),
+ transitionDelay: _prefixStyle('transitionDelay'),
+ transformOrigin: _prefixStyle('transformOrigin')
+ });
+
+ me.hasClass = function(e, c) {
+ var re = new RegExp("(^|\\s)" + c + "(\\s|$)");
+ return re.test(e.className);
+ };
+
+ me.addClass = function(e, c) {
+ if (me.hasClass(e, c)) {
+ return;
+ }
+
+ var newclass = e.className.split(' ');
+ newclass.push(c);
+ e.className = newclass.join(' ');
+ };
+
+ me.removeClass = function(e, c) {
+ if (!me.hasClass(e, c)) {
+ return;
+ }
+
+ var re = new RegExp("(^|\\s)" + c + "(\\s|$)", 'g');
+ e.className = e.className.replace(re, ' ');
+ };
+
+ me.offset = function(el) {
+ var left = -el.offsetLeft,
+ top = -el.offsetTop;
+
+ // jshint -W084
+ while (el = el.offsetParent) {
+ left -= el.offsetLeft;
+ top -= el.offsetTop;
+ }
+ // jshint +W084
+
+ return {
+ left: left,
+ top: top
+ };
+ };
+
+ me.preventDefaultException = function(el, exceptions) {
+ for (var i in exceptions) {
+ if (exceptions[i].test(el[i])) {
+ return true;
+ }
+ }
+
+ return false;
+ };
+
+ me.extend(me.eventType = {}, {
+ touchstart: 1,
+ touchmove: 1,
+ touchend: 1,
+
+ mousedown: 2,
+ mousemove: 2,
+ mouseup: 2,
+
+ pointerdown: 3,
+ pointermove: 3,
+ pointerup: 3,
+
+ MSPointerDown: 3,
+ MSPointerMove: 3,
+ MSPointerUp: 3
+ });
+
+ me.extend(me.ease = {}, {
+ quadratic: {
+ style: 'cubic-bezier(0.25, 0.46, 0.45, 0.94)',
+ fn: function(k) {
+ return k * ( 2 - k );
+ }
+ },
+ circular: {
+ style: 'cubic-bezier(0.1, 0.57, 0.1, 1)', // Not properly "circular" but this looks better, it should be (0.075, 0.82, 0.165, 1)
+ fn: function(k) {
+ return Math.sqrt(1 - ( --k * k ));
+ }
+ },
+ back: {
+ style: 'cubic-bezier(0.175, 0.885, 0.32, 1.275)',
+ fn: function(k) {
+ var b = 4;
+ return ( k = k - 1 ) * k * ( ( b + 1 ) * k + b ) + 1;
+ }
+ },
+ bounce: {
+ style: '',
+ fn: function(k) {
+ if (( k /= 1 ) < ( 1 / 2.75 )) {
+ return 7.5625 * k * k;
+ } else if (k < ( 2 / 2.75 )) {
+ return 7.5625 * ( k -= ( 1.5 / 2.75 ) ) * k + 0.75;
+ } else if (k < ( 2.5 / 2.75 )) {
+ return 7.5625 * ( k -= ( 2.25 / 2.75 ) ) * k + 0.9375;
+ } else {
+ return 7.5625 * ( k -= ( 2.625 / 2.75 ) ) * k + 0.984375;
+ }
+ }
+ },
+ elastic: {
+ style: '',
+ fn: function(k) {
+ var f = 0.22,
+ e = 0.4;
+
+ if (k === 0) {
+ return 0;
+ }
+ if (k == 1) {
+ return 1;
+ }
+
+ return ( e * Math.pow(2, -10 * k) * Math.sin(( k - f / 4 ) * ( 2 * Math.PI ) / f) + 1 );
+ }
+ }
+ });
+
+ me.tap = function(e, eventName) {
+ var ev = document.createEvent('Event');
+ ev.initEvent(eventName, true, true);
+ ev.pageX = e.pageX;
+ ev.pageY = e.pageY;
+ e.target.dispatchEvent(ev);
+ };
+
+ me.click = function(e) {
+ var target = e.target,
+ ev;
+
+ if (!(/(SELECT|INPUT|TEXTAREA)/i).test(target.tagName)) {
+ // https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/initMouseEvent
+ // initMouseEvent is deprecated.
+ ev = document.createEvent(window.MouseEvent ? 'MouseEvents' : 'Event');
+ ev.initEvent('click', true, true);
+ ev.view = e.view || window;
+ ev.detail = 1;
+ ev.screenX = target.screenX || 0;
+ ev.screenY = target.screenY || 0;
+ ev.clientX = target.clientX || 0;
+ ev.clientY = target.clientY || 0;
+ ev.ctrlKey = !!e.ctrlKey;
+ ev.altKey = !!e.altKey;
+ ev.shiftKey = !!e.shiftKey;
+ ev.metaKey = !!e.metaKey;
+ ev.button = 0;
+ ev.relatedTarget = null;
+ ev._constructed = true;
+ target.dispatchEvent(ev);
+ }
+ };
+
+ return me;
+ })();
+ function IScroll(el, options) {
+ this.wrapper = typeof el == 'string' ? document.querySelector(el) : el;
+ this.scroller = this.wrapper.children[0];
+ this.scrollerStyle = this.scroller.style; // cache style for better performance
+
+ this.options = {
+
+ // INSERT POINT: OPTIONS
+ disablePointer: !utils.hasPointer,
+ disableTouch: utils.hasPointer || !utils.hasTouch,
+ disableMouse: utils.hasPointer || utils.hasTouch,
+ startX: 0,
+ startY: 0,
+ scrollY: true,
+ directionLockThreshold: 5,
+ momentum: true,
+
+ bounce: true,
+ bounceTime: 600,
+ bounceEasing: '',
+
+ preventDefault: true,
+ preventDefaultException: {tagName: /^(INPUT|TEXTAREA|BUTTON|SELECT)$/},
+
+ HWCompositing: true,
+ useTransition: true,
+ useTransform: true,
+ bindToWrapper: typeof window.onmousedown === "undefined"
+ };
+
+ for (var i in options) {
+ this.options[i] = options[i];
+ }
+
+ // Normalize options
+ this.translateZ = this.options.HWCompositing && utils.hasPerspective ? ' translateZ(0)' : '';
+
+ this.options.useTransition = utils.hasTransition && this.options.useTransition;
+ this.options.useTransform = utils.hasTransform && this.options.useTransform;
+
+ this.options.eventPassthrough = this.options.eventPassthrough === true ? 'vertical' : this.options.eventPassthrough;
+ this.options.preventDefault = !this.options.eventPassthrough && this.options.preventDefault;
+
+ // If you want eventPassthrough I have to lock one of the axes
+ this.options.scrollY = this.options.eventPassthrough == 'vertical' ? false : this.options.scrollY;
+ this.options.scrollX = this.options.eventPassthrough == 'horizontal' ? false : this.options.scrollX;
+
+ // With eventPassthrough we also need lockDirection mechanism
+ this.options.freeScroll = this.options.freeScroll && !this.options.eventPassthrough;
+ this.options.directionLockThreshold = this.options.eventPassthrough ? 0 : this.options.directionLockThreshold;
+
+ this.options.bounceEasing = typeof this.options.bounceEasing == 'string' ? utils.ease[this.options.bounceEasing] || utils.ease.circular : this.options.bounceEasing;
+
+ this.options.resizePolling = this.options.resizePolling === undefined ? 60 : this.options.resizePolling;
+
+ if (this.options.tap === true) {
+ this.options.tap = 'tap';
+ }
+
+ // https://github.com/cubiq/iscroll/issues/1029
+ if (!this.options.useTransition && !this.options.useTransform) {
+ if (!(/relative|absolute/i).test(this.scrollerStyle.position)) {
+ this.scrollerStyle.position = "relative";
+ }
+ }
+
+ // INSERT POINT: NORMALIZATION
+
+ // Some defaults
+ this.x = 0;
+ this.y = 0;
+ this.directionX = 0;
+ this.directionY = 0;
+ this._events = {};
+
+ // INSERT POINT: DEFAULTS
+
+ this._init();
+ this.refresh();
+
+ this.scrollTo(this.options.startX, this.options.startY);
+ this.enable();
+ }
+
+ IScroll.prototype = {
+ version: '5.2.0',
+
+ _init: function() {
+ this._initEvents();
+
+ // INSERT POINT: _init
+
+ },
+
+ destroy: function() {
+ this._initEvents(true);
+ clearTimeout(this.resizeTimeout);
+ this.resizeTimeout = null;
+ this._execEvent('destroy');
+ },
+
+ _transitionEnd: function(e) {
+ if (e.target != this.scroller || !this.isInTransition) {
+ return;
+ }
+
+ this._transitionTime();
+ if (!this.resetPosition(this.options.bounceTime)) {
+ this.isInTransition = false;
+ this._execEvent('scrollEnd');
+ }
+ },
+
+ _start: function(e) {
+ // React to left mouse button only
+ if (utils.eventType[e.type] != 1) {
+ // for button property
+ // http://unixpapa.com/js/mouse.html
+ var button;
+ if (!e.which) {
+ /* IE case */
+ button = (e.button < 2) ? 0 :
+ ((e.button == 4) ? 1 : 2);
+ } else {
+ /* All others */
+ button = e.button;
+ }
+ if (button !== 0) {
+ return;
+ }
+ }
+
+ if (!this.enabled || (this.initiated && utils.eventType[e.type] !== this.initiated)) {
+ return;
+ }
+
+ if (this.options.preventDefault && !utils.isBadAndroid && !utils.preventDefaultException(e.target, this.options.preventDefaultException)) {
+ e.preventDefault();
+ }
+
+ var point = e.touches ? e.touches[0] : e,
+ pos;
+
+ this.initiated = utils.eventType[e.type];
+ this.moved = false;
+ this.distX = 0;
+ this.distY = 0;
+ this.directionX = 0;
+ this.directionY = 0;
+ this.directionLocked = 0;
+
+ this.startTime = utils.getTime();
+
+ if (this.options.useTransition && this.isInTransition) {
+ this._transitionTime();
+ this.isInTransition = false;
+ pos = this.getComputedPosition();
+ this._translate(Math.round(pos.x), Math.round(pos.y));
+ this._execEvent('scrollEnd');
+ } else if (!this.options.useTransition && this.isAnimating) {
+ this.isAnimating = false;
+ this._execEvent('scrollEnd');
+ }
+
+ this.startX = this.x;
+ this.startY = this.y;
+ this.absStartX = this.x;
+ this.absStartY = this.y;
+ this.pointX = point.pageX;
+ this.pointY = point.pageY;
+
+ this._execEvent('beforeScrollStart');
+ },
+
+ _move: function(e) {
+ if (!this.enabled || utils.eventType[e.type] !== this.initiated) {
+ return;
+ }
+
+ if (this.options.preventDefault) { // increases performance on Android? TODO: check!
+ e.preventDefault();
+ }
+
+ var point = e.touches ? e.touches[0] : e,
+ deltaX = point.pageX - this.pointX,
+ deltaY = point.pageY - this.pointY,
+ timestamp = utils.getTime(),
+ newX, newY,
+ absDistX, absDistY;
+
+ this.pointX = point.pageX;
+ this.pointY = point.pageY;
+
+ this.distX += deltaX;
+ this.distY += deltaY;
+ absDistX = Math.abs(this.distX);
+ absDistY = Math.abs(this.distY);
+
+ // We need to move at least 10 pixels for the scrolling to initiate
+ if (timestamp - this.endTime > 300 && (absDistX < 10 && absDistY < 10)) {
+ return;
+ }
+
+ // If you are scrolling in one direction lock the other
+ if (!this.directionLocked && !this.options.freeScroll) {
+ if (absDistX > absDistY + this.options.directionLockThreshold) {
+ this.directionLocked = 'h'; // lock horizontally
+ } else if (absDistY >= absDistX + this.options.directionLockThreshold) {
+ this.directionLocked = 'v'; // lock vertically
+ } else {
+ this.directionLocked = 'n'; // no lock
+ }
+ }
+
+ if (this.directionLocked == 'h') {
+ if (this.options.eventPassthrough == 'vertical') {
+ e.preventDefault();
+ } else if (this.options.eventPassthrough == 'horizontal') {
+ this.initiated = false;
+ return;
+ }
+
+ deltaY = 0;
+ } else if (this.directionLocked == 'v') {
+ if (this.options.eventPassthrough == 'horizontal') {
+ e.preventDefault();
+ } else if (this.options.eventPassthrough == 'vertical') {
+ this.initiated = false;
+ return;
+ }
+
+ deltaX = 0;
+ }
+
+ deltaX = this.hasHorizontalScroll ? deltaX : 0;
+ deltaY = this.hasVerticalScroll ? deltaY : 0;
+
+ newX = this.x + deltaX;
+ newY = this.y + deltaY;
+
+ // Slow down if outside of the boundaries
+ if (newX > 0 || newX < this.maxScrollX) {
+ newX = this.options.bounce ? this.x + deltaX / 3 : newX > 0 ? 0 : this.maxScrollX;
+ }
+ if (newY > 0 || newY < this.maxScrollY) {
+ newY = this.options.bounce ? this.y + deltaY / 3 : newY > 0 ? 0 : this.maxScrollY;
+ }
+
+ this.directionX = deltaX > 0 ? -1 : deltaX < 0 ? 1 : 0;
+ this.directionY = deltaY > 0 ? -1 : deltaY < 0 ? 1 : 0;
+
+ if (!this.moved) {
+ this._execEvent('scrollStart');
+ }
+
+ this.moved = true;
+
+ this._translate(newX, newY);
+
+ /* REPLACE START: _move */
+
+ if (timestamp - this.startTime > 300) {
+ this.startTime = timestamp;
+ this.startX = this.x;
+ this.startY = this.y;
+ }
+
+ /* REPLACE END: _move */
+
+ },
+
+ _end: function(e) {
+ if (!this.enabled || utils.eventType[e.type] !== this.initiated) {
+ return;
+ }
+
+ if (this.options.preventDefault && !utils.preventDefaultException(e.target, this.options.preventDefaultException)) {
+ e.preventDefault();
+ }
+
+ var point = e.changedTouches ? e.changedTouches[0] : e,
+ momentumX,
+ momentumY,
+ duration = utils.getTime() - this.startTime,
+ newX = Math.round(this.x),
+ newY = Math.round(this.y),
+ distanceX = Math.abs(newX - this.startX),
+ distanceY = Math.abs(newY - this.startY),
+ time = 0,
+ easing = '';
+
+ this.isInTransition = 0;
+ this.initiated = 0;
+ this.endTime = utils.getTime();
+
+ // reset if we are outside of the boundaries
+ if (this.resetPosition(this.options.bounceTime)) {
+ return;
+ }
+
+ this.scrollTo(newX, newY); // ensures that the last position is rounded
+
+ // we scrolled less than 10 pixels
+ if (!this.moved) {
+ if (this.options.tap) {
+ utils.tap(e, this.options.tap);
+ }
+
+ if (this.options.click) {
+ utils.click(e);
+ }
+
+ this._execEvent('scrollCancel');
+ return;
+ }
+
+ if (this._events.flick && duration < 200 && distanceX < 100 && distanceY < 100) {
+ this._execEvent('flick');
+ return;
+ }
+
+ // start momentum animation if needed
+ if (this.options.momentum && duration < 300) {
+ momentumX = this.hasHorizontalScroll ? utils.momentum(this.x, this.startX, duration, this.maxScrollX, this.options.bounce ? this.wrapperWidth : 0, this.options.deceleration) : {
+ destination: newX,
+ duration: 0
+ };
+ momentumY = this.hasVerticalScroll ? utils.momentum(this.y, this.startY, duration, this.maxScrollY, this.options.bounce ? this.wrapperHeight : 0, this.options.deceleration) : {
+ destination: newY,
+ duration: 0
+ };
+ newX = momentumX.destination;
+ newY = momentumY.destination;
+ time = Math.max(momentumX.duration, momentumY.duration);
+ this.isInTransition = 1;
+ }
+
+ // INSERT POINT: _end
+
+ if (newX != this.x || newY != this.y) {
+ // change easing function when scroller goes out of the boundaries
+ if (newX > 0 || newX < this.maxScrollX || newY > 0 || newY < this.maxScrollY) {
+ easing = utils.ease.quadratic;
+ }
+
+ this.scrollTo(newX, newY, time, easing);
+ return;
+ }
+
+ this._execEvent('scrollEnd');
+ },
+
+ _resize: function() {
+ var that = this;
+
+ clearTimeout(this.resizeTimeout);
+
+ this.resizeTimeout = setTimeout(function() {
+ that.refresh();
+ }, this.options.resizePolling);
+ },
+
+ resetPosition: function(time) {
+ var x = this.x,
+ y = this.y;
+
+ time = time || 0;
+
+ if (!this.hasHorizontalScroll || this.x > 0) {
+ x = 0;
+ } else if (this.x < this.maxScrollX) {
+ x = this.maxScrollX;
+ }
+
+ if (!this.hasVerticalScroll || this.y > 0) {
+ y = 0;
+ } else if (this.y < this.maxScrollY) {
+ y = this.maxScrollY;
+ }
+
+ if (x == this.x && y == this.y) {
+ return false;
+ }
+
+ this.scrollTo(x, y, time, this.options.bounceEasing);
+
+ return true;
+ },
+
+ disable: function() {
+ this.enabled = false;
+ },
+
+ enable: function() {
+ this.enabled = true;
+ },
+
+ refresh: function() {
+ var rf = this.wrapper.offsetHeight; // Force reflow
+
+ this.wrapperWidth = this.wrapper.clientWidth;
+ this.wrapperHeight = this.wrapper.clientHeight;
+
+ /* REPLACE START: refresh */
+
+ this.scrollerWidth = this.scroller.offsetWidth;
+ this.scrollerHeight = this.scroller.offsetHeight;
+
+ this.maxScrollX = this.wrapperWidth - this.scrollerWidth;
+ this.maxScrollY = this.wrapperHeight - this.scrollerHeight;
+
+ /* REPLACE END: refresh */
+
+ this.hasHorizontalScroll = this.options.scrollX && this.maxScrollX < 0;
+ this.hasVerticalScroll = this.options.scrollY && this.maxScrollY < 0;
+
+ if (!this.hasHorizontalScroll) {
+ this.maxScrollX = 0;
+ this.scrollerWidth = this.wrapperWidth;
+ }
+
+ if (!this.hasVerticalScroll) {
+ this.maxScrollY = 0;
+ this.scrollerHeight = this.wrapperHeight;
+ }
+
+ this.endTime = 0;
+ this.directionX = 0;
+ this.directionY = 0;
+
+ this.wrapperOffset = utils.offset(this.wrapper);
+
+ this._execEvent('refresh');
+
+ this.resetPosition();
+
+ // INSERT POINT: _refresh
+
+ },
+
+ on: function(type, fn) {
+ if (!this._events[type]) {
+ this._events[type] = [];
+ }
+
+ this._events[type].push(fn);
+ },
+
+ off: function(type, fn) {
+ if (!this._events[type]) {
+ return;
+ }
+
+ var index = this._events[type].indexOf(fn);
+
+ if (index > -1) {
+ this._events[type].splice(index, 1);
+ }
+ },
+
+ _execEvent: function(type) {
+ if (!this._events[type]) {
+ return;
+ }
+
+ var i = 0,
+ l = this._events[type].length;
+
+ if (!l) {
+ return;
+ }
+
+ for (; i < l; i++) {
+ this._events[type][i].apply(this, [].slice.call(arguments, 1));
+ }
+ },
+
+ scrollBy: function(x, y, time, easing) {
+ x = this.x + x;
+ y = this.y + y;
+ time = time || 0;
+
+ this.scrollTo(x, y, time, easing);
+ },
+
+ scrollTo: function(x, y, time, easing) {
+ easing = easing || utils.ease.circular;
+
+ this.isInTransition = this.options.useTransition && time > 0;
+ var transitionType = this.options.useTransition && easing.style;
+ if (!time || transitionType) {
+ if (transitionType) {
+ this._transitionTimingFunction(easing.style);
+ this._transitionTime(time);
+ }
+ this._translate(x, y);
+ } else {
+ this._animate(x, y, time, easing.fn);
+ }
+ },
+
+ scrollToElement: function(el, time, offsetX, offsetY, easing) {
+ el = el.nodeType ? el : this.scroller.querySelector(el);
+
+ if (!el) {
+ return;
+ }
+
+ var pos = utils.offset(el);
+
+ pos.left -= this.wrapperOffset.left;
+ pos.top -= this.wrapperOffset.top;
+
+ // if offsetX/Y are true we center the element to the screen
+ if (offsetX === true) {
+ offsetX = Math.round(el.offsetWidth / 2 - this.wrapper.offsetWidth / 2);
+ }
+ if (offsetY === true) {
+ offsetY = Math.round(el.offsetHeight / 2 - this.wrapper.offsetHeight / 2);
+ }
+
+ pos.left -= offsetX || 0;
+ pos.top -= offsetY || 0;
+
+ pos.left = pos.left > 0 ? 0 : pos.left < this.maxScrollX ? this.maxScrollX : pos.left;
+ pos.top = pos.top > 0 ? 0 : pos.top < this.maxScrollY ? this.maxScrollY : pos.top;
+
+ time = time === undefined || time === null || time === 'auto' ? Math.max(Math.abs(this.x - pos.left), Math.abs(this.y - pos.top)) : time;
+
+ this.scrollTo(pos.left, pos.top, time, easing);
+ },
+
+ _transitionTime: function(time) {
+ if (!this.options.useTransition) {
+ return;
+ }
+ time = time || 0;
+ var durationProp = utils.style.transitionDuration;
+ if (!durationProp) {
+ return;
+ }
+
+ this.scrollerStyle[durationProp] = time + 'ms';
+
+ if (!time && utils.isBadAndroid) {
+ this.scrollerStyle[durationProp] = '0.0001ms';
+ // remove 0.0001ms
+ var self = this;
+ rAF(function() {
+ if (self.scrollerStyle[durationProp] === '0.0001ms') {
+ self.scrollerStyle[durationProp] = '0s';
+ }
+ });
+ }
+
+ // INSERT POINT: _transitionTime
+
+ },
+
+ _transitionTimingFunction: function(easing) {
+ this.scrollerStyle[utils.style.transitionTimingFunction] = easing;
+
+ // INSERT POINT: _transitionTimingFunction
+
+ },
+
+ _translate: function(x, y) {
+ if (this.options.useTransform) {
+
+ /* REPLACE START: _translate */
+
+ this.scrollerStyle[utils.style.transform] = 'translate(' + x + 'px,' + y + 'px)' + this.translateZ;
+
+ /* REPLACE END: _translate */
+
+ } else {
+ x = Math.round(x);
+ y = Math.round(y);
+ this.scrollerStyle.left = x + 'px';
+ this.scrollerStyle.top = y + 'px';
+ }
+
+ this.x = x;
+ this.y = y;
+
+ // INSERT POINT: _translate
+
+ },
+
+ _initEvents: function(remove) {
+ var eventType = remove ? utils.removeEvent : utils.addEvent,
+ target = this.options.bindToWrapper ? this.wrapper : window;
+
+ eventType(window, 'orientationchange', this);
+ eventType(window, 'resize', this);
+
+ if (this.options.click) {
+ eventType(this.wrapper, 'click', this, true);
+ }
+
+ if (!this.options.disableMouse) {
+ eventType(this.wrapper, 'mousedown', this);
+ eventType(target, 'mousemove', this);
+ eventType(target, 'mousecancel', this);
+ eventType(target, 'mouseup', this);
+ }
+
+ if (utils.hasPointer && !this.options.disablePointer) {
+ eventType(this.wrapper, utils.prefixPointerEvent('pointerdown'), this);
+ eventType(target, utils.prefixPointerEvent('pointermove'), this);
+ eventType(target, utils.prefixPointerEvent('pointercancel'), this);
+ eventType(target, utils.prefixPointerEvent('pointerup'), this);
+ }
+
+ if (utils.hasTouch && !this.options.disableTouch) {
+ eventType(this.wrapper, 'touchstart', this);
+ eventType(target, 'touchmove', this);
+ eventType(target, 'touchcancel', this);
+ eventType(target, 'touchend', this);
+ }
+
+ eventType(this.scroller, 'transitionend', this);
+ eventType(this.scroller, 'webkitTransitionEnd', this);
+ eventType(this.scroller, 'oTransitionEnd', this);
+ eventType(this.scroller, 'MSTransitionEnd', this);
+ },
+
+ getComputedPosition: function() {
+ var matrix = window.getComputedStyle(this.scroller, null),
+ x, y;
+
+ if (this.options.useTransform) {
+ matrix = matrix[utils.style.transform].split(')')[0].split(', ');
+ x = +(matrix[12] || matrix[4]);
+ y = +(matrix[13] || matrix[5]);
+ } else {
+ x = +matrix.left.replace(/[^-\d.]/g, '');
+ y = +matrix.top.replace(/[^-\d.]/g, '');
+ }
+
+ return {x: x, y: y};
+ },
+ _animate: function(destX, destY, duration, easingFn) {
+ var that = this,
+ startX = this.x,
+ startY = this.y,
+ startTime = utils.getTime(),
+ destTime = startTime + duration;
+
+ function step() {
+ var now = utils.getTime(),
+ newX, newY,
+ easing;
+
+ if (now >= destTime) {
+ that.isAnimating = false;
+ that._translate(destX, destY);
+
+ if (!that.resetPosition(that.options.bounceTime)) {
+ that._execEvent('scrollEnd');
+ }
+
+ return;
+ }
+
+ now = ( now - startTime ) / duration;
+ easing = easingFn(now);
+ newX = ( destX - startX ) * easing + startX;
+ newY = ( destY - startY ) * easing + startY;
+ that._translate(newX, newY);
+
+ if (that.isAnimating) {
+ rAF(step);
+ }
+ }
+
+ this.isAnimating = true;
+ step();
+ },
+ handleEvent: function(e) {
+ switch (e.type) {
+ case 'touchstart':
+ case 'pointerdown':
+ case 'MSPointerDown':
+ case 'mousedown':
+ this._start(e);
+ break;
+ case 'touchmove':
+ case 'pointermove':
+ case 'MSPointerMove':
+ case 'mousemove':
+ this._move(e);
+ break;
+ case 'touchend':
+ case 'pointerup':
+ case 'MSPointerUp':
+ case 'mouseup':
+ case 'touchcancel':
+ case 'pointercancel':
+ case 'MSPointerCancel':
+ case 'mousecancel':
+ this._end(e);
+ break;
+ case 'orientationchange':
+ case 'resize':
+ this._resize();
+ break;
+ case 'transitionend':
+ case 'webkitTransitionEnd':
+ case 'oTransitionEnd':
+ case 'MSTransitionEnd':
+ this._transitionEnd(e);
+ break;
+ case 'wheel':
+ case 'DOMMouseScroll':
+ case 'mousewheel':
+ this._wheel(e);
+ break;
+ case 'keydown':
+ this._key(e);
+ break;
+ case 'click':
+ if (this.enabled && !e._constructed) {
+ e.preventDefault();
+ e.stopPropagation();
+ }
+ break;
+ }
+ }
+ };
+
+ IScroll.utils = utils;
+
+ module.exports = UI.iScroll = IScroll;
+
+ /* jshint unused: true */
+ /* jshint +W101, +W116, +W109 */
+
+
+/***/ },
+/* 15 */
+/***/ function(module, exports, __webpack_require__) {
+
+ 'use strict';
+
+ var $ = __webpack_require__(1);
+ var UI = __webpack_require__(2);
+ var dimmer = __webpack_require__(9);
+ var $doc = $(document);
+ var supportTransition = UI.support.transition;
+
+ /**
+ * @reference https://github.com/nolimits4web/Framework7/blob/master/src/js/modals.js
+ * @license https://github.com/nolimits4web/Framework7/blob/master/LICENSE
+ */
+
+ var Modal = function(element, options) {
+ this.options = $.extend({}, Modal.DEFAULTS, options || {});
+ this.$element = $(element);
+ this.$dialog = this.$element.find('.am-modal-dialog');
+
+ if (!this.$element.attr('id')) {
+ this.$element.attr('id', UI.utils.generateGUID('am-modal'));
+ }
+
+ this.isPopup = this.$element.hasClass('am-popup');
+ this.isActions = this.$element.hasClass('am-modal-actions');
+ this.isPrompt = this.$element.hasClass('am-modal-prompt');
+ this.isLoading = this.$element.hasClass('am-modal-loading');
+ this.active = this.transitioning = this.relatedTarget = null;
+ this.dimmer = this.options.dimmer ? dimmer : {
+ open: function() {
+ },
+ close: function() {
+ }
+ };
+
+ this.events();
+ };
+
+ Modal.DEFAULTS = {
+ className: {
+ active: 'am-modal-active',
+ out: 'am-modal-out'
+ },
+ selector: {
+ modal: '.am-modal',
+ active: '.am-modal-active'
+ },
+ closeViaDimmer: true,
+ cancelable: true,
+ onConfirm: function() {
+ },
+ onCancel: function() {
+ },
+ closeOnCancel: true,
+ closeOnConfirm: true,
+ dimmer: true,
+ height: undefined,
+ width: undefined,
+ duration: 300, // must equal the CSS transition duration
+ transitionEnd: supportTransition && supportTransition.end + '.modal.amui'
+ };
+
+ Modal.prototype.toggle = function(relatedTarget) {
+ return this.active ? this.close() : this.open(relatedTarget);
+ };
+
+ Modal.prototype.open = function(relatedTarget) {
+ var $element = this.$element;
+ var options = this.options;
+ var isPopup = this.isPopup;
+ var width = options.width;
+ var height = options.height;
+ var style = {};
+
+ if (this.active) {
+ return;
+ }
+
+ if (!this.$element.length) {
+ return;
+ }
+
+ // callback hook
+ relatedTarget && (this.relatedTarget = relatedTarget);
+
+ // 判断如果还在动画，就先触发之前的closed事件
+ if (this.transitioning) {
+ clearTimeout($element.transitionEndTimmer);
+ $element.transitionEndTimmer = null;
+ $element.trigger(options.transitionEnd)
+ .off(options.transitionEnd);
+ }
+
+ isPopup && this.$element.show();
+
+ this.active = true;
+
+ $element.trigger($.Event('open.modal.amui', {relatedTarget: relatedTarget}));
+
+ this.dimmer.open($element);
+
+ $element.show().redraw();
+
+ // apply Modal width/height if set
+ if (!isPopup && !this.isActions) {
+ if (width) {
+ style.width = parseInt(width, 10) + 'px';
+ }
+
+ if (height) {
+ style.height = parseInt(height, 10) + 'px';
+ }
+
+ this.$dialog.css(style);
+ }
+
+ $element
+ .removeClass(options.className.out)
+ .addClass(options.className.active);
+
+ this.transitioning = 1;
+
+ var complete = function() {
+ $element.trigger($.Event('opened.modal.amui', {
+ relatedTarget: relatedTarget
+ }));
+ this.transitioning = 0;
+
+ // Prompt auto focus
+ if (this.isPrompt) {
+ this.$dialog.find('input').eq(0).focus();
+ }
+ };
+
+ if (!supportTransition) {
+ return complete.call(this);
+ }
+
+ $element
+ .one(options.transitionEnd, $.proxy(complete, this))
+ .emulateTransitionEnd(options.duration);
+ };
+
+ Modal.prototype.close = function(relatedTarget) {
+ if (!this.active) {
+ return;
+ }
+
+ var $element = this.$element;
+ var options = this.options;
+ var isPopup = this.isPopup;
+
+ // 判断如果还在动画，就先触发之前的opened事件
+ if (this.transitioning) {
+ clearTimeout($element.transitionEndTimmer);
+ $element.transitionEndTimmer = null;
+ $element.trigger(options.transitionEnd).off(options.transitionEnd);
+ this.dimmer.close($element, true);
+ }
+
+ this.$element.trigger($.Event('close.modal.amui', {
+ relatedTarget: relatedTarget
+ }));
+
+ this.transitioning = 1;
+
+ var complete = function() {
+ $element.trigger('closed.modal.amui');
+ isPopup && $element.removeClass(options.className.out);
+ $element.hide();
+ this.transitioning = 0;
+ // 不强制关闭 Dimmer，以便多个 Modal 可以共享 Dimmer
+ this.dimmer.close($element, false);
+ this.active = false;
+ };
+
+ $element.removeClass(options.className.active)
+ .addClass(options.className.out);
+
+ if (!supportTransition) {
+ return complete.call(this);
+ }
+
+ $element.one(options.transitionEnd, $.proxy(complete, this))
+ .emulateTransitionEnd(options.duration);
+ };
+
+ Modal.prototype.events = function() {
+ var _this = this;
+ var options = this.options;
+ var $element = this.$element;
+ var $dimmer = this.dimmer.$element;
+ var $ipt = $element.find('.am-modal-prompt-input');
+ var $confirm = $element.find('[data-am-modal-confirm]');
+ var $cancel = $element.find('[data-am-modal-cancel]');
+ var getData = function() {
+ var data = [];
+ $ipt.each(function() {
+ data.push($(this).val());
+ });
+
+ return (data.length === 0) ? undefined :
+ ((data.length === 1) ? data[0] : data);
+ };
+
+ // close via Esc key
+ if (this.options.cancelable) {
+ $element.on('keyup.modal.amui', function(e) {
+ if (_this.active && e.which === 27) {
+ $element.trigger('cancel.modal.amui');
+ _this.close();
+ }
+ });
+ }
+
+ // Close Modal when dimmer clicked
+ if (this.options.dimmer && this.options.closeViaDimmer && !this.isLoading) {
+ $dimmer.on('click.dimmer.modal.amui', function() {
+ _this.close();
+ });
+ }
+
+ // Close Modal when button clicked
+ $element.on(
+ 'click.close.modal.amui',
+ '[data-am-modal-close], .am-modal-btn',
+ function(e) {
+ e.preventDefault();
+ var $this = $(this);
+
+ if ($this.is($confirm)) {
+ options.closeOnConfirm && _this.close();
+ } else if ($this.is($cancel)) {
+ options.closeOnCancel && _this.close();
+ } else {
+ _this.close();
+ }
+ }
+ )
+ // trigger dimmer click event if non-dialog area clicked
+ // fixes #882 caused by https://github.com/amazeui/amazeui/commit/b6be7719681193f1c4cb04af89cb9fd9f4422163
+ .on('click', function(e) {
+ // fixes #900
+ // e.stopPropagation();
+ $(e.target).is($element) && $dimmer.trigger('click.dimmer.modal.amui');
+ });
+
+ $confirm.on('click.confirm.modal.amui',
+ function() {
+ $element.trigger($.Event('confirm.modal.amui', {
+ trigger: this
+ }));
+ });
+
+ $cancel.on('click.cancel.modal.amui', function() {
+ $element.trigger($.Event('cancel.modal.amui', {
+ trigger: this
+ }));
+ });
+
+ $element.on('confirm.modal.amui', function(e) {
+ e.data = getData();
+ _this.options.onConfirm.call(_this, e);
+ }).on('cancel.modal.amui', function(e) {
+ e.data = getData();
+ _this.options.onCancel.call(_this, e);
+ });
+ };
+
+ function Plugin(option, relatedTarget) {
+ return this.each(function() {
+ var $this = $(this);
+ var data = $this.data('amui.modal');
+ var options = typeof option == 'object' && option;
+
+ if (!data) {
+ $this.data('amui.modal', (data = new Modal(this, options)));
+ }
+
+ if (typeof option == 'string') {
+ data[option] && data[option](relatedTarget);
+ } else {
+ data.toggle(option && option.relatedTarget || undefined);
+ }
+ });
+ }
+
+ $.fn.modal = Plugin;
+
+ // Init
+ $doc.on('click.modal.amui.data-api', '[data-am-modal]', function() {
+ var $this = $(this);
+ var options = UI.utils.parseOptions($this.attr('data-am-modal'));
+ var $target = $(options.target ||
+ (this.href && this.href.replace(/.*(?=#[^\s]+$)/, '')));
+ var option = $target.data('amui.modal') ? 'toggle' : options;
+
+ Plugin.call($target, option, this);
+ });
+
+ module.exports = UI.modal = Modal;
+
+
+/***/ },
+/* 16 */
+/***/ function(module, exports, __webpack_require__) {
+
+ 'use strict';
+
+ var $ = __webpack_require__(1);
+ var UI = __webpack_require__(2);
+ __webpack_require__(3);
+
+ var $win = $(window);
+ var $doc = $(document);
+ var scrollPos;
+
+ /**
+ * @via https://github.com/uikit/uikit/blob/master/src/js/offcanvas.js
+ * @license https://github.com/uikit/uikit/blob/master/LICENSE.md
+ */
+
+ var OffCanvas = function(element, options) {
+ this.$element = $(element);
+ this.options = $.extend({}, OffCanvas.DEFAULTS, options);
+ this.active = null;
+ this.bindEvents();
+ };
+
+ OffCanvas.DEFAULTS = {
+ duration: 300,
+ effect: 'overlay' // {push|overlay}, push is too expensive
+ };
+
+ OffCanvas.prototype.open = function(relatedElement) {
+ var _this = this;
+ var $element = this.$element;
+
+ if (!$element.length || $element.hasClass('am-active')) {
+ return;
+ }
+
+ var effect = this.options.effect;
+ var $html = $('html');
+ var $body = $('body');
+ var $bar = $element.find('.am-offcanvas-bar').first();
+ var dir = $bar.hasClass('am-offcanvas-bar-flip') ? -1 : 1;
+
+ $bar.addClass('am-offcanvas-bar-' + effect);
+
+ scrollPos = {x: window.scrollX, y: window.scrollY};
+
+ $element.addClass('am-active');
+
+ $body.css({
+ width: window.innerWidth,
+ height: $win.height()
+ }).addClass('am-offcanvas-page');
+
+ if (effect !== 'overlay') {
+ $body.css({
+ 'margin-left': $bar.outerWidth() * dir
+ }).width(); // force redraw
+ }
+
+ $html.css('margin-top', scrollPos.y * -1);
+
+ setTimeout(function() {
+ $bar.addClass('am-offcanvas-bar-active').width();
+ }, 0);
+
+ $element.trigger('open.offcanvas.amui');
+
+ this.active = 1;
+
+ // Close OffCanvas when none content area clicked
+ $element.on('click.offcanvas.amui', function(e) {
+ var $target = $(e.target);
+
+ if ($target.hasClass('am-offcanvas-bar')) {
+ return;
+ }
+
+ if ($target.parents('.am-offcanvas-bar').first().length) {
+ return;
+ }
+
+ // https://developer.mozilla.org/zh-CN/docs/DOM/event.stopImmediatePropagation
+ e.stopImmediatePropagation();
+
+ _this.close();
+ });
+
+ $html.on('keydown.offcanvas.amui', function(e) {
+ (e.keyCode === 27) && _this.close();
+ });
+ };
+
+ OffCanvas.prototype.close = function(relatedElement) {
+ var _this = this;
+ var $html = $('html');
+ var $body = $('body');
+ var $element = this.$element;
+ var $bar = $element.find('.am-offcanvas-bar').first();
+
+ if (!$element.length || !this.active || !$element.hasClass('am-active')) {
+ return;
+ }
+
+ $element.trigger('close.offcanvas.amui');
+
+ function complete() {
+ $body
+ .removeClass('am-offcanvas-page')
+ .css({
+ width: '',
+ height: '',
+ 'margin-left': '',
+ 'margin-right': ''
+ });
+ $element.removeClass('am-active');
+ $bar.removeClass('am-offcanvas-bar-active');
+ $html.css('margin-top', '');
+ window.scrollTo(scrollPos.x, scrollPos.y);
+ $element.trigger('closed.offcanvas.amui');
+ _this.active = 0;
+ }
+
+ if (UI.support.transition) {
+ setTimeout(function() {
+ $bar.removeClass('am-offcanvas-bar-active');
+ }, 0);
+
+ $body.css('margin-left', '').one(UI.support.transition.end, function() {
+ complete();
+ }).emulateTransitionEnd(this.options.duration);
+ } else {
+ complete();
+ }
+
+ $element.off('click.offcanvas.amui');
+ $html.off('.offcanvas.amui');
+ };
+
+ OffCanvas.prototype.bindEvents = function() {
+ var _this = this;
+ $doc.on('click.offcanvas.amui', '[data-am-dismiss="offcanvas"]', function(e) {
+ e.preventDefault();
+ _this.close();
+ });
+
+ $win.on('resize.offcanvas.amui orientationchange.offcanvas.amui',
+ function() {
+ _this.active && _this.close();
+ });
+
+ this.$element.hammer().on('swipeleft swipeleft', function(e) {
+ e.preventDefault();
+ _this.close();
+ });
+
+ return this;
+ };
+
+ function Plugin(option, relatedElement) {
+ var args = Array.prototype.slice.call(arguments, 1);
+
+ return this.each(function() {
+ var $this = $(this);
+ var data = $this.data('amui.offcanvas');
+ var options = $.extend({}, typeof option == 'object' && option);
+
+ if (!data) {
+ $this.data('amui.offcanvas', (data = new OffCanvas(this, options)));
+ (!option || typeof option == 'object') && data.open(relatedElement);
+ }
+
+ if (typeof option == 'string') {
+ data[option] && data[option].apply(data, args);
+ }
+ });
+ }
+
+ $.fn.offCanvas = Plugin;
+
+ // Init code
+ $doc.on('click.offcanvas.amui', '[data-am-offcanvas]', function(e) {
+ e.preventDefault();
+ var $this = $(this);
+ var options = UI.utils.parseOptions($this.data('amOffcanvas'));
+ var $target = $(options.target ||
+ (this.href && this.href.replace(/.*(?=#[^\s]+$)/, '')));
+ var option = $target.data('amui.offcanvas') ? 'open' : options;
+
+ Plugin.call($target, option, this);
+ });
+
+ module.exports = UI.offcanvas = OffCanvas;
+
+ // TODO: 优化动画效果
+ // http://dbushell.github.io/Responsive-Off-Canvas-Menu/step4.html
+
+
+/***/ },
+/* 17 */
+/***/ function(module, exports, __webpack_require__) {
+
+ 'use strict';
+
+ var $ = __webpack_require__(1);
+ var UI = __webpack_require__(2);
+ var requestAnimationFrame = UI.utils.rAF;
+
+ /**
+ * @via https://github.com/manuelstofer/pinchzoom/blob/master/src/pinchzoom.js
+ * @license the MIT License.
+ */
+
+ var definePinchZoom = function($) {
+
+ /**
+ * Pinch zoom using jQuery
+ * @version 0.0.2
+ * @author Manuel Stofer
+ * @param el
+ * @param options
+ * @constructor
+ */
+ var PinchZoom = function(el, options) {
+ this.el = $(el);
+ this.zoomFactor = 1;
+ this.lastScale = 1;
+ this.offset = {
+ x: 0,
+ y: 0
+ };
+ this.options = $.extend({}, this.defaults, options);
+ this.setupMarkup();
+ this.bindEvents();
+ this.update();
+ // default enable.
+ this.enable();
+
+ },
+ sum = function(a, b) {
+ return a + b;
+ },
+ isCloseTo = function(value, expected) {
+ return value > expected - 0.01 && value < expected + 0.01;
+ };
+
+ PinchZoom.prototype = {
+
+ defaults: {
+ tapZoomFactor: 2,
+ zoomOutFactor: 1.3,
+ animationDuration: 300,
+ maxZoom: 4,
+ minZoom: 0.5,
+ lockDragAxis: false,
+ use2d: true,
+ zoomStartEventName: 'pz_zoomstart',
+ zoomEndEventName: 'pz_zoomend',
+ dragStartEventName: 'pz_dragstart',
+ dragEndEventName: 'pz_dragend',
+ doubleTapEventName: 'pz_doubletap'
+ },
+
+ /**
+ * Event handler for 'dragstart'
+ * @param event
+ */
+ handleDragStart: function(event) {
+ this.el.trigger(this.options.dragStartEventName);
+ this.stopAnimation();
+ this.lastDragPosition = false;
+ this.hasInteraction = true;
+ this.handleDrag(event);
+ },
+
+ /**
+ * Event handler for 'drag'
+ * @param event
+ */
+ handleDrag: function(event) {
+
+ if (this.zoomFactor > 1.0) {
+ var touch = this.getTouches(event)[0];
+ this.drag(touch, this.lastDragPosition);
+ this.offset = this.sanitizeOffset(this.offset);
+ this.lastDragPosition = touch;
+ }
+ },
+
+ handleDragEnd: function() {
+ this.el.trigger(this.options.dragEndEventName);
+ this.end();
+ },
+
+ /**
+ * Event handler for 'zoomstart'
+ * @param event
+ */
+ handleZoomStart: function(event) {
+ this.el.trigger(this.options.zoomStartEventName);
+ this.stopAnimation();
+ this.lastScale = 1;
+ this.nthZoom = 0;
+ this.lastZoomCenter = false;
+ this.hasInteraction = true;
+ },
+
+ /**
+ * Event handler for 'zoom'
+ * @param event
+ */
+ handleZoom: function(event, newScale) {
+
+ // a relative scale factor is used
+ var touchCenter = this.getTouchCenter(this.getTouches(event)),
+ scale = newScale / this.lastScale;
+ this.lastScale = newScale;
+
+ // the first touch events are thrown away since they are not precise
+ this.nthZoom += 1;
+ if (this.nthZoom > 3) {
+
+ this.scale(scale, touchCenter);
+ this.drag(touchCenter, this.lastZoomCenter);
+ }
+ this.lastZoomCenter = touchCenter;
+ },
+
+ handleZoomEnd: function() {
+ this.el.trigger(this.options.zoomEndEventName);
+ this.end();
+ },
+
+ /**
+ * Event handler for 'doubletap'
+ * @param event
+ */
+ handleDoubleTap: function(event) {
+ var center = this.getTouches(event)[0],
+ zoomFactor = this.zoomFactor > 1 ? 1 : this.options.tapZoomFactor,
+ startZoomFactor = this.zoomFactor,
+ updateProgress = (function(progress) {
+ this.scaleTo(startZoomFactor + progress * (zoomFactor - startZoomFactor), center);
+ }).bind(this);
+
+ if (this.hasInteraction) {
+ return;
+ }
+ if (startZoomFactor > zoomFactor) {
+ center = this.getCurrentZoomCenter();
+ }
+
+ this.animate(this.options.animationDuration, updateProgress, this.swing);
+ this.el.trigger(this.options.doubleTapEventName);
+ },
+
+ /**
+ * Max / min values for the offset
+ * @param offset
+ * @return {Object} the sanitized offset
+ */
+ sanitizeOffset: function(offset) {
+ var maxX = (this.zoomFactor - 1) * this.getContainerX(),
+ maxY = (this.zoomFactor - 1) * this.getContainerY(),
+ maxOffsetX = Math.max(maxX, 0),
+ maxOffsetY = Math.max(maxY, 0),
+ minOffsetX = Math.min(maxX, 0),
+ minOffsetY = Math.min(maxY, 0);
+
+ return {
+ x: Math.min(Math.max(offset.x, minOffsetX), maxOffsetX),
+ y: Math.min(Math.max(offset.y, minOffsetY), maxOffsetY)
+ };
+ },
+
+ /**
+ * Scale to a specific zoom factor (not relative)
+ * @param zoomFactor
+ * @param center
+ */
+ scaleTo: function(zoomFactor, center) {
+ this.scale(zoomFactor / this.zoomFactor, center);
+ },
+
+ /**
+ * Scales the element from specified center
+ * @param scale
+ * @param center
+ */
+ scale: function(scale, center) {
+ scale = this.scaleZoomFactor(scale);
+ this.addOffset({
+ x: (scale - 1) * (center.x + this.offset.x),
+ y: (scale - 1) * (center.y + this.offset.y)
+ });
+ },
+
+ /**
+ * Scales the zoom factor relative to current state
+ * @param scale
+ * @return the actual scale (can differ because of max min zoom factor)
+ */
+ scaleZoomFactor: function(scale) {
+ var originalZoomFactor = this.zoomFactor;
+ this.zoomFactor *= scale;
+ this.zoomFactor = Math.min(this.options.maxZoom, Math.max(this.zoomFactor, this.options.minZoom));
+ return this.zoomFactor / originalZoomFactor;
+ },
+
+ /**
+ * Drags the element
+ * @param center
+ * @param lastCenter
+ */
+ drag: function(center, lastCenter) {
+ if (lastCenter) {
+ if (this.options.lockDragAxis) {
+ // lock scroll to position that was changed the most
+ if (Math.abs(center.x - lastCenter.x) > Math.abs(center.y - lastCenter.y)) {
+ this.addOffset({
+ x: -(center.x - lastCenter.x),
+ y: 0
+ });
+ }
+ else {
+ this.addOffset({
+ y: -(center.y - lastCenter.y),
+ x: 0
+ });
+ }
+ }
+ else {
+ this.addOffset({
+ y: -(center.y - lastCenter.y),
+ x: -(center.x - lastCenter.x)
+ });
+ }
+ }
+ },
+
+ /**
+ * Calculates the touch center of multiple touches
+ * @param touches
+ * @return {Object}
+ */
+ getTouchCenter: function(touches) {
+ return this.getVectorAvg(touches);
+ },
+
+ /**
+ * Calculates the average of multiple vectors (x, y values)
+ */
+ getVectorAvg: function(vectors) {
+ return {
+ x: vectors.map(function(v) {
+ return v.x;
+ }).reduce(sum) / vectors.length,
+ y: vectors.map(function(v) {
+ return v.y;
+ }).reduce(sum) / vectors.length
+ };
+ },
+
+ /**
+ * Adds an offset
+ * @param offset the offset to add
+ * @return return true when the offset change was accepted
+ */
+ addOffset: function(offset) {
+ this.offset = {
+ x: this.offset.x + offset.x,
+ y: this.offset.y + offset.y
+ };
+ },
+
+ sanitize: function() {
+ if (this.zoomFactor < this.options.zoomOutFactor) {
+ this.zoomOutAnimation();
+ } else if (this.isInsaneOffset(this.offset)) {
+ this.sanitizeOffsetAnimation();
+ }
+ },
+
+ /**
+ * Checks if the offset is ok with the current zoom factor
+ * @param offset
+ * @return {Boolean}
+ */
+ isInsaneOffset: function(offset) {
+ var sanitizedOffset = this.sanitizeOffset(offset);
+ return sanitizedOffset.x !== offset.x ||
+ sanitizedOffset.y !== offset.y;
+ },
+
+ /**
+ * Creates an animation moving to a sane offset
+ */
+ sanitizeOffsetAnimation: function() {
+ var targetOffset = this.sanitizeOffset(this.offset),
+ startOffset = {
+ x: this.offset.x,
+ y: this.offset.y
+ },
+ updateProgress = (function(progress) {
+ this.offset.x = startOffset.x + progress * (targetOffset.x - startOffset.x);
+ this.offset.y = startOffset.y + progress * (targetOffset.y - startOffset.y);
+ this.update();
+ }).bind(this);
+
+ this.animate(
+ this.options.animationDuration,
+ updateProgress,
+ this.swing
+ );
+ },
+
+ /**
+ * Zooms back to the original position,
+ * (no offset and zoom factor 1)
+ */
+ zoomOutAnimation: function() {
+ var startZoomFactor = this.zoomFactor,
+ zoomFactor = 1,
+ center = this.getCurrentZoomCenter(),
+ updateProgress = (function(progress) {
+ this.scaleTo(startZoomFactor + progress * (zoomFactor - startZoomFactor), center);
+ }).bind(this);
+
+ this.animate(
+ this.options.animationDuration,
+ updateProgress,
+ this.swing
+ );
+ },
+
+ /**
+ * Updates the aspect ratio
+ */
+ updateAspectRatio: function() {
+ this.setContainerY(this.getContainerX() / this.getAspectRatio());
+ },
+
+ /**
+ * Calculates the initial zoom factor (for the element to fit into the container)
+ * @return the initial zoom factor
+ */
+ getInitialZoomFactor: function() {
+ // use .offsetWidth instead of width()
+ // because jQuery-width() return the original width but Zepto-width() will calculate width with transform.
+ // the same as .height()
+ return this.container[0].offsetWidth / this.el[0].offsetWidth;
+ },
+
+ /**
+ * Calculates the aspect ratio of the element
+ * @return the aspect ratio
+ */
+ getAspectRatio: function() {
+ return this.el[0].offsetWidth / this.el[0].offsetHeight;
+ },
+
+ /**
+ * Calculates the virtual zoom center for the current offset and zoom factor
+ * (used for reverse zoom)
+ * @return {Object} the current zoom center
+ */
+ getCurrentZoomCenter: function() {
+
+ // uses following formula to calculate the zoom center x value
+ // offset_left / offset_right = zoomcenter_x / (container_x - zoomcenter_x)
+ var length = this.container[0].offsetWidth * this.zoomFactor,
+ offsetLeft = this.offset.x,
+ offsetRight = length - offsetLeft - this.container[0].offsetWidth,
+ widthOffsetRatio = offsetLeft / offsetRight,
+ centerX = widthOffsetRatio * this.container[0].offsetWidth / (widthOffsetRatio + 1),
+
+ // the same for the zoomcenter y
+ height = this.container[0].offsetHeight * this.zoomFactor,
+ offsetTop = this.offset.y,
+ offsetBottom = height - offsetTop - this.container[0].offsetHeight,
+ heightOffsetRatio = offsetTop / offsetBottom,
+ centerY = heightOffsetRatio * this.container[0].offsetHeight / (heightOffsetRatio + 1);
+
+ // prevents division by zero
+ if (offsetRight === 0) {
+ centerX = this.container[0].offsetWidth;
+ }
+ if (offsetBottom === 0) {
+ centerY = this.container[0].offsetHeight;
+ }
+
+ return {
+ x: centerX,
+ y: centerY
+ };
+ },
+
+ canDrag: function() {
+ return !isCloseTo(this.zoomFactor, 1);
+ },
+
+ /**
+ * Returns the touches of an event relative to the container offset
+ * @param event
+ * @return array touches
+ */
+ getTouches: function(event) {
+ var position = this.container.offset();
+ return Array.prototype.slice.call(event.touches).map(function(touch) {
+ return {
+ x: touch.pageX - position.left,
+ y: touch.pageY - position.top
+ };
+ });
+ },
+
+ /**
+ * Animation loop
+ * does not support simultaneous animations
+ * @param duration
+ * @param framefn
+ * @param timefn
+ * @param callback
+ */
+ animate: function(duration, framefn, timefn, callback) {
+ var startTime = new Date().getTime(),
+ renderFrame = (function() {
+ if (!this.inAnimation) {
+ return;
+ }
+ var frameTime = new Date().getTime() - startTime,
+ progress = frameTime / duration;
+ if (frameTime >= duration) {
+ framefn(1);
+ if (callback) {
+ callback();
+ }
+ this.update();
+ this.stopAnimation();
+ this.update();
+ } else {
+ if (timefn) {
+ progress = timefn(progress);
+ }
+ framefn(progress);
+ this.update();
+ requestAnimationFrame(renderFrame);
+ }
+ }).bind(this);
+ this.inAnimation = true;
+ requestAnimationFrame(renderFrame);
+ },
+
+ /**
+ * Stops the animation
+ */
+ stopAnimation: function() {
+ this.inAnimation = false;
+ },
+
+ /**
+ * Swing timing function for animations
+ * @param p
+ * @return {Number}
+ */
+ swing: function(p) {
+ return -Math.cos(p * Math.PI) / 2 + 0.5;
+ },
+
+ getContainerX: function() {
+ return this.container[0].offsetWidth;
+ },
+
+ getContainerY: function() {
+ return this.container[0].offsetHeight;
+ },
+
+ setContainerY: function(y) {
+ return this.container.height(y);
+ },
+
+ /**
+ * Creates the expected html structure
+ */
+ setupMarkup: function() {
+ this.container = $('');
+ this.el.before(this.container);
+ this.container.append(this.el);
+
+ this.container.css({
+ 'overflow': 'hidden',
+ 'position': 'relative'
+ });
+
+ // Zepto doesn't recognize `webkitTransform..` style
+ this.el.css({
+ '-webkit-transform-origin': '0% 0%',
+ '-moz-transform-origin': '0% 0%',
+ '-ms-transform-origin': '0% 0%',
+ '-o-transform-origin': '0% 0%',
+ 'transform-origin': '0% 0%',
+ 'position': 'absolute'
+ });
+ },
+
+ end: function() {
+ this.hasInteraction = false;
+ this.sanitize();
+ this.update();
+ },
+
+ /**
+ * Binds all required event listeners
+ */
+ bindEvents: function() {
+ detectGestures(this.container.get(0), this);
+ // Zepto and jQuery both know about `on`
+ $(window).on('resize', this.update.bind(this));
+ $(this.el).find('img').on('load', this.update.bind(this));
+ },
+
+ /**
+ * Updates the css values according to the current zoom factor and offset
+ */
+ update: function() {
+
+ if (this.updatePlaned) {
+ return;
+ }
+ this.updatePlaned = true;
+
+ setTimeout((function() {
+ this.updatePlaned = false;
+ this.updateAspectRatio();
+
+ var zoomFactor = this.getInitialZoomFactor() * this.zoomFactor,
+ offsetX = -this.offset.x / zoomFactor,
+ offsetY = -this.offset.y / zoomFactor,
+ transform3d = 'scale3d(' + zoomFactor + ', ' + zoomFactor + ',1) ' +
+ 'translate3d(' + offsetX + 'px,' + offsetY + 'px,0px)',
+ transform2d = 'scale(' + zoomFactor + ', ' + zoomFactor + ') ' +
+ 'translate(' + offsetX + 'px,' + offsetY + 'px)',
+ removeClone = (function() {
+ if (this.clone) {
+ this.clone.remove();
+ delete this.clone;
+ }
+ }).bind(this);
+
+ // Scale 3d and translate3d are faster (at least on ios)
+ // but they also reduce the quality.
+ // PinchZoom uses the 3d transformations during interactions
+ // after interactions it falls back to 2d transformations
+ if (!this.options.use2d || this.hasInteraction || this.inAnimation) {
+ this.is3d = true;
+ removeClone();
+ this.el.css({
+ '-webkit-transform': transform3d,
+ '-o-transform': transform2d,
+ '-ms-transform': transform2d,
+ '-moz-transform': transform2d,
+ 'transform': transform3d
+ });
+ } else {
+
+ // When changing from 3d to 2d transform webkit has some glitches.
+ // To avoid this, a copy of the 3d transformed element is displayed in the
+ // foreground while the element is converted from 3d to 2d transform
+ if (this.is3d) {
+ this.clone = this.el.clone();
+ this.clone.css('pointer-events', 'none');
+ this.clone.appendTo(this.container);
+ setTimeout(removeClone, 200);
+ }
+ this.el.css({
+ '-webkit-transform': transform2d,
+ '-o-transform': transform2d,
+ '-ms-transform': transform2d,
+ '-moz-transform': transform2d,
+ 'transform': transform2d
+ });
+ this.is3d = false;
+ }
+ }).bind(this), 0);
+ },
+
+ /**
+ * Enables event handling for gestures
+ */
+ enable: function() {
+ this.enabled = true;
+ },
+
+ /**
+ * Disables event handling for gestures
+ */
+ disable: function() {
+ this.enabled = false;
+ }
+ };
+
+ var detectGestures = function(el, target) {
+ var interaction = null,
+ fingers = 0,
+ lastTouchStart = null,
+ startTouches = null,
+
+ setInteraction = function(newInteraction, event) {
+ if (interaction !== newInteraction) {
+
+ if (interaction && !newInteraction) {
+ switch (interaction) {
+ case "zoom":
+ target.handleZoomEnd(event);
+ break;
+ case 'drag':
+ target.handleDragEnd(event);
+ break;
+ }
+ }
+
+ switch (newInteraction) {
+ case 'zoom':
+ target.handleZoomStart(event);
+ break;
+ case 'drag':
+ target.handleDragStart(event);
+ break;
+ }
+ }
+ interaction = newInteraction;
+ },
+
+ updateInteraction = function(event) {
+ if (fingers === 2) {
+ setInteraction('zoom');
+ } else if (fingers === 1 && target.canDrag()) {
+ setInteraction('drag', event);
+ } else {
+ setInteraction(null, event);
+ }
+ },
+
+ targetTouches = function(touches) {
+ return Array.prototype.slice.call(touches).map(function(touch) {
+ return {
+ x: touch.pageX,
+ y: touch.pageY
+ };
+ });
+ },
+
+ getDistance = function(a, b) {
+ var x, y;
+ x = a.x - b.x;
+ y = a.y - b.y;
+ return Math.sqrt(x * x + y * y);
+ },
+
+ calculateScale = function(startTouches, endTouches) {
+ var startDistance = getDistance(startTouches[0], startTouches[1]),
+ endDistance = getDistance(endTouches[0], endTouches[1]);
+ return endDistance / startDistance;
+ },
+
+ cancelEvent = function(event) {
+ event.stopPropagation();
+ event.preventDefault();
+ },
+
+ detectDoubleTap = function(event) {
+ var time = (new Date()).getTime();
+
+ if (fingers > 1) {
+ lastTouchStart = null;
+ }
+
+ if (time - lastTouchStart < 300) {
+ cancelEvent(event);
+
+ target.handleDoubleTap(event);
+ switch (interaction) {
+ case 'zoom':
+ target.handleZoomEnd(event);
+ break;
+ case 'drag':
+ target.handleDragEnd(event);
+ break;
+ }
+ }
+
+ if (fingers === 1) {
+ lastTouchStart = time;
+ }
+ },
+ firstMove = true;
+
+ el.addEventListener('touchstart', function(event) {
+ if (target.enabled) {
+ firstMove = true;
+ fingers = event.touches.length;
+ detectDoubleTap(event);
+ }
+ });
+
+ el.addEventListener('touchmove', function(event) {
+ if (target.enabled) {
+ if (firstMove) {
+ updateInteraction(event);
+ if (interaction) {
+ cancelEvent(event);
+ }
+ startTouches = targetTouches(event.touches);
+ } else {
+ switch (interaction) {
+ case 'zoom':
+ target.handleZoom(event, calculateScale(startTouches, targetTouches(event.touches)));
+ break;
+ case 'drag':
+ target.handleDrag(event);
+ break;
+ }
+ if (interaction) {
+ cancelEvent(event);
+ target.update();
+ }
+ }
+
+ firstMove = false;
+ }
+ });
+
+ el.addEventListener('touchend', function(event) {
+ if (target.enabled) {
+ fingers = event.touches.length;
+ updateInteraction(event);
+ }
+ });
+ };
+
+ return PinchZoom;
+ };
+
+ module.exports = UI.pichzoom = definePinchZoom($);
+
+
+/***/ },
+/* 18 */
+/***/ function(module, exports, __webpack_require__) {
+
+ 'use strict';
+
+ var $ = __webpack_require__(1);
+ var UI = __webpack_require__(2);
+ var $w = $(window);
+
+ /**
+ * @reference https://github.com/nolimits4web/Framework7/blob/master/src/js/modals.js
+ * @license https://github.com/nolimits4web/Framework7/blob/master/LICENSE
+ */
+
+ var Popover = function(element, options) {
+ this.options = $.extend({}, Popover.DEFAULTS, options);
+ this.$element = $(element);
+ this.active = null;
+ this.$popover = (this.options.target && $(this.options.target)) || null;
+
+ this.init();
+ this._bindEvents();
+ };
+
+ Popover.DEFAULTS = {
+ theme: null,
+ trigger: 'click',
+ content: '',
+ open: false,
+ target: null,
+ tpl: '![]()
+ src = UI.utils.getAbsoluteUrl(src);
+ title = $(item).attr('alt') || '';
+ }
+
+ // add pureviewed flag
+ item.setAttribute(viewedFlag, '1');
+
+ // hide bar: wechat_webview_type=1
+ // http://tmt.io/wechat/ not working?
+ _this.imgUrls.push(src);
+
+ $slides = $slides.add($(''));
+ $navItems = $navItems.add($('' + (i + 1) + ' '));
+ });
+
+ $pureview.find(options.selector.total).text(total);
+
+ this.$slider.append($slides);
+ this.$nav.append($navItems);
+ this.$navItems = this.$nav.find('li');
+ this.$slides = this.$slider.find('li');
+ };
+
+ PureView.prototype.loadImage = function($slide, callback) {
+ var appendedFlag = 'image-appended';
+
+ if (!$slide.data(appendedFlag)) {
+ var $img = $('![]()
', {
+ src: $slide.data('src'),
+ alt: $slide.data('title')
+ });
+
+ $slide.html($img).wrapInner('').redraw();
+
+ var $pinchWrapper = $slide.find(this.options.selector.pinchZoom);
+ $pinchWrapper.data('amui.pinchzoom', new PinchZoom($pinchWrapper[0], {}));
+ $slide.data('image-appended', true);
+ }
+
+ callback && callback.call(this);
+ };
+
+ PureView.prototype.activate = function($slide) {
+ var options = this.options;
+ var $slides = this.$slides;
+ var activeIndex = $slides.index($slide);
+ var title = $slide.data('title') || '';
+ var active = options.className.active;
+
+ if ($slides.find('.' + active).is($slide)) {
+ return;
+ }
+
+ if (this.transitioning) {
+ return;
+ }
+
+ this.loadImage($slide, function() {
+ UI.utils.imageLoader($slide.find('img'), function(image) {
+ $slide.find('.am-pinch-zoom').addClass('am-pureview-loaded');
+ $(image).addClass('am-img-loaded');
+ });
+ });
+
+ this.transitioning = 1;
+
+ this.$title.text(title);
+ this.$current.text(activeIndex + 1);
+ $slides.removeClass();
+ $slide.addClass(active);
+ $slides.eq(activeIndex - 1).addClass(options.className.prevSlide);
+ $slides.eq(activeIndex + 1).addClass(options.className.nextSlide);
+
+ this.$navItems.removeClass().
+ eq(activeIndex).addClass(options.className.active);
+
+ if (transition) {
+ $slide.one(transition.end, $.proxy(function() {
+ this.transitioning = 0;
+ }, this)).emulateTransitionEnd(300);
+ } else {
+ this.transitioning = 0;
+ }
+
+ // TODO: pre-load next image
+ };
+
+ PureView.prototype.nextSlide = function() {
+ if (this.$slides.length === 1) {
+ return;
+ }
+
+ var $slides = this.$slides;
+ var $active = $slides.filter('.am-active');
+ var activeIndex = $slides.index($active);
+ var rightSpring = 'am-animation-right-spring';
+
+ if (activeIndex + 1 >= $slides.length) { // last one
+ animation && $active.addClass(rightSpring).on(animation.end, function() {
+ $active.removeClass(rightSpring);
+ });
+ } else {
+ this.activate($slides.eq(activeIndex + 1));
+ }
+ };
+
+ PureView.prototype.prevSlide = function() {
+ if (this.$slides.length === 1) {
+ return;
+ }
+
+ var $slides = this.$slides;
+ var $active = $slides.filter('.am-active');
+ var activeIndex = this.$slides.index(($active));
+ var leftSpring = 'am-animation-left-spring';
+
+ if (activeIndex === 0) { // first one
+ animation && $active.addClass(leftSpring).on(animation.end, function() {
+ $active.removeClass(leftSpring);
+ });
+ } else {
+ this.activate($slides.eq(activeIndex - 1));
+ }
+ };
+
+ PureView.prototype.toggleToolBar = function() {
+ this.$pureview.toggleClass(this.options.className.barActive);
+ };
+
+ PureView.prototype.open = function(index) {
+ var active = index || 0;
+ this.checkScrollbar();
+ this.setScrollbar();
+ this.activate(this.$slides.eq(active));
+ this.$pureview.show().redraw().addClass(this.options.className.active);
+ this.$body.addClass(this.options.className.activeBody);
+ };
+
+ PureView.prototype.close = function() {
+ var options = this.options;
+
+ this.$pureview.removeClass(options.className.active);
+ this.$slides.removeClass();
+
+ function resetBody() {
+ this.$pureview.hide();
+ this.$body.removeClass(options.className.activeBody);
+ this.resetScrollbar();
+ }
+
+ if (transition) {
+ this.$pureview.one(transition.end, $.proxy(resetBody, this)).
+ emulateTransitionEnd(300);
+ } else {
+ resetBody.call(this);
+ }
+ };
+
+ PureView.prototype.checkScrollbar = function() {
+ this.scrollbarWidth = UI.utils.measureScrollbar();
+ };
+
+ PureView.prototype.setScrollbar = function() {
+ var bodyPaddingRight = parseInt((this.$body.css('padding-right') || 0), 10);
+ if (this.scrollbarWidth) {
+ this.$body.css('padding-right', bodyPaddingRight + this.scrollbarWidth);
+ }
+ };
+
+ PureView.prototype.resetScrollbar = function() {
+ this.$body.css('padding-right', '');
+ };
+
+ UI.plugin('pureview', PureView);
+
+ // Init code
+ UI.ready(function(context) {
+ $('[data-am-pureview]', context).pureview();
+ });
+
+ module.exports = PureView;
+
+ // TODO: 1. 动画改进
+ // 2. 改变图片的时候恢复 Zoom
+ // 3. 选项
+ // 4. 图片高度问题：由于 PinchZoom 的原因，过高的图片如果设置看了滚动，则放大以后显示不全
+
+
+/***/ },
+/* 21 */
+/***/ function(module, exports, __webpack_require__) {
+
+ 'use strict';
+
+ var $ = __webpack_require__(1);
+ var UI = __webpack_require__(2);
+
+ /**
+ * @via https://github.com/uikit/uikit/blob/master/src/js/scrollspy.js
+ * @license https://github.com/uikit/uikit/blob/master/LICENSE.md
+ */
+
+ var ScrollSpy = function(element, options) {
+ if (!UI.support.animation) {
+ return;
+ }
+
+ this.options = $.extend({}, ScrollSpy.DEFAULTS, options);
+ this.$element = $(element);
+
+ var checkViewRAF = function() {
+ UI.utils.rAF.call(window, $.proxy(this.checkView, this));
+ }.bind(this);
+
+ this.$window = $(window).on('scroll.scrollspy.amui', checkViewRAF)
+ .on('resize.scrollspy.amui orientationchange.scrollspy.amui',
+ UI.utils.debounce(checkViewRAF, 50));
+
+ this.timer = this.inViewState = this.initInView = null;
+
+ checkViewRAF();
+ };
+
+ ScrollSpy.DEFAULTS = {
+ animation: 'fade',
+ className: {
+ inView: 'am-scrollspy-inview',
+ init: 'am-scrollspy-init'
+ },
+ repeat: true,
+ delay: 0,
+ topOffset: 0,
+ leftOffset: 0
+ };
+
+ ScrollSpy.prototype.checkView = function() {
+ var $element = this.$element;
+ var options = this.options;
+ var inView = UI.utils.isInView($element, options);
+ var animation = options.animation ?
+ ' am-animation-' + options.animation : '';
+
+ if (inView && !this.inViewState) {
+ if (this.timer) {
+ clearTimeout(this.timer);
+ }
+
+ if (!this.initInView) {
+ $element.addClass(options.className.init);
+ this.offset = $element.offset();
+ this.initInView = true;
+
+ $element.trigger('init.scrollspy.amui');
+ }
+
+ this.timer = setTimeout(function() {
+ if (inView) {
+ $element.addClass(options.className.inView + animation).width();
+ }
+ }, options.delay);
+
+ this.inViewState = true;
+ $element.trigger('inview.scrollspy.amui');
+ }
+
+ if (!inView && this.inViewState && options.repeat) {
+ $element.removeClass(options.className.inView + animation);
+
+ this.inViewState = false;
+
+ $element.trigger('outview.scrollspy.amui');
+ }
+ };
+
+ ScrollSpy.prototype.check = function() {
+ UI.utils.rAF.call(window, $.proxy(this.checkView, this));
+ };
+
+ // Sticky Plugin
+ UI.plugin('scrollspy', ScrollSpy);
+
+ // Init code
+ UI.ready(function(context) {
+ $('[data-am-scrollspy]', context).scrollspy();
+ });
+
+ module.exports = ScrollSpy;
+
+
+/***/ },
+/* 22 */
+/***/ function(module, exports, __webpack_require__) {
+
+ 'use strict';
+
+ var $ = __webpack_require__(1);
+ var UI = __webpack_require__(2);
+ __webpack_require__(23);
+
+ /**
+ * @via https://github.com/uikit/uikit/
+ * @license https://github.com/uikit/uikit/blob/master/LICENSE.md
+ */
+
+ // ScrollSpyNav Class
+ var ScrollSpyNav = function(element, options) {
+ this.options = $.extend({}, ScrollSpyNav.DEFAULTS, options);
+ this.$element = $(element);
+ this.anchors = [];
+
+ this.$links = this.$element.find('a[href^="#"]').each(function(i, link) {
+ this.anchors.push($(link).attr('href'));
+ }.bind(this));
+
+ this.$targets = $(this.anchors.join(', '));
+
+ var processRAF = function() {
+ UI.utils.rAF.call(window, $.proxy(this.process, this));
+ }.bind(this);
+
+ this.$window = $(window).on('scroll.scrollspynav.amui', processRAF)
+ .on('resize.scrollspynav.amui orientationchange.scrollspynav.amui',
+ UI.utils.debounce(processRAF, 50));
+
+ processRAF();
+ this.scrollProcess();
+ };
+
+ ScrollSpyNav.DEFAULTS = {
+ className: {
+ active: 'am-active'
+ },
+ closest: false,
+ smooth: true,
+ offsetTop: 0
+ };
+
+ ScrollSpyNav.prototype.process = function() {
+ var scrollTop = this.$window.scrollTop();
+ var options = this.options;
+ var inViews = [];
+ var $links = this.$links;
+
+ var $targets = this.$targets;
+
+ $targets.each(function(i, target) {
+ if (UI.utils.isInView(target, options)) {
+ inViews.push(target);
+ }
+ });
+
+ // console.log(inViews.length);
+
+ if (inViews.length) {
+ var $target;
+
+ $.each(inViews, function(i, item) {
+ if ($(item).offset().top >= scrollTop) {
+ $target = $(item);
+ return false; // break
+ }
+ });
+
+ if (!$target) {
+ return;
+ }
+
+ if (options.closest) {
+ $links.closest(options.closest).removeClass(options.className.active);
+ $links.filter('a[href="#' + $target.attr('id') + '"]').
+ closest(options.closest).addClass(options.className.active);
+ } else {
+ $links.removeClass(options.className.active).
+ filter('a[href="#' + $target.attr('id') + '"]').
+ addClass(options.className.active);
+ }
+ }
+ };
+
+ ScrollSpyNav.prototype.scrollProcess = function() {
+ var $links = this.$links;
+ var options = this.options;
+
+ // smoothScroll
+ if (options.smooth && $.fn.smoothScroll) {
+ $links.on('click', function(e) {
+ e.preventDefault();
+
+ var $this = $(this);
+ var $target = $($this.attr('href'));
+
+ if (!$target) {
+ return;
+ }
+
+ var offsetTop = options.offsetTop &&
+ !isNaN(parseInt(options.offsetTop)) && parseInt(options.offsetTop) || 0;
+
+ $(window).smoothScroll({position: $target.offset().top - offsetTop});
+ });
+ }
+ };
+
+ // ScrollSpyNav Plugin
+ UI.plugin('scrollspynav', ScrollSpyNav);
+
+ // Init code
+ UI.ready(function(context) {
+ $('[data-am-scrollspynav]', context).scrollspynav();
+ });
+
+ module.exports = ScrollSpyNav;
+
+ // TODO: 1. 算法改进
+ // 2. 多级菜单支持
+ // 3. smooth scroll pushState
+
+
+/***/ },
+/* 23 */
+/***/ function(module, exports, __webpack_require__) {
+
+ 'use strict';
+
+ var $ = __webpack_require__(1);
+ var UI = __webpack_require__(2);
+ var rAF = UI.utils.rAF;
+ var cAF = UI.utils.cancelAF;
+
+ /**
+ * Smooth Scroll
+ * @param position
+ * @via http://mir.aculo.us/2014/01/19/scrolling-dom-elements-to-the-top-a-zepto-plugin/
+ */
+
+ // Usage: $(window).smoothScroll([options])
+
+ // only allow one scroll to top operation to be in progress at a time,
+ // which is probably what you want
+ var smoothScrollInProgress = false;
+
+ var SmoothScroll = function(element, options) {
+ options = options || {};
+
+ var $this = $(element);
+ var targetY = parseInt(options.position) || SmoothScroll.DEFAULTS.position;
+ var initialY = $this.scrollTop();
+ var lastY = initialY;
+ var delta = targetY - initialY;
+ // duration in ms, make it a bit shorter for short distances
+ // this is not scientific and you might want to adjust this for
+ // your preferences
+ var speed = options.speed ||
+ Math.min(750, Math.min(1500, Math.abs(initialY - targetY)));
+ // temp variables (t will be a position between 0 and 1, y is the calculated scrollTop)
+ var start;
+ var t;
+ var y;
+ var cancelScroll = function() {
+ abort();
+ };
+
+ // abort if already in progress or nothing to scroll
+ if (smoothScrollInProgress) {
+ return;
+ }
+
+ if (delta === 0) {
+ return;
+ }
+
+ // quint ease-in-out smoothing, from
+ // https://github.com/madrobby/scripty2/blob/master/src/effects/transitions/penner.js#L127-L136
+ function smooth(pos) {
+ if ((pos /= 0.5) < 1) {
+ return 0.5 * Math.pow(pos, 5);
+ }
+
+ return 0.5 * (Math.pow((pos - 2), 5) + 2);
+ }
+
+ function abort() {
+ $this.off('touchstart.smoothscroll.amui', cancelScroll);
+ smoothScrollInProgress = false;
+ }
+
+ // when there's a touch detected while scrolling is in progress, abort
+ // the scrolling (emulates native scrolling behavior)
+ $this.on('touchstart.smoothscroll.amui', cancelScroll);
+ smoothScrollInProgress = true;
+
+ // start rendering away! note the function given to frame
+ // is named "render" so we can reference it again further down
+ function render(now) {
+ if (!smoothScrollInProgress) {
+ return;
+ }
+ if (!start) {
+ start = now;
+ }
+
+ // calculate t, position of animation in [0..1]
+ t = Math.min(1, Math.max((now - start) / speed, 0));
+ // calculate the new scrollTop position (don't forget to smooth)
+ y = Math.round(initialY + delta * smooth(t));
+ // bracket scrollTop so we're never over-scrolling
+ if (delta > 0 && y > targetY) {
+ y = targetY;
+ }
+ if (delta < 0 && y < targetY) {
+ y = targetY;
+ }
+
+ // only actually set scrollTop if there was a change fromt he last frame
+ if (lastY != y) {
+ $this.scrollTop(y);
+ }
+
+ lastY = y;
+ // if we're not done yet, queue up an other frame to render,
+ // or clean up
+ if (y !== targetY) {
+ cAF(scrollRAF);
+ scrollRAF = rAF(render);
+ } else {
+ cAF(scrollRAF);
+ abort();
+ }
+ }
+
+ var scrollRAF = rAF(render);
+ };
+
+ SmoothScroll.DEFAULTS = {
+ position: 0
+ };
+
+ $.fn.smoothScroll = function(option) {
+ return this.each(function() {
+ new SmoothScroll(this, option);
+ });
+ };
+
+ // Init code
+ $(document).on('click.smoothScroll.amui.data-api', '[data-am-smooth-scroll]',
+ function(e) {
+ e.preventDefault();
+ var options = UI.utils.parseOptions($(this).data('amSmoothScroll'));
+
+ $(window).smoothScroll(options);
+ });
+
+ module.exports = SmoothScroll;
+
+
+/***/ },
+/* 24 */
+/***/ function(module, exports, __webpack_require__) {
+
+ 'use strict';
+
+ var $ = __webpack_require__(1);
+ var UI = __webpack_require__(2);
+ // require('./ui.dropdown');
+
+ // Make jQuery :contains Case-Insensitive
+ $.expr[':'].containsNC = function(elem, i, match, array) {
+ return (elem.textContent || elem.innerText || '').toLowerCase().
+ indexOf((match[3] || '').toLowerCase()) >= 0;
+ };
+
+ /**
+ * Selected
+ * @desc HTML select replacer
+ * @via https://github.com/silviomoreto/bootstrap-select
+ * @license https://github.com/silviomoreto/bootstrap-select/blob/master/LICENSE
+ * @param element
+ * @param options
+ * @constructor
+ */
+
+ var Selected = function(element, options) {
+ this.$element = $(element);
+ this.options = $.extend({}, Selected.DEFAULTS, {
+ placeholder: element.getAttribute('placeholder') ||
+ Selected.DEFAULTS.placeholder
+ }, options);
+ this.$originalOptions = this.$element.find('option');
+ this.multiple = element.multiple;
+ this.$selector = null;
+ this.initialized = false;
+ this.init();
+ };
+
+ Selected.DEFAULTS = {
+ btnWidth: null,
+ btnSize: null,
+ btnStyle: 'default',
+ dropUp: 0,
+ maxHeight: null,
+ maxChecked: null,
+ placeholder: '点击选择...',
+ selectedClass: 'am-checked',
+ disabledClass: 'am-disabled',
+ searchBox: false,
+ tpl: '' +
+ ' <%= option.text %> ' +
+ ' <% } else { %>' +
+ ' ' +
+ ' <%= option.text %>' +
+ ' ' +
+ ' <% } %>' +
+ ' <% } %>'
+ };
+
+ Selected.prototype.init = function() {
+ var _this = this;
+ var $element = this.$element;
+ var options = this.options;
+
+ $element.hide();
+
+ var data = {
+ id: UI.utils.generateGUID('am-selected'),
+ multiple: this.multiple,
+ options: [],
+ searchBox: options.searchBox,
+ dropUp: options.dropUp,
+ placeholder: options.placeholder
+ };
+
+ this.$selector = $(UI.template(this.options.tpl, data));
+ // set select button styles
+ this.$selector.css({width: this.options.btnWidth});
+
+ this.$list = this.$selector.find('.am-selected-list');
+ this.$searchField = this.$selector.find('.am-selected-search input');
+ this.$hint = this.$selector.find('.am-selected-hint');
+
+ var $selectorBtn = this.$selector.find('.am-selected-btn');
+ var btnClassNames = [];
+
+ options.btnSize && btnClassNames.push('am-btn-' + options.btnSize);
+ options.btnStyle && btnClassNames.push('am-btn-' + options.btnStyle);
+ $selectorBtn.addClass(btnClassNames.join(' '));
+
+ this.$selector.dropdown({
+ justify: $selectorBtn
+ });
+
+ // disable Selected instance if is disabled
+ // should call .disable() after Dropdown initialed
+ if ($element[0].disabled) {
+ this.disable();
+ }
+
+ // set list height
+ if (options.maxHeight) {
+ this.$selector.find('.am-selected-list').css({
+ 'max-height': options.maxHeight,
+ 'overflow-y': 'scroll'
+ });
+ }
+
+ // set hint text
+ var hint = [];
+ var min = $element.attr('minchecked');
+ var max = $element.attr('maxchecked') || options.maxChecked;
+
+ this.maxChecked = max || Infinity;
+
+ if ($element[0].required) {
+ hint.push('必选');
+ }
+
+ if (min || max) {
+ min && hint.push('至少选择 ' + min + ' 项');
+ max && hint.push('至多选择 ' + max + ' 项');
+ }
+
+ this.$hint.text(hint.join('，'));
+
+ // render dropdown list
+ this.renderOptions();
+
+ // append $selector after
"),d.mark(t,n).holidays(t,n).limit({elem:t,date:{year:n[0],month:n[1]-1,date:n[2]},index:e,rangeType:i,disabledType:"date"}),d.cellRender(t,{year:n[0],month:n[1],date:n[2]},"date")}),lay(c[0]).attr("lay-ym",s.year+"-"+(s.month+1)),lay(c[1]).attr("lay-ym",s.year+"-"+(s.month+1)),d.panelYM||(d.panelYM={}),d.panelYM[i]={year:s.year,month:s.month},"cn"===a.lang?(lay(c[0]).attr("lay-type","year").html(s.year+" \u5e74"),lay(c[1]).attr("lay-type","month").html(s.month+1+" \u6708")):(lay(c[0]).attr("lay-type","month").html(y.month[s.month]),lay(c[1]).attr("lay-type","year").html(s.year)),m&&(a.range?!e&&"init"===t||(d.listYM=[[(d.startDate||a.dateTime).year,(d.startDate||a.dateTime).month+1],[d.endDate.year,d.endDate.month+1]],d.list(a.type,0).list(a.type,1),"time"===a.type?d.setBtnStatus("\u65f6\u95f4",lay.extend({},d.systemDate(),d.startTime),lay.extend({},d.systemDate(),d.endTime)):d.setBtnStatus(!0)):(d.listYM=[[s.year,s.month+1]],d.list(a.type,0))),a.range&&"init"===t&&(d.rangeLinked?(n=d.getAsYM(s.year,s.month,i?"sub":null),d.calendar(lay.extend({},s,{year:n[0],month:n[1]}),1-i)):d.calendar(null,1-i)),a.range||(u=["hours","minutes","seconds"],d.limit({elem:lay(d.footer).find(".laydate-btns-now"),date:d.systemDate(/^(datetime|time)$/.test(a.type)?new Date:null),index:0,time:u,disabledType:"datetime"}),d.limit({elem:lay(d.footer).find(E),index:0,time:u,disabledType:"datetime"})),d.setBtnStatus(),lay(d.shortcut).find("li."+M).removeClass(M),a.range&&!m&&"init"!==t&&d.stampRange(),d},k.prototype.list=function(n,i){var l,r,e,a,o,d,t,s=this,y=s.config,m=s.rangeLinked?y.dateTime:[y.dateTime,s.endDate][i],u=s.lang(),c=y.range&&"date"!==y.type&&"datetime"!==y.type,h=lay.elem("ul",{"class":b+" "+{year:"laydate-year-list",month:"laydate-month-list",time:"laydate-time-list"}[n]}),p=s.elemHeader[i],f=lay(p[2]).find("span"),g=s.elemCont[i||0],D=lay(g).find("."+b)[0],T="cn"===y.lang,v=T?"\u5e74":"",x=s.listYM[i]||{},w=["hours","minutes","seconds"],k=["startTime","endTime"][i];return x[0]<1&&(x[0]=1),"year"===n?(e=l=x[0]-7,l<1&&(e=l=1),lay.each(new Array(15),function(e){var t=lay.elem("li",{"lay-ym":l}),a={year:l,month:0,date:1};l==x[0]&&lay(t).addClass(M),t.innerHTML=l+v,h.appendChild(t),s.limit({elem:lay(t),date:a,index:i,type:n,rangeType:i,disabledType:"date"}),s.cellRender(t,{year:l,month:1,date:1},"year"),l++}),lay(f[T?0:1]).attr("lay-ym",l-8+"-"+x[1]).html(e+v+" - "+(l-1)+v)):"month"===n?(lay.each(new Array(12),function(e){var t=lay.elem("li",{"lay-ym":e}),a={year:x[0],month:e,date:1};e+1==x[1]&&lay(t).addClass(M),t.innerHTML=u.month[e]+(T?"\u6708":""),h.appendChild(t),s.limit({elem:lay(t),date:a,index:i,type:n,rangeType:i,disabledType:"date"}),s.cellRender(t,{year:x[0],month:e+1,date:1},"month")}),lay(f[T?0:1]).attr("lay-ym",x[0]+"-"+x[1]).html(x[0]+v)):"time"===n&&(r=function(){lay(h).find("ol").each(function(a,e){lay(e).find("li").each(function(e,t){s.limit({elem:lay(t),date:[{hours:e},{hours:s[k].hours,minutes:e},{hours:s[k].hours,minutes:s[k].minutes,seconds:e}][a],index:i,rangeType:i,disabledType:"time",time:[["hours"],["hours","minutes"],["hours","minutes","seconds"]][a]})})}),y.range||s.limit({elem:lay(s.footer).find(E),date:s[k],index:0,time:["hours","minutes","seconds"],disabledType:"datetime"})},y.range?s[k]||(s[k]="startTime"===k?m:s.endDate):s[k]=m,lay.each([24,60,60],function(t,e){var a=lay.elem("li"),n=["' + message.replace('%icon', '') + '
'; + + // create the message container + this.viewport = document.createElement('div'); + this.viewport.className = 'ath-viewport'; + if (this.options.modal) { + this.viewport.className += ' ath-modal'; + } + if (this.options.mandatory) { + this.viewport.className += ' ath-mandatory'; + } + this.viewport.style.position = 'absolute'; + + // create the actual message element + this.element = document.createElement('div'); + this.element.className = 'ath-container ath-' + ath.OS + ' ath-' + ath.OS + (ath.OSVersion + '').substr(0, 1) + ' ath-' + (ath.isTablet ? 'tablet' : 'phone'); + this.element.style.cssText = '-webkit-transition-property:-webkit-transform,opacity;-webkit-transition-duration:0s;-webkit-transition-timing-function:ease-out;transition-property:transform,opacity;transition-duration:0s;transition-timing-function:ease-out;'; + this.element.style.webkitTransform = 'translate3d(0,-' + window.innerHeight + 'px,0)'; + this.element.style.transform = 'translate3d(0,-' + window.innerHeight + 'px,0)'; + + // add the application icon + if (this.options.icon && this.applicationIcon) { + this.element.className += ' ath-icon'; + this.img = document.createElement('img'); + this.img.className = 'ath-application-icon'; + this.img.addEventListener('load', this, false); + this.img.addEventListener('error', this, false); + + this.img.src = this.applicationIcon.href; + this.element.appendChild(this.img); + } + + this.element.innerHTML += message; + + // we are not ready to show, place the message out of sight + this.viewport.style.left = '-99999em'; + + // attach all elements to the DOM + this.viewport.appendChild(this.element); + this.container.appendChild(this.viewport); + + // if we don't have to wait for an image to load, show the message right away + if (this.img) { + this.doLog("Add to homescreen: not displaying callout because waiting for img to load"); + } else { + this._delayedShow(); + } + }, + + _delayedShow: function(e) { + setTimeout(this._show.bind(this), this.options.startDelay * 1000 + 500); + }, + + _show: function() { + var that = this; + + // update the viewport size and orientation + this.updateViewport(); + + // reposition/resize the message on orientation change + window.addEventListener('resize', this, false); + window.addEventListener('scroll', this, false); + window.addEventListener('orientationchange', this, false); + + if (this.options.modal) { + // lock any other interaction + document.addEventListener('touchmove', this, true); + } + + // Enable closing after 1 second + if (!this.options.mandatory) { + setTimeout(function() { + that.element.addEventListener('click', that, true); + }, 1000); + } + + // kick the animation + setTimeout(function() { + that.element.style.webkitTransitionDuration = '1.2s'; + that.element.style.transitionDuration = '1.2s'; + that.element.style.webkitTransform = 'translate3d(0,0,0)'; + that.element.style.transform = 'translate3d(0,0,0)'; + }, 0); + + // set the destroy timer + if (this.options.lifespan) { + this.removeTimer = setTimeout(this.remove.bind(this), this.options.lifespan * 1000); + } + + // fire the custom onShow event + if (this.options.onShow) { + this.options.onShow.call(this); + } + }, + + remove: function() { + clearTimeout(this.removeTimer); + + // clear up the event listeners + if (this.img) { + this.img.removeEventListener('load', this, false); + this.img.removeEventListener('error', this, false); + } + + window.removeEventListener('resize', this, false); + window.removeEventListener('scroll', this, false); + window.removeEventListener('orientationchange', this, false); + document.removeEventListener('touchmove', this, true); + this.element.removeEventListener('click', this, true); + + // remove the message element on transition end + this.element.addEventListener('transitionend', this, false); + this.element.addEventListener('webkitTransitionEnd', this, false); + this.element.addEventListener('MSTransitionEnd', this, false); + + // start the fade out animation + this.element.style.webkitTransitionDuration = '0.3s'; + this.element.style.opacity = '0'; + }, + + _removeElements: function() { + this.element.removeEventListener('transitionend', this, false); + this.element.removeEventListener('webkitTransitionEnd', this, false); + this.element.removeEventListener('MSTransitionEnd', this, false); + + // remove the message from the DOM + this.container.removeChild(this.viewport); + + this.shown = false; + + // fire the custom onRemove event + if (this.options.onRemove) { + this.options.onRemove.call(this); + } + }, + + updateViewport: function() { + if (!this.shown) { + return; + } + + this.viewport.style.width = window.innerWidth + 'px'; + this.viewport.style.height = window.innerHeight + 'px'; + this.viewport.style.left = window.scrollX + 'px'; + this.viewport.style.top = window.scrollY + 'px'; + + var clientWidth = document.documentElement.clientWidth; + + this.orientation = clientWidth > document.documentElement.clientHeight ? 'landscape' : 'portrait'; + + var screenWidth = ath.OS == 'ios' ? this.orientation == 'portrait' ? screen.width : screen.height : screen.width; + this.scale = screen.width > clientWidth ? 1 : screenWidth / window.innerWidth; + + this.element.style.fontSize = this.options.fontSize / this.scale + 'px'; + }, + + resize: function() { + clearTimeout(this.resizeTimer); + this.resizeTimer = setTimeout(this.updateViewport.bind(this), 100); + }, + + updateSession: function() { + if (ath.hasLocalStorage === false) { + return; + } + + if (localStorage) { + localStorage.setItem(this.options.appID, JSON.stringify(this.session)); + } + }, + + clearSession: function() { + this.session = _defaultSession; + this.updateSession(); + }, + + getItem: function(item) { + try { + if (!localStorage) { + throw new Error('localStorage is not defined'); + } + + return localStorage.getItem(item); + } catch (e) { + // Preventing exception for some browsers when fetching localStorage key + ath.hasLocalStorage = false; + } + }, + + optOut: function() { + this.session.optedout = true; + this.updateSession(); + }, + + optIn: function() { + this.session.optedout = false; + this.updateSession(); + }, + + clearDisplayCount: function() { + this.session.displayCount = 0; + this.updateSession(); + }, + + _preventDefault: function(e) { + e.preventDefault(); + e.stopPropagation(); + } + }; + + // utility + function _extend(target, obj) { + for (var i in obj) { + target[i] = obj[i]; + } + + return target; + } + + function _removeToken() { + if (document.location.hash == '#ath') { + history.replaceState('', window.document.title, document.location.href.split('#')[0]); + } + + if (_reSmartURL.test(document.location.href)) { + history.replaceState('', window.document.title, document.location.href.replace(_reSmartURL, '$1')); + } + + if (_reQueryString.test(document.location.search)) { + history.replaceState('', window.document.title, document.location.href.replace(_reQueryString, '$2')); + } + } + + /* jshint +W101, +W106 */ + + ath.VERSION = '3.2.2'; + + module.exports = UI.addToHomescreen = ath; + + +/***/ }, +/* 5 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var $ = __webpack_require__(1); + var UI = __webpack_require__(2); + + /** + * @via https://github.com/Minwe/bootstrap/blob/master/js/alert.js + * @copyright Copyright 2013 Twitter, Inc. + * @license Apache 2.0 + */ + + // Alert Class + // NOTE: removeElement option is unavailable now + var Alert = function(element, options) { + var _this = this; + this.options = $.extend({}, Alert.DEFAULTS, options); + this.$element = $(element); + + this.$element + .addClass('am-fade am-in') + .on('click.alert.amui', '.am-close', function() { + _this.close(); + }); + }; + + Alert.DEFAULTS = { + removeElement: true + }; + + Alert.prototype.close = function() { + var $element = this.$element; + + $element.trigger('close.alert.amui').removeClass('am-in'); + + function processAlert() { + $element.trigger('closed.alert.amui').remove(); + } + + UI.support.transition && $element.hasClass('am-fade') ? + $element + .one(UI.support.transition.end, processAlert) + .emulateTransitionEnd(200) : + processAlert(); + }; + + // plugin + UI.plugin('alert', Alert); + + // Init code + $(document).on('click.alert.amui.data-api', '[data-am-alert]', function(e) { + var $target = $(e.target); + $target.is('.am-close') && $(this).alert('close'); + }); + + module.exports = Alert; + + +/***/ }, +/* 6 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var $ = __webpack_require__(1); + var UI = __webpack_require__(2); + + /** + * @via https://github.com/twbs/bootstrap/blob/master/js/button.js + * @copyright (c) 2011-2014 Twitter, Inc + * @license The MIT License + */ + + var Button = function(element, options) { + this.$element = $(element); + this.options = $.extend({}, Button.DEFAULTS, options); + this.isLoading = false; + this.hasSpinner = false; + }; + + Button.DEFAULTS = { + loadingText: 'loading...', + disabledClassName: 'am-disabled', + activeClassName: 'am-active', + spinner: undefined + }; + + Button.prototype.setState = function(state, stateText) { + var $element = this.$element; + var disabled = 'disabled'; + var data = $element.data(); + var options = this.options; + var val = $element.is('input') ? 'val' : 'html'; + var stateClassName = 'am-btn-' + state + ' ' + options.disabledClassName; + + state += 'Text'; + + if (!options.resetText) { + options.resetText = $element[val](); + } + + // add spinner for element with html() + if (UI.support.animation && options.spinner && + val === 'html' && !this.hasSpinner) { + options.loadingText = '' + options.loadingText; + + this.hasSpinner = true; + } + + stateText = stateText || + (data[state] === undefined ? options[state] : data[state]); + + $element[val](stateText); + + // push to event loop to allow forms to submit + setTimeout($.proxy(function() { + // TODO: add stateClass for other states + if (state === 'loadingText') { + $element.addClass(stateClassName).attr(disabled, disabled); + this.isLoading = true; + } else if (this.isLoading) { + $element.removeClass(stateClassName).removeAttr(disabled); + this.isLoading = false; + } + }, this), 0); + }; + + Button.prototype.toggle = function() { + var changed = true; + var $element = this.$element; + var $parent = this.$element.parent('[class*="am-btn-group"]'); + var activeClassName = Button.DEFAULTS.activeClassName; + + if ($parent.length) { + var $input = this.$element.find('input'); + + if ($input.prop('type') == 'radio') { + if ($input.prop('checked') && $element.hasClass(activeClassName)) { + changed = false; + } else { + $parent.find('.' + activeClassName).removeClass(activeClassName); + } + } + + if (changed) { + $input.prop('checked', + !$element.hasClass(activeClassName)).trigger('change'); + } + } + + if (changed) { + $element.toggleClass(activeClassName); + if (!$element.hasClass(activeClassName)) { + $element.blur(); + } + } + }; + + UI.plugin('button', Button, { + dataOptions: 'data-am-loading', + methodCall: function(args, instance) { + if (args[0] === 'toggle') { + instance.toggle(); + } else if (typeof args[0] === 'string') { + instance.setState.apply(instance, args); + } + } + }); + + // Init code + $(document).on('click.button.amui.data-api', '[data-am-button]', function(e) { + e.preventDefault(); + var $btn = $(e.target); + + if (!$btn.hasClass('am-btn')) { + $btn = $btn.closest('.am-btn'); + } + + $btn.button('toggle'); + }); + + UI.ready(function(context) { + $('[data-am-loading]', context).button(); + + // resolves #866 + $('[data-am-button]', context).find('input:checked').each(function() { + $(this).parent('label').addClass(Button.DEFAULTS.activeClassName); + }); + }); + + module.exports = UI.button = Button; + + +/***/ }, +/* 7 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var $ = __webpack_require__(1); + var UI = __webpack_require__(2); + + /** + * @via https://github.com/twbs/bootstrap/blob/master/js/collapse.js + * @copyright (c) 2011-2014 Twitter, Inc + * @license The MIT License + */ + + var Collapse = function(element, options) { + this.$element = $(element); + this.options = $.extend({}, Collapse.DEFAULTS, options); + this.transitioning = null; + + if (this.options.parent) { + this.$parent = $(this.options.parent); + } + + if (this.options.toggle) { + this.toggle(); + } + }; + + Collapse.DEFAULTS = { + toggle: true + }; + + Collapse.prototype.open = function() { + if (this.transitioning || this.$element.hasClass('am-in')) { + return; + } + + var startEvent = $.Event('open.collapse.amui'); + this.$element.trigger(startEvent); + + if (startEvent.isDefaultPrevented()) { + return; + } + + var actives = this.$parent && this.$parent.find('> .am-panel > .am-in'); + + if (actives && actives.length) { + var hasData = actives.data('amui.collapse'); + + if (hasData && hasData.transitioning) { + return; + } + + Plugin.call(actives, 'close'); + + hasData || actives.data('amui.collapse', null); + } + + this.$element + .removeClass('am-collapse') + .addClass('am-collapsing').height(0); + + this.transitioning = 1; + + var complete = function() { + this.$element + .removeClass('am-collapsing') + .addClass('am-collapse am-in') + .height('') + .trigger('opened.collapse.amui'); + this.transitioning = 0; + }; + + if (!UI.support.transition) { + return complete.call(this); + } + + var scrollHeight = this.$element[0].scrollHeight; + + this.$element + .one(UI.support.transition.end, $.proxy(complete, this)) + .emulateTransitionEnd(300) + .css({height: scrollHeight}); // 当折叠的容器有 padding 时，如果用 height() 只能设置内容的宽度 + }; + + Collapse.prototype.close = function() { + if (this.transitioning || !this.$element.hasClass('am-in')) { + return; + } + + var startEvent = $.Event('close.collapse.amui'); + this.$element.trigger(startEvent); + + if (startEvent.isDefaultPrevented()) { + return; + } + + this.$element.height(this.$element.height()).redraw(); + + this.$element.addClass('am-collapsing'). + removeClass('am-collapse am-in'); + + this.transitioning = 1; + + var complete = function() { + this.transitioning = 0; + this.$element + .trigger('closed.collapse.amui') + .removeClass('am-collapsing') + .addClass('am-collapse'); + // css({height: '0'}); + }; + + if (!UI.support.transition) { + return complete.call(this); + } + + this.$element.height(0) + .one(UI.support.transition.end, $.proxy(complete, this)) + .emulateTransitionEnd(300); + }; + + Collapse.prototype.toggle = function() { + this[this.$element.hasClass('am-in') ? 'close' : 'open'](); + }; + + // Collapse Plugin + function Plugin(option) { + return this.each(function() { + var $this = $(this); + var data = $this.data('amui.collapse'); + var options = $.extend({}, Collapse.DEFAULTS, + UI.utils.options($this.attr('data-am-collapse')), + typeof option == 'object' && option); + + if (!data && options.toggle && option === 'open') { + option = !option; + } + + if (!data) { + $this.data('amui.collapse', (data = new Collapse(this, options))); + } + + if (typeof option == 'string') { + data[option](); + } + }); + } + + $.fn.collapse = Plugin; + + // Init code + $(document).on('click.collapse.amui.data-api', '[data-am-collapse]', + function(e) { + var href; + var $this = $(this); + var options = UI.utils.options($this.attr('data-am-collapse')); + var target = options.target || + e.preventDefault() || + (href = $this.attr('href')) && + href.replace(/.*(?=#[^\s]+$)/, ''); + var $target = $(target); + var data = $target.data('amui.collapse'); + var option = data ? 'toggle' : options; + var parent = options.parent; + var $parent = parent && $(parent); + + if (!data || !data.transitioning) { + if ($parent) { + // '[data-am-collapse*="{parent: \'' + parent + '"] + $parent.find('[data-am-collapse]').not($this).addClass('am-collapsed'); + } + + $this[$target.hasClass('am-in') ? + 'addClass' : 'removeClass']('am-collapsed'); + } + + Plugin.call($target, option); + }); + + module.exports = UI.collapse = Collapse; + + // TODO: 更好的 target 选择方式 + // 折叠的容器必须没有 border/padding 才能正常处理，否则动画会有一些小问题 + // 寻找更好的未知高度 transition 动画解决方案，max-height 之类的就算了 + + +/***/ }, +/* 8 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var $ = __webpack_require__(1); + var UI = __webpack_require__(2); + var $doc = $(document); + + /** + * bootstrap-datepicker.js + * @via http://www.eyecon.ro/bootstrap-datepicker + * @license http://www.apache.org/licenses/LICENSE-2.0 + */ + var Datepicker = function(element, options) { + this.$element = $(element); + this.options = $.extend({}, Datepicker.DEFAULTS, options); + this.format = DPGlobal.parseFormat(this.options.format); + + this.$element.data('date', this.options.date); + this.language = this.getLocale(this.options.locale); + this.theme = this.options.theme; + this.$picker = $(DPGlobal.template).appendTo('body').on({ + click: $.proxy(this.click, this) + // mousedown: $.proxy(this.mousedown, this) + }); + + this.isInput = this.$element.is('input'); + this.component = this.$element.is('.am-datepicker-date') ? + this.$element.find('.am-datepicker-add-on') : false; + + if (this.isInput) { + this.$element.on({ + 'click.datepicker.amui': $.proxy(this.open, this), + // blur: $.proxy(this.close, this), + 'keyup.datepicker.amui': $.proxy(this.update, this) + }); + } else { + if (this.component) { + this.component.on('click.datepicker.amui', $.proxy(this.open, this)); + } else { + this.$element.on('click.datepicker.amui', $.proxy(this.open, this)); + } + } + + this.minViewMode = this.options.minViewMode; + + if (typeof this.minViewMode === 'string') { + switch (this.minViewMode) { + case 'months': + this.minViewMode = 1; + break; + case 'years': + this.minViewMode = 2; + break; + default: + this.minViewMode = 0; + break; + } + } + + this.viewMode = this.options.viewMode; + + if (typeof this.viewMode === 'string') { + switch (this.viewMode) { + case 'months': + this.viewMode = 1; + break; + case 'years': + this.viewMode = 2; + break; + default: + this.viewMode = 0; + break; + } + } + + this.startViewMode = this.viewMode; + this.weekStart = ((this.options.weekStart || + Datepicker.locales[this.language].weekStart || 0) % 7); + this.weekEnd = ((this.weekStart + 6) % 7); + this.onRender = this.options.onRender; + + this.setTheme(); + this.fillDow(); + this.fillMonths(); + this.update(); + this.showMode(); + }; + + Datepicker.DEFAULTS = { + locale: 'zh_CN', + format: 'yyyy-mm-dd', + weekStart: undefined, + viewMode: 0, + minViewMode: 0, + date: '', + theme: '', + autoClose: 1, + onRender: function(date) { + return ''; + } + }; + + Datepicker.prototype.open = function(e) { + this.$picker.show(); + this.height = this.component ? + this.component.outerHeight() : this.$element.outerHeight(); + + this.place(); + $(window).on('resize.datepicker.amui', $.proxy(this.place, this)); + if (e) { + e.stopPropagation(); + e.preventDefault(); + } + var that = this; + $doc.on('mousedown.datapicker.amui touchstart.datepicker.amui', function(ev) { + if ($(ev.target).closest('.am-datepicker').length === 0) { + that.close(); + } + }); + this.$element.trigger({ + type: 'open.datepicker.amui', + date: this.date + }); + }; + + Datepicker.prototype.close = function() { + this.$picker.hide(); + $(window).off('resize.datepicker.amui', this.place); + this.viewMode = this.startViewMode; + this.showMode(); + if (!this.isInput) { + $(document).off('mousedown.datapicker.amui touchstart.datepicker.amui', + this.close); + } + // this.set(); + this.$element.trigger({ + type: 'close.datepicker.amui', + date: this.date + }); + }; + + Datepicker.prototype.set = function() { + var formatted = DPGlobal.formatDate(this.date, this.format); + var $input; + + if (!this.isInput) { + if (this.component) { + $input = this.$element.find('input').attr('value', formatted); + } + + this.$element.data('date', formatted); + } else { + $input = this.$element.attr('value', formatted); + } + + // fixes https://github.com/amazeui/amazeui/issues/711 + $input && $input.trigger('change'); + }; + + Datepicker.prototype.setValue = function(newDate) { + if (typeof newDate === 'string') { + this.date = DPGlobal.parseDate(newDate, this.format); + } else { + this.date = new Date(newDate); + } + this.set(); + + this.viewDate = new Date(this.date.getFullYear(), + this.date.getMonth(), 1, 0, 0, 0, 0); + + this.fill(); + }; + + Datepicker.prototype.place = function() { + var offset = this.component ? + this.component.offset() : this.$element.offset(); + var $width = this.component ? + this.component.width() : this.$element.width(); + var top = offset.top + this.height; + var left = offset.left; + var right = $doc.width() - offset.left - $width; + var isOutView = this.isOutView(); + + this.$picker.removeClass('am-datepicker-right'); + this.$picker.removeClass('am-datepicker-up'); + + if ($doc.width() > 640) { + if (isOutView.outRight) { + this.$picker.addClass('am-datepicker-right'); + this.$picker.css({ + top: top, + left: 'auto', + right: right + }); + return; + } + if (isOutView.outBottom) { + this.$picker.addClass('am-datepicker-up'); + top = offset.top - this.$picker.outerHeight(true); + } + } else { + left = 0; + } + + this.$picker.css({ + top: top, + left: left + }); + }; + + Datepicker.prototype.update = function(newDate) { + this.date = DPGlobal.parseDate( + typeof newDate === 'string' ? newDate : (this.isInput ? + this.$element.prop('value') : this.$element.data('date')), + this.format + ); + this.viewDate = new Date(this.date.getFullYear(), + this.date.getMonth(), 1, 0, 0, 0, 0); + this.fill(); + }; + + // Days of week + Datepicker.prototype.fillDow = function() { + var dowCount = this.weekStart; + var html = '' +
+ '' +
+ '
';
+
+ // jQuery plugin
+ UI.plugin('datepicker', Datepicker);
+
+ // Init code
+ UI.ready(function(context) {
+ $('[data-am-datepicker]').datepicker();
+ });
+
+ module.exports = UI.datepicker = Datepicker;
+
+ // TODO: 1. 载入动画
+ // 2. less 优化
+
+
+/***/ },
+/* 9 */
+/***/ function(module, exports, __webpack_require__) {
+
+ 'use strict';
+
+ var $ = __webpack_require__(1);
+ var UI = __webpack_require__(2);
+ var $doc = $(document);
+ var transition = UI.support.transition;
+
+ var Dimmer = function() {
+ this.id = UI.utils.generateGUID('am-dimmer');
+ this.$element = $(Dimmer.DEFAULTS.tpl, {
+ id: this.id
+ });
+
+ this.inited = false;
+ this.scrollbarWidth = 0;
+ this.$used = $([]);
+ };
+
+ Dimmer.DEFAULTS = {
+ tpl: ''
+ };
+
+ Dimmer.prototype.init = function() {
+ if (!this.inited) {
+ $(document.body).append(this.$element);
+ this.inited = true;
+ $doc.trigger('init.dimmer.amui');
+ this.$element.on('touchmove.dimmer.amui', function(e) {
+ e.preventDefault();
+ });
+ }
+
+ return this;
+ };
+
+ Dimmer.prototype.open = function(relatedElement) {
+ if (!this.inited) {
+ this.init();
+ }
+
+ var $element = this.$element;
+
+ // 用于多重调用
+ if (relatedElement) {
+ this.$used = this.$used.add($(relatedElement));
+ }
+
+ this.checkScrollbar().setScrollbar();
+
+ $element.show().trigger('open.dimmer.amui');
+
+ transition && $element.off(transition.end);
+
+ setTimeout(function() {
+ $element.addClass('am-active');
+ }, 0);
+
+ return this;
+ };
+
+ Dimmer.prototype.close = function(relatedElement, force) {
+ this.$used = this.$used.not($(relatedElement));
+
+ if (!force && this.$used.length) {
+ return this;
+ }
+
+ var $element = this.$element;
+
+ $element.removeClass('am-active').trigger('close.dimmer.amui');
+
+ function complete() {
+ $element.hide();
+ this.resetScrollbar();
+ }
+
+ // transition ? $element.one(transition.end, $.proxy(complete, this)) :
+ complete.call(this);
+
+ return this;
+ };
+
+ Dimmer.prototype.checkScrollbar = function() {
+ this.scrollbarWidth = UI.utils.measureScrollbar();
+
+ return this;
+ };
+
+ Dimmer.prototype.setScrollbar = function() {
+ var $body = $(document.body);
+ var bodyPaddingRight = parseInt(($body.css('padding-right') || 0), 10);
+
+ if (this.scrollbarWidth) {
+ $body.css('padding-right', bodyPaddingRight + this.scrollbarWidth);
+ }
+
+ $body.addClass('am-dimmer-active');
+
+ return this;
+ };
+
+ Dimmer.prototype.resetScrollbar = function() {
+ $(document.body).css('padding-right', '').removeClass('am-dimmer-active');
+
+ return this;
+ };
+
+ module.exports = UI.dimmer = new Dimmer();
+
+
+/***/ },
+/* 10 */
+/***/ function(module, exports, __webpack_require__) {
+
+ 'use strict';
+
+ var $ = __webpack_require__(1);
+ var UI = __webpack_require__(2);
+ var animation = UI.support.animation;
+
+ /**
+ * @via https://github.com/Minwe/bootstrap/blob/master/js/dropdown.js
+ * @copyright (c) 2011-2014 Twitter, Inc
+ * @license The MIT License
+ */
+
+ // var toggle = '[data-am-dropdown] > .am-dropdown-toggle';
+
+ var Dropdown = function(element, options) {
+ this.options = $.extend({}, Dropdown.DEFAULTS, options);
+
+ options = this.options;
+
+ this.$element = $(element);
+ this.$toggle = this.$element.find(options.selector.toggle);
+ this.$dropdown = this.$element.find(options.selector.dropdown);
+ this.$boundary = (options.boundary === window) ? $(window) :
+ this.$element.closest(options.boundary);
+ this.$justify = (options.justify && $(options.justify).length &&
+ $(options.justify)) || undefined;
+
+ !this.$boundary.length && (this.$boundary = $(window));
+
+ this.active = this.$element.hasClass('am-active') ? true : false;
+ this.animating = null;
+
+ this.events();
+ };
+
+ Dropdown.DEFAULTS = {
+ animation: 'am-animation-slide-top-fixed',
+ boundary: window,
+ justify: undefined,
+ selector: {
+ dropdown: '.am-dropdown-content',
+ toggle: '.am-dropdown-toggle'
+ },
+ trigger: 'click'
+ };
+
+ Dropdown.prototype.toggle = function() {
+ this.clear();
+
+ if (this.animating) {
+ return;
+ }
+
+ this[this.active ? 'close' : 'open']();
+ };
+
+ Dropdown.prototype.open = function(e) {
+ var $toggle = this.$toggle;
+ var $element = this.$element;
+ var $dropdown = this.$dropdown;
+
+ if ($toggle.is('.am-disabled, :disabled')) {
+ return;
+ }
+
+ if (this.active) {
+ return;
+ }
+
+ $element.trigger('open.dropdown.amui').addClass('am-active');
+
+ $toggle.trigger('focus');
+
+ this.checkDimensions(e);
+
+ var complete = $.proxy(function() {
+ $element.trigger('opened.dropdown.amui');
+ this.active = true;
+ this.animating = 0;
+ }, this);
+
+ if (animation) {
+ this.animating = 1;
+ $dropdown.addClass(this.options.animation).
+ on(animation.end + '.open.dropdown.amui', $.proxy(function() {
+ complete();
+ $dropdown.removeClass(this.options.animation);
+ }, this));
+ } else {
+ complete();
+ }
+ };
+
+ Dropdown.prototype.close = function() {
+ if (!this.active) {
+ return;
+ }
+
+ // fix #165
+ // var animationName = this.options.animation + ' am-animation-reverse';
+ var animationName = 'am-dropdown-animation';
+ var $element = this.$element;
+ var $dropdown = this.$dropdown;
+
+ $element.trigger('close.dropdown.amui');
+
+ var complete = $.proxy(function complete() {
+ $element.
+ removeClass('am-active').
+ trigger('closed.dropdown.amui');
+ this.active = false;
+ this.animating = 0;
+ this.$toggle.blur();
+ }, this);
+
+ if (animation) {
+ $dropdown.removeClass(this.options.animation);
+ $dropdown.addClass(animationName);
+ this.animating = 1;
+ // animation
+ $dropdown.one(animation.end + '.close.dropdown.amui', function() {
+ $dropdown.removeClass(animationName);
+ complete();
+ });
+ } else {
+ complete();
+ }
+ };
+
+ Dropdown.prototype.enable = function() {
+ this.$toggle.prop('disabled', false);
+ },
+
+ Dropdown.prototype.disable = function() {
+ this.$toggle.prop('disabled', true);
+ },
+
+ Dropdown.prototype.checkDimensions = function(e) {
+ if (!this.$dropdown.length) {
+ return;
+ }
+
+ var $dropdown = this.$dropdown;
+
+ // @see #873
+ if (e && e.offset) {
+ $dropdown.offset(e.offset);
+ }
+
+ var offset = $dropdown.offset();
+ var width = $dropdown.outerWidth();
+ var boundaryWidth = this.$boundary.width();
+ var boundaryOffset = $.isWindow(this.boundary) && this.$boundary.offset() ?
+ this.$boundary.offset().left : 0;
+
+ if (this.$justify) {
+ // jQuery.fn.width() is really...
+ $dropdown.css({'min-width': this.$justify.css('width')});
+ }
+
+ if ((width + (offset.left - boundaryOffset)) > boundaryWidth) {
+ this.$element.addClass('am-dropdown-flip');
+ }
+ };
+
+ Dropdown.prototype.clear = function() {
+ $('[data-am-dropdown]').not(this.$element).each(function() {
+ var data = $(this).data('amui.dropdown');
+ data && data.close();
+ });
+ };
+
+ Dropdown.prototype.events = function() {
+ var eventNS = 'dropdown.amui';
+ // triggers = this.options.trigger.split(' '),
+ var $toggle = this.$toggle;
+
+ $toggle.on('click.' + eventNS, $.proxy(function(e) {
+ e.preventDefault();
+ this.toggle();
+ }, this));
+
+ /*for (var i = triggers.length; i--;) {
+ var trigger = triggers[i];
+
+ if (trigger === 'click') {
+ $toggle.on('click.' + eventNS, $.proxy(this.toggle, this))
+ }
+
+ if (trigger === 'focus' || trigger === 'hover') {
+ var eventIn = trigger == 'hover' ? 'mouseenter' : 'focusin';
+ var eventOut = trigger == 'hover' ? 'mouseleave' : 'focusout';
+
+ this.$element.on(eventIn + '.' + eventNS, $.proxy(this.open, this))
+ .on(eventOut + '.' + eventNS, $.proxy(this.close, this));
+ }
+ }*/
+
+ $(document).on('keydown.dropdown.amui', $.proxy(function(e) {
+ e.keyCode === 27 && this.active && this.close();
+ }, this)).on('click.outer.dropdown.amui', $.proxy(function(e) {
+ // var $target = $(e.target);
+
+ if (this.active &&
+ (this.$element[0] === e.target || !this.$element.find(e.target).length)) {
+ this.close();
+ }
+ }, this));
+ };
+
+ // Dropdown Plugin
+ UI.plugin('dropdown', Dropdown);
+
+ // Init code
+ UI.ready(function(context) {
+ $('[data-am-dropdown]', context).dropdown();
+ });
+
+ $(document).on('click.dropdown.amui.data-api', '.am-dropdown form',
+ function(e) {
+ e.stopPropagation();
+ });
+
+ module.exports = UI.dropdown = Dropdown;
+
+ // TODO: 1. 处理链接 focus
+ // 2. 增加 mouseenter / mouseleave 选项
+ // 3. 宽度适应
+
+
+/***/ },
+/* 11 */
+/***/ function(module, exports, __webpack_require__) {
+
+ /* WEBPACK VAR INJECTION */(function(setImmediate) {var $ = __webpack_require__(1);
+ var UI = __webpack_require__(2);
+
+ // MODIFIED:
+ // - LINE 252: add ``
+ // - namespace
+ // - Init code
+ // TODO: start after x ms when pause on actions
+
+ /*
+ * jQuery FlexSlider v2.6.1
+ * Copyright 2012 WooThemes
+ * Contributing Author: Tyler Smith
+ */
+
+ var focused = true;
+
+ // FlexSlider: Object Instance
+ $.flexslider = function(el, options) {
+ var slider = $(el);
+
+ // making variables public
+ slider.vars = $.extend({}, $.flexslider.defaults, options);
+
+ var namespace = slider.vars.namespace,
+ msGesture = window.navigator && window.navigator.msPointerEnabled && window.MSGesture,
+ touch = (( "ontouchstart" in window ) || msGesture || window.DocumentTouch && document instanceof DocumentTouch) && slider.vars.touch,
+ // depricating this idea, as devices are being released with both of these events
+ eventType = "click touchend MSPointerUp keyup",
+ watchedEvent = "",
+ watchedEventClearTimer,
+ vertical = slider.vars.direction === "vertical",
+ reverse = slider.vars.reverse,
+ carousel = (slider.vars.itemWidth > 0),
+ fade = slider.vars.animation === "fade",
+ asNav = slider.vars.asNavFor !== "",
+ methods = {};
+
+ // Store a reference to the slider object
+ $.data(el, 'flexslider', slider);
+
+ // Private slider methods
+ methods = {
+ init: function() {
+ slider.animating = false;
+ // Get current slide and make sure it is a number
+ slider.currentSlide = parseInt((slider.vars.startAt ? slider.vars.startAt : 0), 10);
+ if (isNaN(slider.currentSlide)) {
+ slider.currentSlide = 0;
+ }
+ slider.animatingTo = slider.currentSlide;
+ slider.atEnd = (slider.currentSlide === 0 || slider.currentSlide === slider.last);
+ slider.containerSelector = slider.vars.selector.substr(0, slider.vars.selector.search(' '));
+ slider.slides = $(slider.vars.selector, slider);
+ slider.container = $(slider.containerSelector, slider);
+ slider.count = slider.slides.length;
+ // SYNC:
+ slider.syncExists = $(slider.vars.sync).length > 0;
+ // SLIDE:
+ if (slider.vars.animation === "slide") {
+ slider.vars.animation = "swing";
+ }
+ slider.prop = (vertical) ? "top" : "marginLeft";
+ slider.args = {};
+ // SLIDESHOW:
+ slider.manualPause = false;
+ slider.stopped = false;
+ //PAUSE WHEN INVISIBLE
+ slider.started = false;
+ slider.startTimeout = null;
+ // TOUCH/USECSS:
+ slider.transitions = !slider.vars.video && !fade && slider.vars.useCSS && (function() {
+ var obj = document.createElement('div'),
+ props = ['perspectiveProperty', 'WebkitPerspective', 'MozPerspective', 'OPerspective', 'msPerspective'];
+ for (var i in props) {
+ if (obj.style[props[i]] !== undefined) {
+ slider.pfx = props[i].replace('Perspective', '').toLowerCase();
+ slider.prop = "-" + slider.pfx + "-transform";
+ return true;
+ }
+ }
+ return false;
+ }());
+ slider.ensureAnimationEnd = '';
+ // CONTROLSCONTAINER:
+ if (slider.vars.controlsContainer !== "") slider.controlsContainer = $(slider.vars.controlsContainer).length > 0 && $(slider.vars.controlsContainer);
+ // MANUAL:
+ if (slider.vars.manualControls !== "") slider.manualControls = $(slider.vars.manualControls).length > 0 && $(slider.vars.manualControls);
+
+ // CUSTOM DIRECTION NAV:
+ if (slider.vars.customDirectionNav !== "") slider.customDirectionNav = $(slider.vars.customDirectionNav).length === 2 && $(slider.vars.customDirectionNav);
+
+ // RANDOMIZE:
+ if (slider.vars.randomize) {
+ slider.slides.sort(function() {
+ return (Math.round(Math.random()) - 0.5);
+ });
+ slider.container.empty().append(slider.slides);
+ }
+
+ slider.doMath();
+
+ // INIT
+ slider.setup("init");
+
+ // CONTROLNAV:
+ if (slider.vars.controlNav) {
+ methods.controlNav.setup();
+ }
+
+ // DIRECTIONNAV:
+ if (slider.vars.directionNav) {
+ methods.directionNav.setup();
+ }
+
+ // KEYBOARD:
+ if (slider.vars.keyboard && ($(slider.containerSelector).length === 1 || slider.vars.multipleKeyboard)) {
+ $(document).bind('keyup', function(event) {
+ var keycode = event.keyCode;
+ if (!slider.animating && (keycode === 39 || keycode === 37)) {
+ var target = (keycode === 39) ? slider.getTarget('next') :
+ (keycode === 37) ? slider.getTarget('prev') : false;
+ slider.flexAnimate(target, slider.vars.pauseOnAction);
+ }
+ });
+ }
+ // MOUSEWHEEL:
+ if (slider.vars.mousewheel) {
+ slider.bind('mousewheel', function(event, delta, deltaX, deltaY) {
+ event.preventDefault();
+ var target = (delta < 0) ? slider.getTarget('next') : slider.getTarget('prev');
+ slider.flexAnimate(target, slider.vars.pauseOnAction);
+ });
+ }
+
+ // PAUSEPLAY
+ if (slider.vars.pausePlay) {
+ methods.pausePlay.setup();
+ }
+
+ //PAUSE WHEN INVISIBLE
+ if (slider.vars.slideshow && slider.vars.pauseInvisible) {
+ methods.pauseInvisible.init();
+ }
+
+ // SLIDSESHOW
+ if (slider.vars.slideshow) {
+ if (slider.vars.pauseOnHover) {
+ slider.hover(function() {
+ if (!slider.manualPlay && !slider.manualPause) {slider.pause();}
+ }, function() {
+ if (!slider.manualPause && !slider.manualPlay && !slider.stopped) {slider.play();}
+ });
+ }
+ // initialize animation
+ // If we're visible, or we don't use PageVisibility API
+ if (!slider.vars.pauseInvisible || !methods.pauseInvisible.isHidden()) {
+ (slider.vars.initDelay > 0) ? slider.startTimeout = setTimeout(slider.play, slider.vars.initDelay) : slider.play();
+ }
+ }
+
+ // ASNAV:
+ if (asNav) {methods.asNav.setup();}
+
+ // TOUCH
+ if (touch && slider.vars.touch) {methods.touch();}
+
+ // FADE&&SMOOTHHEIGHT || SLIDE:
+ if (!fade || (fade && slider.vars.smoothHeight)) {$(window).bind("resize orientationchange focus", methods.resize);}
+
+ slider.find("img").attr("draggable", "false");
+
+ // API: start() Callback
+ setTimeout(function() {
+ slider.vars.start(slider);
+ }, 200);
+ },
+ asNav: {
+ setup: function() {
+ slider.asNav = true;
+ slider.animatingTo = Math.floor(slider.currentSlide / slider.move);
+ slider.currentItem = slider.currentSlide;
+ slider.slides.removeClass(namespace + "active-slide").eq(slider.currentItem).addClass(namespace + "active-slide");
+ if (!msGesture) {
+ slider.slides.on(eventType, function(e) {
+ e.preventDefault();
+ var $slide = $(this),
+ target = $slide.index();
+ var posFromLeft = $slide.offset().left - $(slider).scrollLeft(); // Find position of slide relative to left of slider container
+ if (posFromLeft <= 0 && $slide.hasClass(namespace + 'active-slide')) {
+ slider.flexAnimate(slider.getTarget("prev"), true);
+ } else if (!$(slider.vars.asNavFor).data('flexslider').animating && !$slide.hasClass(namespace + "active-slide")) {
+ slider.direction = (slider.currentItem < target) ? "next" : "prev";
+ slider.flexAnimate(target, slider.vars.pauseOnAction, false, true, true);
+ }
+ });
+ } else {
+ el._slider = slider;
+ slider.slides.each(function() {
+ var that = this;
+ that._gesture = new MSGesture();
+ that._gesture.target = that;
+ that.addEventListener("MSPointerDown", function(e) {
+ e.preventDefault();
+ if (e.currentTarget._gesture) {
+ e.currentTarget._gesture.addPointer(e.pointerId);
+ }
+ }, false);
+ that.addEventListener("MSGestureTap", function(e) {
+ e.preventDefault();
+ var $slide = $(this),
+ target = $slide.index();
+ if (!$(slider.vars.asNavFor).data('flexslider').animating && !$slide.hasClass('active')) {
+ slider.direction = (slider.currentItem < target) ? "next" : "prev";
+ slider.flexAnimate(target, slider.vars.pauseOnAction, false, true, true);
+ }
+ });
+ });
+ }
+ }
+ },
+ controlNav: {
+ setup: function() {
+ if (!slider.manualControls) {
+ methods.controlNav.setupPaging();
+ } else { // MANUALCONTROLS:
+ methods.controlNav.setupManual();
+ }
+ },
+ setupPaging: function() {
+ var type = (slider.vars.controlNav === "thumbnails") ? 'control-thumbs' : 'control-paging',
+ j = 1,
+ item,
+ slide;
+
+ slider.controlNavScaffold = $('' +
+ '' +
+ DPGlobal.headTemplate +
+ '' +
+ '
' +
+ '
' +
+ '' +
+ '' +
+ DPGlobal.headTemplate +
+ DPGlobal.contTemplate +
+ '
' +
+ '
' +
+ '' +
+ '' +
+ DPGlobal.headTemplate +
+ DPGlobal.contTemplate +
+ '
' +
+ '
' +
+ '' +
+ '' +
+ '
'
+ };
+
+ Popover.prototype.init = function() {
+ var _this = this;
+ var $element = this.$element;
+ var $popover;
+
+ if (!this.options.target) {
+ this.$popover = this.getPopover();
+ this.setContent();
+ }
+
+ $popover = this.$popover;
+
+ $popover.appendTo($('body'));
+
+ this.sizePopover();
+
+ function sizePopover() {
+ _this.sizePopover();
+ }
+
+ // TODO: 监听页面内容变化，重新调整位置
+
+ $element.on('open.popover.amui', function() {
+ $(window).on('resize.popover.amui', UI.utils.debounce(sizePopover, 50));
+ });
+
+ $element.on('close.popover.amui', function() {
+ $(window).off('resize.popover.amui', sizePopover);
+ });
+
+ this.options.open && this.open();
+ };
+
+ Popover.prototype.sizePopover = function sizePopover() {
+ var $element = this.$element;
+ var $popover = this.$popover;
+
+ if (!$popover || !$popover.length) {
+ return;
+ }
+
+ var popWidth = $popover.outerWidth();
+ var popHeight = $popover.outerHeight();
+ var $popCaret = $popover.find('.am-popover-caret');
+ var popCaretSize = ($popCaret.outerWidth() / 2) || 8;
+ // 取不到 $popCaret.outerHeight() 的值，所以直接加 8
+ var popTotalHeight = popHeight + 8; // $popCaret.outerHeight();
+
+ var triggerWidth = $element.outerWidth();
+ var triggerHeight = $element.outerHeight();
+ var triggerOffset = $element.offset();
+ var triggerRect = $element[0].getBoundingClientRect();
+
+ var winHeight = $w.height();
+ var winWidth = $w.width();
+ var popTop = 0;
+ var popLeft = 0;
+ var diff = 0;
+ var spacing = 2;
+ var popPosition = 'top';
+
+ $popover.css({left: '', top: ''}).removeClass('am-popover-left ' +
+ 'am-popover-right am-popover-top am-popover-bottom');
+
+ // $popCaret.css({left: '', top: ''});
+
+ if (popTotalHeight - spacing < triggerRect.top + spacing) {
+ // Popover on the top of trigger
+ popTop = triggerOffset.top - popTotalHeight - spacing;
+ } else if (popTotalHeight <
+ winHeight - triggerRect.top - triggerRect.height) {
+ // On bottom
+ popPosition = 'bottom';
+ popTop = triggerOffset.top + triggerHeight + popCaretSize + spacing;
+ } else { // On middle
+ popPosition = 'middle';
+ popTop = triggerHeight / 2 + triggerOffset.top - popHeight / 2;
+ }
+
+ // Horizontal Position
+ if (popPosition === 'top' || popPosition === 'bottom') {
+ popLeft = triggerWidth / 2 + triggerOffset.left - popWidth / 2;
+
+ diff = popLeft;
+
+ if (popLeft < 5) {
+ popLeft = 5;
+ }
+
+ if (popLeft + popWidth > winWidth) {
+ popLeft = (winWidth - popWidth - 20);
+ // console.log('left %d, win %d, popw %d', popLeft, winWidth, popWidth);
+ }
+
+ if (popPosition === 'top') {
+ // This is the Popover position, NOT caret position
+ // Popover on the Top of trigger, caret on the bottom of Popover
+ $popover.addClass('am-popover-top');
+ }
+
+ if (popPosition === 'bottom') {
+ $popover.addClass('am-popover-bottom');
+ }
+
+ diff = diff - popLeft;
+ // $popCaret.css({left: (popWidth / 2 - popCaretSize + diff) + 'px'});
+
+ } else if (popPosition === 'middle') {
+ popLeft = triggerOffset.left - popWidth - popCaretSize;
+ $popover.addClass('am-popover-left');
+ if (popLeft < 5) {
+ popLeft = triggerOffset.left + triggerWidth + popCaretSize;
+ $popover.removeClass('am-popover-left').addClass('am-popover-right');
+ }
+
+ if (popLeft + popWidth > winWidth) {
+ popLeft = winWidth - popWidth - 5;
+ $popover.removeClass('am-popover-left').addClass('am-popover-right');
+ }
+ // $popCaret.css({top: (popHeight / 2 - popCaretSize / 2) + 'px'});
+ }
+
+ // Apply position style
+ $popover.css({top: popTop + 'px', left: popLeft + 'px'});
+ };
+
+ Popover.prototype.toggle = function() {
+ return this[this.active ? 'close' : 'open']();
+ };
+
+ Popover.prototype.open = function() {
+ var $popover = this.$popover;
+
+ this.$element.trigger('open.popover.amui');
+ this.sizePopover();
+ $popover.show().addClass('am-active');
+ this.active = true;
+ };
+
+ Popover.prototype.close = function() {
+ var $popover = this.$popover;
+
+ this.$element.trigger('close.popover.amui');
+
+ $popover
+ .removeClass('am-active')
+ .trigger('closed.popover.amui')
+ .hide();
+
+ this.active = false;
+ };
+
+ Popover.prototype.getPopover = function() {
+ var uid = UI.utils.generateGUID('am-popover');
+ var theme = [];
+
+ if (this.options.theme) {
+ $.each(this.options.theme.split(' '), function(i, item) {
+ theme.push('am-popover-' + $.trim(item));
+ });
+ }
+
+ return $(this.options.tpl).attr('id', uid).addClass(theme.join(' '));
+ };
+
+ Popover.prototype.setContent = function(content) {
+ content = content || this.options.content;
+ this.$popover && this.$popover.find('.am-popover-inner')
+ .empty().html(content);
+ };
+
+ Popover.prototype._bindEvents = function() {
+ var eventNS = 'popover.amui';
+ var triggers = this.options.trigger.split(' ');
+
+ for (var i = triggers.length; i--;) {
+ var trigger = triggers[i];
+
+ if (trigger === 'click') {
+ this.$element.on('click.' + eventNS, $.proxy(this.toggle, this));
+ } else { // hover or focus
+ var eventIn = trigger == 'hover' ? 'mouseenter' : 'focusin';
+ var eventOut = trigger == 'hover' ? 'mouseleave' : 'focusout';
+
+ this.$element.on(eventIn + '.' + eventNS, $.proxy(this.open, this));
+ this.$element.on(eventOut + '.' + eventNS, $.proxy(this.close, this));
+ }
+ }
+ };
+
+ Popover.prototype.destroy = function() {
+ this.$element.off('.popover.amui').removeData('amui.popover');
+ this.$popover.remove();
+ };
+
+ UI.plugin('popover', Popover);
+
+ // Init code
+ UI.ready(function(context) {
+ $('[data-am-popover]', context).popover();
+ });
+
+ module.exports = Popover;
+
+ // TODO: 允许用户定义位置
+
+
+/***/ },
+/* 19 */
+/***/ function(module, exports, __webpack_require__) {
+
+ 'use strict';
+
+ var UI = __webpack_require__(2);
+
+ var Progress = (function() {
+ /**
+ * NProgress (c) 2013, Rico Sta. Cruz
+ * @via http://ricostacruz.com/nprogress
+ */
+
+ var NProgress = {};
+
+ NProgress.version = '0.2.0';
+
+ var Settings = NProgress.settings = {
+ minimum: 0.08,
+ easing: 'ease',
+ positionUsing: '',
+ speed: 200,
+ trickle: true,
+ trickleRate: 0.02,
+ trickleSpeed: 800,
+ showSpinner: true,
+ parent: 'body',
+ barSelector: '[role="nprogress-bar"]',
+ spinnerSelector: '[role="nprogress-spinner"]',
+ template: '' +
+ '' +
+ '
'
+ };
+
+ /**
+ * Updates configuration.
+ *
+ * NProgress.configure({
+ * minimum: 0.1
+ * });
+ */
+ NProgress.configure = function(options) {
+ var key, value;
+ for (key in options) {
+ value = options[key];
+ if (value !== undefined && options.hasOwnProperty(key)) Settings[key] = value;
+ }
+
+ return this;
+ };
+
+ /**
+ * Last number.
+ */
+
+ NProgress.status = null;
+
+ /**
+ * Sets the progress bar status, where `n` is a number from `0.0` to `1.0`.
+ *
+ * NProgress.set(0.4);
+ * NProgress.set(1.0);
+ */
+
+ NProgress.set = function(n) {
+ var started = NProgress.isStarted();
+
+ n = clamp(n, Settings.minimum, 1);
+ NProgress.status = (n === 1 ? null : n);
+
+ var progress = NProgress.render(!started),
+ bar = progress.querySelector(Settings.barSelector),
+ speed = Settings.speed,
+ ease = Settings.easing;
+
+ progress.offsetWidth; /* Repaint */
+
+ queue(function(next) {
+ // Set positionUsing if it hasn't already been set
+ if (Settings.positionUsing === '') Settings.positionUsing = NProgress.getPositioningCSS();
+
+ // Add transition
+ css(bar, barPositionCSS(n, speed, ease));
+
+ if (n === 1) {
+ // Fade out
+ css(progress, {
+ transition: 'none',
+ opacity: 1
+ });
+ progress.offsetWidth; /* Repaint */
+
+ setTimeout(function() {
+ css(progress, {
+ transition: 'all ' + speed + 'ms linear',
+ opacity: 0
+ });
+ setTimeout(function() {
+ NProgress.remove();
+ next();
+ }, speed);
+ }, speed);
+ } else {
+ setTimeout(next, speed);
+ }
+ });
+
+ return this;
+ };
+
+ NProgress.isStarted = function() {
+ return typeof NProgress.status === 'number';
+ };
+
+ /**
+ * Shows the progress bar.
+ * This is the same as setting the status to 0%, except that it doesn't go backwards.
+ *
+ * NProgress.start();
+ *
+ */
+ NProgress.start = function() {
+ if (!NProgress.status) NProgress.set(0);
+
+ var work = function() {
+ setTimeout(function() {
+ if (!NProgress.status) return;
+ NProgress.trickle();
+ work();
+ }, Settings.trickleSpeed);
+ };
+
+ if (Settings.trickle) work();
+
+ return this;
+ };
+
+ /**
+ * Hides the progress bar.
+ * This is the *sort of* the same as setting the status to 100%, with the
+ * difference being `done()` makes some placebo effect of some realistic motion.
+ *
+ * NProgress.done();
+ *
+ * If `true` is passed, it will show the progress bar even if its hidden.
+ *
+ * NProgress.done(true);
+ */
+
+ NProgress.done = function(force) {
+ if (!force && !NProgress.status) return this;
+
+ return NProgress.inc(0.3 + 0.5 * Math.random()).set(1);
+ };
+
+ /**
+ * Increments by a random amount.
+ */
+
+ NProgress.inc = function(amount) {
+ var n = NProgress.status;
+
+ if (!n) {
+ return NProgress.start();
+ } else {
+ if (typeof amount !== 'number') {
+ amount = (1 - n) * clamp(Math.random() * n, 0.1, 0.95);
+ }
+
+ n = clamp(n + amount, 0, 0.994);
+ return NProgress.set(n);
+ }
+ };
+
+ NProgress.trickle = function() {
+ return NProgress.inc(Math.random() * Settings.trickleRate);
+ };
+
+ /**
+ * Waits for all supplied jQuery promises and
+ * increases the progress as the promises resolve.
+ *
+ * @param $promise jQUery Promise
+ */
+ (function() {
+ var initial = 0, current = 0;
+
+ NProgress.promise = function($promise) {
+ if (!$promise || $promise.state() === "resolved") {
+ return this;
+ }
+
+ if (current === 0) {
+ NProgress.start();
+ }
+
+ initial++;
+ current++;
+
+ $promise.always(function() {
+ current--;
+ if (current === 0) {
+ initial = 0;
+ NProgress.done();
+ } else {
+ NProgress.set((initial - current) / initial);
+ }
+ });
+
+ return this;
+ };
+
+ })();
+
+ /**
+ * (Internal) renders the progress bar markup based on the `template`
+ * setting.
+ */
+
+ NProgress.render = function(fromStart) {
+ if (NProgress.isRendered()) return document.getElementById('nprogress');
+
+ addClass(document.documentElement, 'nprogress-busy');
+
+ var progress = document.createElement('div');
+ progress.id = 'nprogress';
+ progress.innerHTML = Settings.template;
+
+ var bar = progress.querySelector(Settings.barSelector),
+ perc = fromStart ? '-100' : toBarPerc(NProgress.status || 0),
+ parent = document.querySelector(Settings.parent),
+ spinner;
+
+ css(bar, {
+ transition: 'all 0 linear',
+ transform: 'translate3d(' + perc + '%,0,0)'
+ });
+
+ if (!Settings.showSpinner) {
+ spinner = progress.querySelector(Settings.spinnerSelector);
+ spinner && removeElement(spinner);
+ }
+
+ if (parent != document.body) {
+ addClass(parent, 'nprogress-custom-parent');
+ }
+
+ parent.appendChild(progress);
+ return progress;
+ };
+
+ /**
+ * Removes the element. Opposite of render().
+ */
+
+ NProgress.remove = function() {
+ removeClass(document.documentElement, 'nprogress-busy');
+ removeClass(document.querySelector(Settings.parent), 'nprogress-custom-parent');
+ var progress = document.getElementById('nprogress');
+ progress && removeElement(progress);
+ };
+
+ /**
+ * Checks if the progress bar is rendered.
+ */
+
+ NProgress.isRendered = function() {
+ return !!document.getElementById('nprogress');
+ };
+
+ /**
+ * Determine which positioning CSS rule to use.
+ */
+
+ NProgress.getPositioningCSS = function() {
+ // Sniff on document.body.style
+ var bodyStyle = document.body.style;
+
+ // Sniff prefixes
+ var vendorPrefix = ('WebkitTransform' in bodyStyle) ? 'Webkit' :
+ ('MozTransform' in bodyStyle) ? 'Moz' :
+ ('msTransform' in bodyStyle) ? 'ms' :
+ ('OTransform' in bodyStyle) ? 'O' : '';
+
+ if (vendorPrefix + 'Perspective' in bodyStyle) {
+ // Modern browsers with 3D support, e.g. Webkit, IE10
+ return 'translate3d';
+ } else if (vendorPrefix + 'Transform' in bodyStyle) {
+ // Browsers without 3D support, e.g. IE9
+ return 'translate';
+ } else {
+ // Browsers without translate() support, e.g. IE7-8
+ return 'margin';
+ }
+ };
+
+ /**
+ * Helpers
+ */
+
+ function clamp(n, min, max) {
+ if (n < min) return min;
+ if (n > max) return max;
+ return n;
+ }
+
+ /**
+ * (Internal) converts a percentage (`0..1`) to a bar translateX
+ * percentage (`-100%..0%`).
+ */
+
+ function toBarPerc(n) {
+ return (-1 + n) * 100;
+ }
+
+
+ /**
+ * (Internal) returns the correct CSS for changing the bar's
+ * position given an n percentage, and speed and ease from Settings
+ */
+
+ function barPositionCSS(n, speed, ease) {
+ var barCSS;
+
+ if (Settings.positionUsing === 'translate3d') {
+ barCSS = { transform: 'translate3d('+toBarPerc(n)+'%,0,0)' };
+ } else if (Settings.positionUsing === 'translate') {
+ barCSS = { transform: 'translate('+toBarPerc(n)+'%,0)' };
+ } else {
+ barCSS = { 'margin-left': toBarPerc(n)+'%' };
+ }
+
+ barCSS.transition = 'all '+speed+'ms '+ease;
+
+ return barCSS;
+ }
+
+ /**
+ * (Internal) Queues a function to be executed.
+ */
+
+ var queue = (function() {
+ var pending = [];
+
+ function next() {
+ var fn = pending.shift();
+ if (fn) {
+ fn(next);
+ }
+ }
+
+ return function(fn) {
+ pending.push(fn);
+ if (pending.length == 1) next();
+ };
+ })();
+
+ /**
+ * (Internal) Applies css properties to an element, similar to the jQuery
+ * css method.
+ *
+ * While this helper does assist with vendor prefixed property names, it
+ * does not perform any manipulation of values prior to setting styles.
+ */
+
+ var css = (function() {
+ var cssPrefixes = [ 'Webkit', 'O', 'Moz', 'ms' ],
+ cssProps = {};
+
+ function camelCase(string) {
+ return string.replace(/^-ms-/, 'ms-').replace(/-([\da-z])/gi, function(match, letter) {
+ return letter.toUpperCase();
+ });
+ }
+
+ function getVendorProp(name) {
+ var style = document.body.style;
+ if (name in style) return name;
+
+ var i = cssPrefixes.length,
+ capName = name.charAt(0).toUpperCase() + name.slice(1),
+ vendorName;
+ while (i--) {
+ vendorName = cssPrefixes[i] + capName;
+ if (vendorName in style) return vendorName;
+ }
+
+ return name;
+ }
+
+ function getStyleProp(name) {
+ name = camelCase(name);
+ return cssProps[name] || (cssProps[name] = getVendorProp(name));
+ }
+
+ function applyCss(element, prop, value) {
+ prop = getStyleProp(prop);
+ element.style[prop] = value;
+ }
+
+ return function(element, properties) {
+ var args = arguments,
+ prop,
+ value;
+
+ if (args.length == 2) {
+ for (prop in properties) {
+ value = properties[prop];
+ if (value !== undefined && properties.hasOwnProperty(prop)) applyCss(element, prop, value);
+ }
+ } else {
+ applyCss(element, args[1], args[2]);
+ }
+ }
+ })();
+
+ /**
+ * (Internal) Determines if an element or space separated list of class names contains a class name.
+ */
+
+ function hasClass(element, name) {
+ var list = typeof element == 'string' ? element : classList(element);
+ return list.indexOf(' ' + name + ' ') >= 0;
+ }
+
+ /**
+ * (Internal) Adds a class to an element.
+ */
+
+ function addClass(element, name) {
+ var oldList = classList(element),
+ newList = oldList + name;
+
+ if (hasClass(oldList, name)) return;
+
+ // Trim the opening space.
+ element.className = newList.substring(1);
+ }
+
+ /**
+ * (Internal) Removes a class from an element.
+ */
+
+ function removeClass(element, name) {
+ var oldList = classList(element),
+ newList;
+
+ if (!hasClass(element, name)) return;
+
+ // Replace the class name.
+ newList = oldList.replace(' ' + name + ' ', ' ');
+
+ // Trim the opening and closing spaces.
+ element.className = newList.substring(1, newList.length - 1);
+ }
+
+ /**
+ * (Internal) Gets a space separated list of the class names on the element.
+ * The list is wrapped with a single space on each end to facilitate finding
+ * matches within the list.
+ */
+
+ function classList(element) {
+ return (' ' + (element.className || '') + ' ').replace(/\s+/gi, ' ');
+ }
+
+ /**
+ * (Internal) Removes an element from the DOM.
+ */
+
+ function removeElement(element) {
+ element && element.parentNode && element.parentNode.removeChild(element);
+ }
+
+ return NProgress;
+ })();
+
+ module.exports = UI.progress = Progress;
+
+
+/***/ },
+/* 20 */
+/***/ function(module, exports, __webpack_require__) {
+
+ 'use strict';
+
+ var $ = __webpack_require__(1);
+ var UI = __webpack_require__(2);
+ var PinchZoom = __webpack_require__(17);
+ var Hammer = __webpack_require__(3);
+ var animation = UI.support.animation;
+ var transition = UI.support.transition;
+
+ /**
+ * PureView
+ * @desc Image browser for Mobile
+ * @param element
+ * @param options
+ * @constructor
+ */
+
+ var PureView = function(element, options) {
+ this.$element = $(element);
+ this.$body = $(document.body);
+ this.options = $.extend({}, PureView.DEFAULTS, options);
+ this.$pureview = $(this.options.tpl).attr('id',
+ UI.utils.generateGUID('am-pureview'));
+
+ this.$slides = null;
+ this.transitioning = null;
+ this.scrollbarWidth = 0;
+
+ this.init();
+ };
+
+ PureView.DEFAULTS = {
+ tpl: '',
+
+ className: {
+ prevSlide: 'am-pureview-slide-prev',
+ nextSlide: 'am-pureview-slide-next',
+ onlyOne: 'am-pureview-only',
+ active: 'am-active',
+ barActive: 'am-pureview-bar-active',
+ activeBody: 'am-pureview-active'
+ },
+
+ selector: {
+ slider: '.am-pureview-slider',
+ close: '[data-am-close="pureview"]',
+ total: '.am-pureview-total',
+ current: '.am-pureview-current',
+ title: '.am-pureview-title',
+ actions: '.am-pureview-actions',
+ bar: '.am-pureview-bar',
+ pinchZoom: '.am-pinch-zoom',
+ nav: '.am-pureview-nav'
+ },
+
+ shareBtn: false,
+
+ // press to toggle Toolbar
+ toggleToolbar: true,
+
+ // 从何处获取图片，img 可以使用 data-rel 指定大图
+ target: 'img',
+
+ // 微信 Webview 中调用微信的图片浏览器
+ // 实现图片保存、分享好友、收藏图片等功能
+ weChatImagePreview: true
+ };
+
+ PureView.prototype.init = function() {
+ var _this = this;
+ var options = this.options;
+ var $element = this.$element;
+ var $pureview = this.$pureview;
+
+ this.refreshSlides();
+
+ $('body').append($pureview);
+
+ this.$title = $pureview.find(options.selector.title);
+ this.$current = $pureview.find(options.selector.current);
+ this.$bar = $pureview.find(options.selector.bar);
+ this.$actions = $pureview.find(options.selector.actions);
+
+ if (options.shareBtn) {
+ this.$actions.append('');
+ }
+
+ this.$element.on('click.pureview.amui', options.target, function(e) {
+ e.preventDefault();
+ var clicked = _this.$images.index(this);
+
+ // Invoke WeChat ImagePreview in WeChat
+ // TODO: detect WeChat before init
+ if (options.weChatImagePreview && window.WeixinJSBridge) {
+ window.WeixinJSBridge.invoke('imagePreview', {
+ current: _this.imgUrls[clicked],
+ urls: _this.imgUrls
+ });
+ } else {
+ _this.open(clicked);
+ }
+ });
+
+ $pureview.find('.am-pureview-direction').
+ on('click.direction.pureview.amui', 'li', function(e) {
+ e.preventDefault();
+
+ if ($(this).is('.am-pureview-prev')) {
+ _this.prevSlide();
+ } else {
+ _this.nextSlide();
+ }
+ });
+
+ // Nav Contorl
+ $pureview.find(options.selector.nav).on('click.nav.pureview.amui', 'li',
+ function() {
+ var index = _this.$navItems.index($(this));
+ _this.activate(_this.$slides.eq(index));
+ });
+
+ // Close Icon
+ $pureview.find(options.selector.close).
+ on('click.close.pureview.amui', function(e) {
+ e.preventDefault();
+ _this.close();
+ });
+
+ this.$slider.hammer().on('swipeleft.pureview.amui', function(e) {
+ e.preventDefault();
+ _this.nextSlide();
+ }).on('swiperight.pureview.amui', function(e) {
+ e.preventDefault();
+ _this.prevSlide();
+ }).on('press.pureview.amui', function(e) {
+ e.preventDefault();
+ options.toggleToolbar && _this.toggleToolBar();
+ });
+
+ this.$slider.data('hammer').get('swipe').set({
+ direction: Hammer.DIRECTION_HORIZONTAL,
+ velocity: 0.35
+ });
+
+ // Observe DOM
+ $element.DOMObserve({
+ childList: true,
+ subtree: true
+ }, function(mutations, observer) {
+ // _this.refreshSlides();
+ // console.log('mutations[0].type);
+ });
+
+ // NOTE:
+ // trigger this event manually if MutationObserver not supported
+ // when new images appended, or call refreshSlides()
+ // if (!UI.support.mutationobserver) $element.trigger('changed.dom.amui')
+ $element.on('changed.dom.amui', function(e) {
+ e.stopPropagation();
+ _this.refreshSlides();
+ });
+
+ $(document).on('keydown.pureview.amui', $.proxy(function(e) {
+ var keyCode = e.keyCode;
+ if (keyCode == 37) {
+ this.prevSlide();
+ } else if (keyCode == 39) {
+ this.nextSlide();
+ } else if (keyCode == 27) {
+ this.close();
+ }
+ }, this));
+ };
+
+ PureView.prototype.refreshSlides = function() {
+ // update images collections
+ this.$images = this.$element.find(this.options.target);
+ var _this = this;
+ var options = this.options;
+ var $pureview = this.$pureview;
+ var $slides = $([]);
+ var $navItems = $([]);
+ var $images = this.$images;
+ var total = $images.length;
+ this.$slider = $pureview.find(options.selector.slider);
+ this.$nav = $pureview.find(options.selector.nav);
+ var viewedFlag = 'data-am-pureviewed';
+ // for WeChat Image Preview
+ this.imgUrls = this.imgUrls || [];
+
+ if (!total) {
+ return;
+ }
+
+ if (total === 1) {
+ $pureview.addClass(options.className.onlyOne);
+ }
+
+ $images.not('[' + viewedFlag + ']').each(function(i, item) {
+ var src;
+ var title;
+
+ // get image URI from link's href attribute
+ if (item.nodeName === 'A') {
+ src = item.href; // to absolute path
+ title = item.title || '';
+ } else {
+ // NOTE: `data-rel` should be a full URL, otherwise,
+ // WeChat images preview will not work
+ src = $(item).data('rel') || item.src; // ' +
+ ' ' +
+ '
',
+ listTpl: '<% for (var i = 0; i < options.length; i++) { %>' +
+ ' <% var option = options[i] %>' +
+ ' <% if (option.header) { %>' +
+ ' ' +
+ '
' +
+ '' + + '
' + + ' <% if (searchBox) { %>' + + '' +
+ ' ' +
+ '
' +
+ ' <% } %>' +
+ ' - ' +
+ ' <% for (var i = 0; i < options.length; i++) { %>' +
+ ' <% var option = options[i] %>' +
+ ' <% if (option.header) { %>' +
+ '
- ' + + ' <%= option.text %> ' + + ' <% } else { %>' + + '
- ' + + ' <%= option.text %>' + + ' ' + + ' <% } %>' + + ' <% } %>' + + '
"+u.time[t]+"
- "];lay.each(new Array(e),function(e){n.push("
'+(e&&2!=a.type?"":s)+"'+(n=["layui-icon-tips","layui-icon-success","layui-icon-error","layui-icon-question","layui-icon-lock","layui-icon-face-cry","layui-icon-face-smile"],o="layui-anim layui-anim-rotate layui-anim-loop",0==a.type&&-1!==a.icon?'':3==a.type?(i=["layui-icon-loading","layui-icon-loading-1"],2==a.icon?'':''):"")+((1!=a.type||!e)&&a.content||"")+'
'+(n=[],r&&(n.push(''),n.push('')),a.closeBtn&&n.push(''),n.join(""))+"
"+(a.btn?function(){var e="";"string"==typeof a.btn&&(a.btn=[a.btn]);for(var t,i=0,n=a.btn.length;i'+e+"
"}():"")+(a.resize?'':"")+""],s,h('')),this},t.pt.creat=function(){var e,t,i,n,a=this,o=a.config,s=a.index,r="object"==typeof(d=o.content),l=h("body"),c=function(e){var t;o.shift&&(o.anim=o.shift),u.anim[o.anim]&&(t="layer-anim "+u.anim[o.anim],e.addClass(t).one("webkitAnimationEnd mozAnimationEnd MSAnimationEnd oanimationend animationend",function(){h(this).removeClass(t)}))};if(o.id&&h("."+u[0]).find("#"+o.id)[0])e=h("#"+o.id).closest("."+u[0]),t=e.attr("times"),i=e.data("config"),n=h("#"+u.SHADE+t),"min"===(e.data("maxminStatus")||{})?v.restore(t):i.hideOnClose&&(n.show(),e.show(),c(e),setTimeout(function(){n.css({opacity:n.data(y)})},10));else{switch(o.removeFocus&&document.activeElement&&document.activeElement.blur(),"string"==typeof o.area&&(o.area="auto"===o.area?["",""]:[o.area,""]),6==v.ie&&(o.fixed=!1),o.type){case 0:o.btn="btn"in o?o.btn:f.btn[0],v.closeAll("dialog");break;case 2:var d=o.content=r?o.content:[o.content||"","auto"];o.content='';break;case 3:delete o.title,delete o.closeBtn,-1===o.icon&&o.icon,v.closeAll("loading");break;case 4:r||(o.content=[o.content,"body"]),o.follow=o.content[1],o.content=o.content[0]+'',delete o.title,o.tips="object"==typeof o.tips?o.tips:[o.tips,!0],o.tipsMore||v.closeAll("tips")}a.vessel(r,function(e,t,i){l.append(e[0]),r?2==o.type||4==o.type?h("body").append(e[1]):d.parents("."+u[0])[0]||(d.data("display",d.css("display")).show().addClass("layui-layer-wrap").wrap(e[1]),h("#"+u[0]+s).find("."+u[5]).before(t)):l.append(e[1]),h("#"+u.MOVE)[0]||l.append(f.moveElem=i),a.layero=h("#"+u[0]+s),a.shadeo=h("#"+u.SHADE+s),o.scrollbar||f.setScrollbar(s)}).auto(s),a.shadeo.css({"background-color":o.shade[1]||"#000",opacity:o.shade[0]||o.shade,transition:o.shade[2]||""}),a.shadeo.data(y,o.shade[0]||o.shade),2==o.type&&6==v.ie&&a.layero.find("iframe").attr("src",d[0]),4==o.type?a.tips():(a.offset(),parseInt(f.getStyle(document.getElementById(u.MOVE),"z-index"))||(a.layero.css("visibility","hidden"),v.ready(function(){a.offset(),a.layero.css("visibility","visible")}))),!o.fixed||f.events.resize[a.index]||(f.events.resize[a.index]=function(){a.resize()},g.on("resize",f.events.resize[a.index])),a.layero.data("config",o),o.time<=0||setTimeout(function(){v.close(a.index)},o.time),a.move().callback(),c(a.layero)}},t.pt.resize=function(){var e=this,t=e.config;e.offset(),(/^\d+%$/.test(t.area[0])||/^\d+%$/.test(t.area[1]))&&e.auto(e.index),4==t.type&&e.tips()},t.pt.auto=function(e){var t=this.config,i=h("#"+u[0]+e),n=((""===t.area[0]||"auto"===t.area[0])&&0- '+function(){var e=a.length,t=1,i="";if(0
'],1','','',"
"].join("")),n.toolbar&&t.push(['"].join("")),n.footer&&t.push(['"].join("")),t.push(""),t.join(""))+"",success:function(e,t,i){s.main=e.find(".layer-layer-photos-main"),s.footer=e.find(".layui-layer-photos-footer"),s.imgElem=s.main.children("img"),s.event(e,t,i),n.tab&&n.tab(o[r],e),"function"==typeof l&&l(e)},end:function(){s.end=!0,h(document).off("keyup",s.keyup)}},n))},u=function(){v.close(s.loadi),v.msg("\u5f53\u524d\u56fe\u7247\u5730\u5740\u5f02\u5e38\uff0c\u662f\u5426\u7ee7\u7eed\u67e5\u770b\u4e0b\u4e00\u5f20\uff1f",{time:3e4,btn:["\u4e0b\u4e00\u5f20","\u4e0d\u770b\u4e86"],yes:function(){1
'+t+("parent"===l?'':"group"===l&&d.isAllowSpread?'':"")+"
":''+t+"
"),"',"
"].join(""),n=d.content||(n=c(''),0p()?p():t)/p()*100/m;h(t,o),r.addClass(Y),d.find("."+L).show(),e.preventDefault()},n=function(e){r.removeClass(Y),c.tipsAlways||setTimeout(function(){d.find("."+L).hide()},e)},a=function(){n&&n(b.touchEventsSupported()?1e3:0),g.remove(),c.done&&c.done(u.value),b.touchEventsSupported()&&(t[0].removeEventListener("touchmove",i,!!b.passiveSupported&&{passive:!1}),t[0].removeEventListener("touchend",a),t[0].removeEventListener("touchcancel",a))},x("#LAY-slider-moving")[0]||x("body").append(g),g.on("mousemove",i),g.on("mouseup",a).on("mouseleave",a),b.touchEventsSupported()&&(t[0].addEventListener("touchmove",i,!!b.passiveSupported&&{passive:!1}),t[0].addEventListener("touchend",a),t[0].addEventListener("touchcancel",a))})}),d.on("click",function(e){var t=x("."+M),i=x(this);!t.is(event.target)&&0===t.has(event.target).length&&t.length&&(i=(t=(t=(t="vertical"===c.type?p()-e.clientY+i.offset().top-x(window).scrollTop():e.clientX-i.offset().left-x(window).scrollLeft())<0?0:t)>p()?p():t)/p()*100/m,t=c.range?"vertical"===c.type?Math.abs(t-parseInt(x(v[0]).css("bottom")))>Math.abs(t-parseInt(x(v[1]).css("bottom")))?1:0:Math.abs(t-v[0].offsetLeft)>Math.abs(t-v[1].offsetLeft)?1:0:0,h(i,t,"done"),e.preventDefault())}),o.children(".layui-slider-input-btn").children("i").each(function(t){x(this).on("click",function(){r=o.children("."+E).children("input").val();var e=((r=1==t?r-c.stepc.max?c.max:Number(r)+c.step)-c.min)/(c.max-c.min)*100/m;h(e,0,"done")})});var n=function(){var e=this.value,e=(e=(e=(e=isNaN(e)?0:e)c.max?c.max:e,((this.value=e)-c.min)/(c.max-c.min)*100/m);h(e,0,"done")};o.children("."+E).children("input").on("keydown",function(e){13===e.keyCode&&(e.preventDefault(),n.call(this))}).on("change",n)},t.prototype.events=function(){this.config},m.render=function(e){e=new t(e);return function(){var i=this,n=i.config;return{setValue:function(e,t){return e=(e=e>n.max?n.max:e)',"",'','',"","","
"].join("")),t=i.elem=x(i.elem);i.size&&o.addClass("layui-colorpicker-"+i.size),t.addClass("layui-inline").html(e.elemColorBox=o),i.id="id"in i?i.id:t.attr("id")||e.index,e.color=e.elemColorBox.find("."+T)[0].style.background,e.events()},s.prototype.renderPicker=function(){var o,e=this,i=e.config,t=e.elemColorBox[0],n=e.elemPicker=x(['','",'',"
"].join("")));i.after(o),function(i){var a=N(this),n="layui-anim-scaleSpring";a.off(u).on(u,function(){var e=a.attr("lay-filter");a[0].disabled||(a[0].checked=!0,layui.event.call(a[0],T,"radio("+e+")",{elem:a[0],value:a[0].value,othis:i}))}),i.on("click",function(){a.closest("label").length||a.trigger("click")}),d.syncAppearanceOnPropChanged(this,"checked",function(){var e,t=this;t.checked?(i.addClass(s+"ed"),i.children(".layui-icon").addClass(n+" "+c[0]),e=a.parents(y).find("input[name="+t.name.replace(/(\.|#|\[|\])/g,"\\$1")+"]"),layui.each(e,function(){t!==this&&(this.checked=!1)})):(i.removeClass(s+"ed"),i.children(".layui-icon").removeClass(n+" "+c[0]).addClass(c[1]))})}.call(this,o)})}},t=function(){layui.each(n,function(e,t){t()})};return"object"===layui.type(e)?N(e).is(y)?(a=N(e),t()):e.each(function(e,t){var i=N(t);i.closest(y).length&&("SELECT"===t.tagName?n.select(i):"INPUT"===t.tagName&&("checkbox"===(t=t.type)||"radio"===t?n[t](i):n.input(i)))}):e?n[e]?n[e]():l.error('\u4e0d\u652f\u6301\u7684 "'+e+'" \u8868\u5355\u6e32\u67d3'):t(),d},t.prototype.syncAppearanceOnPropChanged=v?function(e,t,i){var a=Object.getOwnPropertyDescriptor(HTMLInputElement.prototype,t);Object.defineProperty(e,t,lay.extend({},a,{get:function(){return"string"==typeof this.getAttribute("lay-form-sync-"+t)},set:function(e){m.call(this,"lay-form-sync-"+t,e),i.call(this)}}))}:function(e,t,i){var a=Object.getOwnPropertyDescriptor(HTMLInputElement.prototype,t);Object.defineProperty(e,t,lay.extend({},a,{get:function(){return a.get.call(this)},set:function(e){a.set.call(this,e),i.call(this)}}))},t.prototype.validate=function(e){var u,d=this.config.verify,p="layui-form-danger";return!(e=N(e))[0]||(e.attr("lay-verify")!==undefined||!1!==this.validate(e.find("*[lay-verify]")))&&(layui.each(e,function(e,r){var o=N(this),t=(o.attr("lay-verify")||"").split("|"),s=o.attr("lay-vertype"),c="string"==typeof(c=o.val())?N.trim(c):c;if(o.removeClass(p),layui.each(t,function(e,t){var i="",a=d[t];if(a){var n="function"==typeof a?i=a(c,r):!a[0].test(c),l="select"===r.tagName.toLowerCase()||/^(checkbox|radio)$/.test(r.type),i=i||a[1];if("required"===t&&(i=o.attr("lay-reqtext")||i),n)return"tips"===s?h.tips(i,!o.closest("[lay-ignore]").length&&l?o.next():o,{tips:1}):"alert"===s?h.alert(i,{title:"\u63d0\u793a",shadeClose:!0}):/\b(string|number)\b/.test(typeof i)&&h.msg(i,{icon:5,shift:6}),setTimeout(function(){(l?o.next().find("input"):r).focus()},7),o.addClass(p),u=!0}}),u)return u}),!u)},t.prototype.submit=function(e,t){var i={},a=N(this),e="string"==typeof e?e:a.attr("lay-filter"),n=this.getFormElem?this.getFormElem(e):a.parents(y).eq(0),l=n.find("*[lay-verify]");return!!r.validate(l)&&(i=r.getValue(null,n),l={elem:this.getFormElem?window.event&&window.event.target:this,form:(this.getFormElem?n:a.parents("form"))[0],field:i},"function"==typeof t&&t(l),layui.event.call(this,T,"submit("+e+")",l))});function m(e,t){var i=!!t,t=2===arguments.length&&!t;return null!==this.getAttribute(e)?i||(this.removeAttribute(e),!1):!t&&(this.setAttribute(e,""),!0)}var g=["-",".","e","E","+"];var r=new t,t=N(document),S=N(window);N(function(){r.render()}),t.on("reset",y,function(){var e=N(this).attr("lay-filter");setTimeout(function(){r.render(null,e)},50)}),t.on("submit",y,i).on("click","*[lay-submit]",i),e(T,r)});layui.define(["lay","laytpl","laypage","form","util"],function(s){"use strict";var f=layui.$,r=layui.lay,m=layui.laytpl,p=layui.laypage,g=layui.layer,i=layui.form,v=layui.util,b=layui.hint(),x=layui.device(),k={config:{checkName:"LAY_CHECKED",indexName:"LAY_INDEX",initIndexName:"LAY_INDEX_INIT",numbersName:"LAY_NUM",disabledName:"LAY_DISABLED"},cache:{},index:layui.table?layui.table.index+1e4:0,set:function(e){return this.config=f.extend({},this.config,e),this},on:function(e,t){return layui.onevent.call(this,R,e,t)}},w=function(){var a=this,e=a.config,i=e.id||e.index;return{config:e,reload:function(e,t){a.reload.call(a,e,t)},reloadData:function(e,t){k.reloadData(i,e,t)},setColsWidth:function(){a.setColsWidth.call(a)},resize:function(){a.resize.call(a)}}},C=function(e){var t=w.that[e];return t||b.error(e?"The table instance with ID '"+e+"' not found":"ID argument required"),t||null},l=function(e){var t=w.config[e];return t||b.error(e?"The table instance with ID '"+e+"' not found":"ID argument required"),t||null},T=function(e){var t=this.config||{},a=(e=e||{}).item3,i=e.content;"numbers"===a.type&&(i=e.tplData[k.config.numbersName]);("escape"in a?a:t).escape&&(i=v.escape(i));t=e.text&&a.exportTemplet||a.templet||a.toolbar;return t&&(i="function"==typeof t?t.call(a,e.tplData,e.obj):m(function(e){try{return r(e).html()}catch(t){return e}}(t)||String(i)).render(f.extend({LAY_COL:a},e.tplData))),e.text?f("','
",'','','','',"
",'','',"
","','
",i.predefine?(o=['','',"
","'],layui.each(i.colors,function(e,i){o.push(['
"),o.join("")):"",'','',"
"].join(""))}),o.push("','>16,g:(65280&n)>>8,b:255&n},t=j(r),s[0].style.background=o="#"+H(t),c.elemColorBox.find("."+B).removeClass(w).addClass(C)),"change"===i?(c.select(t.h,t.s,t.b,i),a.change&&a.change(o)):(c.color=l,a.done&&a.done(l),c.removePicker())}};c.elemPicker.on("click","*[colorpicker-events]",function(){var e=x(this),i=e.attr("colorpicker-events");o[i]&&o[i].call(this,e)}),d.on("keyup",function(e){var i=x(this);o.confirm.call(this,i,13===e.keyCode?null:"change")})},s.prototype.events=function(){var e=this;e.config;e.elemColorBox.on("click",function(){e.renderPicker(),x(c)[0]&&(e.val(),e.side())})},a.on(i,function(e){var i,o,t;r.thisId&&(i=n.getThis(r.thisId))&&(o=i.config,t=i.elemColorBox.find("."+T),x(e.target).hasClass(l)||x(e.target).parents("."+l)[0]||x(e.target).hasClass(c.replace(/\./g,""))||x(e.target).parents(c)[0]||i.elemPicker&&(i.color?(e=j(L(i.color)),i.select(e.h,e.s,e.b)):i.elemColorBox.find("."+B).removeClass(C).addClass(w),t[0].style.background=i.color||"","function"==typeof o.cancel&&o.cancel(i.color),i.removePicker()))}),W.on("resize",function(){if(r.thisId){var e=n.getThis(r.thisId);if(e)return!(!e.elemPicker||!x(c)[0])&&void e.position()}}),n.that={},n.getThis=function(e){var i=n.that[e];return i||o.error(e?t+" instance with ID '"+e+"' not found":"ID argument required"),i},r.render=function(e){e=new s(e);return n.call(e)},e(t,r)});layui.define("jquery",function(t){"use strict";var u=layui.$,d=(layui.hint(),layui.device()),r="element",f="layui-this",y="layui-show",c=".layui-tab-title",i=function(){this.config={}},h=(i.prototype.set=function(t){return u.extend(!0,this.config,t),this},i.prototype.on=function(t,i){return layui.onevent.call(this,r,t,i)},i.prototype.tabAdd=function(t,i){var a,e=u(".layui-tab[lay-filter="+t+"]"),l=e.children(c),n=l.children(".layui-tab-bar"),s=e.children(".layui-tab-content"),o=""+(i.title||"unnaming")+"";return n[0]?n.before(o):l.append(o),s.append('"].join("")),n=t.elem.next();(n.hasClass(r)||n.hasClass(l))&&n.remove(),R.ie&&R.ie<10&&t.elem.wrap(''),e.isFile()?(e.elemFile=t.elem,t.field=t.elem[0].name):t.elem.after(i),R.ie&&R.ie<10&&e.initIE()},D.prototype.initIE=function(){var i,e=this.config,t=F(''),n=F(['"].join(""));F("#"+E)[0]||F("body").append(t),e.elem.next().hasClass(l)||(this.elemFile.wrap(n),e.elem.next("."+l).append((i=[],layui.each(e.data,function(e,t){t="function"==typeof t?t():t,i.push('')}),i.join(""))))},D.prototype.msg=function(e){return t.msg(e,{icon:2,shift:6})},D.prototype.isFile=function(){var e=this.config.elem[0];if(e)return"input"===e.tagName.toLocaleLowerCase()&&"file"===e.type},D.prototype.preview=function(n){window.FileReader&&layui.each(this.chooseFiles,function(e,t){var i=new FileReader;i.readAsDataURL(t),i.onload=function(){n&&n(e,t,this.result)}})},D.prototype.upload=function(e,t){var i,n,a,o,r,u=this,f=u.config,s=f.text||{},l=u.elemFile[0],c=function(){return e||u.files||u.chooseFiles||l.files},d=function(){var a=0,o=0,r=c(),l=function(){f.multiple&&a+o===u.fileLength&&"function"==typeof f.allDone&&f.allDone({total:u.fileLength,successful:a,failed:o})},i=function(i){var n=new FormData,t=function(e){i.unified?layui.each(r,function(e,t){delete t[T]}):delete e[T]};if(layui.each(f.data,function(e,t){t="function"==typeof t?i.unified?t():t(i.index,i.file):t,n.append(e,t)}),i.unified)layui.each(r,function(e,t){t[T]||(t[T]=!0,n.append(f.field,t))});else{if(i.file[T])return;n.append(f.field,i.file),i.file[T]=!0}var e={url:f.url,type:"post",data:n,dataType:f.dataType||"json",contentType:!1,processData:!1,headers:f.headers||{},success:function(e){f.unified?a+=u.fileLength:a++,m(i.index,e),l(i.index),t(i.file)},error:function(e){f.unified?o+=u.fileLength:o++,u.msg(s.error||["Upload failed, please try again.","status: "+(e.status||"")+" - "+(e.statusText||"error")].join("
")),g(i.index,e.responseText,e),l(i.index),t(i.file)}};"function"==typeof f.progress&&(e.xhr=function(){var e=F.ajaxSettings.xhr();return e.upload.addEventListener("progress",function(e){var t;e.lengthComputable&&(t=Math.floor(e.loaded/e.total*100),f.progress(t,(f.item||f.elem)[0],e,i.index))}),e}),F.ajax(e)};f.unified?i({unified:!0,index:0}):layui.each(r,function(e,t){i({index:e,file:t})})},p=function(){var n=F("#"+E);u.elemFile.parent().submit(),clearInterval(D.timer),D.timer=setInterval(function(){var e,t=n.contents().find("body");try{e=t.text()}catch(i){u.msg(s["cross-domain"]),clearInterval(D.timer),g()}e&&(clearInterval(D.timer),t.html(""),m(0,e))},30)},h=function(e){if("json"===f.force&&"object"!=typeof e)try{return{status:"CONVERTED",data:JSON.parse(e)}}catch(t){return u.msg(s["data-format-error"]),{status:"FORMAT_ERROR",data:{}}}return{status:"DO_NOTHING",data:{}}},m=function(e,t){u.elemFile.next("."+L).remove(),l.value="";var i=h(t);switch(i.status){case"CONVERTED":t=i.data;break;case"FORMAT_ERROR":return}"function"==typeof f.done&&f.done(t,e||0,function(e){u.upload(e)})},g=function(e,t,i){f.auto&&(l.value="");var n=h(t);switch(n.status){case"CONVERTED":t=n.data;break;case"FORMAT_ERROR":return}"function"==typeof f.error&&f.error(e||0,function(e){u.upload(e)},t,i)},v=f.exts,y=(n=[],layui.each(e||u.chooseFiles,function(e,t){n.push(t.name)}),n),x={preview:function(e){u.preview(e)},upload:function(e,t){var i={};i[e]=t,u.upload(i)},pushFile:function(){return u.files=u.files||{},layui.each(u.chooseFiles,function(e,t){u.files[e]=t}),u.files},resetFile:function(e,t,i){t=new File([t],i);u.files=u.files||{},u.files[e]=t},getChooseFiles:function(){return u.chooseFiles}},b={file:"\u6587\u4ef6",images:"\u56fe\u7247",video:"\u89c6\u9891",audio:"\u97f3\u9891"}[f.accept]||"\u6587\u4ef6",y=0===y.length?l.value.match(/[^\/\\]+\..+/g)||[]:y;if(0!==y.length){switch(f.accept){case"file":layui.each(y,function(e,t){if(v&&!RegExp(".\\.("+v+")$","i").test(escape(t)))return i=!0});break;case"video":layui.each(y,function(e,t){if(!RegExp(".\\.("+(v||"avi|mp4|wma|rmvb|rm|flash|3gp|flv")+")$","i").test(escape(t)))return i=!0});break;case"audio":layui.each(y,function(e,t){if(!RegExp(".\\.("+(v||"mp3|wav|mid")+")$","i").test(escape(t)))return i=!0});break;default:layui.each(y,function(e,t){if(!RegExp(".\\.("+(v||"jpg|png|gif|bmp|jpeg|svg|webp")+")$","i").test(escape(t)))return i=!0})}if(i)return u.msg(s["check-error"]||"\u9009\u62e9\u7684"+b+"\u4e2d\u5305\u542b\u4e0d\u652f\u6301\u7684\u683c\u5f0f"),l.value="";if("choose"!==t&&!f.auto||(f.choose&&f.choose(x),"choose"!==t)){if(u.fileLength=(a=0,b=c(),layui.each(b,function(){a++}),a),f.number&&u.fileLength>f.number)return u.msg("function"==typeof s["limit-number"]?s["limit-number"](f,u.fileLength):"\u540c\u65f6\u6700\u591a\u53ea\u80fd\u4e0a\u4f20: "+f.number+" \u4e2a\u6587\u4ef6
\u60a8\u5f53\u524d\u5df2\u7ecf\u9009\u62e9\u4e86: "+u.fileLength+" \u4e2a\u6587\u4ef6");if(01024*f.size&&(t=1<=(t=f.size/1024)?t.toFixed(2)+"MB":f.size+"KB",l.value="",o=t)}),o)return u.msg("function"==typeof s["limit-size"]?s["limit-size"](f,o):"\u6587\u4ef6\u5927\u5c0f\u4e0d\u80fd\u8d85\u8fc7 "+o);r=function(){if(R.ie)return(9'+e+"")},l=function(i){var n=!0;return layui.each(a.files,function(e,t){if(!(n=!(t.name===i.name)))return!0}),n},u=function(e){var i=function(e){e.ext=e.name.substr(e.name.lastIndexOf(".")+1).toLowerCase(),e.sizes=w.util.parseSize(e.size)};return e instanceof FileList?layui.each(e,function(e,t){i(t)}):i(e),e},f=function(e){var i;return(e=e||[]).length?a.files?(i=[],layui.each(e,function(e,t){l(t)&&i.push(u(t))}),i):u(e):[]};n.elem.off("upload.start").on("upload.start",function(){var e=F(this);a.config.item=e,a.elemFile[0].click()}),R.ie&&R.ie<10||n.elem.off("upload.over").on("upload.over",function(){F(this).attr("lay-over","")}).off("upload.leave").on("upload.leave",function(){F(this).removeAttr("lay-over")}).off("upload.drop").on("upload.drop",function(e,t){var i=F(this),t=f(t.originalEvent.dataTransfer.files);i.removeAttr("lay-over"),o(t),n.auto?a.upload():r(t)}),a.elemFile.on("change",function(){var e=f(this.files);0!==e.length&&(o(e),n.auto?a.upload():r(e))}),n.bindAction.off("upload.action").on("upload.action",function(){a.upload()}),n.elem.data(s)||(n.elem.on("click",function(){a.isFile()||F(this).trigger("upload.start")}),n.drag&&n.elem.on("dragover",function(e){e.preventDefault(),F(this).trigger("upload.over")}).on("dragleave",function(e){F(this).trigger("upload.leave")}).on("drop",function(e){e.preventDefault(),F(this).trigger("upload.drop",e)}),n.bindAction.on("click",function(){F(this).trigger("upload.action")}),n.elem.data(s,n.id))},w.util={parseSize:function(e,t){var i,n;return t=t||2,null!=e&&e?(i="string"==typeof e?parseFloat(e):e,n=Math.floor(Math.log(i)/Math.log(1024)),(e=(e=i/Math.pow(1024,n))%1==0?e:parseFloat(e.toFixed(t)))+["Bytes","Kb","Mb","Gb","Tb","Pb","Eb","Zb","Yb"][n]):"0"},promiseLikeResolve:function(e){var t=F.Deferred();return e&&"function"==typeof e.then?e.then(t.resolve,t.reject):t.resolve(e),t.promise()}},o.that={},o.getThis=function(e){var t=o.that[e];return t||hint.error(e?i+" instance with ID '"+e+"' not found":"ID argument required"),t},w.render=function(e){e=new D(e);return o.call(e)},e(i,w)});layui.define(["lay","layer","util"],function(e){"use strict";var N=layui.$,h=layui.layer,p=layui.util,l=layui.hint(),T=(layui.device(),"form"),y=".layui-form",E="layui-this",O="layui-hide",A="layui-disabled",f="layui-input-number-invalid",v=lay.ie&&8===parseFloat(lay.ie)||void 0===Object.getOwnPropertyDescriptor(HTMLInputElement.prototype,"checked"),t=function(){this.config={verify:{required:function(e){if(!/[\S]+/.test(e)||e===undefined||null===e)return"\u5fc5\u586b\u9879\u4e0d\u80fd\u4e3a\u7a7a"},phone:function(e){if(e&&!/^1\d{10}$/.test(e))return"\u624b\u673a\u53f7\u683c\u5f0f\u4e0d\u6b63\u786e"},email:function(e){if(e&&!/^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9]{2,4})+$/.test(e))return"\u90ae\u7bb1\u683c\u5f0f\u4e0d\u6b63\u786e"},url:function(e){if(e&&!/^(#|(http(s?)):\/\/|\/\/)[^\s]+\.[^\s]+$/.test(e))return"\u94fe\u63a5\u683c\u5f0f\u4e0d\u6b63\u786e"},number:function(e){if(e&&isNaN(e))return"\u53ea\u80fd\u586b\u5199\u6570\u5b57"},date:function(e){if(e&&!/^(\d{4})[-\/](\d{1}|0\d{1}|1[0-2])([-\/](\d{1}|0\d{1}|[1-2][0-9]|3[0-1]))*$/.test(e))return"\u65e5\u671f\u683c\u5f0f\u4e0d\u6b63\u786e"},identity:function(e){if(e&&!/(^\d{15}$)|(^\d{17}(x|X|\d)$)/.test(e))return"\u8eab\u4efd\u8bc1\u53f7\u683c\u5f0f\u4e0d\u6b63\u786e"}},autocomplete:null}},i=(t.prototype.set=function(e){return N.extend(!0,this.config,e),this},t.prototype.verify=function(e){return N.extend(!0,this.config.verify,e),this},t.prototype.getFormElem=function(e){return N(y+(e?'[lay-filter="'+e+'"]':""))},t.prototype.on=function(e,t){return layui.onevent.call(this,T,e,t)},t.prototype.val=function(e,o){return this.getFormElem(e).each(function(e,t){var i,a,n,l,r=N(this);for(i in o)lay.hasOwn(o,i)&&(n=o[i],(l=r.find('[name="'+i+'"]'))[0])&&("checkbox"===(a=l[0].type)?l[0].checked=n:"radio"===a?l.each(function(){this.checked=this.value==n+""}):l.val(n))}),r.render(null,e),this.getValue(e)},t.prototype.getValue=function(e,t){t=t||this.getFormElem(e);var n={},l={},e=t.find("input,select,textarea");return layui.each(e,function(e,t){var i,a=N(this);t.name=(t.name||"").replace(/^\s*|\s*&/,""),t.name&&(/^.*\[\]$/.test(t.name)&&(i=t.name.match(/^(.*)\[\]$/g)[0],n[i]=0|n[i],i=t.name.replace(/^(.*)\[\]$/,"$1["+n[i]+++"]")),/^(checkbox|radio)$/.test(t.type)&&!t.checked||(l[i||t.name]="SELECT"===this.tagName&&"string"==typeof this.getAttribute("multiple")?a.val()||[]:this.value))}),l},t.prototype.render=function(e,t){var d=this,i=d.config,a=N(y+(t?'[lay-filter="'+t+'"]':"")),n={input:function(e){var e=e||a.find("input,textarea"),h=(i.autocomplete&&e.attr("autocomplete",i.autocomplete),function(e,t){var i=e.val(),a=Number(i),n=Number(e.attr("step"))||1,l=Number(e.attr("min")),r=Number(e.attr("max")),o=Number(e.attr("lay-precision")),s="click"!==t&&""===i,c="init"===t,u=isNaN(a),d="string"==typeof e.attr("lay-step-strictly");if(e.toggleClass(f,u),!u){if("click"===t){if("text"===e[0].type&&"string"==typeof e.attr("readonly"))return;a=!!N(this).index()?a-n:a+n}u=function(e){return((e.toString().match(/\.(\d+$)/)||[])[1]||"").length},o=0<=o?o:Math.max(u(n),u(i));s||(c||r<=(a=(a=d?Math.round(a/n)*n:a)<=l?l:a)&&(a=r),0===o?a=parseInt(a):0'),e=layui.isArray(i.value)?i.value:[i.value],e=N((a=[],layui.each(e,function(e,t){a.push('')}),a.join(""))),n=(t.append(e),i.split&&t.addClass("layui-input-split"),i.className&&t.addClass(i.className),r.next("."+u)),l=(n[0]&&n.remove(),r.parent().hasClass(s)||r.wrap(''),r.next("."+c));l[0]?((n=l.find("."+u))[0]&&n.remove(),l.prepend(t),r.css("padding-right",function(){return(r.closest(".layui-input-group")[0]?0:l.outerWidth())+t.outerWidth()})):(t.addClass(c),r.after(t)),"auto"===i.show&&d(t,r.val()),"function"==typeof i.init&&i.init.call(this,r,i),r.on("input propertychange",function(){var e=this.value;"auto"===i.show&&d(t,e)}),r.on("blur",function(){"function"==typeof i.blur&&i.blur.call(this,r,i)}),e.on("click",function(){var e=r.attr("lay-filter");N(this).hasClass(A)||("function"==typeof i.click&&i.click.call(this,r,i),layui.event.call(this,T,"input-affix("+e+")",{elem:r[0],affix:o,options:i}))})},p={eye:{value:"eye-invisible",click:function(e,t){var i="LAY_FORM_INPUT_AFFIX_SHOW",a=e.data(i);e.attr("type",a?"password":"text").data(i,!a),n({value:a?"eye-invisible":"eye"})}},clear:{value:"clear",click:function(e){e.val("").focus(),d(N(this).parent(),null)},show:"auto",disabled:e},number:{value:["up","down"],split:!0,className:"layui-input-number",disabled:r.is("[disabled]"),init:function(a){var e,n,l,t,i,r;"text"!==a.attr("type")&&"text"!==a[0].type||(l=n=!(e=".lay_input_number"),t="string"==typeof a.attr("readonly"),i="string"==typeof a.attr("lay-wheel"),r=a.next(".layui-input-number").children("i"),a.attr("lay-input-mirror",a.val()),a.off(e),a.on("keydown"+e,function(e){n=!1,8!==e.keyCode&&46!==e.keyCode||(n=!0),t||2!==r.length||38!==e.keyCode&&40!==e.keyCode||(e.preventDefault(),r.eq(38===e.keyCode?0:1).click())}),a.on("input"+e+" propertychange"+e,function(e){var t,i;l||"propertychange"===e.type&&"value"!==e.originalEvent.propertyName||(n||""===(e=this.value)||"00"!==e.slice(0,2)&&!e.match(/\s/g)&&!((t=e.match(/\./g))&&1=Math.abs(e.deltaY)?e.deltaX:e.deltaY):"mousewheel"===e.type?t=-e.originalEvent.wheelDelta:"DOMMouseScroll"===e.type&&(t=e.originalEvent.detail),r.eq(0S.height()&&t<=e&&l.addClass(C+"up"),h(),s&&g.off("mousedown.lay_select_ieph").on("mousedown.lay_select_ieph",function(){m[0].__ieph=!0,setTimeout(function(){m[0].__ieph=!1},60)}),n=lay.onClickOutside((a?l:g)[0],function(){p(),x&&m.val(x)},{ignore:v,detectIframe:!0,capture:!1})},p=function(e){v.parent().removeClass(C+"ed "+C+"up"),m.blur(),u&&g.children("."+_).remove(),"function"==typeof n&&(n(),n=null),a&&(l.detach(),N(window).off("resize.lay_select_resize")),e||y(m.val(),function(e){var t=f[0].selectedIndex;e&&(x=N(f[0].options[t]).prop("text"),0===t&&x===m.attr("placeholder")&&(x=""),m.val(x||""))})},h=function(){var e,t,i=g.children("dd."+E);i[0]&&(e=i.position().top,t=g.height(),i=i.height(),t").addClass(_).attr("lay-value",n).text(n),a=(i=g.children().eq(0)).hasClass("layui-select-tips"),i[a?"after":"before"](t)):e?g.find("."+w)[0]||g.append('
"].join(""));i.after(l),function(i,a){var n=N(this),e=n.attr("lay-skin")||"primary",t="switch"===e,e="primary"===e;n.off(u).on(u,function(e){var t=n.attr("lay-filter");n[0].disabled||(n[0].indeterminate&&(n[0].indeterminate=!1),n[0].checked=n[0].checked,layui.event.call(n[0],T,a[2]+"("+t+")",{elem:n[0],value:n[0].value,othis:i}))}),i.on("click",function(){n.closest("label").length||n.trigger("click")}),d.syncAppearanceOnPropChanged(this,"checked",function(){var e;t&&(e=(i.next("*[lay-checkbox]")[0]?i.next().html():n.attr("title")||"").split("|"),i.children("div").html(!this.checked&&e[1]||e[0])),i.toggleClass(a[1],this.checked)}),e&&d.syncAppearanceOnPropChanged(this,"indeterminate",function(){this.indeterminate?i.children(".layui-icon-ok").removeClass("layui-icon-ok").addClass(c.SUBTRA):i.children("."+c.SUBTRA).removeClass(c.SUBTRA).addClass("layui-icon-ok")})}.call(this,l,r)})},radio:function(e){var s="layui-form-radio",c=["layui-icon-radio","layui-icon-circle"],e=e||a.find("input[type=radio]"),u="click.lay_radio_click";e.each(function(e,t){var i=N(this),a=i.next("."+s),n=this.disabled,l=i.attr("lay-skin");if(i.closest("[lay-ignore]").length)return i.show();v&&m.call(t,"lay-form-sync-checked",t.checked),a[0]&&a.remove();var a=p.escape(t.title||""),r=[],o=(i.next("[lay-radio]")[0]&&(a=(o=i.next()).html()||"",1','',"
",'','','',"","
"].join(""));e.elemColorBox.find("."+T)[0];x(c)[0]&&x(c).data("index")==e.index?e.removePicker(s.thisElemInd):(e.removePicker(s.thisElemInd),x("body").append(n)),r.thisId=i.id,s.thisElemInd=e.index,s.thisColor=t.style.background,e.position(),e.pickerEvents()},s.prototype.removePicker=function(e){var i=this.config,e=x("#layui-colorpicker"+(e||this.index));return e[0]&&(e.remove(),delete r.thisId,"function"==typeof i.close)&&i.close(this.color),this},s.prototype.position=function(){var e=this,i=e.config;return P.position(e.bindElem||e.elemColorBox[0],e.elemPicker[0],{position:i.position,align:"center"}),e},s.prototype.val=function(){var e,i=this,o=(i.config,i.elemColorBox.find("."+T)),t=i.elemPicker.find("."+X),n=o[0].style.backgroundColor;n?(e=j(L(n)),o=o.attr("lay-type"),i.select(e.h,e.s,e.b),"torgb"===o?t.find("input").val(n):"rgba"===o?(o=L(n),3===(n.match(/[0-9]{1,3}/g)||[]).length?(t.find("input").val("rgba("+o.r+", "+o.g+", "+o.b+", 1)"),i.elemPicker.find("."+Y).css("left",280)):(t.find("input").val(n),n=280*n.slice(n.lastIndexOf(",")+1,n.length-1),i.elemPicker.find("."+Y).css("left",n)),i.elemPicker.find("."+D)[0].style.background="linear-gradient(to right, rgba("+o.r+", "+o.g+", "+o.b+", 0), rgb("+o.r+", "+o.g+", "+o.b+"))"):t.find("input").val("#"+H(e))):(i.select(0,100,100),t.find("input").val(""),i.elemPicker.find("."+D)[0].style.background="",i.elemPicker.find("."+Y).css("left",280))},s.prototype.side=function(){var r=this,l=r.config,c=r.elemColorBox.find("."+T),a=c.attr("lay-type"),s=r.elemPicker.find(".layui-colorpicker-side"),o=r.elemPicker.find("."+I),d=r.elemPicker.find("."+E),t=r.elemPicker.find("."+M),u=r.elemPicker.find("."+D),f=r.elemPicker.find("."+Y),p=o[0].offsetTop/180*360,h=100-t[0].offsetTop/180*100,g=t[0].offsetLeft/260*100,v=Math.round(f[0].offsetLeft/280*100)/100,m=r.elemColorBox.find("."+B),e=r.elemPicker.find(".layui-colorpicker-pre").children("div"),y=function(e,i,o,t){r.select(e,i,o);var n=F({h:e,s:i,b:o}),e=H({h:e,s:i,b:o}),i=r.elemPicker.find("."+X).find("input");m.addClass(C).removeClass(w),c[0].style.background="rgb("+n.r+", "+n.g+", "+n.b+")","torgb"===a?i.val("rgb("+n.r+", "+n.g+", "+n.b+")"):"rgba"===a?(f.css("left",280*t),i.val("rgba("+n.r+", "+n.g+", "+n.b+", "+t+")"),c[0].style.background="rgba("+n.r+", "+n.g+", "+n.b+", "+t+")",u[0].style.background="linear-gradient(to right, rgba("+n.r+", "+n.g+", "+n.b+", 0), rgb("+n.r+", "+n.g+", "+n.b+"))"):i.val("#"+e),l.change&&l.change(x.trim(r.elemPicker.find("."+X).find("input").val()))},i=x([''].join("")),b=function(e){x("#LAY-colorpicker-moving")[0]||x("body").append(i),i.on("mousemove",e),i.on("mouseup",function(){i.remove()}).on("mouseleave",function(){i.remove()})},n=!0,k=!0;o.on("mousedown",function(e,i){var t=this.offsetTop,n=(e.clientY===undefined?i:e).clientY;k&&layui.stope(e),b(function(e){var i=t+(e.clientY-n),o=s[0].offsetHeight,o=(i=o<(i=i<0?0:i)?o:i)/180*360;y(p=o,g,h,v),e.preventDefault()}),e.preventDefault()}),s.on("mousedown",function(e){var i=e.clientY-x(this).offset().top+W.scrollTop(),i=(i=(i=i<0?0:i)>this.offsetHeight?this.offsetHeight:i)/180*360;y(p=i,g,h,v),e.preventDefault(),n&&o.trigger("mousedown",e)}),t.on("mousedown",function(e,i){var r=this.offsetTop,l=this.offsetLeft,c=(e.clientY===undefined?i:e).clientY,a=(e.clientX===undefined?i:e).clientX;k&&layui.stope(e),b(function(e){var i=r+(e.clientY-c),o=l+(e.clientX-a),t=d[0].offsetHeight,n=d[0].offsetWidth,n=(o=n<(o=o<0?0:o)?n:o)/260*100,o=100-(i=t<(i=i<0?0:i)?t:i)/180*100;y(p,g=n,h=o,v),e.preventDefault()}),e.preventDefault()}),d.on("mousedown",function(e){var i=e.clientY-x(this).offset().top+W.scrollTop(),o=e.clientX-x(this).offset().left+W.scrollLeft(),o=((i=i<0?0:i)>this.offsetHeight&&(i=this.offsetHeight),(o=(o=o<0?0:o)>this.offsetWidth?this.offsetWidth:o)/260*100),i=100-i/180*100;y(p,g=o,h=i,v),layui.stope(e),e.preventDefault(),n&&t.trigger("mousedown",e)}),f.on("mousedown",function(e,i){var t=this.offsetLeft,n=(e.clientX===undefined?i:e).clientX;k&&layui.stope(e),b(function(e){var i=t+(e.clientX-n),o=u[0].offsetWidth,o=(o<(i=i<0?0:i)&&(i=o),Math.round(i/280*100)/100);y(p,g,h,v=o),e.preventDefault()}),e.preventDefault()}),u.on("mousedown",function(e){var i=e.clientX-x(this).offset().left,i=((i=i<0?0:i)>this.offsetWidth&&(i=this.offsetWidth),Math.round(i/280*100)/100);y(p,g,h,v=i),e.preventDefault(),n&&f.trigger("mousedown",e)}),e.each(function(){x(this).on("click",function(){x(this).parent(".layui-colorpicker-pre").addClass("selected").siblings().removeClass("selected");var e=this.style.backgroundColor,i=j(L(e)),o=e.slice(e.lastIndexOf(",")+1,e.length-1);p=i.h,g=i.s,h=i.b,3===(e.match(/[0-9]{1,3}/g)||[]).length&&(o=1),v=o,y(i.h,i.s,i.b,o)})}),P.touchEventsSupported()&&layui.each([{elem:s,eventType:"mousedown"},{elem:u,eventType:"mousedown"},{elem:d,eventType:"mousedown"}],function(e,t){P.touchSwipe(t.elem,{onTouchStart:function(){k=n=!1},onTouchMove:function(e){var i,o;e=e,i=t.eventType,e=e.touches[0],(o=document.createEvent("MouseEvent")).initMouseEvent(i,!0,!0,window,1,e.screenX,e.screenY,e.clientX,e.clientY,!1,!1,!1,!1,0,null),e.target.dispatchEvent(o)},onTouchEnd:function(){i.remove(),k=n=!0}})})},s.prototype.select=function(e,i,o,t){this.config;var n=H({h:e,s:100,b:100}),e=(H({h:e,s:i,b:o}),e/360*180),o=180-o/100*180,i=i/100*260,r=this.elemPicker.find("."+E)[0];this.elemPicker.find("."+I).css("top",e),r.style.background="#"+n,this.elemPicker.find("."+M).css({top:o/r.offsetHeight*100+"%",left:i/r.offsetWidth*100+"%"})},s.prototype.pickerEvents=function(){var c=this,a=c.config,s=c.elemColorBox.find("."+T),d=c.elemPicker.find("."+X+" input"),o={clear:function(e){s[0].style.background="",c.elemColorBox.find("."+B).removeClass(C).addClass(w),c.color="",a.done&&a.done(""),c.removePicker()},confirm:function(e,i){var o,t,n,r,l=x.trim(d.val());-1"+(i.content||"")+"
"),i.change&&this.tabChange(t,i.id),l.data("LAY_TAB_CHANGE",i.change),w.tabAuto(i.change?"change":null,e),this},i.prototype.tabDelete=function(t,i,a){t=u(".layui-tab[lay-filter="+t+"]").children(c).find('>li[lay-id="'+i+'"]');return w.tabDelete.call(t[0],{liElem:t,force:a}),this},i.prototype.tabChange=function(t,i,a){t=u(".layui-tab[lay-filter="+t+"]").children(c).find('>li[lay-id="'+i+'"]');return w.tabClick.call(t[0],{liElem:t,force:a}),this},i.prototype.tab=function(a){a=a||{},e.on("click",a.headerElem,function(t){var i=u(a.headerElem).index(u(this));w.tabClick.call(this,{index:i,options:a})})},i.prototype.progress=function(t,i){var a="layui-progress",t=u("."+a+"[lay-filter="+t+"]").find("."+a+"-bar"),a=t.find("."+a+"-text");return t.css("width",function(){return/^.+\/.+$/.test(i)?100*new Function("return "+i)()+"%":i}).attr("lay-percent",i),a.text(i),this},".layui-nav"),p="layui-nav-item",v="layui-nav-bar",b="layui-nav-tree",m="layui-nav-child",g="layui-nav-more",C="layui-anim layui-anim-upbit",w={tabClick:function(t){var i=(t=t||{}).options||{},a=t.liElem||u(this),e=i.headerElem?a.parent():a.parents(".layui-tab").eq(0),i=i.bodyElem?u(i.bodyElem):e.children(".layui-tab-content").children(".layui-tab-item"),l=a.find("a"),l="javascript:;"!==l.attr("href")&&"_blank"===l.attr("target"),n="string"==typeof a.attr("lay-unselect"),s=e.attr("lay-filter"),o=a.attr("lay-id"),c="index"in t?t.index:a.parent().children("li").index(a);if(!t.force){var t=a.siblings("."+f);if(!1===layui.event.call(this,r,"tabBeforeChange("+s+")",{elem:e,from:{index:a.parent().children("li").index(t),id:t.attr("lay-id")},to:{index:c,id:o}}))return}l||n||(a.addClass(f).siblings().removeClass(f),(o?t=(t=i.filter('[lay-id="'+o+'"]')).length?t:i.eq(c):i.eq(c)).addClass(y).siblings().removeClass(y)),layui.event.call(this,r,"tab("+s+")",{elem:e,index:c,id:o})},tabDelete:function(t){var i=(t=t||{}).liElem||u(this).parent(),a=i.parent().children("li").index(i),e=i.closest(".layui-tab"),l=e.children(".layui-tab-content").children(".layui-tab-item"),n=e.attr("lay-filter"),s=i.attr("lay-id");if(!t.force&&!1===layui.event.call(i[0],r,"tabBeforeDelete("+n+")",{elem:e,index:a,id:s}))return;i.hasClass(f)&&(i.next()[0]&&i.next().is("li")?w.tabClick.call(i.next()[0],{index:a+1}):i.prev()[0]&&i.prev().is("li")&&w.tabClick.call(i.prev()[0],null,a-1)),i.remove(),(s?t=(t=l.filter('[lay-id="'+s+'"]')).length?t:l.eq(a):l.eq(a)).remove(),setTimeout(function(){w.tabAuto(null,e)},50),layui.event.call(this,r,"tabDelete("+n+")",{elem:e,index:a,id:s})},tabAuto:function(l,t){var n="layui-tab-more",s="layui-tab-bar",o="layui-tab-close",c=this;(t||u(".layui-tab")).each(function(){var t=u(this),a=t.children(".layui-tab-title"),i=(t.children(".layui-tab-content").children(".layui-tab-item"),'lay-stope="tabmore"'),i=u(''),e=(c===window&&d.ie,t.attr("lay-allowclose"));e&&"false"!==e&&a.find("li").each(function(){var t,i=u(this);i.find("."+o)[0]||"false"===i.attr("lay-allowclose")||((t=u('')).on("click",function(t){w.tabDelete.call(this,{e:t})}),i.append(t))}),"string"!=typeof t.attr("lay-unauto")&&(a.prop("scrollWidth")>a.outerWidth()+1||a.find("li").length&&a.height()>(e=a.find("li").eq(0).height())+e/2?("change"===l&&a.data("LAY_TAB_CHANGE")&&a.addClass(n),a.find("."+s)[0]||(a.append(i),t.attr("overflow",""),i.on("click",function(t){var i=a.hasClass(n);a[i?"removeClass":"addClass"](n)}))):(a.find("."+s).remove(),t.removeAttr("overflow")))})},hideTabMore:function(t){var i=u(".layui-tab-title");!0!==t&&"tabmore"===u(t.target).attr("lay-stope")||(i.removeClass("layui-tab-more"),i.find(".layui-tab-bar").attr("title",""))},clickThis:function(){var t=u(this),i=t.closest(h),a=i.attr("lay-filter"),e=t.parent(),l=t.siblings("."+m),n="string"==typeof e.attr("lay-unselect");if("javascript:;"!==t.attr("href")&&"_blank"===t.attr("target")||n||l[0]||(i.find("."+f).removeClass(f),e.addClass(f)),i.hasClass(b)){var n=p+"ed",s=!e.hasClass(n),o=function(){u(this).css({display:""}),i.children("."+v).css({opacity:0})};if(l.is(":animated"))return;l.removeClass(C),l[0]&&(s?(l.slideDown(200,o),e.addClass(n)):(e.removeClass(n),l.show().slideUp(200,o)),"string"!=typeof i.attr("lay-accordion")&&"all"!==i.attr("lay-shrink")||((s=e.siblings("."+n)).removeClass(n),s.children("."+m).show().stop().slideUp(200,o)))}layui.event.call(this,r,"nav("+a+")",t)},collapse:function(){var t=u(this),i=t.closest(".layui-collapse"),a=i.attr("lay-filter"),e=".layui-colla-content",l=t.parent(".layui-colla-item"),n=t.siblings(e),s="none"===n.css("display"),i="string"==typeof i.attr("lay-accordion"),o=function(){u(this).css("display","")};n.is(":animated")||(s?(n.slideDown(200,o),l.addClass(y)):(l.removeClass(y),n.show().slideUp(200,o)),i&&((i=l.siblings("."+y)).removeClass(y),i.children(e).show().slideUp(200,o)),layui.event.call(this,r,"collapse("+a+")",{title:t,content:n,show:s}))}},a=(i.prototype.render=i.prototype.init=function(t,i){var a="string"==typeof i&&i?'[lay-filter="'+i+'"]':"",e={tab:function(t){t=t||u(".layui-tab"+a);w.tabAuto.call({},null,t)},nav:function(t){var s={},o={},c={},r="layui-nav-title";(t||u(h+a)).each(function(t){var i=u(this),a=u(''),e=i.find("."+p),l=i.find("."+v);l[0]&&l.remove(),i.append(a),(i.hasClass(b)?e.find("dd,>."+r):e).off("mouseenter.lay_nav").on("mouseenter.lay_nav",function(){!function(t,i,a){var e,l=u(this),n=l.find("."+m);i.hasClass(b)?n[0]||(e=l.children("."+r),t.css({top:l.offset().top-i.offset().top,height:(e[0]?e:l).outerHeight(),opacity:1})):(n.addClass(C),n.hasClass("layui-nav-child-c")&&n.css({left:-(n.outerWidth()-l.width())/2}),n[0]?t.css({left:t.position().left+t.width()/2,width:0,opacity:0}):t.css({left:l.position().left+parseFloat(l.css("marginLeft")),top:l.position().top+l.height()-t.height()}),s[a]=setTimeout(function(){t.css({width:n[0]?0:l.width(),opacity:n[0]?0:1})},d.ie&&d.ie<10?0:200),clearTimeout(c[a]),"block"===n.css("display")&&clearTimeout(o[a]),o[a]=setTimeout(function(){n.addClass(y),l.find("."+g).addClass(g+"d")},300))}.call(this,a,i,t)}).off("mouseleave.lay_nav").on("mouseleave.lay_nav",function(){i.hasClass(b)?a.css({height:0,opacity:0}):(clearTimeout(o[t]),o[t]=setTimeout(function(){i.find("."+m).removeClass(y),i.find("."+g).removeClass(g+"d")},300))}),i.off("mouseleave.lay_nav").on("mouseleave.lay_nav",function(){clearTimeout(s[t]),c[t]=setTimeout(function(){i.hasClass(b)||a.css({width:0,left:a.position().left+a.width()/2,opacity:0})},200)}),e.find("a").each(function(){var t=u(this);t.parent();t.siblings("."+m)[0]&&!t.children("."+g)[0]&&t.append(''),t.off("click",w.clickThis).on("click",w.clickThis)})})},breadcrumb:function(t){(t||u(".layui-breadcrumb"+a)).each(function(){var t=u(this),i="lay-separator",a=t.attr(i)||"/",e=t.find("a");e.next("span["+i+"]")[0]||(e.each(function(t){t!==e.length-1&&u(this).after(""+a+"")}),t.css("visibility","visible"))})},progress:function(t){var e="layui-progress";(t||u("."+e+a)).each(function(){var t=u(this),i=t.find(".layui-progress-bar"),a=i.attr("lay-percent");i.css("width",function(){return/^.+\/.+$/.test(a)?100*new Function("return "+a)()+"%":a}),t.attr("lay-showpercent")&&setTimeout(function(){i.html(''+a+"")},350)})},collapse:function(t){(t||u(".layui-collapse"+a)).each(function(){u(this).find(".layui-colla-item").each(function(){var t=u(this),i=t.find(".layui-colla-title"),a=t.find(".layui-colla-content"),e="none"===a.css("display");i.find(".layui-colla-icon").remove(),i.append(''),t[e?"removeClass":"addClass"](y),a.hasClass(y)&&a.removeClass(y),i.off("click",w.collapse).on("click",w.collapse)})})}};return t&&"object"==typeof i&&i instanceof u?e[t](i):e[t]?e[t]():layui.each(e,function(t,i){i()})},new i),e=u(document);u(function(){a.render()}),e.on("click",".layui-tab-title li",w.tabClick),u(window).on("resize",w.tabAuto),t(r,a)});layui.define(["lay","layer"],function(e){"use strict";var F=layui.$,a=layui.lay,t=layui.layer,R=layui.device(),i="upload",s="layui_"+i+"_index",w={config:{},index:layui[i]?layui[i].index+1e4:0,set:function(e){var t=this;return t.config=F.extend({},t.config,e),t},on:function(e,t){return layui.onevent.call(this,i,e,t)}},o=function(){var t=this,e=t.config.id;return{upload:function(e){t.upload.call(t,e)},reload:function(e){t.reload.call(t,e)},config:(o.that[e]=t).config}},r="layui-upload-file",l="layui-upload-form",E="layui-upload-iframe",L="layui-upload-choose",T="UPLOADING",D=function(e){var t=this;t.index=++w.index,t.config=F.extend({},t.config,w.config,e),t.render()};D.prototype.config={accept:"images",exts:"",auto:!0,bindAction:"",url:"",force:"",field:"file",acceptMime:"",method:"post",data:{},drag:!0,size:0,number:0,multiple:!1,text:{"cross-domain":"Cross-domain requests are not supported","data-format-error":"Please return JSON data format","check-error":"",error:"","limit-number":null,"limit-size":null}},D.prototype.reload=function(e){var t=this;t.config=F.extend({},t.config,e),t.render(!0)},D.prototype.render=function(e){var t=this,i=t.config,n=F(i.elem);return 1")),g(i.index,e.responseText,e),l(i.index),t(i.file)}};"function"==typeof f.progress&&(e.xhr=function(){var e=F.ajaxSettings.xhr();return e.upload.addEventListener("progress",function(e){var t;e.lengthComputable&&(t=Math.floor(e.loaded/e.total*100),f.progress(t,(f.item||f.elem)[0],e,i.index))}),e}),F.ajax(e)};f.unified?i({unified:!0,index:0}):layui.each(r,function(e,t){i({index:e,file:t})})},p=function(){var n=F("#"+E);u.elemFile.parent().submit(),clearInterval(D.timer),D.timer=setInterval(function(){var e,t=n.contents().find("body");try{e=t.text()}catch(i){u.msg(s["cross-domain"]),clearInterval(D.timer),g()}e&&(clearInterval(D.timer),t.html(""),m(0,e))},30)},h=function(e){if("json"===f.force&&"object"!=typeof e)try{return{status:"CONVERTED",data:JSON.parse(e)}}catch(t){return u.msg(s["data-format-error"]),{status:"FORMAT_ERROR",data:{}}}return{status:"DO_NOTHING",data:{}}},m=function(e,t){u.elemFile.next("."+L).remove(),l.value="";var i=h(t);switch(i.status){case"CONVERTED":t=i.data;break;case"FORMAT_ERROR":return}"function"==typeof f.done&&f.done(t,e||0,function(e){u.upload(e)})},g=function(e,t,i){f.auto&&(l.value="");var n=h(t);switch(n.status){case"CONVERTED":t=n.data;break;case"FORMAT_ERROR":return}"function"==typeof f.error&&f.error(e||0,function(e){u.upload(e)},t,i)},v=f.exts,y=(n=[],layui.each(e||u.chooseFiles,function(e,t){n.push(t.name)}),n),x={preview:function(e){u.preview(e)},upload:function(e,t){var i={};i[e]=t,u.upload(i)},pushFile:function(){return u.files=u.files||{},layui.each(u.chooseFiles,function(e,t){u.files[e]=t}),u.files},resetFile:function(e,t,i){t=new File([t],i);u.files=u.files||{},u.files[e]=t},getChooseFiles:function(){return u.chooseFiles}},b={file:"\u6587\u4ef6",images:"\u56fe\u7247",video:"\u89c6\u9891",audio:"\u97f3\u9891"}[f.accept]||"\u6587\u4ef6",y=0===y.length?l.value.match(/[^\/\\]+\..+/g)||[]:y;if(0!==y.length){switch(f.accept){case"file":layui.each(y,function(e,t){if(v&&!RegExp(".\\.("+v+")$","i").test(escape(t)))return i=!0});break;case"video":layui.each(y,function(e,t){if(!RegExp(".\\.("+(v||"avi|mp4|wma|rmvb|rm|flash|3gp|flv")+")$","i").test(escape(t)))return i=!0});break;case"audio":layui.each(y,function(e,t){if(!RegExp(".\\.("+(v||"mp3|wav|mid")+")$","i").test(escape(t)))return i=!0});break;default:layui.each(y,function(e,t){if(!RegExp(".\\.("+(v||"jpg|png|gif|bmp|jpeg|svg|webp")+")$","i").test(escape(t)))return i=!0})}if(i)return u.msg(s["check-error"]||"\u9009\u62e9\u7684"+b+"\u4e2d\u5305\u542b\u4e0d\u652f\u6301\u7684\u683c\u5f0f"),l.value="";if("choose"!==t&&!f.auto||(f.choose&&f.choose(x),"choose"!==t)){if(u.fileLength=(a=0,b=c(),layui.each(b,function(){a++}),a),f.number&&u.fileLength>f.number)return u.msg("function"==typeof s["limit-number"]?s["limit-number"](f,u.fileLength):"\u540c\u65f6\u6700\u591a\u53ea\u80fd\u4e0a\u4f20: "+f.number+" \u4e2a\u6587\u4ef6
\u60a8\u5f53\u524d\u5df2\u7ecf\u9009\u62e9\u4e86: "+u.fileLength+" \u4e2a\u6587\u4ef6");if(0
\u65e0\u5339\u914d\u9879
'):g.find("."+w).remove()},"keyup"),""===n&&(f.val(""),g.find("."+E).removeClass(E),(f[0].options[0]||{}).value||g.children("dd:eq(0)").addClass(E),g.find("."+w).remove(),u)&&g.children("."+_).remove(),void h()))},50)).on("blur",function(e){var t=f[0].selectedIndex;x=N(f[0].options[t]).prop("text"),0===t&&x===m.attr("placeholder")&&(x=""),setTimeout(function(){y(m.val(),function(e){x||m.val("")},"blur")},200)}),g.on("click","dd",function(){var e,t,i=N(this),a=i.attr("lay-value"),n=f.attr("lay-filter");return i.hasClass(A)||(u&&i.hasClass(_)&&(t=(e=N(""+a+"
",""+i+"
").text():i},R="table",N="lay-"+R+"-id",t=".layui-table",W="layui-hide",y="layui-hide-v",h="layui-none",_="layui-table-view",o=".layui-table-header",D=".layui-table-body",I=".layui-table-fixed-r",P=".layui-table-pageview",L=".layui-table-sort",A="layui-table-checked",E="layui-table-edit",M="layui-table-hover",u="laytable-cell-group",F="layui-table-col-special",S="layui-table-tool-panel",H="layui-table-expanded",O="layui-table-disabled-transition",j="LAY_TABLE_MOVE_DICT",e=function(e){return['| ',' ','{{# if(item2.type === "checkbox"){ }}','',"{{# } else { }}",'{{-item2.title||""}}',"{{# if(isSort){ }}",'',"{{# } }}","{{# } }}"," "," | ",e.fixed?"{{# }; }}":"","{{# }); }}","
|---|
','','',"
","{{# } }}",'',"{{# if(d.data.loading){ }}",'
","{{# if(d.data.totalRow){ }}",'','","
","{{# } }}","{{# var left, right; }}",'',e(),"
",'',a,"
","{{# if(left){ }}",'','
","{{# }; }}","{{# if(right){ }}",'',e({fixed:!0}),"
",'',a,"
","','
","{{# }; }}","',e({fixed:"right"}),'',"
",'',a,"
","','','
","
","{{# } }}",'','',"
"].join(""),d=f(window),z=f(document),n=function(e){this.index=++k.index,this.config=f.extend({},this.config,k.config,e),this.render()},c=(n.prototype.config={limit:10,loading:!0,escape:!0,cellMinWidth:60,cellMaxWidth:Number.MAX_VALUE,editTrigger:"click",defaultToolbar:["filter","exports","print"],defaultContextmenu:!0,autoSort:!0,text:{none:"\u65e0\u6570\u636e"},cols:[]},n.prototype.render=function(e){var t=this,a=t.config,i=(a.elem=f(a.elem),a.where=a.where||{},a.id="id"in a?a.id:a.elem.attr("id")||t.index);if(w.that[i]=t,(w.config[i]=a).request=f.extend({pageName:"page",limitName:"limit"},a.request),a.response=f.extend({statusName:"code",statusCode:0,msgName:"msg",dataName:"data",totalRowName:"totalRow",countName:"count"},a.response),null!==a.page&&"object"==typeof a.page&&(a.limit=a.page.limit||a.limit,a.limits=a.page.limits||a.limits,t.page=a.page.curr=a.page.curr||1,delete a.page.elem,delete a.page.jump),!a.elem[0])return t;if(a.elem.attr("lay-filter")||a.elem.attr("lay-filter",a.id),"reloadData"===e)return t.pullData(t.page,{type:"reloadData"});a.index=t.index,t.key=a.id||a.index,t.setInit(),a.height&&/^full-.+$/.test(a.height)?(t.fullHeightGap=a.height.split("-")[1],a.height=d.height()-(parseFloat(t.fullHeightGap)||0)):a.height&&/^#\w+\S*-.+$/.test(a.height)?(i=a.height.split("-"),t.parentHeightGap=i.pop(),t.parentDiv=i.join("-"),a.height=f(t.parentDiv).height()-(parseFloat(t.parentHeightGap)||0)):"function"==typeof a.height&&(t.customHeightFunc=a.height,a.height=t.customHeightFunc());var l,e=a.elem,i=e.next("."+_),n=t.elem=f("");n.addClass((l=[_,_+"-"+t.index,"layui-form","layui-border-box"],a.className&&l.push(a.className),l.join(" "))).attr(((l={"lay-filter":"LAY-TABLE-FORM-DF-"+t.index,style:(l=[],a.width&&l.push("width:"+a.width+"px;"),l.join(""))})[N]=a.id,l)).html(m(B,{open:"{{",close:"}}",tagStyle:"legacy"}).render({data:a,index:t.index})),t.renderStyle(),i[0]&&i.remove(),e.after(n),t.layTool=n.find(".layui-table-tool"),t.layBox=n.find(".layui-table-box"),t.layHeader=n.find(o),t.layMain=n.find(".layui-table-main"),t.layBody=n.find(D),t.layFixed=n.find(".layui-table-fixed"),t.layFixLeft=n.find(".layui-table-fixed-l"),t.layFixRight=n.find(I),t.layTotal=n.find(".layui-table-total"),t.layPage=n.find(".layui-table-page"),t.renderToolbar(),t.renderPagebar(),t.fullSize(),t.setColsWidth({isInit:!0}),t.pullData(t.page),t.events()},n.prototype.initOpts=function(e){this.config;e.checkbox&&(e.type="checkbox"),e.space&&(e.type="space"),e.type||(e.type="normal"),"normal"!==e.type&&(e.unresize=!0,e.width=e.width||{checkbox:50,radio:50,space:30,numbers:60}[e.type])},n.prototype.setInit=function(e){var n,a,d=this,r=d.config;if(r.clientWidth=r.width||(n=function(e){var t,a;e=e||r.elem.parent(),t=d.getContentWidth(e);try{a="none"===e.css("display")}catch(l){}var i=e.parent();return e[0]&&i&&i[0]&&(!t||a)?n(i):t})(),"width"===e)return r.clientWidth;r.height=r.maxHeight||r.height,r.css&&-1===r.css.indexOf(_)&&(a=r.css.split("}"),layui.each(a,function(e,t){t&&(a[e]="."+_+"-"+d.index+" "+t)}),r.css=a.join("}"));var c=function(a,e,i,l){var n,o;l?(l.key=[r.index,a,i].join("-"),l.colspan=l.colspan||0,l.rowspan=l.rowspan||0,d.initOpts(l),(n=a+(parseInt(l.rowspan)||1))','
','
'].join(""),a=o.layTool.find(".layui-table-tool-temp"),n=("default"===e.toolbar?a.html(t):"string"==typeof e.toolbar&&(t=f(e.toolbar).html()||"")&&a.html(m(t).render(e)),{filter:{title:"\u7b5b\u9009\u5217",layEvent:"LAYTABLE_COLS",icon:"layui-icon-cols",onClick:function(e){var a,n=e.config;(0,e.openPanel)({list:(a=[],o.eachCols(function(e,t){t.field&&"normal"==t.type&&a.push('
')),i}),o.layTool.find(".layui-table-tool-self").html(l.join("")))},n.prototype.renderPagebar=function(){var e,t=this.config,a=this.layPagebar=f('');t.pagebar&&((e=f(t.pagebar).html()||"")&&a.append(m(e).render(t)),this.layPage.append(a))},n.prototype.setParentCol=function(e,t){var a=this.config,i=this.layHeader.find('th[data-key="'+t+'"]'),l=parseInt(i.attr("colspan"))||0;i[0]&&(t=t.split("-"),t=a.cols[t[1]][t[2]],e?l--:l++,i.attr("colspan",l),i[l?"removeClass":"addClass"](W),t.colspan2=l,t.hide=l<1,a=i.data("parentkey"))&&this.setParentCol(e,a)},n.prototype.setColsPatch=function(){var a=this,e=a.config;layui.each(e.cols,function(e,t){layui.each(t,function(e,t){t.hide&&a.setParentCol(t.hide,t.parentKey)})})},n.prototype.setGroupWidth=function(i){var e,l=this;l.config.cols.length<=1||((e=l.layHeader.find((i?"th[data-key="+i.data("parentkey")+"]>":"")+"."+u)).css("width",0),layui.each(e.get().reverse(),function(){var e=f(this),t=e.parent().data("key"),a=0;l.layHeader.eq(0).find("th[data-parentkey="+t+"]").width(function(e,t){f(this).hasClass(W)||0
'+(e||"Error")+"
");a[0]&&(t.layNone.remove(),a.remove()),t.layFixed.addClass(W),t.layMain.find("tbody").html(""),t.layMain.append(t.layNone=e),t.layTotal.addClass(y),t.layPage.find(P).addClass(y),k.cache[t.key]=[],t.syncCheckAll(),t.renderForm(),t.setColsWidth(),t.loading(!1)},n.prototype.page=1,n.prototype.pullData=function(i,l){var e,t,n=this,o=n.config,a=(o.HAS_SET_COLS_PATCH||n.setColsPatch(),o.HAS_SET_COLS_PATCH=!0,o.request),d=o.response,r=function(){"object"==typeof o.initSort&&n.sort({field:o.initSort.field,type:o.initSort.type,reloadType:l.type})},c=function(e,t){n.setColsWidth(),n.loading(!1),"function"==typeof o.done&&o.done(e,i,e[d.countName],t)};l=l||{},"function"==typeof o.before&&o.before(o),n.startTime=(new Date).getTime(),l.renderData?((e={})[d.dataName]=k.cache[n.key],e[d.countName]=o.url?"object"===layui.type(o.page)?o.page.count:e[d.dataName].length:o.data.length,"object"==typeof o.totalRow&&(e[d.totalRowName]=f.extend({},n.totalRow)),n.renderData({res:e,curr:i,count:e[d.countName],type:l.type,sort:!0}),c(e,"renderData")):o.url?(t={},o.page&&(t[a.pageName]=i,t[a.limitName]=o.limit),a=f.extend(t,o.where),o.contentType&&0==o.contentType.indexOf("application/json")&&(a=JSON.stringify(a)),n.loading(!0),n._xhr&&4!==n._xhr.readyState&&(n._xhrAbort=!0,n._xhr.abort()),n._xhr=f.ajax({type:o.method||"get",url:o.url,contentType:o.contentType,data:a,dataType:o.dataType||"json",jsonpCallback:o.jsonpCallback,headers:o.headers||{},complete:"function"==typeof o.complete?o.complete:undefined,success:function(e){var t,a;(e="function"==typeof o.parseData?o.parseData(e)||e:e)[d.statusName]!=d.statusCode?n.errorView(e[d.msgName]||'\u8fd4\u56de\u7684\u6570\u636e\u4e0d\u7b26\u5408\u89c4\u8303\uff0c\u6b63\u786e\u7684\u6210\u529f\u72b6\u6001\u7801\u5e94\u4e3a\uff1a"'+d.statusName+'": '+d.statusCode):(t=e[d.countName],(a=Math.ceil(t/o.limit)||1)"+function(){var e,t=f.extend(!0,{LAY_COL:l},o),a=k.config.checkName,i=k.config.disabledName;switch(l.type){case"checkbox":return'';case"radio":return'';case"numbers":return c}return l.toolbar?m(f(l.toolbar).html()||"").render(t):T.call(s,{item3:l,content:n,tplData:t})}(),"
"].join(""),i.push(e),l.fixed&&"right"!==l.fixed&&d.push(e),"right"===l.fixed&&r.push(e))}),e=['data-index="'+e+'"'],o[k.config.checkName]&&e.push('class="'+A+'"'),e=e.join(" "),y.push(""+l+"
").text()}),['"+l,"
',d.html(),"
",''].join(""),d[0],{tips:[3,""],time:-1,anim:-1,maxWidth:x.ios||x.android?300:c.elem.width()/2,isOutAnim:!1,skin:"layui-table-tips",success:function(e,t){e.find(".layui-table-tips-c").on("click",function(){g.close(t)})}}):(c.elem.find("."+i).trigger("click"),c.cssRules(l,function(e){var t=e.style.width,a=n.expandedWidth||s.cellExpandedWidth;a',a[X]?o.flexIconOpen:o.flexIconClose,"
",o.showIcon?''+(l.normalizedIcon(a[c.icon])||o.icon||(a[u]?a[X]?o.iconOpen:o.iconClose:o.iconLeaf)||"")+"
":"",n].join("")).find(".layui-table-tree-flexIcon").on("click",function(e){layui.stope(e),K({trElem:i},null,null,null,!0)}))}),!t&&r.view.expandAllDefault&&l.isExpandAll===undefined)return j.expandAll(i,!0);(!1!==a&&y?(layui.each(y,function(e,t){e=d.find('tr[lay-data-index="'+e+'"]');e.find(".layui-table-tree-flexIcon").html(o.flexIconOpen),K({trElem:e.first()},!0)}),J("renderTreeTable2-"+i,function(){h.render(P(".layui-table-tree["+L+'="'+i+'"]'))},0)):J("renderTreeTable-"+i,function(){n.hasNumberCol&&v(l),h.render(P(".layui-table-tree["+L+'="'+i+'"]'))},0))()},function(a){var e=a.getOptions(),t=e.elem.next(),n=0,i=t.find(".layui-table-main tbody tr"),l=t.find(".layui-table-fixed-l tbody tr"),d=t.find(".layui-table-fixed-r tbody tr");layui.each(a.treeToFlat(B.cache[e.id]),function(e,t){t.LAY_HIDE||(a.getNodeDataByIndex(t[H]).LAY_NUM=++n,i.eq(e).find(".laytable-cell-numbers").html(n),l.eq(e).find(".laytable-cell-numbers").html(n),d.eq(e).find(".laytable-cell-numbers").html(n))})}),N=(a.prototype.render=function(e){var t=this;t.tableIns=B["reloadData"===e?"reloadData":"reload"](t.tableIns.config.id,P.extend(!0,{},t.config)),t.config=t.tableIns.config},a.prototype.reload=function(e,t,a){var n=this;e=e||{},delete n.haveInit,layui.each(e,function(e,t){"array"===layui.type(t)&&delete n.config[e]}),d(n.getOptions().id,e,a||!0),n.config=P.extend(t,{},n.config,e),n.render(a)},j.reloadData=function(){var e=P.extend(!0,[],arguments);return e[3]="reloadData",j.reload.apply(null,e)},function(e,a,n,i){var l=[];return layui.each(e,function(e,t){"function"===layui.type(a)?a(t):P.extend(t,a),l.push(P.extend({},t)),i||(l=l.concat(N(t[n],a,n,i)))}),l}),o=(a.prototype.updateStatus=function(e,t,a){var n=this.getOptions(),i=n.tree;return e=e||B.cache[n.id],N(e,t,i.customName.children,a)},a.prototype.getTableData=function(){var e=this.getOptions();return B.cache[e.id]},j.updateStatus=function(e,t,a){var e=F(e),n=e.getOptions();return a=a||(n.url?B.cache[n.id]:n.data),e.updateStatus(a,t)},j.sort=function(e){var t,a,i,l,n,d=F(e);d&&(n=(t=d.getOptions()).tree,a=j.getData(e),i=n.customName.children,l=function(e,a,n){layui.sort(e,a,n,!0),layui.each(e,function(e,t){l(t[i]||[],a,n)})},t.autoSort)&&((n=t.initSort).type?l(a,n.field,"desc"===n.type):l(a,B.config.indexName,null),B.cache[e]=a,d.initData(a),j.renderData(e))},function(n){var t=n.config.id,i=F(t),a=n.data=j.getNodeDataByIndex(t,n.index),l=a[H],d=(n.dataIndex=l,n.update);n.update=function(){var e=arguments,t=(P.extend(i.getNodeDataByIndex(l),e[0]),d.apply(this,e)),a=n.config.tree.customName.name;return a in e[0]&&n.tr.find('td[data-field="'+a+'"]').children("div.layui-table-cell").removeClass("layui-table-tree-item"),i.renderTreeTable(n.tr,n.tr.attr("data-level"),!1),t},n.del=function(){j.removeNode(t,a)},n.setRowChecked=function(e){j.setRowChecked(t,{index:a,checked:e})}}),u=(j.updateNode=function(e,a,t){var n,i,l,d,r,o=F(e);o&&((d=o.getOptions()).tree,d=(n=d.elem.next()).find('tr[lay-data-index="'+a+'"]'),i=d.attr("data-index"),l=d.attr("data-level"),t)&&(d=o.getNodeDataByIndex(a,!1,t),r=B.getTrHtml(e,[d]),layui.each(["main","fixed-l","fixed-r"],function(e,t){n.find(".layui-table-"+t+' tbody tr[lay-data-index="'+a+'"]').replaceWith(P(r[["trs","trs_fixed","trs_fixed_r"][e]].join("")).attr({"data-index":i,"lay-data-index":a,"data-level":l}).data("index",i))}),o.renderTreeTable(n.find('tr[lay-data-index="'+a+'"]'),l))},j.removeNode=function(e,t,a){var n=F(e);if(n){var i,l=n.getOptions(),d=l.tree,r=d.customName.isParent,o=d.customName.children,c=l.elem.next(),u=[],s=B.cache[e],t=n.getNodeDataByIndex("string"===layui.type(t)?t:t[H],!1,"delete"),f=n.getNodeDataByIndex(t[p]),d=(n.updateCheckStatus(f),n.treeToFlat([t],t[d.customName.pid],t[p])),t=(layui.each(d,function(e,t){t=t[H];u.push('tr[lay-data-index="'+t+'"]'),-1!==t.indexOf("-")&&delete s[t]}),c.find(u.join(",")).remove(),n.initData());for(i in s)-1!==i.indexOf("-")&&i!==s[i][H]&&delete s[i];layui.each(n.treeToFlat(t),function(e,t){t[b]&&t[b]!==t[H]&&c.find('tr[lay-data-index="'+t[b]+'"]').attr({"data-index":t[H],"lay-data-index":t[H]}).data("index",t[H])}),layui.each(s,function(e,t){c.find('tr[data-level="0"][lay-data-index="'+t[H]+'"]').attr("data-index",e).data("index",e)}),l.hasNumberCol&&v(n),f&&(d=c.find('tr[lay-data-index="'+f[H]+'"]'),a||(f[r]=!(!f[o]||!f[o].length)),n.updateNodeIcon({scopeEl:d,isExpand:f[X],isParent:f[r]})),j.resize(e)}},j.addNodes=function(e,t){var a=F(e);if(a){var n=a.getOptions(),i=n.tree,l=n.elem.next(),d=B.config.checkName,r=(t=t||{}).parentIndex,o=t.index,c=t.data,t=t.focus,u=(r="number"===layui.type(r)?r.toString():r)?a.getNodeDataByIndex(r):null,o="number"===layui.type(o)?o:-1,c=P.extend(!0,[],layui.isArray(c)?c:[c]);layui.each(c,function(e,t){d in t||!u||(t[d]=u[d])}),a.getTableData();if(u){var s=i.customName.isParent,f=i.customName.children;u[s]=!0;var y=(y=u[f])?(p=y.splice(-1===o?y.length:o),u[f]=y.concat(c,p)):u[f]=c,f=(a.updateStatus(y,function(e){(e[s]||i.view.showFlexIconIfNotParent)&&(e[V]=!1)}),a.treeToFlat(y));l.find(f.map(function(e){return'tr[lay-data-index="'+e[H]+'"]'}).join(",")).remove(),a.initData(),u[V]=!1,u[U]="local",K({trElem:l.find('tr[lay-data-index="'+r+'"]')},!0)}else{var p=B.cache[e].splice(-1===o?B.cache[e].length:o);if(B.cache[e]=B.cache[e].concat(c,p),n.url||(n.page?(y=n.page,n.data.splice.apply(n.data,[y.limit*(y.curr-1),y.limit].concat(B.cache[e]))):n.data=B.cache[e]),a.initData(),l.find(".layui-none").length)return B.renderData(e),c;var x,f=B.getTrHtml(e,c),h={trs:P(f.trs.join("")),trs_fixed:P(f.trs_fixed.join("")),trs_fixed_r:P(f.trs_fixed_r.join(""))},r=(layui.each(c,function(e,t){x={"data-index":t[H],"lay-data-index":t[H],"data-level":"0"},h.trs.eq(e).attr(x).data("index",t[H]),h.trs_fixed.eq(e).attr(x).data("index",t[H]),h.trs_fixed_r.eq(e).attr(x).data("index",t[H])}),parseInt(c[0][H])-1),y=l.find(R),n=l.find(Y),f=l.find(z);-1==r?y.find('tr[data-level="0"][data-index="0"]')[0]?(y.find('tr[data-level="0"][data-index="0"]').before(h.trs),n.find('tr[data-level="0"][data-index="0"]').before(h.trs_fixed),f.find('tr[data-level="0"][data-index="0"]').before(h.trs_fixed_r)):(y.find("tbody").prepend(h.trs),n.find("tbody").prepend(h.trs_fixed),f.find("tbody").prepend(h.trs_fixed_r)):-1===o?(y.find("tbody").append(h.trs),n.find("tbody").append(h.trs_fixed),f.find("tbody").append(h.trs_fixed_r)):(r=p[0][b],y.find('tr[data-level="0"][data-index="'+r+'"]').before(h.trs),n.find('tr[data-level="0"][data-index="'+r+'"]').before(h.trs_fixed),f.find('tr[data-level="0"][data-index="'+r+'"]').before(h.trs_fixed_r)),layui.each(B.cache[e],function(e,t){l.find('tr[data-level="0"][lay-data-index="'+t[H]+'"]').attr("data-index",e).data("index",e)}),a.renderTreeTable(l.find(c.map(function(e,t,a){return'tr[lay-data-index="'+e[H]+'"]'}).join(",")))}return a.updateCheckStatus(u),u&&(o=l.find('tr[lay-data-index="'+u[H]+'"]'),a.updateNodeIcon({scopeEl:o,isExpand:u[X],isParent:u[s]})),j.resize(e),t&&l.find(R).find('tr[lay-data-index="'+c[0][H]+'"]').get(0).scrollIntoViewIfNeeded(),c}},j.checkStatus=function(e,n){var i,t,a,l=F(e);if(l)return l=l.getOptions().tree,i=B.config.checkName,t=j.getData(e,!0).filter(function(e,t,a){return e[i]||n&&e[g]}),a=!0,layui.each("all"===l.data.cascade?B.cache[e]:j.getData(e,!0),function(e,t){if(!t[i])return!(a=!1)}),{data:t,isAll:a}},j.on("sort",function(e){var e=e.config,t=e.elem.next(),e=e.id;t.hasClass(m)&&j.sort(e)}),j.on("row",function(e){e.config.elem.next().hasClass(m)&&o(e)}),j.on("rowDouble",function(e){var t=e.config,a=t.elem.next();t.id;a.hasClass(m)&&(o(e),(t.tree||{}).view.dblClickExpand)&&K({trElem:e.tr.first()},null,null,null,!0)}),j.on("rowContextmenu",function(e){var t=e.config,a=t.elem.next();t.id;a.hasClass(m)&&o(e)}),j.on("tool",function(e){var t=e.config,a=t.elem.next();t.id;a.hasClass(m)&&o(e)}),j.on("edit",function(e){var t=e.config,a=t.elem.next();t.id;a.hasClass(m)&&(o(e),e.field===t.tree.customName.name)&&((a={})[e.field]=e.value,e.update(a))}),j.on("radio",function(e){var t=e.config,a=t.elem.next(),t=t.id;a.hasClass(m)&&(a=F(t),o(e),u.call(a,e.tr,e.checked))}),a.prototype.setRowCheckedClass=function(e,t){var a=this.getOptions(),n=(e.data("index"),a.elem.next());e[t?"addClass":"removeClass"](l),e.each(function(){var e=P(this).data("index");n.find('.layui-table-fixed-r tbody tr[data-index="'+e+'"]')[t?"addClass":"removeClass"](l)})},a.prototype.updateCheckStatus=function(e,t){var a,n,i,l,d,r,o,c=this,u=c.getOptions();return!!u.hasChecboxCol&&(a=u.tree,n=u.id,i=u.elem.next(),l=B.config.checkName,"all"!==(d=a.data.cascade)&&"parent"!==d||!e||(d=c.updateParentCheckStatus(e,"boolean"===layui.type(t)?t:null),layui.each(d,function(e,t){var a=i.find('tr[lay-data-index="'+t[H]+'"] input[name="layTableCheckbox"]:not(:disabled)'),n=t[l];c.setRowCheckedClass(a.closest("tr"),n),a.prop({checked:n,indeterminate:t[g]})})),o=!(r=!0),0<(e=(e="all"===a.data.cascade?B.cache[n]:j.getData(n,!0)).filter(function(e){return!e[u.disabledName]})).length?layui.each(e,function(e,t){if((t[l]||t[g])&&(o=!0),t[l]||(r=!1),o&&!r)return!0}):r=!1,o=o&&!r,i.find('input[name="layTableCheckbox"][lay-filter="layTableAllChoose"]').prop({checked:r,indeterminate:o}),r)},a.prototype.updateParentCheckStatus=function(a,n){var i,e=this.getOptions(),t=e.tree,e=e.id,l=B.config.checkName,t=t.customName.children,d=[];return!(a[g]=!1)===n?a[t].length?layui.each(a[t],function(e,t){if(!t[l])return n=!1,a[g]=!0}):n=!1:!1===n?layui.each(a[t],function(e,t){if(t[l]||t[g])return a[g]=!0}):(n=!1,i=0,layui.each(a[t],function(e,t){t[l]&&i++}),n=a[t].length?a[t].length===i:a[l],a[g]=!n&&0','','',"
"].join(""))};if("normal"!==t.headerMode){var h,y=r.parent("."+c);if(s||!s&&o'+i.text.none+"
"),n.html(e.elem),0==e.elem.find(".layui-tree-set").length)return e.elem.append(e.elemNone);i.showCheckbox&&e.renderForm("checkbox"),e.elem.find(".layui-tree-set").each(function(){var e=p(this);e.parent(".layui-tree-pack")[0]||e.addClass("layui-tree-setHide"),!e.next()[0]&&e.parents(".layui-tree-pack").eq(1).hasClass("layui-tree-lineExtend")&&e.addClass(T),e.next()[0]||e.parents(".layui-tree-set").eq(0).next()[0]||e.addClass(T)}),e.events()}},l.prototype.renderForm=function(e){i.render(e,"LAY-tree-"+this.index)},l.prototype.tree=function(r,e){var d=this,s=d.config,o=s.customName,e=e||s.data;layui.each(e,function(e,i){var a,n,t=i[o.children]&&0','
"].join(""));t&&(c.append(l),d.tree(l,i[o.children])),r.append(c),c.prev("."+k)[0]&&c.prev().children(".layui-tree-pack").addClass("layui-tree-showLine"),t||c.parent(".layui-tree-pack").addClass("layui-tree-lineExtend"),d.spread(c,i),s.showCheckbox&&(i.checked&&d.checkids.push(i[o.id]),d.checkClick(c,i)),s.edit&&d.operate(c,i)})},l.prototype.spread=function(n,t){var l=this,c=l.config,e=n.children("."+b),i=e.children("."+g),a=i.find('input[same="layuiTreeCheck"]'),r=e.find("."+C),e=e.find("."+w),d=c.onlyIconControl?r:i,s="";d.on("click",function(e){var i=n.children("."+N),a=(d.children(".layui-icon")[0]?d:d.find(".layui-tree-icon")).children(".layui-icon");i[0]?n.hasClass(F)?(n.removeClass(F),i.slideUp(200),a.removeClass(x).addClass(v),l.updateFieldValue(t,"spread",!1)):(n.addClass(F),i.slideDown(200),a.addClass(x).removeClass(v),l.updateFieldValue(t,"spread",!0),c.accordion&&((i=n.siblings("."+k)).removeClass(F),i.children("."+N).slideUp(200),i.find(".layui-tree-icon").children(".layui-icon").removeClass(x).addClass(v))):s="normal"}),e.on("click",function(){p(this).hasClass(u)||(s=n.hasClass(F)?c.onlyIconControl?"open":"close":c.onlyIconControl?"close":"open",a[0]&&l.updateFieldValue(t,"checked",a.prop("checked")),c.click&&c.click({elem:n,state:s,data:t}))})},l.prototype.updateFieldValue=function(e,i,a){i in e&&(e[i]=a)},l.prototype.setCheckbox=function(e,i,a){var t,n=this,l=n.config.customName,c=a.prop("checked");a.prop("disabled")||("object"!=typeof i[l.children]&&!e.find("."+N)[0]||e.find("."+N).find('input[same="layuiTreeCheck"]').each(function(e){this.disabled||((e=i[l.children][e])&&n.updateFieldValue(e,"checked",c),n.updateFieldValue(this,"checked",c))}),(t=function(e){var i,a,n;e.parents("."+k)[0]&&(a=(e=e.parent("."+N)).parent(),n=e.prev().find('input[same="layuiTreeCheck"]'),c?n.prop("checked",c):(e.find('input[same="layuiTreeCheck"]').each(function(){this.checked&&(i=!0)}),i||n.prop("checked",!1)),t(a))})(e),n.renderForm("checkbox"))},l.prototype.checkClick=function(a,n){var t=this,l=t.config;a.children("."+b).children("."+g).on("click",'input[same="layuiTreeCheck"]+',function(e){layui.stope(e);var e=p(this).prev(),i=e.prop("checked");e.prop("disabled")||(t.setCheckbox(a,n,e),t.updateFieldValue(n,"checked",i),l.oncheck&&l.oncheck({elem:a,checked:i,data:n}))})},l.prototype.operate=function(r,d){var s=this,o=s.config,u=o.customName,e=r.children("."+b),h=e.children("."+g);e.children(".layui-tree-btnGroup").on("click",".layui-icon",function(e){layui.stope(e);var i,e=p(this).data("type"),n=r.children("."+N),t={data:d,type:e,elem:r};if("add"==e){n[0]||(o.showLine?(h.find("."+C).addClass("layui-tree-icon"),h.find("."+C).children(".layui-icon").addClass(v).removeClass("layui-icon-file")):h.find(".layui-tree-iconArrow").removeClass(m),r.append(''));var a,l=o.operate&&o.operate(t),c={};if(c[u.title]=o.text.defaultNodeName,c[u.id]=l,s.tree(r.children("."+N),[c]),o.showLine&&(n[0]?(n.hasClass(S)||n.addClass(S),r.find("."+N).each(function(){p(this).children("."+k).last().addClass(T)}),(n.children("."+k).last().prev().hasClass(T)?n.children("."+k).last().prev():n.children("."+k).last()).removeClass(T),!r.parent("."+N)[0]&&r.next()[0]&&n.children("."+k).last().removeClass(T)):(l=r.siblings("."+k),a=1,c=r.parent("."+N),layui.each(l,function(e,i){p(i).children("."+N)[0]||(a=0)}),(1==a?(l.children("."+N).addClass(L),l.children("."+N).children("."+k).removeClass(T),r.children("."+N).addClass(L),c.removeClass(S),c.children("."+k).last().children("."+N).children("."+k).last()):r.children("."+N).children("."+k)).addClass(T))),!o.showCheckbox)return;h.find('input[same="layuiTreeCheck"]')[0].checked&&(r.children("."+N).children("."+k).last().find('input[same="layuiTreeCheck"]')[0].checked=!0),s.renderForm("checkbox")}else"update"==e?(l=h.children("."+w).html(),h.children("."+w).html(""),h.append(''),h.children(".layui-tree-editInput").val(f.unescape(l)).focus(),i=function(e){var i=f.escape(e.val().trim())||o.text.defaultNodeName;e.remove(),h.children("."+w).html(i),t.data[u.title]=i,o.operate&&o.operate(t)},h.children(".layui-tree-editInput").blur(function(){i(p(this))}),h.children(".layui-tree-editInput").on("keydown",function(e){13===e.keyCode&&(e.preventDefault(),i(p(this)))})):y.confirm('\u786e\u8ba4\u5220\u9664\u8be5\u8282\u70b9 "'+(d[u.title]||"")+'" \u5417\uff1f',function(e){var l,a,i;o.operate&&o.operate(t),t.status="remove",y.close(e),r.prev("."+k)[0]||r.next("."+k)[0]||r.parent("."+N)[0]?(r.siblings("."+k).children("."+b)[0]?(o.showCheckbox&&(l=function(e){var i,a,n,t;e.parents("."+k)[0]&&(i=e.siblings("."+k).children("."+b),a=(e=e.parent("."+N).prev()).find('input[same="layuiTreeCheck"]')[0],n=1,(t=0)==a.checked)&&(i.each(function(e,i){i=p(i).find('input[same="layuiTreeCheck"]')[0];0!=i.checked||i.disabled||(n=0),i.disabled||(t=1)}),1==n)&&1==t&&(a.checked=!0,s.renderForm("checkbox"),l(e.parent("."+k)))})(r),o.showLine&&(e=r.siblings("."+k),a=1,i=r.parent("."+N),layui.each(e,function(e,i){p(i).children("."+N)[0]||(a=0)}),1==a?(n[0]||(i.removeClass(S),e.children("."+N).addClass(L),e.children("."+N).children("."+k).removeClass(T)),(r.next()[0]?i.children("."+k).last():r.prev()).children("."+N).children("."+k).last().addClass(T),r.next()[0]||r.parents("."+k)[1]||r.parents("."+k).eq(0).next()[0]||r.prev("."+k).addClass(T)):!r.next()[0]&&r.hasClass(T)&&r.prev().addClass(T))):(e=r.parent("."+N).prev(),o.showLine?(e.find("."+C).removeClass("layui-tree-icon"),e.find("."+C).children(".layui-icon").removeClass(x).addClass("layui-icon-file"),(i=e.parents("."+N).eq(0)).addClass(S),i.children("."+k).each(function(){p(this).children("."+N).children("."+k).last().addClass(T)})):e.find(".layui-tree-iconArrow").addClass(m),r.parents("."+k).eq(0).removeClass(F),r.parent("."+N).remove()),r.remove()):(r.remove(),s.elem.append(s.elemNone))})})},l.prototype.events=function(){var i=this,t=i.config;i.elem.find(".layui-tree-checkedFirst");i.setChecked(i.checkids),i.elem.find(".layui-tree-search").on("keyup",function(){var e=p(this),a=e.val(),e=e.nextAll(),n=[];e.find("."+w).each(function(){var i,e=p(this).parents("."+b);-1!=p(this).html().indexOf(a)&&(n.push(p(this).parent()),(i=function(e){e.addClass("layui-tree-searchShow"),e.parent("."+N)[0]&&i(e.parent("."+N).parent("."+k))})(e.parent("."+k)))}),e.find("."+b).each(function(){var e=p(this).parent("."+k);e.hasClass("layui-tree-searchShow")||e.addClass(m)}),0==e.find(".layui-tree-searchShow").length&&i.elem.append(i.elemNone),t.onsearch&&t.onsearch({elem:n})}),i.elem.find(".layui-tree-search").on("keydown",function(){p(this).nextAll().find("."+b).each(function(){p(this).parent("."+k).removeClass("layui-tree-searchShow "+m)}),p(".layui-tree-emptyText")[0]&&p(".layui-tree-emptyText").remove()})},l.prototype.getChecked=function(){var t=this,e=t.config,l=e.customName,i=[],a=[],c=(t.elem.find(".layui-form-checked").each(function(){i.push(p(this).prev()[0].value)}),function(e,n){layui.each(e,function(e,a){layui.each(i,function(e,i){if(a[l.id]==i)return t.updateFieldValue(a,"checked",!0),delete(i=p.extend({},a))[l.children],n.push(i),a[l.children]&&(i[l.children]=[],c(a[l.children],i[l.children])),!0})})});return c(p.extend({},e.data),a),a},l.prototype.setChecked=function(l){this.config;this.elem.find("."+k).each(function(e,i){var a=p(this).data("id"),n=p(i).children("."+b).find('input[same="layuiTreeCheck"]'),t=n.next();if("number"==typeof l){if(a.toString()==l.toString())return n[0].checked||t.click(),!1}else"object"==typeof l&&layui.each(l,function(e,i){if(i.toString()==a.toString()&&!n[0].checked)return t.click(),!0})})},n.that={},n.config={},t.reload=function(e,i){e=n.that[e];return e.reload(i),n.call(e)},t.getChecked=function(e){return n.that[e].getChecked()},t.setChecked=function(e,i){return n.that[e].setChecked(i)},t.render=function(e){e=new l(e);return n.call(e)},e(a,t)});layui.define(["laytpl","form"],function(e){"use strict";var d=layui.$,n=layui.laytpl,t=layui.form,a="transfer",i={config:{},index:layui[a]?layui[a].index+1e4:0,set:function(e){var t=this;return t.config=d.extend({},t.config,e),t},on:function(e,t){return layui.onevent.call(this,a,e,t)}},l=function(){var t=this,e=t.config,a=e.id||t.index;return l.that[a]=t,{config:l.config[a]=e,reload:function(e){t.reload.call(t,e)},getData:function(){return t.getData.call(t)}}},s="layui-hide",u="layui-btn-disabled",c="layui-none",r="layui-transfer-box",h="layui-transfer-header",o="layui-transfer-search",f="layui-transfer-data",y=function(e){return['','
',s.showLine?t?'':'':'',s.showCheckbox?'':"",s.isJump&&i.href?''+(i[o.title]||i.label||s.text.defaultNodeName)+"":''+(i[o.title]||i.label||s.text.defaultNodeName)+"","
",s.edit?(a={add:'',update:'',del:''},n=[''],!0===s.edit&&(s.edit=["update","del"]),"object"==typeof s.edit?(layui.each(s.edit,function(e,i){n.push(a[i]||"")}),n.join("")+"
"):void 0):"","','
"].join("")},p=['','","
","{{# if(d.data.showSearch){ }}",'','','',"
","{{# } }}",'',y({index:0,checkAllName:"layTransferLeftCheckAll"}),'
"].join(""),v=function(e){var t=this;t.index=++i.index,t.config=d.extend({},t.config,i.config,e),t.render()};v.prototype.config={title:["\u5217\u8868\u4e00","\u5217\u8868\u4e8c"],width:200,height:360,data:[],value:[],showSearch:!1,id:"",text:{none:"\u65e0\u6570\u636e",searchNone:"\u65e0\u5339\u914d\u6570\u636e"}},v.prototype.reload=function(e){var t=this;t.config=d.extend({},t.config,e),t.render()},v.prototype.render=function(){var e=this,t=e.config,a=e.elem=d(n(p,{open:"{{",close:"}}",tagStyle:"legacy"}).render({data:t,index:e.index})),i=t.elem=d(t.elem);i[0]&&(t.data=t.data||[],t.value=t.value||[],t.id="id"in t?t.id:elem.attr("id")||e.index,e.key=t.id,i.html(e.elem),e.layBox=e.elem.find("."+r),e.layHeader=e.elem.find("."+h),e.laySearch=e.elem.find("."+o),e.layData=a.find("."+f),e.layBtn=a.find(".layui-transfer-active .layui-btn"),e.layBox.css({width:t.width,height:t.height}),e.layData.css({height:(i=t.height-e.layHeader.outerHeight(),t.showSearch&&(i-=e.laySearch.outerHeight()),i-2)}),e.renderData(),e.events())},v.prototype.renderData=function(){var e=this,t=e.config,l=[{checkName:"layTransferLeftCheck",views:[]},{checkName:"layTransferRightCheck",views:[]}];e.parseData(function(a){var i=a.selected?1:0,n=["','",'","
",y({index:1,checkAllName:"layTransferRightCheckAll"}),"'+(t||"")+"
");e.find("."+c)[0]&&e.find("."+c).remove(),t.replace(/\s/g,"")&&e.append(a)},v.prototype.setValue=function(){var e=this.config,t=[];return this.layBox.eq(1).find("."+f+' input[type="checkbox"]').each(function(){d(this).data("hide")||t.push(this.value)}),e.value=t,this},v.prototype.parseData=function(t){var i=this.config,n=[];return layui.each(i.data,function(e,a){a=("function"==typeof i.parseData?i.parseData(a):a)||a,n.push(a=d.extend({},a)),layui.each(i.value,function(e,t){t==a.value&&(a.selected=!0)}),t&&t(a)}),i.data=n,this},v.prototype.getData=function(e){var t=this.config,i=[];return this.setValue(),layui.each(e||t.value,function(e,a){layui.each(t.data,function(e,t){delete t.selected,a==t.value&&i.push(t)})}),i},v.prototype.transfer=function(e,t){var a,i=this,n=i.config,l=i.layBox.eq(e),c=[],t=(t?((a=(t=t).find('input[type="checkbox"]'))[0].checked=!1,l.siblings("."+r).find("."+f).append(t.clone()),t.remove(),c.push(a[0].value),i.setValue()):l.each(function(e){d(this).find("."+f).children("li").each(function(){var e=d(this),t=e.find('input[type="checkbox"]'),a=t.data("hide");t[0].checked&&!a&&(t[0].checked=!1,l.siblings("."+r).find("."+f).append(e.clone()),e.remove(),c.push(t[0].value)),i.setValue()})}),i.renderCheckBtn(),l.siblings("."+r).find("."+o+" input"));""!==t.val()&&t.trigger("keyup"),n.onchange&&n.onchange(i.getData(c),e)},v.prototype.events=function(){var n=this,l=n.config;n.elem.on("click",'input[lay-filter="layTransferCheckbox"]+',function(){var e=d(this).prev(),t=e[0].checked,a=e.parents("."+r).eq(0).find("."+f);e[0].disabled||("all"===e.attr("lay-type")&&a.find('input[type="checkbox"]').each(function(){this.disabled||(this.checked=t)}),setTimeout(function(){n.renderCheckBtn({stopNone:!0})},0))}),n.elem.on("dblclick","."+f+">li",function(e){var t=d(this),a=t.children('input[type="checkbox"]'),i=t.parent().parent().data("index");a[0].disabled||!1!==("function"==typeof l.dblclick?l.dblclick({elem:t,data:n.getData([a[0].value])[0],index:i}):null)&&n.transfer(i,t)}),n.layBtn.on("click",function(){var e=d(this),t=e.data("index");e.hasClass(u)||n.transfer(t)}),n.laySearch.find("input").on("keyup",function(){var i=this.value,e=d(this).parents("."+o).eq(0).siblings("."+f),t=e.children("li"),t=(t.each(function(){var e=d(this),t=e.find('input[type="checkbox"]'),a=t[0].title,a=("cs"!==l.showSearch&&(a=a.toLowerCase(),i=i.toLowerCase()),-1!==a.indexOf(i));e[a?"removeClass":"addClass"](s),t.data("hide",!a)}),n.renderCheckBtn(),t.length===e.children("li."+s).length);n.noneView(e,t?l.text.searchNone:"")})},l.that={},l.config={},i.reload=function(e,t){e=l.that[e];return e.reload(t),l.call(e)},i.getData=function(e){return l.that[e].getData()},i.render=function(e){e=new v(e);return l.call(e)},e(a,i)});layui.define(["jquery","lay"],function(e){"use strict";var o=layui.$,l=layui.lay,t=(layui.hint(),layui.device(),{config:{},set:function(e){var n=this;return n.config=o.extend({},n.config,e),n},on:function(e,n){return layui.onevent.call(this,r,e,n)}}),r="carousel",s="layui-this",u="layui-carousel-left",c="layui-carousel-right",m="layui-carousel-prev",h="layui-carousel-next",a="layui-carousel-arrow",d="layui-carousel-ind",n=function(e){var n=this;n.config=o.extend({},n.config,t.config,e),n.render()};n.prototype.config={width:"600px",height:"280px",full:!1,arrow:"hover",indicator:"inside",autoplay:!0,interval:3e3,anim:"",trigger:"click",index:0},n.prototype.render=function(){var e=this,n=e.config,i=o(n.elem);if(1- ',(n=[],layui.each(e.elemItem,function(e){n.push("
- "),i=1;i<=a.length;i++){var n='
- ";a.half&&parseInt(a.value)!==a.value&&i==Math.ceil(a.value)?t=t+'
- ":t+=n}t+="
',D.digit(t+1)+".","
"].join(""):"",'',e||" ","
",""].join("")})}},a=l.code,n=function(e){return"function"==typeof l.codeParse?l.codeParse(e,l):e},"reloadCode"===e?o.children(".layui-code-wrap").html(w(n(a)).html):(d=layui.code.index=++R,o.attr("lay-code-index",d),(M=A.CDDE_DATA_CLASS in o.data())&&o.attr("class",o.data(A.CDDE_DATA_CLASS)||""),M||o.data(A.CDDE_DATA_CLASS,o.attr("class")),c={copy:{className:"file-b",title:["\u590d\u5236\u4ee3\u7801"],event:function(e){var t=D.unescape(n(l.code)),a="function"==typeof l.onCopy;lay.clipboard.writeText({text:t,done:function(){if(a&&!1===l.onCopy(t,!0))return;W.msg("\u5df2\u590d\u5236",{icon:1})},error:function(){if(a&&!1===l.onCopy(t,!1))return;W.msg("\u590d\u5236\u5931\u8d25",{icon:2})}})}}},function b(){var e=o.parent("."+A.ELEM_PREVIEW),t=e.children("."+A.ELEM_TAB),a=e.children("."+A.ELEM_ITEM+"-preview");return t.remove(),a.remove(),e[0]&&o.unwrap(),b}(),l.preview&&(M="LAY-CODE-DF-"+d,f=l.layout||["code","preview"],s="iframe"===l.preview,E=x(''),C=x('
'),r=x('
'),_=x('
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/电子展板/Configs/config.json b/电子展板/Configs/config.json
new file mode 100644
index 0000000..5f28270
--- /dev/null
+++ b/电子展板/Configs/config.json
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/电子展板/Controller/AmazeUIController.cs b/电子展板/Controller/AmazeUIController.cs
new file mode 100644
index 0000000..3f63983
--- /dev/null
+++ b/电子展板/Controller/AmazeUIController.cs
@@ -0,0 +1,155 @@
+using Microsoft.AspNetCore.Mvc;
+using System.Web.Http;
+
+namespace 电子展板.Controller
+{
+ public class AmazeUIController : BaseController
+ {
+ #region css
+ [HttpGet, Route("AmazeUI/css/admin.css")]
+ public ActionResult Index()
+ {
+ return Resouce("/AmazeUI/css/admin.css", "text/css");
+ }
+
+ [HttpGet, Route("AmazeUI/css/amazeui.css")]
+ public ActionResult AmazeuiCSS()
+ {
+ return Resouce("/AmazeUI/css/amazeui.css", "text/css");
+ }
+
+ [HttpGet, Route("AmazeUI/css/amazeui.flat.css")]
+ public ActionResult AmazeuiFlatCss()
+ {
+ return Resouce("/AmazeUI/css/amazeui.flat.css", "text/css");
+ }
+
+ [HttpGet, Route("AmazeUI/css/amazeui.flat.min.css")]
+ public ActionResult AmazeuiFlatMinCSS()
+ {
+ return Resouce("/AmazeUI/css/amazeui.flat.min.css", "text/css");
+ }
+
+ [HttpGet, Route("AmazeUI/css/amazeui.min.css")]
+ public ActionResult AmazeuiMinCSS()
+ {
+ return Resouce("/AmazeUI/css/amazeui.min.css", "text/css");
+ }
+
+ [HttpGet, Route("AmazeUI/css/app.css")]
+ public ActionResult AppCSS()
+ {
+ return Resouce("/AmazeUI/css/app.css", "text/css");
+ }
+ #endregion
+
+
+ #region fonts
+ [HttpGet, Route("AmazeUI/fonts/FontAwesome.otf")]
+ public ActionResult FontAwesomeotf()
+ {
+ return Resouce("/AmazeUI/fonts/FontAwesome.otf", "font/otf");
+ }
+ [HttpGet, Route("AmazeUI/fonts/fontawesome-webfont.eot")]
+ public ActionResult fontawesome_webfont_eot()
+ {
+ return Resouce("/AmazeUI/fonts/fontawesome-webfont.eot", "font/eot");
+ }
+ [HttpGet, Route("AmazeUI/fonts/fontawesome-webfont.ttf")]
+ public ActionResult fontawesome_webfont_ttf()
+ {
+ return Resouce("/AmazeUI/fonts/fontawesome-webfont.ttf", "font/ttf");
+ }
+ [HttpGet, Route("AmazeUI/fonts/fontawesome-webfont.woff")]
+ public ActionResult fontawesome_webfont_woff()
+ {
+ return Resouce("/AmazeUI/fonts/fontawesome-webfont.woff", "font/woff");
+ }
+ [HttpGet, Route("AmazeUI/fonts/fontawesome-webfont.woff2")]
+ public ActionResult fontawesome_webfont_woff2()
+ {
+ return Resouce("/AmazeUI/fonts/fontawesome-webfont.woff2", "font/woff2");
+ }
+ #endregion
+
+
+ #region i
+ [HttpGet, Route("AmazeUI/i/app-icon72x72@2x.png")]
+ public ActionResult app_icon72x72_2x_png()
+ {
+ return Resouce("/AmazeUI/i/app-icon72x72@2x.png", "image/png");
+ }
+
+ [HttpGet, Route("AmazeUI/i/favicon.png")]
+ public ActionResult favicon_png()
+ {
+ return Resouce("/AmazeUI/i/favicon.png", "image/png");
+ }
+
+ [HttpGet, Route("AmazeUI/i/startup-640x1096.png")]
+ public ActionResult startup_640x1096_png()
+ {
+ return Resouce("/AmazeUI/i/startup-640x1096.png", "image/png");
+ }
+
+
+
+ #endregion
+ #region JS
+ [HttpGet, Route("AmazeUI/js/amazeui.ie8polyfill.js")]
+ public ActionResult amazeui_ie8polyfill_js()
+ {
+ return Resouce("/AmazeUI/js/amazeui.ie8polyfill.js", "application/javascript");
+ }
+ [HttpGet, Route("AmazeUI/js/amazeui.ie8polyfill.min.js")]
+ public ActionResult amazeui_ie8polyfill_min_js()
+ {
+ return Resouce("/AmazeUI/js/amazeui.ie8polyfill.min.js", "application/javascript");
+ }
+
+
+ [HttpGet, Route("AmazeUI/js/amazeui.js")]
+ public ActionResult amazeui_js()
+ {
+ return Resouce("/AmazeUI/js/amazeui.js", "application/javascript");
+ }
+
+
+ [HttpGet, Route("AmazeUI/js/amazeui.min.js")]
+ public ActionResult amazeui_min_js()
+ {
+ return Resouce("/AmazeUI/js/amazeui.min.js", "application/javascript");
+ }
+
+
+
+
+ [HttpGet, Route("AmazeUI/js/amazeui.widgets.helper.js")]
+ public ActionResult amazeui_widgets_helper_js()
+ {
+ return Resouce("/AmazeUI/js/amazeui.widgets.helper.js", "application/javascript");
+ }
+
+
+
+
+ [HttpGet, Route("AmazeUI/js/amazeui.widgets.helper.min.js")]
+ public ActionResult amazeui_widgets_helper_min_js()
+ {
+ return Resouce("/AmazeUI/js/amazeui.widgets.helper.min.js", "application/javascript");
+ }
+
+
+ [HttpGet, Route("AmazeUI/js/app_js")]
+ public ActionResult app_js()
+ {
+ return Resouce("/AmazeUI/js/app_js", "application/javascript");
+ }
+ [HttpGet, Route("AmazeUI/js/handlebars.min.js")]
+ public ActionResult handlebars_min_js()
+ {
+ return Resouce("/AmazeUI/js/handlebars.min.js", "application/javascript");
+ }
+ #endregion
+ }
+}
diff --git a/电子展板/Controller/BaseController.cs b/电子展板/Controller/BaseController.cs
new file mode 100644
index 0000000..898519b
--- /dev/null
+++ b/电子展板/Controller/BaseController.cs
@@ -0,0 +1,206 @@
+using JinianNet.JNTemplate;
+using Microsoft.AspNetCore.Mvc;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.Pipes;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Runtime.InteropServices.ComTypes;
+using System.Text;
+using System.Web;
+using System.Web.Http;
+using System.Web.Http.Results;
+using System.Xml.Linq;
+using 电子展板.Utility.Core;
+using 电子展板.Utility.Extension;
+using 电子展板.Utility.ResponseModels;
+
+
+namespace 电子展板.Controller
+{
+
+ public class BaseController : ApiController
+ {
+ protected ActionResult Content(string content)
+ {
+ return new ActionResult { Content = new StringContent(content, Encoding.UTF8, "text/plain") };
+ }
+
+ protected ActionResult ContentType(string content, string contentType)
+ {
+ return new ActionResult { Content = new StringContent(content, Encoding.UTF8, contentType) };
+ }
+
+ public new ActionResult Redirect(string url)
+ {
+ ActionResult resp = new ActionResult(HttpStatusCode.Moved);
+ string originalString = Request.RequestUri.OriginalString;
+ string pathAndQuery = Request.RequestUri.PathAndQuery;
+ string baseUrl = originalString.Substring(0, originalString.IndexOf(pathAndQuery));
+ resp.Headers.Location = new Uri(baseUrl + url);
+ return resp;
+ }
+
+ protected ActionResult File(string virtualPath, string contentType)
+ {
+ return File(virtualPath, contentType, "HelloWorld");
+ }
+
+ protected ActionResult File(string virtualPath, string contentType, string fileDownloadName)
+ {
+ string physicalPath = MyEnvironment.WebRootPath(virtualPath);
+ return PhysicalFile(physicalPath, contentType, fileDownloadName);
+ }
+
+ protected ActionResult PhysicalFile(string physicalPath, string contentType)
+ {
+ return PhysicalFile(physicalPath, contentType, "HelloWorld");
+ }
+
+ protected ActionResult PhysicalFile(string physicalPath, string contentType, string fileDownloadName)
+ {
+ return File(System.IO.File.OpenRead(physicalPath), contentType, fileDownloadName);
+ }
+
+
+ protected ActionResult File(byte[] fileContents, string contentType)
+ {
+ return File(fileContents, contentType, "HelloWorld");
+ }
+
+
+ protected ActionResult File(byte[] fileContents, string contentType, string fileDownloadName)
+ {
+ ActionResult response = new ActionResult(HttpStatusCode.OK);
+ response.Content = new ByteArrayContent(fileContents);
+ response.Content.Headers.ContentType = new MediaTypeHeaderValue(contentType);
+ response.Content.Headers.ContentLength = fileContents.Length;
+ response.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment")
+ {
+ FileName = HttpUtility.UrlEncode(fileDownloadName)
+ };
+ response.Headers.Add("Access-Control-Expose-Headers", "FileName");
+ response.Headers.Add("FileName", HttpUtility.UrlEncode(fileDownloadName));
+ return response;
+ }
+
+ protected ActionResult File(Stream fileStream, string contentType)
+ {
+ return File(fileStream, contentType, "HelloWorld");
+ }
+
+ protected ActionResult File(Stream fileStream, string contentType, string fileDownloadName)
+ {
+ ActionResult response = new ActionResult(HttpStatusCode.OK);
+ response.Content = new StreamContent(fileStream);
+ response.Content.Headers.ContentType = new MediaTypeHeaderValue(contentType);
+ response.Content.Headers.ContentLength = fileStream.Length;
+ response.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment")
+ {
+ FileName = HttpUtility.UrlEncode(fileDownloadName)
+ };
+ response.Headers.Add("Access-Control-Expose-Headers", "FileName");
+ response.Headers.Add("FileName", HttpUtility.UrlEncode(fileDownloadName));
+ return response;
+ }
+ #region 快捷方法
+ protected ActionResult Success(string message = "恭喜您，操作成功。", object data = null)
+ {
+ return Content(new AjaxResult(ResultType.Success, message, data).ToJson());
+ }
+ protected ActionResult Error(string message = "对不起，操作失败。", object data = null)
+ {
+ return Content(new AjaxResult(ResultType.Error, message, data).ToJson());
+ }
+ protected ActionResult Warning(string message, object data = null)
+ {
+ return Content(new AjaxResult(ResultType.Warning, message, data).ToJson());
+ }
+ protected ActionResult Info(string message, object data = null)
+ {
+ return Content(new AjaxResult(ResultType.Info, message, data).ToJson());
+ }
+
+
+ public ActionResult Json(object obj)
+ {
+ return new ActionResult { Content = new StringContent(obj.ToJson(), Encoding.UTF8, "application/json") };
+ }
+
+
+
+ public ActionResult Text(string str)
+ {
+ //return Content(str, "text/plain");
+ return new ActionResult { Content = new System.Net.Http.StringContent(str, Encoding.UTF8, "text/plain") };
+
+ }
+
+ public ActionResult HtmlStr(string str)
+ {
+ return new ActionResult { Content = new System.Net.Http.StringContent(str, Encoding.UTF8, "text/html") };
+
+ }
+
+ public ActionResult Html(string view)
+ {
+ return Html(view, null);
+ }
+ public ActionResult Resouce(string viewName, string contentType)
+ {
+ string packUri = $"pack://application:,,,/Assets{viewName}";
+ byte[] bytes = null;
+ using (Stream stream = System.Windows.Application.GetResourceStream(new Uri(packUri, UriKind.RelativeOrAbsolute)).Stream)
+ {
+ bytes = new byte[stream.Length];
+ stream.Read(bytes, 0, bytes.Length);
+ }
+ ActionResult response = new ActionResult(HttpStatusCode.OK);
+ response.Content = new ByteArrayContent(bytes);
+ response.Content.Headers.ContentType = new MediaTypeHeaderValue(contentType);
+ response.Content.Headers.ContentLength = bytes.Length;
+ return response;
+ }
+
+
+ public ActionResult Html(string view, Dictionary dict)
+ {
+ if (!view.StartsWith("/"))
+ view = "/" + view;
+ string path = AppDomain.CurrentDomain.BaseDirectory.Replace("\\", "/") + "Views";
+
+
+ var template = Engine.LoadTemplate(path + view + ".html");
+
+
+ if (dict != null)
+ {
+ foreach (KeyValuePair keyValue in dict)
+ {
+ template.Set(keyValue.Key, keyValue.Value);
+ }
+ }
+ var result = template.Render();
+ // return Content(result, "text/html");
+ return new ActionResult { Content = new System.Net.Http.StringContent(result, Encoding.UTF8, "text/html") };
+
+ }
+ #endregion
+ }
+}
+
+namespace Microsoft.AspNetCore.Mvc
+{
+ public class ActionResult : System.Net.Http.HttpResponseMessage
+ {
+ public ActionResult() : base(HttpStatusCode.OK)
+ {
+
+ }
+ public ActionResult(HttpStatusCode statusCode) : base(statusCode)
+ {
+ }
+ }
+}
\ No newline at end of file
diff --git a/电子展板/Controller/IndexController.cs b/电子展板/Controller/IndexController.cs
new file mode 100644
index 0000000..f8f5dec
--- /dev/null
+++ b/电子展板/Controller/IndexController.cs
@@ -0,0 +1,25 @@
+using Microsoft.AspNetCore.Mvc;
+using System.Collections.Generic;
+using System.Web.Http;
+
+namespace 电子展板.Controller
+{
+ public class IndexController : BaseController
+ {
+ //[HttpGet, Route("index/error")]
+ //public ActionResult Error()
+ //{
+ // return Html("/Sys/Index/Error");
+ //}
+
+ ///
+ /// 后台首页视图。
+ ///
+ ///
+
\ No newline at end of file
diff --git a/电子展板/FodyWeavers.xsd b/电子展板/FodyWeavers.xsd
new file mode 100644
index 0000000..408a212
--- /dev/null
+++ b/电子展板/FodyWeavers.xsd
@@ -0,0 +1,225 @@
+
+
+
+
+
+
+
+
+
+
+ Used to control if the On_PropertyName_Changed feature is enabled.
+
+
+
+
+ Used to control if the Dependent properties feature is enabled.
+
+
+
+
+ Used to control if the IsChanged property feature is enabled.
+
+
+
+
+ Used to change the name of the method that fires the notify event. This is a string that accepts multiple values in a comma separated form.
+
+
+
+
+ Used to control if equality checks should be inserted. If false, equality checking will be disabled for the project.
+
+
+
+
+ Used to control if equality checks should use the Equals method resolved from the base class.
+
+
+
+
+ Used to control if equality checks should use the static Equals method resolved from the base class.
+
+
+
+
+ Used to turn off build warnings from this weaver.
+
+
+
+
+ Used to turn off build warnings about mismatched On_PropertyName_Changed methods.
+
+
+
+
+
+
+
+
+
+ A list of assembly names to exclude from the default action of "embed all Copy Local references", delimited with line breaks
+
+
+
+
+ A list of assembly names to include from the default action of "embed all Copy Local references", delimited with line breaks.
+
+
+
+
+ A list of runtime assembly names to exclude from the default action of "embed all Copy Local references", delimited with line breaks
+
+
+
+
+ A list of runtime assembly names to include from the default action of "embed all Copy Local references", delimited with line breaks.
+
+
+
+
+ Obsolete, use UnmanagedWinX86Assemblies instead
+
+
+
+
+ A list of unmanaged X86 (32 bit) assembly names to include, delimited with line breaks.
+
+
+
+
+ Obsolete, use UnmanagedWinX64Assemblies instead.
+
+
+
+
+ A list of unmanaged X64 (64 bit) assembly names to include, delimited with line breaks.
+
+
+
+
+ A list of unmanaged Arm64 (64 bit) assembly names to include, delimited with line breaks.
+
+
+
+
+ The order of preloaded assemblies, delimited with line breaks.
+
+
+
+
+
+ This will copy embedded files to disk before loading them into memory. This is helpful for some scenarios that expected an assembly to be loaded from a physical file.
+
+
+
+
+ Controls if .pdbs for reference assemblies are also embedded.
+
+
+
+
+ Controls if runtime assemblies are also embedded.
+
+
+
+
+ Controls whether the runtime assemblies are embedded with their full path or only with their assembly name.
+
+
+
+
+ Embedded assemblies are compressed by default, and uncompressed when they are loaded. You can turn compression off with this option.
+
+
+
+
+ As part of Costura, embedded assemblies are no longer included as part of the build. This cleanup can be turned off.
+
+
+
+
+ The attach method no longer subscribes to the `AppDomain.AssemblyResolve` (.NET 4.x) and `AssemblyLoadContext.Resolving` (.NET 6.0+) events.
+
+
+
+
+ Costura by default will load as part of the module initialization. This flag disables that behavior. Make sure you call CosturaUtility.Initialize() somewhere in your code.
+
+
+
+
+ Costura will by default use assemblies with a name like 'resources.dll' as a satellite resource and prepend the output path. This flag disables that behavior.
+
+
+
+
+ A list of assembly names to exclude from the default action of "embed all Copy Local references", delimited with |
+
+
+
+
+ A list of assembly names to include from the default action of "embed all Copy Local references", delimited with |.
+
+
+
+
+ A list of runtime assembly names to exclude from the default action of "embed all Copy Local references", delimited with |
+
+
+
+
+ A list of runtime assembly names to include from the default action of "embed all Copy Local references", delimited with |.
+
+
+
+
+ Obsolete, use UnmanagedWinX86Assemblies instead
+
+
+
+
+ A list of unmanaged X86 (32 bit) assembly names to include, delimited with |.
+
+
+
+
+ Obsolete, use UnmanagedWinX64Assemblies instead
+
+
+
+
+ A list of unmanaged X64 (64 bit) assembly names to include, delimited with |.
+
+
+
+
+ A list of unmanaged Arm64 (64 bit) assembly names to include, delimited with |.
+
+
+
+
+ The order of preloaded assemblies, delimited with |.
+
+
+
+
+
+
+
+ 'true' to run assembly verification (PEVerify) on the target assembly after all weavers have been executed.
+
+
+
+
+ A comma-separated list of error codes that can be safely ignored in assembly verification.
+
+
+
+
+ 'false' to turn off automatic generation of the XML Schema file.
+
+
+
+
+
\ No newline at end of file
diff --git a/电子展板/MainWindow.xaml b/电子展板/MainWindow.xaml
new file mode 100644
index 0000000..6c6ef8e
--- /dev/null
+++ b/电子展板/MainWindow.xaml
@@ -0,0 +1,83 @@
+
+
+
+
+
+
+
diff --git a/电子展板/MainWindow.xaml.cs b/电子展板/MainWindow.xaml.cs
new file mode 100644
index 0000000..e32727a
--- /dev/null
+++ b/电子展板/MainWindow.xaml.cs
@@ -0,0 +1,47 @@
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Windows;
+using System.Windows.Forms;
+using System.Windows.Media;
+using System.Xml;
+
+namespace 电子展板
+{
+ ///
+ /// Interaction logic for MainWindow.xaml
+ ///
+ public partial class MainWindow : Window
+ {
+ public MainWindow()
+ {
+ InitializeComponent();
+ }
+
+ private void Window_Loaded(object sender, RoutedEventArgs e)
+ {
+ int screenIndex = 0;
+ this.Left = (int)(Screen.AllScreens[screenIndex].Bounds.Left / GetDpiScaleX());
+ this.Top = (int)(Screen.AllScreens[screenIndex].Bounds.Top / GetDpiScaleX());
+ this.Width = (int)(Screen.AllScreens[screenIndex].Bounds.Width / GetDpiScaleX());
+ this.Height = (int)(Screen.AllScreens[screenIndex].Bounds.Height / GetDpiScaleX());
+ WebServer.Start();
+ }
+
+ public double GetDpiScaleX()
+ {
+ return VisualTreeHelper.GetDpi(this).DpiScaleX;
+ }
+
+ private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
+ {
+ WebServer.Stop();
+ Environment.Exit(0);
+ }
+ }
+}
\ No newline at end of file
diff --git a/电子展板/MainWindow2.xaml b/电子展板/MainWindow2.xaml
new file mode 100644
index 0000000..dd89ea1
--- /dev/null
+++ b/电子展板/MainWindow2.xaml
@@ -0,0 +1,98 @@
+
+
+
+
+
+
+
diff --git a/电子展板/MainWindow2.xaml.cs b/电子展板/MainWindow2.xaml.cs
new file mode 100644
index 0000000..feb863e
--- /dev/null
+++ b/电子展板/MainWindow2.xaml.cs
@@ -0,0 +1,59 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
+using System.Windows.Documents;
+using System.Windows.Forms;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using System.Windows.Shapes;
+
+namespace 电子展板
+{
+ ///
+ /// MainWindow2.xaml 的交互逻辑
+ ///
+ public partial class MainWindow2 : Window
+ {
+ public MainWindow2()
+ {
+ InitializeComponent();
+ }
+ private void Window_Loaded(object sender, RoutedEventArgs e)
+ {
+ Screen[] screens = Screen.AllScreens;
+ if (screens.Length > 1)
+ {
+ int screenIndex = 1;
+ this.Left = (int)(Screen.AllScreens[screenIndex].Bounds.Left / GetDpiScaleX());
+ this.Top = (int)(Screen.AllScreens[screenIndex].Bounds.Top / GetDpiScaleX());
+ this.Width = (int)(Screen.AllScreens[screenIndex].Bounds.Width / GetDpiScaleX());
+ this.Height = (int)(Screen.AllScreens[screenIndex].Bounds.Height / GetDpiScaleX());
+ }
+ else
+ {
+ this.Close();
+ }
+ }
+
+ public double GetDpiScaleX()
+ {
+ return VisualTreeHelper.GetDpi(this).DpiScaleX;
+ }
+
+ private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
+ {
+ WebServer.Stop();
+ Screen[] screens = Screen.AllScreens;
+ if (screens.Length > 1)
+ {
+ Environment.Exit(0);
+ }
+ }
+ }
+}
diff --git a/电子展板/Utility/Core/Checker.cs b/电子展板/Utility/Core/Checker.cs
new file mode 100644
index 0000000..b8f22c9
--- /dev/null
+++ b/电子展板/Utility/Core/Checker.cs
@@ -0,0 +1,394 @@
+using System;
+using System.Text;
+using System.Text.RegularExpressions;
+
+namespace 电子展板.Utility.Core
+{
+ public static class Checker
+ {
+ #region 验证IP
+ ///
+ /// 验证IP
+ ///
+ ///
+ ///
+ /// 验证EMail是否合法
+ ///
+ /// 要验证的Email
+ public static bool IsEmail(this string source)
+ {
+ return Regex.IsMatch(source, @"^[A-Za-z0-9](([_\.\-]?[a-zA-Z0-9]+)*)@([A-Za-z0-9]+)(([\.\-]?[a-zA-Z0-9]+)*)\.([A-Za-z]{2,})$", RegexOptions.IgnoreCase);
+ }
+ public static bool HasEmail(this string source)
+ {
+ return Regex.IsMatch(source, @"[A-Za-z0-9](([_\.\-]?[a-zA-Z0-9]+)*)@([A-Za-z0-9]+)(([\.\-]?[a-zA-Z0-9]+)*)\.([A-Za-z]{2,})", RegexOptions.IgnoreCase);
+ }
+ #endregion
+
+ #region 验证网址
+ ///
+ /// 验证网址
+ ///
+ ///
+ ///
+ /// 验证日期
+ ///
+ ///
+ ///
+ /// 验证手机号
+ ///
+ ///
+ ///
+ /// 验证身份证是否有效
+ ///
+ ///
+ ///
+ /// 是不是Int型的
+ ///
+ ///
+ ///
+ /// 看字符串的长度是不是在限定数之间 一个中文为两个字符
+ ///
+ /// 字符串
+ /// 大于等于
+ /// 小于等于
+ ///
+ /// 是不是中国电话，格式010-85849685
+ ///
+ ///
+ ///
+ /// 邮政编码 6个数字
+ ///
+ ///
+ ///
+ /// 中文
+ ///
+ ///
+ ///
+ /// 验证是不是正常字符 字母，数字，下划线的组合
+ ///
+ ///
+ ///
+ /// 验证用户名：必须以字母开头，可以包含字母、数字、“_”、“.”，至少5个字符
+ ///
+ ///
+ ///
+ /// 是否是Base64字符串
+ ///
+ ///
+ ///
+ /// 判断字符串是否为数字
+ ///
+ /// 待验证的字符窜
+ /// bool
+ public static bool IsNumber(this string str)
+ {
+ bool result = true;
+ foreach (char ar in str)
+ {
+ if (!char.IsNumber(ar))
+ {
+ result = false;
+ break;
+ }
+ }
+ return result;
+ }
+ #endregion
+ #region 是否为数字型
+ ///
+ /// 是否为数字型
+ ///
+ ///
+ ///
+ /// 验证是否包含汉语
+ ///
+ ///
+ ///
+ /// 验证是否全部汉语
+ ///
+ ///
+ ///
+ /// ChineseDateTime
+ /// 一日有十二时辰，一时辰有四刻，一刻有三盏茶，一盏茶有两柱香
+ /// 一柱香有五分，一分有六弹指，一弹指有十刹那，一刹那为一念
+ ///
+ public class ChineseDateTime
+ {
+ #region ====== 内部常量 ======
+ private readonly ChineseLunisolarCalendar _chineseDateTime;
+ private readonly DateTime _dateTime;
+ private readonly int _serialMonth;
+
+ private static readonly string[] _chineseNumber = { "〇", "一", "二", "三", "四", "五", "六", "七", "八", "九" };
+ private static readonly string[] _chineseMonth =
+ {
+ "正", "二", "三", "四", "五", "六", "七", "八", "九", "十", "冬", "腊"
+ };
+ private static readonly string[] _chineseDay =
+ {
+ "初一", "初二", "初三", "初四", "初五", "初六", "初七", "初八", "初九", "初十",
+ "十一", "十二", "十三", "十四", "十五", "十六", "十七", "十八", "十九", "二十",
+ "廿一", "廿二", "廿三", "廿四", "廿五", "廿六", "廿七", "廿八", "廿九", "三十"
+ };
+ private static readonly string[] _chineseWeek =
+ {
+ "星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"
+ };
+
+ private static readonly string[] _celestialStem = { "甲", "乙", "丙", "丁", "戊", "己", "庚", "辛", "壬", "癸" };
+ private static readonly string[] _terrestrialBranch = { "子", "丑", "寅", "卯", "辰", "巳", "午", "未", "申", "酉", "戌", "亥" };
+ private static readonly string[] _chineseZodiac = { "鼠", "牛", "虎", "免", "龙", "蛇", "马", "羊", "猴", "鸡", "狗", "猪" };
+
+ private static readonly string[] _solarTerm =
+ {
+ "小寒", "大寒", "立春", "雨水", "惊蛰", "春分",
+ "清明", "谷雨", "立夏", "小满", "芒种", "夏至",
+ "小暑", "大暑", "立秋", "处暑", "白露", "秋分",
+ "寒露", "霜降", "立冬", "小雪", "大雪", "冬至"
+ };
+ private static readonly int[] _solarTermInfo = {
+ 0, 21208, 42467, 63836, 85337, 107014, 128867, 150921, 173149, 195551, 218072, 240693, 263343, 285989,
+ 308563, 331033, 353350, 375494, 397447, 419210, 440795, 462224, 483532, 504758
+ };
+ #endregion
+
+ #region ======= 构建日期 ======
+
+ public ChineseDateTime(DateTime dateTime)
+ {
+ _chineseDateTime = new ChineseLunisolarCalendar();
+ if (dateTime < _chineseDateTime.MinSupportedDateTime || dateTime > _chineseDateTime.MaxSupportedDateTime)
+ {
+ throw new ArgumentOutOfRangeException(
+ $"参数日期不在有效的范围内：只支持{_chineseDateTime.MinSupportedDateTime.ToShortTimeString()}到{_chineseDateTime.MaxSupportedDateTime}");
+ }
+
+ Year = _chineseDateTime.GetYear(dateTime);
+ Month = _chineseDateTime.GetMonth(dateTime);
+ Day = _chineseDateTime.GetDayOfMonth(dateTime);
+ IsLeep = _chineseDateTime.IsLeapMonth(Year, Month);
+ _dateTime = dateTime;
+ _serialMonth = Month;
+ var leepMonth = _chineseDateTime.GetLeapMonth(Year);
+ if (leepMonth > 0 && leepMonth <= Month) Month--;
+ }
+
+ ///
+ /// 参数为农历的年月日及是否润月
+ ///
+ ///
+ ///
+ ///
+ ///
+ public ChineseDateTime(int year, int month, int day, bool isLeap = false)
+ : this(year, month, day, 0, 0, 0, isLeap)
+ {
+
+ }
+
+ public ChineseDateTime(int year, int month, int day, int hour, int minute, int second, bool isLeap = false)
+ : this(year, month, day, hour, minute, second, 0, isLeap)
+ {
+
+ }
+
+ public ChineseDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, bool isLeap = false)
+ {
+ _chineseDateTime = new ChineseLunisolarCalendar();
+ if (year < _chineseDateTime.MinSupportedDateTime.Year || year >= _chineseDateTime.MaxSupportedDateTime.Year)
+ {
+ throw new ArgumentOutOfRangeException(
+ $"参数年份不在有效的范围内，只支持{_chineseDateTime.MinSupportedDateTime.Year}到{_chineseDateTime.MaxSupportedDateTime.Year - 1}");
+ }
+
+ if (month < 1 || month > 12) throw new ArgumentOutOfRangeException($"月份只支持1-12");
+ IsLeep = isLeap;
+ var leepMonth = _chineseDateTime.GetLeapMonth(year);
+ if (leepMonth - 1 != month)
+ IsLeep = false;
+ _serialMonth = month;
+ if (leepMonth > 0 && (month == leepMonth - 1 && isLeap || month > leepMonth - 1))
+ _serialMonth = month + 1;
+
+ if (_chineseDateTime.GetDaysInMonth(year, _serialMonth) < day || day < 1)
+ throw new ArgumentOutOfRangeException($"指定的月份天数，不在有效的范围内");
+
+ Year = year;
+ Month = month;
+ Day = day;
+ _dateTime = _chineseDateTime.ToDateTime(Year, _serialMonth, Day, hour, minute, second, millisecond);
+ }
+
+ public static ChineseDateTime Now => new ChineseDateTime(DateTime.Now);
+
+ #endregion
+
+ #region ====== 年月日润属性 ======
+ public int Year { get; }
+ public int Month { get; }
+ public int Day { get; }
+
+ ///
+ /// 是否为润月
+ ///
+ public bool IsLeep { get; }
+ #endregion
+
+ #region ====== 输出常规日期 ======
+ ///
+ /// 转换为公历
+ ///
+ ///
+ /// 短日期（农历）
+ ///
+ ///
+ /// 长日期（农历）
+ ///
+ ///
+ /// 当前节气，没有则返回空
+ ///
+ public string SolarTerm
+ {
+ get
+ {
+ var i = SolarTermFunc((x, y) => x == y, out var dt);
+ return i == -1 ? "" : _solarTerm[i];
+ }
+ }
+
+ ///
+ /// 上一个节气
+ ///
+ public string SolarTermPrev
+ {
+ get
+ {
+ var i = SolarTermFunc((x, y) => x < y, out var dt);
+ return i == -1 ? "" : _solarTerm[i];
+ }
+ }
+
+ ///
+ /// 下一个节气
+ ///
+ public string SolarTermNext
+ {
+ get
+ {
+ var i = SolarTermFunc((x, y) => x > y, out var dt);
+ return i == -1 ? "" : $"{_solarTerm[i]}";
+ }
+ }
+
+ ///
+ /// 节气计算（当前年），返回指定条件的节气序及日期（公历）
+ ///
+ ///
+ ///
+ /// -1时即没找到
+ private int SolarTermFunc(Expression> func, out DateTime dateTime)
+ {
+ var baseDateAndTime = new DateTime(1900, 1, 6, 2, 5, 0); //#1/6/1900 2:05:00 AM#
+ var year = _dateTime.Year;
+ int[] solar = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24 };
+ var expressionType = func.Body.NodeType;
+ if (expressionType != ExpressionType.LessThan && expressionType != ExpressionType.LessThanOrEqual &&
+ expressionType != ExpressionType.GreaterThan && expressionType != ExpressionType.GreaterThanOrEqual &&
+ expressionType != ExpressionType.Equal)
+ {
+ throw new NotSupportedException("不受支持的操作符");
+ }
+
+ if (expressionType == ExpressionType.LessThan || expressionType == ExpressionType.LessThanOrEqual)
+ {
+ solar = solar.OrderByDescending(x => x).ToArray();
+ }
+ foreach (var item in solar)
+ {
+ var num = 525948.76 * (year - 1900) + _solarTermInfo[item - 1];
+ var newDate = baseDateAndTime.AddMinutes(num); //按分钟计算
+ if (func.Compile()(newDate.DayOfYear, _dateTime.DayOfYear))
+ {
+ dateTime = newDate;
+ return item - 1;
+ }
+ }
+ dateTime = _chineseDateTime.MinSupportedDateTime;
+ return -1;
+ }
+ #endregion
+ }
+}
diff --git a/电子展板/Utility/Core/ConvertHelper.cs b/电子展板/Utility/Core/ConvertHelper.cs
new file mode 100644
index 0000000..5eb7881
--- /dev/null
+++ b/电子展板/Utility/Core/ConvertHelper.cs
@@ -0,0 +1,1149 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Data;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+
+namespace 电子展板.Utility.Core
+{
+ ///
+ /// 处理数据类型转换，数制转换、编码转换相关的类
+ ///
+ public static class ConvertHelper
+ {
+ public static DataTable ToDataTable(this List data)
+ {
+ PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(typeof(T));
+ DataTable dataTable = new DataTable();
+ for (int i = 0; i < properties.Count; i++)
+ {
+ PropertyDescriptor property = properties[i];
+ dataTable.Columns.Add(property.Name, Nullable.GetUnderlyingType(property.PropertyType) ?? property.PropertyType);
+ }
+ object[] values = new object[properties.Count];
+ foreach (T item in data)
+ {
+ for (int i = 0; i < values.Length; i++)
+ {
+ values[i] = properties[i].GetValue(item);
+ }
+ dataTable.Rows.Add(values);
+ }
+ return dataTable;
+ }
+
+ public static List ToList(this DataTable table)
+ {
+ if (table == null)
+ {
+ return null;
+ }
+ List rows = new List();
+ foreach (DataRow row in table.Rows)
+ {
+ rows.Add(row);
+ }
+ return rows.ToList();
+ }
+
+ public static List ToList(this List rows)
+ {
+ List list = null;
+ if (rows != null)
+ {
+ list = new List();
+
+ foreach (DataRow row in rows)
+ {
+ T item = row.ToObject();
+ list.Add(item);
+ }
+ }
+
+ return list;
+ }
+
+ public static T ToObject(this DataRow row)
+ {
+ T obj = default(T);
+ if (row != null)
+ {
+ obj = Activator.CreateInstance();
+
+ foreach (DataColumn column in row.Table.Columns)
+ {
+ PropertyInfo prop = obj.GetType().GetProperty(column.ColumnName);
+ try
+ {
+ object value = row[column.ColumnName];
+ prop.SetValue(obj, value, null);
+ }
+ catch (Exception ex)
+ { //You can log something here
+ //throw;
+ }
+ }
+ }
+ return obj;
+ }
+
+ #region 各进制数间转换
+ ///
+ /// 实现各进制数间的转换。ConvertBase("15",10,16)表示将十进制数15转换为16进制的数。
+ ///
+ /// 要转换的值,即原值
+ /// 原值的进制,只能是2,8,10,16四个值。
+ /// 要转换到的目标进制，只能是2,8,10,16四个值。
+ public static string ConvertBase(string value, int from, int to)
+ {
+ if (!isBaseNumber(from))
+ throw new ArgumentException("参数from只能是2,8,10,16四个值。");
+
+ if (!isBaseNumber(to))
+ throw new ArgumentException("参数to只能是2,8,10,16四个值。");
+
+ int intValue = Convert.ToInt32(value, from); //先转成10进制
+ string result = Convert.ToString(intValue, to); //再转成目标进制
+ if (to == 2)
+ {
+ int resultLength = result.Length; //获取二进制的长度
+ switch (resultLength)
+ {
+ case 7:
+ result = "0" + result;
+ break;
+ case 6:
+ result = "00" + result;
+ break;
+ case 5:
+ result = "000" + result;
+ break;
+ case 4:
+ result = "0000" + result;
+ break;
+ case 3:
+ result = "00000" + result;
+ break;
+ }
+ }
+ return result;
+ }
+
+ ///
+ /// 判断是否是 2 8 10 16
+ ///
+ ///
+ ///
+ /// 将string转换成byte[]。
+ ///
+ /// 要转换的字符串
+ public static byte[] StringToBytes(string text)
+ {
+ return Encoding.Default.GetBytes(text);
+ }
+
+ ///
+ /// 使用指定字符集将string转换成byte[]
+ ///
+ /// 要转换的字符串
+ /// 字符编码
+ public static byte[] StringToBytes(string text, Encoding encoding)
+ {
+ return encoding.GetBytes(text);
+ }
+
+ #endregion
+
+ #region 使用指定字符集将byte[]转换成string
+
+ ///
+ /// 将byte[]转换成string
+ ///
+ /// 要转换的字节数组
+ public static string BytesToString(byte[] bytes)
+ {
+ return Encoding.Default.GetString(bytes);
+ }
+
+ ///
+ /// 使用指定字符集将byte[]转换成string。
+ ///
+ /// 要转换的字节数组
+ /// 字符编码
+ public static string BytesToString(byte[] bytes, Encoding encoding)
+ {
+ return encoding.GetString(bytes);
+ }
+ #endregion
+
+
+ #region string转long
+ ///
+ /// string转long
+ ///
+ public static long ToInt64(this string value)
+ {
+ long? val = ToNullableInt64(value);
+ if (val == null)
+ return 0;
+ return val.Value;
+ }
+ #endregion
+
+ #region string转long?
+ ///
+ /// string转long?
+ ///
+ public static long? ToNullableInt64(this string value)
+ {
+ long? result = null;
+
+ if (!string.IsNullOrWhiteSpace(value))
+ {
+ long d;
+ if (long.TryParse(value, out d))
+ {
+ result = d;
+ }
+ }
+
+ return result;
+ }
+ #endregion
+
+ #region 将byte[]转换成int
+ ///
+ /// 将byte[]转换成int
+ ///
+ /// 需要转换成整数的byte数组
+ public static int BytesToInt32(byte[] data)
+ {
+ //如果传入的字节数组长度小于4,则返回0
+ if (data.Length < 4)
+ {
+ return 0;
+ }
+
+ //定义要返回的整数
+ int num = 0;
+
+ //如果传入的字节数组长度大于4,需要进行处理
+ if (data.Length >= 4)
+ {
+ //创建一个临时缓冲区
+ byte[] tempBuffer = new byte[4];
+
+ //将传入的字节数组的前4个字节复制到临时缓冲区
+ Buffer.BlockCopy(data, 0, tempBuffer, 0, 4);
+
+ //将临时缓冲区的值转换成整数，并赋给num
+ num = BitConverter.ToInt32(tempBuffer, 0);
+ }
+
+ //返回整数
+ return num;
+ }
+ #endregion
+
+ #region 将数据转换为整型
+ #region string转int
+ ///
+ /// string转int
+ ///
+ public static int ToInt32(this string value)
+ {
+ int? val = ToNullableInt32(value);
+ if (val == null)
+ return 0;
+ return val.Value;
+ }
+ #endregion
+ #region string转int?
+ ///
+ /// string转int?
+ ///
+ public static int? ToNullableInt32(this string value)
+ {
+ int? result = null;
+
+ if (!string.IsNullOrWhiteSpace(value))
+ {
+ int d;
+ if (int.TryParse(value, out d))
+ {
+ result = d;
+ }
+ }
+ return result;
+ }
+ #endregion
+ ///
+ /// 将数据转换为整型 转换失败返回默认值
+ ///
+ /// 数据类型
+ /// 数据
+ /// 默认值
+ /// (T data, int defValue)
+ {
+ //如果为空则返回默认值
+ if (data == null || Convert.IsDBNull(data))
+ {
+ return defValue;
+ }
+
+ try
+ {
+ return Convert.ToInt32(data);
+ }
+ catch
+ {
+ return defValue;
+ }
+
+ }
+
+ ///
+ /// 将数据转换为整型 转换失败返回默认值。
+ ///
+ /// 数据
+ /// 默认值
+ ///
+ /// 将数据转换为整型 转换失败返回默认值
+ ///
+ /// 数据
+ /// 默认值
+ ///
+ /// 将数据转换为布尔类型 转换失败返回默认值
+ ///
+ /// 数据类型
+ /// 数据
+ /// 默认值
+ /// (T data, bool defValue)
+ {
+ //如果为空则返回默认值
+ if (data == null || Convert.IsDBNull(data))
+ {
+ return defValue;
+ }
+
+ try
+ {
+ return Convert.ToBoolean(data);
+ }
+ catch
+ {
+ return defValue;
+ }
+ }
+
+ ///
+ /// 将数据转换为布尔类型 转换失败返回 默认值
+ ///
+ /// 数据
+ /// 默认值
+ ///
+ /// 将数据转换为布尔类型 转换失败返回 默认值
+ ///
+ /// 数据
+ /// 默认值
+ ///
+ /// 将数据转换为单精度浮点型 转换失败 返回默认值
+ ///
+ /// 数据类型
+ /// 数据
+ /// 默认值
+ /// (T data, float defValue)
+ {
+ //如果为空则返回默认值
+ if (data == null || Convert.IsDBNull(data))
+ {
+ return defValue;
+ }
+
+ try
+ {
+ return Convert.ToSingle(data);
+ }
+ catch
+ {
+ return defValue;
+ }
+ }
+
+ ///
+ /// 将数据转换为单精度浮点型 转换失败返回默认值
+ ///
+ /// 数据
+ /// 默认值
+ ///
+ /// 将数据转换为单精度浮点型 转换失败返回默认值
+ ///
+ /// 数据
+ /// 默认值
+ ///
+ /// string转double
+ ///
+ public static double ToDouble(this string value)
+ {
+ double? val = ToNullableDouble(value);
+ if (val == null)
+ return 0;
+ return val.Value;
+ }
+ #endregion
+
+ #region string转double?
+ ///
+ /// string转double?
+ ///
+ public static double? ToNullableDouble(this string value)
+ {
+ double? result = null;
+
+ if (!string.IsNullOrWhiteSpace(value))
+ {
+ double d;
+ if (double.TryParse(value, out d))
+ {
+ result = d;
+ }
+ }
+
+ return result;
+ }
+ #endregion
+ ///
+ /// 将数据转换为双精度浮点型 转换失败返回默认值
+ ///
+ /// 数据的类型
+ /// 要转换的数据
+ /// 默认值
+ /// (T data, double defValue)
+ {
+ //如果为空则返回默认值
+ if (data == null || Convert.IsDBNull(data))
+ {
+ return defValue;
+ }
+
+ try
+ {
+ return Convert.ToDouble(data);
+ }
+ catch
+ {
+ return defValue;
+ }
+ }
+
+ ///
+ /// 将数据转换为双精度浮点型,并设置小数位 转换失败返回默认值
+ ///
+ /// 数据的类型
+ /// 要转换的数据
+ /// 小数的位数
+ /// 默认值
+ /// (T data, int decimals, double defValue)
+ {
+ //如果为空则返回默认值
+ if (data == null || Convert.IsDBNull(data))
+ {
+ return defValue;
+ }
+
+ try
+ {
+ return Math.Round(Convert.ToDouble(data), decimals);
+ }
+ catch
+ {
+ return defValue;
+ }
+ }
+
+
+
+ ///
+ /// 将数据转换为双精度浮点型 转换失败返回默认值
+ ///
+ /// 要转换的数据
+ /// 默认值
+ ///
+ /// 将数据转换为双精度浮点型 转换失败返回默认值
+ ///
+ /// 要转换的数据
+ /// 默认值
+ ///
+ /// 将数据转换为双精度浮点型,并设置小数位 转换失败返回默认值
+ ///
+ /// 要转换的数据
+ /// 小数的位数
+ /// 默认值
+ ///
+ /// 将数据转换为双精度浮点型,并设置小数位 转换失败返回默认值
+ ///
+ /// 要转换的数据
+ /// 小数的位数
+ /// 默认值
+ ///
+ /// 将数据转换为指定类型
+ ///
+ /// 转换的数据
+ /// 转换的目标类型
+ public static object ConvertTo(object data, Type targetType)
+ {
+ if (data == null || Convert.IsDBNull(data))
+ {
+ return null;
+ }
+
+ Type type2 = data.GetType();
+ if (targetType == type2)
+ {
+ return data;
+ }
+ if (((targetType == typeof(Guid)) || (targetType == typeof(Guid?))) && (type2 == typeof(string)))
+ {
+ if (string.IsNullOrEmpty(data.ToString()))
+ {
+ return null;
+ }
+ return new Guid(data.ToString());
+ }
+
+ if (targetType.IsEnum)
+ {
+ try
+ {
+ return Enum.Parse(targetType, data.ToString(), true);
+ }
+ catch
+ {
+ return Enum.ToObject(targetType, data);
+ }
+ }
+
+ if (targetType.IsGenericType)
+ {
+ targetType = targetType.GetGenericArguments()[0];
+ }
+
+ return Convert.ChangeType(data, targetType);
+ }
+
+ ///
+ /// 将数据转换为指定类型
+ ///
+ /// 转换的目标类型
+ /// 转换的数据
+ public static T ConvertTo(object data)
+ {
+ if (data == null || Convert.IsDBNull(data))
+ return default(T);
+
+ object obj = ConvertTo(data, typeof(T));
+ if (obj == null)
+ {
+ return default(T);
+ }
+ return (T)obj;
+ }
+ #endregion
+
+ #region 将数据转换Decimal
+
+
+ #region string转decimal
+ ///
+ /// string转decimal
+ ///
+ public static decimal ToDecimal(this string value)
+ {
+ decimal? val = ToNullableDecimal(value);
+ if (null == val)
+ {
+ return 0;
+ }
+ return val.Value;
+ }
+ #endregion
+
+ #region string转decimal?
+ ///
+ /// string转decimal?
+ ///
+ public static decimal? ToNullableDecimal(this string value)
+ {
+ decimal? result = null;
+
+ if (!string.IsNullOrWhiteSpace(value))
+ {
+ decimal d;
+ if (decimal.TryParse(value, out d))
+ {
+ result = d;
+ }
+ }
+
+ return result;
+ }
+ #endregion
+ #region decimal?转decimal
+ ///
+ /// decimal?转decimal
+ ///
+ public static decimal ToDecimal(this decimal? value)
+ {
+ if (value != null) return value.Value;
+ return 0;
+ }
+ #endregion
+ ///
+ /// 将数据转换为Decimal 转换失败返回默认值
+ ///
+ /// 数据类型
+ /// 数据
+ /// 默认值
+ /// (T data, Decimal defValue)
+ {
+ //如果为空则返回默认值
+ if (data == null || Convert.IsDBNull(data))
+ {
+ return defValue;
+ }
+
+ try
+ {
+ return Convert.ToDecimal(data);
+ }
+ catch
+ {
+ return defValue;
+ }
+ }
+
+
+ ///
+ /// 将数据转换为Decimal 转换失败返回 默认值
+ ///
+ /// 数据
+ /// 默认值
+ ///
+ /// 将数据转换为Decimal 转换失败返回 默认值
+ ///
+ /// 数据
+ /// 默认值
+ ///
+ /// string转DateTime
+ ///
+ public static DateTime ToDateTime(this string value)
+ {
+ DateTime? val = ToNullableDateTime(value);
+ if (val == null)
+ return DateTime.MinValue;
+ return val.Value;
+ }
+
+ ///
+ /// string转DateTime?
+ ///
+ public static DateTime? ToNullableDateTime(this string value)
+ {
+ DateTime? result = null;
+
+ if (!string.IsNullOrWhiteSpace(value))
+ {
+ DateTime dt;
+ if (DateTime.TryParse(value, out dt))
+ {
+ result = dt;
+ }
+ }
+
+ return result;
+ }
+ ///
+ /// 将数据转换为DateTime 转换失败返回默认值
+ ///
+ /// 数据类型
+ /// 数据
+ /// 默认值
+ /// (T data, DateTime defValue)
+ {
+ //如果为空则返回默认值
+ if (data == null || Convert.IsDBNull(data))
+ {
+ return defValue;
+ }
+
+ try
+ {
+ return Convert.ToDateTime(data);
+ }
+ catch
+ {
+ return defValue;
+ }
+ }
+
+
+ ///
+ /// 将数据转换为DateTime 转换失败返回 默认值
+ ///
+ /// 数据
+ /// 默认值
+ ///
+ /// 将数据转换为DateTime 转换失败返回 默认值
+ ///
+ /// 数据
+ /// 默认值
+ ///
+ /// 转全角的函数(SBC case)
+ ///
+ /// 任意字符串
+ /// 全角字符串
+ ///
+ ///全角空格为12288，半角空格为32
+ ///其他字符半角(33-126)与全角(65281-65374)的对应关系是：均相差65248
+ ///
+ public static string ConvertToSBC(string input)
+ {
+ //半角转全角：
+ char[] c = input.ToCharArray();
+ for (int i = 0; i < c.Length; i++)
+ {
+ if (c[i] == 32)
+ {
+ c[i] = (char)12288;
+ continue;
+ }
+ if (c[i] < 127)
+ {
+ c[i] = (char)(c[i] + 65248);
+ }
+ }
+ return new string(c);
+ }
+
+
+ /// 转半角的函数(DBC case)
+ /// 任意字符串
+ /// 半角字符串
+ ///
+ ///全角空格为12288，半角空格为32
+ ///其他字符半角(33-126)与全角(65281-65374)的对应关系是：均相差65248
+ ///
+ public static string ConvertToDBC(string input)
+ {
+ char[] c = input.ToCharArray();
+ for (int i = 0; i < c.Length; i++)
+ {
+ if (c[i] == 12288)
+ {
+ c[i] = (char)32;
+ continue;
+ }
+ if (c[i] > 65280 && c[i] < 65375)
+ c[i] = (char)(c[i] - 65248);
+ }
+ return new string(c);
+ }
+ #endregion
+
+
+
+
+
+
+
+
+
+
+
+ #region object转string
+ ///
+ /// object转string
+ ///
+ public static string ToString(this object value)
+ {
+ string result = null;
+
+ if (value != null)
+ {
+ result = value.ToString();
+ }
+
+ return result;
+ }
+ #endregion
+
+
+
+
+
+
+
+ #region double?转double
+ ///
+ /// double?转double
+ ///
+ public static double ToDouble(this double? value)
+ {
+ if (value != null) return value.Value;
+ return 0;
+ }
+ #endregion
+
+ #region long?转long
+ ///
+ /// long?转long
+ ///
+ public static long ToInt64(this long? value)
+ {
+ if (value != null) return value.Value;
+ return 0;
+ }
+ #endregion
+
+ #region int?转int
+ ///
+ /// int?转int
+ ///
+ public static int ToInt32(this int? value)
+ {
+ if (value != null) return value.Value;
+ return 0;
+ }
+ #endregion
+ }
+}
diff --git a/电子展板/Utility/Core/EnumHelper.cs b/电子展板/Utility/Core/EnumHelper.cs
new file mode 100644
index 0000000..fda2e98
--- /dev/null
+++ b/电子展板/Utility/Core/EnumHelper.cs
@@ -0,0 +1,55 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Reflection;
+using System.Text;
+
+namespace 电子展板.Utility.Core
+{
+ ///
+ /// 枚举类型操作公共类。
+ ///
+ public static class EnumHelper
+ {
+ ///
+ /// 获取枚举所有成员名称。
+ ///
+ /// 枚举类型
+ public static string[] GetNames()
+ {
+ return Enum.GetNames(typeof(T));
+ }
+
+ ///
+ /// 检测枚举是否包含指定成员。
+ ///
+ /// 枚举类型
+ /// 成员名或成员值
+ public static bool IsDefined(this Enum value)
+ {
+ Type type = value.GetType();
+ return Enum.IsDefined(type, value);
+ }
+
+ ///
+ /// 返回指定枚举类型的指定值的描述。
+ ///
+ /// 枚举类型
+ /// 枚举值
+ ///
+ /// 获取格式化字符串，不带时分秒。格式："yyyy-MM-dd"
+ ///
+ /// 日期
+ public static string ToDateString(this DateTime dateTime)
+ {
+ return dateTime.ToString("yyyy-MM-dd");
+ }
+
+ ///
+ /// 获取格式化字符串，不带时分秒。格式："yyyy-MM-dd"
+ ///
+ /// 日期
+ public static string ToDateString(this DateTime? dateTime)
+ {
+ if (dateTime == null)
+ {
+ return string.Empty;
+ }
+ return ToDateString(dateTime.Value);
+ }
+
+ ///
+ /// 获取格式化字符串，不带年月日，格式："HH:mm:ss"
+ ///
+ /// 日期
+ public static string ToTimeString(this DateTime dateTime)
+ {
+ return dateTime.ToString("HH:mm:ss");
+ }
+
+ ///
+ /// 获取格式化字符串，不带年月日，格式："HH:mm:ss"
+ ///
+ /// 日期
+ public static string ToTimeString(this DateTime? dateTime)
+ {
+ if (dateTime == null)
+ {
+ return string.Empty;
+ }
+ return ToTimeString(dateTime.Value);
+ }
+
+ ///
+ /// 获取格式化字符串，带毫秒，格式："yyyy-MM-dd HH:mm:ss.fff"
+ ///
+ /// 日期
+ public static string ToMillisecondString(this DateTime dateTime)
+ {
+ return dateTime.ToString("yyyy-MM-dd HH:mm:ss.fff");
+ }
+
+ ///
+ /// 获取格式化字符串，带毫秒，格式："yyyy-MM-dd HH:mm:ss.fff"
+ ///
+ /// 日期
+ public static string ToMillisecondString(this DateTime? dateTime)
+ {
+ if (dateTime == null)
+ {
+ return string.Empty;
+ }
+ return ToMillisecondString(dateTime.Value);
+ }
+
+ ///
+ /// 获取格式化字符串，不带时分秒，格式："yyyy年MM月dd日"
+ ///
+ /// 日期
+ public static string ToChineseDateString(this DateTime dateTime)
+ {
+ return string.Format("{0}年{1}月{2}日", dateTime.Year, dateTime.Month, dateTime.Day);
+ }
+
+ ///
+ /// 获取格式化字符串，带时分秒，格式："yyyy年MM月dd日 HH时mm分"
+ ///
+ /// 日期
+ /// 是否移除秒
+ public static string ToChineseDateTimeString(this DateTime dateTime, bool isRemoveSecond = false)
+ {
+ StringBuilder result = new StringBuilder();
+ result.AppendFormat("{0}年{1}月{2}日", dateTime.Year, dateTime.Month, dateTime.Day);
+ result.AppendFormat(" {0}时{1}分", dateTime.Hour, dateTime.Minute);
+
+ if (isRemoveSecond == false)
+ {
+ result.AppendFormat("{0}秒", dateTime.Second);
+ }
+
+ return result.ToString();
+ }
+
+ ///
+ /// 获取格式化字符串，带时分秒，格式："yyyy年MM月dd日 HH时mm分"
+ ///
+ /// 日期
+ /// 是否移除秒
+ public static string ToChineseDateTimeString(this DateTime? dateTime, bool isRemoveSecond = false)
+ {
+ if (dateTime == null)
+ {
+ return string.Empty;
+ }
+
+ return ToChineseDateTimeString(dateTime.Value);
+ }
+
+ ///
+ /// 返回指定日期起始时间。
+ ///
+ ///
+ ///
+ /// 返回指定日期结束时间。
+ ///
+ ///
+ ///
+ /// 获取时间戳
+ ///
+ public static string GetTimeStamp(DateTime dateTime)
+ {
+ DateTime dtStart = new DateTime(1970, 1, 1, 8, 0, 0);
+ return Convert.ToInt64(dateTime.Subtract(dtStart).TotalMilliseconds).ToString();
+ }
+ #endregion
+
+ #region 根据时间戳获取时间
+ ///
+ /// 根据时间戳获取时间
+ ///
+ public static DateTime TimeStampToDateTime(string timeStamp)
+ {
+ DateTime dtStart = new DateTime(1970, 1, 1, 8, 0, 0);
+ return dtStart.AddMilliseconds(Convert.ToInt64(timeStamp));
+ }
+ #endregion
+
+ #region 本周开始时间
+ ///
+ /// 本周开始时间
+ ///
+ public static DateTime GetCurrentWeekStart()
+ {
+ DateTime now = DateTime.Now;
+ int day = Convert.ToInt32(now.DayOfWeek.ToString("d"));
+ return now.AddDays(1 - day).Date;
+ }
+ #endregion
+
+ #region 本周结束时间
+ ///
+ /// 本周结束时间
+ ///
+ public static DateTime GetCurrentWeekEnd()
+ {
+ return GetCurrentWeekStart().AddDays(7).AddSeconds(-1);
+ }
+ #endregion
+
+ #region 本月开始时间
+ ///
+ /// 本月开始时间
+ ///
+ public static DateTime GetCurrentMonthStart()
+ {
+ DateTime now = DateTime.Now;
+ return now.AddDays(1 - now.Day).Date;
+ }
+ #endregion
+
+ #region 本月结束时间
+ ///
+ /// 本月结束时间
+ ///
+ public static DateTime GetCurrentMonthEnd()
+ {
+ return GetCurrentWeekStart().AddMonths(1).AddSeconds(-1);
+ }
+ #endregion
+
+ #region 本季度开始时间
+ ///
+ /// 本季度开始时间
+ ///
+ public static DateTime GetCurrentQuarterStart()
+ {
+ DateTime now = DateTime.Now;
+ return now.AddMonths(0 - (now.Month - 1) % 3).AddDays(1 - now.Day).Date;
+ }
+ #endregion
+
+ #region 本季度结束时间
+ ///
+ /// 本季度结束时间
+ ///
+ public static DateTime GetCurrentQuarterthEnd()
+ {
+ return GetCurrentWeekStart().AddMonths(3).AddSeconds(-1);
+ }
+ #endregion
+
+ #region 本年开始时间
+ ///
+ /// 本年开始时间
+ ///
+ public static DateTime GetCurrentYearStart()
+ {
+ return new DateTime(DateTime.Now.Year, 1, 1);
+ }
+ #endregion
+
+ #region 本年结束时间
+ ///
+ /// 本年结束时间
+ ///
+ public static DateTime GetCurrentYearEnd()
+ {
+ return new DateTime(DateTime.Now.Year, 12, 31, 23, 59, 59);
+ }
+ #endregion
+
+ }
+}
diff --git a/电子展板/Utility/Core/JsonHelper.cs b/电子展板/Utility/Core/JsonHelper.cs
new file mode 100644
index 0000000..aaf8ac6
--- /dev/null
+++ b/电子展板/Utility/Core/JsonHelper.cs
@@ -0,0 +1,59 @@
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+using System.Collections.Generic;
+using System.Data;
+
+namespace 电子展板.Utility.Core
+{
+ public static class JsonHelper
+ {
+ ///
+ /// 对象序列化成JSON字符串。
+ ///
+ /// 序列化对象
+ /// 设置需要忽略的属性
+ ///
+ /// JSON字符串序列化成对象。
+ ///
+ /// 对象类型
+ /// JSON字符串
+ /// (this string json)
+ {
+ return json.IsNullOrEmpty() ? default(T) : JsonConvert.DeserializeObject(json);
+ }
+
+
+ ///
+ /// JSON字符串序列化成集合。
+ ///
+ /// 集合类型
+ /// JSON字符串
+ /// ToList(this string json)
+ {
+ return json.IsNullOrEmpty() ? null : JsonConvert.DeserializeObject>(json);
+ }
+
+
+ ///
+ /// JSON字符串序列化成DataTable。
+ ///
+ /// JSON字符串
+ /// (json);
+ }
+ }
+}
diff --git a/电子展板/Utility/Core/LinqExtension.cs b/电子展板/Utility/Core/LinqExtension.cs
new file mode 100644
index 0000000..c3d2b26
--- /dev/null
+++ b/电子展板/Utility/Core/LinqExtension.cs
@@ -0,0 +1,255 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Text;
+
+namespace 电子展板.Utility.Core
+{
+ ///
+ /// LINQ扩展方法
+ ///
+ public static class LinqExtension
+ {
+ ///
+ /// 与连接
+ ///
+ /// 类型
+ /// 左条件
+ /// 右条件
+ /// 新表达式
+ public static Expression> And(this Expression> left, Expression> right)
+ {
+ return CombineLambdas(left, right, ExpressionType.AndAlso);
+ }
+
+ ///
+ /// 或连接
+ ///
+ /// 类型
+ /// 左条件
+ /// 右条件
+ /// 新表达式
+ public static Expression> Or(this Expression> left, Expression> right)
+ {
+ return CombineLambdas(left, right, ExpressionType.OrElse);
+ }
+
+ private static Expression> CombineLambdas(this Expression> left, Expression> right, ExpressionType expressionType)
+ {
+ var visitor = new SubstituteParameterVisitor
+ {
+ Sub =
+ {
+ [right.Parameters[0]] = left.Parameters[0]
+ }
+ };
+
+ Expression body = Expression.MakeBinary(expressionType, left.Body, visitor.Visit(right.Body));
+ return Expression.Lambda>(body, left.Parameters[0]);
+ }
+
+ ///
+ /// 取最大值
+ ///
+ /// (this IQueryable source, Expression> selector) => source.Select(selector).OrderByDescending(_ => _).FirstOrDefault();
+
+ ///
+ /// 取最大值
+ ///
+ /// (this IQueryable source, Expression> selector, TResult defaultValue)
+ {
+ TResult result = source.Select(selector).OrderByDescending(_ => _).FirstOrDefault();
+ if (result != null)
+ return result;
+ return defaultValue;
+ }
+
+ ///
+ /// 取最大值
+ ///
+ /// (this IQueryable source)
+ {
+ return source.OrderByDescending(_ => _).FirstOrDefault();
+ }
+
+ ///
+ /// 取最大值
+ ///
+ /// (this IQueryable source, TSource defaultValue)
+ {
+ TSource result = source.OrderByDescending(_ => _).FirstOrDefault();
+ if (result != null)
+ return result;
+ return defaultValue;
+ }
+
+ ///
+ /// 取最大值
+ ///
+ /// (this IEnumerable source, Func selector, TResult defaultValue)
+ {
+ TResult result = source.Select(selector).OrderByDescending(_ => _).FirstOrDefault();
+ if (result != null)
+ return result;
+ return defaultValue;
+ }
+
+ ///
+ /// 取最大值
+ ///
+ /// (this IEnumerable source) => source.OrderByDescending(_ => _).FirstOrDefault();
+
+ ///
+ /// 取最大值
+ ///
+ /// (this IEnumerable source, TSource defaultValue)
+ {
+ TSource result = source.OrderByDescending(_ => _).FirstOrDefault();
+ if (result != null)
+ return result;
+ return defaultValue;
+ }
+
+ ///
+ /// 取最小值
+ ///
+ /// (this IQueryable source, Expression> selector) => source.Select(selector).OrderBy(_ => _).FirstOrDefault();
+
+ ///
+ /// 取最小值
+ ///
+ /// (this IQueryable source, Expression> selector, TResult defaultValue)
+ {
+ TResult result = source.Select(selector).OrderBy(_ => _).FirstOrDefault();
+ if (result != null)
+ return result;
+ return defaultValue;
+ }
+
+ ///
+ /// 取最小值
+ ///
+ /// (this IQueryable source) => source.OrderBy(_ => _).FirstOrDefault();
+
+ ///
+ /// 取最小值
+ ///
+ /// (this IQueryable source, TSource defaultValue)
+ {
+ TSource result = source.OrderBy(_ => _).FirstOrDefault();
+ if (result != null)
+ return result;
+ return defaultValue;
+ }
+
+ ///
+ /// 取最小值
+ ///
+ /// (this IEnumerable source, Func selector) => source.Select(selector).OrderBy(_ => _).FirstOrDefault();
+
+ ///
+ /// 取最小值
+ ///
+ /// (this IEnumerable source, Func selector, TResult defaultValue)
+ {
+ TResult result = source.Select(selector).OrderBy(_ => _).FirstOrDefault();
+ if (result != null)
+ return result;
+ return defaultValue;
+ }
+
+ ///
+ /// 取最小值
+ ///
+ /// (this IEnumerable source) => source.OrderBy(_ => _).FirstOrDefault();
+
+ ///
+ /// 取最小值
+ ///
+ /// (this IEnumerable source, TSource defaultValue)
+ {
+ TSource result = source.OrderBy(_ => _).FirstOrDefault();
+ if (result != null)
+ return result;
+ return defaultValue;
+ }
+ }
+
+ internal class SubstituteParameterVisitor : ExpressionVisitor
+ {
+ public Dictionary Sub = new Dictionary();
+
+ protected override Expression VisitParameter(ParameterExpression node)
+ {
+ return Sub.TryGetValue(node, out var newValue) ? newValue : node;
+ }
+ }
+}
diff --git a/电子展板/Utility/Core/RMB.cs b/电子展板/Utility/Core/RMB.cs
new file mode 100644
index 0000000..ca22740
--- /dev/null
+++ b/电子展板/Utility/Core/RMB.cs
@@ -0,0 +1,163 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace 电子展板.Utility.Core
+{
+ public static class RMB
+ {///
+ /// 转换人民币大小金额
+ ///
+ /// 金额
+ /// 返回大写形式
+ public static string ToRMB(this decimal num)
+ {
+ string str1 = "零壹贰叁肆伍陆柒捌玖"; //0-9所对应的汉字
+ string str2 = "万仟佰拾亿仟佰拾万仟佰拾元角分"; //数字位所对应的汉字
+ string str3 = ""; //从原num值中取出的值
+ string str4 = ""; //数字的字符串形式
+ string str5 = ""; //人民币大写金额形式
+ int i; //循环变量
+ int j; //num的值乘以100的字符串长度
+ string ch1 = ""; //数字的汉语读法
+ string ch2 = ""; //数字位的汉字读法
+ int nzero = 0; //用来计算连续的零值是几个
+ int temp; //从原num值中取出的值
+
+ num = Math.Round(Math.Abs(num), 2); //将num取绝对值并四舍五入取2位小数
+ str4 = ((long)(num * 100)).ToString(); //将num乘100并转换成字符串形式
+ j = str4.Length; //找出最高位
+ if (j > 15) { return "溢出"; }
+ str2 = str2.Substring(15 - j); //取出对应位数的str2的值。如：200.55,j为5所以str2=佰拾元角分
+
+ //循环取出每一位需要转换的值
+ for (i = 0; i < j; i++)
+ {
+ str3 = str4.Substring(i, 1); //取出需转换的某一位的值
+ temp = Convert.ToInt32(str3); //转换为数字
+ if (i != (j - 3) && i != (j - 7) && i != (j - 11) && i != (j - 15))
+ {
+ //当所取位数不为元、万、亿、万亿上的数字时
+ if (str3 == "0")
+ {
+ ch1 = "";
+ ch2 = "";
+ nzero = nzero + 1;
+ }
+ else
+ {
+ if (str3 != "0" && nzero != 0)
+ {
+ ch1 = "零" + str1.Substring(temp * 1, 1);
+ ch2 = str2.Substring(i, 1);
+ nzero = 0;
+ }
+ else
+ {
+ ch1 = str1.Substring(temp * 1, 1);
+ ch2 = str2.Substring(i, 1);
+ nzero = 0;
+ }
+ }
+ }
+ else
+ {
+ //该位是万亿，亿，万，元位等关键位
+ if (str3 != "0" && nzero != 0)
+ {
+ ch1 = "零" + str1.Substring(temp * 1, 1);
+ ch2 = str2.Substring(i, 1);
+ nzero = 0;
+ }
+ else
+ {
+ if (str3 != "0" && nzero == 0)
+ {
+ ch1 = str1.Substring(temp * 1, 1);
+ ch2 = str2.Substring(i, 1);
+ nzero = 0;
+ }
+ else
+ {
+ if (str3 == "0" && nzero >= 3)
+ {
+ ch1 = "";
+ ch2 = "";
+ nzero = nzero + 1;
+ }
+ else
+ {
+ if (j >= 11)
+ {
+ ch1 = "";
+ nzero = nzero + 1;
+ }
+ else
+ {
+ ch1 = "";
+ ch2 = str2.Substring(i, 1);
+ nzero = nzero + 1;
+ }
+ }
+ }
+ }
+ }
+ if (i == (j - 11) || i == (j - 3))
+ {
+ //如果该位是亿位或元位，则必须写上
+ ch2 = str2.Substring(i, 1);
+ }
+ str5 = str5 + ch1 + ch2;
+
+ if (i == j - 1 && str3 == "0")
+ {
+ //最后一位（分）为0时，加上“整”
+ str5 = str5 + '整';
+ }
+ }
+ if (num == 0)
+ {
+ str5 = "零元整";
+ }
+ return str5;
+ }
+
+ public static string ToRMB(this int num)
+ {
+ return ToRMB(Convert.ToString(num));
+ }
+
+ public static string ToRMB(this float num)
+ {
+ return ToRMB(Convert.ToString(num));
+ }
+
+ public static string ToRMB(this double num)
+ {
+ return ToRMB(Convert.ToString(num));
+ }
+
+ public static string ToRMB(this long num)
+ {
+ return ToRMB(Convert.ToString(num));
+ }
+ ///
+ /// 一个重载，将字符串先转换成数字在调用CmycurD(decimal num)
+ ///
+ /// 用户输入的金额，字符串形式未转成decimal
+ ///
+ /// 使用Random类生成伪随机数
+ ///
+ public static class RandomHelper
+ {
+
+ ///
+ /// 生成一个指定范围的随机整数，该随机数范围包括最小值，但不包括最大值
+ ///
+ /// 最小值
+ /// 最大值
+ public static int GetRandomInt(int minNum, int maxNum)
+ {
+ return new Random().Next(minNum, maxNum);
+ }
+
+ ///
+ /// 生成一个0.0到1.0的随机小数
+ ///
+ public static double GetRandomDouble()
+ {
+ return new Random().NextDouble();
+ }
+
+ ///
+ /// 对一个数组进行随机排序
+ ///
+ /// 数组的类型
+ /// 需要随机排序的数组
+ public static void GetRandomArray(T[] arr)
+ {
+ //对数组进行随机排序的算法:随机选择两个位置，将两个位置上的值交换
+
+ //交换的次数,这里使用数组的长度作为交换次数
+ int count = arr.Length;
+
+ //开始交换
+ for (int i = 0; i < count; i++)
+ {
+ //生成两个随机数位置
+ int targetIndex1 = GetRandomInt(0, arr.Length);
+ int targetIndex2 = GetRandomInt(0, arr.Length);
+
+ //定义临时变量
+ T temp;
+
+ //交换两个随机数位置的值
+ temp = arr[targetIndex1];
+ arr[targetIndex1] = arr[targetIndex2];
+ arr[targetIndex2] = temp;
+ }
+ }
+ }
+}
diff --git a/电子展板/Utility/Core/RegexHelper.cs b/电子展板/Utility/Core/RegexHelper.cs
new file mode 100644
index 0000000..32c4803
--- /dev/null
+++ b/电子展板/Utility/Core/RegexHelper.cs
@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+
+namespace 电子展板.Utility.Core
+{
+ ///
+ /// 操作正则表达式的公共类
+ ///
+ public class RegexHelper
+ {
+ ///
+ /// 验证输入字符串是否与模式字符串匹配，匹配返回true
+ ///
+ /// 输入字符串
+ /// 模式字符串
+ public static bool IsMatch(string input, string pattern)
+ {
+ return IsMatch(input, pattern, RegexOptions.IgnoreCase);
+ }
+
+ ///
+ /// 验证输入字符串是否与模式字符串匹配，匹配返回true
+ ///
+ /// 输入的字符串
+ /// 模式字符串
+ /// 筛选条件
+ public static bool IsMatch(string input, string pattern, RegexOptions options)
+ {
+ return Regex.IsMatch(input, pattern, options);
+ }
+ }
+}
diff --git a/电子展板/Utility/Core/RegisterHelper.cs b/电子展板/Utility/Core/RegisterHelper.cs
new file mode 100644
index 0000000..1f145c7
--- /dev/null
+++ b/电子展板/Utility/Core/RegisterHelper.cs
@@ -0,0 +1,279 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.Win32;
+using System.Reflection;
+
+namespace 电子展板.Utility.Core
+{
+#if NETFRAMEWORK
+ ///
+ /// 注册表辅助类
+ ///
+ public class RegisterHelper
+ {
+ ///
+ /// 默认注册表基项
+ ///
+ private string baseKey = "Software";
+
+ #region 构造函数
+ ///
+ /// 构造函数
+ ///
+ /// 基项的名称
+ public RegisterHelper()
+ {
+
+ }
+
+ ///
+ /// 构造函数
+ ///
+ /// 基项的名称
+ public RegisterHelper(string baseKey)
+ {
+ this.baseKey = baseKey;
+
+ }
+ #endregion
+
+ #region 公共方法
+
+ ///
+ /// 写入注册表,如果指定项已经存在,则修改指定项的值
+ ///
+ /// 注册表基项枚举
+ /// 注册表项,不包括基项
+ /// 值名称
+ /// 值
+ public void SetValue(KeyType keytype, string key, string name, string values)
+ {
+
+ RegistryKey rk = (RegistryKey)GetRegistryKey(keytype);
+ RegistryKey software = rk.OpenSubKey(baseKey, true);
+ RegistryKey rkt = software.CreateSubKey(key);
+ if (rkt != null)
+ {
+ rkt.SetValue(name, values);
+ }
+ }
+
+
+ ///
+ /// 读取注册表
+ ///
+ /// 注册表基项枚举
+ /// 注册表项,不包括基项
+ /// 值名称
+ /// 返回字符串
+ public string GetValue(KeyType keytype, string key, string name)
+ {
+ RegistryKey rk = (RegistryKey)GetRegistryKey(keytype);
+ RegistryKey software = rk.OpenSubKey(baseKey, true);
+ RegistryKey rkt = software.OpenSubKey(key);
+
+ if (rkt != null)
+ {
+ return rkt.GetValue(name).ToString();
+ }
+ else
+ {
+ return string.Empty;
+ }
+ }
+
+
+ ///
+ /// 删除注册表中的值
+ ///
+ /// 注册表基项枚举
+ /// 注册表项名称,不包括基项
+ /// 值名称
+ public void DeleteValue(KeyType keytype, string key, string name)
+ {
+ RegistryKey rk = (RegistryKey)GetRegistryKey(keytype);
+ RegistryKey software = rk.OpenSubKey(baseKey, true);
+ RegistryKey rkt = software.OpenSubKey(key, true);
+
+ if (rkt != null)
+ {
+ object value = rkt.GetValue(name);
+ if (value != null)
+ {
+ rkt.DeleteValue(name, true);
+ }
+ }
+ }
+
+
+ ///
+ /// 删除注册表中的指定项
+ ///
+ /// 注册表基项枚举
+ /// 注册表中的项,不包括基项
+ /// 返回布尔值,指定操作是否成功
+ public void DeleteSubKey(KeyType keytype, string key)
+ {
+ RegistryKey rk = (RegistryKey)GetRegistryKey(keytype);
+ RegistryKey software = rk.OpenSubKey(baseKey, true);
+ if (software != null)
+ {
+ software.DeleteSubKeyTree(key);
+ }
+ }
+
+
+ ///
+ /// 判断指定项是否存在
+ ///
+ /// 基项枚举
+ /// 指定项字符串
+ /// 返回布尔值,说明指定项是否存在
+ public bool IsExist(KeyType keytype, string key)
+ {
+ RegistryKey rk = (RegistryKey)GetRegistryKey(keytype);
+ RegistryKey software = rk.OpenSubKey(baseKey);
+ RegistryKey rkt = software.OpenSubKey(key);
+ if (rkt != null)
+ {
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+ }
+
+
+ ///
+ /// 检索指定项关联的所有值
+ ///
+ /// 基项枚举
+ /// 指定项字符串
+ /// 返回指定项关联的所有值的字符串数组
+ public string[] GetValues(KeyType keytype, string key)
+ {
+ RegistryKey rk = (RegistryKey)GetRegistryKey(keytype);
+ RegistryKey software = rk.OpenSubKey(baseKey, true);
+ RegistryKey rkt = software.OpenSubKey(key);
+ string[] names = rkt.GetValueNames();
+
+ if (names.Length == 0)
+ {
+ return names;
+ }
+ else
+ {
+ string[] values = new string[names.Length];
+
+ int i = 0;
+
+ foreach (string name in names)
+ {
+ values[i] = rkt.GetValue(name).ToString();
+
+ i++;
+ }
+
+ return values;
+ }
+
+ }
+
+ ///
+ /// 将对象所有属性写入指定注册表中
+ ///
+ /// 注册表基项枚举
+ /// 注册表项,不包括基项
+ /// 传入的对象
+ public void SetObjectValue(KeyType keyType, string key, Object obj)
+ {
+ if (obj != null)
+ {
+ Type t = obj.GetType();
+
+ string name;
+ object value;
+ foreach (var p in t.GetProperties())
+ {
+ if (p != null)
+ {
+ name = p.Name;
+ value = p.GetValue(obj, null);
+ this.SetValue(keyType, key, name, value.ToString());
+ }
+ }
+ }
+ }
+
+ #endregion
+
+ #region 私有方法
+
+ ///
+ /// 返回RegistryKey对象
+ ///
+ /// 注册表基项枚举
+ ///
+ /// 注册表基项枚举
+ ///
+ public enum KeyType : int
+ {
+ ///
+ /// 注册表基项 HKEY_CLASSES_ROOT
+ ///
+ HKEY_CLASS_ROOT,
+ ///
+ /// 注册表基项 HKEY_CURRENT_USER
+ ///
+ HKEY_CURRENT_USER,
+ ///
+ /// 注册表基项 HKEY_LOCAL_MACHINE
+ ///
+ HKEY_LOCAL_MACHINE,
+ ///
+ /// 注册表基项 HKEY_USERS
+ ///
+ HKEY_USERS,
+ ///
+ /// 注册表基项 HKEY_CURRENT_CONFIG
+ ///
+ HKEY_CURRENT_CONFIG
+ }
+ #endregion
+
+ }
+#endif
+}
diff --git a/电子展板/Utility/Core/StringHelper.cs b/电子展板/Utility/Core/StringHelper.cs
new file mode 100644
index 0000000..587bec3
--- /dev/null
+++ b/电子展板/Utility/Core/StringHelper.cs
@@ -0,0 +1,316 @@
+
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+
+namespace 电子展板.Utility.Core
+{
+ ///
+ /// 字符串操作类
+ ///
+ public static class StringHelper
+ {
+ ///
+ /// 把字符串按照分隔符转换成 List
+ ///
+ /// 源字符串
+ /// 分隔符
+ /// 是否转换为小写
+ /// SplitToList(this string str, char speater = ',', bool toLower = false)
+ {
+ List list = new List();
+ string[] ss = str.Split(speater);
+ foreach (string s in ss)
+ {
+ if (!string.IsNullOrEmpty(s) && s != speater.ToString())
+ {
+ string strVal = s;
+ if (toLower)
+ {
+ strVal = s.ToLower();
+ }
+ list.Add(strVal);
+ }
+ }
+ return list;
+ }
+
+ ///
+ /// 把 List 按照分隔符组装成 string
+ ///
+ ///
+ ///
+ /// list, string speater = ",")
+ {
+ StringBuilder sb = new StringBuilder();
+ for (int i = 0; i < list.Count; i++)
+ {
+ if (i == list.Count - 1)
+ {
+ sb.Append(list[i]);
+ }
+ else
+ {
+ sb.Append(list[i]);
+ sb.Append(speater);
+ }
+ }
+ return sb.ToString();
+ }
+
+
+ ///
+ /// 删除最后结尾的指定字符后的字符
+ ///
+ public static string DelLastChar(this string str, string strChar = ",")
+ {
+ return str.Substring(0, str.LastIndexOf(strChar));
+ }
+
+
+ ///
+ /// 转全角的函数(SBC case)
+ ///
+ ///
+ ///
+ /// 转半角的函数(SBC case)
+ ///
+ /// 输入
+ ///
+ /// 获取正确的Id，如果不是正整数，返回0
+ ///
+ ///
+ /// 返回正确的整数ID，失败返回0
+ public static int ToInt32(this string value)
+ {
+ if (IsNumberId(value))
+ return int.Parse(value);
+ else
+ return 0;
+ }
+
+ ///
+ /// 检查一个字符串是否是纯数字构成的，一般用于查询字符串参数的有效性验证。(0除外)
+ ///
+ /// 需验证的字符串。。
+ /// 是否合法的bool值。
+ public static bool IsNumberId(string _value)
+ {
+ return QuickValidate("^[1-9]*[0-9]*$", _value);
+ }
+
+ ///
+ /// 快速验证一个字符串是否符合指定的正则表达式。
+ ///
+ /// 正则表达式的内容。
+ /// 需验证的字符串。
+ /// 是否合法的bool值。
+ public static bool QuickValidate(string _express, string _value)
+ {
+ if (_value == null) return false;
+ Regex myRegex = new Regex(_express);
+ if (_value.Length == 0)
+ {
+ return false;
+ }
+ return myRegex.IsMatch(_value);
+ }
+ ///
+ /// 得到字符串长度，一个汉字长度为2
+ ///
+ /// 参数字符串
+ ///
+ /// 截取指定长度字符串
+ ///
+ /// 要处理的字符串
+ /// 指定长度
+ /// 返回处理后的字符串
+ public static string splitString(this string inputString, int len)
+ {
+ bool isShowFix = false;
+ if (len % 2 == 1)
+ {
+ isShowFix = true;
+ len--;
+ }
+ System.Text.ASCIIEncoding ascii = new System.Text.ASCIIEncoding();
+ int tempLen = 0;
+ string tempString = "";
+ byte[] s = ascii.GetBytes(inputString);
+ for (int i = 0; i < s.Length; i++)
+ {
+ if ((int)s[i] == 63)
+ tempLen += 2;
+ else
+ tempLen += 1;
+
+ try
+ {
+ tempString += inputString.Substring(i, 1);
+ }
+ catch
+ {
+ break;
+ }
+
+ if (tempLen > len)
+ break;
+ }
+
+ byte[] mybyte = System.Text.Encoding.Default.GetBytes(inputString);
+ if (isShowFix && mybyte.Length > len)
+ tempString += "…";
+ return tempString;
+ }
+
+
+ ///
+ /// HTML转行成TEXT
+ ///
+ ///
+ /// ]*?>.*?",
+ @"<(\/\s*)?!?((\w+:)?\w+)(\w+(\s*=?\s*(([""'])(\\[""'tbnr]|[^\7])*?\7|\w+)|.{0})|\s)*?(\/\s*)?>",
+ @"([\r\n])[\s]+",
+ @"&(quot|#34);",
+ @"&(amp|#38);",
+ @"&(lt|#60);",
+ @"&(gt|#62);",
+ @"&(nbsp|#160);",
+ @"&(iexcl|#161);",
+ @"&(cent|#162);",
+ @"&(pound|#163);",
+ @"&(copy|#169);",
+ @"&#(\d+);",
+ @"-->",
+ @"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/电子展板/favicon.ico b/电子展板/favicon.ico
new file mode 100644
index 0000000..d71d1a5
Binary files /dev/null and b/电子展板/favicon.ico differ
diff --git a/电子展板/电子展板.csproj b/电子展板/电子展板.csproj
new file mode 100644
index 0000000..4784606
--- /dev/null
+++ b/电子展板/电子展板.csproj
@@ -0,0 +1,54 @@
+
+
+
+ WinExe
+ net472
+ true
+ 1.0.1
+ favicon.ico
+ app.manifest
+
+
+
+ PreserveNewest
+
+
+
+
+ all
+ runtime; build; native; contentfiles; analyzers; buildtransitive
+
+
+
+
+
+
+
+
+
+
+
+
+
'),u=x(''),l.id&&E.attr("id",l.id),E.addClass(l.className),C.attr("lay-filter",M),layui.each(f,function(e,t){var a=x('');0===e&&a.addClass("layui-this"),a.html(l.text[t]),r.append(a)}),x.extend(c,{full:{className:"screen-full",title:["\u6700\u5927\u5316\u663e\u793a","\u8fd8\u539f\u663e\u793a"],event:function(e){var e=e.elem,t=e.closest("."+A.ELEM_PREVIEW),a="layui-icon-"+this.className,i="layui-icon-screen-restore",l=this.title,o=x("html,body"),n="layui-scrollbar-hide";e.hasClass(a)?(t.addClass(A.ELEM_FULL),e.removeClass(a).addClass(i),e.attr("title",l[1]),o.addClass(n)):(t.removeClass(A.ELEM_FULL),e.removeClass(i).addClass(a),e.attr("title",l[0]),o.removeClass(n))}},window:{className:"release",title:["\u5728\u65b0\u7a97\u53e3\u9884\u89c8"],event:function(e){D.openWin({content:n(l.code)})}}}),l.copy&&("array"===layui.type(l.tools)?-1===l.tools.indexOf("copy")&&l.tools.unshift("copy"):l.tools=["copy"]),u.on("click",">i",function(){var e=x(this),t=e.data("type"),e={elem:e,type:t,options:l,rawCode:l.code,finalCode:D.unescape(n(l.code))};c[t]&&"function"==typeof c[t].event&&c[t].event(e),"function"==typeof l.toolsEvent&&l.toolsEvent(e)}),l.addTools&&l.tools&&(l.tools=[].concat(l.tools,l.addTools)),layui.each(l.tools,function(e,t){var a="object"==typeof t,i=a?t:c[t]||{className:t,title:[t]},l=i.className||i.type,o=i.title||[""],a=a?i.type||l:t;a&&(c[a]||((t={})[a]=i,x.extend(c,t)),u.append(''))}),o.addClass(A.ELEM_ITEM).wrap(E),C.append(r),l.tools&&C.append(u),o.before(C),s&&_.html(''),y=function(e){var t=e.children("iframe")[0];s&&t?t.srcdoc=n(l.code):e.html(l.code),setTimeout(function(){"function"==typeof l.done&&l.done({container:e,options:l,render:function(){N.render(e.find(".layui-form")),S.render(),I.render({elem:["."+A.ELEM_PREVIEW,".layui-tabs"].join(" ")})}})},3)},"preview"===f[0]?(_.addClass(A.ELEM_SHOW),o.before(_),y(_)):o.addClass(A.ELEM_SHOW).after(_),l.previewStyle=[l.style,l.previewStyle].join(""),_.attr("style",l.previewStyle),S.on("tab("+M+")",function(e){var t=x(this),a=x(e.elem).closest("."+A.ELEM_PREVIEW).find("."+A.ELEM_ITEM),e=a.eq(e.index);a.removeClass(A.ELEM_SHOW),e.addClass(A.ELEM_SHOW),"preview"===t.attr("lay-id")&&y(e),L()})),p=x('
')).html(l.title||l.text.code),o.prepend(_)),M=x(''),l.copy&&!l.preview&&((C=x(['','',""].join(""))).on("click",function(){c.copy.event()}),M.append(C)),l.langMarker&&M.append(''+l.lang+""),l.about&&M.append(l.about),o.append(M),l.preview||setTimeout(function(){"function"==typeof l.done&&l.done({})},3),l.elem.length===1+d&&"function"==typeof l.allDone&&l.allDone())),g})}),layui["layui.all"]||layui.addcss("modules/code.css?v=6","skincodecss");
\ No newline at end of file
diff --git a/电子展板/Configs/NLog.config b/电子展板/Configs/NLog.config
new file mode 100644
index 0000000..893626a
--- /dev/null
+++ b/电子展板/Configs/NLog.config
@@ -0,0 +1,95 @@
+
+