//tipusok:
//size {width: height:}
//pos {top: left:}
//dim {top: left: bottom: right:}  //es nem top left width height

//fuggosegek: 
if (typeof BROWSERDETECT == "undefined") {
  alert("(USEFUL) BROWSERDETECT include missing");
}
//tobbszoros include:
if (typeof USEFUL != "undefined") {
//  alert("USEFUL multiple insert!");
}
USEFUL=true;

////////////clip fuggvenyek
var cssCompat=false;
if (document.compatMode == 'CSS1Compat') {
  cssCompat=true;
}
//alert(cssCompat);
//clip torlese

/** Clipping torlese
  *
  * @param object layer a node
  */
function resetClip(layer) {
  clip = {top: 0, left: 0, right: 0, bottom: 0};
  clip.right = getWidth(layer);
  clip.bottom = getHeight(layer);
  clipTo(layer,clip);
} // resetClip

//aktualis clip
/** Visszaadja az aktualis clip merteket
  *
  * @param object layer a node
  * @return object a clip dim
  */
function getClip(layer) {
  clip = {top: 0, left: 0, right: 0, bottom: 0};
  //  alert(this.layerNode.style.clip);
  clipv = layer.style.clip.split("rect(")[1].split(")")[0].split("px");
  if (nsDOM) {
    clipv[1] = clipv[1].substring(1,clipv[1].length);
    clipv[2] = clipv[2].substring(1,clipv[2].length);
    clipv[3] = clipv[3].substring(1,clipv[3].length);
  }
  clip.top = parseInt(clipv[0]);
  clip.right = parseInt(clipv[1]);
  clip.bottom = parseInt(clipv[2]);
  clip.left = parseInt(clipv[3]);
  return clip;
} // getClip

//clip
/** A megadott meretre allitja be a clippinget
  *
  * @param object layer a node
  * @param object clip a clip dim
  */
function clipTo(layer,clip) {
  layer.style.clip = "rect("+clip.top+"px "+clip.right+"px "+clip.bottom+"px "+clip.left+"px)";
} // clipTo

//clip
/** A megadott merettel noveli a jelenlegi clippinget
  *
  * @param object layer a node
  * @param object clip a clip dim
  */
function clipBy(layer,clip) {
  oldClip = getClip(layer);
  layer.style.clip = "rect("+(oldClip.top+clip.top)+"px "
    +(oldClip.right+clip.right)+"px "
    +(oldClip.bottom+clip.bottom)+"px "
    +(oldClip.left+clip.left)+"px)";
} // clipBy

///////////////////////////////////////////meret fuggvenyek
// M B P [content] P B M
/** Visszaadja, hogy a node content milyen szeles
  *
  * @param object node a node
  * @return int a szelesseg pixelben
  */
function getContentWidth(node) {
//  var value="";
  //Opera miatt, getStyle width-re is padding as border ertekkel novelt erteket ad vissza :(
  return getContentPaddingWidth(node)-getStyle(node,"padding-left",true)-getStyle(node,"padding-right",true);
//  value=getStyle(node,"width",true);
//mindnel padding es border is benne van az offset-ben
//  value=node.offsetWidth;
//  return value;
} // getContentWidth

/** Visszaadja, hogy a node content milyen magas
  *
  * @param object node a node
  * @return int a magassag pixelben
  */
function getContentHeight(node) {
//  var value="";
  
  return getContentPaddingHeight(node)-getStyle(node,"padding-top",true)-getStyle(node,"padding-bottom",true);
//  if (nsDOM) {
//    value=getStyle(node,"height",true);
//  } else {
//    value=node.offsetHeight;
//  }
//  return value;
} // getContentHeight


// M B [P content P] B M
/** Visszaadja, hogy a node content+padding milyen szeles
  *
  * @param object node a node
  * @return int a szelesseg pixelben
  */
function getContentPaddingWidth(node) {
  return getContentBorderWidth(node)-getStyle(node,"border-left-width",true)-getStyle(node,"border-right-width",true);
//  return getContentWidth(node)+getStyle(node,"padding-left",true)+getStyle(node,"padding-right",true);
} // getContentPaddingWidth

/** Visszaadja, hogy a node content+padding milyen magas
  *
  * @param object node a node
  * @return int a magassag pixelben
  */
function getContentPaddingHeight(node) {
  return getContentBorderHeight(node)-getStyle(node,"border-top-width",true)-getStyle(node,"border-bottom-width",true);
//  return getContentHeight(node)+getStyle(node,"padding-top",true)+getStyle(node,"padding-bottom",true);
} // getContentPaddingHeight

// M [B P content P B] M
/** Visszaadja, hogy a node content+padding+border milyen szeles
  *
  * @param object node a node
  * @return int a szelesseg pixelben
  */
function getContentBorderWidth(node) {  
//  return getContentPaddingWidth(node)+getStyle(node,"border-left-width",true)+getStyle(node,"border-right-width",true);
/*  
  if (operaDOM) {
    //nem mindig jo az offsetWidth: absolute eseten jo
    var width=0;
    var position=node.style.position;
    node.style.position="absolute";
    width=node.offsetWidth;
    node.style.position=position;
    return width;
//    return getStyle(node,"width",true);
  } else {
*/  
    return node.offsetWidth;
/*    
  }
  */
} // getContentBorderWidth


/** Visszaadja, hogy a node content+padding+border milyen magas
  *
  * @param object node a node
  * @return int a magassag pixelben
  */
function getContentBorderHeight(node) {
//  return getContentPaddingHeight(node)+getStyle(node,"border-top-width",true)+getStyle(node,"border-bottom-width",true);
  /*
  if (operaDOM) {
    //nem mindig jo az offsetHeight: absolute eseten jo
    var height=0;
    var position=node.style.position;
    node.style.position="absolute";
    height=node.offsetHeight;
    node.style.position=position;
    return height;
//    return getStyle(node,"height",true);
  } else {
  */
    return node.offsetHeight;  
/*    
  }
  */
} // getContentBorderHeight

// [M B P content P B M]
/** Visszaadja, hogy a node content+padding+border+margin milyen szeles
  *
  * @param object node a node
  * @return int a szelesseg pixelben
  */
function getContentMarginWidth(node) {
  return getContentBorderWidth(node)+getStyle(node,"margin-left",true)+getStyle(node,"margin-right",true);
} // getContentMarginWidth

/** Visszaadja, hogy a node content+padding+border+margin milyen magas
  *
  * @param object node a node
  * @return int a magassag pixelben
  */
function getContentMarginHeight(node) {
  return getContentBorderHeight(node)+getStyle(node,"margin-top",true)+getStyle(node,"margin-bottom",true);
} // getContentMarginHeight


/** Visszaadja, hogy a node content milyen szeles, regi cuccokkal valo kompatibilitas miatt
  *
  * @param object node a node
  * @return int a szelesseg pixelben
  */
function getWidth(node) {
  //6278D008
  return getContentWidth(node);
} // getWidth


/** Visszaadja, hogy a node content milyen magas, regi cuccokkal valo kompatibilitas miatt
  *
  * @param object node a node
  * @return int a magassag pixelben
  */
function getHeight(node) {
  return getContentHeight(node);
} // getHeight

//marginos meret

/** Visszaadja, hogy a node content+padding+border+margin mekkora
  *
  * @param object node a node
  * @return object a meret size
  */
function getSizeMargin(node) {
  return {width: getContentMarginWidth(node), height: getContentMarginHeight(node)};
} // getSizeMargin

//borderes meret
/** Visszaadja, hogy a node content+padding+border mekkora
  *
  * @param object node a node
  * @return object a meret size
  */
function getSizeBorder(node) {
  return {width: getContentBorderWidth(node), height: getContentBorderHeight(node)};
} // getSizeBorder

//paddingos meret
/** Visszaadja, hogy a node content+padding mekkora
  *
  * @param object node a node
  * @return object a meret size
  */
function getSizePadding(node) {
  return {width: getContentPaddingWidth(node), height: getContentPaddingHeight(node)};
} // getSizePadding

//contentes meret
/** Visszaadja, hogy a node content mekkora
  *
  * @param object node a node
  * @return object a meret size
  */
function getSizeContent(node) {
  return {width: getContentWidth(node), height: getContentHeight(node)};
} // getSizeContent



//ez magadja a negy sarok koordinatait
//border szerinti merettel es pozicioval dolgozik
/** Visszaadja, hogy a node hol van és mekkora (content+padding+border)
  *
  * @param object node a node
  * @return object a meret-pozicio dim
  */
function getDim(node) {
  var dim={top: 0, left: 0, right: 0, bottom: 0};
  var pos=getPosBorder(node);
  dim.top=pos.top;
  dim.left=pos.left;
  dim.right=dim.left+getContentBorderWidth(node);
  dim.bottom=dim.top+getContentBorderHeight(node);
  return dim;
} // getDim

//ez eleg furcsa, mert pos a box-ra vonatkozik, size meg content-re
//dimenzio beallitas
/** Beallitja, hogy a node hol es mekkora legyen
  *
  * @param object node a node
  * @param object dim a meret-pozicio dim
  */
function setDim(node,dim) {
  node.style.top=dim.top+"px";
  node.style.left=dim.left+"px";
  node.style.width=dim.right - dim.left+"px";
  node.style.height=dim.bottom - dim.top+"px";
} // setDim

//size a margin meretet adja meg
/** Beallitja a node content+padding+border+margin meretet
  *
  * @param object node a node
  * @param object size a meret size
  */
function setSizeMargin(node,size) {
  size.width-=getStyle(node,"margin-left",true)+getStyle(node,"margin-right",true);
  size.height-=getStyle(node,"margin-top",true)+getStyle(node,"margin-bottom",true);
  setSizeBorder(node,size);
} // setSizeMargin

//size a border meretet adja meg
/** Beallitja a node content+padding+border meretet
  *
  * @param object node a node
  * @param object size a meret size
  */
function setSizeBorder(node,size) {
  size.width-=getStyle(node,"border-left-width",true)+getStyle(node,"border-right-width",true);
  size.height-=getStyle(node,"border-top-width",true)+getStyle(node,"border-bottom-width",true);
  setSizePadding(node,size);
} // setSizeBorder

//size a padding meretet adja meg
/** Beallitja a node content+padding meretet
  *
  * @param object node a node
  * @param object size a meret size
  */
