From f644aa99744ee95acb5010d8abaf588906aedb10 Mon Sep 17 00:00:00 2001
From: Alan Knowles <alan@akkbhome.com>
Date: Mon, 29 Mar 2010 22:12:38 +0800
Subject: [PATCH] Remove Roo dependancy, add Elliot's changes

Roo dependancy removed, replaced with Prototype/jQuery like interfaces in Object.
Elliot's Changes relating to removal of shtml, xhtml complience, and general tidying up
of templates added.
---
 Array.js          |  72 -----
 Date.js           | 809 ++++++++++++++++++++++++++++++++++++++++++++++
 File.js           | 146 +++++++++
 Roo.js            | 181 -----------
 Roo/Observable.js | 355 --------------------
 String.js         | 180 +++++++++++
 6 files changed, 1135 insertions(+), 608 deletions(-)
 delete mode 100644 Array.js
 create mode 100755 Date.js
 create mode 100755 File.js
 delete mode 100644 Roo.js
 delete mode 100644 Roo/Observable.js
 create mode 100755 String.js

diff --git a/Array.js b/Array.js
deleted file mode 100644
index e6aa03a..0000000
--- a/Array.js
+++ /dev/null
@@ -1,72 +0,0 @@
-/**
- * Compat array utils..
- *
- * <script type="text/javascript">
- *
- */
-Array.prototype.filter = function(fun /*, thisp*/)
-  {
-    var len = this.length;
-    if (typeof(fun) != "function")
-      throw "typeerror";
-
-    var res = new Array();
-    var thisp = arguments[1];
-    var t = this;
-    for (var i = 0; i < len; i++)
-    {
-     
-        var val = t[i]; // in case fun mutates this
-        if (fun.call(thisp, val, i, t))
-          res.push(val);
-      //}
-    }
-
-    return res;
-  };
-
-Array.prototype.map = function(fun /*, thisp*/)
-  {
-    var len = this.length;
-    if (typeof(fun) != "function")
-      throw "typeerror";
-
-    var res = new Array(len);
-    var thisp = arguments[1];
-    for (var i = 0; i < len; i++)
-    {
-      
-        res[i] = fun.call(thisp, this[i], i, this);
-    }
-
-    return res;
-  };
-
-if (typeof(Array.prototype['lastIndexOf']) == 'undefined')
-{
-  Array.prototype.lastIndexOf = function(elt /*, from*/)
-  {
-    var len = this.length;
-
-    var from = Number(arguments[1]);
-    if (isNaN(from)) {
-      from = len - 1;
-    }   else   {
-      from = (from < 0)
-           ? Math.ceil(from)
-           : Math.floor(from);
-      if (from < 0)
-        from += len;
-      else if (from >= len)
-        from = len - 1;
-    }
-    var _t = this;
-    for (; from > -1; from--)
-    {
-      if ((typeof(_t[from]) !== 'undefined') &&
-          this[from] === elt)
-        return from;
-    }
-    return -1;
-  };
-}
\ No newline at end of file
diff --git a/Date.js b/Date.js
new file mode 100755
index 0000000..bbbd93a
--- /dev/null
+++ b/Date.js
@@ -0,0 +1,809 @@
+/*
+ * Based on:
+ * Ext JS Library 1.1.1
+ * Copyright(c) 2006-2007, Ext JS, LLC.
+ *
+ * Originally Released Under LGPL - original licence link has changed is not relivant.
+ *
+ * Fork - LGPL
+ * <script type="text/javascript">
+ */
+
+//imports['Date.js'].load(Date);
+if (imports) {
+    imports['String.js'].load(String);
+
+}
+
+if (imports) {
+    load = false; // declare global for gnome langs.
+}
+(function() {
+ 
+
+
+/**
+ * @class Date
+ *
+ * The date parsing and format syntax is a subset of
+ * <a href="http://www.php.net/date">PHP's date() function</a>, and the formats that are
+ * supported will provide results equivalent to their PHP versions.
+ *
+ * Following is the list of all currently supported formats:
+ *<pre>
+Sample date:
+'Wed Jan 10 2007 15:05:01 GMT-0600 (Central Standard Time)'
+
+Format  Output      Description
+------  ----------  --------------------------------------------------------------
+  d      10         Day of the month, 2 digits with leading zeros
+  D      Wed        A textual representation of a day, three letters
+  j      10         Day of the month without leading zeros
+  l      Wednesday  A full textual representation of the day of the week
+  S      th         English ordinal day of month suffix, 2 chars (use with j)
+  w      3          Numeric representation of the day of the week
+  z      9          The julian date, or day of the year (0-365)
+  W      01         ISO-8601 2-digit week number of year, weeks starting on Monday (00-52)
+  F      January    A full textual representation of the month
+  m      01         Numeric representation of a month, with leading zeros
+  M      Jan        Month name abbreviation, three letters
+  n      1          Numeric representation of a month, without leading zeros
+  t      31         Number of days in the given month
+  L      0          Whether it's a leap year (1 if it is a leap year, else 0)
+  Y      2007       A full numeric representation of a year, 4 digits
+  y      07         A two digit representation of a year
+  a      pm         Lowercase Ante meridiem and Post meridiem
+  A      PM         Uppercase Ante meridiem and Post meridiem
+  g      3          12-hour format of an hour without leading zeros
+  G      15         24-hour format of an hour without leading zeros
+  h      03         12-hour format of an hour with leading zeros
+  H      15         24-hour format of an hour with leading zeros
+  i      05         Minutes with leading zeros
+  s      01         Seconds, with leading zeros
+  O      -0600      Difference to Greenwich time (GMT) in hours
+  T      CST        Timezone setting of the machine running the code
+  Z      -21600     Timezone offset in seconds (negative if west of UTC, positive if east)
+</pre>
+ *
+ * Example usage (note that you must escape format specifiers with '\\' to render them as character literals):
+ * <pre><code>
+var dt = new Date('1/10/2007 03:05:01 PM GMT-0600');
+document.write(dt.format('Y-m-d'));                         //2007-01-10
+document.write(dt.format('F j, Y, g:i a'));                 //January 10, 2007, 3:05 pm
+document.write(dt.format('l, \\t\\he dS of F Y h:i:s A'));  //Wednesday, the 10th of January 2007 03:05:01 PM
+ </code></pre>
+ *
+ * Here are some standard date/time patterns that you might find helpful.  They
+ * are not part of the source of Date.js, but to use them you can simply copy this
+ * block of code into any script that is included after Date.js and they will also become
+ * globally available on the Date object.  Feel free to add or remove patterns as needed in your code.
+ * <pre><code>
+Date.patterns = {
+    ISO8601Long:"Y-m-d H:i:s",
+    ISO8601Short:"Y-m-d",
+    ShortDate: "n/j/Y",
+    LongDate: "l, F d, Y",
+    FullDateTime: "l, F d, Y g:i:s A",
+    MonthDay: "F d",
+    ShortTime: "g:i A",
+    LongTime: "g:i:s A",
+    SortableDateTime: "Y-m-d\\TH:i:s",
+    UniversalSortableDateTime: "Y-m-d H:i:sO",
+    YearMonth: "F, Y"
+};
+</code></pre>
+ *
+ * Example usage:
+ * <pre><code>
+var dt = new Date();
+document.write(dt.format(Date.patterns.ShortDate));
+ </code></pre>
+ */
+
+/*
+ * Most of the date-formatting functions below are the excellent work of Baron Schwartz.
+ * They generate precompiled functions from date formats instead of parsing and
+ * processing the pattern every time you format a date.  These functions are available
+ * on every Date object (any javascript function).
+ *
+ * The original article and download are here:
+ * http://www.xaprb.com/blog/2005/12/12/javascript-closures-for-runtime-efficiency/
+ *
+ */
+ 
+     
+     // was in core
+    /**
+     Returns the number of milliseconds between this date and date
+     @param {Date} date (optional) Defaults to now
+     @return {Number} The diff in milliseconds
+     @member Date getElapsed
+     */
+    var date = {
+        
+        // private
+        parseFunctions : {count:0},
+        // private
+        parseRegexes : [],
+        // private
+        formatFunctions : {count:0},
+            
+            
+        // private
+        // safari setMonth is broken
+         
+        /** Date interval constant 
+        * @static 
+        * @type String */
+        MILLI : "ms",
+        /** Date interval constant 
+        * @static 
+        * @type String */
+        SECOND : "s",
+        /** Date interval constant 
+        * @static 
+        * @type String */
+        MINUTE : "mi",
+        /** Date interval constant 
+        * @static 
+        * @type String */
+        HOUR : "h",
+        /** Date interval constant 
+        * @static 
+        * @type String */
+        DAY : "d",
+        /** Date interval constant 
+        * @static 
+        * @type String */
+        MONTH : "mo",
+        /** Date interval constant 
+        * @static 
+        * @type String */
+        YEAR : "y",
+
+        // private
+        daysInMonth : [31,28,31,30,31,30,31,31,30,31,30,31],
+
+        /**
+         * An array of textual month names.
+         * Override these values for international dates, for example...
+         * Date.monthNames = ['JanInYourLang', 'FebInYourLang', ...];
+         * @type Array
+         * @static
+         */
+        monthNames : [
+            "January",
+            "February",
+            "March",
+            "April",
+            "May",
+            "June",
+            "July",
+            "August",
+            "September",
+            "October",
+            "November",
+            "December"],
+
+        /**
+         * An array of textual day names.
+         * Override these values for international dates, for example...
+         * Date.dayNames = ['SundayInYourLang', 'MondayInYourLang', ...];
+         * @type Array
+         * @static
+         */
+        dayNames : [
+            "Sunday",
+            "Monday",
+            "Tuesday",
+            "Wednesday",
+            "Thursday",
+            "Friday",
+            "Saturday"],
+
+        // private
+        y2kYear : 50,
+        // private
+        monthNumbers : {
+            Jan:0,
+            Feb:1,
+            Mar:2,
+            Apr:3,
+            May:4,
+            Jun:5,
+            Jul:6,
+            Aug:7,
+            Sep:8,
+            Oct:9,
+            Nov:10,
+            Dec:11},
+        
+        createNewFormat : function(format) {
+            var funcName = "format" + Date.formatFunctions.count++;
+            Date.formatFunctions[format] = funcName;
+            var code = "Date.prototype." + funcName + " = function(){return ";
+            var special = false;
+            var ch = '';
+            for (var i = 0; i < format.length; ++i) {
+                ch = format.charAt(i);
+                if (!special && ch == "\\") {
+                    special = true;
+                }
+                else if (special) {
+                    special = false;
+                    code += "'" + String.escape(ch) + "' + ";
+                }
+                else {
+                    code += Date.getFormatCode(ch);
+                }
+            }
+            /** eval:var:zzzzzzzzzzzzz */
+            eval(code.substring(0, code.length - 3) + ";}");
+        },
+
+        // private
+        getFormatCode : function(character) {
+            switch (character) {
+            case "d":
+                return "String.leftPad(this.getDate(), 2, '0') + ";
+            case "D":
+                return "Date.dayNames[this.getDay()].substring(0, 3) + ";
+            case "j":
+                return "this.getDate() + ";
+            case "l":
+                return "Date.dayNames[this.getDay()] + ";
+            case "S":
+                return "this.getSuffix() + ";
+            case "w":
+                return "this.getDay() + ";
+            case "z":
+                return "this.getDayOfYear() + ";
+            case "W":
+                return "this.getWeekOfYear() + ";
+            case "F":
+                return "Date.monthNames[this.getMonth()] + ";
+            case "m":
+                return "String.leftPad(this.getMonth() + 1, 2, '0') + ";
+            case "M":
+                return "Date.monthNames[this.getMonth()].substring(0, 3) + ";
+            case "n":
+                return "(this.getMonth() + 1) + ";
+            case "t":
+                return "this.getDaysInMonth() + ";
+            case "L":
+                return "(this.isLeapYear() ? 1 : 0) + ";
+            case "Y":
+                return "this.getFullYear() + ";
+            case "y":
+                return "('' + this.getFullYear()).substring(2, 4) + ";
+            case "a":
+                return "(this.getHours() < 12 ? 'am' : 'pm') + ";
+            case "A":
+                return "(this.getHours() < 12 ? 'AM' : 'PM') + ";
+            case "g":
+                return "((this.getHours() % 12) ? this.getHours() % 12 : 12) + ";
+            case "G":
+                return "this.getHours() + ";
+            case "h":
+                return "String.leftPad((this.getHours() % 12) ? this.getHours() % 12 : 12, 2, '0') + ";
+            case "H":
+                return "String.leftPad(this.getHours(), 2, '0') + ";
+            case "i":
+                return "String.leftPad(this.getMinutes(), 2, '0') + ";
+            case "s":
+                return "String.leftPad(this.getSeconds(), 2, '0') + ";
+            case "O":
+                return "this.getGMTOffset() + ";
+            case "T":
+                return "this.getTimezone() + ";
+            case "Z":
+                return "(this.getTimezoneOffset() * -60) + ";
+            default:
+                return "'" + String.escape(character) + "' + ";
+            }
+        },
+
+        /**
+         * Parses the passed string using the specified format. Note that this function expects dates in normal calendar
+         * format, meaning that months are 1-based (1 = January) and not zero-based like in JavaScript dates.  Any part of
+         * the date format that is not specified will default to the current date value for that part.  Time parts can also
+         * be specified, but default to 0.  Keep in mind that the input date string must precisely match the specified format
+         * string or the parse operation will fail.
+         * Example Usage:
+        <pre><code>
+        //dt = Fri May 25 2007 (current date)
+        var dt = new Date();
+
+        //dt = Thu May 25 2006 (today's month/day in 2006)
+        dt = Date.parseDate("2006", "Y");
+
+        //dt = Sun Jan 15 2006 (all date parts specified)
+        dt = Date.parseDate("2006-1-15", "Y-m-d");
+
+        //dt = Sun Jan 15 2006 15:20:01 GMT-0600 (CST)
+        dt = Date.parseDate("2006-1-15 3:20:01 PM", "Y-m-d h:i:s A" );
+        </code></pre>
+         * @param {String} input The unparsed date as a string
+         * @param {String} format The format the date is in
+         * @return {Date} The parsed date
+         * @static
+         */
+        parseDate : function(input, format) {
+            if (Date.parseFunctions[format] == null) {
+                Date.createParser(format);
+            }
+            var func = Date.parseFunctions[format];
+            return Date[func](input);
+        },
+
+        // private
+        createParser : function(format) {
+            var funcName = "parse" + Date.parseFunctions.count++;
+            var regexNum = Date.parseRegexes.length;
+            var currentGroup = 1;
+            Date.parseFunctions[format] = funcName;
+
+            var code = "Date." + funcName + " = function(input){\n"
+                + "var y = -1, m = -1, d = -1, h = -1, i = -1, s = -1, o, z, v;\n"
+                + "var d = new Date();\n"
+                + "y = d.getFullYear();\n"
+                + "m = d.getMonth();\n"
+                + "d = d.getDate();\n"
+                + "var results = input.match(Date.parseRegexes[" + regexNum + "]);\n"
+                + "if (results && results.length > 0) {";
+            var regex = "";
+
+            var special = false;
+            var ch = '';
+            for (var i = 0; i < format.length; ++i) {
+                ch = format.charAt(i);
+                if (!special && ch == "\\") {
+                    special = true;
+                }
+                else if (special) {
+                    special = false;
+                    regex += String.escape(ch);
+                }
+                else {
+                    var obj = Date.formatCodeToRegex(ch, currentGroup);
+                    currentGroup += obj.g;
+                    regex += obj.s;
+                    if (obj.g && obj.c) {
+                        code += obj.c;
+                    }
+                }
+            }
+
+            code += "if (y >= 0 && m >= 0 && d > 0 && h >= 0 && i >= 0 && s >= 0)\n"
+                + "{v = new Date(y, m, d, h, i, s);}\n"
+                + "else if (y >= 0 && m >= 0 && d > 0 && h >= 0 && i >= 0)\n"
+                + "{v = new Date(y, m, d, h, i);}\n"
+                + "else if (y >= 0 && m >= 0 && d > 0 && h >= 0)\n"
+                + "{v = new Date(y, m, d, h);}\n"
+                + "else if (y >= 0 && m >= 0 && d > 0)\n"
+                + "{v = new Date(y, m, d);}\n"
+                + "else if (y >= 0 && m >= 0)\n"
+                + "{v = new Date(y, m);}\n"
+                + "else if (y >= 0)\n"
+                + "{v = new Date(y);}\n"
+                + "}return (v && (z || o))?\n" // favour UTC offset over GMT offset
+                + "    ((z)? v.add(Date.SECOND, (v.getTimezoneOffset() * 60) + (z*1)) :\n" // reset to UTC, then add offset
+                + "        v.add(Date.HOUR, (v.getGMTOffset() / 100) + (o / -100))) : v\n" // reset to GMT, then add offset
+                + ";}";
+
+            Date.parseRegexes[regexNum] = new RegExp("^" + regex + "$");
+             /** eval:var:zzzzzzzzzzzzz */
+            eval(code);
+        },
+
+        // private
+        formatCodeToRegex : function(character, currentGroup) {
+            switch (character) {
+            case "D":
+                return {g:0,
+                c:null,
+                s:"(?:Sun|Mon|Tue|Wed|Thu|Fri|Sat)"};
+            case "j":
+                return {g:1,
+                    c:"d = parseInt(results[" + currentGroup + "], 10);\n",
+                    s:"(\\d{1,2})"}; // day of month without leading zeroes
+            case "d":
+                return {g:1,
+                    c:"d = parseInt(results[" + currentGroup + "], 10);\n",
+                    s:"(\\d{2})"}; // day of month with leading zeroes
+            case "l":
+                return {g:0,
+                    c:null,
+                    s:"(?:" + Date.dayNames.join("|") + ")"};
+            case "S":
+                return {g:0,
+                    c:null,
+                    s:"(?:st|nd|rd|th)"};
+            case "w":
+                return {g:0,
+                    c:null,
+                    s:"\\d"};
+            case "z":
+                return {g:0,
+                    c:null,
+                    s:"(?:\\d{1,3})"};
+            case "W":
+                return {g:0,
+                    c:null,
+                    s:"(?:\\d{2})"};
+            case "F":
+                return {g:1,
+                    c:"m = parseInt(Date.monthNumbers[results[" + currentGroup + "].substring(0, 3)], 10);\n",
+                    s:"(" + Date.monthNames.join("|") + ")"};
+            case "M":
+                return {g:1,
+                    c:"m = parseInt(Date.monthNumbers[results[" + currentGroup + "]], 10);\n",
+                    s:"(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)"};
+            case "n":
+                return {g:1,
+                    c:"m = parseInt(results[" + currentGroup + "], 10) - 1;\n",
+                    s:"(\\d{1,2})"}; // Numeric representation of a month, without leading zeros
+            case "m":
+                return {g:1,
+                    c:"m = parseInt(results[" + currentGroup + "], 10) - 1;\n",
+                    s:"(\\d{2})"}; // Numeric representation of a month, with leading zeros
+            case "t":
+                return {g:0,
+                    c:null,
+                    s:"\\d{1,2}"};
+            case "L":
+                return {g:0,
+                    c:null,
+                    s:"(?:1|0)"};
+            case "Y":
+                return {g:1,
+                    c:"y = parseInt(results[" + currentGroup + "], 10);\n",
+                    s:"(\\d{4})"};
+            case "y":
+                return {g:1,
+                    c:"var ty = parseInt(results[" + currentGroup + "], 10);\n"
+                        + "y = ty > Date.y2kYear ? 1900 + ty : 2000 + ty;\n",
+                    s:"(\\d{1,2})"};
+            case "a":
+                return {g:1,
+                    c:"if (results[" + currentGroup + "] == 'am') {\n"
+                        + "if (h == 12) { h = 0; }\n"
+                        + "} else { if (h < 12) { h += 12; }}",
+                    s:"(am|pm)"};
+            case "A":
+                return {g:1,
+                    c:"if (results[" + currentGroup + "] == 'AM') {\n"
+                        + "if (h == 12) { h = 0; }\n"
+                        + "} else { if (h < 12) { h += 12; }}",
+                    s:"(AM|PM)"};
+            case "g":
+            case "G":
+                return {g:1,
+                    c:"h = parseInt(results[" + currentGroup + "], 10);\n",
+                    s:"(\\d{1,2})"}; // 12/24-hr format  format of an hour without leading zeroes
+            case "h":
+            case "H":
+                return {g:1,
+                    c:"h = parseInt(results[" + currentGroup + "], 10);\n",
+                    s:"(\\d{2})"}; //  12/24-hr format  format of an hour with leading zeroes
+            case "i":
+                return {g:1,
+                    c:"i = parseInt(results[" + currentGroup + "], 10);\n",
+                    s:"(\\d{2})"};
+            case "s":
+                return {g:1,
+                    c:"s = parseInt(results[" + currentGroup + "], 10);\n",
+                    s:"(\\d{2})"};
+            case "O":
+                return {g:1,
+                    c:[
+                        "o = results[", currentGroup, "];\n",
+                        "var sn = o.substring(0,1);\n", // get + / - sign
+                        "var hr = o.substring(1,3)*1 + Math.floor(o.substring(3,5) / 60);\n", // get hours (performs minutes-to-hour conversion also)
+                        "var mn = o.substring(3,5) % 60;\n", // get minutes
+                        "o = ((-12 <= (hr*60 + mn)/60) && ((hr*60 + mn)/60 <= 14))?\n", // -12hrs <= GMT offset <= 14hrs
+                        "    (sn + String.leftPad(hr, 2, 0) + String.leftPad(mn, 2, 0)) : null;\n"
+                    ].join(""),
+                    s:"([+\-]\\d{4})"};
+            case "T":
+                return {g:0,
+                    c:null,
+                    s:"[A-Z]{1,4}"}; // timezone abbrev. may be between 1 - 4 chars
+            case "Z":
+                return {g:1,
+                    c:"z = results[" + currentGroup + "];\n" // -43200 <= UTC offset <= 50400
+                          + "z = (-43200 <= z*1 && z*1 <= 50400)? z : null;\n",
+                    s:"([+\-]?\\d{1,5})"}; // leading '+' sign is optional for UTC offset
+            default:
+            
+                return {g:0,
+                    c:null,
+                    s:String.escape(character)};
+            }
+        }
+
+        
+    };
+
+    var datePrototype = {
+
+        getElapsed : function(date) {
+            return Math.abs((date || new Date()).getTime()-this.getTime());
+        },
+         
+
+        /**
+         * Formats a date given the supplied format string
+         * @param {String} format The format string
+         * @return {String} The formatted date
+         * @method
+         */
+
+        
+        format : function(format) {
+            if (Date.formatFunctions[format] == null) {
+                Date.createNewFormat(format);
+            }
+            var func = Date.formatFunctions[format];
+            return this[func]();
+        },
+
+        // private - why is dataFormat an alias?
+        //format : dateFormat;
+
+        // private
+
+        /**
+         * Get the timezone abbreviation of the current date (equivalent to the format specifier 'T').
+         * @return {String} The abbreviated timezone name (e.g. 'CST')
+         */
+        getTimezone : function() {
+            return this.toString().replace(/^.*? ([A-Z]{1,4})[\-+][0-9]{4} .*$/, "$1");
+        },
+
+        /**
+         * Get the offset from GMT of the current date (equivalent to the format specifier 'O').
+         * @return {String} The 4-character offset string prefixed with + or - (e.g. '-0600')
+         */
+        getGMTOffset : function() {
+            return (this.getTimezoneOffset() > 0 ? "-" : "+")
+                + String.leftPad(Math.abs(Math.floor(this.getTimezoneOffset() / 60)), 2, "0")
+                + String.leftPad(this.getTimezoneOffset() % 60, 2, "0");
+        },
+
+        /**
+         * Get the numeric day number of the year, adjusted for leap year.
+         * @return {Number} 0 through 364 (365 in leap years)
+         */
+        getDayOfYear : function() {
+            var num = 0;
+            Date.daysInMonth[1] = this.isLeapYear() ? 29 : 28;
+            for (var i = 0; i < this.getMonth(); ++i) {
+                num += Date.daysInMonth[i];
+            }
+            return num + this.getDate() - 1;
+        },
+
+        /**
+         * Get the string representation of the numeric week number of the year
+         * (equivalent to the format specifier 'W').
+         * @return {String} '00' through '52'
+         */
+        getWeekOfYear : function() {
+            // Skip to Thursday of this week
+            var now = this.getDayOfYear() + (4 - this.getDay());
+            // Find the first Thursday of the year
+            var jan1 = new Date(this.getFullYear(), 0, 1);
+            var then = (7 - jan1.getDay() + 4);
+            return String.leftPad(((now - then) / 7) + 1, 2, "0");
+        },
+
+        /**
+         * Whether or not the current date is in a leap year.
+         * @return {Boolean} True if the current date is in a leap year, else false
+         */
+        isLeapYear : function() {
+            var year = this.getFullYear();
+            return ((year & 3) == 0 && (year % 100 || (year % 400 == 0 && year)));
+        },
+
+        /**
+         * Get the first day of the current month, adjusted for leap year.  The returned value
+         * is the numeric day index within the week (0-6) which can be used in conjunction with
+         * the {@link #monthNames} array to retrieve the textual day name.
+         * Example:
+         *<pre><code>
+        var dt = new Date('1/10/2007');
+        document.write(Date.dayNames[dt.getFirstDayOfMonth()]); //output: 'Monday'
+        </code></pre>
+         * @return {Number} The day number (0-6)
+         */
+        getFirstDayOfMonth : function() {
+            var day = (this.getDay() - (this.getDate() - 1)) % 7;
+            return (day < 0) ? (day + 7) : day;
+        },
+
+        /**
+         * Get the last day of the current month, adjusted for leap year.  The returned value
+         * is the numeric day index within the week (0-6) which can be used in conjunction with
+         * the {@link #monthNames} array to retrieve the textual day name.
+         * Example:
+         *<pre><code>
+        var dt = new Date('1/10/2007');
+        document.write(Date.dayNames[dt.getLastDayOfMonth()]); //output: 'Wednesday'
+        </code></pre>
+         * @return {Number} The day number (0-6)
+         */
+        getLastDayOfMonth : function() {
+            var day = (this.getDay() + (Date.daysInMonth[this.getMonth()] - this.getDate())) % 7;
+            return (day < 0) ? (day + 7) : day;
+        },
+
+
+        /**
+         * Get the first date of this date's month
+         * @return {Date}
+         */
+        getFirstDateOfMonth : function() {
+            return new Date(this.getFullYear(), this.getMonth(), 1);
+        },
+
+        /**
+         * Get the last date of this date's month
+         * @return {Date}
+         */
+        getLastDateOfMonth : function() {
+            return new Date(this.getFullYear(), this.getMonth(), this.getDaysInMonth());
+        },
+        /**
+         * Get the number of days in the current month, adjusted for leap year.
+         * @return {Number} The number of days in the month
+         */
+        getDaysInMonth : function() {
+            Date.daysInMonth[1] = this.isLeapYear() ? 29 : 28;
+            return Date.daysInMonth[this.getMonth()];
+        },
+
+        /**
+         * Get the English ordinal suffix of the current day (equivalent to the format specifier 'S').
+         * @return {String} 'st, 'nd', 'rd' or 'th'
+         */
+        getSuffix : function() {
+            switch (this.getDate()) {
+                case 1:
+                case 21:
+                case 31:
+                    return "st";
+                case 2:
+                case 22:
+                    return "nd";
+                case 3:
+                case 23:
+                    return "rd";
+                default:
+                    return "th";
+            }
+        },
+
+
+        /**
+         * Creates and returns a new Date instance with the exact same date value as the called instance.
+         * Dates are copied and passed by reference, so if a copied date variable is modified later, the original
+         * variable will also be changed.  When the intention is to create a new variable that will not
+         * modify the original instance, you should create a clone.
+         *
+         * Example of correctly cloning a date:
+         * <pre><code>
+        //wrong way:
+        var orig = new Date('10/1/2006');
+        var copy = orig;
+        copy.setDate(5);
+        document.write(orig);  //returns 'Thu Oct 05 2006'!
+
+        //correct way:
+        var orig = new Date('10/1/2006');
+        var copy = orig.clone();
+        copy.setDate(5);
+        document.write(orig);  //returns 'Thu Oct 01 2006'
+        </code></pre>
+         * @return {Date} The new Date instance
+         */
+        clone : function() {
+            return new Date(this.getTime());
+        },
+
+        /**
+         * Clears any time information from this date
+         @param {Boolean} clone true to create a clone of this date, clear the time and return it
+         @return {Date} this or the clone
+         */
+        clearTime : function(clone){
+            if(clone){
+                return this.clone().clearTime();
+            }
+            this.setHours(0);
+            this.setMinutes(0);
+            this.setSeconds(0);
+            this.setMilliseconds(0);
+            return this;
+        },
+
+        /**
+         * Provides a convenient method of performing basic date arithmetic.  This method
+         * does not modify the Date instance being called - it creates and returns
+         * a new Date instance containing the resulting date value.
+         *
+         * Examples:
+         * <pre><code>
+        //Basic usage:
+        var dt = new Date('10/29/2006').add(Date.DAY, 5);
+        document.write(dt); //returns 'Fri Oct 06 2006 00:00:00'
+
+        //Negative values will subtract correctly:
+        var dt2 = new Date('10/1/2006').add(Date.DAY, -5);
+        document.write(dt2); //returns 'Tue Sep 26 2006 00:00:00'
+
+        //You can even chain several calls together in one line!
+        var dt3 = new Date('10/1/2006').add(Date.DAY, 5).add(Date.HOUR, 8).add(Date.MINUTE, -30);
+        document.write(dt3); //returns 'Fri Oct 06 2006 07:30:00'
+         </code></pre>
+         *
+         * @param {String} interval   A valid date interval enum value
+         * @param {Number} value      The amount to add to the current date
+         * @return {Date} The new Date instance
+         */
+        add : function(interval, value){
+          var d = this.clone();
+          if (!interval || value === 0) return d;
+          switch(interval.toLowerCase()){
+            case Date.MILLI:
+              d.setMilliseconds(this.getMilliseconds() + value);
+              break;
+            case Date.SECOND:
+              d.setSeconds(this.getSeconds() + value);
+              break;
+            case Date.MINUTE:
+              d.setMinutes(this.getMinutes() + value);
+              break;
+            case Date.HOUR:
+              d.setHours(this.getHours() + value);
+              break;
+            case Date.DAY:
+              d.setDate(this.getDate() + value);
+              break;
+            case Date.MONTH:
+              var day = this.getDate();
+              if(day > 28){
+                  day = Math.min(day, this.getFirstDateOfMonth().add('mo', value).getLastDateOfMonth().getDate());
+              }
+              d.setDate(day);
+              d.setMonth(this.getMonth() + value);
+              break;
+            case Date.YEAR:
+              d.setFullYear(this.getFullYear() + value);
+              break;
+          }
+          return d;
+        }
+    };
+    if (imports) {
+        load = function(ar) {
+            Date = ar;
+            imports.lang.copyPropertiesNoOverwrite( date,ar);
+            imports.lang.copyPropertiesNoOverwrite(datePrototype, ar.prototype);
+            
+        };
+    } else {
+        // non imports version.
+        for(i in datePrototype) {
+            if (!Date.prototype[i]) {
+                Date.prototype[i] = datePrototype[i];
+            }
+        }
+        for(i in date) {
+            if (!Date[i]) {
+                Date[i] = date[i];
+            }
+        }
+    }
+})();
\ No newline at end of file
diff --git a/File.js b/File.js
new file mode 100755
index 0000000..e6e8da8
--- /dev/null
+++ b/File.js
@@ -0,0 +1,146 @@
+// <script type ="text/Javascript">
+GLib = imports.gi.GLib;
+Gio = imports.gi.Gio;
+
+imports['String.js'].load(String);
+
+var File = {
+
+    SEPARATOR : '/',
+
+    join : function () {
+        var out = "";
+        for (var i = 0; i < arguments.length; i++) {
+            if (i == 0) {
+              out += arguments[i].rtrim(File.SEPARATOR);
+            }
+            else if (i == arguments.length - 1) {
+              out += File.SEPARATOR + arguments[i].ltrim(File.SEPARATOR);
+            }
+            else {
+              out += File.SEPARATOR + arguments[i].trim(File.SEPARATOR);
+            }
+        }
+        return out;
+    },
+
+    read : function (path) {
+        var out = {};
+        GLib.file_get_contents(path, out, null, null);
+        return out['value'];
+    },
+
+    isFile : function (path) {
+      return GLib.file_test(path, GLib.FileTest.IS_REGULAR);
+    },
+    exists : function (path) {
+      return GLib.file_test(path, GLib.FileTest.EXISTS);
+    },
+    isDirectory : function (path) {
+      return GLib.file_test(path, GLib.FileTest.IS_DIR);
+    },
+
+    list : function (path) {
+        var listing = [];
+
+        var f = Gio.file_new_for_path(String(path));
+        var file_enum = f.enumerate_children(Gio.FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME, Gio.FileQueryInfoFlags.NONE, null);
+
+        var next_file = null;
+
+        while ((next_file = file_enum.next_file(null)) != null) {
+          listing.push(next_file.get_display_name());
+        }
+
+        file_enum.close(null);
+
+        listing.sort();
+
+        return listing;
+    },
+
+    mtime : function (path) {
+        var f = Gio.file_new_for_path(String(path));
+        var mtime = new GLib.TimeVal();
+
+        var info = f.query_info(Gio.FILE_ATTRIBUTE_TIME_MODIFIED, Gio.FileQueryInfoFlags.NONE, null);
+        info.get_modification_time(mtime);
+
+        return new Date(mtime.tv_sec * 1000);
+    },
+
+    canonical : function (path) {
+        var f = Gio.file_new_for_path(String(path));
+        var can = f.resolve_relative_path('');
+        return can.get_path();
+    },
+
+    write : function (path, string) {
+        var f = Gio.file_new_for_path(String(path));
+        var data_out = new Gio.DataOutputStream({base_stream:f.replace(null, false, Gio.FileCreateFlags.NONE, null)});
+        data_out.put_string(string, null);
+        data_out.close(null);
+    },
+
+    // copy files recursively from fromDir, silently ignore them if they already exist in toDir
+    silentRecursiveCopy : function (fromDir, toDir) {
+        var filesToCopy = File.recursiveListing(fromDir);
+        var srcPath, destPath, src, dest;
+
+        for (index in filesToCopy) {
+          srcPath = File.join(String(fromDir), filesToCopy[index]);
+          destPath = File.join(String(toDir), filesToCopy[index]);
+
+          if (File.isFile(srcPath) && !File.isFile(destPath)) {
+            File.copyFile(srcPath, destPath);
+          }
+          else if (File.isDirectory(srcPath) && !File.isDirectory(destPath)) {
+            File.mkdir(destPath);
+          }
+
+        }
+    },
+
+    mkdir : function (destPath) {
+        var dest = Gio.file_new_for_path(String(destPath));
+        return dest.make_directory(null, null);
+    },
+
+    copyFile : function (srcPath, destPath) {
+        var dest = Gio.file_new_for_path(String(destPath));
+        var src = Gio.file_new_for_path(String(srcPath));
+
+        // a bit of a hack for the fact that Gio.File.copy arguments
+        // can be nulled, but not according to the GIR file
+        return src.copy(dest, Gio.FileCopyFlags.NONE, null, function(_a,_b,_c) {return true;}, true);
+    },
+
+    recursiveListing : function (dir) {
+        
+        function recursiveListingInternal(prefix, listing, dir) {
+          var entries = File.list(dir);
+          var next, fullPath;
+
+          for (var index in entries) {
+            next = entries[index];
+            fullPath = File.join(prefix, dir, next);
+
+            if (File.isDirectory(fullPath)) {
+              listing.push(next);
+              listing = listing.concat(recursiveListingInternal(next, [], fullPath));
+            }
+            else {
+              if (prefix) {
+                next = File.join(prefix, next);
+              }
+              listing.push(next);
+            }
+          }
+
+          return listing;
+        }
+        
+        return recursiveListingInternal('', [], dir);
+    }
+
+};
\ No newline at end of file
diff --git a/Roo.js b/Roo.js
deleted file mode 100644
index 7351de5..0000000
--- a/Roo.js
+++ /dev/null
@@ -1,181 +0,0 @@
-
-
-/*
- * Based on:
- * Ext JS Library 1.1.1
- * Copyright(c) 2006-2007, Ext JS, LLC.
- *
- * Originally Released Under LGPL - original licence link has changed is not relivant.
- *
- * Fork - LGPL
- * <script type="text/javascript">
- */
- 
-
-
-/**
- * @class Roo
- * Roo core utilities and functions.
- * @singleton
- */
-//Roo = imports['Roo.js']; 
-//xnew = imports['xnew.js']; 
-Roo = { }; 
- 
-/**
- * Copies all the properties of config to obj.
- * @param {Object} obj The receiver of the properties
- * @param {Object} config The source of the properties
- * @param {Object} defaults A different object that will also be applied for default values
- * @return {Object} returns obj
- * @member Roo apply
- */
-
-Roo.apply = function(o, c, defaults){
-    if(defaults){
-        // no "this" reference for friendly out of scope calls
-        Roo.apply(o, defaults);
-    }
-    if(o && c && typeof c == 'object'){
-        for(var p in c){
-            o[p] = c[p];
-        }
-    }
-    return o;
-};
-
-
-(function(){ 
-
-    var idSeed = 0;
-
-    Roo.apply(Roo, {
-        
-        /**
-         * Generates unique ids. If the element already has an id, it is unchanged
-         * @param {String/HTMLElement/Element} el (optional) The element to generate an id for
-         * @param {String} prefix (optional) Id prefix (defaults "Roo-gen")
-         * @return {String} The generated Id.
-         */
-        id : function(el, prefix){
-            prefix = prefix || "roo-gen";
-            //el = Roo.getDom(el);
-            var id = prefix + (++idSeed);
-            return id;
-            //return el ? (el.id ? el.id : (el.id = id)) : id;
-        },
-        /**
-         * Extends one class with another class and optionally overrides members with the passed literal. This class
-         * also adds the function "override()" to the class that can be used to override
-         * members on an instance.
-         * @param {Object} subclass The class inheriting the functionality
-         * @param {Object} superclass The class being extended
-         * @param {Object} overrides (optional) A literal with members
-         * @method extend
-         */
-        extend : function(){
-            // inline overrides
-            var io = function(o){
-                for(var m in o){
-                    this[m] = o[m];
-                }
-            };
-            return function(sb, sp, overrides) {
-                if (typeof(sp) == 'undefined') {
-                    // error condition - try and dump..
-                    imports['console.js'].console.dump(sb);
-                }
-                
-                if(typeof sp == 'object'){ // eg. prototype, rather than function constructor..
-                    overrides = sp;
-                    sp = sb;
-                    sb = function(){sp.apply(this, arguments);};
-                }
-                var F = function(){}, sbp, spp = sp.prototype;
-                F.prototype = spp;
-                sbp = sb.prototype = new F();
-                sbp.constructor=sb;
-                sb.superclass=spp;
-                
-                if(spp.constructor == Object.prototype.constructor){
-                    spp.constructor=sp;
-                   
-                }
-                
-                sb.override = function(o){
-                    Roo.override(sb, o);
-                };
-                sbp.override = io;
-                Roo.override(sb, overrides);
-                return sb;
-            };
-        }(),
-        /**
-         * Adds a list of functions to the prototype of an existing class, overwriting any existing methods with the same name.
-         * Usage:<pre><code>
-Roo.override(MyClass, {
-    newMethod1: function(){
-        // etc.
-    },
-    newMethod2: function(foo){
-        // etc.
-    }
-});
- </code></pre>
-         * @param {Object} origclass The class to override
-         * @param {Object} overrides The list of functions to add to origClass.  This should be specified as an object literal
-         * containing one or more methods.
-         * @method override
-         */
-        override : function(origclass, overrides){
-            if(overrides){
-                var p = origclass.prototype;
-                for(var method in overrides){
-                    p[method] = overrides[method];
-                }
-            }
-        },
-        
-        
-        /**
-         * Iterates an array calling the passed function with each item, stopping if your function returns false. If the
-         * passed array is not really an array, your function is called once with it.
-         * The supplied function is called with (Object item, Number index, Array allItems).
-         * @param {Array/NodeList/Mixed} array
-         * @param {Function} fn
-         * @param {Object} scope
-         */
-        each : function(array, fn, scope){
-            if(typeof array.length == "undefined" || typeof array == "string"){
-                array = [array];
-            }
-            for(var i = 0, len = array.length; i < len; i++){
-                if(fn.call(scope || array[i], array[i], i, array) === false){ return i; };
-            }
-        },
-        
-           /**
-         * Copies all the properties of config to obj if they don't already exist.
-         * @param {Object} obj The receiver of the properties
-         * @param {Object} config The source of the properties
-         * @return {Object} returns obj
-         */
-        applyIf : function(o, c){
-            if(o && c){
-                for(var p in c){
-                    if(typeof o[p] == "undefined"){ o[p] = c[p]; }
-                }
-            }
-            return o;
-        },
-
-        
-    })
-    
-    imports['xnew.js'].xnew.load( Roo,  'Roo' );
-})();
-
-
-
-        
-        
\ No newline at end of file
diff --git a/Roo/Observable.js b/Roo/Observable.js
deleted file mode 100644
index d5f7000..0000000
--- a/Roo/Observable.js
+++ /dev/null
@@ -1,355 +0,0 @@
-/*
- * Based on:
- * Ext JS Library 1.1.1
- * Copyright(c) 2006-2007, Ext JS, LLC.
- *
- * Originally Released Under LGPL - original licence link has changed is not relivant.
- *
- * Fork - LGPL
- * <script type="text/javascript">
- */
-Roo = imports['Roo.js'].Roo;
-/**
- * @class Roo.Observable
- * Base class that provides a common interface for publishing events. Subclasses are expected to
- * to have a property "events" with all the events defined.<br>
- * For example:
- * <pre><code>
- Employee = function(name){
-    this.name = name;
-    this.addEvents({
-        "fired" : true,
-        "quit" : true
-    });
- }
- Roo.extend(Employee, Roo.Observable);
-</code></pre>
- * @param {Object} config properties to use (incuding events / listeners)
- */
- 
- 
-Observable = function(cfg){
-    
-    cfg = cfg|| {};
-    this.addEvents(cfg.events || {});
-    if (cfg.events) {
-        delete cfg.events; // make sure
-    }
-     
-    Roo.apply(this, cfg);
-    
-    if(this.listeners){
-        this.on(this.listeners);
-        delete this.listeners;
-    }
-};
-Observable.prototype = {
-    /** 
- * @cfg {Object} listeners  list of events and functions to call for this object, 
- * For example :
- * <pre><code>
-    listeners :  { 
-       'click' : function(e) {
-           ..... 
-        } ,
-        .... 
-    } 
-  </code></pre>
- */
-    
-    
-    /**
-     * Fires the specified event with the passed parameters (minus the event name).
-     * @param {String} eventName
-     * @param {Object...} args Variable number of parameters are passed to handlers
-     * @return {Boolean} returns false if any of the handlers return false otherwise it returns true
-     */
-    fireEvent : function(){
-        var ce = this.events[arguments[0].toLowerCase()];
-        if(typeof ce == "object"){
-            return ce.fire.apply(ce, Array.prototype.slice.call(arguments, 1));
-        }else{
-            return true;
-        }
-    },
-
-    // private
-    filterOptRe : /^(?:scope|delay|buffer|single)$/,
-
-    /**
-     * Appends an event handler to this component
-     * @param {String}   eventName The type of event to listen for
-     * @param {Function} handler The method the event invokes
-     * @param {Object}   scope (optional) The scope in which to execute the handler
-     * function. The handler function's "this" context.
-     * @param {Object}   options (optional) An object containing handler configuration
-     * properties. This may contain any of the following properties:<ul>
-     * <li>scope {Object} The scope in which to execute the handler function. The handler function's "this" context.</li>
-     * <li>delay {Number} The number of milliseconds to delay the invocation of the handler after te event fires.</li>
-     * <li>single {Boolean} True to add a handler to handle just the next firing of the event, and then remove itself.</li>
-     * <li>buffer {Number} Causes the handler to be scheduled to run in an {@link Roo.DelayedTask} delayed
-     * by the specified number of milliseconds. If the event fires again within that time, the original
-     * handler is <em>not</em> invoked, but the new handler is scheduled in its place.</li>
-     * </ul><br>
-     * <p>
-     * <b>Combining Options</b><br>
-     * Using the options argument, it is possible to combine different types of listeners:<br>
-     * <br>
-     * A normalized, delayed, one-time listener that auto stops the event and passes a custom argument (forumId)
-		<pre><code>
-		el.on('click', this.onClick, this, {
- 			single: true,
-    		delay: 100,
-    		forumId: 4
-		});
-		</code></pre>
-     * <p>
-     * <b>Attaching multiple handlers in 1 call</b><br>
-     * The method also allows for a single argument to be passed which is a config object containing properties
-     * which specify multiple handlers.
-     * <pre><code>
-		el.on({
-			'click': {
-        		fn: this.onClick,
-        		scope: this,
-        		delay: 100
-    		}, 
-    		'mouseover': {
-        		fn: this.onMouseOver,
-        		scope: this
-    		},
-    		'mouseout': {
-        		fn: this.onMouseOut,
-        		scope: this
-    		}
-		});
-		</code></pre>
-     * <p>
-     * Or a shorthand syntax which passes the same scope object to all handlers:
-     	<pre><code>
-		el.on({
-			'click': this.onClick,
-    		'mouseover': this.onMouseOver,
-    		'mouseout': this.onMouseOut,
-    		scope: this
-		});
-		</code></pre>
-     */
-    on : function(eventName, fn, scope, o){
-        if(typeof eventName == "object"){
-            o = eventName;
-            for(var e in o){
-                if(this.filterOptRe.test(e)){
-                    continue;
-                }
-                if(typeof o[e] == "function"){
-                    // shared options
-                    this.on(e, o[e], o.scope,  o);
-                }else{
-                    // individual options
-                    this.on(e, o[e].fn, o[e].scope, o[e]);
-                }
-            }
-            return;
-        }
-        o = (!o || typeof o == "boolean") ? {} : o;
-        eventName = eventName.toLowerCase();
-        var ce = this.events[eventName] || true;
-        if(typeof ce == "boolean"){
-            ce = new Roo.Event(this, eventName);
-            this.events[eventName] = ce;
-        }
-        ce.addListener(fn, scope, o);
-    },
-
-    /**
-     * Removes a listener
-     * @param {String}   eventName     The type of event to listen for
-     * @param {Function} handler        The handler to remove
-     * @param {Object}   scope  (optional) The scope (this object) for the handler
-     */
-    un : function(eventName, fn, scope){
-        var ce = this.events[eventName.toLowerCase()];
-        if(typeof ce == "object"){
-            ce.removeListener(fn, scope);
-        }
-    },
-
-    /**
-     * Removes all listeners for this object
-     */
-    purgeListeners : function(){
-        for(var evt in this.events){
-            if(typeof this.events[evt] == "object"){
-                 this.events[evt].clearListeners();
-            }
-        }
-    },
-
-    relayEvents : function(o, events){
-        var createHandler = function(ename){
-            return function(){
-                return this.fireEvent.apply(this, Roo.combine(ename, Array.prototype.slice.call(arguments, 0)));
-            };
-        };
-        for(var i = 0, len = events.length; i < len; i++){
-            var ename = events[i];
-            if(!this.events[ename]){ this.events[ename] = true; };
-            o.on(ename, createHandler(ename), this);
-        }
-    },
-
-    /**
-     * Used to define events on this Observable
-     * @param {Object} object The object with the events defined
-     */
-    addEvents : function(o){
-        if(!this.events){
-            this.events = {};
-        }
-        Roo.applyIf(this.events, o);
-    },
-
-    /**
-     * Checks to see if this object has any listeners for a specified event
-     * @param {String} eventName The name of the event to check for
-     * @return {Boolean} True if the event is being listened for, else false
-     */
-    hasListener : function(eventName){
-        var e = this.events[eventName];
-        return typeof e == "object" && e.listeners.length > 0;
-    }
-};
- 
-/**
- * Starts capture on the specified Observable. All events will be passed
- * to the supplied function with the event name + standard signature of the event
- * <b>before</b> the event is fired. If the supplied function returns false,
- * the event will not fire.
- * @param {Observable} o The Observable to capture
- * @param {Function} fn The function to call
- * @param {Object} scope (optional) The scope (this object) for the fn
- * @static
- */
-Observable.capture = function(o, fn, scope){
-    o.fireEvent = o.fireEvent.createInterceptor(fn, scope);
-};
-
-/**
- * Removes <b>all</b> added captures from the Observable.
- * @param {Observable} o The Observable to release
- * @static
- */
-Observable.releaseCapture = function(o){
-    o.fireEvent = Observable.prototype.fireEvent;
-};
-
-(function(){
-
-    var createBuffered = function(h, o, scope){
-        var task = new Roo.DelayedTask();
-        return function(){
-            task.delay(o.buffer, h, scope, Array.prototype.slice.call(arguments, 0));
-        };
-    };
-
-    var createSingle = function(h, e, fn, scope){
-        return function(){
-            e.removeListener(fn, scope);
-            return h.apply(scope, arguments);
-        };
-    };
-
-    var createDelayed = function(h, o, scope){
-        return function(){
-            var args = Array.prototype.slice.call(arguments, 0);
-            setTimeout(function(){
-                h.apply(scope, args);
-            }, o.delay || 10);
-        };
-    };
-
-    Roo.Event = function(obj, name){
-        this.name = name;
-        this.obj = obj;
-        this.listeners = [];
-    };
-
-    Roo.Event.prototype = {
-        addListener : function(fn, scope, options){
-            var o = options || {};
-            scope = scope || this.obj;
-            if(!this.isListening(fn, scope)){
-                var l = {fn: fn, scope: scope, options: o};
-                var h = fn;
-                if(o.delay){
-                    h = createDelayed(h, o, scope);
-                }
-                if(o.single){
-                    h = createSingle(h, this, fn, scope);
-                }
-                if(o.buffer){
-                    h = createBuffered(h, o, scope);
-                }
-                l.fireFn = h;
-                if(!this.firing){ // if we are currently firing this event, don't disturb the listener loop
-                    this.listeners.push(l);
-                }else{
-                    this.listeners = this.listeners.slice(0);
-                    this.listeners.push(l);
-                }
-            }
-        },
-
-        findListener : function(fn, scope){
-            scope = scope || this.obj;
-            var ls = this.listeners;
-            for(var i = 0, len = ls.length; i < len; i++){
-                var l = ls[i];
-                if(l.fn == fn && l.scope == scope){
-                    return i;
-                }
-            }
-            return -1;
-        },
-
-        isListening : function(fn, scope){
-            return this.findListener(fn, scope) != -1;
-        },
-
-        removeListener : function(fn, scope){
-            var index;
-            if((index = this.findListener(fn, scope)) != -1){
-                if(!this.firing){
-                    this.listeners.splice(index, 1);
-                }else{
-                    this.listeners = this.listeners.slice(0);
-                    this.listeners.splice(index, 1);
-                }
-                return true;
-            }
-            return false;
-        },
-
-        clearListeners : function(){
-            this.listeners = [];
-        },
-
-        fire : function(){
-            var ls = this.listeners, scope, len = ls.length;
-            if(len > 0){
-                this.firing = true;
-                var args = Array.prototype.slice.call(arguments, 0);
-                for(var i = 0; i < len; i++){
-                    var l = ls[i];
-                    if(l.fireFn.apply(l.scope||this.obj||window, arguments) === false){
-                        this.firing = false;
-                        return false;
-                    }
-                }
-                this.firing = false;
-            }
-            return true;
-        }
-    };
-})();
\ No newline at end of file
diff --git a/String.js b/String.js
new file mode 100755
index 0000000..37ff1d4
--- /dev/null
+++ b/String.js
@@ -0,0 +1,180 @@
+/*
+ * Based on:
+ * Ext JS Library 1.1.1
+ * Copyright(c) 2006-2007, Ext JS, LLC.
+ *
+ * Originally Released Under LGPL - original licence link has changed is not relivant.
+ *
+ * Fork - LGPL
+ * <script type="text/javascript">
+ */
+// usage:
+//imports['String.js'].load(String);
+if (imports) {
+    load = false; // declare global for gnome langs.
+}
+(function () {
+    
+
+    var string =  {
+    
+        /** @scope String */
+        
+        /**
+         * Escapes the passed string for ' and \
+         * @param {String} string The string to escape
+         * @return {String} The escaped string
+         * @static
+         */
+        escape : function(string) {
+            return string.replace(/('|\\)/g, "\\$1");
+        },
+
+        /**
+         * Pads the left side of a string with a specified character.  This is especially useful
+         * for normalizing number and date strings.  Example usage:
+         * <pre><code>
+    var s = String.leftPad('123', 5, '0');
+    // s now contains the string: '00123'
+    </code></pre>
+         * @param {String} string The original string
+         * @param {Number} size The total length of the output string
+         * @param {String} char (optional) The character with which to pad the original string (defaults to empty string " ")
+         * @return {String} The padded string
+         * @static
+         */
+        leftPad : function (val, size, ch) {
+            var result = new String(val);
+            if(ch === null || ch === undefined || ch === '') {
+                ch = " ";
+            }
+            while (result.length < size) {
+                result = ch + result;
+            }
+            return result;
+        },
+         /**
+         * Allows you to define a tokenized string and pass an arbitrary number of arguments to replace the tokens.  Each
+         * token must be unique, and must increment in the format {0}, {1}, etc.  Example usage:
+         * <pre><code>
+    var cls = 'my-class', text = 'Some text';
+    var s = String.format('<div class="{0}">{1}</div>', cls, text);
+    // s now contains the string: '<div class="my-class">Some text</div>'
+    </code></pre>
+         * @p aram {String} string The tokenized string to be formatted
+         * @param {String} value1 The value to replace token {0}
+         * @param {String} value2 Etc...
+         * @return {String} The formatted string
+         * @static
+         */
+        format : function(format){
+            var args = Array.prototype.slice.call(arguments, 1);
+            return format.replace(/\{(\d+)\}/g, function(m, i){
+                return args[i];
+            });
+        },
+        
+
+        /**
+         * Allows you to define a tokenized string and pass an arbitrary number of arguments to replace the tokens.  Each
+         * token must be unique, and must increment in the format {0}, {1}, etc.  Example usage:
+         * <pre><code>
+    var cls = 'my-class', text = 'Some text';
+    var s = String.format('<div class="{0}">{1}</div>', cls, text);
+    // s now contains the string: '<div class="my-class">Some text</div>'
+    </code></pre>
+         * @param {String} string The tokenized string to be formatted
+         * @param {String} value1 The value to replace token {0}
+         * @param {String} value2 Etc...
+         * @return {String} The formatted string, all arguments will be htmlEncoded.
+         * @static
+         */
+        htmlFormat : function(format){
+            var args = Array.prototype.slice.call(arguments, 1);
+            return format.replace(/\{(\d+)\}/g, function(m, i){
+                return this.htmlEncode(args[i]);
+            });
+        },
+        
+        /**
+         * Convert certain characters (&, <, >, and ') to their HTML character equivalents for literal display in web pages.
+         * @param {String} value The string to encode
+         * @return {String} The encoded text
+         */
+        htmlEncode : function(value){
+            return !value ? value : 
+                String(value).replace(/&/g, "&amp;"
+                    ).replace(/>/g, "&gt;").replace(/</g, "&lt;").replace(/"/g, "&quot;");
+        }
+        
+        
+    };
+
+    /**
+     * Utility function that allows you to easily switch a string between two alternating values.  The passed value
+     * is compared to the current string, and if they are equal, the other value that was passed in is returned.  If
+     * they are already different, the first value passed in is returned.  Note that this method returns the new value
+     * but does not change the current string.
+     * <pre><code>
+    // alternate sort directions
+    sort = sort.toggle('ASC', 'DESC');
+
+    // instead of conditional logic:
+    sort = (sort == 'ASC' ? 'DESC' : 'ASC');
+    </code></pre>
+     * @param {String} value The value to compare to the current string
+     * @param {String} other The new value to use if the string already equals the first value passed in
+     * @return {String} The new value
+     */
+     
+    var stringPrototype = {
+        toggle : function(value, other){
+            return this == value ? other : value;
+        },
+        
+        trim : function (toTrim) {
+            var out = this.ltrim(toTrim);
+            out = out.rtrim(toTrim);
+            return out;
+        },
+        
+        ltrim : function (toTrim) {
+            if (this.substr(0, toTrim.length) == toTrim) {
+                return this.slice(toTrim.length);
+            }
+            
+            return this;
+        },
+        
+        rtrim : function (toTrim) {
+            if (this.substr(this.length - toTrim.length) == toTrim) {
+                return this.slice(0, this.length - toTrim.length);
+            }
+       
+            return this;
+        }
+ 
+    };
+    
+    
+    
+    if (imports) {
+        load = function(ar) {
+            String = ar;
+            imports.lang.copyPropertiesNoOverwrite(string,ar);
+            imports.lang.copyPropertiesNoOverwrite(stringPrototype,ar.prototype);
+        };
+    } else {
+        // non imports version.
+        for(i in stringPrototype) {
+            if (!String.prototype[i]) {
+                String.prototype[i] = stringPrototype[i];
+            }
+        }
+        for(i in string) {
+            if (!String[i]) {
+                String[i] = string[i];
+            }
+        }
+    }
+})();
\ No newline at end of file
-- 
2.39.2