// JavaScript Document

// ###########################################
// GooglEvents version 3.0
// Permet enregistrer dans Google Analytics 
// les clics sur les fichiers, liens et formulaires internes ou externes, 
// ainsi que les fonctions javascript et sections de page (ancres)
// nicolas.debray@micc.gouv.qc.ca
// Derniere mise a jour : 2011-07-15
// ###########################################
// Derniere mise a jour : 2011-11-10
// Ajout du support pour le Code Google Nouveau
// ###########################################


// ###########################################
function classGooglEvents(){
// ###########################################


// ###########################################
// EDITER CES PARAMETRES
// ###########################################
// Des parametres GET sont ajoutes a l'url envoyee a GoogleAnalytics
// de maniere a pouvoir filtrer les urls recues dans GoogleAnalytics
// sans perdre l'url originale
// ###########################################

// NOMS DES PARAMETRES GET  
  var GOOGLE_TARGET_TYPE     = new String("nature");
  var GOOGLE_TARGET_LABEL    = new String("titre");
  var GOOGLE_TARGET_SOURCE   = new String("source");
  var GOOGLE_DATA_PREFIX     = new String("{gdata:[");
  var GOOGLE_DATA_SUFFIX     = new String("]}");

// VALEURS DES PARAMETRES GET
  var TARGET_TYPE_INT        = new String("ilink");
  var TARGET_TYPE_FILE       = new String("ifile");
  var TARGET_TYPE_EXT        = new String("xlink");
  var TARGET_TYPE_EXT_FILE   = new String("xfile");
  var TARGET_TYPE_FORM       = new String("iform");
  var TARGET_TYPE_FORM_EXT   = new String("xform");
  var TARGET_TYPE_FUNC       = new String("func");
  var TARGET_TYPE_SECT       = new String("anchor");
  var TARGET_TYPE_ELEM       = new String("element");
  var TARGET_ALT_LABELS      = new Array("alt","title","name","id");
  var TARGET_ATTRIBUTES      = new Array(GOOGLE_TARGET_TYPE.valueOf(),GOOGLE_TARGET_LABEL.valueOf(),GOOGLE_TARGET_SOURCE.valueOf(),"name","id","class","rel","ref","lang");
  var TARGET_ATTR_TO_AVOID   = new Array("title","alt","src","href","target","coords","shape","tabindex","start","loop","maxlength","height","size","style");
  var TARGET_ATTR_SEPARATOR1 = new String(",");
  var TARGET_ATTR_SEPARATOR2 = new String(":");
  var TARGET_TAGS_TO_AVOID   = new Array("WINDOW","HTML","BODY","DOCUMENT","DIV","UL","OL","LI","DL","DD","DT","LI");
  var TARGET_TYPES           = new Array("A", "AREA", "INPUT");
  var TARGET_INPUT_TYPES     = new Array("BUTTON", "SUBMIT");  
  var TARGET_FUNC_TYPES      = new Array("onblur","onchange","onclick","ondblclick","onfocus","onkeydown","onkeypress","onkeyup","onload","onmousedown","onmouseout","onmouseover","onmouseup","onselect");  
  var TARGET_INFO_UNDEFINED  = new String("nd");
  
// SUR QUELLE PARTIE SUIVRE LES CLICS
  var EVENT_TYPE             = new String("click"); // iPhone fully compatible EVENTS : click, mousedown, mouseup
  var EVENT_ZONE             = document;

// true POUR TESTER et false POUR USAGE NORMAL 
  var TEST_MODE              = new Boolean(false);  

 
 
 
   
// ###########################################
// +++++++++++++++++++++++++++++++++++++++++++
// ###########################################
 
// NE PAS EDITER PLUS BAS A MOINS DE...
 
// ###########################################
// +++++++++++++++++++++++++++++++++++++++++++
// ###########################################

 
// VARIABLES
  var __domTargetEventElement = new Object();
  var __domTargetElement      = new Object();
  var __strTargetRawUrl       = new String();
  var __strTargetUrl          = new String();
  var __strTargetAttributes   = new String();
  var __arrTargetAttributes   = new Array();
  var __strTargetTagName      = new String();
  var __strLocation           = decodeURI(window.location.toString()); 
  var __strGoogleCallMethod   = new String();
  var __strTargetEventElementTagName = new String();    

// CONSTANTES (pseudo)
	var REGEX_NONWORD      = /\W+/gi;
	var REGEX_QUOTES       = /(['']|[""]|(’))/g; 
	var REGEX_SPACE        = /\s+/g;
	var REGEX_PONCTUATION  = /((,)|(;)|(:)|(\.))/g;
	var REGEX_EXTENSIONS_1 = /((.doc)|(.docx)|(.xls)|(.xlsx)|(.rtf)|(.ppt)|(.pps)|(.pdf)|(.jpg)|(.jpeg)|(.gif)|(.png))$/i;
	var REGEX_EXTENSIONS_2 = /((.doc)|(.docx)|(.xls)|(.xlsx)|(.rtf)|(.ppt)|(.pps)|(.pdf)|(.jpg)|(.jpeg)|(.gif)|(.png))(\?)/i;
	var REGEX_FUNCTIONS_1  = /((retur.)(.)*(.alse))|((javascript)(.)*(:))|((\()(.)*(\)))/;
  var REGEX_FUNCTIONS_2  = /#$/;
	var REGEX_ANCHOR       = /(#)(.)*$/;
  var REGEX_TRIM         = /^(\s*)|(\s*)$/g;
	var REGEX_HTML         = /<\S[^><]*>/g;
	var REGEX_HTTP         = /^http/;
	var REGEX_FTP          = /^ftp/;
	var REGEX_HTTP_HOST    = new String(location.protocol+"//"+location.hostname);
	var REGEX_HOST         = new String(location.hostname);
	var REGEX_LOCATION     = new String(window.location);
	var REGEX_LOC_PATH     = new String(location.pathname);


// ###########################################
// ++++++++   MÉTHODES PUBLIQUES  ++++++++++++
// ########################################### 

  this.void_addEventListener          =   void_addEventListener;
  this.str_setGoogleMethod            =   str_setGoogleMethod;
  this.bool_setTestMode               =   bool_setTestMode;
  this.arrStr_setUnwantedAttributes   =   arrStr_setUnwantedAttributes;
 

//-------------------------------------------
function void_addEventListener(myZone, myEvent) 
//-------------------------------------------
{
    try
    {
        if (myZone == "")  myZone  = EVENT_ZONE;
        if (myEvent == "") myEvent = EVENT_TYPE.valueOf();
        
        if (myZone.addEventListener)
        {
            myZone.addEventListener(myEvent,voidEventAction,false); 
        }
        else if (myZone.attachEvent)
        {   
            myZone.attachEvent(('on'+myEvent),voidEventAction); 
        }
        else return;      
    }
    catch(err)
    {
        void_doWithErrors("void_addEventListener : " + err);
    }
}



//-------------------------------------------
function str_setGoogleMethod(myString)
//-------------------------------------------
{
    try
    {
        __strGoogleCallMethod = myString;   
    }
    catch(err)
    {
        void_doWithErrors("str_setGoogleMethod : " + err);
    }
}


//-------------------------------------------
function bool_setTestMode(myBool)
//-------------------------------------------
{
    try
    {
        TEST_MODE = myBool;   
    }
    catch(err)
    {
        void_doWithErrors("bool_setTestMode : " + err);
    }
}


//-------------------------------------------
function arrStr_setUnwantedAttributes(myArrString)
//-------------------------------------------
{
    try
    {
        TARGET_ATTR_TO_AVOID = myArrString;   
    }
    catch(err)
    {
        void_doWithErrors("arrStr_setUnwantedAttributes : " + err);
    }
}



// ###########################################
// ++++++++++   MÉTHODES PRIVÉES  ++++++++++++
// ###########################################


//-------------------------------------------
var voidEventAction = function voidEventAction(myEvent)
//-------------------------------------------
{
    try
    {
        __arrTargetAttributes = new Array();
        setTargetElement(myEvent);
        if (!boolValidateTarget())  return;
        setTargetRawUrl();
        setTargetType();
        str_setTargetLabel();
        str_setTargetUrl();
        str_setTargetSource();
        void_setTargetAttributes();
        if (TEST_MODE.valueOf()) void_test(str_makeGoogleString());
        else void_googleController(str_makeGoogleString());     
    }
    catch(err)
    {
        void_doWithErrors("voidEventAction : " + err);
    }
}


//-------------------------------------------
var setTargetElement = function setTargetElement(myEvent)
//-------------------------------------------
{
    try
    {
        if (!myEvent) myEvent = window.event;
        __domTargetEventElement = (myEvent.target) ? myEvent.target : myEvent.srcElement;
        __strTargetEventElementTagName = __domTargetEventElement.tagName.toUpperCase();
        __domTargetElement = __domTargetEventElement;
        __strTargetTagName = __domTargetElement.tagName.toUpperCase();
    }
    catch(err)
    {
        void_doWithErrors("setTargetElement : " + err);
    }
}


//-------------------------------------------
var boolValidateTarget = function boolValidateTarget() 
//-------------------------------------------
{
    try
    {
        if (boolInArray(__strTargetTagName, TARGET_TAGS_TO_AVOID)) return false;
        while (!boolInArray(__strTargetTagName, TARGET_TYPES) && __strTargetTagName != "BODY")
        {
            __domTargetElement = __domTargetElement.parentNode;
            __strTargetTagName = __domTargetElement.tagName;
        }
        if (__strTargetTagName == "INPUT" && !boolInArray(__domTargetElement.type.toUpperCase(), TARGET_INPUT_TYPES)) return false;  
        return (__strTargetTagName != "BODY") ? true : false;
    }
    catch(err)
    {
        void_doWithErrors("boolValidateTarget : " + err);
        return false;
    }
}
       


//-------------------------------------------
var boolInArray = function boolInArray(myNeedle, myArray) 
//-------------------------------------------
{
    try
    {
        for (var i in myArray)
        {
          if(myArray[i] == myNeedle.toUpperCase() || myArray[i] == myNeedle.toLowerCase()) return true;
        }
        return false;
    }
    catch(err)
    {
        void_doWithErrors("boolInArray : " + err);
        return false;
    }
}


//-------------------------------------------
var str_cleanNonWord = function str_cleanNonWord(myString) 
//-------------------------------------------
{
    try
    {
        //myString = myString.toString();
        myString = myString.replace(REGEX_TRIM,"");
        myString = myString.replace(REGEX_SPACE,"_"); 
        myString = str_replaceAccents(myString);
        myString = myString.replace(REGEX_QUOTES,"_");
        myString = myString.replace(REGEX_PONCTUATION,"");
        return myString;
    }
    catch(err)
    {
        void_doWithErrors("str_cleanNonWord : " + err);
        return "";
    }
}


//-------------------------------------------
var str_replaceAccents = function str_replaceAccents(myString)
//-------------------------------------------
{
    try
    {
        //myString = myString.toString();
        myString = myString.replace(/[àâä]/gi,"a");
        myString = myString.replace(/[éèêë]/gi,"e");
        myString = myString.replace(/[îï]/gi,"i");
        myString = myString.replace(/[ôö]/gi,"o");
        myString = myString.replace(/[ùûü]/gi,"u");
        return myString;
    }
    catch(err)
    {
        void_doWithErrors("str_replaceAccents : " + err);
        return "";
    }
}



//-------------------------------------------
var setTargetRawUrl = function setTargetRawUrl()
//-------------------------------------------
{
    try
    {
        if (__strTargetTagName == "INPUT")
        {
            __strTargetRawUrl = __domTargetElement.form.action.replace(REGEX_TRIM,"");
            
            if (__strTargetRawUrl.replace(REGEX_SPACE,"") == "")
            {
                __strTargetRawUrl = window.location.toString(); 
            }
        }
        else
        {
            __strTargetRawUrl = __domTargetElement.href.replace(REGEX_TRIM,"");
        } 
    }
    catch(err)
    {
        void_doWithErrors("setTargetRawUrl : " + err);
    } 
}


//-------------------------------------------
var setTargetType = function setTargetType()
//-------------------------------------------
{
    try
    {
        __arrTargetAttributes[GOOGLE_TARGET_TYPE.valueOf()] = str_detectLinkType();
    }
    catch(err)
    {
        void_doWithErrors("setTargetType : " + err);
    } 
}


//-------------------------------------------
var str_detectLinkType = function str_detectLinkType() 
//-------------------------------------------
{
    try
    {
        if (__strTargetTagName == "INPUT" && typeof(__domTargetElement.form) != "undefined")
        {
            if (__domTargetElement.form.getAttribute("action").match(REGEX_HOST) || __domTargetElement.form.action.match(REGEX_HOST)) 
            {
                return TARGET_TYPE_FORM;
            }
            else if (__domTargetElement.form.getAttribute("action").match(REGEX_HTTP)) 
            {
                return TARGET_TYPE_FORM_EXT;
            }
            else
            {
                return TARGET_INFO_UNDEFINED;
            }            
        }
        else
        {
            if (__domTargetElement.getAttribute("href").match(REGEX_HOST)) 
            {
                if (bool_detectLinkTypeFile()) return TARGET_TYPE_FILE;
                else if (bool_detectLinkTypeAnchor()) return TARGET_TYPE_SECT;
                else return TARGET_TYPE_INT;
            }
            else if (__strTargetRawUrl.match(REGEX_HOST) && !__domTargetElement.getAttribute("href").match(REGEX_HTTP)) 
            {
                if (bool_detectLinkTypeFunction())    return TARGET_TYPE_FUNC;
                else if (bool_detectLinkTypeFile())   return TARGET_TYPE_FILE;
                else if (bool_detectLinkTypeAnchor()) return TARGET_TYPE_SECT;
                else return TARGET_TYPE_INT;
            }
            else if (__domTargetElement.getAttribute("href").match(REGEX_HTTP) || __domTargetElement.getAttribute("href").match(REGEX_FTP))
            {
                if (__strTargetRawUrl.match(REGEX_FUNCTIONS_1)) return TARGET_TYPE_FUNC;
                else if (bool_detectLinkTypeFile()) return TARGET_TYPE_EXT_FILE;
                else return TARGET_TYPE_EXT;
            } 
            else
            {
                if(bool_detectLinkTypeFunction()) return TARGET_TYPE_FUNC;
                else return TARGET_INFO_UNDEFINED;
            }        
        }
        return TARGET_INFO_UNDEFINED;
    }
    catch(err)
    {
        void_doWithErrors("str_detectLinkType : " + err);
        return TARGET_INFO_UNDEFINED;
    }  
}


//-------------------------------------------
var bool_detectLinkTypeFunction = function bool_detectLinkTypeFunction() 
//-------------------------------------------
{
    try
    {
        if (__strTargetRawUrl.match(REGEX_FUNCTIONS_1))         
        {
            return true;
        }
        else if ((__strTargetRawUrl.match(REGEX_FUNCTIONS_2) || __strTargetRawUrl == REGEX_LOCATION || __strTargetRawUrl == "" || __strTargetRawUrl == REGEX_HTTP_HOST) && (bool_detectTargetEventScript())) 
        {
            return true;
        }
        else return false;
    }
    catch(err)
    {
        void_doWithErrors("bool_detectLinkTypeFunction : " + err);
        return false;
    }  
}


//-------------------------------------------
var bool_detectLinkTypeFile = function bool_detectLinkTypeFile() 
//-------------------------------------------
{
    try
    {
        if (__strTargetRawUrl.match(REGEX_EXTENSIONS_1) || __strTargetRawUrl.match(REGEX_EXTENSIONS_2))         
        {
            return true;
        }
        else return false;
    }
    catch(err)
    {
        void_doWithErrors("bool_detectLinkTypeFile : " + err);
        return false;
    }  
}


//-------------------------------------------
var bool_detectLinkTypeAnchor = function bool_detectLinkTypeAnchor() 
//-------------------------------------------
{
    try
    {
        if (__strTargetRawUrl.match(REGEX_ANCHOR))         
        {
            return true;
        }
        else return false;
    }
    catch(err)
    {
        void_doWithErrors("bool_detectLinkTypeAnchor : " + err);
        return false;
    }  
}



//-------------------------------------------
var bool_detectTargetEventScript = function bool_detectTargetEventScript()
//-------------------------------------------
{
    try
    {
        for (var x in TARGET_FUNC_TYPES)
        {
            if (__domTargetElement.getAttribute(TARGET_FUNC_TYPES[x]))
            {
                return true;
            }
        }
        return false;
    }
    catch(err)
    {
        void_doWithErrors("bool_detectTargetEventScript : " + err);
        return false;
    } 
}



//-------------------------------------------
var str_setTargetLabel = function str_setTargetLabel()
//-------------------------------------------
{
    try
    {
        var theStr = new String();
            theStr = str_targetLabel(); 
            theStr = str_cleanNonWord(theStr);
        __arrTargetAttributes[GOOGLE_TARGET_LABEL.valueOf()] = theStr; 
    }
    catch(err)
    {
        void_doWithErrors("str_setTargetLabel : " + err);
    } 
}



//-------------------------------------------
var str_targetLabel = function str_targetLabel()
//-------------------------------------------
{
    try
    {
        switch(__strTargetTagName)
        {
            case "A":
                var theName = __domTargetElement.innerHTML.replace(REGEX_HTML,"");
                    theName = theName.replace(REGEX_TRIM,"");
                if (theName.replace(REGEX_NONWORD,"") != "") 
                {
                    return theName;
                }
                else if (str_targetAltLabels(__domTargetElement) != TARGET_INFO_UNDEFINED)
                {
                    return str_targetAltLabels(__domTargetElement);
                }
                else if (__domTargetElement.hasChildNodes())
                {
                    var theChildren = __domTargetElement.childNodes;
                    for (var i=0; i<=theChildren.length-1; i++)
                    {
                        if (str_targetAltLabels(theChildren[i] != TARGET_INFO_UNDEFINED)) 
                        {
                            return str_targetAltLabels(theChildren[i]);
                        }
                    }
                }
                break;
                
            case "AREA":
                if (str_targetAltLabels(__domTargetElement) != TARGET_INFO_UNDEFINED)
                {
                    return str_targetAltLabels(__domTargetElement);
                }
                else if (str_targetAltLabels(__domTargetElement.parentNode) != TARGET_INFO_UNDEFINED)
                {
                    return str_targetAltLabels(__domTargetElement.parentNode);
                }
                break;
                
            case "INPUT":
                if (__domTargetElement.value.replace(REGEX_TRIM,"") != "")
                {
                    return __domTargetElement.value;
                }
                else if (str_targetAltLabels(__domTargetElement) != TARGET_INFO_UNDEFINED)
                {
                    return str_targetAltLabels(__domTargetElement);
                }
                else if (typeof(__domTargetElement.form)!= "undefined" && str_targetAltLabels(__domTargetElement.form) != TARGET_INFO_UNDEFINED)
                {
                    return str_targetAltLabels(__domTargetElement.form);
                }
                break;
                
            default:
                return str_targetAltLabels(__domTargetElement);
                break;
        }
        return TARGET_INFO_UNDEFINED;
    }
    catch(err)
    {
        void_doWithErrors("str_targetLabel : " + err);
        return "";
    }     
}


//-------------------------------------------
var str_targetAltLabels = function str_targetAltLabels(myElem)
//-------------------------------------------
{
    try
    {        
        var theLabel = "";
        for (var i=0; i<=TARGET_ALT_LABELS.length-1; i++)
        {
            if (myElem.nodeType == 1 && myElem.getAttribute(TARGET_ALT_LABELS[i]))  
            {
                return myElem.getAttribute(TARGET_ALT_LABELS[i]);
            }
        }
        return TARGET_INFO_UNDEFINED;
    }
    catch(err)
    {
        void_doWithErrors("str_targetAltLabels : " + err);
        return TARGET_INFO_UNDEFINED;
    } 
}


//-------------------------------------------
var void_setTargetAttributes = function void_setTargetAttributes()
//-------------------------------------------
{
    try
    {    
        void_targetAttributes();
        __strTargetAttributes = str_joinTargetAttributes();
    }
    catch(err)
    {
        void_doWithErrors("void_setTargetAttributes : " + err);
    } 
}



//-------------------------------------------
var void_targetAttributes = function void_targetAttributes()          
//-------------------------------------------       
{
    try
    {      
        var resultStr = new String();
        var theKey    = new String();
        var theValue  = new String();
        var theAttributes = __domTargetElement.attributes;
    
        for (var i=0; i<=theAttributes.length-1; i++)
        {
             theKey   = theAttributes[i].nodeName;
             theValue = theAttributes[i].nodeValue;
             
             if (theValue != "" && theValue != null && theValue != "inherit")
             {
                 theValue = str_cleanNonWord(theValue+"");
                 __arrTargetAttributes[theKey] = theValue;             
             }
        }
    }
    catch(err)
    {
        void_doWithErrors("void_targetAttributes : " + err);
    } 
}


//-------------------------------------------
var str_joinTargetAttributes = function str_joinTargetAttributes()          
//-------------------------------------------       
{
    try
    {      
        var resultStr = new String();
        var theArray  = new Array();
        
        for (var x in __arrTargetAttributes)
        {
             if (boolInArray(x, TARGET_ATTRIBUTES))
             {
                theArray.push(x+TARGET_ATTR_SEPARATOR2+__arrTargetAttributes[x]);
             }
        }
        resultStr = theArray.join(TARGET_ATTR_SEPARATOR1);
        return resultStr;
    }
    catch(err)
    {
        void_doWithErrors("str_joinTargetAttributes : " + err);
        return "";
    } 
}


//-------------------------------------------
var str_setTargetUrl = function str_setTargetUrl()
//-------------------------------------------
{
    try
    {    
        __strTargetUrl = encodeURI(__strTargetRawUrl);
    }
    catch(err)
    {
        void_doWithErrors("str_setTargetUrl : " + err);
    } 
}


//-------------------------------------------
var str_setTargetSource = function str_setTargetSource() 
//-------------------------------------------
{
    try
    {    
        __arrTargetAttributes[GOOGLE_TARGET_SOURCE.valueOf()] = __strLocation;
    }
    catch(err)
    {
        void_doWithErrors("str_setTargetSource : " + err);
    } 
}


//-------------------------------------------
var str_makeGoogleString = function str_makeGoogleString()
//-------------------------------------------
{
    try
    {    
        return __strTargetUrl + GOOGLE_DATA_PREFIX.valueOf() + __strTargetAttributes + GOOGLE_DATA_SUFFIX.valueOf();
    }
    catch(err)
    {
        void_doWithErrors("str_makeGoogleString : " + err);
        return "";
    } 
}



//-------------------------------------------
var void_googleController = function void_googleController(myString)
//-------------------------------------------
{
    try
    {    
        //eval('__strGoogleCallMethod.valueOf()+"("+myString+");"');
        //pageTracker._trackPageview(myString);
        if (typeof(pageTracker) != "undefined") pageTracker._trackPageview(myString); 
        else if (typeof(_gaq) != "undefined") _gaq.push(['_trackPageview', myString]); 
    }
    catch(err)
    {
        void_doWithErrors("void_googleController : " + err);
    } 
}


//-------------------------------------------
var void_test = function void_test(myString)
//-------------------------------------------
{
    try
    {    
        alert(myString);
    }
    catch(err)
    {
        void_doWithErrors("void_test : " + err);
    } 
}



//-------------------------------------------
var void_doWithErrors = function void_doWithErrors(myString)
//-------------------------------------------
{
    //alert(myString);
}









// ###########################################
}
// ###########################################




//--------------------------------------    
function onloadInitialize()
//--------------------------------------   
{
    // Pour tous les navigateurs sauf Firefox
    if (document.readyState == "complete" || document.readyState == "interactive")
    {
        initialize();
    }
    // Pour Firefox
    else if (document.addEventListener) 
    {
        document.addEventListener("DOMContentLoaded", initialize, false);
    }
}


//--------------------------------------    
function initialize()
//--------------------------------------   
{
    // Instanciation
    var myGooglEventObj = new classGooglEvents();
        myGooglEventObj.void_addEventListener(document, "click");
}

onloadInitialize();