function setSizePadding(node,size) {
  size.width-=getStyle(node,"padding-left",true)+getStyle(node,"padding-right",true);
  size.height-=getStyle(node,"padding-top",true)+getStyle(node,"padding-bottom",true);
  setSizeContent(node,size);
} // setSizePadding

//size a content meretet adja meg
/** Beallitja a node content meretet
  *
  * @param object node a node
  * @param object size a meret size
  */
function setSizeContent(node,size) {
  setSize(node,size);
} // setSizeContent

//meret beallitas content-re
//ez a content meretet allitja be
/** Beallitja a node content meretet, regi rovid nev
  *
  * @param object node a node
  * @param object size a meret size
  */
function setSize(node,size) {
  setWidth(node,size.width);
  setHeight(node,size.height);
} // setSize

//width a margin meretet adja meg
/** Beallitja a node content+padding+border+margin szelesseget
  *
  * @param object node a node
  * @param int width a szelesseg pixelben
  */
function setWidthMargin(node,width) {
  width-=getStyle(node,"margin-left",true)+getStyle(node,"margin-right",true);
  setWidthBorder(node,width);
} // setWidthMargin

//width a border meretet adja meg
/** Beallitja a node content+padding+border szelesseget
  *
  * @param object node a node
  * @param int width a szelesseg pixelben
  */
function setWidthBorder(node,width) {
  width-=getStyle(node,"border-left-width",true)+getStyle(node,"border-right-width",true);
  setWidthPadding(node,width);
} // setWidthBorder

//width a padding meretet adja meg
/** Beallitja a node content+padding szelesseget
  *
  * @param object node a node
  * @param int width a szelesseg pixelben
  */
function setWidthPadding(node,width) {
  width-=getStyle(node,"padding-left",true)+getStyle(node,"padding-right",true);
  setWidthContent(node,width);
} // setWidthPadding

//size a content meretet adja meg
/** Beallitja a node content szelesseget
  *
  * @param object node a node
  * @param int width a szelesseg pixelben
  */
function setWidthContent(node,width) {
  setWidth(node,width);
} // setWidthContent

//content meret box model szerint
/** Beallitja a node content szelesseget, regi rovid nev
  *
  * @param object node a node
  * @param int width a szelesseg pixelben
  */
function setWidth(node,width) {
  //ha textarea es cssCompat false es nsDOM, akkor nem jol csinalja (border+padding is benne van), DIV-re viszont jo!!!????
  //talan display beallitastol fugg????
  if (cssCompat || nsDOM) {    
    //textarea-ra ns nem megy cssCompat false-al csinalja
    node.style.width=width+"px";
  } else {
    //ilyenkor content, padding es border is beleszamit a meretbe!!!
    node.style.width=width+getStyle(node,'padding-left',true)+getStyle(node,'padding-right',true)
      +getStyle(node,'border-left-width',true)+getStyle(node,'border-right-width',true)+"px";
  }
} // setWidth


//height a margin meretet adja meg
/** Beallitja a node content+padding+border+margin magassagat
  *
  * @param object node a node
  * @param int width a magassag pixelben
  */
function setHeightMargin(node,height) {
  height-=getStyle(node,"margin-top",true)+getStyle(node,"margin-bottom",true);
  setHeightBorder(node,height);
} // setHeightMargin

//height a border meretet adja meg
/** Beallitja a node content+padding+border magassagat
  *
  * @param object node a node
  * @param int width a magassag pixelben
  */
function setHeightBorder(node,height) {
  height-=getStyle(node,"border-top-width",true)+getStyle(node,"border-bottom-width",true);
  setHeightPadding(node,height);
} // setHeightBorder

//height a padding meretet adja meg
/** Beallitja a node content+padding magassagat
  *
  * @param object node a node
  * @param int width a magassag pixelben
  */
function setHeightPadding(node,height) {
  height-=getStyle(node,"padding-top",true)+getStyle(node,"padding-bottom",true);
  setHeightContent(node,height);
} // setHeightPadding

//height a content meretet adja meg
/** Beallitja a node content magassagat
  *
  * @param object node a node
  * @param int width a magassag pixelben
  */
function setHeightContent(node,height) {
  setHeight(node,height);
} // setHeightContent


//content meret box model szerint
/** Beallitja a node content magassagat, regi rovid nev
  *
  * @param object node a node
  * @param int width a magassag pixelben
  */
function setHeight(node,height) {
  if (cssCompat || nsDOM) {    
    node.style.height=height+"px";
  } else {
    //ilyenkor content, padding es border is beleszamit a meretbe!!!
    node.style.height=height+getStyle(node,'padding-top',true)+getStyle(node,'padding-bottom',true)
      +getStyle(node,'border-top-width',true)+getStyle(node,'border-bottom-width',true)+"px";
  }
} // setHeight


//body teljes merete, ablakmerettol fuggetlenul
//ha body nagyobb, mint az ablak, akkor body merete
//ha kisebb, akkor 
//ns: ablak merete
//opera: body merete
//ie: body merete
/** Visszaadja a body teljes meretet
  *
  * @return object a body size
  */
function getBodySize() {
  var size={width: 0, height: 0};
  /*
  if (nsDOM) {   
    size.width=document.body.offsetWidth;
    size.height=document.body.offsetHeight;
  } else {
    size.width=document.body.scrollWidth;
    size.height=document.body.scrollHeight;
  }
  */
  
//ppk szerint: http://www.quirksmode.org/viewport/compatibility.html   
  if (document.documentElement && document.documentElement.scrollWidth) {
    //strict
    size.width=document.documentElement.scrollWidth;
    size.height=document.documentElement.scrollHeight;
  } 
  if (size.width < document.body.scrollWidth) {
    size.width=document.body.scrollWidth;
  }
  if (size.width < document.body.offsetWidth) {
    size.width=document.body.offsetWidth;
  }
  if (size.height < document.body.scrollHeight) {
    size.height=document.body.scrollHeight;
  }
  if (size.height < document.body.offsetHeight) {
    size.height=document.body.offsetHeight;
  }
      
  return size;
} // getBodySize

//scrollbarok nelkul
//ablak belso merete
/** Bongeszoablak belso meretenek lekerdezese
  *
  * @param object win a bongeszoablak
  * @return object a meret size
  */
function getViewportSize(win) {
  var size={width: 0, height: 0};
  if (win == null) {
    win=window;
  }
  
  if (win.innerHeight) {
    //all except IE
    size.width=win.innerWidth;
    size.height=win.innerHeight;
  } else if (win.document.documentElement && win.document.documentElement.clientHeight) {
    // Explorer 6 Strict Mode 
    size.width=win.document.documentElement.clientWidth;
    size.height=win.document.documentElement.clientHeight;
  } else if (win.document.body) { // other Explorers
    size.width=win.document.body.clientWidth;
    size.height=win.document.body.clientHeight;
  }
  
//  size.width=win.document.body.clientWidth;
//  size.height=win.document.body.clientHeight;
  
  return size;
} // getViewportSize

//adott ablak belso dimnenzioi
//tehat az akutalis scrollal modositva
/** Bongeszoablak belso merete+scroll lekerdezese
  *
  * @return object a meret-scroll dim
  */
function getViewportDim() {
  var winSize=getViewportSize();
  var winScroll=getScrollPos();

  return {top: winScroll.top, left: winScroll.left, bottom: winScroll.top+winSize.height, right: winScroll.left+winSize.width};
} // getViewportDim

//meret lekerdezes
/** Meret lekerdezes, body eseten getBodySize-ot hivja
  *
  * @param object node a node
  * @return object a meret size
  */
function getSize(node) {
  var size={width: 0, height: 0};
  if (node == document.body) {
    size=getBodySize();
  } else {
    //contentWidth alapjan
    size.width=getContentWidth(node);
    size.height=getContentHeight(node);
  }    
  return size;
} // getSize



//ez megadja a bal felso sarok helyet
/** Lekerdezi a node bal felso sarkanak poziciojat
  *
  * @param object node a node
  * @return object a pozicio pos
  */
function getPos_old(node){
  var pos={top: 0, left:0};
  var node=node;
  while(node != null) {
    pos.left+=node.offsetLeft;
    pos.top+=node.offsetTop;
    node=node.offsetParent;
  }
  return pos;
} // getPos_old

/** Lekerdezi a node bal felso sarkanak poziciojat content
  *
  * @param object node a node
  * @return object a pozicio pos
  */
function getPosContent(node) {
  var pos=getPosPadding(node);
  pos.top+=getStyle(node,"padding-top",true);
  pos.left+=getStyle(node,"padding-left",true);
  return pos;
} // getPosContent

/** Lekerdezi a node bal felso sarkanak poziciojat content+padding
  *
  * @param object node a node
  * @return object a pozicio pos
  */
function getPosPadding(node) {
  var pos=getPosBorder(node);
  pos.top+=getStyle(node,"border-top-width",true);
  pos.left+=getStyle(node,"border-left-width",true);
  return pos;
} // getPosPadding


/** Lekerdezi a node bal felso sarkanak poziciojat content+padding+border
  *
  * @param object oriNode a node
  * @return object a pozicio pos
  */
