var globalVariables = new Array(0); //holds all refferences to objects that may be required in different objects
                                    //for example globalVariables["carsListGrid_store"] - holds refference to store
                                    //for carsListGrid_store - used to .lodad() after adding new model
                                    //carsListGrid
                                    //globalVariables['editSectionsActiveTabIndex'] - 



var idSeparator2 = '__'; //separator used to create id attribute of html elements (used in adminPanel)






formatXMLCode = {
  output: '',
  
  traverseToHTML: function(node) {
    if(node.hasChildNodes()) {
        this.output += '<ul style="margin-left: 15px;"><li>';
        this.output += '<b>&lt;<span style="color: #a31515;">'+node.tagName + '</span>';
        
        //print attribs
        for(var i=0; i<node.attributes.length; i++)
          this.output +=  ' <span style="color: #F00;">' + node.attributes(i).name + '</span>="<span style="color: #00F;">' + node.attributes(i).value + '</span>"';
        
        this.output += '&gt;</b>';
        for(var i=0; i<node.childNodes.length; i++)
            this.traverseToHTML(node.childNodes(i));
        this.output += '<b>&lt;/<span style="color: #a31515;">'+node.tagName+'</span>&gt;</b>';
        this.output += '</li></ul>';
    }else{
      if(node.nodeName != '#text'){
        this.output += '<ul style="margin-left: 15px;"><li>';
        this.output += '<b>&lt;<span style="color: #a31515;">'+node.tagName + '</span>';
        
        //print attribs
        for(var i=0; i<node.attributes.length; i++)
          this.output +=  ' <span style="color: #F00;">' + node.attributes(i).name + '</span>="<span style="color: #00F;">' + node.attributes(i).value + '</span>"';
        
        this.output += '&gt;</b>';
      }
      
      this.output += node.text;
      
      if(node.nodeName != '#text'){
        this.output += '<b>&lt;/<span style="color: #a31515;">'+node.tagName+'</span>&gt;</b>';
        this.output += '</li></ul>';
      }
    }
  },
  
  traverse: function(node, deep) {
    if(node.hasChildNodes()) {
        for(var i = 0; i < deep; i++)
          this.output += '\t';
        this.output += '<' + node.tagName;
        
        //print attribs
        for(var i=0; i<node.attributes.length; i++)
          this.output +=  ' ' + node.attributes(i).name + '="' + node.attributes(i).value.replace(/&/gi, '&amp;').replace(/</gi, '&lt;').replace(/>/gi, '&gt;').replace(/'/gi, '&apos;').replace(/"/gi, '&quot;') + '"';
        
        this.output += '>';
        
        
        
        if(node.firstChild.nodeName != '#text'){
          this.output += '\r\n';
        }
        for(var i=0; i<node.childNodes.length; i++)
            this.traverse(node.childNodes(i), deep+1);
        
        
        if(node.firstChild.nodeName != '#text'){
          for(var i = 0; i < deep; i++)
            this.output += '\t';
        }
        this.output += '</'+node.tagName+'>\r\n';
    }else{
      if(node.nodeName != '#text'){
        for(var i = 0; i < deep; i++)
          this.output += '\t';
        this.output += '<' + node.tagName;
        
        //print attribs
        for(var i=0; i<node.attributes.length; i++)
          this.output +=  ' ' + node.attributes(i).name + '="' + node.attributes(i).value.replace(/&/gi, '&amp;').replace(/</gi, '&lt;').replace(/>/gi, '&gt;').replace(/'/gi, '&apos;').replace(/"/gi, '&quot;') + '"';
        
        this.output += '>';
      }
      
      this.output += node.text.replace(/&/gi, '&amp;').replace(/</gi, '&lt;').replace(/>/gi, '&gt;').replace(/'/gi, '&apos;').replace(/"/gi, '&quot;');
      
      if(node.nodeName != '#text'){
        this.output += '</'+node.tagName+'>\r\n';
      }
    }
  },
  
  
  formatXML: function(XMLstring, includeXMLDeclaration) {
    this.output = '';
    this.traverse(this.createNodeFromString(XMLstring), 0);
    var results = XMLstring.match(new RegExp("<\\?xml.*\\?>", ''));
    if(includeXMLDeclaration){
      this.output = results[0] + '\n' + this.output;  
    }
    return this.output;
  },
  
  
  formatXMLToHTML: function(XMLstring) {
    this.output = '';
    this.traverseToHTML(this.createNodeFromString(XMLstring));
    return this.output;
  },
  
  
  /* ------------------------------------------------------------------------- *\
     Returns node object created from XMLstring
     
     XMLstring - for ex.: '<someName><subNode></subNode></someName>'
                 will return <someName> node
  \* ------------------------------------------------------------------------- */
  createNodeFromString: function(XMLstring){
  	var tempObjXML = new ActiveXObject("Microsoft.XMLDOM");
    tempObjXML.async = false;
    
    tempObjXML.loadXML(XMLstring);
    var newNode = tempObjXML.documentElement;
    tempObjXML = null;
    
    return newNode;
  }//END: createNodeFromString: function(XMLstring){
  
}






/* ------------------------------------------------------------------------- *\
  Replaces special characters to entities.
\* ------------------------------------------------------------------------- */
function mako_toEntities(str){
  return str.replace(/([^\x00-\x80])/g, function (str, p1, offset, s) { return  '&#' + s.charCodeAt(offset) + ';'	});
}




/* ------------------------------------------------------------------------- *\
  Replaces special characters to entities.
\* ------------------------------------------------------------------------- */
function mako_fromEntities(str){
  return str.replace(/&#(\d+);/g, function (allMachedStr, code) { 
                                          return  String.fromCharCode(code);
                                        });
}




/* ------------------------------------------------------------------------- *\
  Renders element to middle of page.
  Designed for elements which inherits by Panel class (may work for some others)
  
  panelElement - object of type Ext.Panel or object of clas that extends Ext.Panel
                 for example: Ext.FormPanel
  destinationElement - dom element to render to, type: Ext.Element
\* ------------------------------------------------------------------------- */
function mako_renderToMiddle(panelElement, destinationElement){
    
    panelElement.render(destinationElement);
    var panelElementWidth = panelElement.getSize().width;
    var panelElementHeight = panelElement.getSize().height;
    panelElement.setVisible(false);
    
    var destinationElementX = (Ext.getBody().getSize().width/2) - (panelElementWidth/2);
    var destinationElementY = (Ext.getBody().getSize().height/2) - (panelElementHeight/2);
    destinationElement.position('absolute', 0, destinationElementX, destinationElementY);
    
    panelElement.setVisible(true);
    panelElement.render(destinationElement);
}//END: function mako_renderToMiddle(panelElement, destinationElement){
/* ------------------------------------------------------------------------- *\
	###########################################################################
\* ------------------------------------------------------------------------- */




/* ------------------------------------------------------------------------- *\
  encodes form fields to base64
  function used to assign to form to 'beforeaction' event
  
\* ------------------------------------------------------------------------- */
function mako_addEntitiesToFormFields(formObj, action){
    if(action.type == 'submit'){
      var formItems = formObj.items.items;
      for(var i = 0; i<formItems.length; i++){
        //revrite values from 'file' fields to hidden fields (and add entities - solution for special characters)
        if(formItems[i].inputType!=undefined && formItems[i].inputType == 'file'){
            formItems[i-1].setValue(mako_toEntities(document.getElementById(formItems[i].getId()).value));
        }
  		//solution for special characters
        if(formItems[i].xtype == 'radio'){
          //if 'radio' assign value holded in Ext js object to dom element value property
          formItems[i].getEl().dom.value = mako_toEntities(formItems[i].value);
        }else{
          formItems[i].setValue(mako_toEntities(''+formItems[i].getValue())); //chackbox getValues must be converted to String
        }
		
      }
    }//END: if(action.type == 'submit'){
    
    return true;
    
}//END: function mako_addEntitiesToFormFields(formObj, action){




/* ------------------------------------------------------------------------- *\
  decodes form fields from Entities
  function used to assign to form to 'actioncomplete' event
  function used to undo changes made in form fields before submit
  This function undo changes made by mako_encodeFormFieldsToBase64
  
\* ------------------------------------------------------------------------- */
function mako_removeEntitiesFromFormFields(formObj, action){
    if(action.type == 'submit'){
      var formItems = formObj.items.items;
      for(var i = 0; i<formItems.length; i++){
        //revrite values from 'file' fields to hidden fields (and encode in base64 - solution for special characters)
        if(formItems[i].inputType == 'file'){
            formItems[i-1].setValue(mako_fromEntities(document.getElementById(formItems[i].getId()).value));
        }
        
		//solution for special characters
        if(formItems[i].xtype == 'radio'){
          //if 'radio' assign value holded in Ext js object to dom element value property
          formItems[i].getEl().dom.value = mako_fromEntities(formItems[i].getEl().dom.value);
        }else{
          formItems[i].setValue(mako_fromEntities(formItems[i].getValue()));
        }
		
      }
    }//END: if(action.type == 'submit'){
    
	//mark invalid fields
	if (action.result && action.result.errors) {
		for (elements in action.result.errors) {
			Ext.getCmp(elements).markInvalid(action.result.errors[elements]);
		}
	}
	
    return true;
    
}//END: function mako_removeEntitiesFromFormFields(formObj, action){




/* ------------------------------------------------------------------------- *\
  creates Flash object depending on browser type.
  
  id - id of newly created element
  src, flashvars, width, height - values to add to attributes of flash object
  
\* ------------------------------------------------------------------------- */
function createFlashObject(id, src, flashvars, width, height){
  if(window.ActiveXObject || (window.navigator.appName.toUpperCase().indexOf('OPERA') != -1)){
    //is IE or Opera
    var obj = document.createElement('object');
        
    var paramObj = document.createElement('param');
        paramObj.setAttribute('name', 'allowScriptAccess');
        paramObj.setAttribute('value', 'always');
        obj.appendChild(paramObj);
    
        paramObj = document.createElement('param');
        paramObj.setAttribute('name', 'WMode');
        paramObj.setAttribute('value', 'transparent');
        obj.appendChild(paramObj);
        
        paramObj = document.createElement('param');
        paramObj.setAttribute('name', 'quality');
        paramObj.setAttribute('value', 'high');
        obj.appendChild(paramObj);
        
        paramObj = document.createElement('param');
        paramObj.setAttribute('name', 'src');
        paramObj.setAttribute('value', src);
        obj.appendChild(paramObj);
        
        paramObj = document.createElement('param');
        paramObj.setAttribute('name', 'flashvars');
        paramObj.setAttribute('value', flashvars);
        obj.appendChild(paramObj);
        
    document.getElementById('VideoGalleryScreen').appendChild(obj);
        obj.setAttribute('id', id);
        obj.setAttribute('width', width);
        obj.setAttribute('height', height);
        obj.setAttribute('codebase', 'http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=7,0,19,0');
        obj.setAttribute('classid', 'clsid:D27CDB6E-AE6D-11cf-96B8-444553540000');
        
  }else{
    //is some another browser
    var obj = document.createElement('embed');
        obj.setAttribute('id', id);
        obj.setAttribute('width', width);
        obj.setAttribute('height', height);
        obj.setAttribute('type', 'application/x-shockwave-flash');
        obj.setAttribute('allowScriptAccess', 'always');
        obj.setAttribute('WMode', 'transparent');
        obj.setAttribute('quality', 'high');
        obj.setAttribute('src', src);
        obj.setAttribute('flashvars', flashvars);
        
    document.getElementById('VideoGalleryScreen').appendChild(obj);
        
  }
}//END: function createFlashObject(){


/* ------------------------------------------------------------------------- *\
  Removes element from DOM tree
  
  id - id of element to remove
\* ------------------------------------------------------------------------- */
function removeFlashObject(id){
  var obj = document.getElementById(id);
  obj.parentNode.removeChild(obj);
}




/* ------------------------------------------------------------------------- *\
  used to scroll elements
  
  WARRING: Modulo of dividing heightToMove by stepSize have to be equal '0'
           
           
  direction - 'up'/'down'
  elementId - id of element that is scrolled and have some items
  heightToMove - used in function to pass height that is left to move, when
                 adding this function to button this value will be equal to itemHeight
  stepSize - number of pixels that items will be moved in one step
  delay - number of miliseconds betwen steps
  itemHeight - height of one item that is moved
  numberOfVisibleElements - nubmer of elements that should be always visible
                            (scrolling will not work if we will try to scroll 
                            if there is only numberOfVisibleElements left on the screen)
\* ------------------------------------------------------------------------- */

function scrollGallery(direction, elementId, heightToMove, stepSize, delay, itemHeight, numberOfVisibleElements) {

    var elementObj = document.getElementById(elementId);
    var elementOffset = parseInt(elementObj.style.top.substr(0, elementObj.style.top.length-2));
    var numberOfElements = 0;
    
    
    //counting number of elements to scroll
    elementsArray = elementObj.childNodes;
    for (var i = 0; i < elementsArray.length; i++){
      if ( elementsArray[i].nodeType==1){
        numberOfElements++;
      }
    }//END: for (var i = 0; i < elementsArray.length; i++){
    
    
    
    switch(direction){
      case 'up':
        heightToMove -= stepSize;
        elementOffset -= stepSize;

        if(numberOfElements*itemHeight + elementOffset >= numberOfVisibleElements * itemHeight){
            if(heightToMove==0)
            {
                elementOffset--;
            }
          elementObj.style.top = elementOffset + "px";

          if(heightToMove != 0){
            setTimeout("scrollGallery('" + direction + "', '" + elementId + "', " + heightToMove + ", " + stepSize + ", " + delay + ", " + itemHeight + ", " + numberOfVisibleElements + ")", delay);
          }
        }
        break;
      case 'down':
        heightToMove -= stepSize;
        elementOffset += stepSize;
        if(elementOffset <= 0){
            if(heightToMove==0)
            {
                elementOffset++;
            }
          elementObj.style.top = elementOffset + "px";

          if(heightToMove != 0){
            setTimeout("scrollGallery('" + direction + "', '" + elementId + "', " + heightToMove + ", " + stepSize + ", " + delay + ", " + itemHeight + ", " + numberOfVisibleElements + ")", delay);
          }
        }
        break;
    }//END: switch(direction){
    
    
    
}//END: function scrollGallery(direction, elementId) {
  
  
  
function addslashes(str) {
  str=str.replace(/\'/g,'\\\'');
  str=str.replace(/\"/g,'\\"');
  str=str.replace(/\\/g,'\\\\');
  str=str.replace(/\0/g,'\\0');
  return str;
}

function stripslashes(str) {
  str=str.replace(/\\'/g,'\'');
  str=str.replace(/\\"/g,'"');
  str=str.replace(/\\\\/g,'\\');
  str=str.replace(/\\0/g,'\0');
  return str;
}





/* ------------------------------------------------------------------------- *\
   Returns name that is displayed on page for page or folder.
   
   node - node of page or dir from index.xml for which name will be returned
   objXMLcarsList - object created from loading carsList.xml
                    is required only if node is node of car folder
\* ------------------------------------------------------------------------- */
function mako_getDisplayedName(node, objXMLcarsList){
    
    if(node.selectNodes("displayedName")[0] != undefined) {
        //there is displayedName node
        return node.selectNodes("displayedName")[0].text;
    }else{
        
        if(node.parentNode.nodeName=='dirs' && node.parentNode.parentNode.nodeName=='cars'){
            //node is node of car folder, for example: 'root/site/dirs/cars/dirs/clio'
            //so displayedName is taken from 'title' node of car from carsList.xml
            return objXMLcarsList.selectNodes("cars/car[@id='" + node.getAttribute("id") + "']/title")[0].text;
        }else{
            //it is not car folder and it doesn't have <displayedName> tag
            //so name have to be taken from 
            if(node.getAttribute("XPathToMainPage")!=null){
                return node.selectNodes(node.getAttribute("XPathToMainPage") + '/displayedName')[0].text;
            }
        }
    }
}//END: function mako_getDisplayedName(node){




/* ------------------------------------------------------------------------- *\
  
  searchedNodeName - name of searched node
  baseNode - base node to search in (node obj where we will search
             for first occurence of node with name searchedNodeName
\* ------------------------------------------------------------------------- */
function mako_findFirstNodeWithName(searchedNodeName, baseNode){
  
  var nodesArray = baseNode.childNodes;
  for(var i = 0; i<nodesArray.length; i++){
    if(nodesArray[i].nodeName == searchedNodeName){
      return nodesArray[i];
    }
  }//END: for(var i = 0; i<nodesArray.length; i++){
  
  
  //if execution goes here (after for loop) it means node was not found
  //search inside of first child, then second....
  for(var i = 0; i<nodesArray.length; i++){
    return mako_findFirstNodeWithName(searchedNodeName, nodesArray[i]);
  }//END: for(var i = 0; i<nodesArray.length; i++){
  
}//END: mako_findFirstNodeWithName(searchedNodeName, baseNode){
/* ------------------------------------------------------------------------- *\
	###########################################################################
\* ------------------------------------------------------------------------- */




/* ------------------------------------------------------------------------- *\
  Returns path to root folder basing on siteId or elemId.
  
  NOTE: Returned path is like: '../../'
  
  siteId - id of site/template in format: 'root|site|dirs|cars|dirs|clio|pages|clio_prices'
\* ------------------------------------------------------------------------- */
function mako_getPathToRoot(siteId){
  
  var siteIdArray = siteId.split('|');
  
  var path = '';
  for(var i = siteIdArray.length-1; i >= 0; i--){
    if(siteIdArray[i] == 'dirs'){
      path += '../';
    }
  }//END: for(var i = siteIdArray.length; i >= 0; i--){
  
  return path;
}//END: mako_getPathToRoot(siteId){
/* ------------------------------------------------------------------------- *\
	###########################################################################
\* ------------------------------------------------------------------------- */




/* ------------------------------------------------------------------------- *\
  Returns XPath to node
  for example 'root/site/dirs/cars/dirs/clio/pages/clio_gallery'
\* ------------------------------------------------------------------------- */
function mako_getPathToNode(node){
    
    var path = node.nodeName;
    while(node.parentNode.nodeName != '#document'){
        path = node.parentNode.nodeName + '/' + path;
        node = node.parentNode;
    }
    
    return path;
    
}//END: function mako_deletePage(pageNode){
/* ------------------------------------------------------------------------- *\
	###########################################################################
\* ------------------------------------------------------------------------- */




/* ------------------------------------------------------------------------- *\
  Returns path to folder with images for page,
  elemId is element of page.
  
  NOTE: Returned path is absolute path to application root folder and 
        is like: 'images/cars/clio/clio_prices'
  
  elemId - id of element on which we will base to build path, in format: 'root|site|dirs|cars|dirs|clio|pages|clio_prices|text1'
\* ------------------------------------------------------------------------- */
function mako_getPathToProposedImageFolder(elemId){
  
  var elemIdArray = elemId.split('|');
  
  var path = 'images';
  for(var i = 0; i<elemIdArray.length; i++){
    if(elemIdArray[i] == 'dirs'){
      path += '/' + elemIdArray[i+1];
    }else if(elemIdArray[i] == 'pages'){
      //we know that there will be no more 'dirs' nodes -> dir can not be in page
      //so there can be only more pages in this page -> find the last one
      var lastPageNodeIndex = i;
      for(var j = i+1; j<elemIdArray.length; j++){
        if(elemIdArray[j] == 'pages'){
          lastPageNodeIndex = j;
        }
      }
      path += '/' + elemIdArray[lastPageNodeIndex+1];
      break;
    }
  }//END: for(var i = 0; i<elemIdArray.length; i++){
  
  return path;
}//END: mako_getPathToProposedImageFolder(siteId){
/* ------------------------------------------------------------------------- *\
	###########################################################################
\* ------------------------------------------------------------------------- */




/* ------------------------------------------------------------------------- *\
  Returns siteId basing on elemId (cuts off everything until find 'pages' node)
  
  NOTE: Returns for example: 'root|site|dirs|cars|dirs|clio|pages|clio_prices'
  
  elemId - id of edited element in format: 'root|site|dirs|cars|dirs|clio|pages|clio_prices|img1'
\* ------------------------------------------------------------------------- */
function mako_getSiteId(elemId){
  
  var elemIdArray = elemId.split('|');
  
  var siteId = '';
  for(var i = elemIdArray.length-1; i >= 0; i--){
    if(elemIdArray[i] == 'pages'){
      i++;
      break;
    }
  }//END: for(var i = elemIdArray.length-1; i >= 0; i--){
  
  //after for loop i contains index of page node (not 'pages' node!!!)
  var pageNodeIndex = i;
  for(var i = 0; i<=pageNodeIndex; i++){
    siteId += elemIdArray[i]
    if(i != pageNodeIndex){
        //add separator if not last node is processed
        siteId += '|';
    }
  }
  
  return siteId;
  
}//END: mako_getSiteId(elemId){
/* ------------------------------------------------------------------------- *\
	###########################################################################
\* ------------------------------------------------------------------------- */





/* ------------------------------------------------------------------------- *\
   Returns path to <flashHeader> node that defines data for page passed as node argument
   
   WARRING: Returns only beggining of XPath, to get full path you have to add: '/flashHeader'
            to returned string
   
   XPathToPage - XPath to node of page from index.xml for which path to <flashHeader> node will be returned
                 //example: 'root/site/dirs/services/pages/accessories'
\* ------------------------------------------------------------------------- */
function mako_getXPathToFlashHeaderNode(XPathToPage){
    
    var XPathWithoutTemplatesDir = XPathToPage;
    /*
    var XPathWithoutTemplatesDir = '';
    if(XPathToPage.indexOf('/templates/') != -1){
        //page is in templates folder
        XPathWithoutTemplatesDir = XPathToPage.replace(new RegExp('/dirs/templates/', 'gi'), '');
    }else{
        XPathWithoutTemplatesDir = XPathToPage;
    }
    */
    
    if(XPathWithoutTemplatesDir.indexOf('/dirs/') != -1){
      //this page is in some dir -> its <flashHeader> node is take from first dirs node
      var XPathToPageArray = XPathToPage.split('/');
      var i = 0;
      var XPathToSectionFolderNode = '';
      while(XPathToPageArray[i] != 'dirs'){
        XPathToSectionFolderNode += XPathToPageArray[i] + '/';
        i++;
      }
      XPathToSectionFolderNode += XPathToPageArray[i] + '/'; //<dirs> node
      XPathToSectionFolderNode += XPathToPageArray[i+1]; //folder node
      
      return XPathToSectionFolderNode;
      
    }else{
      //this page is in application root folder -> its <flashHeader> node is one of childrens
      return XPathToPage;
    }
    
}//END: function mako_getXPathToFlashHeaderNode(XPathToPage){


function mako_getPathToFileOrDir(fileNode, fileOrDir){
    
    var tempPathToFile = '';
    
    
    if(fileOrDir == 'file'){
        tempPathToFile = fileNode.nodeName + '.asp';
    }//END: if(fileOrDir == 'file'){
    
    
    var tempParentNode = fileNode.parentNode;
    var tempThisNode = fileNode; //will hold refference to children node from which we went up
    while(tempParentNode.nodeName != 'site'){
        while((tempParentNode.nodeName != 'dirs') && (tempParentNode.nodeName != '#document')){
            tempThisNode = tempParentNode;
            tempParentNode = tempParentNode.parentNode;
        }
        if(tempParentNode.nodeName == '#document'){
            //will enter here only if there was no <dirs> tag in parent nodes
            if(fileOrDir == 'file'){
                return tempPathToFile; //return only file name
            }else{
                //there was no <dirs> tag, so return empty path
                return '';
            }
        }
        //tempParentNode holds first 'dirs' node (searching up)
        //tempThisNode holds refference to children node from which we went up
        tempPathToFile = tempThisNode.nodeName + "\\" + tempPathToFile;
        
        tempThisNode = tempParentNode;
        tempParentNode = tempParentNode.parentNode;
    }
    
    
    if(fileOrDir == 'dir'){
        //cut off last back slash
        tempPathToFile = tempPathToFile.substr(0, tempPathToFile.length-1);
    }
    
    
    return tempPathToFile;
    
}


//return index.xml object
function GetIndexXmlObject(pathToXml) {
	xmlDoc = new ActiveXObject("Msxml2.DOMDocument.3.0"); 
	xmlDoc.async="false";
	xmlDoc.load(pathToXml);
	return xmlDoc;
}





/* ------------------------------------------------------------------------- *\
   Returns node object created from XMLstring
   
   XMLstring - for ex.: '<someName><subNode></subNode></someName>'
               will return <someName> node
\* ------------------------------------------------------------------------- */
function createNodeFromString(XMLstring){
	var tempObjXML = new ActiveXObject("Microsoft.XMLDOM");
  tempObjXML.async = false;
  
  tempObjXML.loadXML(XMLstring);
  var newNode = tempObjXML.documentElement;
  tempObjXML = null;
  
  return newNode;
}//END: function createNodeFromString(XMLstring){





/* ------------------------------------------------------------------------- *\
   Returns Json object if responseText is OK,
   false if some error occures.
\* ------------------------------------------------------------------------- */
function mako_getJsonObject(responseText, nameOfFileWhereRequestWasSend){
	try{
		var oJson = eval("(" + responseText + ")");
		return oJson;
	}catch(e){
		Ext.Msg.alert('', 'unknown Error occured in \'' + nameOfFileWhereRequestWasSend + '\'<br />\nresponseText:<br />\n' + responseText);
		return false;
	}
}





/* ------------------------------------------------------------------------- *\
   Runs recursive,
   Returns true if 'node' is published
\* ------------------------------------------------------------------------- */
function mako_isNodePublished(node){
	while(node.nodeName != '#document'){
		if((node.getAttributeNode('published') != null) && (node.getAttribute('published') == 'false')){
			//not published
			return false;
 	    }
		node = node.parentNode;
	}
	return true;
}