SHARE
TWEET

Untitled

a guest Feb 14th, 2020 59 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /*
  2. Class:
  3.     df.WebDynamicObjectContainer
  4. Mixin:
  5.     df.WebBaseContainer_mixin
  6. Extends:
  7.     df.WebBaseControl
  8.  
  9. This class is the client-side representation of the WebDynamicObjectContainer. This class
  10. contains the logic required to support dynamic object creation in DataFlex.
  11. */
  12.  
  13. df.tQueuedSyncProp = {
  14.     sO  : df.tString,
  15.     sP  : df.tString,
  16.     bA  : df.tBool,
  17.     sV  : df.tString,
  18.     tVT : {}
  19. }
  20.  
  21. df.tSyncProp = {
  22.     sO : df.tString,
  23.     aP : [{
  24.         sN : df.tString,
  25.         sV : df.tString
  26.     }]
  27. };
  28.  
  29. df.tAdvSyncProp = {
  30.     sO : df.tString,
  31.     sP : df.tString,
  32.     tV : {}
  33. };
  34.  
  35. //  Use the WebBaseContainer_mixin and inherit from WebBaseControl
  36. df.WebDynamicObjectContainerBase = df.mixin("df.WebBaseContainer_mixin", "df.WebBaseControl");
  37.  
  38. df.WebDynamicObjectContainer = function WebDynamicObjectContainer(sName, oParent){
  39.     //  Forward Send
  40.     df.WebDynamicObjectContainer.base.constructor.call(this, sName, oParent);
  41.  
  42.     this.prop(df.tAdv, "paSyncProps", null);
  43.     this.prop(df.tAdv, "paAdvSyncProps", null);
  44.  
  45.     this.addSync("paSyncProps");
  46.     this.addSync("paAdvSyncProps");
  47.  
  48.     // Private variables
  49.     this._aSyncPropQueue  = []; // Contains both regular and advanced syncprops
  50. };
  51.  
  52. df.defineClass("df.WebDynamicObjectContainer", "df.WebDynamicObjectContainerBase", {
  53.  
  54.     /*
  55.     Published method that allows the server to send a list
  56.     of queued synchronized properties to the client so that
  57.     these can be applied after the objects are created.
  58.     */
  59.     loadQueuedSyncProps : function() {
  60.         var sVal = this._tActionData, aQueuedSyncProps = df.sys.vt.deserialize(sVal, [ df.tQueuedSyncProp ]);
  61.  
  62.         for (var tQueuedSyncProp of aQueuedSyncProps) {
  63.             if (tQueuedSyncProp.bA) {
  64.                 tQueuedSyncProp.tV = this.deserializeVT(sVal['c'][4]);
  65.             }
  66.    
  67.             this._aSyncPropQueue.push(tQueuedSyncProp);
  68.         }
  69.     },
  70.  
  71.     /*
  72.     Published method that allows the server to send an new
  73.     structure of dynamic objects to the client to be rendered.
  74.     */
  75.     loadDynamicObjects : function() {
  76.         var oObj, aObjects, aObjNames = [], vtObjects = this._tActionData;
  77.  
  78.         aObjects = this.deserializeObjectDefArray(vtObjects);
  79.  
  80.         for (var tDef of aObjects) {
  81.             oObj = this.initDynamicObject(tDef, this, false, aObjNames);
  82.  
  83.             // Set owner to WebDynamicObjectContainer
  84.             oObj._oOwner = this;
  85.         }
  86.  
  87.         if (this._eElem) {
  88.             this.renderChildren();
  89.             this.afterRender();
  90.             this.position();
  91.  
  92.             this.getWebApp().resize();
  93.             this.finishRendering(aObjNames);
  94.         }
  95.     },
  96.  
  97.     /*
  98.     Published method that allows the server to insert an object
  99.     into the client's data structure.
  100.     */
  101.     insertDynamicObject : function(sParent, sInsertAfter) {
  102.         var tDef, oObj, oParent, oInsertAfter, aObjNames = [], vtObject = this._tActionData, iIndex;
  103.  
  104.         tDef = this.deserializeObjectDef(vtObject);
  105.         oParent = this.getWebApp().findObj(sParent) || this;
  106.         oInsertAfter = oParent[sInsertAfter] || null;
  107.         oObj = this.initDynamicObject(tDef, oParent, true, aObjNames);
  108.        
  109.         if (this._eElem) {
  110.             // Insert the object in its parent's children structure
  111.             iIndex = oInsertAfter !== null ? oParent._aChildren.indexOf(oInsertAfter) + 1 : 0;
  112.             oParent.insertChild(oObj, iIndex);
  113.  
  114.             // Render the child object
  115.             oParent.renderChild(oObj);
  116.  
  117.             this.getWebApp().resize();
  118.             this.finishRendering(aObjNames);
  119.         }
  120.     },
  121.  
  122.     /*
  123.     Published method that allows the server to insert an object
  124.     into the client's data structure. This function specifically
  125.     inserts the object at the beginning of its parent's list of children.
  126.     */
  127.     prependDynamicObject : function(sParent) {
  128.         var tDef, oObj, oParent, aObjNames = [], vtObject = this._tActionData;
  129.  
  130.         tDef = this.deserializeObjectDef(vtObject);
  131.         oParent = this.getWebApp().findObj(sParent) || this;
  132.         oObj = this.initDynamicObject(tDef, oParent, true, aObjNames);
  133.        
  134.         if (this._eElem) {
  135.             // Insert the object in its parent's children structure
  136.             oParent.insertChild(oObj, 0);
  137.  
  138.             // Render the child object
  139.             oParent.renderChild(oObj);
  140.  
  141.             this.getWebApp().resize();
  142.             this.finishRendering(aObjNames);
  143.         }
  144.     },
  145.  
  146.     /*
  147.     Published method that allows the server to insert an object
  148.     into the client's data structure. This function specifically
  149.     inserts the object at the end of its parent's list of children.
  150.     */
  151.     appendDynamicObject : function(sParent) {
  152.         var tDef, oObj, oParent, aObjNames = [], vtObject = this._tActionData, iIndex;
  153.  
  154.         tDef = this.deserializeObjectDef(vtObject);
  155.         oParent = this.getWebApp().findObj(sParent) || this;
  156.         oObj = this.initDynamicObject(tDef, oParent, true, aObjNames);
  157.        
  158.         if (this._eElem) {
  159.             // Insert the object in its parent's children structure
  160.             iIndex = oParent._aUIObjects.length;
  161.             oParent.insertChild(oObj, iIndex);
  162.  
  163.             // Render the child object
  164.             oParent.renderChild(oObj);
  165.  
  166.             this.getWebApp().resize();
  167.             this.finishRendering(aObjNames);
  168.         }
  169.     },
  170.  
  171.     /*
  172.     Published method that moves the given dynamic object
  173.     behind the second passed dynamic object.
  174.     */
  175.     moveDynamicObject : function(sDynamicObjectId, sInsertAfter) {
  176.         var oObj, eObj, oOldParent, oInsertAfter, oNewParent, iResizeCount, webApp = this.getWebApp(), iIndex;
  177.        
  178.         oObj = webApp.findObj(sDynamicObjectId);
  179.         oInsertAfter = webApp.findObj(sInsertAfter);
  180.         oNewParent = oInsertAfter._oParent;
  181.         oOldParent = oObj._oParent;
  182.        
  183.         // Store object's DOM element
  184.         eObj = oObj._eElem;
  185.  
  186.         // Update object's parent
  187.         oObj._oParent = oNewParent;
  188.        
  189.         // Move object
  190.         oOldParent.removeChild(oObj);
  191.  
  192.         iIndex = oInsertAfter !== null ? oNewParent._aChildren.indexOf(oInsertAfter) + 1 : 0;
  193.         oNewParent.insertChild(oObj, iIndex, oInsertAfter);
  194.         oNewParent.renderChild(oObj, eObj);
  195.        
  196.         // Resize the webapp.
  197.         // For some reason, the web app requires x amount of resizes, where
  198.         // x = depth(oObj) - 1. The depth of an object is defined by how
  199.         // far into the object structure it is located, starting from the view.
  200.         iResizeCount = oObj.getObjectLevel();
  201.         for (var i = 0; i < iResizeCount; i++) {
  202.             webApp.resize();
  203.         }
  204.     },
  205.    
  206.     /*
  207.     Published method that moves the given dynamic object
  208.     behind the second passed dynamic object.
  209.     */
  210.     moveDynamicObjectToIndex : function(sDynamicObjectId, sParentId, iIndex) {
  211.         var oObj, eObj, oOldParent, oNewParent, iResizeCount, webApp = this.getWebApp(), iIndex;
  212.        
  213.         oObj = webApp.findObj(sDynamicObjectId);
  214.         oNewParent = webApp.findObj(sParentId);
  215.         oOldParent = oObj._oParent;
  216.        
  217.         // Store object's DOM element
  218.         eObj = oObj._eElem;
  219.  
  220.         // Update object's parent
  221.         oObj._oParent = oNewParent;
  222.        
  223.         // Move object
  224.         oOldParent.removeChild(oObj);
  225.  
  226.         oNewParent.insertChild(oObj, iIndex);
  227.         oNewParent.renderChild(oObj, eObj);
  228.        
  229.         // Resize the webapp.
  230.         // For some reason, the web app requires x amount of resizes, where
  231.         // x = depth(oObj) - 1. The depth of an object is defined by how
  232.         // far into the object structure it is located, starting from the view.
  233.         iResizeCount = oObj.getObjectLevel();
  234.         for (var i = 0; i < iResizeCount; i++) {
  235.             webApp.resize();
  236.         }
  237.     },
  238.    
  239.     /*
  240.     Published method that destroys the given dynamic object
  241.     and removes it from the container.
  242.     */
  243.     destroyDynamicObject : function(sDynamicObjectId) {
  244.         var oObj, oParent, iResizeCount;
  245.  
  246.         oObj = this.getWebApp().findObj(sDynamicObjectId);
  247.  
  248.         oParent = oObj._oParent;
  249.         oParent.removeChild(oObj);
  250.         oParent.unrenderChild(oObj);
  251.  
  252.         // Destroy the actual object
  253.         oObj.destroy();
  254.  
  255.         // Resize the webapp.
  256.         // For some reason, the web app requires x amount of resizes, where
  257.         // x = depth(oObj) - 1. The depth of an object is defined by how
  258.         // far into the object structure it is located, starting from the view.
  259.         iResizeCount = oParent.getObjectLevel();
  260.         for (var i = 0; i < iResizeCount; i++) {
  261.             this.getWebApp().resize();
  262.         }
  263.     },
  264.  
  265.     finishRendering : function(aObjs) {
  266.         tVT = df.sys.vt.serialize(aObjs);
  267.         this.serverAction("FinishRendering", [], tVT);
  268.     },
  269.  
  270.     /*
  271.     Initializes a dynamic web object.
  272.     */
  273.     initDynamicObject : function(tDef, oParent, bInsert, aObjNames) {
  274.         var i, sP, oObj, FConstructor, webApp = this.getWebApp();
  275.  
  276.         //  Check for name conflict
  277.         if(!oParent[tDef.sName]){
  278.  
  279.             //  Find constructor
  280.             FConstructor = webApp.getConstructor(tDef.sType, tDef);
  281.             if(typeof(FConstructor) === "function"){
  282.  
  283.                 //  Create new instance
  284.                 oParent[tDef.sName] = oObj = new FConstructor(tDef.sName, oParent);
  285.             }else{
  286.                 throw new df.Error(999, "Could not find class '{{0}}'", this, [tDef.sType]);
  287.             }
  288.         }else{
  289.             throw new df.Error(999, "Naming conflict with child object '{{0}}'", this, [tDef.sName]);
  290.         }
  291.        
  292.         //  Set the published property values
  293.         for(i = 0; i < tDef.aProps.length; i++){
  294.             sP = tDef.aProps[i].sN;
  295.  
  296.             //  Check naming convention
  297.             if(sP.charAt(0) !== "_"){
  298.                 //  Check if not conficting with child object or function
  299.                 if(!oObj[sP] || (typeof(oObj[sP]) !== "object" && typeof(oObj[sP]) !== "function")){
  300.                     oObj._set(sP, tDef.aProps[i].sV, false, false);
  301.                 }else{
  302.                     throw new df.Error(999, "Naming conflict with property '{{0}}' of object '{{1}}'", this, [ sP,  tDef.sName ] );
  303.                 }
  304.             }else{
  305.                 throw new df.Error(999, "Published property '{{0}}' of object '{{1}}' properties should not start with an '_'", this, [tDef.aProps[i].sV, tDef.sName ]);
  306.             }
  307.         }
  308.  
  309.         //  Set the advanced typed published property values
  310.         if(tDef.aAdvP){
  311.             for(i = 0; i < tDef.aAdvP.length; i++){
  312.                 sP = tDef.aAdvP[i].sN;
  313.  
  314.                 //  Check naming convention
  315.                 if(sP.charAt(0) !== "_"){
  316.                     if(!oObj[sP] || (typeof(oObj[sP]) !== "object" && typeof(oObj[sP]) !== "function")){
  317.                         //  Make sure to mark it as advanced (this is used to determine this when sending a call
  318.                         if(!oObj._oTypes[sP]){
  319.                             oObj._oTypes[sP] = df.tAdv;
  320.                         }
  321.  
  322.                         //  Actually set the property value
  323.                         oObj._set(sP, tDef.aAdvP[i].tV, false, false);
  324.                     }else{
  325.                         throw new df.Error(999, "Naming conflict with property '{{0}}' of object '{{1}}'", this, [ sP,  tDef.sName ] );
  326.                     }
  327.                 }else{
  328.                     throw new df.Error(999, "Published property '{{0}}' of object '{{1}}' properties should not start with an '_'", this, [tDef.aAdvP[i].sV, tDef.sName ]);
  329.                 }
  330.             }
  331.         }
  332.  
  333.         // Apply queued WebSet operations
  334.         this.applyQueuedSyncProps(oObj);
  335.  
  336.         // Set owner to WebDynamicObjectContainer
  337.         oObj._oOwner = this;
  338.  
  339.         if (!bInsert) {
  340.             webApp.newWebObject(oObj, oParent);
  341.         }
  342.  
  343.         //  Create children
  344.         for(i = 0; i < tDef.aObjs.length; i++){
  345.             this.initDynamicObject.call(this, tDef.aObjs[i], oObj, false, aObjNames);
  346.         }
  347.  
  348.         aObjNames.push(oObj._sName);
  349.  
  350.         //  Call create
  351.         oObj.create(tDef);
  352.  
  353.         return oObj;
  354.     },
  355.  
  356.     /*
  357.     Resets the container, including all saved properties.
  358.     */
  359.     resetContainer : function() {
  360.         for (var oControl of this._aChildren){
  361.             oControl.destroy();
  362.         }
  363.  
  364.         this._aChildren = [];
  365.         this._aFloats = [];
  366.         this._aUIObjects = [];
  367.         this._aPanels = [];
  368.  
  369.         // Reset variables
  370.         this._aSyncPropQueue  = [];
  371.  
  372.         this.getWebApp().resize();
  373.     },
  374.  
  375.     /*
  376.     Finds and applies all queued SyncProps for the given dynamic object.
  377.     */
  378.     applyQueuedSyncProps : function(oObj) {
  379.         var vPropValue, aQueue;
  380.  
  381.         aQueue = this._aSyncPropQueue.filter(e => e.sO === oObj.getLongName());
  382.         this._aSyncPropQueue = this._aSyncPropQueue.filter(e => e.sO !== oObj._sName);
  383.  
  384.  
  385.         // Apply queued synchronized property changes
  386.         for (var tQueuedSyncProp of aQueue) {
  387.             if (tQueuedSyncProp.bA) {
  388.                 vPropValue = tQueuedSyncProp.tVT;
  389.             } else {
  390.                 vPropValue = tQueuedSyncProp.sV;
  391.             }
  392.             oObj.addSync(tQueuedSyncProp.sP);
  393.             oObj.set(tQueuedSyncProp.sP, vPropValue);
  394.         }
  395.     },
  396.  
  397.     /*
  398.     This method gathers the synchronized properties for this Web Object.
  399.  
  400.     @param  aObjs   Reference to the array of synchronized property objects to which the properties are added.
  401.     @param  aAdvProps   Reference to the array in which the advanced sync props are gathered.
  402.     @private
  403.     */
  404.     getSynced : function(aObjs, aAdvProps){
  405.         var i, sProp, aProps = [], val, sObj = this.getLongName();
  406.        
  407.         //  Gather synchronized properties
  408.         for(sProp in this._oSynced){
  409.             if(this._oSynced.hasOwnProperty(sProp)){
  410.                 val = this.get(sProp);
  411.                
  412.                 if(this._oTypes[sProp]){
  413.                     val = this.toServerType(val, this._oTypes[sProp]);
  414.                 }
  415.                 if(val === undefined){
  416.                     val = null;
  417.                 }
  418.                
  419.                 //  Switch between advanced and local synchronized properties
  420.                 if(this._oTypes[sProp] === df.tAdv){
  421.                     aAdvProps.push({
  422.                         sO : sObj,
  423.                         sP : sProp,
  424.                         tV : val
  425.                     });
  426.                 }else{
  427.                     aProps.push({
  428.                         sN : sProp,
  429.                         sV : val
  430.                     });
  431.                 }
  432.             }
  433.         }
  434.        
  435.         //  If synced props where found we add it to the list with wrappers
  436.         if(aProps.length > 0){
  437.             aObjs.push({
  438.                 sO : sObj,
  439.                 aP : aProps
  440.             });
  441.         }
  442.     },
  443.  
  444.  
  445.     /*
  446.     Setter method for the server variable 'paSyncProps'.
  447.     Receives data regarding synchronized properties from the server
  448.     and sets the values on the client accordingly.
  449.     */
  450.     set_paSyncProps : function(sVal) {
  451.         var tPropList, webApp = this.getWebApp();
  452.         tPropList = df.sys.vt.deserialize(sVal, [ df.tSyncProp ]);
  453.         webApp.handleSyncProps(tPropList);
  454.     },
  455.  
  456.     /*
  457.     Getter method for the server variable 'paSyncProps'.
  458.     Collects the values of all registered synchronized properties
  459.     and sends them to the server.
  460.     */
  461.     get_paSyncProps : function() {
  462.         var aPropList = [], aAdvPropList = [];
  463.        
  464.         for (var oObj of this._aChildren) {
  465.             oObj.getSynced(aPropList, aAdvPropList);
  466.         }
  467.  
  468.         // Sort the properties array for each object
  469.         for (var iObj in aPropList) {
  470.             aPropList[iObj].aP.sort((a, b) => (a.sN > b.sN) ? 1 : ((b.sN > a.sN) ? -1 : 0))
  471.         }
  472.  
  473.         return df.sys.vt.serialize(aPropList, [ this._tSyncProp ]);
  474.     },
  475.  
  476.     /*
  477.     Setter method for the server variable 'paAdvSyncProps'.
  478.     Receives data regarding advanced synchronized properties from
  479.     the server and sets the values on the client accordingly.
  480.     */
  481.     set_paAdvSyncProps : function(sVal) {
  482.         var tPropList, webApp = this.getWebApp();
  483.  
  484.         tPropList = df.sys.vt.deserialize(sVal, [ df.tAdvSyncProp ]);
  485.  
  486.         for (var i = 0; i < sVal['c'].length; i++) {
  487.             tPropList[i].tV = sVal['c'][i]['c'][2];
  488.             this.addAdvSyncProp(tPropList[i].sO, tPropList[i].sP);
  489.         }
  490.  
  491.         webApp.handleAdvSyncProps(tPropList);
  492.     },
  493.  
  494.     /*
  495.     Getter method for the server variable 'paAdvSyncProps'.
  496.     Collects the values of all registered advanced
  497.     synchronized properties and sends them to the server.
  498.     */
  499.     get_paAdvSyncProps : function() {
  500.         var aPropList = [], aAdvPropList = [];
  501.        
  502.         for (var oObj of this._aChildren) {
  503.             oObj.getSynced(aPropList, aAdvPropList);
  504.         }
  505.  
  506.         // Sort the properties array for each object
  507.         for (var iObj in aAdvPropList) {
  508.             aAdvPropList[iObj].aP.sort((a, b) => (a.sN > b.sN) ? 1 : ((b.sN > a.sN) ? -1 : 0))
  509.         }
  510.  
  511.         return this.serializeAdvSyncProps(aAdvPropList);
  512.     },
  513.  
  514.     /*
  515.     Sends an action to the server to be executed.
  516.     */
  517.     handleAction : function(oActionObj){
  518.         var oAction = [];
  519.  
  520.         oAction.push({
  521.             sTarget : oActionObj.oWO._sName,
  522.             sAction : oActionObj.sAction,
  523.             aParams : oActionObj.aParams,
  524.             tData   : oActionObj.tData
  525.         });
  526.  
  527.         var tVT = df.sys.vt.serialize(oAction);
  528.         this.serverAction("DynamicServerAction", [], tVT, oActionObj.fHandler, oActionObj.oHandlerEnv);
  529.     },
  530.  
  531.     onFocus : function(oEV){
  532.         //  Intercept onfocus as a container cannot take the focus
  533.     },
  534.  
  535.     onBlur : function(oEV){
  536.         //  Intercept onfocus as a container cannot take the focus
  537.     },
  538.  
  539.     /*
  540.     Deserializes a value tree
  541.     */
  542.     deserializeVT : function(tVT) {
  543.         function parseWebValueTreeValue(tVT) {
  544.             var a = [],
  545.                 i;
  546.             for (i = 0; i < tVT.c.length; i++) {
  547.                 a.push(parseWebValueTreeValue(tVT.c[i]));
  548.             }
  549.             return a;
  550.         }
  551.  
  552.         return {
  553.             v: tVT.c[0].v,
  554.             c: parseWebValueTreeValue(tVT.c[1])
  555.         };
  556.     },
  557.  
  558.     /*
  559.     Serializes a value tree
  560.     */
  561.     serializeVT : function(tStruct) {
  562.         function composeWebValueTreeValue(oObj) {
  563.             return {
  564.                 v: "",
  565.                 c: composeWebValueTree(oObj["c"])
  566.             };
  567.         }
  568.    
  569.         function composeWebValueTree(oObj) {
  570.             return {
  571.                 v: "",
  572.                 c: [{
  573.                     v: oObj["v"].toString(),
  574.                     c: []
  575.                 }, composeWebValueTreeValue(oObj["c"])]
  576.             };
  577.         }
  578.         try {
  579.             return composeWebValueTree(tStruct);
  580.         } catch (oErr) {
  581.             throw new df.Error(999, "Unable to serialize valuetree, invalid data format!\n\r\n\rMSG: {{0}}", this, [oErr.message]);
  582.         }
  583.     },
  584.  
  585.     /*
  586.     Deserializes an object definition value tree.
  587.     */
  588.     deserializeObjectDef : function(tVT) {
  589.         function parseObject(tVT) {
  590.             return {
  591.                 sName: tVT.c[0].v,
  592.                 sType: tVT.c[1].v,
  593.                 aProps: parsePropArray(tVT.c[2]),
  594.                 aAdvP: parseAdvPropArray(tVT.c[3]),
  595.                 aObjs: parseChildren(tVT.c[4])
  596.             };
  597.         }
  598.  
  599.         function parsePropArray(tVT) {
  600.             var a = [],
  601.                 i;
  602.             for (i = 0; i < tVT.c.length; i++) {
  603.                 a.push(parseProp(tVT.c[i]));
  604.             }
  605.             return a;
  606.         }
  607.  
  608.         function parseProp(tVT) {
  609.             return {
  610.                 sN: tVT.c[0].v,
  611.                 sV: tVT.c[1].v
  612.             };
  613.         }
  614.  
  615.         function parseAdvPropArray(tVT) {
  616.             var a = [],
  617.                 i;
  618.             for (i = 0; i < tVT.c.length; i++) {
  619.                 a.push(parseAdvProp(tVT.c[i]));
  620.             }
  621.             return a;
  622.         }
  623.  
  624.         function parseAdvProp(tVT) {
  625.             return {
  626.                 sN: tVT.c[0].v,
  627.                 tV: df.WebDynamicObjectContainer.prototype.deserializeVT(tVT.c[1])
  628.             };
  629.         }
  630.    
  631.         function parseChildren(tVT) {
  632.             return df.WebDynamicObjectContainer.prototype.deserializeObjectDefArray(tVT);
  633.         }
  634.  
  635.         try {
  636.             return parseObject(tVT);
  637.         } catch (oErr) {
  638.             throw new df.Error(999, "Unable to deserialize object, invalid data format!\n\r\n\rMSG: {{0}}", this, [oErr.message]);
  639.         }
  640.     },
  641.  
  642.     /*
  643.     Deserializes a list of object definitions
  644.     */
  645.     deserializeObjectDefArray : function(tVT) {
  646.         function parseObjectArray(tVT) {
  647.             var a = [],
  648.                 i;
  649.             for (i = 0; i < tVT.c.length; i++) {
  650.                 a.push(df.WebDynamicObjectContainer.prototype.deserializeObjectDef(tVT.c[i]));
  651.             }
  652.  
  653.             return a;
  654.         }
  655.  
  656.         try {
  657.             return parseObjectArray(tVT);
  658.         } catch (oErr) {
  659.             throw new df.Error(999, "Unable to deserialize object array, invalid data format!\n\r\n\rMSG: {{0}}", this, [oErr.message]);
  660.         }
  661.     },
  662.  
  663.     /*
  664.     Serializes an array of advanced syncprops
  665.     */
  666.     serializeAdvSyncProps :function(tStruct) {
  667.         function composeAdvSyncProp(oObj) {
  668.             return {
  669.                 v: "",
  670.                 c: [{
  671.                     v: oObj["sO"].toString(),
  672.                     c: []
  673.                 }, {
  674.                     v: oObj["sP"].toString(),
  675.                     c: []
  676.                 }, this.serializeVT(oObj["tV"])]
  677.             };
  678.         }
  679.    
  680.         function composeAdvSyncPropsArray(aArray) {
  681.             var tVT = {
  682.                     v: "",
  683.                     c: []
  684.                 },
  685.                 i;
  686.             for (i = 0; i < aArray.length; i++) {
  687.                 tVT.c.push(composeAdvSyncProp(aArray[i]));
  688.             }
  689.             return tVT;
  690.         }
  691.    
  692.         function composeAdvSyncPropsObject(oObj) {
  693.             return {
  694.                 v: "",
  695.                 c: [{
  696.                     v: oObj["sO"].toString(),
  697.                     c: []
  698.                 }, composeAdvSyncPropsArray(oObj["aP"])]
  699.             };
  700.         }
  701.    
  702.         function composeAdvSyncPropsObjectArray(aArray) {
  703.             var tVT = {
  704.                     v: "",
  705.                     c: []
  706.                 },
  707.                 i;
  708.             for (i = 0; i < aArray.length; i++) {
  709.                 tVT.c.push(composeAdvSyncPropsObject(aArray[i]));
  710.             }
  711.             return tVT;
  712.         }
  713.         try {
  714.             return composeAdvSyncPropsObjectArray(tStruct);
  715.         } catch (oErr) {
  716.             throw new df.Error(999, "Unable to serialize AdvSyncProps array, invalid data format!\n\r\n\rMSG: {{0}}", this, [oErr.message]);
  717.         }
  718.     }
  719. });
  720.  
  721.  
  722. df.WebObject.prototype.getObjectLevel = function() {
  723.     var oObj = this, oView = this.getView(), iLevel = 0;
  724.  
  725.     while(oObj !== oView){
  726.         oObj = oObj._oParent;
  727.         iLevel++;
  728.     }
  729.  
  730.     return iLevel;
  731. }
  732.  
  733. /*
  734. Inserts a new child after the passed existing child.
  735. */
  736. df.WebObject.prototype.insertChild = function(oChild, iIndex) {
  737.     this._aChildren.splice(iIndex, 0, oChild);
  738. }
  739.  
  740. /*
  741. Renders the given child.
  742.  
  743. If eOptChild is passed as a parameter, this function will not freshly
  744. render the oChild object, but rather used the passed DOM element.
  745. */
  746. df.WebObject.prototype.renderChild = function(oChild, eOptChild) {
  747.     // Subclasses of cWebObject class will implement this method
  748. }
  749.  
  750. /*
  751. Removes the child from the parent's list of children.
  752. */
  753. df.WebObject.prototype.removeChild = function(oChild) {
  754.     var iIndex = this._aChildren.indexOf(oChild);
  755.     if (iIndex !== -1) {
  756.         this._aChildren.splice(iIndex, 1);
  757.     }
  758. }
  759.  
  760. /*
  761. Unrenders the given child.
  762. */
  763. df.WebObject.prototype.unrenderChild = function(oChild) {
  764.     // Subclasses of cWebObject class will implement this method
  765. }
  766.  
  767.  
  768. df.WebBaseContainer.prototype.insertChild = function(oChild, iIndex) {
  769.     if(oChild instanceof df.WebBaseUIObject){
  770.         if(oChild._bFloating){
  771.             this._aFloats.push(oChild);
  772.         }else if(oChild.peRegion !== undefined){
  773.             this._bPanels = true;
  774.             this._aPanels.push(oChild);
  775.         }else{
  776.             this._aUIObjects.splice(iIndex, 0, oChild);
  777.         }
  778.     }
  779.  
  780.     this.getBase("df.WebBaseContainer_mixin").insertChild.call(this, oChild, iIndex);
  781. }
  782.  
  783. df.WebBaseContainer.prototype.renderChild = function(oChild, eOptChild) {
  784.     var eChild, oInsertAfter, eBefore, iIndex, bMoveOperation;
  785.  
  786.     if (eOptChild) {
  787.         bMoveOperation = true;
  788.     }
  789.  
  790.     iIndex = this._aUIObjects.indexOf(oChild);
  791.     oInsertAfter = iIndex >= 1 ? this._aUIObjects[iIndex - 1] : null;
  792.     eChild = eOptChild || oChild.render();
  793.  
  794.     if (oChild instanceof df.WebPanel) {
  795.         switch (oChild.peRegion) {
  796.             case df.ciRegionBottom:
  797.                 this._eRegionBottom = eChild;
  798.                 this._oRegionBottom = oChild;
  799.                 break;
  800.  
  801.             case df.ciRegionCenter:
  802.                 this._eRegionCenter = eChild;
  803.                 this._oRegionCenter = oChild;
  804.                 break;
  805.  
  806.             case df.ciRegionLeft:
  807.                 this._eRegionLeft = eChild;
  808.                 this._oRegionLeft = oChild;
  809.                 break;
  810.  
  811.             case df.ciRegionRight:
  812.                 this._eRegionRight = eChild;
  813.                 this._oRegionRight = oChild;
  814.                 break;
  815.  
  816.             case df.ciRegionTop:
  817.                 this._eRegionTop = eChild;
  818.                 this._oRegionTop = oChild;
  819.                 break;
  820.         }
  821.  
  822.         this.placePanels();
  823.     } else if (this._eContent) {
  824.         if (eChild) {
  825.             if (oInsertAfter !== null) {
  826.                 eBefore = oInsertAfter._eElem.nextElementSibling;
  827.             } else {
  828.                 // oInsertAfter is null when the element to be inserted is the first
  829.                 // child object of its parent.
  830.                 eBefore = this._eContent.firstElementChild;
  831.             }
  832.  
  833.             this._eContent.insertBefore(eChild, eBefore);
  834.         }
  835.     }
  836.  
  837.    
  838.     if (!bMoveOperation) {
  839.         oChild.afterRender();
  840.     }
  841.    
  842.     this.position();
  843.  
  844.     this.getBase("df.WebBaseContainer_mixin").renderchild.call(this, oChild, eOptChild);
  845. }
  846.  
  847. df.WebBaseContainer.prototype.removeChild = function(oChild) {
  848.     var iIndex;
  849.  
  850.     if (oChild instanceof df.WebBaseUIObject) {
  851.         if(oChild._bFloating){
  852.             iIndex = this._aFloats.indexOf(oChild);
  853.             this._aFloats.splice(iIndex, 1);
  854.         }else if(oChild.peRegion !== undefined){
  855.             iIndex = this._aPanels.indexOf(oChild);
  856.  
  857.             if (this._aPanels.length === 0) {
  858.                 this._bPanels = false;
  859.             }
  860.            
  861.             this._aPanels.splice(iIndex, 1);
  862.         }else{
  863.             iIndex = this._aUIObjects.indexOf(oChild);
  864.             this._aUIObjects.splice(iIndex, 1);
  865.         }
  866.     }
  867.  
  868.     this.getBase("df.WebBaseContainer_mixin").removeChild.call(this, oChild);
  869. }
  870.  
  871. df.WebBaseContainer.prototype.unrenderChild = function(oChild) {
  872.     var eChild;
  873.  
  874.     eChild = oChild._eElem;
  875.  
  876.     if (oChild instanceof df.WebPanel) {
  877.         switch (oChild.peRegion) {
  878.             case df.ciRegionBottom:
  879.                 this._eRegionBottom = null;
  880.                 this._oRegionBottom = null;
  881.                 break;
  882.  
  883.             case df.ciRegionCenter:
  884.                 this._eRegionCenter = null;
  885.                 this._oRegionCenter = null;
  886.                 break;
  887.  
  888.             case df.ciRegionLeft:
  889.                 this._eRegionLeft = null;
  890.                 this._oRegionLeft = null;
  891.                 break;
  892.  
  893.             case df.ciRegionRight:
  894.                 this._eRegionRight = null;
  895.                 this._oRegionRight = null;
  896.                 break;
  897.  
  898.             case df.ciRegionTop:
  899.                 this._eRegionTop = null;
  900.                 this._oRegionTop = null;
  901.                 break;
  902.         }
  903.     } else {
  904.         this._eContent.removeChild(eChild);
  905.     }
  906.  
  907.     this.position();
  908.  
  909.     this.getBase("df.WebBaseContainer_mixin").unrenderChild.call(this, oChild);
  910. }
  911.  
  912.  
  913. df.WebGroup.prototype.insertChild = function(oChild, iIndex) {
  914.     if(oChild instanceof df.WebBaseUIObject){
  915.         if(oChild._bFloating){
  916.             this._aFloats.push(oChild);
  917.         }else if(oChild.peRegion !== undefined){
  918.             this._bPanels = true;
  919.             this._aPanels.push(oChild);
  920.         }else{
  921.             this._aUIObjects.splice(iIndex, 0, oChild);
  922.         }
  923.     }
  924.  
  925.     df.WebGroup.base.insertChild.call(this, oChild, iIndex);
  926. }
  927.  
  928. df.WebGroup.prototype.renderChild = function(oChild, eOptChild) {
  929.     var eChild, oInsertAfter, eBefore, iIndex, bMoveOperation;
  930.  
  931.     if (eOptChild) {
  932.         bMoveOperation = true;
  933.     }
  934.  
  935.     iIndex = this._aUIObjects.indexOf(oChild);
  936.     oInsertAfter = iIndex >= 1 ? this._aUIObjects[iIndex - 1] : null;
  937.     eChild = eOptChild || oChild.render();
  938.  
  939.     if (oChild instanceof df.WebPanel) {
  940.         switch (oChild.peRegion) {
  941.             case df.ciRegionBottom:
  942.                 this._eRegionBottom = eChild;
  943.                 this._oRegionBottom = oChild;
  944.                 break;
  945.  
  946.             case df.ciRegionCenter:
  947.                 this._eRegionCenter = eChild;
  948.                 this._oRegionCenter = oChild;
  949.                 break;
  950.  
  951.             case df.ciRegionLeft:
  952.                 this._eRegionLeft = eChild;
  953.                 this._oRegionLeft = oChild;
  954.                 break;
  955.  
  956.             case df.ciRegionRight:
  957.                 this._eRegionRight = eChild;
  958.                 this._oRegionRight = oChild;
  959.                 break;
  960.  
  961.             case df.ciRegionTop:
  962.                 this._eRegionTop = eChild;
  963.                 this._oRegionTop = oChild;
  964.                 break;
  965.         }
  966.  
  967.         this.placePanels();
  968.     } else if (this._eContent) {
  969.         if (eChild) {
  970.             if (oInsertAfter !== null) {
  971.                 eBefore = oInsertAfter._eElem.nextElementSibling;
  972.             } else {
  973.                 // oInsertAfter is null when the element to be inserted is the first
  974.                 // child object of its parent.
  975.                 eBefore = this._eContent.firstElementChild;
  976.             }
  977.  
  978.             this._eContent.insertBefore(eChild, eBefore);
  979.         }
  980.     }
  981.  
  982.    
  983.     if (!bMoveOperation) {
  984.         oChild.afterRender();
  985.     }
  986.    
  987.     this.position();
  988.  
  989.     df.WebGroup.base.renderChild.call(this, oChild, eOptChild);
  990. }
  991.  
  992. df.WebGroup.prototype.removeChild = function(oChild) {
  993.     var iIndex;
  994.  
  995.     if (oChild instanceof df.WebBaseUIObject) {
  996.         if(oChild._bFloating){
  997.             iIndex = this._aFloats.indexOf(oChild);
  998.             this._aFloats.splice(iIndex, 1);
  999.         }else if(oChild.peRegion !== undefined){
  1000.             iIndex = this._aPanels.indexOf(oChild);
  1001.  
  1002.             if (this._aPanels.length === 0) {
  1003.                 this._bPanels = false;
  1004.             }
  1005.            
  1006.             this._aPanels.splice(iIndex, 1);
  1007.         }else{
  1008.             iIndex = this._aUIObjects.indexOf(oChild);
  1009.             this._aUIObjects.splice(iIndex, 1);
  1010.         }
  1011.     }
  1012.  
  1013.     df.WebGroup.base.removeChild.call(this, oChild);
  1014. }
  1015.  
  1016. df.WebGroup.prototype.unrenderChild = function(oChild) {
  1017.     var eChild;
  1018.  
  1019.     eChild = oChild._eElem;
  1020.  
  1021.     if (oChild instanceof df.WebPanel) {
  1022.         switch (oChild.peRegion) {
  1023.             case df.ciRegionBottom:
  1024.                 this._eRegionBottom = null;
  1025.                 this._oRegionBottom = null;
  1026.                 break;
  1027.  
  1028.             case df.ciRegionCenter:
  1029.                 this._eRegionCenter = null;
  1030.                 this._oRegionCenter = null;
  1031.                 break;
  1032.  
  1033.             case df.ciRegionLeft:
  1034.                 this._eRegionLeft = null;
  1035.                 this._oRegionLeft = null;
  1036.                 break;
  1037.  
  1038.             case df.ciRegionRight:
  1039.                 this._eRegionRight = null;
  1040.                 this._oRegionRight = null;
  1041.                 break;
  1042.  
  1043.             case df.ciRegionTop:
  1044.                 this._eRegionTop = null;
  1045.                 this._oRegionTop = null;
  1046.                 break;
  1047.         }
  1048.     } else {
  1049.         this._eContent.removeChild(eChild);
  1050.     }
  1051.  
  1052.     this.position();
  1053.     df.WebGroup.base.unrenderChild.call(this, oChild);
  1054. }
  1055.  
  1056.  
  1057. df.WebDynamicObjectContainer.prototype.insertChild = function(oChild, iIndex) {
  1058.     if(oChild instanceof df.WebBaseUIObject){
  1059.         if(oChild._bFloating){
  1060.             this._aFloats.push(oChild);
  1061.         }else if(oChild.peRegion !== undefined){
  1062.             this._bPanels = true;
  1063.             this._aPanels.push(oChild);
  1064.         }else{
  1065.             this._aUIObjects.splice(iIndex, 0, oChild);
  1066.         }
  1067.     }
  1068.  
  1069.     df.WebDynamicObjectContainer.base.insertChild.call(this, oChild, iIndex);
  1070. },
  1071.  
  1072. df.WebDynamicObjectContainer.prototype.renderChild = function(oChild, eOptChild) {
  1073.     var eChild, oInsertAfter, eBefore, iIndex, bMoveOperation;
  1074.  
  1075.     if (eOptChild) {
  1076.         bMoveOperation = true;
  1077.     }
  1078.  
  1079.     iIndex = this._aUIObjects.indexOf(oChild);
  1080.     oInsertAfter = iIndex >= 1 ? this._aUIObjects[iIndex - 1] : null;
  1081.     eChild = eOptChild || oChild.render();
  1082.  
  1083.     if (oChild instanceof df.WebPanel) {
  1084.         switch (oChild.peRegion) {
  1085.             case df.ciRegionBottom:
  1086.                 this._eRegionBottom = eChild;
  1087.                 this._oRegionBottom = oChild;
  1088.                 break;
  1089.  
  1090.             case df.ciRegionCenter:
  1091.                 this._eRegionCenter = eChild;
  1092.                 this._oRegionCenter = oChild;
  1093.                 break;
  1094.  
  1095.             case df.ciRegionLeft:
  1096.                 this._eRegionLeft = eChild;
  1097.                 this._oRegionLeft = oChild;
  1098.                 break;
  1099.  
  1100.             case df.ciRegionRight:
  1101.                 this._eRegionRight = eChild;
  1102.                 this._oRegionRight = oChild;
  1103.                 break;
  1104.  
  1105.             case df.ciRegionTop:
  1106.                 this._eRegionTop = eChild;
  1107.                 this._oRegionTop = oChild;
  1108.                 break;
  1109.         }
  1110.  
  1111.         this.placePanels();
  1112.     } else if (this._eContent) {
  1113.         if (eChild) {
  1114.             if (oInsertAfter !== null) {
  1115.                 eBefore = oInsertAfter._eElem.nextElementSibling;
  1116.             } else {
  1117.                 // oInsertAfter is null when the element to be inserted is the first
  1118.                 // child object of its parent.
  1119.                 eBefore = this._eContent.firstElementChild;
  1120.             }
  1121.  
  1122.             this._eContent.insertBefore(eChild, eBefore);
  1123.         }
  1124.     }
  1125.  
  1126.    
  1127.     if (!bMoveOperation) {
  1128.         oChild.afterRender();
  1129.     }
  1130.    
  1131.     this.position();
  1132.  
  1133.     df.WebDynamicObjectContainer.base.renderChild(oChild);
  1134. },
  1135.  
  1136. df.WebDynamicObjectContainer.prototype.removeChild = function(oChild) {
  1137.     var iIndex;
  1138.  
  1139.     if (oChild instanceof df.WebBaseUIObject) {
  1140.         if(oChild._bFloating){
  1141.             iIndex = this._aFloats.indexOf(oChild);
  1142.             this._aFloats.splice(iIndex, 1);
  1143.         }else if(oChild.peRegion !== undefined){
  1144.             iIndex = this._aPanels.indexOf(oChild);
  1145.  
  1146.             if (this._aPanels.length === 0) {
  1147.                 this._bPanels = false;
  1148.             }
  1149.            
  1150.             this._aPanels.splice(iIndex, 1);
  1151.         }else{
  1152.             iIndex = this._aUIObjects.indexOf(oChild);
  1153.             this._aUIObjects.splice(iIndex, 1);
  1154.         }
  1155.     }
  1156.  
  1157.     df.WebDynamicObjectContainer.base.removeChild.call(this, oChild);
  1158. },
  1159.  
  1160. df.WebDynamicObjectContainer.prototype.unrenderChild = function(oChild) {
  1161.     var eChild;
  1162.  
  1163.     eChild = oChild._eElem;
  1164.  
  1165.     if (oChild instanceof df.WebPanel) {
  1166.         switch (oChild.peRegion) {
  1167.             case df.ciRegionBottom:
  1168.                 this._eRegionBottom = null;
  1169.                 this._oRegionBottom = null;
  1170.                 break;
  1171.  
  1172.             case df.ciRegionCenter:
  1173.                 this._eRegionCenter = null;
  1174.                 this._oRegionCenter = null;
  1175.                 break;
  1176.  
  1177.             case df.ciRegionLeft:
  1178.                 this._eRegionLeft = null;
  1179.                 this._oRegionLeft = null;
  1180.                 break;
  1181.  
  1182.             case df.ciRegionRight:
  1183.                 this._eRegionRight = null;
  1184.                 this._oRegionRight = null;
  1185.                 break;
  1186.  
  1187.             case df.ciRegionTop:
  1188.                 this._eRegionTop = null;
  1189.                 this._oRegionTop = null;
  1190.                 break;
  1191.         }
  1192.     } else {
  1193.         this._eContent.removeChild(eChild);
  1194.     }
  1195.  
  1196.     this.position();
  1197.  
  1198.     df.WebDynamicObjectContainer.base.unrenderChild.call(this, oChild);
  1199. }
  1200.  
  1201.  
  1202. df.WebList.prototype.insertChild = function(oChild, iIndex) {
  1203.     if(oChild._bIsColumn){
  1204.         oChild._iColIndex = this._iColCount++;
  1205.         oChild._iCol = this._aColumns.length;
  1206.         this._aColumns.splice(iIndex, 0, oChild);
  1207.     }
  1208.     if(oChild._bIsSwipeButton){
  1209.         oChild._iColIndex = this._iColCount++;
  1210.         this._aSwipeBtns.splice(iIndex, 0, oChild);
  1211.     }
  1212.    
  1213.     df.WebList.base.insertChild.call(this, oChild, iIndex);
  1214. }
  1215.  
  1216. df.WebList.prototype.renderChild = function(oChild, eOptChild) {
  1217.     this.redraw();
  1218.     df.WebList.base.renderChild.call(this, oChild, eOptChild);
  1219. }
  1220.  
  1221. df.WebList.prototype.removeChild = function(oChild) {
  1222.     var iIndex = this._aChildren.indexOf(oChild);
  1223.  
  1224.     if(oChild._bIsColumn){
  1225.         oChild._iColIndex = this._iColCount--;
  1226.         oChild._iCol = this._aColumns.length;
  1227.         this._aColumns.splice(iIndex, 1);
  1228.     }
  1229.     if(oChild._bIsSwipeButton){
  1230.         oChild._iColIndex = this._iColCount--;
  1231.         this._aSwipeBtns.splice(iIndex, 1);
  1232.     }
  1233.  
  1234.     df.WebList.base.removeChild.call(this, oChild);
  1235. }
  1236.  
  1237. df.WebList.prototype.unrenderChild = function(oChild) {
  1238.     this.redraw();
  1239.     df.WebList.base.unrenderChild.call(this, oChild);
  1240. }
  1241.  
  1242. /*
  1243.  
  1244.     New WebApp methods
  1245.  
  1246. */
  1247. df.WebApp.prototype.getOwner = function() {
  1248.     return this;
  1249. },
  1250.  
  1251. df.WebApp.prototype.findObj = function(sName) {
  1252.     var i, aParts, oObj;
  1253.  
  1254.     if(sName === ""){
  1255.         return this;
  1256.     }
  1257.  
  1258.     aParts = sName.split(/[\. | \$]/);
  1259.  
  1260.     oObj = this;
  1261.     for(i = 0; i < aParts.length && oObj; i++){
  1262.         oObj = oObj[aParts[i]];
  1263.     }
  1264.  
  1265.     return (typeof oObj === "object" && oObj) || null;
  1266. }
  1267.  
  1268.  
  1269. /*
  1270.  
  1271.     New WebObject properties
  1272.  
  1273. */
  1274. df.WebObject.prototype._oOwner = null;
  1275.  
  1276.  
  1277. /*
  1278.  
  1279.     New WebObject methods
  1280.  
  1281. */
  1282. df.WebObject.prototype.getLongName = function() {
  1283.     var sName, oOwner, sDivider;
  1284.  
  1285.     if(this instanceof df.WebApp){
  1286.         return "";
  1287.     }
  1288.  
  1289.     sName = (this._oParent && this._oParent.getLongName()) || "";
  1290.     oOwner = this.getOwner();
  1291.     sDivider = ".";
  1292.  
  1293.     if (sName) {
  1294.         if (oOwner !== this.getWebApp()) {
  1295.             if (this._oParent === oOwner) {
  1296.                 sDivider = "$";
  1297.             }
  1298.         }
  1299.    
  1300.         sName = sName + sDivider + this._sName;
  1301.     } else {
  1302.         sName = this._sName;
  1303.     }
  1304.  
  1305.     return sName;
  1306. }
  1307.  
  1308. df.WebObject.prototype.getOwner = function() {
  1309.     if (this._oParent instanceof df.WebDynamicObjectContainer) {
  1310.         return this._oParent;
  1311.     } else {
  1312.         return this._oParent.getOwner();
  1313.     }
  1314. }
  1315.  
  1316. df.WebObject.prototype.serverActionEx = function(oConf){
  1317.     var oView, sMethod, oAction = new df.ServerAction();
  1318.  
  1319.     //  Configure action
  1320.     oAction.oWO = this;
  1321.     oAction.sAction = sMethod = oConf.sMethod;
  1322.     oAction.aParams = oConf.aParams || [];
  1323.     oAction.tData = oConf.tData || null;
  1324.     oAction.fHandler = oConf.fHandler || null;
  1325.     oAction.oHandlerEnv = oConf.oHandlerEnv || this;
  1326.     oAction.aViews = oConf.aViews || [];
  1327.  
  1328.     //  Add current view
  1329.     oView = this.getView();
  1330.     if(oView){
  1331.         oAction.aViews.push(oView);
  1332.     }
  1333.  
  1334.     //  Determine call mode
  1335.     if(oConf.eCallMode){
  1336.         oAction.eCallMode = oConf.eCallMode;
  1337.     }else{
  1338.         oAction.eCallMode = this._oServerActionModes[sMethod.toLowerCase()] || df.cCallModeDefault;
  1339.         if(oAction.eCallMode === df.cCallModeProgress && this._oServerWaitMsg[sMethod.toLowerCase()] ){
  1340.             oAction.sProcessMessage = this._oServerWaitMsg[sMethod.toLowerCase()];
  1341.         }
  1342.     }
  1343.  
  1344.     //  Pass on to owner object
  1345.     this.getOwner().handleAction(oAction);
  1346. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Top