function getPosBorder(oriNode) {
  var pos={top: 0, left:0};
  var node=oriNode;
  var absolute=false;
  var i=0;
  var borderTopWidthSum=0;
  var borderLeftWidthSum=0;

  if (node) {
    while(node != null) {
      ++i;
      if (i != 1) {
        //nem az eredeti node-nal vagyunk mar
        borderTopWidthSum+=getStyle(node,"border-top-width",true);
        borderLeftWidthSum+=getStyle(node,"border-left-width",true);
      }
      pos.top+=node.offsetTop;
      pos.left+=node.offsetLeft;
    
//      alert(node.tagName+" "+node.offsetTop+" "+node.offsetLeft);

      //ha div-ben van absolute, akkor a div pozicioja lesz neki az origo, tehat nem kene absolute-nal megallni
      if (getStyle(node,"position") == "abslute") {
        //itt lehetne offset ertekek helyett top es left getStyle is, de akkor meg a margint is hozza kellene adni
        //szoval ez igy gyorsabb es jobb szerintem
        absolute=true;
        node=null;
      } else {
        node=node.offsetParent;
      }
    }
    if (ieDOM || absolute) {
//      pos.left=pos.left-getStyle(oriNode,"margin-left",true)+borderLeftWidthSum;      
//      pos.top=pos.top-getStyle(oriNode,"margin-top",true)+borderTopWidthSum;
      pos.left=pos.left+borderLeftWidthSum;      
      pos.top=pos.top+borderTopWidthSum;
      //IE a max(parent.padding-top,node.margin-top) tavolsagot renderel fuggolegesen (vizszintesnel osszeadodnak)      
      //ezzel nem torodunk, ugy vesszuk, hogy megkapta a node.margin-top tavolsagot
    } else if (nsDOM) {
      //negativ, ha van border, egyszer lejott ezert ketszer hozza kell adni
//      pos.left=pos.left-2*document.body.offsetLeft-getStyle(oriNode,"margin-left",true);
//      pos.top=pos.top-2*document.body.offsetTop-getStyle(oriNode,"margin-top",true);                
      pos.left=pos.left-2*document.body.offsetLeft;
      pos.top=pos.top-2*document.body.offsetTop;                
    } else if (operaDOM) {        
//      alert(pos.top+" "+pos.left);
//      pos.left=pos.left+getStyle(document.body,"border-left-width",true)-getStyle(oriNode,"margin-left",true);
//      pos.top=pos.top+getStyle(document.body,"border-top-width",true)-getStyle(oriNode,"margin-top",true);
      pos.left=pos.left+getStyle(document.body,"border-left-width",true);
      pos.top=pos.top+getStyle(document.body,"border-top-width",true);
      if (oriNode.tagName == "TEXTAREA" && getStyle(oriNode,"position") != "absolute") {
//        alert(getStyle(oriNode,"position"));
        pos.left+=3;
        pos.top+=3;
        //2 table-ben levo textarea-ra meg mindig nem franko teljesen
      }
    }
  }
  return pos;
} // getPosBorder

/** Lekerdezi a node bal felso sarkanak poziciojat content+padding+border+margin
  *
  * @param object node a node
  * @return object a pozicio pos
  */
function getPosMargin(node) {
  var pos=getPosBorder(node);
  pos.top-=getStyle(node,"margin-top",true);
  pos.left-=getStyle(node,"margin-left",true);
  return pos;
} // getPosMargin

//ez margin poziciojat adja meg, box model szerint
/** Lekerdezi a node bal felso sarkanak poziciojat content+padding+border+margin, regi rovid nev
  *
  * @param object node a node
  * @return object a pozicio pos
  */
function getPos(node){
  return getPosMargin(node);
} // getPos


/*
function getPos2(obj) {
  var pos={top:0 , left:0};
  if (obj.offsetParent) {
    while (obj.offsetParent) {
      pos.left += obj.offsetLeft;
      pos.top += obj.offsetTop;
      obj = obj.offsetParent;
    }
  } else if (obj.x) {
    pos.left += obj.x;
    pos.top += obj.y;
  }
  return pos;
}
*/
//alert(document.compatMode);

//ez megadja a bal felso sarok helyet
/*
function getPos(oriNode){
  var pos={top: 0, left:0};
  var node=oriNode;
  var absolute=false;
  var i=0;
  var borderTopWidthSum=0;
  var borderLeftWidthSum=0;

  if (node) {
    while(node != null) {
      ++i;
      if (i != 1) {
        //nem az eredeti node-nal vagyunk mar
        borderTopWidthSum+=getStyle(node,"border-top-width",true);
        borderLeftWidthSum+=getStyle(node,"border-left-width",true);
      }
      if (getStyle(node,"position") == "absolute") {
        absolute=true;
//        pos.top+=getStyle(node,"top",true);
//        pos.left+=getStyle(node,"left",true);
        pos.top+=node.offsetTop;
        pos.left+=node.offsetLeft;
        alert(node.id+"-"+node.tagName+" abs "+node.offsetLeft+" "+node.offsetTop);
        node=null;
      } else {
        pos.left+=node.offsetLeft;
        pos.top+=node.offsetTop;
        alert(node.id+"-"+node.tagName+" "+node.offsetLeft+" "+node.offsetTop);

        node=node.offsetParent;
      }
    }
    if (ieDOM) {
      //margin collapsing??? http://www.w3.org/TR/CSS21/box.html#collapsing-margins

      pos.left=pos.left-getStyle(oriNode,"margin-left",true)+borderLeftWidthSum;      
      pos.top=pos.top-getStyle(oriNode,"margin-top",true)+borderTopWidthSum;
      //IE a max(parent.padding-top,node.margin-top) tavolsagot renderel fuggolegesen (vizszintesnel osszeadodnak)      
      //ezzel nem torodunk, ugy vesszuk, hogy megkapta a node.margin-top tavolsagot
    } else if (nsDOM) {
      if (absolute == true) {
//        if (i != 1) {
          pos.left=pos.left-getStyle(oriNode,"margin-left",true)+borderLeftWidthSum;
          pos.top=pos.top-getStyle(oriNode,"margin-top",true)+borderTopWidthSum;
//        }
      } else {
        //negativ, ha van border, egyszer lejott ezert ketszer hozza kell adni
        pos.left=pos.left-2*document.body.offsetLeft-getStyle(oriNode,"margin-left",true);
        pos.top=pos.top-2*document.body.offsetTop-getStyle(oriNode,"margin-top",true);                
      }
    } else if (operaDOM) {        
      //ezzel magkapjuk a pontos meretet
      if (absolute == false) {
        pos.left=pos.left+getStyle(document.body,"border-left-width",true)-getStyle(oriNode,"margin-left",true);
        pos.top=pos.top+getStyle(document.body,"border-top-width",true)-getStyle(oriNode,"margin-top",true);
      } else {
        pos.left=pos.left-getStyle(oriNode,"margin-left",true)+borderLeftWidthSum;
        pos.top=pos.top-getStyle(oriNode,"margin-top",true)+borderTopWidthSum;
      }
    }
  }
  return pos;
}
*/

//content poziciojat adja meg pos
/** Beallitja a node bal felso sarkanak poziciojat content
  *
  * @param object node a node
  * @param object pos a pozicio pos
  * @param boolean check ha true, akkor nem lehet viewporton kivulre mozgatni
  * @param boolean relative ha true, akkor a pozicio a legkozelebbi absolute szulohoz lesz viszonyitva
  * @return boolean volt-e mozgatas
  */
function setPosContent(node,pos,check,relative) {
  pos.top-=getStyle(node,"padding-top",true);
  pos.left-=getStyle(node,"padding-left",true);
  return setPosBorder(node,pos,check,relative);
} // setPosContent

//padding poziciojat adja meg pos
/** Beallitja a node bal felso sarkanak poziciojat content+padding
  *
  * @param object node a node
  * @param object pos a pozicio pos
  * @param boolean check ha true, akkor nem lehet viewporton kivulre mozgatni
  * @param boolean relative ha true, akkor a pozicio a legkozelebbi absolute szulohoz lesz viszonyitva
  * @return boolean volt-e mozgatas
  */
function setPosPadding(node,pos,check,relative) {
  pos.top-=getStyle(node,"border-top-width",true);
  pos.left-=getStyle(node,"border-left-width",true);
  return setPosBorder(node,pos,check,relative);
} // setPosPadding

//border poziciojat adja meg pos
/** Beallitja a node bal felso sarkanak poziciojat content+padding+border
  *
  * @param object node a node
  * @param object pos a pozicio pos
  * @param boolean check ha true, akkor nem lehet viewporton kivulre mozgatni
  * @param boolean relative ha true, akkor a pozicio a legkozelebbi absolute szulohoz lesz viszonyitva
  * @return boolean volt-e mozgatas
  */
function setPosBorder(node,pos,check,relative) {
  pos.top-=getStyle(node,"margin-top",true);
  pos.left-=getStyle(node,"margin-left",true);
  return setPosMargin(node,pos,check,relative);
} // setPosBorder

//box poziciojat adja meg pos
/** Beallitja a node bal felso sarkanak poziciojat content+padding+border+margin
  *
  * @param object node a node
  * @param object pos a pozicio pos
  * @param boolean check ha true, akkor nem lehet viewporton kivulre mozgatni
  * @param boolean relative ha true, akkor a pozicio a legkozelebbi absolute szulohoz lesz viszonyitva
  * @return boolean volt-e mozgatas
  */
function setPosMargin(node,pos,check,relative) {
  return setPos(node,pos,check,relative);
} // setPosMargin

//ez a box-modelt mozgatja
//mozgatas
//ha relative=true, akkor szimplan egyenlove teszi a pozicioval
//ha relative=false, akkor ugy veszi, hogy document 0,0-hoz szamit a pozicio (csak absolute eseten van ertelme)
/** Beallitja a node bal felso sarkanak poziciojat content+padding+border+margin, regi rovid nev
  *
  * @param object node a node
  * @param object pos a pozicio pos
  * @param boolean check ha true, akkor nem lehet viewporton kivulre mozgatni
  * @param boolean relative ha true, akkor a pozicio a legkozelebbi absolute szulohoz lesz viszonyitva
  * @return boolean volt-e mozgatas
  */
function setPos(node,pos,check,relative) {
  check=(check == null ) ? false : check; 
  relative=(relative == null ) ? false : relative;  //nem body-hoz adom meg a pos-t, hanem absolute parent-hez
                                                    //position:relative eseten is hasznos
  var moved=true;
  if (check) {
    var dim = {top: pos.top, left: pos.left, bottom: pos.top+getHeight(node), right: pos.left+getWidth(node)};    
    if (viewportContainsDim(dim)) { //ha az uj pozicio teljesen benne van a viewportban
      node.style.left=pos.left+"px";
      node.style.top=pos.top+"px";
    } else {
      moved=false;
    }
  } else {
    if (relative == false && getStyle(node,"position") == "absolute") {
      var parent=node.offsetParent;
      //elso absolute szulo poziciojat le kell vonni, mert absolute szulo bal felso sarka lesz az origo
      while(parent) {
        if (getStyle(parent,"position") == "absolute") {
          var parentPos=getPos(parent); 
          pos.left-=parentPos.left;
          pos.top-=parentPos.top;
          parent=null;
        } else {
          parent=parent.offsetParent;
        }
      }
    }
    node.style.left=pos.left+"px";
    node.style.top=pos.top+"px";
  }
  return moved;
} // setPos
/*
function moveTo(node,p,check) {
  return setPos(node,p,check);
}
//mozgatas
function moveBy(node,p) {
  var topleft = getPos(node);
  p.left += topleft.left;
  p.top += topleft.top;
  moveTo(node,p);
}
*/

