git.roojs.org Git - roojs1/blob - Roo.js

   1 /*
   2  * Based on:
   3  * Ext JS Library 1.1.1
   4  * Copyright(c) 2006-2007, Ext JS, LLC.
   5  *
   6  * Originally Released Under LGPL - original licence link has changed is not relivant.
   7  *
   8  * Fork - LGPL
   9  * <script type="text/javascript">
  10  */
  11
  12
  13
  14
  15
  16 // for old browsers
  17 window["undefined"] = window["undefined"];
  18
  19 /**
  20  * @class Roo
  21  * Roo core utilities and functions.
  22  * @singleton
  23  */
  24 var Roo = {};
  25 /**
  26  * Copies all the properties of config to obj.
  27  * @param {Object} obj The receiver of the properties
  28  * @param {Object} config The source of the properties
  29  * @param {Object} defaults A different object that will also be applied for default values
  30  * @return {Object} returns obj
  31  * @member Roo apply
  32  */
  33
  34
  35 Roo.apply = function(o, c, defaults){
  36     if(defaults){
  37         // no "this" reference for friendly out of scope calls
  38         Roo.apply(o, defaults);
  39     }
  40     if(o && c && typeof c == 'object'){
  41         for(var p in c){
  42             o[p] = c[p];
  43         }
  44     }
  45     return o;
  46 };
  47
  48
  49 (function(){
  50     var idSeed = 0;
  51     var ua = navigator.userAgent.toLowerCase();
  52
  53     var isStrict = document.compatMode == "CSS1Compat",
  54         isOpera = ua.indexOf("opera") > -1,
  55         isSafari = (/webkit|khtml/).test(ua),
  56         isFirefox = ua.indexOf("firefox") > -1,
  57         isIE = ua.indexOf("msie") > -1,
  58         isIE7 = ua.indexOf("msie 7") > -1,
  59         isIE11 = /trident.*rv\:11\./.test(ua),
  60         isEdge = ua.indexOf("edge") > -1,
  61         isGecko = !isSafari && ua.indexOf("gecko") > -1,
  62         isBorderBox = isIE && !isStrict,
  63         isWindows = (ua.indexOf("windows") != -1 || ua.indexOf("win32") != -1),
  64         isMac = (ua.indexOf("macintosh") != -1 || ua.indexOf("mac os x") != -1),
  65         isLinux = (ua.indexOf("linux") != -1),
  66         isSecure = window.location.href.toLowerCase().indexOf("https") === 0,
  67         isIOS = /iphone|ipad/.test(ua),
  68         isAndroid = /android/.test(ua),
  69         isTouch =  (function() {
  70             try {
  71                 if (ua.indexOf('chrome') != -1 && ua.indexOf('android') == -1) {
  72                     window.addEventListener('touchstart', function __set_has_touch__ () {
  73                         Roo.isTouch = true;
  74                         window.removeEventListener('touchstart', __set_has_touch__);
  75                     });
  76                     return false; // no touch on chrome!?
  77                 }
  78                 document.createEvent("TouchEvent");
  79                 return true;
  80             } catch (e) {
  81                 return false;
  82             }
  83
  84         })();
  85     // remove css image flicker
  86         if(isIE && !isIE7){
  87         try{
  88             document.execCommand("BackgroundImageCache", false, true);
  89         }catch(e){}
  90     }
  91
  92     Roo.apply(Roo, {
  93         /**
  94          * True if the browser is in strict mode
  95          * @type Boolean
  96          */
  97         isStrict : isStrict,
  98         /**
  99          * True if the page is running over SSL
 100          * @type Boolean
 101          */
 102         isSecure : isSecure,
 103         /**
 104          * True when the document is fully initialized and ready for action
 105          * @type Boolean
 106          */
 107         isReady : false,
 108         /**
 109          * Turn on debugging output (currently only the factory uses this)
 110          * @type Boolean
 111          */
 112
 113         debug: false,
 114
 115         /**
 116          * True to automatically uncache orphaned Roo.Elements periodically (defaults to true)
 117          * @type Boolean
 118          */
 119         enableGarbageCollector : true,
 120
 121         /**
 122          * True to automatically purge event listeners after uncaching an element (defaults to false).
 123          * Note: this only happens if enableGarbageCollector is true.
 124          * @type Boolean
 125          */
 126         enableListenerCollection:false,
 127
 128         /**
 129          * URL to a blank file used by Roo when in secure mode for iframe src and onReady src to prevent
 130          * the IE insecure content warning (defaults to javascript:false).
 131          * @type String
 132          */
 133         SSL_SECURE_URL : "javascript:false",
 134
 135         /**
 136          * URL to a 1x1 transparent gif image used by Roo to create inline icons with CSS background images. (Defaults to
 137          * "http://Roojs.com/s.gif" and you should change this to a URL on your server).
 138          * @type String
 139          */
 140         BLANK_IMAGE_URL : "http:/"+"/localhost/s.gif",
 141
 142         emptyFn : function(){},
 143
 144         /**
 145          * Copies all the properties of config to obj if they don't already exist.
 146          * @param {Object} obj The receiver of the properties
 147          * @param {Object} config The source of the properties
 148          * @return {Object} returns obj
 149          */
 150         applyIf : function(o, c){
 151             if(o && c){
 152                 for(var p in c){
 153                     if(typeof o[p] == "undefined"){ o[p] = c[p]; }
 154                 }
 155             }
 156             return o;
 157         },
 158
 159         /**
 160          * Applies event listeners to elements by selectors when the document is ready.
 161          * The event name is specified with an @ suffix.
 162 <pre><code>
 163 Roo.addBehaviors({
 164    // add a listener for click on all anchors in element with id foo
 165    '#foo a@click' : function(e, t){
 166        // do something
 167    },
 168
 169    // add the same listener to multiple selectors (separated by comma BEFORE the @)
 170    '#foo a, #bar span.some-class@mouseover' : function(){
 171        // do something
 172    }
 173 });
 174 </code></pre>
 175          * @param {Object} obj The list of behaviors to apply
 176          */
 177         addBehaviors : function(o){
 178             if(!Roo.isReady){
 179                 Roo.onReady(function(){
 180                     Roo.addBehaviors(o);
 181                 });
 182                 return;
 183             }
 184             var cache = {}; // simple cache for applying multiple behaviors to same selector does query multiple times
 185             for(var b in o){
 186                 var parts = b.split('@');
 187                 if(parts[1]){ // for Object prototype breakers
 188                     var s = parts[0];
 189                     if(!cache[s]){
 190                         cache[s] = Roo.select(s);
 191                     }
 192                     cache[s].on(parts[1], o[b]);
 193                 }
 194             }
 195             cache = null;
 196         },
 197
 198         /**
 199          * Generates unique ids. If the element already has an id, it is unchanged
 200          * @param {String/HTMLElement/Element} el (optional) The element to generate an id for
 201          * @param {String} prefix (optional) Id prefix (defaults "Roo-gen")
 202          * @return {String} The generated Id.
 203          */
 204         id : function(el, prefix){
 205             prefix = prefix || "roo-gen";
 206             el = Roo.getDom(el);
 207             var id = prefix + (++idSeed);
 208             return el ? (el.id ? el.id : (el.id = id)) : id;
 209         },
 210
 211
 212         /**
 213          * Extends one class with another class and optionally overrides members with the passed literal. This class
 214          * also adds the function "override()" to the class that can be used to override
 215          * members on an instance.
 216          * @param {Object} subclass The class inheriting the functionality
 217          * @param {Object} superclass The class being extended
 218          * @param {Object} overrides (optional) A literal with members
 219          * @method extend
 220          */
 221         extend : function(){
 222             // inline overrides
 223             var io = function(o){
 224                 for(var m in o){
 225                     this[m] = o[m];
 226                 }
 227             };
 228             return function(sb, sp, overrides){
 229                 if(typeof sp == 'object'){ // eg. prototype, rather than function constructor..
 230                     overrides = sp;
 231                     sp = sb;
 232                     sb = function(){sp.apply(this, arguments);};
 233                 }
 234                 var F = function(){}, sbp, spp = sp.prototype;
 235                 F.prototype = spp;
 236                 sbp = sb.prototype = new F();
 237                 sbp.constructor=sb;
 238                 sb.superclass=spp;
 239
 240                 if(spp.constructor == Object.prototype.constructor){
 241                     spp.constructor=sp;
 242
 243                 }
 244
 245                 sb.override = function(o){
 246                     Roo.override(sb, o);
 247                 };
 248                 sbp.override = io;
 249                 Roo.override(sb, overrides);
 250                 return sb;
 251             };
 252         }(),
 253
 254         /**
 255          * Adds a list of functions to the prototype of an existing class, overwriting any existing methods with the same name.
 256          * Usage:<pre><code>
 257 Roo.override(MyClass, {
 258     newMethod1: function(){
 259         // etc.
 260     },
 261     newMethod2: function(foo){
 262         // etc.
 263     }
 264 });
 265  </code></pre>
 266          * @param {Object} origclass The class to override
 267          * @param {Object} overrides The list of functions to add to origClass.  This should be specified as an object literal
 268          * containing one or more methods.
 269          * @method override
 270          */
 271         override : function(origclass, overrides){
 272             if(overrides){
 273                 var p = origclass.prototype;
 274                 for(var method in overrides){
 275                     p[method] = overrides[method];
 276                 }
 277             }
 278         },
 279         /**
 280          * Creates namespaces to be used for scoping variables and classes so that they are not global.  Usage:
 281          * <pre><code>
 282 Roo.namespace('Company', 'Company.data');
 283 Company.Widget = function() { ... }
 284 Company.data.CustomStore = function(config) { ... }
 285 </code></pre>
 286          * @param {String} namespace1
 287          * @param {String} namespace2
 288          * @param {String} etc
 289          * @method namespace
 290          */
 291         namespace : function(){
 292             var a=arguments, o=null, i, j, d, rt;
 293             for (i=0; i<a.length; ++i) {
 294                 d=a[i].split(".");
 295                 rt = d[0];
 296                 /** eval:var:o */
 297                 eval('if (typeof ' + rt + ' == "undefined"){' + rt + ' = {};} o = ' + rt + ';');
 298                 for (j=1; j<d.length; ++j) {
 299                     o[d[j]]=o[d[j]] || {};
 300                     o=o[d[j]];
 301                 }
 302             }
 303         },
 304         /**
 305          * Creates namespaces to be used for scoping variables and classes so that they are not global.  Usage:
 306          * <pre><code>
 307 Roo.factory({ xns: Roo.data, xtype : 'Store', .....});
 308 Roo.factory(conf, Roo.data);
 309 </code></pre>
 310          * @param {String} classname
 311          * @param {String} namespace (optional)
 312          * @method factory
 313          */
 314
 315         factory : function(c, ns)
 316         {
 317             // no xtype, no ns or c.xns - or forced off by c.xns
 318             if (!c.xtype   || (!ns && !c.xns) ||  (c.xns === false)) { // not enough info...
 319                 return c;
 320             }
 321             ns = c.xns ? c.xns : ns; // if c.xns is set, then use that..
 322             if (c.constructor == ns[c.xtype]) {// already created...
 323                 return c;
 324             }
 325             if (ns[c.xtype]) {
 326                 if (Roo.debug) { Roo.log("Roo.Factory(" + c.xtype + ")"); }
 327                 var ret = new ns[c.xtype](c);
 328                 ret.xns = false;
 329                 return ret;
 330             }
 331             c.xns = false; // prevent recursion..
 332             return c;
 333         },
 334          /**
 335          * Logs to console if it can.
 336          *
 337          * @param {String|Object} string
 338          * @method log
 339          */
 340         log : function(s)
 341         {
 342             if ((typeof(console) == 'undefined') || (typeof(console.log) == 'undefined')) {
 343                 return; // alerT?
 344             }
 345
 346             if(window.location.href.indexOf("localhost") !== -1) {
 347                 return;
 348             }
 349
 350             console.log(s);
 351
 352         },
 353         /**
 354          * Takes an object and converts it to an encoded URL. e.g. Roo.urlEncode({foo: 1, bar: 2}); would return "foo=1&bar=2".  Optionally, property values can be arrays, instead of keys and the resulting string that's returned will contain a name/value pair for each array value.
 355          * @param {Object} o
 356          * @return {String}
 357          */
 358         urlEncode : function(o){
 359             if(!o){
 360                 return "";
 361             }
 362             var buf = [];
 363             for(var key in o){
 364                 var ov = o[key], k = Roo.encodeURIComponent(key);
 365                 var type = typeof ov;
 366                 if(type == 'undefined'){
 367                     buf.push(k, "=&");
 368                 }else if(type != "function" && type != "object"){
 369                     buf.push(k, "=", Roo.encodeURIComponent(ov), "&");
 370                 }else if(ov instanceof Array){
 371                     if (ov.length) {
 372                             for(var i = 0, len = ov.length; i < len; i++) {
 373                                 buf.push(k, "=", Roo.encodeURIComponent(ov[i] === undefined ? '' : ov[i]), "&");
 374                             }
 375                         } else {
 376                             buf.push(k, "=&");
 377                         }
 378                 }
 379             }
 380             buf.pop();
 381             return buf.join("");
 382         },
 383          /**
 384          * Safe version of encodeURIComponent
 385          * @param {String} data
 386          * @return {String}
 387          */
 388
 389         encodeURIComponent : function (data)
 390         {
 391             try {
 392                 return encodeURIComponent(data);
 393             } catch(e) {} // should be an uri encode error.
 394
 395             if (data == '' || data == null){
 396                return '';
 397             }
 398             // http://stackoverflow.com/questions/2596483/unicode-and-uri-encoding-decoding-and-escaping-in-javascript
 399             function nibble_to_hex(nibble){
 400                 var chars = '0123456789ABCDEF';
 401                 return chars.charAt(nibble);
 402             }
 403             data = data.toString();
 404             var buffer = '';
 405             for(var i=0; i<data.length; i++){
 406                 var c = data.charCodeAt(i);
 407                 var bs = new Array();
 408                 if (c > 0x10000){
 409                         // 4 bytes
 410                     bs[0] = 0xF0 | ((c & 0x1C0000) >>> 18);
 411                     bs[1] = 0x80 | ((c & 0x3F000) >>> 12);
 412                     bs[2] = 0x80 | ((c & 0xFC0) >>> 6);
 413                     bs[3] = 0x80 | (c & 0x3F);
 414                 }else if (c > 0x800){
 415                          // 3 bytes
 416                     bs[0] = 0xE0 | ((c & 0xF000) >>> 12);
 417                     bs[1] = 0x80 | ((c & 0xFC0) >>> 6);
 418                     bs[2] = 0x80 | (c & 0x3F);
 419                 }else if (c > 0x80){
 420                        // 2 bytes
 421                     bs[0] = 0xC0 | ((c & 0x7C0) >>> 6);
 422                     bs[1] = 0x80 | (c & 0x3F);
 423                 }else{
 424                         // 1 byte
 425                     bs[0] = c;
 426                 }
 427                 for(var j=0; j<bs.length; j++){
 428                     var b = bs[j];
 429                     var hex = nibble_to_hex((b & 0xF0) >>> 4)
 430                             + nibble_to_hex(b &0x0F);
 431                     buffer += '%'+hex;
 432                }
 433             }
 434             return buffer;
 435
 436         },
 437
 438         /**
 439          * Takes an encoded URL and and converts it to an object. e.g. Roo.urlDecode("foo=1&bar=2"); would return {foo: 1, bar: 2} or Roo.urlDecode("foo=1&bar=2&bar=3&bar=4", true); would return {foo: 1, bar: [2, 3, 4]}.
 440          * @param {String} string
 441          * @param {Boolean} overwrite (optional) Items of the same name will overwrite previous values instead of creating an an array (Defaults to false).
 442          * @return {Object} A literal with members
 443          */
 444         urlDecode : function(string, overwrite){
 445             if(!string || !string.length){
 446                 return {};
 447             }
 448             var obj = {};
 449             var pairs = string.split('&');
 450             var pair, name, value;
 451             for(var i = 0, len = pairs.length; i < len; i++){
 452                 pair = pairs[i].split('=');
 453                 name = decodeURIComponent(pair[0]);
 454                 value = decodeURIComponent(pair[1]);
 455                 if(overwrite !== true){
 456                     if(typeof obj[name] == "undefined"){
 457                         obj[name] = value;
 458                     }else if(typeof obj[name] == "string"){
 459                         obj[name] = [obj[name]];
 460                         obj[name].push(value);
 461                     }else{
 462                         obj[name].push(value);
 463                     }
 464                 }else{
 465                     obj[name] = value;
 466                 }
 467             }
 468             return obj;
 469         },
 470
 471         /**
 472          * Iterates an array calling the passed function with each item, stopping if your function returns false. If the
 473          * passed array is not really an array, your function is called once with it.
 474          * The supplied function is called with (Object item, Number index, Array allItems).
 475          * @param {Array/NodeList/Mixed} array
 476          * @param {Function} fn
 477          * @param {Object} scope
 478          */
 479         each : function(array, fn, scope){
 480             if(typeof array.length == "undefined" || typeof array == "string"){
 481                 array = [array];
 482             }
 483             for(var i = 0, len = array.length; i < len; i++){
 484                 if(fn.call(scope || array[i], array[i], i, array) === false){ return i; };
 485             }
 486         },
 487
 488         // deprecated
 489         combine : function(){
 490             var as = arguments, l = as.length, r = [];
 491             for(var i = 0; i < l; i++){
 492                 var a = as[i];
 493                 if(a instanceof Array){
 494                     r = r.concat(a);
 495                 }else if(a.length !== undefined && !a.substr){
 496                     r = r.concat(Array.prototype.slice.call(a, 0));
 497                 }else{
 498                     r.push(a);
 499                 }
 500             }
 501             return r;
 502         },
 503
 504         /**
 505          * Escapes the passed string for use in a regular expression
 506          * @param {String} str
 507          * @return {String}
 508          */
 509         escapeRe : function(s) {
 510             return s.replace(/([.*+?^${}()|[\]\/\\])/g, "\\$1");
 511         },
 512
 513         // internal
 514         callback : function(cb, scope, args, delay){
 515             if(typeof cb == "function"){
 516                 if(delay){
 517                     cb.defer(delay, scope, args || []);
 518                 }else{
 519                     cb.apply(scope, args || []);
 520                 }
 521             }
 522         },
 523
 524         /**
 525          * Return the dom node for the passed string (id), dom node, or Roo.Element
 526          * @param {String/HTMLElement/Roo.Element} el
 527          * @return HTMLElement
 528          */
 529         getDom : function(el){
 530             if(!el){
 531                 return null;
 532             }
 533             return el.dom ? el.dom : (typeof el == 'string' ? document.getElementById(el) : el);
 534         },
 535
 536         /**
 537         * Shorthand for {@link Roo.ComponentMgr#get}
 538         * @param {String} id
 539         * @return Roo.Component
 540         */
 541         getCmp : function(id){
 542             return Roo.ComponentMgr.get(id);
 543         },
 544
 545         num : function(v, defaultValue){
 546             if(typeof v != 'number'){
 547                 return defaultValue;
 548             }
 549             return v;
 550         },
 551
 552         destroy : function(){
 553             for(var i = 0, a = arguments, len = a.length; i < len; i++) {
 554                 var as = a[i];
 555                 if(as){
 556                     if(as.dom){
 557                         as.removeAllListeners();
 558                         as.remove();
 559                         continue;
 560                     }
 561                     if(typeof as.purgeListeners == 'function'){
 562                         as.purgeListeners();
 563                     }
 564                     if(typeof as.destroy == 'function'){
 565                         as.destroy();
 566                     }
 567                 }
 568             }
 569         },
 570
 571         // inpired by a similar function in mootools library
 572         /**
 573          * Returns the type of object that is passed in. If the object passed in is null or undefined it
 574          * return false otherwise it returns one of the following values:<ul>
 575          * <li><b>string</b>: If the object passed is a string</li>
 576          * <li><b>number</b>: If the object passed is a number</li>
 577          * <li><b>boolean</b>: If the object passed is a boolean value</li>
 578          * <li><b>function</b>: If the object passed is a function reference</li>
 579          * <li><b>object</b>: If the object passed is an object</li>
 580          * <li><b>array</b>: If the object passed is an array</li>
 581          * <li><b>regexp</b>: If the object passed is a regular expression</li>
 582          * <li><b>element</b>: If the object passed is a DOM Element</li>
 583          * <li><b>nodelist</b>: If the object passed is a DOM NodeList</li>
 584          * <li><b>textnode</b>: If the object passed is a DOM text node and contains something other than whitespace</li>
 585          * <li><b>whitespace</b>: If the object passed is a DOM text node and contains only whitespace</li>
 586          * @param {Mixed} object
 587          * @return {String}
 588          */
 589         type : function(o){
 590             if(o === undefined || o === null){
 591                 return false;
 592             }
 593             if(o.htmlElement){
 594                 return 'element';
 595             }
 596             var t = typeof o;
 597             if(t == 'object' && o.nodeName) {
 598                 switch(o.nodeType) {
 599                     case 1: return 'element';
 600                     case 3: return (/\S/).test(o.nodeValue) ? 'textnode' : 'whitespace';
 601                 }
 602             }
 603             if(t == 'object' || t == 'function') {
 604                 switch(o.constructor) {
 605                     case Array: return 'array';
 606                     case RegExp: return 'regexp';
 607                 }
 608                 if(typeof o.length == 'number' && typeof o.item == 'function') {
 609                     return 'nodelist';
 610                 }
 611             }
 612             return t;
 613         },
 614
 615         /**
 616          * Returns true if the passed value is null, undefined or an empty string (optional).
 617          * @param {Mixed} value The value to test
 618          * @param {Boolean} allowBlank (optional) Pass true if an empty string is not considered empty
 619          * @return {Boolean}
 620          */
 621         isEmpty : function(v, allowBlank){
 622             return v === null || v === undefined || (!allowBlank ? v === '' : false);
 623         },
 624
 625         /** @type Boolean */
 626         isOpera : isOpera,
 627         /** @type Boolean */
 628         isSafari : isSafari,
 629         /** @type Boolean */
 630         isFirefox : isFirefox,
 631         /** @type Boolean */
 632         isIE : isIE,
 633         /** @type Boolean */
 634         isIE7 : isIE7,
 635         /** @type Boolean */
 636         isIE11 : isIE11,
 637         /** @type Boolean */
 638         isEdge : isEdge,
 639         /** @type Boolean */
 640         isGecko : isGecko,
 641         /** @type Boolean */
 642         isBorderBox : isBorderBox,
 643         /** @type Boolean */
 644         isWindows : isWindows,
 645         /** @type Boolean */
 646         isLinux : isLinux,
 647         /** @type Boolean */
 648         isMac : isMac,
 649         /** @type Boolean */
 650         isIOS : isIOS,
 651         /** @type Boolean */
 652         isAndroid : isAndroid,
 653         /** @type Boolean */
 654         isTouch : isTouch,
 655
 656         /**
 657          * By default, Ext intelligently decides whether floating elements should be shimmed. If you are using flash,
 658          * you may want to set this to true.
 659          * @type Boolean
 660          */
 661         useShims : ((isIE && !isIE7) || (isGecko && isMac)),
 662
 663
 664
 665         /**
 666          * Selects a single element as a Roo Element
 667          * This is about as close as you can get to jQuery's $('do crazy stuff')
 668          * @param {String} selector The selector/xpath query
 669          * @param {Node} root (optional) The start of the query (defaults to document).
 670          * @return {Roo.Element}
 671          */
 672         selectNode : function(selector, root)
 673         {
 674             var node = Roo.DomQuery.selectNode(selector,root);
 675             return node ? Roo.get(node) : new Roo.Element(false);
 676         }
 677
 678     });
 679
 680
 681 })();
 682
 683 Roo.namespace("Roo", "Roo.util", "Roo.grid", "Roo.dd", "Roo.tree", "Roo.data",
 684                 "Roo.form", "Roo.menu", "Roo.state", "Roo.lib", "Roo.layout",
 685                 "Roo.app", "Roo.ux",
 686                 "Roo.bootstrap",
 687                 "Roo.bootstrap.dash");