☰

WazeWrap Beta

A base library for WME script writers

目前為 2016-11-17 提交的版本，檢視 最新版本。

此腳本不應該直接安裝，它是一個供其他腳本使用的函式庫。欲使用本函式庫，請在腳本 metadata 寫上： // @require https://update.cn-greasyfork.org/scripts/24870/158442/WazeWrap%20Beta.js 

  1. // ==UserScript==
  2. // @name         WazeWrap Beta
  3. // @namespace    https://greasyfork.org/users/30701-justins83-waze
  4. // @version      0.1.4
  5. // @description  A base library for WME script writers
  6. // @author       JustinS83/MapOMatic
  7. // @include      https://beta.waze.com/*editor/*
  8. // @include      https://www.waze.com/*editor/*
  9. // @exclude      https://www.waze.com/*user/editor/*
  10. // @grant        none
  11. // ==/UserScript==
  12.  
  13. /* global W */
  14. /* global WazeWrap */
  15.  
  16. (function() {
  17.  
  18. 	function bootstrap(tries) {
  19. 		tries = tries || 1;
  20. 		if (W &&
  21. 			W.map &&
  22. 			W.model &&
  23. 			W.loginManager &&
  24. 			$) {
  25. 			init();
  26. 		} else if (tries < 1000) {
  27. 			setTimeout(function () { bootstrap(tries++); }, 200);
  28. 		} else {
  29. 			console.log('WazeWrap failed to load');
  30. 		}
  31. 	}
  32.  
  33.     bootstrap();
  34.  
  35.     function init(){
  36.         //extendModel();
  37.         //extendGeometry();
  38.  
  39.         var oldLib = window.WazeWrap;
  40.  
  41.         var root = this;
  42. 		var WazeWrap = {};
  43.  
  44. 		WazeWrap.Version = "0.1.4";
  45.  
  46.         SetUpRequire();
  47.  
  48. 		WazeWrap.isBetaEditor = /beta/.test(location.href);
  49. 		WazeWrap.test = "test";
  50.         
  51. 		WazeWrap.Geometry = new Geometry;
  52. 		WazeWrap.Model = new Model;
  53. 		WazeWrap.Interface = new Interface;
  54. 		WazeWrap.User = new User;
  55. 		WazeWrap.Util = new Util;
  56. 		
  57.         root.WazeWrap = WazeWrap;
  58.  
  59.         console.log('WazeWrap Loaded');
  60.     };
  61.  
  62.  
  63.     function SetUpRequire(){
  64.                 if(require)
  65.                      return;
  66.  
  67. 		// setup one global var and put all in
  68. 		var WMEAPI = {};
  69.  
  70. 		// detect URL of WME source code
  71. 		WMEAPI.scripts = document.getElementsByTagName('script');
  72. 		WMEAPI.url=null;
  73. 		for (i=0;i<WMEAPI.scripts.length;i++){
  74. 			if (WMEAPI.scripts[i].src.indexOf('/assets-editor/js/app')!=-1)
  75. 			{
  76. 				WMEAPI.url=WMEAPI.scripts[i].src;
  77. 				break;
  78. 			}
  79. 		}
  80. 		if (WMEAPI.url==null)
  81. 			throw new Error("WME Hack: can't detect WME main JS");
  82.  
  83.  
  84. 		// setup a fake require and require.define
  85. 		WMEAPI.require=function (e) {
  86. 			if (WMEAPI.require.define.modules.hasOwnProperty(e))
  87. 				return WMEAPI.require.define.modules[e];
  88. 			else
  89. 				console.error('Require failed on ' + e, WMEAPI.require.define.modules);
  90. 			return null;
  91. 		};
  92.  
  93. 		WMEAPI.require.define=function (m) {
  94. 			if (WMEAPI.require.define.hasOwnProperty('modules')==false)
  95. 				WMEAPI.require.define.modules={};
  96. 			for (var p in m){
  97. 				WMEAPI.require.define.modules[p]=m[p];
  98. 			}
  99. 		};
  100.  
  101. 		// save the original webpackJsonp function
  102. 		WMEAPI.tmp = window.webpackJsonp;
  103.  
  104. 		// taken from WME code: this function is a wrapper that setup the API and may call recursively other functions
  105. 		WMEAPI.t = function (n) {
  106. 			if (WMEAPI.s[n]) return WMEAPI.s[n].exports;
  107. 			var r = WMEAPI.s[n] = {
  108. 				exports: {},
  109. 				id: n,
  110. 				loaded: !1
  111. 			};
  112. 			return WMEAPI.e[n].call(r.exports, r, r.exports, WMEAPI.t), r.loaded = !0, r.exports;
  113. 		};
  114.  
  115. 		// e is a copy of all WME funcs because function t need to access to this list
  116. 		WMEAPI.e=[];
  117.  
  118. 		// the patch
  119. 		window.webpackJsonp = function(a, i) {
  120. 		// our API but we will use it only to build the require stuffs
  121. 		var api={};
  122. 		// taken from WME code. a is [1], so...
  123. 		for (var o, d, u = 0, l = []; u < a.length; u++) d = a[u], WMEAPI.r[d] && l.push.apply(l, WMEAPI.r[d]), WMEAPI.r[d] = 0;
  124. 		
  125. 		var unknownCount=0;
  126. 		var classname, funcStr;
  127. 		
  128. 		// copy i in e and keep a link from classname to index in e
  129. 		for (o in i){
  130. 			WMEAPI.e[o] = i[o];
  131. 			funcStr = i[o].toString();
  132. 			classname = funcStr.match(/CLASS_NAME:\"([^\"]*)\"/);
  133. 			if (classname){
  134. 				// keep the link.
  135. 				api[classname[1].replace(/\./g,'/').replace(/^W\//, 'Waze/')]={index: o, func: WMEAPI.e[o]};
  136. 			}
  137. 			else{
  138. 				api['Waze/Unknown/' + unknownCount]={index: o, func: WMEAPI.e[o]};
  139. 				unknownCount++;
  140. 			}
  141. 			
  142. 		}
  143. 		
  144. 		// taken from WME code: it calls the original webpackJsonp and do something else, but I don't really know what.
  145. 		// removed the call to the original webpackJsonp: still works...
  146. 		//for (tmp && tmp(a, i); l.length;) l.shift().call(null, t);
  147. 		for (; l.length;) l.shift().call(null, WMEAPI.t);
  148. 		WMEAPI.s[0] = 0;
  149. 		
  150. 		// run the first func of WME. This first func will call recusrsively all funcs needed to setup the API.
  151. 		// After this call, s will contain all instanciables classes.
  152. 		//var ret = WMEAPI.t(0);
  153. 		
  154. 		// now, build the requires thanks to the link we've built in var api.
  155. 		var module={};
  156. 		var apiFuncName;
  157. 		unknownCount=0;
  158. 		
  159. 		for (o in i){
  160. 			funcStr = i[o].toString();
  161. 			classname = funcStr.match(/CLASS_NAME:\"([^\"]*)\"/);
  162. 			if (classname){
  163. 				module={};
  164. 				apiFuncName = classname[1].replace(/\./g,'/').replace(/^W\//, 'Waze/');
  165. 				module[apiFuncName]=WMEAPI.t(api[apiFuncName].index);
  166. 				WMEAPI.require.define(module);
  167. 			}
  168. 			else{
  169. 				var matches = funcStr.match(/SEGMENT:"segment",/);
  170. 				if (matches){
  171. 					module={};
  172. 					apiFuncName='Waze/Model/ObjectType';
  173. 					module[apiFuncName]=WMEAPI.t(api['Waze/Unknown/' + unknownCount].index);
  174. 					WMEAPI.require.define(module);
  175. 				}
  176. 				unknownCount++;
  177. 			}
  178. 		}
  179. 		 
  180.  
  181. 		// restore the original func
  182. 		window.webpackJsonp=WMEAPI.tmp;
  183.  
  184. 		// set the require public if needed
  185. 		// if so: others scripts must wait for the window.require to be available before using it.
  186. 		window.require = WMEAPI.require;
  187. 		// all available functions are in WMEAPI.require.define.modules
  188. 		// console.debug this variable to read it:
  189. 		// console.debug('Modules: ', WMEAPI.require.define.modules);
  190. 		
  191. 		// run your script here:
  192. 		// setTimeout(yourscript);
  193. 		
  194. 		// again taken from WME code. Not sure about what it does.
  195. 		//if (i[0]) return ret;
  196. 		};
  197.  
  198. 		// some kind of global vars and init
  199. 		WMEAPI.s = {};
  200. 		WMEAPI.r = {
  201. 			0: 0
  202. 		};
  203.  
  204. 		// hacking finished
  205.  
  206. 		// load again WME through our patched func
  207. 		WMEAPI.WMEHACK_Injected_script = document.createElement("script");
  208. 		WMEAPI.WMEHACK_Injected_script.setAttribute("type", "application/javascript");
  209. 		WMEAPI.WMEHACK_Injected_script.src = WMEAPI.url;
  210. 		document.body.appendChild(WMEAPI.WMEHACK_Injected_script);
  211. 	}
  212.  
  213.     function Geometry(){
  214.         //var geometry = WazeWrap.Geometry;
  215.  
  216.         //Converts to "normal" GPS coordinates
  217.         this.ConvertTo4326 = function (long, lat){
  218.             var projI=new OpenLayers.Projection("EPSG:900913");
  219.             var projE=new OpenLayers.Projection("EPSG:4326");
  220.             return (new OpenLayers.LonLat(long, lat)).transform(projI,projE);
  221.         };
  222.     
  223.         this.ConvertTo900913 = function (long, lat){
  224.             var projI=new OpenLayers.Projection("EPSG:900913");
  225.             var projE=new OpenLayers.Projection("EPSG:4326");
  226.             return (new OpenLayers.LonLat(long, lat)).transform(projE,projI);
  227.         };
  228.  
  229.         //Converts the Longitudinal offset to an offset in 4326 gps coordinates
  230.         this.CalculateLongOffsetGPS = function(longMetersOffset, long, lat)
  231.         {
  232.             var R= 6378137; //Earth's radius
  233.             var dLon = longMetersOffset / (R * Math.cos(Math.PI * lat / 180)); //offset in radians
  234.             var lon0 = dLon * (180 / Math.PI); //offset degrees
  235.  
  236.             return lon0;
  237.         };
  238.  
  239.         //Converts the Latitudinal offset to an offset in 4326 gps coordinates
  240.         this.CalculateLatOffsetGPS = function(latMetersOffset, lat)
  241.         {
  242.             var R= 6378137; //Earth's radius
  243.             var dLat = latMetersOffset/R;
  244.             var lat0 = dLat * (180  /Math.PI); //offset degrees
  245.  
  246.             return lat0;
  247.         };
  248. 		
  249. 		this.isLonLatInMapExtent = function (lonLat) {
  250.             'use strict';
  251.             return lonLat && W.map.getExtent().containsLonLat(lonLat);
  252.         };
  253. 		
  254. 		this.isGeometryInMapExtent = function (geometry) {
  255.             'use strict';
  256.             return geometry && geometry.getBounds &&
  257.                 W.map.getExtent().intersectsBounds(geometry.getBounds());
  258.         };
  259.     };
  260.  
  261.     function Model(){
  262.         //var model = WazeWrap.Model;
  263.  
  264.         this.getPrimaryStreetID = function(segmentID){
  265.             return W.model.segments.get(segmentID).attributes.primaryStreetID;
  266.         };
  267.  
  268.         this.getStreetName = function(primaryStreetID){
  269.             return W.model.streets.get(PrimaryStreetID).name;
  270.         };
  271.  
  272.         this.getCityID = function(primaryStreetID){
  273.             return W.model.streets.get(primaryStreetID).cityID;
  274.         };
  275.  
  276.         this.getCityName = function(primaryStreetID){
  277.             return W.model.cities.get(this.getCityID(primaryStreetID)).attributes.Name;
  278.         };
  279.  
  280.         this.getStateName = function(primaryStreetID){
  281.             return W.model.states.get(getStateID(primaryStreetID)).Name;   
  282.         };
  283.  
  284.         this.getStateID = function(primaryStreetID){
  285.             return W.model.cities.get(primaryStreetID).attributes.stateID;
  286.         };
  287.  
  288.         this.getCountryID = function(primaryStreetID){
  289.             return W.model.cities.get(this.getCityID(primaryStreetID)).attributes.CountryID;
  290.         };
  291.  
  292.         this.getCountryName = function(primaryStreetID){
  293.             return W.model.countries.get(getCountryID(primaryStreetID)).name;
  294.         };
  295.  
  296.         this.getCityNameFromSegmentObj = function(segObj){
  297.             return this.getCityName(segObj.attributes.primaryStreetID);
  298.         };
  299.  
  300.         this.getStateNameFromSegmentObj = function(segObj){
  301.             return this.getStateName(segObj.attributes.primaryStreetID);
  302.         };
  303.  
  304.         //returns an array of segmentIDs for all segments that are part of the same roundabout as the passed segment
  305.         this.getAllRoundaboutSegmentsFromObj = function(segObj){
  306.             if(segObj.model.attributes.junctionID === null)
  307.                 return null;
  308.  
  309.             return W.model.junctions.objects[segObj.model.attributes.junctionID].segIDs;
  310.         };
  311.  
  312.         this.getAllRoundaboutJunctionNodesFromObj = function(segObj){
  313.             var RASegs = this.getAllRoundaboutSegmentsFromObj(segObj);
  314.             var RAJunctionNodes = [];
  315.             for(i=0; i< RASegs.length; i++){
  316.                 RAJunctionNodes.push(W.model.nodes.objects[W.model.segments.get(RASegs[i]).attributes.toNodeID]);
  317.  
  318.             }
  319.             return RAJunctionNodes;
  320.         };
  321.  
  322.         this.isRoundaboutSegmentID = function(segmentID){
  323.             if(W.model.segments.get(segmentID).attributes.junctionID === null)
  324.                 return false;
  325.             else
  326.                 return true;
  327.         };
  328.  
  329.         this.isRoundaboutSegmentObj = function(segObj){
  330.             if(segObj.model.attributes.junctionID === null)
  331.                 return false;
  332.             else
  333.                 return true;
  334.         };
  335.  
  336. /**
  337.          * Defers execution of a callback function until the WME map and data 
  338.          * model are ready. Call this function before calling a function that 
  339.          * causes a map and model reload, such as W.map.moveTo(). After the 
  340.          * move is completed the callback function will be executed.
  341.          * @function WazeWrap.Model.onModelReady
  342.          * @param {Function} callback The callback function to be executed.
  343.          * @param {Boolean} now Whether or not to call the callback now if the
  344.          * model is currently ready.
  345.          * @param {Object} context The context in which to call the callback.
  346.          */
  347.         this.onModelReady = function (callback, now, context) {
  348.             var deferModelReady = function () {
  349.                 return $.Deferred(function (dfd) {
  350.                     var resolve = function () {
  351.                         dfd.resolve();
  352.                         W.model.events.unregister('mergeend', null, resolve);
  353.                     };
  354.                     W.model.events.register('mergeend', null, resolve);
  355.                 }).promise();
  356.             };
  357.             var deferMapReady = function () {
  358.                 return $.Deferred(function (dfd) {
  359.                     var resolve = function () {
  360.                         dfd.resolve();
  361.                         W.vent.off('operationDone', resolve);
  362.                     };
  363.                     W.vent.on('operationDone', resolve);
  364.                 }).promise();
  365.             };
  366.  
  367.             if (typeof callback === 'function') {
  368.                 context = context || callback;
  369.                 if (now && WazeWrap.Util.mapReady() && WazeWrap.Util.modelReady()) {
  370.                     callback.call(context);
  371.                 } else {
  372.                     $.when(deferMapReady() && deferModelReady()).
  373.                         then(function () {
  374.                             callback.call(context);
  375.                         });
  376.                 }
  377.             }
  378.         };
  379.     };
  380. 	
  381. 	function User(){
  382. 		this.Rank = function(){
  383. 			return W.loginManager.user.normalizedLevel;
  384. 		};
  385.  
  386. 		this.Username = function(){
  387. 			return W.loginManager.user.userName;
  388. 		};
  389.  
  390. 		this.isCM = function(){
  391. 			if(W.loginManager.user.editableCountryIDs.length > 0)
  392. 				return true;
  393. 			else
  394. 				return false;
  395. 		};
  396. 		
  397. 		this.isAM = function(){
  398. 			return W.loginManager.user.isAreaManager;
  399. 		};
  400. 	};
  401. 	
  402. 	function Util(){
  403. 		/**
  404.          * Function to defer function execution until an element is present on 
  405.          * the page.
  406.          * @function WazeWrap.Util.waitForElement
  407.          * @param {String} selector The CSS selector string or a jQuery object 
  408.          * to find before executing the callback.
  409.          * @param {Function} callback The function to call when the page 
  410.          * element is detected.
  411.          * @param {Object} [context] The context in which to call the callback.
  412.          */
  413.         this.waitForElement = function (selector, callback, context) {
  414.             var jqObj;
  415.  
  416.             if (!selector || typeof callback !== 'function') {
  417.                 return;
  418.             }
  419.  
  420.             jqObj = typeof selector === 'string' ?
  421.                 $(selector) : selector instanceof $ ? selector : null;
  422.  
  423.             if (!jqObj.size()) {
  424.                 window.requestAnimationFrame(function () {
  425.                     WazeWrap.Util.waitForElement(selector, callback, context);
  426.                 });
  427.             } else {
  428.                 callback.call(context || callback);
  429.             }
  430.         };
  431.  
  432.          /**
  433.          * Function to track the ready state of the map.
  434.          * @function WazeWrap.Util.mapReady
  435.          * @return {Boolean} Whether or not a map operation is pending or 
  436.          * undefined if the function has not yet seen a map ready event fired.
  437.          */
  438.         this.mapReady = function () {
  439.             var mapReady = true;
  440.             W.vent.on('operationPending', function () {
  441.                 mapReady = false;
  442.             });
  443.             W.vent.on('operationDone', function () {
  444.                 mapReady = true;
  445.             });
  446.             return function () {
  447.                 return mapReady;
  448.             };
  449.         } ();
  450.  
  451.          /**
  452.          * Function to track the ready state of the model.
  453.          * @function WazeWrap.Util.modelReady
  454.          * @return {Boolean} Whether or not the model has loaded objects or 
  455.          * undefined if the function has not yet seen a model ready event fired.
  456.          */
  457.         this.modelReady = function () {
  458.             var modelReady = true;
  459.             W.model.events.register('mergestart', null, function () {
  460.                 modelReady = false;
  461.             });
  462.             W.model.events.register('mergeend', null, function () {
  463.                 modelReady = true;
  464.             });
  465.             return function () {
  466.                 return modelReady;
  467.             };
  468.         } ();
  469. 	};
  470.  
  471.     function Interface() {
  472.         /**
  473.          * Generates id for message bars.
  474.          * @private
  475.          */
  476.         var getNextID = function () {
  477.             var id = 1;
  478.             return function () {
  479.                 return id++;
  480.             };
  481.         } ();
  482. 		
  483.         this.Shortcut = OL.Class(this, /** @lends WazeWrap.Interface.Shortcut.prototype */ {
  484.             name: null,
  485.             group: null,
  486.             shortcut: {},
  487.             callback: null,
  488.             scope: null,
  489.             groupExists: false,
  490.             actionExists: false,
  491.             eventExists: false,
  492.             defaults: {
  493.                 group: 'default'
  494.             },
  495.                 
  496.             /**
  497.              * Creates a new {WazeWrap.Interface.Shortcut}.
  498.              * @class
  499.              * @name WazeWrap.Interface.Shortcut
  500.              * @param name {String} The name of the shortcut.
  501.              * @param group {String} The name of the shortcut group.
  502.              * @param shortcut {String} The shortcut key(s). The shortcut  
  503.              * should be of the form 'i' where i is the keyboard shortuct or 
  504.              * include modifier keys  such as 'CSA+i', where C = the control 
  505.              * key, S = the shift key, A = the alt key, and i = the desired 
  506.              * keyboard shortcut. The modifier keys are optional.
  507.              * @param callback {Function} The function to be called by the 
  508.              * shortcut.
  509.              * @param scope {Object} The object to be used as this by the 
  510.              * callback.
  511.              * @return {WazeWrap.Interface.Shortcut} The new shortcut object.
  512.              * @example //Creates new shortcut and adds it to the map.
  513.              * shortcut = new WazeWrap.Interface.Shortcut('myName', 'myGroup', 'C+p', callbackFunc, null).add();
  514.              */
  515.             initialize: function (name, group, shortcut, callback, scope) {
  516.                 if ('string' === typeof name && name.length > 0 &&
  517.                     'string' === typeof shortcut && shortcut.length > 0 &&
  518.                     'function' === typeof callback) {
  519.                     this.name = name;
  520.                     this.group = group || this.defaults.group;
  521.                     this.callback = callback;
  522.                     this.shortcut[shortcut] = name;
  523.                     if ('object' !== typeof scope) {
  524.                         this.scope = null;
  525.                     } else {
  526.                         this.scope = scope;
  527.                     }
  528.                     return this;
  529.                 }
  530.             },
  531.                 
  532.             /**
  533.             * Determines if the shortcut's group already exists.
  534.             * @private
  535.             */
  536.             doesGroupExist: function () {
  537.                 this.groupExists = 'undefined' !== typeof W.accelerators.Groups[this.group] &&
  538.                 undefined !== typeof W.accelerators.Groups[this.group].members &&
  539.                 W.accelerators.Groups[this.group].length > 0;
  540.                 return this.groupExists;
  541.             },
  542.                 
  543.             /**
  544.             * Determines if the shortcut's action already exists.
  545.             * @private
  546.             */
  547.             doesActionExist: function () {
  548.                 this.actionExists = 'undefined' !== typeof W.accelerators.Actions[this.name];
  549.                 return this.actionExists;
  550.             },
  551.                 
  552.             /**
  553.             * Determines if the shortcut's event already exists.
  554.             * @private
  555.             */
  556.             doesEventExist: function () {
  557.                 this.eventExists = 'undefined' !== typeof W.accelerators.events.listeners[this.name] &&
  558.                 W.accelerators.events.listeners[this.name].length > 0 &&
  559.                 this.callback === W.accelerators.events.listeners[this.name][0].func &&
  560.                 this.scope === W.accelerators.events.listeners[this.name][0].obj;
  561.                 return this.eventExists;
  562.             },
  563.                 
  564.             /**
  565.             * Creates the shortcut's group.
  566.             * @private
  567.             */
  568.             createGroup: function () {
  569.                 W.accelerators.Groups[this.group] = [];
  570.                 W.accelerators.Groups[this.group].members = [];
  571.             },
  572.                 
  573.             /**
  574.             * Registers the shortcut's action.
  575.             * @private
  576.             */
  577.             addAction: function () {
  578.                 W.accelerators.addAction(this.name, { group: this.group });
  579.             },
  580.                 
  581.             /**
  582.             * Registers the shortcut's event.
  583.             * @private
  584.             */
  585.             addEvent: function () {
  586.                 W.accelerators.events.register(this.name, this.scope, this.callback);
  587.             },
  588.                 
  589.             /**
  590.             * Registers the shortcut's keyboard shortcut.
  591.             * @private
  592.             */
  593.             registerShortcut: function () {
  594.                 W.accelerators._registerShortcuts(this.shortcut);
  595.             },
  596.                 
  597.             /**
  598.             * Adds the keyboard shortcut to the map.
  599.             * @return {WazeWrap.Interface.Shortcut} The keyboard shortcut.
  600.             */
  601.             add: function () {
  602.                 /* If the group is not already defined, initialize the group. */
  603.                 if (!this.doesGroupExist()) {
  604.                     this.createGroup();
  605.                 }
  606.  
  607.                 /* Clear existing actions with same name */
  608.                 if (this.doesActionExist()) {
  609.                     W.accelerators.Actions[this.name] = null;
  610.                 }
  611.                 this.addAction();
  612.  
  613.                 /* Register event only if it's not already registered */
  614.                 if (!this.doesEventExist()) {
  615.                     this.addEvent();
  616.                 }
  617.  
  618.                 /* Finally, register the shortcut. */
  619.                 this.registerShortcut();
  620.                 return this;
  621.             },
  622.                 
  623.             /**
  624.             * Removes the keyboard shortcut from the map.
  625.             * @return {WazeWrap.Interface.Shortcut} The keyboard shortcut.
  626.             */
  627.             remove: function () {
  628.                 if (this.doesEventExist()) {
  629.                     W.accelerators.events.unregister(this.name, this.scope, this.callback);
  630.                 }
  631.                 if (this.doesActionExist()) {
  632.                     delete W.accelerators.Actions[this.name];
  633.                 }
  634.                 //remove shortcut?
  635.                 return this;
  636.             },
  637.                 
  638.             /**
  639.             * Changes the keyboard shortcut and applies changes to the map.
  640.             * @return {WazeWrap.Interface.Shortcut} The keyboard shortcut.
  641.             */
  642.             change: function (shortcut) {
  643.                 if (shortcut) {
  644.                     this.shortcut = {};
  645.                     this.shortcut[shortcut] = this.name;
  646.                     this.registerShortcut();
  647.                 }
  648.                 return this;
  649.             }
  650.         }),
  651.  
  652. 		this.Tab = OL.Class(this, {
  653.             /** @lends WazeWrap.Interface.Tab */
  654.             TAB_SELECTOR: '#user-tabs ul.nav-tabs',
  655.             CONTENT_SELECTOR: '#user-info div.tab-content',
  656.             callback: null,
  657.             $content: null,
  658.             context: null,
  659.             $tab: null,
  660.             
  661.             /**
  662.              * Creates a new WazeWrap.Interface.Tab. The tab is appended to the WME 
  663.              * editor sidebar and contains the passed HTML content.
  664.              * @class
  665.              * @name WazeWrap.Interface.Tab
  666.              * @param {String} name The name of the tab. Should not contain any 
  667.              * special characters.
  668.              * @param {String} content The HTML content of the tab.
  669.              * @param {Function} [callback] A function to call upon successfully 
  670.              * appending the tab.
  671.              * @param {Object} [context] The context in which to call the callback 
  672.              * function.
  673.                      * @return {WazeWrap.Interface.Tab} The new tab object.
  674.              * @example //Creates new tab and adds it to the page.
  675.              * new WazeWrap.Interface.Tab('thebestscriptever', '<div>Hello World!</div>');
  676.              */
  677.             initialize: function (name, content, callback, context) {
  678.                 var idName, i = 0;
  679.                 if (name && 'string' === typeof name &&
  680.                     content && 'string' === typeof content) {
  681.                     if (callback && 'function' === typeof callback) {
  682.                         this.callback = callback;
  683.                         this.context = context || callback;
  684.                     }
  685.                     /* Sanitize name for html id attribute */
  686.                     idName = name.toLowerCase().replace(/[^a-z-_]/g, '');
  687.                     /* Make sure id will be unique on page */
  688.                     while (
  689.                         $('#sidepanel-' + (i ? idName + i : idName)).length > 0) {
  690.                         i++;
  691.                     }
  692.                     if (i) {
  693.                         idName = idName + i;
  694.                     }
  695.                     /* Create tab and content */
  696.                     this.$tab = $('<li/>')
  697.                         .append($('<a/>')
  698.                             .attr({
  699.                                 'href': '#sidepanel-' + idName,
  700.                                 'data-toggle': 'tab',
  701.                             })
  702.                             .text(name));
  703.                     this.$content = $('<div/>')
  704.                         .addClass('tab-pane')
  705.                         .attr('id', 'sidepanel-' + idName)
  706.                         .html(content);
  707.  
  708.                     this.appendTab();
  709.                 }
  710.             },
  711.  
  712.             append: function (content) {
  713.                 this.$content.append(content);
  714.             },
  715.  
  716.             appendTab: function () {
  717.                 WazeWrap.Util.waitForElement(
  718.                     this.TAB_SELECTOR + ',' + this.CONTENT_SELECTOR,
  719.                     function () {
  720.                         $(this.TAB_SELECTOR).append(this.$tab);
  721.                         $(this.CONTENT_SELECTOR).first().append(this.$content);
  722.                         if (this.callback) {
  723.                             this.callback.call(this.context);
  724.                         }
  725.                     }, this);
  726.             },
  727.  
  728.             clearContent: function () {
  729.                 this.$content.empty();
  730.             },
  731.  
  732.             destroy: function () {
  733.                 this.$tab.remove();
  734.                 this.$content.remove();
  735.             }
  736.         });
  737. 	};
  738.  
  739. }.call(this));