//az ablakot body mereture allitja
/** Beallitja az ablak meretet, hogy pont akkora legyen, amennyit a body megkivan
  *
  * @param object win a bongeszoablak
  */
function setWindowSizeToContent(win) {
  if (win == null) {
    win = window;
  }
  if (win.sizeToContent) {
    //    win.resizeTo(win.document.body.scrollWidth,win.document.body.scrollHeight+10);
    win.resizeTo(win.document.body.scrollWidth+3,win.document.body.scrollHeight+10);
    win.sizeToContent();
    //    win.sizeToContent();
  } else {
    //    win.resizeTo(20,50);
    win.resizeTo(win.document.body.scrollWidth,win.document.body.scrollHeight+50);
    win.resizeTo(win.document.body.scrollWidth,win.document.body.scrollHeight+50);
  }  
} // setWindowSizeToContent

//aktualis scroll pozicio
/** Visszaadja a bongeszo aktualis scroll erteket
  * 
  * @return object scroll pos
  */
function getScrollPos() {
  var pos={top: 0, left: 0};  
 
  if (document.documentElement && (document.documentElement.scrollTop || document.documentElement.scrollLeft)) { 
    // Explorer 6 Strict and mozilla strict
    pos.left=document.documentElement.scrollLeft;
    pos.top=document.documentElement.scrollTop;
  } else if (self.pageYOffset) {// all except Explorer
    pos.left=self.pageXOffset;
    pos.top=self.pageYOffset;
  } else if (document.body) { // all other Explorers
    pos.left=document.body.scrollLeft;
    pos.top=document.body.scrollTop;
  }
  
//  pos.top=document.body.scrollTop;
//  pos.left=document.body.scrollLeft;

  return pos;
} // getScrollPos

//adott dim-ben benne-e van-e a pont
//mit miben
/** Megnezi, hogy egy pont egy dim-ben van-e
  *
  * @param object pos a pont koordinatai (pos)
  * @param object dim a teglalap dim
  * @return boolean teglalapban van-e a pont
  */
function dimContainsPos(pos,dim) {
  var contains=true;
  
  if (pos.top < dim.top || pos.top > dim.bottom || pos.left < dim.left || pos.left > dim.right) {
    contains=false;
  }
  return contains;
} // dimContainsPos

//megnezi dim1 es dim2 metszet dim-jet
//egy tombot ad vissza, 
//elso parametere a metszes modjat mondja meg, dim2 merre van dim1-tol (dim1-hez milyen vektorokat kell adni, hogy dim2-ot kapjuk)
//masodik a metszet merete 
//harmadik a metszet pozicioja es merete (dim)
//mit miben
/** Ket teglalap metszetet szamolja ki
  *
  * @param object elso teglalap dim
  * @param object masodik teglalap dim
  * @return array eltolasi vektor (dim), metszet meret (size), metszet teglalap (dim)
  */
function dimIntersectsDim(dim1,dim2) {
  //megfelelo oldalak viszonyai
  var a=dim1.left - dim2.left;
  var b=dim1.top - dim2.top;
  var c=dim1.right - dim2.right;
  var d=dim1.bottom - dim2.bottom;
  //ellentetes oldalak viszonyai
  var aa=dim1.left - dim2.right;
  var bb=dim1.top - dim2.bottom;
  var cc=dim1.right - dim2.left;
  var dd=dim1.bottom - dim2.top;

  var ret=new Array();


  //(d1)top a (d2)toptol, left a lefttol, bottom a bottomtol, right a righttol
  //ha top -, akkor felfele log ki
  //ha left -, akkor balra log ki
  //ha right +, akkor jobbra log ki
  //ha bottom +, akkor alul log ki
  ret[0]={top: b, left: a, bottom: d, right: c};    

//  van metszes:
//  a1*c1 <= 0 && b1*d1 <= 0   //teljes tartalmazas
//  a1*c1 <= 0 && b2*d2 < 0    //x szerint benne van, y szerint reszlegesen
//  b1*d1 <= 0 && a2*c2 < 0    //y szerint benne van, x szerint reszlegesen
//  a2*c2 < 0  && b2*d2 < 0    //x es y szerint reszlegesen
//eleg a2*c2 < 0 && b2*d2 < 0  is  
  if (aa*cc >= 0 || bb*dd >= 0) {
    ret[1]=null;
    ret[2]=null;
  } else {
    //van metszes
    var width=(dim1.right - dim1.left + dim2.right - dim2.left - (Math.abs(a) + Math.abs(c))) / 2;
    var height=(dim1.bottom - dim1.top + dim2.bottom - dim2.top - (Math.abs(b) + Math.abs(d))) / 2;

    ret[1]={width: width, height: height};  //metszet meretei
    ret[2]={top: dim2.top, left: dim2.left, bottom: 0, right: 0};   //metszet dim
    if (a > 0) {
      //belul kezdodik x
      ret[2].left+=a;
    }
    if (b > 0) {
      //belul kezdodik y
      ret[2].top+=b;
    }
    ret[2].right=ret[2].left+width;
    ret[2].bottom=ret[2].top+height; 
  }
   
  return ret;
} // dimIntersectsDim

//viewport-ban benne van-e teljesen az adott dim?
/** Bongeszoablak tartalmazza-e az adott teglalapot
  *
  * @param object dim a teglalap dim
  * @return boolean tartalmazas
  */
function viewportContainsDim(dim) {
  var ret=dimIntersectsDim(dim,getViewportDim());
  if (ret[1] == null) {
    return false;
  } else if (ret[2].top != dim.top || ret[2].left != dim.left || ret[2].right != dim.right || ret[2].bottom != dim.bottom) {
    return false;      
  }
  return true;
} // viewportContainsDim


//egy adott pont belul van-e a browserer belul vagy nem
//ezt nem a body-ra kell nezni, hanem viewportdim-re!!!!
/** Egy adott pont a bongeszoablakon belul van-e, regi elavult
  *
  * @param object p a pont pos
  * @return boolean tartalmazas
  */
function inBodyPoint(p) {
  var scrolltopleft = getScrollPos();
  var widthheight = getBodySize();
  var isin = true;
  
  if (p.top < scrolltopleft.top || p.top > scrolltopleft.top + widthheight.height 
      || p.left < scrolltopleft.left || p.left > scrolltopleft.top + widthheight.width) {
    isin = false;
  }
  return isin;
} // inBodyPoint

//egy adott terulet belul van-e a browserer belul vagy nem
/** Bongeszoablak tartalmazza-e az adott teglalapot, regi elavult
 *
 * @param object dim a teglalap dim
 * @return boolean tartalmazas
 */
function inBodyDim(dim) {
  var scrolltopleft = getScrollPos();
  var widthheight = getBodyWidthHeight();
  var isin = true;
  
  if (dim.top < scrolltopleft.top || dim.bottom > scrolltopleft.top + widthheight.height 
      || dim.left < scrolltopleft.left || dim.right > scrolltopleft.top + widthheight.width) {
    isin = false;
  }
  return isin;
} // inBodyDim



/////////////////////////////////////////////////////////////////////Event fuggvenyek

//elementhez esemenykezelo csatolasa
/** Elemhez esemenykezelo csatolas
  * 
  * @param object el az elem
  * @param string evname az esemeny neve 'on' nelkul
  * @param function func az esemenykezelo fuggveny
  */
function addEvent(el, evname, func) {
  if (el.attachEvent) {
    el.attachEvent("on" + evname, func);
  } else if (el.addEventListener){
    el.addEventListener(evname, func, false);   //bubbling
  }
} // addEvent

//elementtol esemenykezelo torlese
/** Elemhez csatolt esemenykezelo torlese
  *
  * @param object el az elem
  * @param string evname az esemeny neve 'on' nelkul
  * @param function func az esemenykezelo fuggveny
  */
function removeEvent(el, evname, func) {
  if (el.detachEvent) {
    el.detachEvent("on" + evname, func);
  } else if (el.removeEventListener) {
    if (nsDOM && evname.toLowerCase() == 'submit') {
      el.onsubmit = function () {};
    } else {
      el.removeEventListener(evname, func, false); //ha false volt az attach-ban, akkor itt is az kell
    }
  }
} // removeEvent

//event propagation stop, ez csak azt intezi el, hogy a dom faban felfele haladva a tobbi node ne kapja meg az esemenyt
//ettol meg a bongeszo elkapja pl.: egy linkre klikkelest, ehhez return false, vagy returnValue kell!!!
//vagy event.preventDefault() ????
/** Az esemeny felfele terjedeset allitja meg a DOM strukturaban
  *
  * @param object e az esemeny objektum
  * @return object az esemeny objektum
  */
function stopProp(e) {
  if (!e) var e = window.event;
  e.cancelBubble = true;
  if (e.stopPropagation) e.stopPropagation();
  return e;
} // stopProp

/** Megakadalyozza, hogy a bongeszo az adott esemenyhez tartozo muveletet elvegezze, pl.: eger bal gomb lenyomas es 
  * huzas stopProp ellenere is kijelolest eredmenyezne e nelkul
  *
  * @param object e az esemeny objektum
  * @return object az esemeny objektum
  */
function preventDef(e) {  
  if (!e) var e = window.event;
  e.returnValue=false;
  if (e.preventDefault) {
    e.preventDefault();
  }
  return e;
} // preventDef

//adott esemeny koordinatait adja vissza
/** Egy esemeny letrejottenek abszolut helyet adja meg, regi kompatibilitas miatt
  *
  * @param object e az esemeny objektum
  * @return object pozicio pos
  */
function getEventPos(e) {
  var posx = 0;
  var posy = 0;
  if (!e) var e = window.event;
  if (e.pageX || e.pageY)  {
    posx = e.pageX;
    posy = e.pageY;
  } else if (e.clientX || e.clientY)  {
    var scrollPos=getScrollPos();
    posx = e.clientX + scrollPos.left;
    posy = e.clientY + scrollPos.top;
  }
  return {top: posy, left: posx};
} // getEventPos


/** Egy esemeny letrejottenek abszolut helyet adja meg
  *
  * @param object e az esemeny objektum
  * @return object pozicio pos
  */
