home *** CD-ROM | disk | FTP | other *** search
/ Chip 2011 November / CHIP_2011_11.iso / Programy / Narzedzia / AIMP2 / aimp_2.61.583.exe / $TEMP / YandexPackSetup.msi / fil322579FA43F870D48B3FE187A5D7B988 < prev    next >
Text File  |  2010-07-12  |  16KB  |  455 lines
  1. var XB = {};
  2. XB.init = function XB_init(application) {
  3.     XB._base.application = application;
  4.     XB._base.loggersRoot = application.name + ".XB";
  5.     XB._base.logger = application.core.Log4Moz.repository.getLogger(XB._base.loggersRoot + ".Base");
  6.     
  7.     XB.cache.init();
  8.     XB.network.init();
  9. };
  10.  
  11. XB.finalize = function XB_finalize() {
  12.     XB.network.finalize();
  13.     XB.cache.finalize();
  14.     XB._base.runtime.finalize();
  15.     XB._base.logger = null;
  16.     XB._base.domParser = null;
  17. };
  18.  
  19. XB._Cc = Components.classes;
  20. XB._Ci = Components.interfaces;
  21. XB._Cr = Components.results;
  22. XB._Cu = Components.utils;
  23.  
  24. XB._base = {
  25.     application: null,
  26.     consts: {
  27.         STR_LOCALE_DECIMAL_SEPARATOR: (1.1).toLocaleString()[1],
  28.         STR_FUNCTIONAL_NS: "http://bar.yandex.ru/dev/functional",
  29.         STR_UI_NS: "http://bar.yandex.ru/dev/gui",
  30.         
  31.         STR_VAL_REF_ELEM_NAME: "__value__",
  32.         STR_VAL_REF_ID_KEY_NAME: "uid",
  33.         STR_WIDGET_ELEMENT_NAME: "widget",
  34.         
  35.         ENUM_SCOPE_PACKAGE: 0,
  36.         ENUM_SCOPE_WIDGET: 1,
  37.         ENUM_SCOPE_INSTANCE: 2,
  38.         
  39.         ERR_XML_PARSE_ERROR: "XML Parse error",
  40.         ERR_INVALID_DOC_STRUC: "Invalid document structure",
  41.         ERR_UID_NOT_FOUND: "Node uid attribute not found",
  42.         ERR_DOM_DOC_EXPECTED: "DOM document expected",
  43.         ERR_DOM_NODES_EXPECTED: "DOM node or node list expected",
  44.         ERR_NUMBER_EXPECTED: "Number expected",
  45.         ERR_STRING_EXPECTED: "String expected",
  46.         ERR_NO_RUNTIME_FUNCTION: "Function is not defined",
  47.         ERR_UID_REQUIRED: "UID required",
  48.         ERR_RUNTIME_ERROR: "Runtime error occured",
  49.         ERR_UNIT_REQUIRED: "XB unit required",
  50.         ERR_PACKAGE_REQUIRED: "Widget package required",
  51.         ERR_WINST_REQUIRED: "Widget instance required",
  52.         ERR_DATA_UNDEFINED: "No data, variable or setting with this name was defined",
  53.         ERR_PROC_NODE_EXPECTED: "ProcNode instance expected",
  54.         ERR_FUNC_NODE_EXPECTED: "FuncNode instance expected",
  55.         ERR_DISPOSED_XML: "Disposed XML object"
  56.     },
  57.     logger: null,
  58.     domParser: XB._Cc["@mozilla.org/xmlextras/domparser;1"].getService(XB._Ci.nsIDOMParser),
  59.     
  60.     genWindowEngineID: function XB_genWindowEngineID() {
  61.         return this._newWEID++;
  62.     },
  63.     
  64.     genXULBuilderID: function XB_genXULBuilderID() {
  65.         return this._newXBID++;
  66.     },
  67.     
  68.     _newWEID: 0,
  69.     _newXBID: 0
  70. };
  71.  
  72. XB._base.runtime = {
  73.     finalize: function XBRuntime_finalize() {
  74.         this._tempDoc = null;
  75.     },
  76.     
  77.     xToString: function XBRuntime_xToString(fromXVal) {
  78.         if (sysutils.isString(fromXVal))
  79.             return fromXVal;
  80.         if (fromXVal == undefined || fromXVal == XB.types.empty)
  81.             return "";
  82.         if (this.isXML(fromXVal))
  83.             return fromXVal.textContent;
  84.         if (this.isRequestData(fromXVal))
  85.             return fromXVal.url;
  86.         if (this.isException(fromXVal))
  87.             throw new Error(this._consts.ERR_EXCEPTION_CONV);
  88.         return fromXVal.toString();
  89.     },
  90.     
  91.     xToNumber: function XBRuntime_xToNumber(fromXVal) {
  92.         if (sysutils.isNumber(fromXVal)) {
  93.             if (isNaN(fromXVal))
  94.                 throw new Error(this._consts.ERR_CANT_CONVERT);
  95.             return fromXVal;
  96.         }
  97.         if (this.isException(fromXVal))
  98.             throw new Error(this._consts.ERR_EXCEPTION_CONV);
  99.         if (sysutils.isBool(fromXVal))
  100.             return Number(fromXVal);
  101.         var trimmedStrVal = sysutils.trimAllSpaces( this.xToString(fromXVal) );
  102.         if (!trimmedStrVal)
  103.             throw new Error(this._consts.ERR_CANT_CONVERT);
  104.         if (!this._numPattern.test(trimmedStrVal))
  105.             throw new Error(this._consts.ERR_CANT_CONVERT + " '" + trimmedStrVal + "'");
  106.         var num = Number(trimmedStrVal);
  107.         if (isNaN(num))
  108.             throw new Error(this._consts.ERR_CANT_CONVERT);
  109.         return num;
  110.     },
  111.     
  112.     xToBool: function XBRuntime_xToBool(fromXVal) {
  113.         if (sysutils.isBool(fromXVal))
  114.             return fromXVal;
  115.         if (sysutils.isNumber(fromXVal))
  116.             return fromXVal != 0;
  117.         if (this.isException(fromXVal))
  118.             throw new Error(this._consts.ERR_EXCEPTION_CONV);
  119.         var strVal = sysutils.trimSpaces( this.xToString(fromXVal) );
  120.         if (strVal == "" || strVal == "false")
  121.             return false;
  122.         if (this._numPattern.test(strVal)) {
  123.             let numVal = Number(strVal);
  124.             if (!isNaN(numVal))
  125.                 return numVal != 0;
  126.         }
  127.         return true;
  128.     },
  129.     
  130.     xToXML: function XBRuntime_xToXML(fromXVal) {
  131.         if (this.isXML(fromXVal))
  132.             return fromXVal;
  133.         var node = this._tempDoc.createTextNode(this.xToString(fromXVal));
  134.         var xmlObj = new XB.types.XML(node);
  135.         return xmlObj;
  136.     },
  137.     
  138.     xToRequestData: function XBRuntime_xToRequestData(fromXVal) {
  139.         if (this.isRequestData(fromXVal))
  140.             return fromXVal;
  141.         const monthTimeRange = 60 * 60 * 24 * 30;
  142.         return new XB.types.RequestData(this.xToString(fromXVal), "GET", monthTimeRange, monthTimeRange * 2,
  143.                                         XB.types.RequestData.Format.FMT_XML, {start:100, end:399});
  144.     },
  145.     
  146.     isXML: function XBRuntime_IsXML(xVal) {
  147.         return (xVal instanceof XB.types.XML);
  148.     },
  149.     
  150.     isException: function XBRuntime_IsException(xVal) {
  151.         return xVal instanceof XB.types.Exception;
  152.     },
  153.     
  154.     isRequestData: function XBRuntime_IsRequestData(xVal) {
  155.         return xVal instanceof XB.types.RequestData;
  156.     },
  157.  
  158.     compareValues: function XBRuntime_CompareValues(value1, value2, mode) {
  159.         if (value1 === value2)
  160.             return 0;
  161.         
  162.         var [value1, value2, rank] = this._checkTypes(value1, value2, mode);
  163.         switch (rank) {
  164.             case this._ranksMap.Empty:
  165.                 return 0;
  166.             case this._ranksMap.Bool:
  167.                 return Number(value1) - Number(value2);
  168.             case this._ranksMap.Number:
  169.                 return value1 - value2;
  170.             case this._ranksMap.String:
  171.                 return sysutils.strcmp(value1, value2);
  172.             case this._ranksMap.XML:
  173.             case this._ranksMap.RequestData:
  174.             case this._ranksMap.Exception:
  175.                 return value1.equalsTo(value2) ? 0 : NaN;
  176.             default:
  177.                 return NaN;
  178.         }
  179.     },
  180.     
  181.     serializeXML: function XBRuntime_serializeXML(node) {
  182.         return this._XMLSerializer.serializeToString(node);
  183.     },
  184.     
  185.     get tempXMLDoc() {
  186.         return this._tempDoc;
  187.     },
  188.     
  189.     queryXMLDoc: function XBRuntime_QueryXMLDoc(expr, contextNode) {
  190.         try {
  191.             XB._base.logger.trace("XPATH expr: " + expr);
  192.             if ( !(contextNode instanceof XB._Ci.nsIDOMNode) )
  193.                 throw new TypeError(XB._base.consts.ERR_DOM_NODES_EXPECTED);
  194.             var doc = (contextNode instanceof XB._Ci.nsIDOMDocument)? contextNode: contextNode.ownerDocument;
  195.             var NSResolver = this._xpathEvaluator.createNSResolver(doc.documentElement);
  196.             var rawResult = this._xpathEvaluator.evaluate(expr, contextNode, NSResolver, 0, null);
  197.             XB._base.logger.trace("Got raw XPATH result of type " + rawResult.resultType);
  198.             
  199.             var result;
  200.             switch (rawResult.resultType) {
  201.                 case rawResult.NUMBER_TYPE:
  202.                     result = rawResult.numberValue;
  203.                     if (isNaN(result))
  204.                         throw new this.EXPATHNaN(expr);
  205.                     break;
  206.                 case rawResult.STRING_TYPE:
  207.                     result = rawResult.stringValue;
  208.                     break;
  209.                 case rawResult.BOOLEAN_TYPE:
  210.                     result = rawResult.booleanValue;
  211.                     break;
  212.                 case rawResult.UNORDERED_NODE_ITERATOR_TYPE:
  213.                     var nodesArray = [];
  214.                     var node;
  215.                     while (node = rawResult.iterateNext())
  216.                         nodesArray.push(node);
  217.                     XB._base.logger.trace("XPATH result nodes length = " + nodesArray.length);
  218.                     result = nodesArray;
  219.                     break;
  220.                 default:
  221.                     throw new this.EXPATHUnexpectedResult(expr, rawResult.resultType);
  222.             }
  223.             XB._base.logger.trace("XPATH (" + expr + ") result is \"" + result + "\"");
  224.             return result;
  225.         }
  226.         catch (e) {
  227.             if (!(e instanceof this.EXPATHNaN)) // this happens pretty often
  228.                 XB._base.logger.warn(this._consts.ERR_XPATH_QUERY_FAILED + ". " + misc.formatError(e));
  229.             throw e;
  230.         }
  231.     },
  232.     
  233.     transformXML: function XBRuntime_transformXML(node, stylesheet) {
  234.         try {
  235.             this._xsltProcessor.importStylesheet(stylesheet);
  236.             return this._xsltProcessor.transformToFragment(node, this._tempDoc);
  237.         }
  238.         finally {
  239.             this._xsltProcessor.reset();
  240.         }
  241.     },
  242.     
  243.     createXBExceptionFromRTError: function XBRuntime_XBEFromRTE(nid, error) {
  244.         var XBE = new XB.types.Exception(nid, XB.types.Exception.types.E_RUNTIME, error.message);
  245.         XBE.name = error.name;
  246.         XBE.fileName = error.fileName;
  247.         XBE.lineNumber = error.lineNumber;
  248.         
  249.         return XBE;
  250.     },
  251.     
  252.     describeValue: function XBRuntime_describeValue(xValue) {
  253.         var valueRank = this._rankValue(xValue);
  254.         var descr = this._typeNames[valueRank];
  255.         if (valueRank > this._ranksMap.Empty && valueRank < this._ranksMap.XML)
  256.             descr += "(" + this.xToString(xValue) + ")";
  257.         if (valueRank == this._ranksMap.Exception)
  258.             descr += "(" + xValue.toString() + ")";
  259.         return descr;
  260.     },
  261.     
  262.     ensureValueTypeIs: function XBRuntime_ensureValueTypeIs(xValue, xType) {
  263.         var valueRank = this._rankValue(xValue);
  264.         var expectedRank = this._ranksMap[xType];
  265.         if (expectedRank === undefined)
  266.             throw new Error("Unknown type name");
  267.         if (expectedRank != valueRank)
  268.             throw new TypeError(xType + " expected, got " + this._typeNames[valueRank]);
  269.     },
  270.     
  271.     _consts: {
  272.         ERR_CANT_CONVERT: "This value conversion is impossible",
  273.         ERR_EXCEPTION_CONV: "Exception objects cannot be converted",
  274.         ERR_XPATH_QUERY_FAILED: "XPATH query failed",
  275.         ERR_UNKNOWN_TYPE: "Unknown type ",
  276.         ERR_NO_CAST_FUNC: "No casting function for this rank"
  277.     },
  278.     
  279.     _tempDoc: XB._Cc["@mozilla.org/xml/xml-document;1"].createInstance(XB._Ci.nsIDOMDocument).implementation.createDocument("", "xbruntime", null),
  280.     _XMLSerializer: XB._Cc["@mozilla.org/xmlextras/xmlserializer;1"].getService(XB._Ci.nsIDOMSerializer),
  281.     _xpathEvaluator: XB._Cc["@mozilla.org/dom/xpath-evaluator;1"].getService(XB._Ci.nsIDOMXPathEvaluator),
  282.     _xsltProcessor: XB._Cc["@mozilla.org/document-transformer;1?type=xslt"].createInstance(XB._Ci.nsIXSLTProcessor),
  283.     _numPattern: /^[+\-]?(\d+\.?|\d*\.\d+)$/,
  284.  
  285.     _typeNames: {
  286.         0: "Empty",
  287.         1: "Bool",
  288.         2: "Number",
  289.         3: "String",
  290.         4: "XML",
  291.         5: "RequestData",
  292.         6: "Exception"
  293.     },
  294.     
  295.     _ranksMap: {
  296.         Empty: 0,
  297.         Bool: 1,
  298.         Number: 2,
  299.         String: 3,
  300.         XML: 4,
  301.         RequestData: 5,
  302.         Exception: 6
  303.     },
  304.     
  305.     _rankValue: function XBRuntime_rankValue(value) {
  306.         if (value === XB.types.empty)
  307.             return this._ranksMap.Empty;
  308.         if (sysutils.isBool(value))
  309.             return this._ranksMap.Bool;
  310.         if (sysutils.isNumber(value))
  311.             return this._ranksMap.Number;
  312.         if (sysutils.isString(value))
  313.             return this._ranksMap.String;
  314.         if (this.isXML(value))
  315.             return this._ranksMap.XML;
  316.         if (this.isRequestData(value))
  317.             return this._ranksMap.RequestData;
  318.         if (this.isException(value))
  319.             return this._ranksMap.Exception;
  320.         
  321.         throw new TypeError(this._consts.ERR_UNKNOWN_TYPE + typeof value);
  322.     },
  323.     
  324.     _castToRank: function XBRuntime_CastToRank(value, rank) {
  325.         var destType = this._typeNames[rank];
  326.         var castFunc = this["xTo" + destType];
  327.         if (castFunc == undefined)
  328.             throw new Error(this._consts.ERR_NO_CAST_FUNC);
  329.         return castFunc.call(this, value);
  330.     },
  331.     
  332.     _checkTypes: function XBRuntime_CheckTypes(value1, value2, mode) {
  333.         var r1 = this._rankValue(value1);
  334.         var r2 = this._rankValue(value2);
  335.         
  336.         if (r1 == r2)
  337.             return [value1, value2, r1];
  338.         
  339.         if (mode == XB._base.runtime.cmpModes.CMP_STRICT ||
  340.             r1 > this._ranksMap.RequestData || r2 > this._ranksMap.RequestData)
  341.             return [value1, value2, NaN];
  342.         
  343.         var maxRank = Math.max(r1, r2);
  344.         var commonRank = (mode == this.cmpModes.CMP_SMART ? Math.min(this._ranksMap.String, maxRank) : maxRank);
  345.         try {
  346.             return [this._castToRank(value1, commonRank), this._castToRank(value2, commonRank), commonRank]
  347.         }
  348.         catch (e) {
  349.             XB._base.logger.warn("Could not cast either '" + this.describeValue(value1) + "' or '" +
  350.                                  this.describeValue(value2) + "' to type '" + this._typeNames[commonRank] + "'");
  351.             return [value1, value2, NaN];
  352.         }
  353.     }
  354. };
  355.  
  356. XB._base.runtime.cmpModes = {
  357.     CMP_STRICT: 0,
  358.     CMP_FREE: 1,
  359.     CMP_SMART: 2
  360. };
  361.  
  362. XB._base.runtime.EXPATH = CustomErrors.ECustom.extend({
  363.     $name: "EXPATH",
  364.     
  365.     constructor: function EXPATH_constructor(expression) {
  366.         this.base();
  367.         this._expr = expression.toString();
  368.     },
  369.     
  370.     _message: "XPATH query error",
  371.     _expr: undefined,
  372.     
  373.     get _details() {
  374.         return [this._expr];
  375.     }
  376. });
  377.  
  378. XB._base.runtime.EXPATHNaN = XB._base.runtime.EXPATH.extend({
  379.     $name: "EXPATHNaN",
  380.     
  381.     _message: "XPATH 'number' expression returned NaN"
  382. });
  383.  
  384. XB._base.runtime.EXPATHUnexpectedResult = XB._base.runtime.EXPATH.extend({
  385.     $name: "EXPATHUnexpectedResult",
  386.     
  387.     constructor: function EXPATHUnexpReslt_constructor(expression, resultType) {
  388.         this.base(expression);
  389.         this._resType = resultType.toString();
  390.     },
  391.     
  392.     _message: "XPATH query error",
  393.     _resType: undefined,
  394.     
  395.     get _details() {
  396.         return [this._expr, this._resType];
  397.     }
  398. });
  399.  
  400. XB._base.WidgetBase = Base.extend({
  401.     constructor: function XBWidgetBase_constructor(id) {
  402.         if (!id)
  403.             throw new Error(this._consts.ERR_ID_REQUIRED);
  404.         this._id = id;
  405.         this._varsMap = {};
  406.         this._dataMap = {};
  407.         this._settingsMap = {};
  408.         this._refsMap = {};
  409.     },
  410.     
  411.     get id() {
  412.         return this._id;
  413.     },
  414.     
  415.     get settings() {
  416.         return sysutils.copyObj(this._settingsMap, false);
  417.     },
  418.     
  419.     findReference: function XBWidgetBase_findReference(refID) {
  420.         var refNode = this._refsMap[refID];
  421.         return refNode? refNode: null;
  422.     },
  423.     
  424.     findVariable: function XBWidgetBase_findVariable(varName) {
  425.         var varNode = this._varsMap[varName];
  426.         return varNode? varNode: null;
  427.     },
  428.     
  429.     findData: function XBWidgetBase_findData(dataName) {
  430.         var dataNode = this._dataMap[dataName];
  431.         return dataNode? dataNode: null;
  432.     },
  433.     
  434.     findSetting: function XBWidgetBase_findSetting(settingName) {
  435.         var setting = this._settingsMap[settingName];
  436.         return setting? setting.node: null;
  437.     },
  438.     
  439.     eraseSettings: function XBWidgetBase_eraseSettings() {
  440.         for each (let setting in this._settingsMap) {
  441.             setting.node.erase();
  442.         }
  443.     },
  444.     
  445.     _consts : {
  446.         WARN_VAR_REDEFINED: "Redefined variable",
  447.         WARN_DATA_REDEFINED: "Redefined data",
  448.         ERR_ID_REQUIRED: "ID required",
  449.         ERR_INVALID_SCOPE: "Widget or instance scope expected"
  450.     },
  451.     _varsMap: null,
  452.     _dataMap: null,
  453.     _settingsMap: null,
  454.     _refsMap: null
  455. });