☰

wLib

A library for WME script developers.

当前为 2016-02-05 提交的版本，查看 最新版本。

此脚本不应直接安装。它是供其他脚本使用的外部库，要使用该库请加入元指令 // @require https://update.gf.qytechs.cn/scripts/9794/105726/wLib.js 

  1. // ==UserScript==
  2. // @name            wLib
  3. // @description     A library for WME script developers.
  4. // @version         1.0.5
  5. // @author          SAR85
  6. // @copyright       SAR85
  7. // @license         CC BY-NC-ND
  8. // @grant           none
  9. // @include         https://www.waze.com/editor/*
  10. // @include         https://www.waze.com/*/editor/*
  11. // @include         https://editor-beta.waze.com/*
  12. // @namespace       https://gf.qytechs.cn/users/9321
  13. // ==/UserScript==
  14.  
  15. /* global W */
  16. /* global OL */
  17. /* global wLib */
  18.  
  19. (function ($, Backbone, _) {
  20.     /**
  21.      * The wLib namespace.
  22.      * @namespace {Object} wLib
  23.      * @global
  24.      */
  25.     var wLib = {};
  26.     
  27.     /**
  28.      * The current version.
  29.      */
  30.     wLib.VERSION = '1.0.5';
  31.     
  32.     /**
  33. 	 * Namespace for functions related to geometry.
  34.      * @namespace {Object} wLib.Geometry
  35. 	 */
  36.     wLib.Geometry = {};
  37.     /**
  38. 	 * Namespace for functions related to the model.
  39. 	 * @namespace {Object} wLib.Model
  40. 	 */
  41.     wLib.Model = {};
  42.     /**
  43. 	 * Namespace for functions related to the WME interface
  44. 	 * @namespace {Obect} wLib.Interface
  45. 	 */
  46.     wLib.Interface = {};
  47.     /**
  48.      * Namespace for utility functions.
  49.      * @namespace {Object} wLib.Util
  50.      */
  51.     wLib.Util = {};
  52.     /**
  53.      * Namespace for functions related to WME actions.
  54.      * @namespace {Object} wLib.api
  55.      */
  56.     wLib.api = {};
  57.  
  58.     this.wLib = wLib;
  59.  
  60. } (jQuery, Backbone, _));
  61.  
  62. /*** GEOMETRY ***/
  63. (function () {
  64.     /**
  65.     * Determines if an {OpenLayers.Geometry} is within the map view.
  66.     * @function wLib.Geometry.isGeometryInMapExtent
  67.     * @param geometry {OpenLayers.Geometry}
  68.     * @return {Boolean} Whether or not the geometry is in the map extent.
  69.     */
  70.     this.isGeometryInMapExtent = function (geometry) {
  71.         'use strict';
  72.         return geometry && geometry.getBounds &&
  73.             W.map.getExtent().intersectsBounds(geometry.getBounds());
  74.     };
  75.         
  76.     /**
  77.      * Determines if an {OpenLayers.LonLat} is within the map view.
  78.      * @function wLib.Geometry.isLonLatInMapExtent
  79.      * @param {OpenLayers.LonLat} lonlat
  80.      * @return {Boolean} Whether or not the LonLat is in the map extent.
  81.      */
  82.     this.isLonLatInMapExtent = function (lonlat) {
  83.         'use strict';
  84.         return lonlat && W.map.getExtent().containsLonLat(lonlat);
  85.     };
  86. }).call(wLib.Geometry);
  87.  
  88. /*** MODEL ***/
  89. (function () {
  90. 	/**
  91. 	* Gets the IDs of any selected segments.
  92. 	* @function wLib.Model.getSelectedSegmentIDs
  93. 	* @return {Array} Array containing the IDs of selected segments.
  94. 	*/
  95.     this.getSelectedSegmentIDs = function () {
  96.         'use strict';
  97.         var i, n, selectedItems, item, segments = [];
  98.         if (!W.selectionManager.hasSelectedItems()) {
  99.             return false;
  100.         } else {
  101.             selectedItems = W.selectionManager.selectedItems;
  102.             for (i = 0, n = selectedItems.length; i < n; i++) {
  103.                 item = selectedItems[i].model;
  104.                 if ('segment' === item.type) {
  105.                     segments.push(item.attributes.id);
  106.                 }
  107.             }
  108.             return segments.length === 0 ? false : segments;
  109.         }
  110.     };
  111.  
  112.     /**
  113.      * Defers execution of a callback function until the WME map and data 
  114.      * model are ready. Call this function before calling a function that 
  115.      * causes a map and model reload, such as W.map.moveTo(). After the move is 
  116.      * completed the callback function will be executed.
  117.      * @function wLib.Model.onModelReady
  118.      * @param {Function} callback The callback function to be executed.
  119.      * @param {Boolean} now Whether or not to call the callback now if the
  120.      * model is currently ready.
  121.      * @param {Object} context The context in which to call the callback.
  122.      */
  123.     this.onModelReady = function (callback, now, context) {
  124.         var deferModelReady = function () {
  125.             return $.Deferred(function (dfd) {
  126.                 var resolve = function () {
  127.                     dfd.resolve();
  128.                     W.model.events.unregister('mergeend', null, resolve);
  129.                 };
  130.                 W.model.events.register('mergeend', null, resolve);
  131.             }).promise();
  132.         };
  133.         var deferMapReady = function () {
  134.             return $.Deferred(function (dfd) {
  135.                 var resolve = function () {
  136.                     dfd.resolve();
  137.                     W.vent.off('operationDone', resolve);
  138.                 };
  139.                 W.vent.on('operationDone', resolve);
  140.             }).promise();
  141.         };
  142.  
  143.         if (typeof callback === 'function') {
  144.             context = context || callback;
  145.             if (now && wLib.Util.mapReady() && wLib.Util.modelReady()) {
  146.                 callback.call(context);
  147.             } else {
  148.                 $.when(deferMapReady() && deferModelReady()).then(function () {
  149.                     callback.call(context);
  150.                 });
  151.             }
  152.         }
  153.     };
  154.     
  155. 	/**
  156. 	 * Retrives a route from the Waze Live Map.
  157. 	 * @class
  158. 	 * @name wLib.Model.RouteSelection
  159. 	 * @param firstSegment The segment to use as the start of the route.
  160. 	 * @param lastSegment The segment to use as the destination for the route.
  161. 	 * @param {Array|Function} callback A function or array of funcitons to be 
  162.      * executed after the route
  163. 	 * is retrieved. 'This' in the callback functions will refer to the 
  164.      * RouteSelection object.
  165. 	 * @param {Object} options A hash of options for determining route. Valid 
  166.      * options are:
  167. 	 * fastest: {Boolean} Whether or not the fastest route should be used. 
  168.      * Default is false, which selects the shortest route.
  169. 	 * freeways: {Boolean} Whether or not to avoid freeways. Default is false.
  170. 	 * dirt: {Boolean} Whether or not to avoid dirt roads. Default is false.
  171. 	 * longtrails: {Boolean} Whether or not to avoid long dirt roads. Default 
  172.      * is false.
  173. 	 * uturns: {Boolean} Whether or not to allow U-turns. Default is true.
  174. 	 * @return {wLib.Model.RouteSelection} The new RouteSelection object.
  175. 	 * @example: // The following example will retrieve a route from the Live Map and select the segments in the route.
  176. 	 * selection = W.selectionManager.selectedItems;
  177. 	 * myRoute = new wLib.Model.RouteSelection(selection[0], selection[1], function(){this.selectRouteSegments();}, {fastest: true});
  178. 	 */
  179.     this.RouteSelection = function (firstSegment, lastSegment, callback, options) {
  180.         var i,
  181.             n,
  182.             start = this.getSegmentCenterLonLat(firstSegment),
  183.             end = this.getSegmentCenterLonLat(lastSegment);
  184.         this.options = {
  185.             fastest: options && options.fastest || false,
  186.             freeways: options && options.freeways || false,
  187.             dirt: options && options.dirt || false,
  188.             longtrails: options && options.longtrails || false,
  189.             uturns: options && options.uturns || true
  190.         };
  191.         this.requestData = {
  192.             from: 'x:' + start.x + ' y:' + start.y + ' bd:true',
  193.             to: 'x:' + end.x + ' y:' + end.y + ' bd:true',
  194.             returnJSON: true,
  195.             returnGeometries: true,
  196.             returnInstructions: false,
  197.             type: this.options.fastest ? 'HISTORIC_TIME' : 'DISTANCE',
  198.             clientVersion: '4.0.0',
  199.             timeout: 60000,
  200.             nPaths: 3,
  201.             options: this.setRequestOptions(this.options)
  202.         };
  203.         this.callbacks = [];
  204.         if (callback) {
  205.             if (!(callback instanceof Array)) {
  206.                 callback = [callback];
  207.             }
  208.             for (i = 0, n = callback.length; i < n; i++) {
  209.                 if ('function' === typeof callback[i]) {
  210.                     this.callbacks.push(callback[i]);
  211.                 }
  212.             }
  213.         }
  214.         this.routeData = null;
  215.         this.getRouteData();
  216.     };
  217.     this.RouteSelection.prototype = 
  218.     /** @lends wLib.Model.RouteSelection.prototype */ {
  219. 		/**
  220. 		 * Formats the routing options string for the ajax request.
  221. 		 * @private
  222. 		 * @param {Object} options Object containing the routing options.
  223. 		 * @return {String} String containing routing options.
  224. 		 */
  225.         setRequestOptions: function (options) {
  226.             return 'AVOID_TOLL_ROADS:' + (options.tolls ? 't' : 'f') + ',' +
  227.                 'AVOID_PRIMARIES:' + (options.freeways ? 't' : 'f') + ',' +
  228.                 'AVOID_TRAILS:' + (options.dirt ? 't' : 'f') + ',' +
  229.                 'AVOID_LONG_TRAILS:' + (options.longtrails ? 't' : 'f') + ',' +
  230.                 'ALLOW_UTURNS:' + (options.uturns ? 't' : 'f');
  231.         },
  232. 		/**
  233. 		 * Gets the center of a segment in LonLat form.
  234. 		 * @private
  235. 		 * @param segment A Waze model segment object.
  236. 		 * @return {OpenLayers.LonLat} The LonLat object corresponding to the
  237. 		 * center of the segment.
  238. 		 */
  239.         getSegmentCenterLonLat: function (segment) {
  240.             var x, y, componentsLength, midPoint;
  241.             if (segment) {
  242.                 componentsLength = segment.geometry.components.length;
  243.                 midPoint = Math.floor(componentsLength / 2);
  244.                 if (componentsLength % 2 === 1) {
  245.                     x = segment.geometry.components[midPoint].x;
  246.                     y = segment.geometry.components[midPoint].y;
  247.                 } else {
  248.                     x = (segment.geometry.components[midPoint - 1].x +
  249.                         segment.geometry.components[midPoint].x) / 2;
  250.                     y = (segment.geometry.components[midPoint - 1].y +
  251.                         segment.geometry.components[midPoint].y) / 2;
  252.                 }
  253.                 return new OL.Geometry.Point(x, y).
  254.                     transform(W.map.getProjectionObject(), 'EPSG:4326');
  255.             }
  256.  
  257.         },
  258. 		/**
  259. 		 * Gets the route from Live Map and executes any callbacks upon success.
  260. 		 * @private
  261. 		 * @returns The ajax request object. The responseJSON property of the 
  262.          * returned object
  263. 		 * contains the route information.
  264. 		 *
  265. 		 */
  266.         getRouteData: function () {
  267.             var i,
  268.                 n,
  269.                 that = this;
  270.             return $.ajax({
  271.                 dataType: 'json',
  272.                 url: this.getURL(),
  273.                 data: this.requestData,
  274.                 dataFilter: function (data, dataType) {
  275.                     return data.replace(/NaN/g, '0');
  276.                 },
  277.                 success: function (data) {
  278.                     that.routeData = data;
  279.                     for (i = 0, n = that.callbacks.length; i < n; i++) {
  280.                         that.callbacks[i].call(that);
  281.                     }
  282.                 }
  283.             });
  284.         },
  285. 		/**
  286. 		 * Extracts the IDs from all segments on the route.
  287. 		 * @private
  288. 		 * @return {Array} Array containing an array of segment IDs for
  289. 		 * each route alternative.
  290. 		 */
  291.         getRouteSegmentIDs: function () {
  292.             var i, j, route, len1, len2, segIDs = [],
  293.                 routeArray = [],
  294.                 data = this.routeData;
  295.             if ('undefined' !== typeof data.alternatives) {
  296.                 for (i = 0, len1 = data.alternatives.length; i < len1; i++) {
  297.                     route = data.alternatives[i].response.results;
  298.                     for (j = 0, len2 = route.length; j < len2; j++) {
  299.                         routeArray.push(route[j].path.segmentId);
  300.                     }
  301.                     segIDs.push(routeArray);
  302.                     routeArray = [];
  303.                 }
  304.             } else {
  305.                 route = data.response.results;
  306.                 for (i = 0, len1 = route.length; i < len1; i++) {
  307.                     routeArray.push(route[i].path.segmentId);
  308.                 }
  309.                 segIDs.push(routeArray);
  310.             }
  311.             return segIDs;
  312.         },
  313. 		/**
  314. 		 * Gets the URL to use for the ajax request based on country.
  315. 		 * @private
  316. 		 * @return {String} Relative URl to use for route ajax request.
  317. 		 */
  318.         getURL: function () {
  319.             if (W.model.countries.get(235) || W.model.countries.get(40)) {
  320.                 return '/RoutingManager/routingRequest';
  321.             } else if (W.model.countries.get(106)) {
  322.                 return '/il-RoutingManager/routingRequest';
  323.             } else {
  324.                 return '/row-RoutingManager/routingRequest';
  325.             }
  326.         },
  327. 		/**
  328. 		 * Selects all segments on the route in the editor.
  329. 		 * @param {Integer} routeIndex The index of the alternate route.
  330. 		 * Default route to use is the first one, which is 0.
  331. 		 */
  332.         selectRouteSegments: function (routeIndex) {
  333.             var i, n, seg,
  334.                 segIDs = this.getRouteSegmentIDs()[Math.floor(routeIndex) || 0],
  335.                 segments = [];
  336.             if ('undefined' === typeof segIDs) {
  337.                 return;
  338.             }
  339.             for (i = 0, n = segIDs.length; i < n; i++) {
  340.                 seg = W.model.segments.get(segIDs[i]);
  341.                 if ('undefined' !== seg) {
  342.                     segments.push(seg);
  343.                 }
  344.             }
  345.             return W.selectionManager.select(segments);
  346.         }
  347.     };
  348. }).call(wLib.Model);
  349.  
  350. /*** INTERFACE ***/
  351. (function () {
  352.     /**
  353.      * Generates id for message bars.
  354.      * @private
  355.      */
  356.     var getNextID = function () {
  357.         var id = 1;
  358.         return function () {
  359.             return id++;
  360.         };
  361.     } ();
  362.  
  363.     this.MessageBar = OL.Class(this, /** @lends wLib.Interface.MessageBar.prototype */ {
  364.         $el: null,
  365.         id: null,
  366.         elementID: null,
  367.         divStyle: {
  368.             'margin': 'auto',
  369.             'border-radius': '10px',
  370.             'text-align': 'center',
  371.             'width': '40%',
  372.             'font-size': '1em',
  373.             'font-weight': 'bold',
  374.             'color': 'white'
  375.         },
  376.         /**
  377.          * Class to store individual message information.
  378.          * @class {Object} Message
  379.          * @private 
  380.          */
  381.         Message: Backbone.Model.extend({
  382.             defaults: {
  383.                 messageName: null,
  384.                 messageType: 'info',
  385.                 messageText: '',
  386.                 displayDuration: null,
  387.                 skipPrefix: false
  388.             }
  389.         }),
  390.         /**
  391.          * Class to display messages on page.
  392.          * @class {Object} MessageView
  393.          * @private 
  394.          */
  395.         MessageView: Backbone.View.extend({
  396.             styles: {
  397.                 defaultStyle: {
  398.                     'border-radius': '20px',
  399.                     'display': 'inline-block',
  400.                     'padding': '5px',
  401.                     'background-color': 'rgba(0,0,0,0.7)'
  402.                 },
  403.                 error: {
  404.                     'border-radius': '20px',
  405.                     'display': 'inline-block',
  406.                     'padding': '5px',
  407.                     'background-color': 'rgba(180,0,0,0.9)',
  408.                     'color': 'black'
  409.                 },
  410.                 warn: {
  411.                     'border-radius': '20px',
  412.                     'display': 'inline-block',
  413.                     'padding': '5px',
  414.                     'background-color': 'rgba(230,230,0,0.9)',
  415.                     'color': 'black'
  416.                 },
  417.                 info: {
  418.                     'border-radius': '20px',
  419.                     'display': 'inline-block',
  420.                     'padding': '5px',
  421.                     'background-color': 'rgba(0,0,230,0.9)'
  422.                 }
  423.             },
  424.             template: function () {
  425.                 var messageText = '',
  426.                     style,
  427.                     $messageEl = $('<p/>');
  428.  
  429.                 if (!this.model.attributes.skipPrefix && this.messagePrefix) {
  430.                     messageText = this.messagePrefix + ' ';
  431.                 }
  432.  
  433.                 messageText += this.model.attributes.messageText;
  434.  
  435.                 style = (this.model.attributes.messageType &&
  436.                     this.styles[this.model.attributes.messageType]) ?
  437.                     this.styles[this.model.attributes.messageType] : this.styles.defaultStyle;
  438.  
  439.                 $messageEl.
  440.                     css(style).
  441.                     text(messageText);
  442.  
  443.                 return $messageEl;
  444.             },
  445.             initialize: function () {
  446.                 this.render();
  447.             },
  448.             render: function () {
  449.                 this.$el.
  450.                     append(this.template()).
  451.                     appendTo(this.messageBar.$el).
  452.                     fadeIn('fast').
  453.                     delay(this.model.attributes.displayDuration ||
  454.                         this.displayDuration || 5000).
  455.                     fadeOut('slow', function () {
  456.                         $(this).remove();
  457.                     });
  458.                 return this;
  459.             }
  460.         }),
  461.         /**
  462.          * Class to hold Messages.
  463.          * @class {Object} MessageCollection
  464.          * @private 
  465.          */
  466.         MessageCollection: Backbone.Collection.extend(),
  467.  
  468.         messages: null,
  469.         /**
  470.          * Creates a new {wLib.Interface.MessageBar}.
  471.          * @class
  472.          * @name wLib.Interface.MessageBar
  473.          * @param options {Object} Object containing options to use for the 
  474.          * message bar. Valid options are:
  475.          * messages (an array of objects containing message info).
  476.          * messagePrefix (prefix to prepend to each message; can be
  477.          * disabled per message by using skipPrefix),.
  478.          * displayDuration (default duration to display messages).
  479.          * styles (object with keys representing a name for the style, i.e. 
  480.          * messageType, and values containing objects with css properties for 
  481.          * the messageType).
  482.          */
  483.         initialize: function (options) {
  484.             var $insertTarget = $('#search');
  485.  
  486.             options = _.defaults(options || {}, {
  487.                 messagePrefix: null,
  488.                 messages: [],
  489.                 styles: {},
  490.                 displayDuration: 5000
  491.             });
  492.  
  493.             this.messages = new this.MessageCollection({ model: this.Message });
  494.             this.id = getNextID();
  495.             this.elementID = 'wlib-messagebar-' + this.id;
  496.  
  497.             _(options.styles).each(function (style, name) {
  498.                 this.addMessageType(name, style);
  499.             }, this);
  500.  
  501.             _(options.messages).each(function (message) {
  502.                 this.messages.add(message);
  503.             }, this);
  504.  
  505.             this.MessageView.prototype.messagePrefix = options.messagePrefix;
  506.             this.MessageView.prototype.displayDuration = options.displayDuration;
  507.             this.MessageView.prototype.messageBar = this;
  508.  
  509.             this.$el = $('<div/>').
  510.                 css(this.divStyle).
  511.                 attr('id', this.elementID);
  512.  
  513.             wLib.Util.waitForElement($insertTarget, function () {
  514.                 this.$el.insertAfter($insertTarget);
  515.             }, this);
  516.         },
  517.         /**
  518.          * Adds a style for a message type.
  519.          * @param {String} name The name of the message type/style.
  520.          * @param style {Object} Object containing css properties and 
  521.          * values to use for the new messageType.
  522.          */
  523.         addMessageType: function (name, style) {
  524.             style = style || {};
  525.  
  526.             if (name) {
  527.                 this.MessageView.prototype.styles[name] = style;
  528.             }
  529.  
  530.             return this;
  531.         },
  532.         /**
  533.          * Removes the message bar from the page.
  534.          */
  535.         destroy: function () {
  536.             this.messages.reset();
  537.             this.$el.remove();
  538.         },
  539.         /**
  540.          * Displays a message.
  541.          * @param message The message object or the name of the message to 
  542.          * look up.
  543.          */
  544.         displayMessage: function (message) {
  545.             if (typeof message === 'string') {
  546.                 // look up message by name and display
  547.                 message = this.messages.findWhere({ 'messageName': message });
  548.             } else {
  549.                 // add the new message object to the collection and display
  550.                 message = this.messages.add(message);
  551.             }
  552.             new this.MessageView({
  553.                 model: message
  554.             });
  555.             if (!message.attributes.messageName) {
  556.                 this.messages.remove(message);
  557.             }
  558.         },
  559.         /**
  560.          * Adds a new message to the collection of saved messages.
  561.          * @param {Object} messageObject An object containing one or more of the following options:
  562.          * messageName: a string containing the name of the message (for lookup 
  563.          * later).
  564.          * messageType: a string containing the style/type of message.
  565.          * messageText: the text of the message.
  566.          * displayDuration: the duration to display the message in 
  567.          * milliseconds. This value overrides any default value set upon 
  568.          * creation of the MessageBar.
  569.          * skipPrefix: a boolean for whether to show the default message prefix 
  570.          * or not.
  571.          */
  572.         saveMessage: function (messageObject) {
  573.             this.messages.add(messageObject);
  574.             return this;
  575.         },
  576.     });
  577.  
  578.     this.Options = OL.Class(this,
  579.         /** @lends wLib.Interface.Options.prototype */ {
  580.             localStorageName: null,
  581.             options: {},
  582.             /**
  583.              * Creates a new Options object to handle saving and retrieving 
  584.              * script options. During initialization, any options stored under 
  585.              * the named key in localStorage will be loaded. Any options 
  586.              * provided as a parameter to the constructor will be applied to 
  587.              * the retrieved options and thus may overwrite any stored values.
  588.              * @name wLib.Interface.Options
  589.              * @class
  590.              * @param {String} name The string used as the localStorage key 
  591.              * under which to store the options.
  592.              * @param {Object} options A hash containing options to set during 
  593.              * initialization.
  594.              * @example var myOptions = new wLib.Interface.Options(thebestscriptever, {scriptVersion: x});
  595.              * myOptions.set('option1', true);
  596.              * myOptions.set({'option2': false, 'option3': 'very true'});
  597.              * myOptions.get('option2') === false // true;
  598.              */
  599.             initialize: function (name, options) {
  600.                 var i = 1;
  601.  
  602.                 if (window.localStorage && typeof name === 'string') {
  603.  
  604.                     this.localStorageName = name.toLowerCase().
  605.                         replace(/[^a-z]/g, '');
  606.  
  607.                     if (localStorage.getItem(this.localStorageName)) {
  608.                         while (localStorage.getItem(
  609.                             this.localStorageName + i)) {
  610.                             i += 1;
  611.                         }
  612.                         this.localStorageName = this.localStorageName + i;
  613.                     }
  614.  
  615.                     this.retrieveOptions();
  616.  
  617.                     if (options && _.isObject(options)) {
  618.                         this.set(options);
  619.                     }
  620.                 }
  621.             },
  622.             /**
  623.              * Clears all stored options.
  624.              */
  625.             clear: function () {
  626.                 this.options = null;
  627.                 this.saveOptions();
  628.                 return this;
  629.             },
  630.             /**
  631.              * Retrieves a stored value. If no key is specified, the entire 
  632.              * options object is returned.
  633.              * @param {String} key Optional. The key to retrieve.
  634.              */
  635.             get: function (key) {
  636.                 return key && this.options[key] || this.options;
  637.             },
  638.             /**
  639.              * Saves the options to localStorage
  640.              * @private
  641.              */
  642.             saveOptions: function () {
  643.                 localStorage[this.localStorageName] =
  644.                 JSON.stringify(this.options);
  645.             },
  646.             /**
  647.              * Stores a value under the provided key. Provide either an object 
  648.              * hash of keys and values to store as a single parameter or 
  649.              * provide a key and value as two parameters.
  650.              * @param {Object} key The name of the option. Can be string, 
  651.              * number if providing a value as the second parameter, or a hash 
  652.              * of multiple options (see function description).
  653.              * @param {Any} value The value to store. Not used if providing a 
  654.              * hash as the first argument.
  655.              * @example myOptions.set('option1', true); // or
  656.              * myOptions.set({'option2': false, 'option3': 'very true'});
  657.              */
  658.             set: function (key, value) {
  659.                 var j;
  660.                 if ((typeof key === 'string' || !isNaN(key)) && value) {
  661.                     this.options[key] = value;
  662.                 } else if (_.isObject(key)) {
  663.                     for (j in key) {
  664.                         if (key.hasOwnProperty(j)) {
  665.                             this.options[j] = key[j];
  666.                         }
  667.                     }
  668.                 }
  669.                 this.saveOptions();
  670.                 return this;
  671.             },           
  672.             /**
  673.              * Retrieves options previously stored in localStorage.
  674.              * @private
  675.              */
  676.             retrieveOptions: function () {
  677.                 var options = localStorage[this.localStorageName];
  678.                 if (options) {
  679.                     this.options = options;
  680.                 }
  681.             }
  682.         });
  683.  
  684.     this.Shortcut = OL.Class(this,
  685. 		/** @lends wLib.Interface.Shortcut.prototype */ {
  686.             name: null,
  687.             group: null,
  688.             shortcut: {},
  689.             callback: null,
  690.             scope: null,
  691.             groupExists: false,
  692.             actionExists: false,
  693.             eventExists: false,
  694. 			/**
  695. 			 * Creates a new {wLib.Interface.Shortcut}.
  696. 			 * @class
  697. 			 * @name wLib.Interface.Shortcut
  698. 			 * @param name {String} The name of the shortcut.
  699. 			 * @param group {String} The name of the shortcut group.
  700. 			 * @param shortcut {String} The shortcut key(s). The shortcut  
  701.              * should be of the form 'i' where i is the keyboard shortuct or 
  702.              * include modifier keys  such as 'CSA+i', where C = the control 
  703.              * key, S = the shift key, A = the alt key, and i = the desired 
  704.              * keyboard shortcut. The modifier keys are optional.
  705. 			 * @param callback {Function} The function to be called by the 
  706.              * shortcut.
  707. 			 * @param scope {Object} The object to be used as this by the 
  708.              * callback.
  709. 			 * @return {wLib.Interface.Shortcut} The new shortcut object.
  710. 			 * @example //Creates new shortcut and adds it to the map.
  711. 			 * shortcut = new wLib.Interface.Shortcut('myName', 'myGroup', 'C+p', callbackFunc, null).add();
  712. 			 */
  713.             initialize: function (name, group, shortcut, callback, scope) {
  714.                 var defaults = { group: 'default' };
  715.                 this.CLASS_NAME = 'wLib Shortcut';
  716.                 if ('string' === typeof name && name.length > 0 &&
  717.                     'string' === typeof shortcut && shortcut.length > 0 &&
  718.                     'function' === typeof callback) {
  719.                     this.name = name;
  720.                     this.group = group || defaults.group;
  721.                     this.callback = callback;
  722.                     this.shortcut[shortcut] = name;
  723.                     if ('object' !== typeof scope) {
  724.                         this.scope = null;
  725.                     } else {
  726.                         this.scope = scope;
  727.                     }
  728.                     return this;
  729.                 }
  730.             },
  731. 			/**
  732. 			* Determines if the shortcut's group already exists.
  733. 			* @private
  734. 			*/
  735.             doesGroupExist: function () {
  736.                 this.groupExists = 'undefined' !== typeof W.accelerators.Groups[this.group] &&
  737.                 undefined !== typeof W.accelerators.Groups[this.group].members &&
  738.                 W.accelerators.Groups[this.group].length > 0;
  739.                 return this.groupExists;
  740.             },
  741. 			/**
  742. 			* Determines if the shortcut's action already exists.
  743. 			* @private
  744. 			*/
  745.             doesActionExist: function () {
  746.                 this.actionExists = 'undefined' !== typeof W.accelerators.Actions[this.name];
  747.                 return this.actionExists;
  748.             },
  749. 			/**
  750. 			* Determines if the shortcut's event already exists.
  751. 			* @private
  752. 			*/
  753.             doesEventExist: function () {
  754.                 this.eventExists = 'undefined' !== typeof W.accelerators.events.listeners[this.name] &&
  755.                 W.accelerators.events.listeners[this.name].length > 0 &&
  756.                 this.callback === W.accelerators.events.listeners[this.name][0].func &&
  757.                 this.scope === W.accelerators.events.listeners[this.name][0].obj;
  758.                 return this.eventExists;
  759.             },
  760. 			/**
  761. 			* Creates the shortcut's group.
  762. 			* @private
  763. 			*/
  764.             createGroup: function () {
  765.                 W.accelerators.Groups[this.group] = [];
  766.                 W.accelerators.Groups[this.group].members = [];
  767.             },
  768. 			/**
  769. 			* Registers the shortcut's action.
  770. 			* @private
  771. 			*/
  772.             addAction: function () {
  773.                 W.accelerators.addAction(this.name, { group: this.group });
  774.             },
  775. 			/**
  776. 			* Registers the shortcut's event.
  777. 			* @private
  778. 			*/
  779.             addEvent: function () {
  780.                 W.accelerators.events.register(this.name, this.scope, this.callback);
  781.             },
  782. 			/**
  783. 			* Registers the shortcut's keyboard shortcut.
  784. 			* @private
  785. 			*/
  786.             registerShortcut: function () {
  787.                 W.accelerators.registerShortcuts(this.shortcut);
  788.             },
  789. 			/**
  790. 			* Adds the keyboard shortcut to the map.
  791. 			* @return {wLib.Interface.Shortcut} The keyboard shortcut.
  792. 			*/
  793.             add: function () {
  794.                 /* If the group is not already defined, initialize the group. */
  795.                 if (!this.doesGroupExist()) {
  796.                     this.createGroup();
  797.                 }
  798.  
  799.                 /* Clear existing actions with same name */
  800.                 if (this.doesActionExist()) {
  801.                     W.accelerators.Actions[this.name] = null;
  802.                 }
  803.                 this.addAction();
  804.  
  805.                 /* Register event only if it's not already registered */
  806.                 if (!this.doesEventExist()) {
  807.                     this.addEvent();
  808.                 }
  809.  
  810.                 /* Finally, register the shortcut. */
  811.                 this.registerShortcut();
  812.                 return this;
  813.             },
  814. 			/**
  815. 			* Removes the keyboard shortcut from the map.
  816. 			* @return {wLib.Interface.Shortcut} The keyboard shortcut.
  817. 			*/
  818.             remove: function () {
  819.                 if (this.doesEventExist()) {
  820.                     W.accelerators.events.unregister(this.name, this.scope, this.callback);
  821.                 }
  822.                 if (this.doesActionExist()) {
  823.                     delete W.accelerators.Actions[this.name];
  824.                 }
  825.                 //remove shortcut?
  826.                 return this;
  827.             },
  828. 			/**
  829. 			* Changes the keyboard shortcut and applies changes to the map.
  830. 			* @return {wLib.Interface.Shortcut} The keyboard shortcut.
  831. 			*/
  832.             change: function (shortcut) {
  833.                 if (shortcut) {
  834.                     this.shortcut = {};
  835.                     this.shortcut[shortcut] = this.name;
  836.                     this.registerShortcut();
  837.                 }
  838.                 return this;
  839.             }
  840.         }),
  841.  
  842.     this.Tab = OL.Class(this, {
  843.         /** @lends wLib.Interface.Tab */
  844.         TAB_SELECTOR: '#user-tabs ul.nav-tabs',
  845.         CONTENT_SELECTOR: '#user-info > div.tab-content',
  846.         callback: null,
  847.         $content: null,
  848.         context: null,
  849.         $tab: null,
  850.         /**
  851. 	     * Creates a new {wLib.Interface.Tab}. The tab is appended to the WME 
  852.          * editor sidebar and contains the passed HTML content.
  853. 		 * @class
  854. 		 * @name wLib.Interface.Tab
  855. 		 * @param name {String} The name of the tab. Should not contain any 
  856.          * special characters.
  857. 		 * @param content {String} The HTML content of the tab.
  858.          * @param callback {Function} A function to call upon successfully 
  859.          * appending the tab.
  860.          * @param {Object} context The context in which to call the callback 
  861.          * function.
  862.    		 * @return {wLib.Interface.Tab} The new tab object.
  863. 		 * @example //Creates new tab and adds it to the page.
  864. 		 * new wLib.Interface.Tab('thebestscriptever', '<div>Hello World!</div>');
  865. 		 */
  866.         initialize: function (name, content, callback, context) {
  867.             var idName, i = 0;
  868.             if (name && 'string' === typeof name &&
  869.                 content && 'string' === typeof content) {
  870.                 if (callback && 'function' === typeof callback) {
  871.                     this.callback = callback;
  872.                     this.context = context || callback;
  873.                 }
  874.                 /* Sanitize name for html id attribute */
  875.                 idName = name.toLowerCase().replace(/[^a-z-_]/g, '');
  876.                 /* Make sure id will be unique on page */
  877.                 while (
  878.                     $('#sidepanel-' + (i ? idName + i : idName)).length > 0) {
  879.                     i++;
  880.                 }
  881.                 if (i) {
  882.                     idName = idName + i;
  883.                 }
  884.                 /* Create tab and content */
  885.                 this.$tab = $('<li/>')
  886.                     .append($('<a/>')
  887.                         .attr({
  888.                             'href': '#sidepanel-' + idName,
  889.                             'data-toggle': 'tab',
  890.                         })
  891.                         .text(name));
  892.                 this.$content = $('<div/>')
  893.                     .addClass('tab-pane')
  894.                     .attr('id', 'sidepanel-' + idName)
  895.                     .html(content);
  896.  
  897.                 this.appendTab();
  898.             }
  899.         },
  900.         append: function (content) {
  901.             this.$content.append(content);
  902.         },
  903.         appendTab: function (tries) {
  904.             wLib.Util.waitForElement(
  905.                 this.TAB_SELECTOR + ',' + this.CONTENT_SELECTOR,
  906.                 function () {
  907.                     $(this.TAB_SELECTOR).append(this.$tab);
  908.                     $(this.CONTENT_SELECTOR).append(this.$content);
  909.                     if (this.callback) {
  910.                         this.callback.call(this.context);
  911.                     }
  912.                 }, this);
  913.         }
  914.     });
  915. }).call(wLib.Interface);
  916.  
  917. /*** Utilities ***/
  918. (function () {
  919.     /**
  920.      * Function to track the ready state of the map.
  921.      * @memberof wLib.Util
  922.      * @return {Boolean} Whether or not a map operation is pending or undefined
  923.      * if the function has not yet seen a map ready event fired.
  924.      */
  925.     this.mapReady = function () {
  926.         var mapReady = true;
  927.         W.vent.on('operationPending', function () {
  928.             mapReady = false;
  929.         });
  930.         W.vent.on('operationDone', function () {
  931.             mapReady = true;
  932.         });
  933.         return function () {
  934.             return mapReady;
  935.         };
  936.     } ();
  937.  
  938.     /**
  939.      * Function to track the ready state of the model.
  940.      * @memberof wLib.Util
  941.      * @return {Boolean} Whether or not the model has loaded objects or 
  942.      * undefined if the function has not yet seen a model ready event fired.
  943.      */
  944.     this.modelReady = function () {
  945.         var modelReady = true;
  946.         W.model.events.register('mergestart', null, function () {
  947.             modelReady = false;
  948.         });
  949.         W.model.events.register('mergeend', null, function () {
  950.             modelReady = true;
  951.         });
  952.         return function () {
  953.             return modelReady;
  954.         };
  955.     } ();
  956.     
  957.     /**
  958.      * Function to defer function execution until an element is present on the 
  959.      * page.
  960.      * @memberof wLib.Util
  961.      * @param {String} selector The CSS selector string or a jQuery object to 
  962.      * find before executing the callback.
  963.      * @param {Function} callback The function to call when the page element is 
  964.      * detected.
  965.      * @param {Object} context The context in which to call the callback.
  966.      */
  967.     this.waitForElement = function (selector, callback, context) {
  968.         var jqObj;
  969.  
  970.         if (!selector || typeof callback !== 'function') {
  971.             return;
  972.         }
  973.  
  974.         jqObj = typeof selector === 'string' ?
  975.             $(selector) : selector instanceof $ ? selector : null;
  976.  
  977.         if (!jqObj.size()) {
  978.             window.requestAnimationFrame(function () {
  979.                 wLib.Util.waitForElement(selector, callback, context);
  980.             });
  981.         } else {
  982.             callback.call(context || callback);
  983.         }
  984.     };
  985.     
  986.     /**
  987.      * Returns a callback function in the appropriate scope.
  988.      * @memberof wLib.Util
  989.      * @param {Function} func The callback function.
  990.      * @param {Obj} scope The scope in which to call the callback.
  991.      * @return {Function} A function that returns the callback function called 
  992.      * in the appropriate scope.
  993.      */
  994.     this.createCallback = function (func, scope) {
  995.         return typeof func === 'function' && function () {
  996.             return func.call(scope || func);
  997.         };
  998.     };
  999.  
  1000. }).call(wLib.Util);
  1001.  
  1002. /*** API ***/
  1003. (function () {
  1004.  
  1005. }).call(wLib.api);

欢迎访问Greasy Fork镜像

土豆服务器，请按需使用

镜像地址随时可能被墙，建议加群获取最新地址

加入Q群

QingJ © 2025

镜像随时可能失效，请加Q群300939539或关注我们的公众号极客氢云获取最新地址