function getEventAbsolutePos(e) {
  return getEventPos(e);
} // getEventAbsolutePos

//ez border pos-t rakja 0,0-ba ehhez kepest hol generalodott az esemeny
/** Egy esemeny letrejottenek relativ helyet adja meg, amelyik elemen generalodott, annak a border poziciojahoz kepest
  *
  * @param object e az esemeny objektum
  * @return object pozicio pos
  */
function getEventRelativePos(e) {
  var posx = 0;
  var posy = 0;
  if (!e) var e = window.event;
  if (ieDOM) {
    var target=getTarget(e);
    posx=e.offsetX+getStyle(target,"border-left-width",true);  //content bal felso a 0,0, de margin nem kell neki
    posy=e.offsetY+getStyle(target,"border-top-width",true);
  } else if (operaDOM) {    
    var target=getTarget(e);
    //content bal felso a 0,0, margin is kell
    posx=e.offsetX+getStyle(target,"border-left-width",true)+getStyle(target,"padding-left",true);      
    posy=e.offsetY+getStyle(target,"border-top-width",true)+getStyle(target,"padding-top",true);
  } else if (nsDOM || konquerorDOM) {
    posx=e.layerX;  //border is benne van 0,0-ban
    posy=e.layerY;
  }   
  return {top: posy, left: posx};
} // getEventRelativePos

/** Billentyuzet esemeny karakterkodjat adja vissza
  *
  * @param object e az esemeny objektum
  * @return int a karakter ASCII kodja
  */
function getEventKeyCode(e) {
  if (!e) {
    var e = window.event;
  }
  if (nsDOM) {
    return e.charCode;
  } else if (operaDOM) {
    return e.keyCode;
  } else if (ieDOM) {
    return e.keyCode;
  }
  return 0;
} // getEventKeyCode

//mouseevent gombjat adja meg
/** Eger esemeny eseten melyik gomb valtotta ki az esemenyt
  * 
  * @param object e az esemeny objektum
  * @return string a gomb tipusa
  */
function getEventButton(e) {
  var button = '';
  if (!e) {
    var e = window.event;
  }
  if (nsDOM) {
     switch (e.button) {
       case 0: button = 'left';
               break;
       case 1: button = 'middle';
               break;
       case 2: button = 'right';
               break;
     }
  } else if (ieDOM) {
     //mousedown eseten: 1,4,2
     //click eseten: 0
     if ("click" == e.type) {
       switch (e.button) {
         case 0: button = 'left';
                 break;
         case 4: button = 'middle';
                 break;
         case 2: button = 'right';
                 break;
       }
     } else {
       switch (e.button) {
         case 1: button = 'left';
                 break;
         case 4: button = 'middle';
                 break;
         case 2: button = 'right';
                 break;
       }
     }
  } else if (operaDOM) {
     switch (e.button) {
       case 0: button = 'left';
               break;
       case 1: button = 'middle';
               break;
       case 2: button = 'right';
               break;
     }
  } else if (konquerorDOM || safariDOM) {
     switch (e.button) {
       case 1: button = 'left';
               break;
       case 4: button = 'middle';
               break;
       case 2: button = 'right';
               break;
     }
  }
  return button;
} // getEventButton

//mouseover, mouseout event-ek esetere
//target: az az element, amelyiknel az esemeny letrejott (ha onmouseover van, akkor ennek az onmouseover esemenykezeloje hivodna meg legeloszor)   outer -> inner (mouseover) from -> to 
//currentTarget: az az element, amire propagal az esemeny, tehat ahogy megy felfele (kontenerek fele) ez mindig az adott kontenert jeloli, a target viszont tartalmazza az eredeti esemeny elemet

/** Meghatarozza, hogy mely elemrol mely elemre tortent valtaskor generalodott az esemeny
  *
  * @param object e az esemeny objektum
  * @return object az elemeket tartalmazo objektum (from,to)
  */
function getFromTo(e) {
  var fromto = {from: null, to: null};
  if (!e) {
    var e = window.event;
  }
  if (e.fromElement) {
    fromto.from = e.fromElement;
  }
  if (e.toElement) {
    fromto.to = e.toElement;
  }
  if (e.relatedTarget) {
    if (e.type == 'mouseover') {
      fromto.from = e.relatedTarget;
      fromto.to = e.target;
    } else if (e.type == 'mouseout') {
      fromto.to = e.relatedTarget;
      fromto.from = e.target; 
    }
  } else {
  }

  return fromto;
} // getFromTo

//ez azt az elemet adja vissza, amin letrejott az eredeti esemeny
/** Azt az elemet adja vissza, amin letrejott az eredeti esemeny
  *
  * @param object e az esemeny objektum
  * @return object az elem
  */
function getTarget(e) {
  if (!e) {
    var e=window.event;
  }
  if (e.target) {
    return e.target;
  } else if (e.srcElement) {
    return e.srcElement;
  }

  return null;
} // getTarget


//////////////////////////////////////////////////////fas fuggvenyek
/** Egy fa (reszfa) strukturat stringre alakit
  *
  * @param object node az aktualis node
  * @param int level a node szintje
  * @return string a node reszfa stringje
  */
function getDomTree(node,level) {
  var text="";
  if (level == null) {
    level=0;
  }
  
  switch (node.nodeType) {
    case 9: //document
      text+="#document\n";
      for (var i=0; i < node.childNodes.length; i++) {        
        text+=getDomTree(node.childNodes[i],level+1); 
      }      
      break;
    case 1: // Node.ELEMENT_NODE
    case 11: // Node.DOCUMENT_FRAGMENT_NODE
      var tagName=node.tagName.toLowerCase();
      for (var i=0; i<level; i++) {
        text+=" ";
      }
      text+=tagName+"\n";
      for (var i=0; i < node.childNodes.length; i++) {        
        text+=getDomTree(node.childNodes[i],level+1); 
      }
      break;
    case 3: // Node.TEXT_NODE
      for (var i=0; i<level; i++) {
//        text+=" ";
      }
      text+="("+node.nodeValue.substr(0,10)+")\n";
		break;
    case 8: // Node.COMMENT_NODE
		break;		// skip comments, for now.
  }
  return text;
} // getDomTree

/** Ezt nem tudom, hogy mit csinal, vagyis tudom, csak azt nem, hogy miert igy
  * szerintem ugyanaz, mint a contains, esetleg annyi kulonbseggel, hogy szoveget is elfogad:
  */
function intoChild(obj,obj2) {
  var e = null;
  var t;
  var i = 0;
  var go = true;
  while(go == true) {
    if (i < obj.childNodes.length) {
      t = obj.childNodes[i];
      if (t == obj2) {   //megvan
        e = t;
        go = false;
      } else if (t.nodeType == 1) {  //element
        e = intoChild(t,obj2);
        if (e != null) {             //megvan
          go = false;
        }
      }
      i++;
    } else {
      go = false;
    }
  }
  return e;
} // intoChild


//child benne van-e parent reszfajaban?
/** Megvizsgalja, hogy egy elemet tartalmaz-e egy reszfa
  *
  * @param object parent a reszfa szulo node-ja
  * @param object child a node
  * @return boolean
  */
function contains(parent,child) {
  var go = true;
  var found = false;
  
  while(go) {
    if (child == parent) {
      go = false;
      found = true;
    } else if (child != null) {
      child = child.parentNode;
    } else {
      go = false;
    }
  }
  return found;
} // contains

//elsoszintu gyerekei kozul az adott indexu(0 az elso) es tipusu elem jon vissza
/** Egy node kozvetlen gyerekei kozul a megadott sorszamu es tagName-el rendelkezo elemet adja vissza
  *
  * @param object obj a node
  * @param int index a sorszam
  * @param string tagname a tag name
  * @return object a megtalalt elem
  */
function getChildByTagName(obj,index,tagname) {
  var childs = obj.childNodes;
  var elem = null;
  var i = 0;
  var j = 0;
  var go = (childs != null) ? true : false;
  
  while(go) {
    if (i < childs.length) {
      e = childs[i];
      if (e.nodeType == 1) {  //element
        if (e.tagName.toLowerCase() == tagname.toLowerCase()) {  //ha olyan, ami kell
          if (j == index) {  //ha megvan
            go = false;
            elem = e;
          } else {
            j++;
          }
        }
      }
      i++;
    } else {
      go = false;
    }
  }
  
  return elem;
} // getChildByTagName

//elsoszintu gyerekek kozul az adott indexu (0 az elso)
//ha text=false , akkor csak az elementek szamitanak
//ha text=true , akkor text is beleszamit
/** Egy node kozvetlen gyerekei kozul a megadott sorszamu node-ot adja vissza
  *
  * @param object obj a node
  * @param int index a sorszam
  * @param boolean text figyelembe kell-e venni a textNode-okat
  * @return object a megtalalt node
  */
function getChild(obj,index,text) {
  var childs = obj.childNodes;
  var elem = null;
  var i = 0;
  var j = 0;
  var go = (childs != null) ? true : false;
  
  while(go) {
    if (i < childs.length) {
      e = childs[i];
      if (text == false && e.nodeType == 1 || text == true && (e.nodeType == 3 || e.nodeType == 1)) {  
        //ha nem kell szoveg es htmlelementet talaltunk
        //vagy szoveg is kell es szoveget vagy htmlelementet talaltunk
        if (j == index) {
          go = false;
          elem = e;
        } else {
          j++;
        }
      }
      i++;
    } else {
      go = false;
    }
  }
  return elem;
} // getChild

//elem adott tipusu es indexu (0 a legkozelebi testver) testveret adja vissza
/** Egy elem adott sorszamu es tipusu testveret adja vissza
  *
  * @param object obj a node
  * @param int index a sorszam
  * @param string tagName a keresett elem tagName-je
  * @return object a megtalalt elem
  */
function getNextSibling(obj,index,tagName) {
  var elem=null;
  var node=obj.nextSibling;
  var i=0;
  var go=true;
  
  while(node && go) {
    if (1 == node.nodeType && node.tagName.toLowerCase() == tagName.toLowerCase()) {
      if (i == index) {
        go=false;
        elem=node;
      } else {
        ++i;
      }
    } else {
      node=node.nextSibling;
    }
  }
  return elem;
} // getNextSibling

