☰

Greasy Fork is available in English.

wLib

A library for WME script developers.

Този скрипт не може да бъде инсталиран директно. Това е библиотека за други скриптове и може да бъде използвана с мета-директива // @require https://update.greatest.deepsurf.us/scripts/9794/106259/wLib.js 

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