/* AUTO-GENERATED FILE - DO NOT EDIT. @title: tealeafOptimized.js @date: auto-generated @author: yoshi chen @desc: File is auto-generated from multiple source files to optimize tealeaf files */ /* * Copyright © 1999-2009 TeaLeaf Technology, Inc. * All rights reserved. * * THIS SOFTWARE IS PROVIDED BY TEALEAF ``AS IS'' * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE DISCLAIMED. * IN NO EVENT SHALL TEALEAF BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF * THE POSSIBILITY OF SUCH DAMAGE. * * @fileoverview * This is the configuration for the main UI Client Event Capture JavaScript. * It contains versioning information and the the flag thant turns * the JavaScript into a true SDK. * * @version 2009.09.24.1 * */ if(typeof TeaLeaf == "undefined"){ var TeaLeaf = {}; TeaLeaf.tlStartLoad = new Date(); if(typeof TeaLeaf.Configuration == "undefined"){ TeaLeaf.Configuration = { "tlinit" : false, "tlversion" : "2009.09.24.1", "tlSDK" : false }; } if (TeaLeaf.$C == null) { //#ifndef TLT_XML_VERBOSE /* The following data object is used to map the verbose constants used * in the SDK's POST data to their encoded version. A reverse mapping * is done during replay to preserve the user-friendly UI. * * WARNING: DO NOT EDIT THIS UNLESS YOU KNOW WHAT YOU ARE DOING! */ TeaLeaf._C = { // Shared True: "True", False: "False", // ClientEvent tag ClientEvent: "CE", XPath: "XP", ValueIn: "VI", KeyCode: "KC", KeyCount: "KI", Excluded: "EX", TimeInControl: "TI", VisitOrder: "VO", MouseMove: "MM", AltKey: "AltKey", CtrlKey: "CtrlKey", ShiftKey: "ShiftKey", NodeName: "NodeName", NodeValue: "NodeValue", InputFields: "InputFields", InputFieldCount: "InputFieldCount", Field: "Field", Status: "Status", Features: "Features", Replace: "Replace", ClientX: "ClientX", ClientY: "ClientY", ScreenX: "ScreenX", ScreenY: "ScreenY", ScrollHeight: "ScrollHeight", ScrollWidth: "ScrollWidth", ScrollTop: "ScrollTop", ScrollLeft: "ScrollLeft", Action: "ACT", Source: "SRC", PageId: "PID", Count: "A", Type: "B", SubType: "C", Id: "D", Name: "E", ElementType: "F", TagName: "G", TimeDuration: "H", DateSince1970: "I", // CUI CUI: "CUI", DateStamp: "DS", // Info tag Info: "Info", PageLoadMilliSecs: "J", Version: "K", TimezoneOffset: "L", // Document tag Document: "Doc", URL: "URL", Title: "M", LastModified: "N", Anchors: "O", Forms: "P", Images: "Q", Links: "R", Referer: "S", ContentType: "T", CharacterSet: "U", Height: "V", Width: "W", Applets: "X", Embeds: "Y", BadImages: "Z", Plugins: "AB", // Window tag Window: "Win", WindowProtocol: "AA", WindowHref: "AC", WindowHost: "AD", WindowHostName: "AE", WindowPort: "AF", WindowPathName: "AG", ClientSize: "AH", FullScreen: "AI", Frames: "AJ", WindowId: "WindowId", // Navigator tag Navigator: "Nav", AppCodeName: "AK", AppName: "AL", AppVersion: "AM", BrowserLanguage: "AN", CookieEnabled: "AO", CPUClass: "AP", Language: "AQ", OSCPU: "AR", Platform: "AS", Product: "AT", SystemLanguage: "AU", UserAgent: "AV", UserLanguage: "AW", Vendor: "AX", VendorSub: "AZ", // Screen tag Screen: "Scr", AvailHeight: "BA", AvailLeft: "BB", AvailTop: "BC", AvailWidth: "BD", BufferDepth: "BE", ColorDepth: "BF", DeviceXDPI: "BG", DeviceYDPI: "BH", FontSmoothingEnabled: "BI", Left: "BK", LogicalXDPI: "BL", LogicalYDPI: "BM", Top: "BN", UpdateInterval: "BO", // Plugin Tag Plugin: "PLG", Pluginname: "BQ", // Xpath Tag XPathTag: "XPN", XPATH: "XPATH", // Event Types and Sub-types EXCEPTION: "EXCEPTION", GUI: "GUI", INFO: "INFO", INIT: "INIT", PERFORMANCE: "PERFORMANCE", QUEUED: "QUEUED", // Others FailedUrl: "FailedUrl", Message: "Message", Line: "Line", Lev: "Lev", // DOM Events BeforeUnload: "BeforeUnload", Unload: "Unload", KeyUp: "KeyUp", Resize: "Resize", Scroll: "Scroll", WindowOpen: "WindowOpen", Dummy: "" }; // End of TeaLeaf.C object definition TeaLeaf.$C = function(attr) { if (!TeaLeaf._C[attr]) { return attr; } return TeaLeaf._C[attr]; }; //#endif //#ifdef TLT_XML_VERBOSE TeaLeaf.$C = function(attr) { return attr; }; //#endif } } /* * Copyright © 1999-2009 TeaLeaf Technology, Inc. * All rights reserved. * * THIS SOFTWARE IS PROVIDED BY TEALEAF ``AS IS'' * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE DISCLAIMED. * IN NO EVENT SHALL TEALEAF BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF * THE POSSIBILITY OF SUCH DAMAGE. * * @fileoverview * This is the main UI Client Event Capture JavaScript file that is * used by other JavaScript to register their onload routines. * * @requires * TeaLeafCfg.js * * @version 2009.09.24.1 * */ if(TeaLeaf && TeaLeaf.Configuration && TeaLeaf.Configuration.tlinit == false){ TeaLeaf.Configuration.tlinit = true; if( ! Array.prototype.push ) { Array.prototype.stackEnd = 0; /** * Add push if the browser does not supply * them with the Array object (IE6 and earlier) * @addon */ Array.prototype.push = function(obj) { this[this.stackEnd] = obj; this.stackEnd++; } } if( ! Array.prototype.pop ) { /** * Add pop if the browser does not supply * them with the Array object (IE6 and earlier) * @addon */ Array.prototype.pop = function(obj) { this.stackEnd--; return this[this.stackEnd]; } } /** * Set TeaLeaf UI Client Event Capture as an SDK. * The default behavior is not set as an SDK * @requires * TeaLeafCfg.js * @addon */ TeaLeaf.settlSDK = function(){ TeaLeaf.Configuration.tlSDK = true; } /** * Reset TeaLeaf UI Client Event Capture not to act as an SDK. * The default behavior is not set as an SDK * @requires * TeaLeafCfg.js * @addon */ TeaLeaf.resettlSDK = function(){ TeaLeaf.Configuration.tlSDK = false; } /** * Checks if the browser is IE * @requires * TeaLeafCfg.js * @addon */ TeaLeaf.tlIsIE = function(){ if(navigator.appName.indexOf("Microsoft") >= 0 && parseInt(navigator.appVersion) >= 4){ return true; } return false; } /* Random string generator */ TeaLeaf.makeRandomString = function(length) { var inputSet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890~!@#$%^*()_+|\=-][}{;,./?"; var rv = ""; for (var i = 0; i < length; i++) { var j = Math.floor(Math.random() * inputSet.length); rv += inputSet.charAt(j); } return rv; } /** * Array to store all the object that need to be loaded after the page is rendered. * NOTE: This will not be used if the UI Client Event Capture is used as an SDK. */ TeaLeaf.tLoadObjs = []; /** * This function is used for the other javascript files to register their * onload functions to be called * @param obj object that is registered from other JavaScript to be loaded * @param functionName object function that is registered from other JavaScript to be loaded * @requires * TeaLeafCfg.js * @addon */ TeaLeaf.addOnLoad = function(obj, functionName){ if(arguments.length == 1) { TeaLeaf.tLoadObjs.push(obj); } else if(arguments.length > 1) { TeaLeaf.tLoadObjs.push(obj[functionName]); } } /** * This function is used to load UI Client Event Caputre or the * UI Client Event Capture SDK. * @requires * TeaLeafCfg.js * @addon */ TeaLeaf.PageSetup = function() { if(TeaLeaf.Configuration.tlSDK == false ){ for(var i=0; i 0){ winWidth = elems[0].clientWidth; winHeight = elems[0].clientHeight; } } var retType = TeaLeaf.Event.tlResolutionType(winWidth, winHeight); return retType; } /** * Get the page render time. * @requires * TeaLeaf.js * TeaLeafCfg.js * TeaLeafEventCfg.js * @addon */ TeaLeaf.Event.tlGetRenderTime = function(){ return TeaLeaf.Event.PageLoadMilliSecs; } /** * Get element count. * @param element DOM element name * @addon */ TeaLeaf.Event.tlGetElementCount = function(element){ return document.getElementsByName(element).length; } /** * Get count of broaken images. * @addon */ TeaLeaf.Event.tlBadImageCount = function() { var cnt = 0; var ind; for(ind = 0; ind < document.images.length; ind++) { var img = document.images[ind]; // IE correctly identifies any images that weren't downloaded as // not complete. Others should too. Gecko-based browsers act // like NS4 in that they report this incorrectly. if (!img.complete) { cnt++; continue; } // However, they do have two very useful properties: naturalWidth and // naturalHeight. These give the true size of the image. If it failed // to load, either of these should be zero. if (typeof img.naturalWidth != "undefined" && img.naturalWidth == 0) { cnt++; } } return cnt; } /** * Get TeaLeaf current event count. * @addon */ TeaLeaf.Event.tlGetEventCount = function(){ return TeaLeaf.Event.Configuration.tleventcount; } /** * Get sent sting length. * @param sendStr get lenght of sendStr * @addon */ TeaLeaf.Event.tlGetSendStringBytes = function(sendStr){ return sendStr.length; } /** * Get TeaLeaf current exception event count. * @addon */ TeaLeaf.Event.tlGetExceptionCount = function() { return (TeaLeaf.Event.Configuration.tlcatcherrors ? TeaLeaf.Event.Configuration.tlexceptioncount : null); } /** * Get user dwell time on a page. * @requires * TeaLeaf.js * TeaLeafCfg.js * TeaLeafEventCfg.js * @addon */ TeaLeaf.Event.tlGetDwellTime = function(){ return TeaLeaf.Event.tlDateDiff(TeaLeaf.tlStartLoad, TeaLeaf.Event.Configuration.tllastdwelltime); } /** * Get the ID of the last visited DOM element that we have listeners attached. * @requires * TeaLeafEventCfg.js * @addon */ TeaLeaf.Event.tlGetLastVisitedElementID = function(){ return TeaLeaf.Event.Configuration.tlidoflastvisitedcontrol; } /** * Get the date difference between two values. * @param v1 first time value * @param v2 second time value * @addon */ TeaLeaf.Event.tlDateDiff = function(v1, v2) { return Math.abs(v1-v2); } /** * Get the XForm path string with ids or names in fill out order. * @requires * TeaLeafEventCfg.js * @addon */ TeaLeaf.Event.tlGetVisitOrder= function(){ return TeaLeaf.Event.Configuration.tlvisitorder; } /** * Re-format the XML. * @param Str containing XML to be re-formated * @addon */ TeaLeaf.Event.tlFormatXML = function(Str) { if (Str) { if( Str.replace ) { return Str.replace(/&/g, "&").replace(/\"/g, """).replace(//g, ">"); } return Str; } return ""; } /** * Get cookie value. * @param name cookie name * @addon */ TeaLeaf.Event.tlGetCookie = function(name){ var dc = document.cookie; var prefix = name + "="; var begin = dc.indexOf("; " + prefix); if (begin == -1) { begin = dc.indexOf(prefix); if (begin != 0) { return ""; } } else { begin += 2; } var end = document.cookie.indexOf(";", begin); if (end == -1) { end = dc.length; } return unescape(dc.substring(begin + prefix.length, end)); } /** * Set HTTP headers. * @param tlreq XMLHTTPRequest object * @param tlheaderconfig JSON array with the HTTP header field values. * @requires * TeaLeaf.js * TeaLeafCfg.js * TeaLeafEventCfg.js * @addon */ TeaLeaf.Event.tlSetHTTPHeaders = function(tlreq, tlheaderconfig){ for(var i=0; i\r\n'; // Send the request try { TeaLeaf.Event.Configuration.tlasync = true; var tlExceptionEvent = new TeaLeaf.Event(TeaLeaf.$C("INFO"), TeaLeaf.$C("EXCEPTION")); tlExceptionEvent.tlSendXML(tlsendStr,true); } catch(exc) { if( TeaLeaf.Event.Configuration.tlshowexceptions ) { alert(exc.name + ": " + exc.message + "\r\n\r\nPos 4"); } } } /** * Create the XMLHTTPRequest transport object. * @addon */ TeaLeaf.Event.tlGetTransport = function(){ var tlreq; if(window.XMLHttpRequest) { try { tlreq = new XMLHttpRequest(); } catch(e) { tlreq = null; } } else if(window.ActiveXObject) { try { tlreq = new ActiveXObject("Msxml2.XMLHTTP"); } catch(e) { try { tlreq = new ActiveXObject("Microsoft.XMLHTTP"); } catch(e) { tlreq = null; } } } return tlreq; } TeaLeaf.Event.TransportArray = []; /** * Get the XMLHTTPRequest transport object from the Transport Array if not create one. * @addon */ TeaLeaf.Event.tlXMLHTTPObj = function(){ var i = 0; for(; i < TeaLeaf.Event.TransportArray.length; i++) { if( TeaLeaf.Event.TransportArray[i] && TeaLeaf.Event.TransportArray[i].readyState > 0 ) { if( TeaLeaf.Event.TransportArray[i].readyState == 4 ) { TeaLeaf.Event.TransportArray[i].abort(); TeaLeaf.Event.TransportArray[i].onreadystatechange = new function() {}; return TeaLeaf.Event.TransportArray[i]; } } else { TeaLeaf.Event.TransportArray[i] = TeaLeaf.Event.tlGetTransport(); return TeaLeaf.Event.TransportArray[i]; } } // Nope, we need another TeaLeaf.Event.TransportArray[i] = TeaLeaf.Event.tlGetTransport(); return TeaLeaf.Event.TransportArray[i]; } /** * Clean the XMLHTTPRequest Transport Array. * @addon */ TeaLeaf.Event.tlCleanXMLHTTPObj = function(obj){ // Zap this one! var i = 0; for(; i < TeaLeaf.Event.TransportArray.length; i++) { if( obj == TeaLeaf.Event.TransportArray[i] ) { TeaLeaf.Event.TransportArray[i] = null; } } } /** * Add event handler. * @param tlitem element that we attach a listener * @param tlevt event that we listen for * @param tlhandler event handler * @addon */ TeaLeaf.Event.tlAddHandler = function(tlitem, tlevt, tlhandler, tlcapture) { try { if( tlitem.addEventListener ) { if(navigator.userAgent.toLowerCase().indexOf('safari')!=-1){ tlitem.addEventListener('on'+tlevt, tlhandler, tlcapture); } else{ tlitem.addEventListener(tlevt, tlhandler, tlcapture); } } else if( tlitem.attachEvent ) { tlitem.attachEvent('on'+tlevt, tlhandler); } } catch(exc) { if( TeaLeaf.Event.Configuration.tlshowexceptions ) { alert(exc.name + ": " + exc.message + "\r\n\r\nPos 4"); } } } /** * Remove event handler. * @param tlitem element that we attached a listener * @param tlevt event that we listened * @param tlhandler event handler * @addon */ TeaLeaf.Event.tlRemoveHandler = function(tlitem, tlevt, tlhandler, tlcapture) { try { if( tlitem.removeEventListener ) { tlitem.removeEventListener(tlevt, tlhandler, tlcapture); } else if( tlitem.detachEvent ) { tlitem.detachEvent('on'+tlevt, tlhandler); } } catch(exc) { if( TeaLeaf.Event.Configuration.tlshowexceptions ) { alert(exc.name + ": " + exc.message + "\r\n\r\nPos 5"); } } } /** * Flush the event queue. * @param force forces the flush if true * @requires * TeaLeaf.js * TeaLeafCfg.js * TeaLeafEventCfg.js * @addon */ TeaLeaf.Event.tlFlushQueue = function(force) { var dataToSend = null; var queueTime = TeaLeaf.Event.Configuration.tlqueueeventstimer; var maxTime = queueTime * 3; // Nothing to send if(TeaLeaf.Event.Configuration.tlusetopqueue) { var now = new Date(); var diff = (now - top.TeaLeaf.Event.TimeSent); // If we have queued data, let's send it if appropriate if( top.TeaLeaf.Event.tlQueuedXML ) { if( force || diff >= queueTime ) { dataToSend = top.TeaLeaf.Event.tlQueuedXML; top.TeaLeaf.Event.tlQueuedXML = ""; top.TeaLeaf.Event.TimeSent = now; } } // Nothing to send if( ! dataToSend ) { if( ! force && diff < (queueTime / 2) ) { // A little heuristics here--If the time is less than // 1/2 the standard time, then assume another frame // is handling the send. Slow down the transmission // time for this frame. // we need to do this so we do not end up waiting infinately. if(queueTime >= maxTime){ queueTime = maxTime; } else{ queueTime = (queueTime * 3) / 2; } } return queueTime; } } else { if( ! TeaLeaf.Event.tlQueuedXML ) { return queueTime; } dataToSend = TeaLeaf.Event.tlQueuedXML; TeaLeaf.Event.tlQueuedXML = ""; } // Get the Event var evt = new TeaLeaf.Event(TeaLeaf.$C("GUI"), TeaLeaf.$C("QUEUED")); evt.tlSendXML(dataToSend); return queueTime; } /** * Push XML on the stack. * @param tag tag name * @addon */ TeaLeaf.Event.prototype.tlPushXML = function(tag, tlXPath){ if( ! this.XMLStack ) { this.XMLStack = []; } if(tlXPath){ } else{ var strTag = " <" + tag + " "; if(this.XMLData){ this.XMLData += strTag; } else{ this.XMLData = strTag; } } } /** * Pop XML from the stack. * @param tag tag name * @addon */ TeaLeaf.Event.prototype.tlPopXML = function(){ if(this.XMLData){ this.XMLData += "/>\r\n"; } else{ return false; } } /** * Add data tot he XML stack. * @param name0 name of the XML attribute. * @param value0 value of the XML attribute. * @addon */ TeaLeaf.Event.prototype.tlAddData = function(nameValueArray){ var offset = ""; if( this.XMLStack ) { for(var ind = 0; ind < this.XMLStack.length; ind++) { offset += " "; } } var parts = []; for (var ind = 0; ind < nameValueArray.length; ind += 2) { var tlName = nameValueArray[ind]; var tlValue = TeaLeaf.Event.tlFormatXML(nameValueArray[ind+1]); if (tlName && tlValue) { parts[parts.length] = offset + tlName + "=" + '"' + tlValue + '" '; } } if (!this.XMLData) { this.XMLData = ""; } this.XMLData += parts.join(""); nameValueArray = null; } /** * Send the XML with the UI Client Events including the HTTP headers if set. * @param tlsendStr XML message * @requires * TeaLeafEventCfg.js * @addon */ TeaLeaf.Event.prototype.tlSendXML = function(tlsendStr, tlignoresendfailure ){ // Get an the request object var tlreq = TeaLeaf.Event.tlXMLHTTPObj(); if( ! tlreq ) { return; } // Send the request try { var tlurl = this.theUrl; tlreq.onreadystatechange = function(code) { if(tlreq.readyState == 2 && typeof TeaLeaf.Cookie != "undefined") { // Clear the queued xml stored in the cookie, by clearing the contents and setting the expiration to a day before // Done on readyState == 2, which means data has been sent and is waiting on a server response var d = new Date(); d.setTime(d.getTime()-86400000); TeaLeaf.Cookie.tlSetCookieValue("tlQueuedXML", "", d, "/"); } if( tlreq.readyState == 4 ) { // The try/catch is to catch a netscape bug // https://bugzilla.mozilla.org/show_bug.cgi?id=238559#c0 // Thanks to JS for the help try { if( tlreq.status != 200 && tlreq.status != 304 ) { if(TeaLeaf.Event.Configuration.tlignoresendfailure == true){ TeaLeaf.Event.Configuration.tlignoresendfailure = false; TeaLeaf.Event.tlSendFailure(tlurl, tlurl, "Status " + tlreq.status + ": " + tlreq.statusText); } } } catch(e) { } } } tlreq.open("POST", tlurl, TeaLeaf.Event.Configuration.tlasync); TeaLeaf.Event.tlSetHTTPHeaders(tlreq, TeaLeaf.Event.Configuration.tlHTTPRequestHeadersSet); //Set the TeaLeaf HTTP Header Values if( TeaLeaf.Event.Configuration.tlinitflag == true ){ TeaLeaf.Event.tlSetHTTPHeaders(tlreq, TeaLeaf.Event.Configuration.tlHTTPRequestHeadersEvalInit); } if( TeaLeaf.Event.Configuration.tlbeforeunloadflag == true ){ TeaLeaf.Event.tlSetHTTPHeaders(tlreq, TeaLeaf.Event.Configuration.tlHTTPRequestHeadersEvalBeforeUnload); } var tlposttime = new Date(); var tlpostmilisec = Date.UTC(tlposttime.getUTCFullYear(),tlposttime.getUTCMonth(),tlposttime.getUTCDate(), tlposttime.getUTCHours(),tlposttime.getUTCMinutes(),tlposttime.getUTCSeconds(), tlposttime.getUTCMilliseconds()); var tlPostTimeStamp = '<' + TeaLeaf.$C("ClientEventSet") + ' ' + TeaLeaf.$C("PostTimeStamp") + '="' + tlpostmilisec + '" >'; //#ifdef TLT_XML_VERBOSE tlsendStr = tlPostTimeStamp + tlsendStr + ''; //#endif //#ifndef TLT_XML_VERBOSE var tlCui = '<' + TeaLeaf.$C("CUI") + ' ' + TeaLeaf.$C("PageID") + '="' + TeaLeaf.Event.tlGetPageId() + '" ' + TeaLeaf.$C("DateStamp") + '="' + TeaLeaf.Event.Configuration.t1970 + '" />\r\n'; if (TeaLeaf.Event.tlQueuedXPXML) { tlCui += '<' + TeaLeaf.$C("XPATH") + '>' + TeaLeaf.Event.tlQueuedXPXML + '\r\n'; } tlsendStr = tlPostTimeStamp + tlCui + tlsendStr + ''; TeaLeaf.Event.tlQueuedXPXML =""; //#endif tlreq.send(tlsendStr); } catch(exc) { if( TeaLeaf.Event.Configuration.tlshowexceptions ) { if( exc.name ) { alert(exc.name + ": " + exc.message + "\r\n\r\nURL: " + this.theUrl + "\r\n\r\nPos 3 "); } else { alert(exc + "\r\n\r\nURL: " + this.theUrl + "\r\n\r\nPos 3 "); } } if(TeaLeaf.Event.Configuration.tlignoresendfailure == true){ TeaLeaf.Event.Configuration.tlignoresendfailure = false; TeaLeaf.Event.tlSendFailure(this.theUrl, this.theUrl, exc); } TeaLeaf.Event.tlCleanXMLHTTPObj(tlreq); } } /** * Depending on the configuration settings send the XML or queue the XML message. * @requires * TeaLeaf.js * TeaLeafCfg.js * TeaLeafEventCfg.js * @addon */ TeaLeaf.Event.prototype.tlSend = function(bRoot){ TeaLeaf.Event.Configuration.tleventcount++; // Pop everything on the queue if( this.XMLStack ) { while( this.XMLStack.length > 0 ) { this.tlPopXML() } } if(TeaLeaf.Event.Configuration.tleventcount > TeaLeaf.Event.Configuration.tlmaxeventcount){ TeaLeaf.Event.tlFlushQueue(); return; } var t1970 = Date.UTC(this.date.getUTCFullYear(),this.date.getUTCMonth(),this.date.getUTCDate(), this.date.getUTCHours(),this.date.getUTCMinutes(),this.date.getUTCSeconds(), this.date.getUTCMilliseconds()); sendStr = '<' + TeaLeaf.$C("ClientEvent") + ' ' + TeaLeaf.$C("Count") + '="' + TeaLeaf.Event.Configuration.tleventcount + '" ' + TeaLeaf.$C("Type") + '="' + this.EventType + '" ' + TeaLeaf.$C("SubType") + '="' + this.EventSubType + '" '; if (this.EventSource) { sendStr += TeaLeaf.$C("Source") + '="' + this.EventSource+ '" '; } //#ifdef TLT_XML_VERBOSE sendStr += TeaLeaf.$C("PageId") + '="' + TeaLeaf.Event.tlGetPageId() + '" '; //#endif if (!bRoot) { sendStr += this.XMLData; } if (TeaLeaf.tlStartLoad) { sendStr += TeaLeaf.$C("TimeDuration") + '="' + TeaLeaf.Event.tlDateDiff(this.date, TeaLeaf.tlStartLoad) + '" '; } sendStr += TeaLeaf.$C("DateSince1970") + '="' + //#ifdef TLT_XML_VERBOSE t1970 + //#endif //#ifndef TLT_XML_VERBOSE TeaLeaf.Event.tlDateDiff(t1970, TeaLeaf.Event.Configuration.t1970) + //#endif '" '; if (bRoot) { sendStr += '>\r\n' + this.XMLData + '\r\n'; } else { sendStr += '/>\r\n'; } //#ifndef TLT_XML_VERBOSE var tlxpstr = ""; if (TeaLeaf.Event.Configuration.tlXPTable && TeaLeaf.Event.Configuration.tlXP) { tlxpstr = '<' + TeaLeaf.$C("XPathTag") + ' ' + TeaLeaf.$C("Id") + '="' + TeaLeaf.Event.Configuration.tlXPTable + '" ' + TeaLeaf.$C("XPath") + '="' + TeaLeaf.Event.Configuration.tlXP + '" />'; } //#endif // Queue the event if( TeaLeaf.Event.Configuration.tlqueueevents ) { if( TeaLeaf.Event.Configuration.tlusetopqueue ) { if( top.TeaLeaf.Event.tlQueuedXML ) { top.TeaLeaf.Event.tlQueuedXML += sendStr; } else { top.TeaLeaf.Event.tlQueuedXML = sendStr; } //#ifndef TLT_XML_VERBOSE if (tlxpstr) { if (top.TeaLeaf.Event.tlQueuedXPXML) { top.TeaLeaf.Event.tlQueuedXPXML += tlxpstr; } else { top.TeaLeaf.Event.tlQueuedXPXML = tlxpstr; } } //#endif } else { if( TeaLeaf.Event.tlQueuedXML ) { TeaLeaf.Event.tlQueuedXML += sendStr; } else { TeaLeaf.Event.tlQueuedXML = sendStr; } //#ifndef TLT_XML_VERBOSE if (tlxpstr) { if (TeaLeaf.Event.tlQueuedXPXML) { TeaLeaf.Event.tlQueuedXPXML += tlxpstr; } else { TeaLeaf.Event.tlQueuedXPXML = tlxpstr; } } //#endif } // Check the size of the XML. IF it is getting too // big, send it if( TeaLeaf.Event.Configuration.tlqueueeventsmaxsz < TeaLeaf.Event.tlQueuedXML.length ) { TeaLeaf.Event.tlFlushQueue(); } return; } // Send the request try { this.tlSendXML(sendStr); this.XMLData = ""; } catch(exp) { } this.XMLData = ""; } /** * Encode a string to be suitable for an XML attribute. * @param str * @addon */ TeaLeaf.Event.tlXMLEncode = function(str){ if(str == null) return str; str = str.replace(/&/g, "&"); str = str.replace(/"/g, """); str = str.replace(/'/g, "'"); str = str.replace(/:/g, ":"); return str; } /** * Decode a string encoded with tlXMLEncode. * @param str * @addon */ TeaLeaf.Event.tlXMLDecode = function(str){ if(str == null) return str; str = str.replace(/:/g, ":"); str = str.replace(/'/g, "'"); str = str.replace(/"/g, "\""); str = str.replace(/&/g, "&"); return str; } /** * Enable HTTP Headers defined in the TeaLeafEventCfg.js. * @param obj determines what set of HTTP headers to be set. * @requires * TeaLeafEventCfg.js * @addon */ TeaLeaf.Event.tlEnableAllHTTPHeaders = function(obj) { if(obj){ if(obj == "info"){ TeaLeaf.Event.tlEventJSONCfgUtil(TeaLeaf.Event.Configuration.tlHTTPRequestHeadersSet, true, "all"); } else if(obj == "init"){ TeaLeaf.Event.tlEventJSONCfgUtil(TeaLeaf.Event.Configuration.tlHTTPRequestHeadersEvalInit, true, "all"); } else if(obj == "beforeunload"){ TeaLeaf.Event.tlEventJSONCfgUtil(TeaLeaf.Event.Configuration.tlHTTPRequestHeadersEvalBeforeUnload, true, "all"); } } else{ TeaLeaf.Event.tlEventJSONCfgUtil(TeaLeaf.Event.Configuration.tlHTTPRequestHeadersSet, true, "all"); TeaLeaf.Event.tlEventJSONCfgUtil(TeaLeaf.Event.Configuration.tlHTTPRequestHeadersEvalInit, true, "all"); TeaLeaf.Event.tlEventJSONCfgUtil(TeaLeaf.Event.Configuration.tlHTTPRequestHeadersEvalBeforeUnload, true, "all"); } } /** * Enable HTTP Headers defined in the TeaLeafEventCfg.js. * @param obj determines what set of HTTP headers to be set. * @requires * TeaLeafEventCfg.js * @addon */ TeaLeaf.Event.tlEnableHTTPHeader = function(obj, headerName) { if(obj == "info"){ TeaLeaf.Event.tlEventJSONCfgUtil(TeaLeaf.Event.Configuration.tlHTTPRequestHeadersSet, true, headerName); } else if(obj == "init"){ TeaLeaf.Event.tlEventJSONCfgUtil(TeaLeaf.Event.Configuration.tlHTTPRequestHeadersEvalInit, true, headerName); } else if(obj == "beforeunload"){ TeaLeaf.Event.tlEventJSONCfgUtil(TeaLeaf.Event.Configuration.tlHTTPRequestHeadersEvalBeforeUnload, true, headerName); } } /** * Disable HTTP Headers defined in the TeaLeafEventCfg.js. * @param obj determines what set of HTTP headers to be set. * @requires * TeaLeafEventCfg.js * @addon */ TeaLeaf.Event.tlDisableAllHTTPHeaders = function(obj) { if(obj){ if(obj == "info"){ TeaLeaf.Event.tlEventJSONCfgUtil(TeaLeaf.Event.Configuration.tlHTTPRequestHeadersSet, false, "all"); } else if(obj == "init"){ TeaLeaf.Event.tlEventJSONCfgUtil(TeaLeaf.Event.Configuration.tlHTTPRequestHeadersEvalInit, false, "all"); } else if(obj == "beforeunload"){ TeaLeaf.Event.tlEventJSONCfgUtil(TeaLeaf.Event.Configuration.tlHTTPRequestHeadersEvalBeforeUnload, false, "all"); } } else{ TeaLeaf.Event.tlEventJSONCfgUtil(TeaLeaf.Event.Configuration.tlHTTPRequestHeadersSet, false, "all"); TeaLeaf.Event.tlEventJSONCfgUtil(TeaLeaf.Event.Configuration.tlHTTPRequestHeadersEvalInit, false, "all"); TeaLeaf.Event.tlEventJSONCfgUtil(TeaLeaf.Event.Configuration.tlHTTPRequestHeadersEvalBeforeUnload, false, "all"); } } /** * Enable queuing of events. * @requires * TeaLeafEventCfg.js * @addon */ TeaLeaf.Event.tlEnableQueueEvents = function() { TeaLeaf.Event.Configuration.tlqueueevents = true; } /** * Disable queuing of events. * @requires * TeaLeafEventCfg.js * @addon */ TeaLeaf.Event.tlDisableQueueEvents = function() { TeaLeaf.Event.Configuration.tlqueueevents = false; } /** * Enable showing of exception in an alert message. * @requires * TeaLeafEventCfg.js * @addon */ TeaLeaf.Event.tlEnableShowExceptions = function() { TeaLeaf.Event.Configuration.tlshowexceptions = true; } /** * Disable showing of exception in an alert message. * @requires * TeaLeafEventCfg.js * @addon */ TeaLeaf.Event.tlDisableShowExceptions = function() { TeaLeaf.Event.Configuration.tlshowexceptions = false; } /** * Set queue event flush time. * @requires * TeaLeafEventCfg.js * @addon */ TeaLeaf.Event.tlSetQueueEventTime = function(tlvalue) { TeaLeaf.Event.Configuration.tlqueueeventstimer = tlvalue; } /** * Get queue event flush time. * @requires * TeaLeafEventCfg.js * @addon */ TeaLeaf.Event.tlGetQueueEventTime = function() { return TeaLeaf.Event.Configuration.tlqueueeventstimer; } /** * Set queue event maximum size. * @requires * TeaLeafEventCfg.js * @addon */ TeaLeaf.Event.tlSetQueueEventMaxSize = function(tlvalue) { TeaLeaf.Event.Configuration.tlqueueeventsmaxsz = tlvalue; } /** * Get queue event maximum size. * @requires * TeaLeafEventCfg.js * @addon */ TeaLeaf.Event.tlGetQueueEventMaxSize = function() { return TeaLeaf.Event.Configuration.tlqueueeventsmaxsz; } /** * Set the url where TeaLeaf posts. * @requires * TeaLeafEventCfg.js * @addon */ TeaLeaf.Event.tlSetPostURL = function(tlvalue) { TeaLeaf.Event.Configuration.tlurl = tlvalue; } /** * Get the url where TeaLeaf posts. * @requires * TeaLeafEventCfg.js * @addon */ TeaLeaf.Event.tlGetPostURL = function() { return TeaLeaf.Event.Configuration.tlurl; } /** * JSON configuration utility allowing to enable/disable certain DOM events * @requires * TeaLeafEventCfg.js * @addon */ TeaLeaf.Event.tlEventJSONCfgUtil = function(tlJSONConfig, tlEnable, domEventName) { for(var i = 0; i TeaLeaf.Event.Configuration.tlmaxeventexception){ return; } if ((typeof message !== "string") && !url) { /* If "message" and "url" is not specified then * the data is not all that useful. */ return false; } var now = new Date(); if (!line) { line = "-"; } var tlevt = new TeaLeaf.Event(TeaLeaf.$C("INFO"), TeaLeaf.$C("EXCEPTION")); var tlAddNameValueArray = [TeaLeaf.$C("Message"), message, TeaLeaf.$C("URL"), escape(url), TeaLeaf.$C("Line"), line]; tlevt.tlAddData(tlAddNameValueArray); TeaLeaf.Event.Configuration.tlasync = true; tlevt.tlSend(); TeaLeaf.Event.tlFlushQueue(); return false; } /** * Handle the before unload event and flush the queue of events. * * @requires * TeaLeafEventCfg.js * @addon */ TeaLeaf.Event.tlBeforeUnload = function(){ if(TeaLeaf.Event.Configuration.tleventbeforeunloadflag == true){ TeaLeaf.Event.Configuration.tleventunloadflag = false; // Send in the notice var tlevt = new TeaLeaf.Event(TeaLeaf.$C("PERFORMANCE"), TeaLeaf.$C("BeforeUnload")); TeaLeaf.Event.SetType = tlevt.EventType; if(TeaLeaf.Event.SetSubType == ""){ TeaLeaf.Event.SetSubType = tlevt.EventSubType; } else{ TeaLeaf.Event.SetSubType += "; " + tlevt.EventSubType; } TeaLeaf.Event.Configuration.tlbeforeunloadflag = true; TeaLeaf.Event.Configuration.tlignoresendfailure = true; TeaLeaf.Event.Configuration.tlasync = false; tlevt.tlSend(); TeaLeaf.Event.tlFlushQueue(true); } TeaLeaf.Event.tlRemoveHandler(window, "beforeunload", eval(TeaLeaf.Event.tlBeforeUnload), false); TeaLeaf.Event.tlRemoveHandler(window, "unload", eval(TeaLeaf.Event.tlUnload), false); } /** * Handle the unload event and flush the queue of events. * * @requires * TeaLeafEventCfg.js * @addon */ TeaLeaf.Event.tlUnload = function(){ if(TeaLeaf.Event.Configuration.tleventunloadflag ){ TeaLeaf.Event.Configuration.tllastdwelltime = new Date(); TeaLeaf.Event.Configuration.tleventbeforeunloadflag = false; // Send in the notice var tlevt = new TeaLeaf.Event(TeaLeaf.$C("PERFORMANCE"), TeaLeaf.$C("Unload")); TeaLeaf.Event.SetType = tlevt.EventType; if(TeaLeaf.Event.SetSubType == ""){ TeaLeaf.Event.SetSubType = tlevt.EventSubType; } else{ TeaLeaf.Event.SetSubType += "; " + tlevt.EventSubType; } TeaLeaf.Event.Configuration.tlignoresendfailure = true; TeaLeaf.Event.Configuration.tlasync = false; tlevt.tlSend(); TeaLeaf.Event.tlFlushQueue(true); } TeaLeaf.Event.tlRemoveHandler(window, "beforeunload", eval(TeaLeaf.Event.tlBeforeUnload), false); TeaLeaf.Event.tlRemoveHandler(window, "unload", eval(TeaLeaf.Event.tlUnload), false); } /** * Event setup. * @requires * TeaLeafEventCfg.js * @addon */ TeaLeaf.Event.EventSetup = function() { //Handle Errors if(TeaLeaf.Event.Configuration.tlcatcherrors){ // If there is no error handler registered only then we attach ours. if (typeof window.onerror !== "function") { /* Use direct assignment instead of the normal event handler API. * If you use the latter to attach to onerror, Firefox will pass an * event object in the callback instead of the message, url, and line number. */ window.onerror = TeaLeaf.Event.tlErrorHandler; } } if(!TeaLeaf.Client){ TeaLeaf.Event.tlAddHandler(window, "beforeunload", eval(TeaLeaf.Event.tlBeforeUnload), false); TeaLeaf.Event.tlAddHandler(window, "unload", eval(TeaLeaf.Event.tlUnload), false); } // If we are queueing events, set up the timer if( TeaLeaf.Event.Configuration.tlqueueevents ) { TeaLeaf.Event.tlTimerRoutine = function() { // Amount of time until the next timeout var timeAmount = TeaLeaf.Event.Configuration.tlqueueeventstimer; try { timeAmount = TeaLeaf.Event.tlFlushQueue(); } catch(exc) { if( TeaLeaf.Event.Configuration.tlshowexceptions ) { alert(exc.name + ": " + exc.message + "\r\n\r\nPos 7"); } } //NOTE: Use setTimeout instead of setInterval since // setInterval is only JS 1.2 and later setTimeout('TeaLeaf.Event.tlTimerRoutine()', timeAmount); } setTimeout('TeaLeaf.Event.tlTimerRoutine()', TeaLeaf.Event.Configuration.tlqueueeventstimer); } var tlnow = new Date(); var t1970 = Date.UTC(tlnow.getUTCFullYear(),tlnow.getUTCMonth(), tlnow.getUTCDate(), tlnow.getUTCHours(),tlnow.getUTCMinutes(),tlnow.getUTCSeconds(), tlnow.getUTCMilliseconds()); TeaLeaf.Event.Configuration.t1970 = t1970; TeaLeaf.Event.Loaded = true; } // Get the appropriate URL var tmpUrl; if( window.location.protocol == "http:" ) { tmpUrl = TeaLeaf.Event.Configuration.tlurl; } else { tmpUrl = TeaLeaf.Event.Configuration.tlsecureurl; } // Is this an absolute vs relative url if( tmpUrl.substr(0, 1) == "/" ) { TeaLeaf.Event.prototype.theUrl = window.location.protocol + "//" + window.location.host + tmpUrl; } else { TeaLeaf.Event.prototype.theUrl = window.location.href.substr(0, window.location.href.lastIndexOf("/")+1) + tmpUrl; } if(TeaLeaf.Event.Configuration.tlinit == false){ TeaLeaf.Event.Configuration.tlinit = true; TeaLeaf.Event.prototype.XMLData = ""; TeaLeaf.addOnLoad(TeaLeaf.Event.EventSetup); } } /* * Copyright © 1999-2009 TeaLeaf Technology, Inc. * All rights reserved. * * THIS SOFTWARE IS PROVIDED BY TEALEAF ``AS IS'' * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE DISCLAIMED. * IN NO EVENT SHALL TEALEAF BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF * THE POSSIBILITY OF SUCH DAMAGE. * * @fileoverview * This is the configuration file for capturing Client Events that * happen on the rendered DOM. It proviedes the capabilty to block fields * and turn off an on events on the Window and Document object. * * @version 2009.09.24.1 * */ if(typeof TeaLeaf.Client == "undefined"){ TeaLeaf.Client = {}; if(typeof TeaLeaf.Client.Configuration == "undefined"){ TeaLeaf.Client.Configuration = { "tlinit" : false, "tlpassword" : 1, // 1 no capture, 2 don't send value "tlsendfocus" : false, "tlsendblur" : true, "tlunloadflag" : true, "tlactiontype" : "No Submit", "tlbeforeunloadflag" : true, "tlcontrolsattached" : false, "tlassignTLID" : false, "tlscanupdate" : 0, "tlIEhref" : false, // tlScheduledScan controls whether or not to periodically scan the DOM // for changes (and tag the appropriate nodes) at the interval defined by // tlscanupdate tlScheduledScan : true, // tlExcludeTags controls whether to explicitly exclude or include the // tags listed in tlNodeTags when attaching to descendent elements using // TeaLeaf.Client.tlProcessNode(). See TeaLeaf.Client.tlTagNameAllowed() tlExcludeTags : true, // If events are being cancelled, the document object will not catch events // since they are not being bubbled up. In order to combat this, we can attach // to every relevant item (see tlExcludeTags and tlNodeTags), except this may // result in duplicate events being captured. tlUniversalAttach : false, // Option to store the xml of queued events on a page unload in a cookie, so // that it may be sent up with the next page's events. Since this may interfere // with the existing cookies on the site, this is disabled by default. tlStoreQueueInCookie : false, // This is where input fields can be globally blocked. Four examples are shown // below. Add or remove fields as appropriate. The parameters are: // tlfieldname : the id of the field // caseinsensitive : check for the field name in using case // insensitive check // eventnovalue : if true, send event but without value. If // false do not send event tlFieldBlock:[ {"tlfieldname": "TLCREDITCARD", "caseinsensitive": true, "eventvaluereplace": "", "eventnovalue": true}, {"tlfieldname": "tlpassword", "caseinsensitive": true, "eventvaluereplace": "", "eventnovalue": true}, {"tlfieldname": "tlpwd", "caseinsensitive": true, "eventvaluereplace": "", "eventnovalue": true}, {"tlfieldname": "tlqty", "caseinsensitive": true, "eventvaluereplace": "333", "eventnovalue": false} ], tlFieldBlockMap : null, // This is the list of events we catch off of the window object tlWindowHandlers:[ {"domevent": "resize", "load": false, "tlhandler": "TeaLeaf.Client.tlQueueResize"}, {"domevent": "focus", "load": true, "tlhandler": "TeaLeaf.Client.tlSetFocusTime"}, {"domevent": "help", "load": true, "tlhandler": "TeaLeaf.Client.tlAddEvent"}, {"domevent": "scroll", "load": false, "tlhandler": "TeaLeaf.Client.tlQueueScroll"}, {"domevent": "beforeprint", "load": false, "tlhandler": "TeaLeaf.Client.tlAddEvent"}, {"domevent": "afterprint", "load": false, "tlhandler": "TeaLeaf.Client.tlAddEvent"} ], // This is the list of events we catch off of the document object tlDocumentHandlers:[ {"domevent": "click", "load": true, "tlhandler": "TeaLeaf.Client.tlAddEvent"}, {"domevent": "dblclick", "load": true, "tlhandler": "TeaLeaf.Client.tlAddEvent"}, {"domevent": "keyup", "load": true, "tlhandler": "TeaLeaf.Client.tlQueueKey"}, {"domevent": "mousedown", "load": false, "tlhandler": "TeaLeaf.Client.tlAddEvent"}, {"domevent": "mouseup", "load": false, "tlhandler": "TeaLeaf.Client.tlAddEvent"}, {"domevent": "mouseover", "load": false, "tlhandler": "TeaLeaf.Client.tlAddEvent"}, {"domevent": "mouseout", "load": false, "tlhandler": "TeaLeaf.Client.tlAddEvent"}, // This event is only caught once and turned off. This is used to // detect robots, since a robot will never have mouse movement. {"domevent": "mousemove", "load": false, "tlhandler": "TeaLeaf.Client.tlUserMovement"} ], tlSingleAttach:[ {"domelementID": "", "domevent": "mousedown", "tlhandler": "TeaLeaf.Client.tlAddEvent"}, {"domelementID": "", "domevent": "mouseup", "tlhandler": "TeaLeaf.Client.tlAddEvent"}, {"domelementID": "", "domevent": "mouseover", "tlhandler": "TeaLeaf.Client.tlAddEvent"}, {"domelementID": "", "domevent": "mouseout", "tlhandler": "TeaLeaf.Client.tlAddEvent"} ], /* tlNodeTags by default includes a list of tag names that are "unimportant" * or not rendered. The associated true/false value is used in conjunction with * tlExcludeTags - e.g. if tlExcludeTags is true and a node tag is true, it will * be excluded; if tlExcludeTags is true and a node tag is false, the tag will be * included. Similarly if tlExcludeTags is false (meaning to explicitly include the * listed node tags, those with "true" with be excluded. */ tlNodeTags : { "APPLET" : true, "ATTRIBUTE" : true, "B" : true, "BASE" : true, "BODY" : true, "BR" : true, "CENTER" : true, "COL" : true, "COLGROUP" : true, "COMMENT" : true, "DIV" : true, "DEFAULT" : true, "DEL" : true, "EVENT" : true, "FONT" : true, "FORM" : true, "HEAD" : true, "HISTORY" : true, "HR" : true, "HTML" : true, "I" : true, "INS" : true, "LINK" : true, "MAP" : true, "META" : true, "NAMESPACE" : true, "NAVIGGATOR" : true, "NOBR" : true, "OPTION" : true, "P" : true, "PARAM" : true, "S" : true, "SCRIPT" : true, "SMALL" : true, "STRIKE" : true, "STRONG" : true, "STYLE" : true, "SUB" : true, "SUP" : true, "TH" : true, "TITLE" : true, "THEAD" : true, "TFOOT" : true, "TR" : true, "U" : true }, /* tlSpecialChildNodeTags represents tags with a special * situation where the event that fires is attached to a * non-visual item that is inside the actual UI element. * Example would be a menu with a tag inside to * keep the visual text of the menu on one line. The * fires the event when we really want the parent menu. */ tlSpecialChildNodeTags : { "NOBR" : true, "P" : true } }; TeaLeaf.Client.Configuration.tlIdCounter = []; } } /* * Copyright ? 1999-2009 TeaLeaf Technology, Inc. * All rights reserved. * * THIS SOFTWARE IS PROVIDED BY TEALEAF ``AS IS'' * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE DISCLAIMED. * IN NO EVENT SHALL TEALEAF BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF * THE POSSIBILITY OF SUCH DAMAGE. * * @fileoverview * This is the main UI Client Event Capture JavaScript file that is * used by other JavaScript to register their onload routines. * * @requires * TeaLeaf.js * TeaLeafEvent.js * TeaLeafClientCfg.js * * @version 2009.09.24.1 * */ if(TeaLeaf.Client && TeaLeaf.Client.Configuration){ TeaLeaf.Client.tlTimeoutID = -1; /** * Enable all event handlers specified in the configuration. * @param obj parameter that determines to enable handlers to the window or document object or both. * @requires * TeaLeafClientCfg.js * @addon */ TeaLeaf.Client.tlEnableAllEventHandlers = function(obj) { if(obj){ if(obj == window){ TeaLeaf.Client.tlClientJSONCfgUtil(TeaLeaf.Client.Configuration.tlWindowHandlers, true, "all"); } else if(obj == document){ TeaLeaf.Client.tlClientJSONCfgUtil(TeaLeaf.Client.Configuration.tlDocumentHandlers, true, "all"); } } else{ TeaLeaf.Client.tlClientJSONCfgUtil(TeaLeaf.Client.Configuration.tlWindowHandlers, true, "all"); TeaLeaf.Client.tlClientJSONCfgUtil(TeaLeaf.Client.Configuration.tlDocumentHandlers, true, "all"); } } /** * Enable a specific event handler defined in the configuration. * @param obj parameter that determines to enable handlers to the window or document object. * @param domEventName name of the event to enable. * @requires * TeaLeafClientCfg.js * @addon */ TeaLeaf.Client.tlEnableEventHandler = function(obj, domEventName) { if(obj == window){ TeaLeaf.Client.tlClientJSONCfgUtil(TeaLeaf.Client.Configuration.tlWindowHandlers, true, domEventName); } else{ TeaLeaf.Client.tlClientJSONCfgUtil(TeaLeaf.Client.Configuration.tlDocumentHandlers, true, domEventName); } } /** * Disable all event handlers specified in the configuration. * @param obj parameter that determines to disable handlers to the window or document object or both. * @requires * TeaLeafClientCfg.js * @addon */ TeaLeaf.Client.tlDisableAllEventHandlers = function(obj) { if(obj){ if(obj == window){ TeaLeaf.Client.tlClientJSONCfgUtil(TeaLeaf.Client.Configuration.tlWindowHandlers, false, "all"); } else if(obj == document){ TeaLeaf.Client.tlClientJSONCfgUtil(TeaLeaf.Client.Configuration.tlDocumentHandlers, false, "all"); } } else{ TeaLeaf.Client.tlClientJSONCfgUtil(TeaLeaf.Client.Configuration.tlWindowHandlers, false, "all"); TeaLeaf.Client.tlClientJSONCfgUtil(TeaLeaf.Client.Configuration.tlDocumentHandlers, false, "all"); } } /** * Disable a specific event handler defined in the configuration. * @param obj parameter that determines to disable handlers to the window or document object. * @param domEventName name of the event to enable. * @requires * TeaLeafClientCfg.js * @addon */ TeaLeaf.Client.tlDisableEventHandlers = function(obj, domEventName) { if(obj == window){ TeaLeaf.Client.tlClientJSONCfgUtil(TeaLeaf.Client.Configuration.tlWindowHandlers, false, domEventName); } else{ TeaLeaf.Client.tlClientJSONCfgUtil(TeaLeaf.Client.Configuration.tlDocumentHandlers, false, domEventName); } } /** * Utility that helps enabling or disabling of event handlers. * @param tlJSONConfig configuration array. * @param tlEnable enable (true or false flag). * @param domEventName event name to enable or disable. * @addon */ TeaLeaf.Client.tlClientJSONCfgUtil = function(tlJSONConfig, tlEnable, domEventName) { for(var i = 0; i 0) return map_item["eventvaluereplace"]; else return ""; } /** * Check if element is excluded from capture. * @param name or id of element. * @requires * TeaLeafClientCfg.js * @addon */ TeaLeaf.Client.tlIsExcluded = function(name) { // Nothing there if( !name ) { return false; } // If this an object if( typeof name == "object" ) { if( name.TeaLeafExclude ) { return true; } } else{ var tlExclude = document.getElementById(name); if(tlExclude){ if(tlExclude.TeaLeafExclude){ return true; } } else{ tlExclude = document.getElementsByName(name); if(tlExclude){ for(var i=0; i" + idx + "\r\n"; } else { return "Anchor-" + idx; } } } for(idx = 0; idx < document.links.length; idx++) { if( document.links[idx] == theNode ) { if( full ) { return "" + idx + "\r\n"; } else { return "Link-" + idx; } } } return null; } /** * Check if element is of type input */ TeaLeaf.Client.checkIsInput = function(elem) { if(typeof(elem) == "string") elem = document.getElementById(elem); switch(elem.tagName) { case "INPUT": case "SELECT": case "TEXTAREA": return true; } return false; } /** * If we don't have an name, get the index from either the anchors * or the links collection. * @param str XML string. * @requires * TeaLeafClientCfg.js * TeaLeafEvent.js * @addon */ TeaLeaf.Event.tlFormatXMLName = function(str) { // Nothing handed in if( ! str || str.length <= 0 ) return null; var rtn = ""; if( ! TeaLeaf.Event.tlNameStartChar(str.charCodeAt(0)) ) { rtn = "_"; } var max = str.length; var ind; for(ind = 0; ind < max; ind++) { if( TeaLeaf.Event.tlNameChar(str.charCodeAt(ind)) ) { rtn = rtn + str.charAt(ind); } else { rtn = rtn + "_"; } } return rtn; } /** * Utility function to help format the XML. * @param chr character. * @addon */ TeaLeaf.Event.tlNameStartChar = function(chr) { // ":" | [A-Z] | "_" | [a-z] | [#xC0-#xD6] | [#xD8-#xF6] | // [#xF8-#x2FF] | [#x370-#x37D] | [#x37F-#x1FFF] | // [#x200C-#x200D] | [#x2070-#x218F] | [#x2C00-#x2FEF] | // [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] // Note: ":" was removed because it is only valid when a namespace // is defined return (chr >= 0x41 && chr <= 0x5A) || chr == 0x5F || (chr >= 0x61 && chr <= 0x7A) || (chr >= 0xC0 && chr <= 0xD6) || (chr >= 0xD8 && chr <= 0xF6) || (chr >= 0xF8 && chr <= 0x2FF) || (chr >= 0x370 && chr <= 0x37D) || (chr >= 0x37F && chr <= 0x1FFF) || (chr >= 0x200C && chr <= 0x200D) || (chr >= 0x2070 && chr <= 0x218F) || (chr >= 0x2C00 && chr <= 0x2FEF) || (chr >= 0x3001 && chr <= 0xD7FF) || (chr >= 0xF900 && chr <= 0xFDCF) || (chr >= 0xFDF0 && chr <= 0xFFFD); } /** * Utility function to help format the XML. * @param chr character. * @addon */ TeaLeaf.Event.tlNameChar = function(chr) { // NameStartChar | "-" | "." | [0-9] | #xB7 | [#x0300-#x036F] | [#x203F-#x2040] return TeaLeaf.Event.tlNameStartChar(chr) || chr == 0x2D || chr == 0x2E || (chr >= 0x30 && chr <= 0x39) || chr == 0xB7 || (chr >= 0x0300 && chr <= 0x036F) || (chr >= 0x203F && chr <= 0x2040); } TeaLeaf.Client.tlQueuedKeys = ""; /** * Queues the keys * @param theEvent DOM event. * @requires * TeaLeafClientCfg.js * TeaLeafEvent.js * @addon */ TeaLeaf.Client.tlQueueKey = function(theEvent) { TeaLeaf.Client.tlSendResize(); TeaLeaf.Client.tlSendScroll(); if( ! theEvent ) { theEvent = window.event; } if( theEvent.keyCode < 0x20 ) { return; } // Residual keys to send in? Save the source for next time around var itemSource = TeaLeaf.Client.tlGetEventSource(theEvent); if( ! itemSource ) { return; } // Do we need to set the onFocus time? if( ! itemSource.TeaLeafFocusTime ) { itemSource.TeaLeafFocusTime = new Date(); } if( TeaLeaf.Client.tlQueuedKeySource ) { if( TeaLeaf.Client.tlQueuedKeySource != itemSource ) { if( TeaLeaf.Client.tlQueuedKeys && TeaLeaf.Client.tlQueuedKeys.length > 0 ) TeaLeaf.Client.tlSendKeys(); TeaLeaf.Client.tlQueuedKeySource = itemSource; } } else { TeaLeaf.Client.tlQueuedKeySource = itemSource; } // Get the name/anchor where the key happened. If both are null, // don't worry about logging var name = TeaLeaf.Client.tlGetName(itemSource); var lev = null; if( !name ){ name = TeaLeaf.Client.tlGetXPathFromNode(itemSource); if(!name){ lev = TeaLeaf.Client.tlGetAnchor(itemSource, false); if( ! lev ) { TeaLeaf.Client.tlQueuedKeySource = null; return; } } else{ TeaLeaf.Client.tlQueuedKeySource = itemSource; } } else { if( TeaLeaf.Client.tlIsReplace(itemSource) ) { TeaLeaf.Client.tlQueuedKeysCount++; return; } if( TeaLeaf.Client.tlIsExcluded(itemSource) ) { TeaLeaf.Client.tlQueuedKeys=null; TeaLeaf.Client.tlQueuedKeysCount++; return; } } // Put in the seperator if we need it if( TeaLeaf.Client.tlQueuedKeys ) { if( TeaLeaf.Client.tlQueuedKeys.length > 0 ) { TeaLeaf.Client.tlQueuedKeys = TeaLeaf.Client.tlQueuedKeys + ";"; } } // build the string if( theEvent.ctrlKey ) { if( TeaLeaf.Client.tlQueuedKeys ) { TeaLeaf.Client.tlQueuedKeys = TeaLeaf.Client.tlQueuedKeys + "ctrl-"; } else { TeaLeaf.Client.tlQueuedKeys = "ctrl-"; } } if( theEvent.altKey ) { if( TeaLeaf.Client.tlQueuedKeys ) { TeaLeaf.Client.tlQueuedKeys = TeaLeaf.Client.tlQueuedKeys + "alt-"; } else { TeaLeaf.Client.tlQueuedKeys = "alt-"; } } if( theEvent.shiftKey ) { if( TeaLeaf.Client.tlQueuedKeys ) { TeaLeaf.Client.tlQueuedKeys = TeaLeaf.Client.tlQueuedKeys + "shift-"; } else { TeaLeaf.Client.tlQueuedKeys = "shift-"; } } TeaLeaf.Client.tlQueuedKeys = TeaLeaf.Client.tlQueuedKeys + theEvent.keyCode; } /** * Send the keys. * @requires * TeaLeafClientCfg.js * TeaLeafEvent.js * @addon */ TeaLeaf.Client.tlSendKeys = function() { if( ! TeaLeaf.Client.tlQueuedKeySource || ( ! TeaLeaf.Client.tlQueuedKeys && ! TeaLeaf.Client.tlQueuedKeysCount ) ) { return; } // Save the values to temp variables and null out the // queue variables var qSource = TeaLeaf.Client.tlQueuedKeySource; var qKeys = TeaLeaf.Client.tlQueuedKeys; var qCount = TeaLeaf.Client.tlQueuedKeysCount; TeaLeaf.Client.tlQueuedKeySource = null; TeaLeaf.Client.tlQueuedKeys = ""; TeaLeaf.Client.tlQueuedKeysCount = 0; var tlreplace = false; if( TeaLeaf.Client.tlIsReplace(qSource) ) { tlreplace = true; return; } var excluded = false; if( TeaLeaf.Client.tlIsExcluded(qSource) ) { excluded = true; qKeys = null; } // Get the name/anchor where the key happened. If both are null, // don't worry about logging var name = TeaLeaf.Client.tlGetName(qSource); var lev = null; if( name & TeaLeaf.Client.tlIsExcluded(name) ) { return null; } // The Reporting Event var tlevt = new TeaLeaf.Event(TeaLeaf.$C("GUI"), TeaLeaf.$C("KeyUp")); var tlAddNameValueArray = [TeaLeaf.$C("Name"), qSource.name, TeaLeaf.$C("Id"), qSource.id, TeaLeaf.$C("Lev"), lev, TeaLeaf.$C("ElementType"), qSource.type, TeaLeaf.$C("TagName"), qSource.tagName, TeaLeaf.$C("XPath"), TeaLeaf.Client.tlGetXPathFromNode(qSource), TeaLeaf.$C("KeyCount"), qCount]; tlevt.tlAddData(tlAddNameValueArray); if (excluded) { tlevt.tlAddData([TeaLeaf.$C("Excluded"), TeaLeaf.$C("True")]); } else if (tlreplace) { var tlRepValue = TeaLeaf.Client.tlGetReplaceValue(qSource); var tlAddNameValueArrayReplaceName = [TeaLeaf.$C("ValueIn"), name, name, tlRepValue, TeaLeaf.$C("KeyCode"), qKeys]; tlevt.tlAddData(tlAddNameValueArrayReplaceName); } else { var tlManualName = TeaLeaf.Event.tlFormatXMLName(name); if(tlManualName == null){ tlManualName = TeaLeaf.Client.tlGetXPathFromNode(qSource); tlManualName = TeaLeaf.Event.tlFormatXMLName(tlManualName); } var tlAddNameValueArrayManualName = [TeaLeaf.$C("ValueIn"), tlManualName, tlManualName, qSource.value, TeaLeaf.$C("KeyCode"), qKeys]; tlevt.tlAddData(tlAddNameValueArrayManualName); } // Now send the data in tlevt.tlSend(); } /* Send resize event. * @requires * TeaLeafClientCfg.js * TeaLeafEvent.js * @addon */ TeaLeaf.Client.tlSendResize = function() { if (!TeaLeaf.Client.ResizeClientX && !TeaLeaf.Client.ResizeClientY) { return; } var tlevt = new TeaLeaf.Event(TeaLeaf.$C("GUI"), TeaLeaf.$C("Resize")); var tlAddNameValueArray = [TeaLeaf.$C("ClientX"), TeaLeaf.Client.ResizeClientX, TeaLeaf.$C("ClientY"), TeaLeaf.Client.ResizeClientY, TeaLeaf.$C("ScreenX"), TeaLeaf.Client.ResizeScreenX, TeaLeaf.$C("ScreenY"), TeaLeaf.Client.ResizeScreenY]; tlevt.tlAddData(tlAddNameValueArray); TeaLeaf.Client.ResizeClientX = null; TeaLeaf.Client.ResizeClientY = null; TeaLeaf.Client.ResizeScreenX = null; TeaLeaf.Client.ResizeScreenY = null; // Now send the data in tlevt.tlSend(); } /** * Queue scroll event. * @requires * TeaLeafClientCfg.js * TeaLeafEvent.js * @addon */ TeaLeaf.Client.tlQueueScroll = function(tlEvent) { TeaLeaf.Client.tlSendKeys(); TeaLeaf.Client.tlSendResize(); if( ! tlEvent ) { tlEvent = window.event; } if( tlEvent.clientX ) { // IE TeaLeaf.Client.ScrollClientX = tlEvent.clientX; TeaLeaf.Client.ScrollClientY = tlEvent.clientY; TeaLeaf.Client.ScrollScreenX = tlEvent.screenX; TeaLeaf.Client.ScrollScreenY = tlEvent.screenY; } else { // Other TeaLeaf.Client.ScrollHeight = tlEvent.target.scrollHeight; TeaLeaf.Client.ScrollWidth = tlEvent.target.scrollWidth; TeaLeaf.Client.ScrollTop = tlEvent.target.scrollTop; TeaLeaf.Client.ScrollLeft = tlEvent.target.scrollLeft; } } /* Send scroll event. * @requires * TeaLeafClientCfg.js * TeaLeafEvent.js * @addon */ TeaLeaf.Client.tlSendScroll = function() { if (!TeaLeaf.Client.ScrollClientX && !TeaLeaf.Client.ScrollHeight) { return; } var tlevt = new TeaLeaf.Event(TeaLeaf.$C("GUI"), TeaLeaf.$C("Scroll")); var tlAddNameValueArray = [TeaLeaf.$C("ClientX"), TeaLeaf.Client.ScrollClientX, TeaLeaf.$C("ClientY"), TeaLeaf.Client.ScrollClientY, TeaLeaf.$C("ScreenX"), TeaLeaf.Client.ScrollScreenX, TeaLeaf.$C("ScreenY"), TeaLeaf.Client.ScrollScreenY, TeaLeaf.$C("ScrollHeight"), TeaLeaf.Client.ScrollHeight, TeaLeaf.$C("ScrollWidth"), TeaLeaf.Client.ScrollWidth, TeaLeaf.$C("ScrollTop"), TeaLeaf.Client.ScrollTop, TeaLeaf.$C("ScrollLeft"), TeaLeaf.Client.ScrollLeft]; tlevt.tlAddData(tlAddNameValueArray); TeaLeaf.Client.ScrollClientX = TeaLeaf.Client.ScrollClientY = null; TeaLeaf.Client.ScrollScreenX = TeaLeaf.Client.ScrollScreenY = null; TeaLeaf.Client.ScrollHeight = TeaLeaf.Client.ScrollWidth = null; TeaLeaf.Client.ScrollTop = TeaLeaf.Client.ScrollLeft = null; // Now send the data in tlevt.tlSend(); } /** * Find the nearest ancestor for a DOM node of the given type * @param node The original node * @param tag The tag to match on * @addon */ TeaLeaf.Client.tlFindAncestorByTag = function(node, tag) { var cur_node = node.parentNode; while(cur_node && cur_node != window.document) { if(cur_node.nodeType != 1) continue; if(cur_node.tagName == tag) break; else cur_node = cur_node.parentNode; } return cur_node; } /** * Generate an XPath for the node, consumable by TeaLeaf.Client.tlGetNodeFromXPath * @param node The starting node * @param tag The tag to match on * @addon */ TeaLeaf.Client.tlGetXPathFromNode = function(node){ if(node == null){ return null; } var xpath = []; var cur_node = node; var nodes_arr = null; var parent_node = null; // Hack fix to handle tags that are not normally visual elements for(var i in TeaLeaf.Client.Configuration.tlSpecialChildNodeTags) { if(cur_node.tagName.toString()==i) cur_node = cur_node.parentNode; } var idValid = false; for(idValid = TeaLeaf.Client.CheckIfIdValid(cur_node); cur_node != window.document && (!idValid); idValid = TeaLeaf.Client.CheckIfIdValid(cur_node)) { nodes_arr = null; parent_node = null; switch(cur_node.tagName) { case "TD": if(parent_node = TeaLeaf.Client.tlFindAncestorByTag(cur_node, "TR")) nodes_arr = parent_node.cells; break; case "TR": if(parent_node = TeaLeaf.Client.tlFindAncestorByTag(cur_node, "TABLE")) nodes_arr = parent_node.rows; break; case "OPTION": if(parent_node = TeaLeaf.Client.tlFindAncestorByTag(cur_node, "SELECT")) nodes_arr = parent_node.options; break; default: parent_node = cur_node.parentNode; if(!parent_node) parent_node = window.document; nodes_arr = parent_node.childNodes; break; } if(nodes_arr == null) return null; var j=0; for(var i=0; i=0; i--) { if(xpath[i].length > 1) parts[parts.length] = "['"+xpath[i][0]+"',"+xpath[i][1]+"]"; else parts[parts.length] = "['"+xpath[i][0].toString().replace(/'/g, "\\'")+"']"; } return "["+parts.join(",")+"]"; } /** * Check the if the node has a valid id attribute for TeaLeaf.Client.tlGetNodeFromXPath * @param node The node to be tested * @addon */ TeaLeaf.Client.CheckIfIdValid = function(node) { if (node.id == null || typeof(node.id) != "string" || node.id == "") return false; var oldId = node.id; if(!(window.XMLHttpRequest && document.all)) { //bypassing IE7+ browsers node.id = (new Date()).getTime() + "TeaLeaf_unique"; } try { if (!document.getElementById(oldId)) { // id is unique node.id = oldId; return true; } node.id = oldId; return false; } catch(e) { return false;} finally { node.id = oldId; } } /** * Find a node specified by an XPath generated by TeaLeaf.Client.tlGetXPathFromNode * @param path The XPath * @addon */ TeaLeaf.Client.tlGetNodeFromXPath = function(path, decode) { if(path == null) return null; if(decode) path = TeaLeaf.Event.tlXMLDecode(path); var xpath = eval(path); if(xpath == null) return null; var cur_node = window.document; for(var i=0; i 0; } break; } if(TeaLeaf.Client.Configuration.tlUniversalAttach) { var handlers = TeaLeaf.Client.Configuration.tlDocumentHandlers; for(var i=0; i0){ items = items[0].getElementsByTagName("*"); for(var i = 0; i < items.length; i++) { TeaLeaf.Client.tlCheckAttach(items[i]); } } } } catch(e) { } } /** * Attach to the given DOM node and all descendants * @param obj DOM object * @param ignore_descendants (Optional) boolean to ignore child nodes * @addon */ TeaLeaf.Client.tlProcessNode = function(obj, ignore_descendants) { if(typeof(obj) == "string") obj = document.getElementById(obj); if(obj == null) return; try{ switch(obj.tagName) { case "INPUT": case "SELECT": case "TEXTAREA": TeaLeaf.Client.tlCheckAttach(obj); break; default: if(TeaLeaf.Client.Configuration.tlUniversalAttach && TeaLeaf.Client.tlTagNameAllowed(obj.tagName)) TeaLeaf.Client.tlCheckAttach(obj); break; } if(!ignore_descendants) { var explicit_tags = ["INPUT","SELECT","TEXTAREA"]; for(var i=0; i 0; } } } /** * Scan the DOM based on a timer set in the configuration and attach * to controls that might have been rendered due to a DOM update. * * @requires * TeaLeafClientCfg.js * @addon */ TeaLeaf.Client.tlScanForAdditions = function() { if(!TeaLeaf.Client.Configuration.tlScheduledScan) return; // Attach to the main window //TeaLeaf.Client.tlCheckIndControls(window); TeaLeaf.Client.tlProcessNode(document.body); // attach to the frames try{ for(var i=0; i0 ){ TeaLeaf.Client.tlTimeoutID = window.setTimeout(TeaLeaf.Client.tlScanForAdditions, TeaLeaf.Client.Configuration.tlscanupdate); } } /** * Initialize the call to tlSetup UI Client Event * Capture is not used as an SDK. * @requires * TeaLeafEvent.js * @addon */ TeaLeaf.Client.CallInit = function() { TeaLeaf.Event.tlRemoveHandler(window, "beforeunload", eval(TeaLeaf.Client.tlBeforeUnload), false); TeaLeaf.Event.tlRemoveHandler(window, "unload", eval(TeaLeaf.Client.tlUnload), false); TeaLeaf.addOnLoad(TeaLeaf.Client.tlSetup); } //#ifndef TLT_CSC if(TeaLeaf.Client.Configuration.tlinit == false){ TeaLeaf.Client.Configuration.tlinit = true; TeaLeaf.Client.CallInit(); } //#endif } /* * Copyright © 1999-2009 TeaLeaf Technology, Inc. * All rights reserved. * * THIS SOFTWARE IS PROVIDED BY TEALEAF ``AS IS'' * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE DISCLAIMED. * IN NO EVENT SHALL TEALEAF BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF * THE POSSIBILITY OF SUCH DAMAGE. * * @fileoverview * This is the configuration for TeaLeafEnv.js * * @version 2009.09.24.1 * */ if(typeof TeaLeaf.Env == "undefined"){ TeaLeaf.Env = {}; if(typeof TeaLeaf.Env.Configuration == "undefined"){ TeaLeaf.Env.Configuration = { "tlinit" : false, "tlinitpost" : true, tlPlugins : [ {"tlIEplugin": "ShockwaveFlash.ShockwaveFlash.1", "tlpluginname": "Shockwave Flash", "tlversion":"1.0", "tlenable": false}, {"tlIEplugin": "MediaPlayer.MediaPlayer.1", "tlpluginname": "Windows Media Player", "tlversion":"", "tlenable": false}, {"tlIEplugin": "PDF.PdfCtrl.1", "tlpluginname": "Adobe Acrobat", "tlversion":"", "tlenable": false}, {"tlIEplugin": "QuickTimeCheckObject.QuickTimeCheck.1", "tlpluginname": "QuickTime", "tlversion":"", "tlenable": false} ] }; } } /* * Copyright © 1999-2009 TeaLeaf Technology, Inc. * All rights reserved. * * THIS SOFTWARE IS PROVIDED BY TEALEAF ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE * AND NON-INFRINGEMENT ARE DISCLAIMED. IN NO EVENT SHALL TEALEAF * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * * @fileoverview * This file sends Summary about Window, Document, Navigator and * Screen objects rendered on the page. * * @requires * TeaLeaf.js * TeaLeafEnvCfg.js * TeaLeafEvent.js * * @version 2009.09.24.1 * */ if (TeaLeaf.Env && TeaLeaf.Env.Configuration) { /* * Send a page summary about Window, Document, Navigator and Screen * object when the page is loaded. * @requires * TeaLeafEvent.js * @addon */ TeaLeaf.Env.tlSendPageSummary = function() { if (TeaLeaf.Configuration.tlSDK || TeaLeaf.Env.Configuration.tlinitpost != true) { return; } TeaLeaf.Env.Configuration.tlinitpost = false; var tlevt = new TeaLeaf.Event(TeaLeaf.$C("PERFORMANCE"), TeaLeaf.$C("INIT")); TeaLeaf.Event.PageLoadMilliSecs = TeaLeaf.Event.tlDateDiff(TeaLeaf.tlStartLoad, tlevt.date); TeaLeaf.Event.SetType = tlevt.EventType; if (TeaLeaf.Event.SetSubType == "") { TeaLeaf.Event.SetSubType = tlevt.EventSubType; } else { TeaLeaf.Event.SetSubType += "; " + tlevt.EventSubType; } TeaLeaf.Event.Configuration.tlinitflag = true; TeaLeaf.Env.tlInfo(tlevt); TeaLeaf.Env.tlDOMDocumentInfo(tlevt); TeaLeaf.Env.tlDOMWindowInfo(tlevt); TeaLeaf.Env.tlDOMScreenInfo(tlevt); TeaLeaf.Env.tlPluginInfo(tlevt); tlevt.tlSend(true); } /* Gather Basic Info. * @param tlevt TeaLeaf event used for reporting on the Document object. * @requires * TeaLeafEvent.js * @addon */ TeaLeaf.Env.tlInfo = function(tlevt) { tlevt.tlPushXML(TeaLeaf.$C("Info")); var tlAddNameValueArray = [TeaLeaf.$C("PageLoadMilliSecs"), TeaLeaf.Event.tlGetRenderTime(), TeaLeaf.$C("Version"), TeaLeaf.Event.tlGetJSVersion(), TeaLeaf.$C("TimezoneOffset"), tlevt.date.getTimezoneOffset()]; tlevt.tlAddData(tlAddNameValueArray); tlevt.tlPopXML(); } /* Gather Information about the Document object. * @param tlevt TeaLeaf event used for reporting on the Document object. * @requires * TeaLeafEvent.js * @addon */ TeaLeaf.Env.tlDOMDocumentInfo = function(tlevt) { tlevt.tlPushXML(TeaLeaf.$C("Document")); var tlAddNameValueArray1 = [TeaLeaf.$C("Title"), document.title, TeaLeaf.$C("Referer"), document.referer, TeaLeaf.$C("ContentType"), document.contentType, TeaLeaf.$C("LastModified"), document.lastModified, TeaLeaf.$C("CharacterSet"), document.characterSet, TeaLeaf.$C("Height"), document.height, TeaLeaf.$C("Width"), document.width]; tlevt.tlAddData(tlAddNameValueArray1); var tlAddNameValueArray2 = [TeaLeaf.$C("Anchors"), document.anchors.length, TeaLeaf.$C("Applets"), document.applets.length, TeaLeaf.$C("Embeds"), document.embeds.length, TeaLeaf.$C("Forms"), document.forms.length, TeaLeaf.$C("Images"), document.images.length, TeaLeaf.$C("BadImages"), TeaLeaf.Event.tlBadImageCount(), TeaLeaf.$C("Links"), document.links.length, TeaLeaf.$C("Plugins"), document.plugins.length]; tlevt.tlAddData(tlAddNameValueArray2); tlevt.tlPopXML(); } /* Gather Information about the Window object. * @param tlevt TeaLeaf event used for reporting on the Window object. * @requires * TeaLeafEvent.js * @addon */ TeaLeaf.Env.tlDOMWindowInfo = function(tlevt) { tlevt.tlPushXML(TeaLeaf.$C("Window")); var tlAddNameValueArray = [TeaLeaf.$C("WindowHref"), escape(window.location.href), TeaLeaf.$C("WindowProtocol"), window.location.protocol, TeaLeaf.$C("WindowHost"), window.location.host, TeaLeaf.$C("WindowHostName"), window.location.hostname, TeaLeaf.$C("WindowPort"), window.location.port, TeaLeaf.$C("WindowPathName"), window.location.pathname]; tlevt.tlAddData(tlAddNameValueArray); if (window.innerHeight && window.innerWidth) { tlevt.tlAddData([TeaLeaf.$C("ClientSize"), (window.innerHeight + "x" + window.innerWidth)]); } else if (document.body) { if (document.body.clientWidth && document.body.clientHeight) { tlevt.tlAddData([TeaLeaf.$C("ClientSize"), (document.body.clientHeight + "x" + document.body.clientWidth)]); } } var tlAddNameValueArrayScreen = [TeaLeaf.$C("FullScreen"), navigator.fullScreen, TeaLeaf.$C("Frames"), window.frames.length]; if (typeof window.sessionStorage === "object") { var tlWindowId = window.sessionStorage.TLTWID; if (tlWindowId == null) { // Create a new window Id tlWindowId = TeaLeaf.makeRandomString(6); window.sessionStorage.TLTWID = tlWindowId; } tlevt.tlAddData([TeaLeaf.$C("WindowId"), tlWindowId]); } tlevt.tlAddData(tlAddNameValueArrayScreen); tlevt.tlPopXML(); } /* Gather Information about the Navigator object. * @param tlevt TeaLeaf event used for reporting on the Navigator object. * @requires * TeaLeafEvent.js * @addon */ TeaLeaf.Env.tlDOMNavigatorInfo = function(tlevt) { tlevt.tlPushXML(TeaLeaf.$C("Navigator")); // Navigator Info var tlAddNameValueArray = [TeaLeaf.$C("AppCodeName"), navigator.appCodeName, TeaLeaf.$C("AppName"), navigator.appName, TeaLeaf.$C("AppVersion"), navigator.appVersion, TeaLeaf.$C("BrowserLanguage"), navigator.browserLanguage, TeaLeaf.$C("CookieEnabled"), navigator.cookieEnabled, TeaLeaf.$C("CPUClass"), navigator.cpuClass, TeaLeaf.$C("Language"), navigator.language, TeaLeaf.$C("OSCPU"), navigator.oscpu, TeaLeaf.$C("Platform"), navigator.platform, TeaLeaf.$C("Product"), navigator.product, TeaLeaf.$C("SystemLanguage"), navigator.systemLanguage, TeaLeaf.$C("UserAgent"), navigator.userAgent, TeaLeaf.$C("UserLanguage"), navigator.userLanguage, TeaLeaf.$C("Vendor"), navigator.vendor, TeaLeaf.$C("VendorSub"), navigator.vendorSub]; tlevt.tlAddData(tlAddNameValueArray); tlevt.tlPopXML(); } /* Gather Information about the Screen object. * @param tlevt TeaLeaf event used for reporting on the Navigator object. * @requires * TeaLeafEvent.js * @addon */ TeaLeaf.Env.tlDOMScreenInfo = function(tlevt) { tlevt.tlPushXML(TeaLeaf.$C("Screen")); // Screen Info var tlAddNameValueArray = [TeaLeaf.$C("AvailHeight"), screen.availHeight, TeaLeaf.$C("AvailLeft"), screen.availLeft, TeaLeaf.$C("AvailTop"), screen.availTop, TeaLeaf.$C("AvailWidth"), screen.availWidth, TeaLeaf.$C("BufferDepth"), screen.bufferDepth, TeaLeaf.$C("ColorDepth"), screen.colorDepth, TeaLeaf.$C("DeviceXDPI"), screen.deviceXDPI, TeaLeaf.$C("DeviceYDPI"), screen.deviceYDPI, TeaLeaf.$C("FontSmoothingEnabled"), screen.fontSmoothingEnabled, TeaLeaf.$C("Height"), screen.height, TeaLeaf.$C("Left"), screen.left, TeaLeaf.$C("LogicalXDPI"), screen.logicalXDPI, TeaLeaf.$C("LogicalYDPI"), screen.logicalYDPI, TeaLeaf.$C("Top"), screen.top, TeaLeaf.$C("UpdateInterval"), screen.updateInterval, TeaLeaf.$C("Width"), screen.width]; tlevt.tlAddData(tlAddNameValueArray); tlevt.tlPopXML(); } /* Gather Information about the available plugins. * @param tlevt TeaLeaf event used for reporting on available plugins. * @requires * TeaLeafEvent.js * @addon */ TeaLeaf.Env.tlPluginInfo = function(tlevt) { if (window.ActiveXObject) { for (var i = 0; i < TeaLeaf.Env.Configuration.tlPlugins.length; i++) { if (!TeaLeaf.Env.Configuration.tlPlugins[i].tlenable) { continue; } var tlPlugin = TeaLeaf.Env.Configuration.tlPlugins[i].tlIEplugin; try { var tlActiveX = new ActiveXObject(tlPlugin); if (tlActiveX) { tlevt.tlPushXML(TeaLeaf.$C("Plugin")); var tlAddNameValueArray = [TeaLeaf.$C("Pluginname"), TeaLeaf.Env.Configuration.tlPlugins[i].tlpluginname, TeaLeaf.$C("Version"), TeaLeaf.Env.Configuration.tlPlugins[i].tlversion]; tlevt.tlAddData(tlAddNameValueArray); tlevt.tlPopXML(); } } catch(e) { // Do nothing } } } else { for (var i = 0; i < navigator.plugins.length; i++) { for (var j = 0; j < TeaLeaf.Env.Configuration.tlPlugins.length; j++) { if (!TeaLeaf.Env.Configuration.tlPlugins[j].tlenable) { continue; } var tlnavpluginname = navigator.plugins[i].name.substr(0, TeaLeaf.Env.Configuration.tlPlugins[j].tlpluginname.length); if (tlnavpluginname == TeaLeaf.Env.Configuration.tlPlugins[j].tlpluginname) { TeaLeaf.Env.Configuration.tlPlugins[j].tlenable = false; tlevt.tlPushXML(TeaLeaf.$C("Plugin")); var tlAddNameValueArray = [TeaLeaf.$C("Pluginname"), TeaLeaf.Env.Configuration.tlPlugins[j].tlpluginname, TeaLeaf.$C("Version"), TeaLeaf.Env.Configuration.tlPlugins[j].tlversion]; tlevt.tlAddData(tlAddNameValueArray); tlevt.tlPopXML(); } } } } } /* Initialize the call to tlSendPageSummary when UI Client Event * Capture is not used as an SDK. * @addon */ TeaLeaf.Env.CallInit = function() { TeaLeaf.addOnLoad(TeaLeaf.Env.tlSendPageSummary); } if (TeaLeaf.Env.Configuration.tlinit == false) { TeaLeaf.Env.Configuration.tlinit = true; TeaLeaf.Env.CallInit(); } }