//elem adott tipusu es indexu (0 a legkozelebi szulo) szulojet adja vissza
/** Egy elem adott sorszamu es tagName tipusu szulojet adja vissza
  *
  * @param object obj a node
  * @param int index a sorszam
  * @param string tagName a keresett elem tagName-je
  * @return object a megtalalt elem
  */
function getParent(obj,index,tagName) {
  var elem = null;
  var found = false;
  var parent = obj.parentNode;
  var i = 0;
  var go = (parent != null) ? true : false;
  
  while(go) {
    if (parent == null)  {  //nincs ilyen szulo
      go = false;
    } else if (parent.tagName.toLowerCase() == tagName.toLowerCase()) {
      if (i == index) {
        go = false;
        elem = parent;
      } else {
        i++;
      }
    } else {
      parent = parent.parentNode;
    }
  }
  return elem;
} // getParent

//ez melysegi keresessel visszadja az elso textnode-t, vagy null-t ha nincs
//igeny szerint index-re es elementre is meg lehet irni, mint ahogyan getchild
/** Adott node reszfajaba tartozo elso textnode-ot adja vissza (melysegi kereses)
  *
  * @param object obj a node
  * @return object a megtalalt textnode
  */
function getFirstTextNode(obj) {
  var e = null;
  var t;
  var i = 0;
  var go = true;
  while(go) {
    if (i < obj.childNodes.length) {
      t = obj.childNodes[i];
      if (t.nodeType == 3) {   //megvan
        e = t;
        go = false;
      } else if (t.nodeType == 1) {  //element
        e = getFirstTextNode(t);
        if (e != null) {             //megvan
          go = false;
        }
      }
      i++;
    } else {
      go = false;
    }
  }
  return e;
} // getFirstTextNode

/** ez kitorli az adott node-ot, ha kell, akkor gyerekei feljonnek helyere
  * visszaadja, hogy mennyi gyereket mozgatott fel
  *
  * @param object node a node
  * @param boolean contentMove reszfa tartalom a node helyere keruljon-e
  * @return int (elsoszintu) gyerek node-ok szama
  */
function deleteNode(node,contentMove) {      //node torlese, true: tartalom felmozog a helyere, false: az is elveszik
  contentMove = (contentMove == null) ? false : contentMove;  //default: tartalom torlese
  var i=0;
  if (node != null) {
    var parent = node.parentNode;
    if (contentMove) {
      i=node.childNodes.length;
      while(node.hasChildNodes()) {
 //       alert(node.tagName+"-"+node.hasChildNodes()+"-"+node.childNodes[0]+"-"+node.firstChild);
//IE alatt lehet olyan, hogy firstchild null, mig childnodes[0] az jo
//        var child = node.removeChild(node.firstChild);  //gyerekek node ele mozgatasa
        var child = node.removeChild(node.childNodes[0]);  //gyerekek node ele mozgatasa
        parent.insertBefore(child,node);   
      }
    }
    parent.removeChild(node);
  }
  return i;
} // deleteNode



/** ez megmondja, hogy adott node-nak be van-e allitva az adott attributum
  * altalaban link es anchor megkulonboztetesere hasznalatos, (van-e neki href-je)
  *
  * @param object node a node
  * @param string attr az attributum neve
  * @return boolean be van-e allitva 
  */
function nodeHasAttribute(node,attr) {
  if (node.hasAttribute) {
    //mozilla
    return node.hasAttribute(attr);
  } else {
    //IE
    var t=node.getAttributeNode(attr);
    if (t != null) {
      return t.specified;
    }
  }
  return false;
} // nodeHasAttribute


/////////////////////////tablas fuggvenyek
/** Ennek mar nincs sok ertelme, megnezte az adott tablara, hogy tbody-ban vannak-e a sorok, 
  * ha nem, akkor berakta oket egy tbody-ba
  */
function domtabla(htmltable) {
  //tbody-ba rakjuk a sorokat
  childs = htmltable.childNodes;
  var tbody;
  if (childs == null) {   //nincs gyereke
    tbody = document.createElement("tbody");
    htmltable.appendChild(tbody);
  } else {  //van gyereke
    first = getChild(htmltable,0,false);  //elso nem szoveg gyerek kell
    if (first == null || first.tagName.toLowerCase() != 'tbody') {
      tbody = document.createElement("tbody");
      //tbody-ba mozgatas
      for (var i = 0; i < childs.length ; i++) {
        tbody.appendChild(childs[i]);
      }
      for (var i = 0; i < childs.length ; i++) {
        table.removeChild(childs[i]);
      }
      htmltable.appendChild(tbody);
    } else {        //mar tbody-ban van
    }
    for (var i = 0; i < htmltable.rows.length ; i++) {  //ure sorok kinyirasa
      if (htmltable.rows.item(i).cells.length == 0) {  //ures sor: <tr></tr>
        htmltable.deleteRow(i);
        i--;
      }
    }
  }
} // domtabla

//egy sort szur be a megadott indexre
/** Egy sort szur be a megadott sorszamu helyre
  *
  * @param object table a tablazat
  * @param object row a sor
  * @param int index a sorsuam
  */
function insertRow(table,row,index) {
  if (index < table.rows.length) {  //kozbeszuras
    r = table.rows.item(index);
    r.parentNode.insertBefore(row,r);
  } else {  //biztosan van tbody-ja!!!!, ennek vegere szurjuk be
    tbody = getChildByTagName(table,0,'tbody');
    tbody.appendChild(row);
  }
} // insertRow
////////////////////////////////////location fuggvenyek

//js popup ablakban vagyunk?
/** Megvizsgalja, hogy popup ablak-e a bongeszoablak
  *
  * @return boolean popup-e
  */
function isPopup() {
  if (window.opener) {
    return true;
  } else {
    return false;
  }
} // isPopup

//frame-ben vagyunk?
//a szigetnel false kell
//mig imindon true kell, kulonben ki kell menni a tartalmazo oldalra
/** Megvizsgalja, hogy frame-e a bongeszoablak
  *
  * @return boolean frame-e
  */
function isFrame() {
  if(window.top.location == document.location) {
    return false;
  } else {
    return true;
  }  
} // isFrame


///////////////////////////////////////string es char fuggvenyek
/** Megviszgalja, hogy white space-e az adott karakter
  *
  * @param string c a karakter
  * @return boolean space-e
  */
function isSpace(c) {
  var spaces=" \t\n\r";
  return (spaces.indexOf(c) != -1 ? true : false);
} // isSpace

/** Whitespace levagas mindket oldalrol
  *
  * @param string str a string
  * @return string a trimmelt string
  */
function trim(str) {        //ketoldali trim
  if (str == null) {
    return "";
  }
  var i = 0,j = str.length - 1;
  var b = false;
  
  while(i < str.length && b == false) {
    if (isSpace(str.charAt(i)) == false) {
      b = true;
    } else {
      i++;
    }
  }
  if (b == true) {    //biztosan van benne nem white space char
    b = false;
    while(j >= 0 && b == false) {
      if (isSpace(str.charAt(j)) == false) {
        b = true;
      } else {
        j--;
      }
    }
    return str.substring(i,j + 1);   //i mutat az elso jo charra
  } else {
    return "";
  }
} // trim

/** Whitespace levagas bal oldalrol
  *
  * @param string str a string
  * @return string a trimmelt string
  */
function ltrim(str) {        //baloldali trim
  if (str == null) {
    return "";
  }
  var i = 0;
  var b = false;
  
  while(i < str.length && b == false) {
    if (isSpace(str.charAt(j)) == false) {
      b = true;
    } else {
      i++;
    }
  }
  if (b == true) {    //biztosan van benne nem white space char
    return str.substring(i,str.length);   //i mutat az elso jo charra
  } else {
    return "";
  }
} // ltrim

/** Whitespace levagas jobb oldalrol
  *
  * @param string str a string
  * @return string a trimmelt string
  */
function rtrim(str) {        //jobboldali trim
  if (str == null) {
    return "";
  }
  var j = str.length - 1;
  var b = false;
  
  while(j >= 0 && b == false) {
    if (isSpace(str.charAt(j)) == false) {
      b = true;
    } else {
      j--;
    }
  }
  if (b == true) {    //biztosan van benne nem white space char
    return str.substring(0,j + 1);   //j mutat az utolso jo charra
  } else {
    return "";
  }
} // rtrim

///////////////////////////////class fuggvenyek
/** Egy elem CSS classai koze felveszi a megadott classt
  *
  * @param object el az elem
  * @param string className az uj class neve
  */
function addClass(el, className) {
  removeClass(el, className);
  if (el.className == null || typeof el.className == 'undefined' || el.className == '') {  //opera miatt
    el.className = className;
  } else {
    el.className += ' ' + className;
  }  
} // addClass

/** Egy elem CSS classai kozul kitorli a megadott classt
  *
  * @param object el az elem
  * @parm string className a class neve
  */
function removeClass(el, className) {
  if (!(el && el.className)) {
    return;
  }
  var cls = el.className.split(' ');
  var ar = new Array();
  for (var i = cls.length; i > 0;) {
    if (cls[--i] != className) {
      ar[ar.length] = cls[i];
    }
  }
  el.className = ar.join(' ');
} // removeClass

/** Egy elem CSS style beallitasat torli
  *
  * @param object node az elem
  * @param string attr a style attributum neve
  */
function removeStyle(node,attr) {
  if (node && node.style) {
    if (ieDOM) {
      node.style.removeAttribute(attr);  //IE
    } else {
      node.style.removeProperty(attr);
    }
  }
} // removeStyle

/** Adott CSS stiluslap egy szabalyat adja vissza, aminek a kivalasztoja a megadott selector
  *
  * @param object sheet a CSS stylesheet
  * @param string a selector
  * @return object a CSS rule
  */
function getCssRuleBySelectorFromSheet(sheet,selector) {
  if (nsDOM) {
    var ruleList=sheet.cssRules;

    for (var j=0; j<ruleList.length; ++j) {
      //    alert("selector:"+ruleList[j].selectorText);
      if (ruleList[j].type == CSSRule.STYLE_RULE && ruleList[j].selectorText == selector) {
        return ruleList[j];
      } else if (ruleList[j].type == CSSRule.IMPORT_RULE) {
        //         alert("import!!:"+ruleList[j].href);
        var ret=getCssRuleBySelectorFromSheet(ruleList[j].styleSheet,selector);
        if (ret != null) {
          return ret;
        }
      }
    }
  } else if (ieDOM) {
    //elobb az importalt sheet-et keressuk
    for (var j=0; j<sheet.imports.length; ++j) {
      var ret=getCssRuleBySelectorFromSheet(sheet.imports[j],selector);
      if (ret != null) {
        return ret;
      }
    }
    var ruleList=sheet.rules;
    for (var j=0; j<ruleList.length; ++j) {
//    alert(ruleList[j].selectorText);
      if (ruleList[j].selectorText == selector) {
        return ruleList[j];
      }   
    }
  
  }
  return null;
} // getCssRuleBySelectorFromSheet

//ez a style objektumot adja vissza, 
//lehet, hogy a cssrule-t kellene
/** A megadott selectorral rendelkezo CSS szabalyt adja vissza, az osszes stiluslapot megnezi
  *
  * @param string selector a kivalaszto
  * @return object CSS rule
  */
function getCssRuleBySelector( selector ) {
  var sheetList=document.styleSheets;
  var ruleList;
  var i, j;


  if (sheetList) {
    /* look through stylesheets in reverse order that
       they appear in the document */
    for (i=sheetList.length-1; i >= 0; --i) {
      var ret=getCssRuleBySelectorFromSheet(sheetList[i],selector);
      if (ret != null) {
        return ret;
      }
    }
  }
  return null;
} //getCssRuleBySelector


//node.style -ebben az van, ami inline, vagy js-bol lett beallitva
/** Meghatarozza, hogy az adott elemre milyen stilus beallitas ervenyes, ha nincs beallitva semmi sem, 
  * akkor a renderelt erteket adja vissza
  *
  * @param object node az elem
  * @param string attr a stilus attributum neve
  * @param boolean num szamot kell-e a visszaadni (pl.: width eseten 16px helyett 16 kell)
  * @return mixed az atritbutum string vagy szam
  */
function getStyle(node,attr,num) {
  var value = node.style[toCamelCase(attr)];
  if (value=='') {
    if(document.defaultView) {
      value = document.defaultView.getComputedStyle(node, "").getPropertyValue(attr);
    } else if (node.currentStyle) {
      value = node.currentStyle[toCamelCase(attr)];
    }
  }
  if (num) {
    value=parseInt(value);
    if (isNaN(value)) {
      value=0;
    }
  }
  return value;
} // getStyle

/** A CSS attributum nevet atalakitja javascript megfelelo nevere
  *
  * @param string sInput a CSS nev
  * @return string a konvertalt ertek
  */
function toCamelCase( sInput ) {
  var sArray = sInput.split('-');
  if(sArray.length == 1)    
    return sArray[0];
  var ret = sArray[0];
  for(var i = 1; i < sArray.length; i++){
    var s = sArray[i];
    ret += s.charAt(0).toUpperCase() + s.substring(1)
  }
  return ret;
} // toCamelCase

/** A toCamleCase inverze, JS nevet visszaalakit CSS nevre
  *
  * @param string camel a JS nev
  * @return string a konvertalt ertek
  */
function fromCamelCase(camel) {
  return camel.replace(/([A-Z])/g,"-$1").toLowerCase();
} // fromCamelCase

/** Kozelitoleg atvaltja a fontmeretet pixelre
  *
  * @param string fontsize a font merete
  * @param object body a body objektum em szamolashoz
  * @return int a fontmeret kozelito erteke pixelben
  */
function getFontSizePx(fontsize,body) {
  var newfont='';
  if (/pt/.test(fontsize)) {    //ha pt
    newfont=parseInt(fontsize)*1.333333;
  } else if (/em/.test(fontsize) && !body) {                     //ha em
    newfont=parseInt(fontSize)*getFontSizePx(getStyle(document.body,"font-size",false),true);
  } else {    //ha nem
    newfont=parseInt(fontsize);
  }
  return newfont;
} // getFontSizePx


/** A pixelben megadott font meretet alakitja vissza pt-re
  *
  * @param string a font meret
  * @return int a font meret kozelito erteke pt-ben
  */
function px2pt(fontsize) {  //esetleg a vegere lehet tenni a pt-t
  var newfont = '';
  if (ieDOM) {
    reg = /px/;
    if (reg.test(fontsize)) {    //ha px
      newfont = Math.round(parseInt(fontsize)/1.3);
    } else {                     //ha nem
      newfont = parseInt(fontsize);
    }
  } else {
    newfont = parseInt(fontsize);
  }
  return newfont;
} // px2pt

/////////////////////////////////objektum fuggvenyek

/*
//klonozni egy objektumot: ez a tartalmazott objektumokat is lemasolja, nem csak a referenciajuk lesz
function cloneObject(what) {
for (i in what) {
if (typeof what[i] == 'object') {
this[i] = new cloneObject(what[i]);
}
else
this[i] = what[i];
}
}
var book2= new cloneObject(book1);

//ez referenciat hagy
function cloneObject(what) {
for (i in what) {
this[i] = what[i];
}
}
var book2 = new cloneObject(book1)
 */
//nekunk eleg konfiguracios objektumot masolni

/** Egy adott objektumot masol le, a szimpla = ertekadas referencia szerint megy
  *
  * @param object obj az objektum
  * @param array list opcionalis attributum lista, ha meg van adva, akkor csak ezeket az attributumokat masolja le
  * @return object a masolat
  */
function copyObject(obj,list) {
  var newObj = new Object();

  if (list == null) {
    for (var i in obj) {   //osszes elem
      if (typeof obj[i] == 'object') {
        newObj[i] = obj[i];
//        newObj[i] = copyObject(obj[i]);  //ez elszall rekurzioval, ha DomNode-t kap be
      } else {
        newObj[i] = obj[i];
      }
    }
  } else {
    for (var i in list) { //csak a megadott elemek
      newObj[list[i]] = obj[list[i]];
    }
  }
  return newObj;
} // copyObject

/** Ket objektum attributumait osszefesuli
  *
  * @param object dst ennek az attributumait irja felul
  * @param object src ennek az attributumaival
  * @return object az osszefesult objektum
  */
function mergeObject(dst,src) {
  var newObj=copyObject(dst);
  for (var i in src) {
    newObj[i]=src[i];
  }
  return newObj;
} // mergeObject

/** Megnezi, hogy a tombben szerepel-e az adott ertek
  *
  * @param array arr a tomb
  * @param mixed value az ertek
  * @return boolean tartalmazas
  */
function inArray(arr,value) { 
  for (var i in arr) {
    if (arr[i] == value) {
      return true;
    }
  }

  return false;
} // inArray

/** Megallapitja, hogy milyen index-szel szerepel az ertek a tombben
  *
  * @param array arr a tomb
  * @param mixed value az ertek
  * @return int az index
  */
function getIndex(arr,value) {
  for (var i in arr) {
    if (arr[i] == value) {
      return i;
    }
  }
  return null;
} // getIndex

/** Egy valtozo erteket alakitja at rekurzivan egy stringge, idealis objektumok attributumainak megnezesehez
  *
  * @param mixed v a valtozo
  * @param boolean functions fuggvenyek kellenek-e a felsorolasba
  * @param boolean functionsBody a fuggvenyek torzse kell-e
  * @param int level a rekurzio szintje
  * @return string az ertekek stringje
  */
function varDump(v,functions,functionsBody,level) {
  //undefined    null
  //number       1, 1.1
  //string       "1"
  //boolean      true
  //object       {asdf: 1}
  //object       ["asdf",1]
  //function     function() {}
  if (level == null) {
    level = 0;
  }
  var str="";
  switch (typeof v) {
    case 'undefined':
    case 'number':
    case 'string':
    case 'boolean':      
      str+= "("+typeof v + "): " + v + "\n";
      break;
    case 'function':
      if (functions) {
        str+= "("+typeof v + "): ";
        if (functionsBody) {
          str+=v;
        }
        str+="\n";
      }
      break;
    case 'object':
      str+= "("+typeof v + "): {\n";
      if (level > 0) {
        for (var i in v) {
          str+= i + " " + varDump(v[i],functions,functionsBody,level-1);
        }
      }
      str+= "}\n";
      break;
    default:
      alert("varDump unknown type: "+(typeof v));
      break;
  }
  return str;
} // varDump

/** Megmondja, hogy a valtozo tipusa objektum-e (a null is object!)
  * leginkabb az objektum-fuggveny megkulonboztetsre erdemes hasznalni
  *
  * @param mixed v a valtozo
  * @return boolean objektum-e
  */
function isObject(v) {
  if (v && typeof v == 'object' && v.toString().indexOf('function(') != 0) { //IE neha a fuggvenyeket objektumnak nezi
    return true;
  } else {
    return false;
  }
} // isObject

/** Megmondja, hogy a valtozo tipusa fuggveny-e (
  * IE alatt csak dinamikusan letrehozott fuggvenyekre lehet hasznalni, beepitettekre nem)
  *
  * @param mixed v a valtozo
  * @return boolean fuggveny-e
  */
function isFunction(v) {
  //IE alatt ez csak dinamikusan letrehozott fuggvenyekre mukodik, input.focus-ra nem!
  if (typeof v == 'function' || (v && v.toString().indexOf('function(') == 0)) {//IE neha a fuggvenyeket objektumnak nezi
    return true;
  } else {
    return false;
  }
} // isFunction

/** ez visszaadja a get parametereket egy tombben
  * 
  * @param boolean empty ha true, akkor ures parametereket is visszaadja, default: true
  * @return object egy tomb, melyben nevvel lehet elerni a kulcsokat
  */
function parseLocationSearch(empty) {
  var empty=(empty != null) ? empty : true;
  var ret=new Array();
  var search=location.search;

  if (search != '') {
    search=search.substr(1);  //? levagasa
    search=unescape(search);
    var t=search.split('&');
    for (var i=0; i<t.length; ++i) {
      if (t[i]) {
        var t2=t[i].split('=');
        if (empty || t2[1]) {
          //ha uresek is kellenek, akkor mindenkeppen kell
          //amugy csak akkor, ha nem ures
          ret[t2[0]]=t2[1];
        }
      }
    }
  }
  
  return ret;
} // parseLocationSearch


/** A PHPSESSID erteket adja vissza vagy get-bol, vagy cookie-bol
  *
  * @param string sessionName opcialisan megadhato, hogy milyen nevu valtozot keressen, def: PHPSESSID
  * @return string a php session id-ja
  */
function getSessionId(sessionName) {
  var sessionName = (sessionName != null) ? sessionName : "PHPSESSID";
 
  var getValues=parseLocationSearch();
  if (getValues[sessionName]) {
    //ha _GET-ben utazik a session
    return getValues[sessionName];
  } else {
    //ha _COOKIE-ban utazik a session
    return getCookie(sessionName);
  }
  return ""; 
} // getSessionId

////////////////////////range


/** textinput vagy textarea eseten megmondja, hogy mettol meddig tart az aktualis kijeloles (vagy a kurzor eppen hol all)
  *
  * @param object node az input node
  * @param object firingNode IE eseten focust is allitani kell, ezert kell egy node, amire vissza lehet allitani a focus (pl. gomb)
  * @return object a selection intervallum {start,end}
  */
function getSelectionRange(node,firingNode) {
  var selRange={start: 0, end: 0};  //az elejetol szamitva megy az end [start,end[
  if (node.selectionStart != null) {
    selRange.start=node.selectionStart;
    selRange.end=node.selectionEnd;    
  } else if (node.ownerDocument.selection) {
    node.focus();
    var oSelection=node.ownerDocument.selection;
    var oldRange=oSelection.createRange();   //eredeti range

    node.select();
    oSelection=node.ownerDocument.selection;
    var newRange=oSelection.createRange();   //uj range
    //eleg a start-ot nezni!
 
    var newLines=0;
    while(newRange.compareEndPoints('StartToStart',oldRange) < 0)  {
      //amig kisebb a range kezdete
      selRange.start++;
      newRange.moveStart('character',1);
    }

    var index1=0;
    var index2=selRange.start;
    newLines=countChar(node.value,"\r",index1,index2);
    while(newLines > 0) {
      index1=index2;
      index2+=newLines;
      newLines=countChar(node.value,"\r",index1,index2);
    }
    selRange.start=index2;  

    selRange.end=selRange.start+oldRange.text.length;
    
    oldRange.select();  //itt vissza a regit
    if (firingNode) {
      firingNode.focus();
    }
  }
  return selRange;
} // getSelectionRange


/** Az aktualis kijelolest allitja be, ha a ket index megegyezik, akkor a kurzort allitja addot helyre
  *
  * @param object node a node
  * @param int startIndex a kezdoindex
  * @param int endIndex a vegindex
  */
function selectRange(node,startIndex,endIndex) {
  if (node.setSelectionRange) {
    node.focus();
    node.setSelectionRange(startIndex, endIndex);
//    node.selectionStart=startIndex;
//    node.selectionEnd=endIndex;
  } else if (node.createTextRange) {
    node.focus();

    var tr=node.createTextRange();
    //reset 0,0-ba
    tr.moveStart('character',-1*node.value.length);
    tr.moveEnd('character',-1*node.value.length);

    var count=countChar(node.value,"\r",0,startIndex);
    startIndex-=count;
    count=countChar(node.value,"\r",0,endIndex);
    endIndex-=count;

    tr.moveStart('character',startIndex);
    tr.moveEnd('character',endIndex-startIndex);  //hosszat adja meg
    tr.select();

  }
} // selectRange

/** Megszamolja, hogy adott szovegen belul hanyszor fordul elo egy karakter (string)
  *
  * @param string text a szoveg
  * @param string ch a karakter (szoveg)
  * @param int startIndex a kezdoindex, opcionalis
  * @param int endindex a veg index, opcionalis
  */
function countChar(text,ch,startIndex,endIndex) {
  //ez megszamolja, hanyszor fordul elo egy char egy text-ben
  if (startIndex != null) {
    if (endIndex == null) {       
      endIndex=text.length;
    }
    text=text.substring(startIndex,endIndex);
  }
  var index=0;
  var foundIndex=0;
  var count=0;
  while(index < text.length) {
    foundIndex=text.indexOf(ch,index);
    if (foundIndex == -1) {
      index=text.length;
    } else {
      index=foundIndex+1;
      ++count;
    }
  }

  return count;
} // countChar

/////////////////////////////////cookie

/*
   name - name of the cookie
   value - value of the cookie
   [expires] - expiration date of the cookie
   (defaults to end of current session)
   [path] - path for which the cookie is valid
   (defaults to path of calling document)
   [domain] - domain for which the cookie is valid
   (defaults to domain of calling document)
   [secure] - Boolean value indicating if the cookie transmission requires
   a secure transmission
 * an argument defaults when it is assigned null as a placeholder
 * a null placeholder is not required for trailing omitted arguments
 */

/** Lerak egy cookie-t
  *
  * @param string name a cookie neve
  * @param string value az erteke
  * @param date expires a lejarata
  * @param string path mely eleresi utvonal alatt ervenyes
  * @param string domain mely domain alatt ervenyes
  * @param boolean secure igenyel-e HTTPS-t
  */
function setCookie(name, value, expires, path, domain, secure) {
  var curCookie = name + "=" + escape(value) +
    ((expires) ? "; expires=" + expires.toGMTString() : "") +
      ((path) ? "; path=" + path : "") +
        ((domain) ? "; domain=" + domain : "") +
        ((secure) ? "; secure" : "");
  document.cookie = curCookie;
} // setCookie


/*
   name - name of the desired cookie
   return string containing value of specified cookie or null
   if cookie does not exist
 */
/** Egy cookie erteket adja vissza
  *
  * @param string name a nev
  * @return string az ertek
  */
function getCookie(name) {
  var dc = document.cookie;
  var prefix = name + "=";
  var begin = dc.indexOf("; " + prefix);
  if (begin == -1) {
    begin = dc.indexOf(prefix);
    if (begin != 0) return null;
  } else
    begin += 2;
  var end = document.cookie.indexOf(";", begin);
  if (end == -1)
    end = dc.length;
  return unescape(dc.substring(begin + prefix.length, end));
} // getCookie


/*
   name - name of the cookie
   [path] - path of the cookie (must be same as path used to create cookie)
   [domain] - domain of the cookie (must be same as domain used to
   create cookie)
   path and domain default if assigned null or omitted if no explicit
   argument proceeds
 */
/** Egy cookie torlese
  *
  * @param sring name a neve
  * @param string path az eleresi utvonal
  * @param string domain a domain
  */
function deleteCookie(name, path, domain) {
  if (getCookie(name)) {
    document.cookie = name + "=" +
      ((path) ? "; path=" + path : "") +
      ((domain) ? "; domain=" + domain : "") +
      "; expires=Thu, 01-Jan-70 00:00:01 GMT";
  }
} // deleteCookie


/** HTML entitasok konvertalasa a megfelelo karakterekre
  *
  * @param string html az entitasokat tartalmazo html
  * @return string a konvertalt karakterek
  */
function html2Text(html) {
  var div=document.createElement("div");
  var text="";
  div.innerHTML=html;
  if (typeof div.innerText != 'undefined') {
    text=div.innerText;
  } else if (typeof div.ownerDocument != 'undefined' && typeof div.ownerDocument.createRange != 'undefined')  {
    var range=div.ownerDocument.createRange();
    range.selectNodeContents(div);
    text=range.toString();
  } else if (typeof div.textContent != 'undefined') {
    text=div.textContent;
  } 
  return text;
} // html2Text

/** Egy javacript file-t illeszt be a dokumentumba
  *
  * @param string url a JS url-je
  */
function downloadScript(url) {
  if (url) {
    var heads=document.getElementsByTagName("head");
    if (heads.length > 0) {
      var script=document.createElement("script");
      heads[0].appendChild(script);
      script.setAttribute("src",url);
    }
  }
} // downloadScript

/** Decimalis erteket alakit at hexadecimalisra
  *
  * @param int num a decimalis szam
  * @return string hexadecimalis szam
  */
function dec2Hex(num) {
  var chars='0123456789ABCDEF';
  if (num > 255) return 'FF';
  return chars.charAt(parseInt(num/16))+chars.charAt(num%16);
} // dec2Hex

/** Egy szamot ket szamjegyure alakit at
  *
  * @param int num a szam
  * @return string a ket szamjegyu szam
  */
function digit2(num) {
  if (num < 10) return "0"+num;
  return num;
} // digit2

/** A behaviour imind:attributes={} class feldolgozasa
  *
  * @param object node a node
  * @return object az attributum objektum
  */
function getImindAttributes(node) {
  if (node && node.className) {
    var i1=node.className.indexOf("{");
    var i2=node.className.lastIndexOf("}");
    if (i1 >= 0 && i2 >= 0) {
      var attributes="{"+node.className.substring(i1+1,i2)+"}";
      attributes=attributes.replace(/\&quot;/gi,'"',attributes); //newaffield miatt
      eval("attributes="+attributes+";");
      return attributes;
    } 
  } 
  return null;
} // getImindAttributes

/** Megkeresi az elso szulojet az adott node-nak, amelyiknek a className-je egyezik a megadottal
  *
  * @param object node a node
  * @param string className a CSS class neve
  * @return object a megtalalt elem
  */
function getParentByClassName(node,className) {

  if (node.parentNode) {
    node=node.parentNode;
    while(node) {
      if (node.className == className) {
        return node;
      }
      node=node.parentNode;
    }
  } 
  return null;
} // getParentByClassName


// http://www.robertnyman.com/2005/11/07/the-ultimate-getelementsbyclassname/
/** Kigyujti azokat az elemeket, amelyek rendekeznek az adott CSS class-al
  *
  * @param object oElm az elem aminek a reszfajaban kell keresni
  * @param string strTagName az elem tagName-je, * is lehet
  * @param string strClassName a CSS class neve
  * @return array az talalt elemek tombje
  */
function getElementsByClassName(oElm, strTagName, strClassName){
  var arrElements = (strTagName == "*" && document.all)? document.all : oElm.getElementsByTagName(strTagName);
  var arrReturnElements=new Array();
  strClassName=strClassName.replace(/\-/g, "\\-");
  var oRegExp=new RegExp("(^|\\s)" + strClassName + "(\\s|$)");
  var oElement;
  for(var i=0; i<arrElements.length; ++i){
    oElement=arrElements[i];      
    if(oRegExp.test(oElement.className)){
      arrReturnElements.push(oElement);
    }   
  }
  return arrReturnElements;
} // getElementsByClassName