﻿function CMapGrid(iTop, iLeft, iBottom, iRight, tmTopoliszMap, iMapViewVectorY, iMapViewVectorX)
{
    this.iTop  = iTop;
	this.iLeft = iLeft;	
	this.iWidth = iRight - iLeft + 1;
	this.iHeight = iBottom - iTop + 1;
	this.iMapViewVectorX = iMapViewVectorX;
	this.iMapViewVectorY = iMapViewVectorY;	
	this.tmTopoliszMap = tmTopoliszMap;
	
	this.arrGridItems = new Array();	
    this.iLevel = 0;	
	this.i_gHbase = 1;
	this.i_gWbase = 1;	
	this.FileNames = null;	
	this.ArgLoad_DiffTop = 0;
	this.ArgLoad_DiffLeft = 0;	
	this.LoadedImagesTop = 0;
	this.LoadedImagesLeft = 0;	
	this.AllowMove = true;
	this.MemoMoveX = 0;
	this.MemoMoveY = 0;	
	this.bCanMoveX = true;
	this.bCanMoveY = true;
	this.sMoveCallbackOn = "true";	
	this.mainGridDiv = null;
	this.mainGridImageDiv = null;
	this.mainGridImageDivSec = null;
	this.mainGridImage = null;
	this.mainGridImageSec = null;	
	this.mainGridPrintImage = null;
	this.mainGridDistMeasureImageDiv = null;
	//this.divPoiParent = null;	
	this.dWgsLowerLeftX = 0.0;
	this.dWgsLowerLeftY = 0.0;
	this.dWgsUpperRightX = 0.0;
	this.dWgsUpperRightY = 0.0;	
    this.iAccMoveMapVectorY = 0;
    this.iAccMoveMapVectorX = 0;               
	
	this.zoomPreviewAnim_Images = null;    
	this.zoomPreviewAnim_Images_Width = null;    
	this.zoomPreviewAnim_Images_Height = null;    
    this.zoomPreviewAnim_Tops = new Array ();
    this.zoomPreviewAnim_Lefts = new Array ();
    this.zoomPreviewAnim_ImageHeight = null;
    this.zoomPreviewAnim_ImageWidth = null;
    this.zoomPreviewAnim_ZoomFactor = 0;
    this.zoomPreviewAnim_BasePointX = 0;
    this.zoomPreviewAnim_BasePointY = 0;
    this.zoomPreviewAnim_PhasesLeft = 10;
    this.zoomPreviewAnim_PhasesNum = 10;     	
	
	var me=this;
	
	
	this.GetTop = function ()
	{
	    return me.iTop;
	}	
	
	this.GetLeft = function ()
	{
	    return me.iLeft;
	}
	
	this.GetBottom = function ()
	{
	    return me.iTop + me.iHeight - 1;
	}	
	
	this.GetRight = function ()
	{
	    return me.iLeft + me.iWidth - 1;
	}
	
	// ==========================================================================
	
	this.SetWgs = function (dLowerLeftX, dLowerLeftY, dUpperRightX, dUpperRightY)
	{
	    me.dWgsLowerLeftX = dLowerLeftX;
	    me.dWgsLowerLeftY = dLowerLeftY;
	    me.dWgsUpperRightX = dUpperRightX;
	    me.dWgsUpperRightY = dUpperRightY;
	}
	
	// --------------------------------------------------------------------------
	
	this.SetImageFileNames = function (FileNames)
	{
	    me.FileNames = FileNames;
	}
	
	// --------------------------------------------------------------------------
	
	// iRow, iCol : a csempek abszolut indexei
	// abszolut index itt azt jelenti, hogy a (0,0)-as  csempe a teljes felszeletelt terkep
	// bal felso csempeje
	
	this.GetImageFileName = function (iRow, iCol)
	{
	    var ArrayCoord = me.GetArrayAbsCoordinate(iRow-me.LoadedImagesTop, iCol-me.LoadedImagesLeft);
	    return me.FileNames[ArrayCoord];
	}
	
	// --------------------------------------------------------------------------
	
	// hanyadik elem a sorban az a csempe melynek koordinataja az input ha
	// a (0,0)-as  csempe a teljes felszeletelt terkep bal felso csempeje
	
	this.GetArrayCoordinate = function (iY, iX)
	{
	   return (me.iWidth)*(iY-me.iTop)+iX-me.iLeft;
	}
	
	// --------------------------------------------------------------------------

	// hanyadik elem a sorban az a csempe melynek koordinataja az input ha
	// a gridben! levo bal felso csempe koordinataja a (0,0)
	
	this.GetArrayAbsCoordinate = function (iY, iX)
	{
	   return (me.iWidth)*(iY)+iX;
	}
	
	// --------------------------------------------------------------------------
	
	// a grid szelessege csempeszamban
	
	this.GetWidth = function () 
	{
	    return me.iWidth;
	}
	
	// --------------------------------------------------------------------------
	
    // a grid magassaga csempeszamban

	this.GetHeight = function () 
	{
	    return me.iHeight;
	}
	
    // --------------------------------------------------------------------------
		
    this.GetMapViewVectorX = function ()
    {
        return me.iMapViewVectorX;
    }

	// --------------------------------------------------------------------------
	
    this.GetMapViewVectorY = function ()
    {
        return me.iMapViewVectorY;
    }
		
	// --------------------------------------------------------------------------
	
	// az elso csempesor index-et adja
	// ha PosY. abszolut terkep pixelsor = a grid elso pixelsora 
	
    this.GetTopFromAbsCoordY = function (PosY)
    {
  	    var DivY = PosY / me.tmTopoliszMap.GetMapGridItemHeight();
        var res = Math.floor(DivY);
        return res;
    }
    
    // --------------------------------------------------------------------------

	// az elso csempeoszlop index-et adja
	// ha PosX. abszolut terkep pixelsor = a grid elso pixeloszlopa 

    this.GetLeftFromAbsCoordX = function (PosX)
    {
  	    var DivX = PosX / me.tmTopoliszMap.GetMapGridItemWidth();
        var res = Math.floor(DivX);
        return res;
    }

    // --------------------------------------------------------------------------
    
    this.GetMapViewVectorYFromAbsCoordY = function (PosY)
    {
        var DivY = PosY / me.tmTopoliszMap.GetMapGridItemHeight();
        return Math.floor((DivY - Math.floor(DivY)) * me.tmTopoliszMap.GetMapGridItemHeight());
    }
    
    // --------------------------------------------------------------------------

    this.GetMapViewVectorXFromAbsCoordX = function (PosX)
    {
        var DivX = PosX / me.tmTopoliszMap.GetMapGridItemWidth();
        return  Math.floor((DivX - Math.floor(DivX)) * me.tmTopoliszMap.GetMapGridItemWidth());
    }
    
    // --------------------------------------------------------------------------
	
	// a szerver valaszan alapszik
	this.LoadLevel2 = function (serverResponse) 
	{	
        me.SetImageFileNames (serverResponse.arrUrls);     
        me.iLevel = serverResponse.iLevel;            
        me.SetWgs (serverResponse.dGridLowerLeftX, serverResponse.dGridLowerLeftY, serverResponse.dGridUpperRightX, serverResponse.dGridUpperRightY);                
        me.LoadedImagesTop = serverResponse.iGridUpperRow;
        me.LoadedImagesLeft = serverResponse.iGridLeftColumn;  
  	      	    	    	      	   	    	      	    	    
        me.iTop = serverResponse.iGridUpperRow;
        me.iMapViewVectorY = serverResponse.iViewportOffsetY;        
        me.iLeft = serverResponse.iGridLeftColumn;
        me.iMapViewVectorX = serverResponse.iViewportOffsetX;
	    
        for(var iYIter = me.iTop; iYIter <= serverResponse.iGridLowerRow; iYIter++)
        {
	        for(var iXIter = me.iLeft; iXIter <= serverResponse.iGridRightColumn; iXIter++)
            {   
                var GridItem = me.arrGridItems[me.GetArrayCoordinate(iYIter, iXIter)];
                GridItem.RemoveImg();                   
            }
        }	                           	                           

	    
	    
        for(var iYIter = me.iTop; iYIter <= serverResponse.iGridLowerRow; iYIter++)
        {
	        for(var iXIter = me.iLeft; iXIter <= serverResponse.iGridRightColumn; iXIter++)
            {          
                var iPosY = me.tmTopoliszMap.GetMapGridItemHeight() * (iYIter - me.iTop) - me.iMapViewVectorY;
                var iPosX = me.tmTopoliszMap.GetMapGridItemWidth() * (iXIter - me.iLeft) - me.iMapViewVectorX;
	           
                var GridItem = me.arrGridItems[me.GetArrayCoordinate(iYIter, iXIter)];

                GridItem.Load(me.iLevel, iYIter, iXIter);
                GridItem.SetPos(iPosY,iPosX);                                     
            }
        }	                           	                           
                
        me.SetMainGridDiv ();
	}	

    // --------------------------------------------------------------------------
    
	this.CreateGrid = function () 
	{	    	    
	  var mgd = me.mainGridDiv = NewTag('div');
	  me.mainGridDiv.className = "grid";
	  me.mainGridDiv.id = me.tmTopoliszMap.divMap.id + "grid";
	    
	    me.mainGridImageDiv = NewTag('div');
	    me.mainGridImageDiv.id = me.tmTopoliszMap.divMap.id + "imggrid";
		me.mainGridImageDiv.style.position = "absolute";
		me.mainGridImageDiv.className = "noprint";
		me.mainGridImageDiv.style.top = "0px";
		me.mainGridImageDiv.style.left = "0px";
		me.mainGridImageDiv.style.zIndex = "6";
		me.mainGridImageDiv.style.backgroundColor = "transparent";
		AddTag(me.mainGridImageDiv, me.mainGridDiv);    
	  		  	    
		me.mainGridImage = NewTag('img');
		me.mainGridImage.style.position = "absolute";
		me.mainGridImage.style.top = "0px";
		me.mainGridImage.style.left = "0px";
		me.mainGridImage.style.backgroundColor = "transparent";
		AddTag(me.mainGridImage, me.mainGridImageDiv);						

	    me.mainGridImageDivSec = NewTag('div');
	    me.mainGridImageDivSec.id = me.tmTopoliszMap.divMap.id + "imggridsec";
		me.mainGridImageDivSec.style.position = "absolute";
		me.mainGridImageDivSec.className = "noprint";
		me.mainGridImageDivSec.style.top = "0px";
		me.mainGridImageDivSec.style.left = "0px";
		me.mainGridImageDivSec.style.zIndex = "5";
		me.mainGridImageDivSec.style.backgroundColor = "transparent";
		AddTag(me.mainGridImageDivSec, me.mainGridDiv);    
	  		  	    
		me.mainGridImageSec = NewTag('img');
		me.mainGridImageSec.style.position = "absolute";
		me.mainGridImageSec.style.top = "0px";
		me.mainGridImageSec.style.left = "0px";
		me.mainGridImageSec.style.backgroundColor = "transparent";
		AddTag(me.mainGridImageSec, me.mainGridImageDivSec);						

		me.mainGridPrintImage = NewTag('img');
		me.mainGridPrintImage.className = "imggridprint";
		me.mainGridPrintImage.style.position = "absolute";
		me.mainGridPrintImage.style.top = "0px";
		me.mainGridPrintImage.style.left = "0px";
		me.mainGridPrintImage.style.backgroundColor = "transparent";
		AddTag(me.mainGridPrintImage, me.mainGridDiv);						

		me.mainGridDistMeasureImageDiv = NewTag('div');
		me.mainGridDistMeasureImageDiv.id = me.tmTopoliszMap.divMap.id + "distmeasureimggrid";
		me.mainGridDistMeasureImageDiv.style.position = "absolute";
		me.mainGridDistMeasureImageDiv.style.top = "0px";
		me.mainGridDistMeasureImageDiv.style.left = "0px";
		me.mainGridDistMeasureImageDiv.style.zIndex = "1";
		AddTag(me.mainGridDistMeasureImageDiv, me.mainGridDiv);
		
		

		//me.divPoiParent = NewTag('div', me.mainGridDiv);
		//me.divPoiParent.className = "poiParent";
	    
	  AddTag(me.mainGridDiv, me.tmTopoliszMap.divMap);    
	
	  for(var iYIter = me.iTop; iYIter < me.iTop + me.iHeight; iYIter++)
	  {
      for(var iXIter = me.iLeft; iXIter < me.iLeft + me.iWidth; iXIter++)
	    {
		    var NewGridItem = me.tmTopoliszMap.GetMapGridItem ();	
				me.arrGridItems[me.GetArrayCoordinate(iYIter, iXIter)] = NewGridItem;
	    }
	  }
	    
	  return mgd;
	}	
	
	// --------------------------------------------------------------------------  
	
	this.SetMainGridDiv = function ()
	{	
	    me.mainGridDiv.style.left = -me.iMapViewVectorX + "px";
	    me.mainGridDiv.style.top = -me.iMapViewVectorY + "px";
	    me.mainGridDiv.style.width = me.iWidth * me.tmTopoliszMap.GetMapGridItemWidth() + "px";
	    me.mainGridDiv.style.height = me.iHeight * me.tmTopoliszMap.GetMapGridItemHeight() + "px";		    	    

	    me.mainGridImageDiv.style.width = me.iWidth * me.tmTopoliszMap.GetMapGridItemWidth() + "px";
	    me.mainGridImageDiv.style.height = me.iHeight * me.tmTopoliszMap.GetMapGridItemHeight() + "px";		    	    
	    me.mainGridImageDivSec.style.width = me.iWidth * me.tmTopoliszMap.GetMapGridItemWidth() + "px";
	    me.mainGridImageDivSec.style.height = me.iHeight * me.tmTopoliszMap.GetMapGridItemHeight() + "px";		    	    

//
	    me.mainGridPrintImage.style.width = me.iWidth * me.tmTopoliszMap.GetMapGridItemWidth() + "px";
	    me.mainGridPrintImage.style.height = me.iHeight * me.tmTopoliszMap.GetMapGridItemHeight() + "px";

//
	    me.mainGridImage.style.width = me.iWidth * me.tmTopoliszMap.GetMapGridItemWidth() + "px";
	    me.mainGridImage.style.height = me.iHeight * me.tmTopoliszMap.GetMapGridItemHeight() + "px";	
	    me.mainGridImageSec.style.width = me.iWidth * me.tmTopoliszMap.GetMapGridItemWidth() + "px";
	    me.mainGridImageSec.style.height = me.iHeight * me.tmTopoliszMap.GetMapGridItemHeight() + "px";	
	    
	    
	    me.mainGridDistMeasureImageDiv.style.width = me.iWidth * me.tmTopoliszMap.GetMapGridItemWidth() + "px";
	    me.mainGridDistMeasureImageDiv.style.height = me.iHeight * me.tmTopoliszMap.GetMapGridItemHeight() + "px";		    	    	    	    	    
	    
	    me.tmTopoliszMap.DrawLine ();
	}  
	
	// --------------------------------------------------------------------------
	
	this.SetMainGridImage = function (urlImage, iOpacity)
	{
		if ((urlImage != "") && (urlImage != null))
		{
			me.mainGridImage.src = urlImage;
			me.mainGridPrintImage.src = urlImage;
			SetOpac (me.mainGridImageDiv, iOpacity); 
			me.mainGridImageDiv.style.visibility = "visible";
			me.mainGridDiv.style.visibility = "visible";
		}
		else
		{
			me.mainGridImage.src =  GetAbsUrl("images/transparent.gif");
			me.mainGridPrintImage.src = GetAbsUrl("images/transparent.gif");
		}
	}

	this.SetMainGridImageSec = function (urlImage, iOpacity)
	{
		if ((urlImage != "") && (urlImage != null))
		{
			me.mainGridImageSec.src = urlImage;			
			SetOpac (me.mainGridImageDivSec, iOpacity); 
			me.mainGridImageDivSec.style.visibility = "visible";
			me.mainGridDiv.style.visibility = "visible";
		}
		else
		{
			me.mainGridImageSec.src =  GetAbsUrl("images/transparent.gif");			
			me.mainGridImageDivSec.style.visibility = "hidden";
		}
	}

	this.SetMainGridDistMeasureImage = function (urlImage)
	{
	    if ((urlImage != "") && (urlImage != null))
	    {
	        me.mainGridDistMeasureImageDiv.style.backgroundImage = "url('" + urlImage + "')";
	        me.mainGridDistMeasureImageDiv.style.visibility = "visible";
	    }
	    else
	    {
		me.mainGridDistMeasureImageDiv.style.backgroundImage = "url('" + GetAbsUrl("images/transparent.gif") +"')";
	        me.mainGridDistMeasureImageDiv.style.visibility = "hidden";	    	    	    
	    }
	}
	
	// --------------------------------------------------------------------------
	
	this.HideMainGridImage = function ()
	{	    
	    me.mainGridDiv.style.visibility = "hidden";
	    me.mainGridImageDiv.style.visibility = "hidden";
	    me.mainGridImageDivSec.style.visibility = "hidden";
	}
	
    // --------------------------------------------------------------------------

	this.ShowMainGridImage = function ()
	{	
	    me.mainGridDiv.style.visibility = "visible";
	    me.mainGridImageDiv.style.visibility = "visible";
	    me.mainGridImageDivSec.style.visibility = "visible";
	}
	
    // --------------------------------------------------------------------------
	this.HideDistMeasure = function ()
	{	    
	    //me.mainGridDiv.style.visibility = "hidden";
	    me.mainGridDistMeasureImageDiv.style.visibility = "hidden";
	}
	
    // --------------------------------------------------------------------------

	this.ShowDistMeasure = function ()
	{	    
	    //me.mainGridDiv.style.visibility = "visible";
	    me.mainGridDistMeasureImageDiv.style.visibility = "visible";
	}
	
    // --------------------------------------------------------------------------
    
    // szintváltás nélkül, mozgatás hatására a grid
    // tartalmának frissitése
    
    this.StartLoad = function (iDiffTop, iDiffLeft, iNewViewOffsetY, iNewViewOffsetX)
    {            
        me.ArgLoad_DiffTop = iDiffTop;
	    me.ArgLoad_DiffLeft = iDiffLeft;

        var iNewLeft = me.iLeft + iDiffLeft;
        var iNewTop  = me.iTop + iDiffTop;
        
        if ((iDiffTop!=0) || (iDiffLeft!=0))        
        {
					var iViewDeltaX = me.tmTopoliszMap.GetMapViewWidth ();
					var iViewDeltaY = me.tmTopoliszMap.GetMapViewHeight ();
					var iGridDeltaX = me.tmTopoliszMap.GetMapGridItemWidth () * me.GetWidth();
					var iGridDeltaY = me.tmTopoliszMap.GetMapGridItemHeight () * me.GetHeight();
		    
					var Params = "";
					Params += 'iLevel=' + me.iLevel;
					Params += '&iMinRow=' + iNewTop;
					Params += '&iMinCol=' + iNewLeft;
					Params += '&iMaxRow=' + (iNewTop+me.iHeight-1);
					Params += '&iMaxCol=' + (iNewLeft+me.iWidth-1);
					Params += '&iViewDeltaX=' + iViewDeltaX;
					Params += '&iViewDeltaY=' + iViewDeltaY;
                    Params += '&iViewOffsetX=' + me.iMapViewVectorX;
                    Params += '&iViewOffsetY=' + me.iMapViewVectorY;					
					Params += '&iGridDeltaX=' + iGridDeltaX;
					Params += '&iGridDeltaY=' + iGridDeltaY;
       
          me.tmTopoliszMap.HideRoute();
          me.SetMainGridImage("", 100 );
          me.SetMainGridImageSec("", 100 );
          me.tmTopoliszMap.HidePois();          
          me.tmTopoliszMap.HideDistMeasure();
		  me.tmTopoliszMap.NoSessionServer.CallFunction("DrawRasterMap", Params, 0, me.EndLoad);
        }
        else
            me.EndLoad(null);
    }
    
    // --------------------------------------------------------------------------
    
    // EndLoad: StartLoad (DrawRasterMap) callback fuggvenye
    
    this.EndLoad = function (result, clientParam, iCommandID)
    {  
        if (result != null)
        {
            me.tmTopoliszMap.pLastStateFromServer = result;
   		    me.tmTopoliszMap.iMovingSinceLastServerStateX = 0;
		    me.tmTopoliszMap.iMovingSinceLastServerStateY = 0;		                 
        }		    
       
        var iDiffLeft = me.ArgLoad_DiffLeft;
        var iDiffTop  = me.ArgLoad_DiffTop;
        var iNewLeft = me.iLeft + iDiffLeft;
        var iNewTop  = me.iTop + iDiffTop;
        
        if (result!=null)
        {
            me.LoadedImagesTop = iNewTop;
            me.LoadedImagesLeft = iNewLeft;
            me.SetImageFileNames (result.arrUrls);            
            me.SetWgs (result.dGridLowerLeftX, result.dGridLowerLeftY, result.dGridUpperRightX, result.dGridUpperRightY);       
        }

        var StartY = 0;
        var AfterEndY = me.iHeight;
        var StartX = 0;
        var AfterEndX = me.iWidth;
        
        var iYIter=StartY;
        var iXIter=StartX;
        var YDir = "pos";
        var XDir = "pos";
        
        if (iDiffTop < 0) 
        {
            var iYIter=me.iHeight-1;       
            var YDir = "neg";
            var AfterEndY = -1;
        }

        if ((iDiffLeft < 0) && (iDiffTop >= 0)) 
        {
            var iXIter=me.iWidth-1;       
            var XDir = "neg";
            var AfterEndX = -1;
        }
               
        if ((iDiffLeft >= 0) || (iDiffTop < 0)) 
        {
	        while (iYIter != AfterEndY)
	        {
    	        while (iXIter != AfterEndX)
	            {
                    me.LoadCycleCore (iYIter, iXIter, iNewTop, iNewLeft);                    
                    if (XDir=="pos")
	                    iXIter++;
	                else
	                    iXIter--;
	            }
	            iXIter = StartX;
	            if (YDir=="pos")
	                iYIter++;
	            else
	                iYIter--;
	        }	    
	    }
	    else
        {
	        while (iXIter != AfterEndX)
	        {    	        
    	        while (iYIter != AfterEndY)
	            {
                    me.LoadCycleCore (iYIter, iXIter, iNewTop, iNewLeft);
                                        
                    if (YDir=="pos")
	                    iYIter++;
	                else
	                    iYIter--;
	            }
	            iYIter = StartY;
	            if (XDir=="pos")
	                iXIter++;
	            else
	                iXIter--;
	        }	    
	    }   
	    
        me.iLeft = iNewLeft;              
        me.iTop  = iNewTop; 
        me.MemoMoveX = 0;
        me.MemoMoveX = 0;
               
        
        me.SetMainGridDiv ();
        
        me.AllowMove = true;                 
         
        if (result!=null)
        {
            me.tmTopoliszMap.DrawRoute ();
            me.tmTopoliszMap.DrawDistMeasure();
        }
        else
        {
            me.tmTopoliszMap.RearrangePois();
        }
        
         
        // visszaszol a map-nak, hogy befejezodott a mozgatas
        if (me.sMoveCallbackOn == "true")
            me.tmTopoliszMap.MovedCallback (); 
        else if (me.sMoveCallbackOn == "rearrangeframe")
        {
            me.tmTopoliszMap.pMiniMapFrame.ReArrange ();
        }
    }
    
    // --------------------------------------------------------------------------
    
	this.Load = function (iDiffTop, iDiffLeft) 
	{
	    me.StartLoad(iDiffTop, iDiffLeft);
	}
	
	// --------------------------------------------------------------------------
		
	this.LoadCycleCore = function (iYIter, iXIter, iNewTop, iNewLeft)
	{
        var NewIdxX = iNewLeft + iXIter;
        var NewIdxY = iNewTop + iYIter;
        var OldIdxX = me.iLeft + iXIter;
        var OldIdxY = me.iTop + iYIter;
                        
        // if exists in old grid
        if (
            (NewIdxX >= me.iLeft) && 
            (NewIdxX < me.iLeft + me.iWidth) &&
            (NewIdxY >= me.iTop) && 
            (NewIdxY < me.iTop + me.iHeight))
        {
            var iPosY = me.tmTopoliszMap.GetMapGridItemHeight() * iYIter - me.iMapViewVectorY;
            var iPosX = me.tmTopoliszMap.GetMapGridItemWidth() * iXIter - me.iMapViewVectorX;
                   
            gridItemTmp = me.arrGridItems[me.GetArrayAbsCoordinate(iYIter, iXIter)];
            
            me.arrGridItems[me.GetArrayAbsCoordinate(iYIter, iXIter)] = me.arrGridItems[me.GetArrayCoordinate(NewIdxY, NewIdxX)];
            me.arrGridItems[me.GetArrayCoordinate(NewIdxY, NewIdxX)] = gridItemTmp;	                
            me.arrGridItems[me.GetArrayAbsCoordinate(iYIter, iXIter)].SetPos(iPosY,iPosX); 	                                   
        }
        else
        {
            var iPosY = me.tmTopoliszMap.GetMapGridItemHeight() * iYIter - me.iMapViewVectorY;
            var iPosX = me.tmTopoliszMap.GetMapGridItemWidth() * iXIter - me.iMapViewVectorX;
            me.arrGridItems[me.GetArrayAbsCoordinate(iYIter, iXIter)].SetPos(iPosY,iPosX);
            me.arrGridItems[me.GetArrayAbsCoordinate(iYIter, iXIter)].Set(me.iLevel,NewIdxY, NewIdxX);	                
        }
	}    
	
	// --------------------------------------------------------------------------
	
	// a terkep viewban lathato bal felso pixeleve
	// teszi a teljes logikai terkep iRow,iCol pixelet
	
    this.MoveTo = function (iRow, iCol)
    {
        var iNowAbsX = me.GetViewAbsoluteLeft();
        var iNowAbsY = me.GetViewAbsoluteTop();
        
        var iDX = iCol - iNowAbsX;
        var iDY = iRow - iNowAbsY;
        
        me.Move (iDY, iDX);
    }
    
    // --------------------------------------------------------------------------    
    
    this.MoveToCenter = function ()
    {
        var MVW = me.tmTopoliszMap.GetMapViewWidth ();   
        var MVH = me.tmTopoliszMap.GetMapViewHeight ();   
        var MH = me.tmTopoliszMap.GetMapHeight ();
        var MW = me.tmTopoliszMap.GetMapWidth ();
    
    
        me.MoveTo (Math.floor(MH/2-MVH/2), Math.floor(MW/2-MVW/2));
    }

    // --------------------------------------------------------------------------
    this.MoveNew = function (iMoveMapVectorY, iMoveMapVectorX)
    {           
	    // ha ez minimap, akkor a main map gatol-e?
	    var bMainMapAllowMove = true;
	    if (me.tmTopoliszMap.pConnectedMainMap)
	        bMainMapAllowMove = me.tmTopoliszMap.pConnectedMainMap.pGridMain.AllowMove;

	    // ha ez mainmap, akkor a mini map gatol-e?
	    var bMiniMapAllowMove = true;
	    if (me.tmTopoliszMap.pConnectedMiniMap)
	        bMiniMapAllowMove = me.tmTopoliszMap.pConnectedMiniMap.pGridMain.AllowMove;
	        
	    // a szerverkommunikacio miatt (me.AllowMove)	    
	    // me.AllowMove: true: ha nincs folyamatban move
	    
	    if (me.AllowMove && bMainMapAllowMove && bMiniMapAllowMove)	    
	    {             	    	    	    
	        me.RemoveZoomPreview ();
	        me.AllowMove = false;      
    	
            // calculate new indices and coordinates            
            
//            var iNewMapViewVectorY = me.iMapViewVectorY;
//            var iNewMapViewVectorX = me.iMapViewVectorX;

            // kilog-e az uj view a gridbol?
            
            var GIWpix = me.tmTopoliszMap.GetMapGridItemWidth ();               
            var GIHpix = me.tmTopoliszMap.GetMapGridItemHeight ();   
            var GWpix = GIWpix * me.GetWidth ();               
            var GHpix = GIHpix * me.GetHeight ();               
            var MVWpix = me.tmTopoliszMap.GetMapViewWidth ();   
            var MVHpix = me.tmTopoliszMap.GetMapViewHeight ();   
            var MHpix = me.tmTopoliszMap.GetMapHeight ();
            var MWpix = me.tmTopoliszMap.GetMapWidth ();
            var MAHpix = me.tmTopoliszMap.GetActiveHeight();
            var MAWpix = me.tmTopoliszMap.GetActiveWidth();
            var AVVOXpix = me.iMapViewVectorX + me.iLeft * GIWpix; // a mozgatas elotti view vector a terkephez kepest
            var AVVOYpix = me.iMapViewVectorY + me.iTop * GIHpix;
            var GALpix = me.iLeft * GIWpix; // grid abszolut sarkai
            var GATpix = me.iTop * GIHpix;
            var GARpix = GALpix + GWpix;
            var GABpix = GATpix + GHpix;            
            var AVVNXpix = 0; // a mozgatas utani view vector a terkephez kepest (lesz)
            var AVVNYpix = 0;            
            //var MLpix = MAWpix; // margók a felütközéshez
            //var MRpix = MAWpix;
            //var MTpix = MAHpix;
            //var MBpix = MAHpix;                       
            var MLpix = 0; // margók a felütközéshez (pozitiv szamok)
            var MRpix = 0;
            var MTpix = 0;
            var MBpix = 0;                                   
            var iNewTop = me.iTop; // az uj allapot alapbol egyenlo a regivel
            var iNewLeft = me.iLeft;   
            var iNewMapViewVectorY = me.iMapViewVectorY;
            var iNewMapViewVectorX = me.iMapViewVectorX;
                                             
            //  AVVOXpix, AVVOYpix    
            var _AVVNXpix, _AVVNYpix;
            _AVVNXpix = AVVOXpix + iMoveMapVectorX;
            
            if (MVWpix < MAWpix)
            {                                
                if (_AVVNXpix < -MLpix) _AVVNXpix = -MLpix;
                if (_AVVNXpix > MAWpix + MRpix - MVWpix) _AVVNXpix = MAWpix + MRpix - MVWpix;
            }
            else
            {                                
                if (_AVVNXpix > MLpix) _AVVNXpix = MLpix;
                if (_AVVNXpix < MAWpix - MRpix - MVWpix) _AVVNXpix = MAWpix - MRpix - MVWpix;            
            }
            
            AVVNXpix = _AVVNXpix;
            _AVVNYpix = AVVOYpix + iMoveMapVectorY;
            
            if (MVHpix < MAHpix)
            {                                
                if (_AVVNYpix < -MTpix) _AVVNYpix = -MTpix;
                if (_AVVNYpix > MAHpix + MBpix - MVHpix) _AVVNYpix = MAHpix + MBpix - MVHpix;
            }
            else
            {                                
                if (_AVVNYpix > MTpix) _AVVNYpix = MTpix;
                if (_AVVNYpix < MAHpix - MBpix - MVHpix) _AVVNYpix = MAHpix - MBpix - MVHpix;            
            }
            
            AVVNYpix = _AVVNYpix;
                        
            if (
                (GALpix < AVVNXpix) && 
                (GARpix > AVVNXpix) && 
                (GATpix < AVVNYpix) && 
                (GABpix > AVVNYpix) &&                
                (GALpix < AVVNXpix + MVWpix) && 
                (GARpix > AVVNXpix + MVWpix) && 
                (GATpix < AVVNYpix + MVHpix) && 
                (GABpix > AVVNYpix + MVHpix)                
               )
            {
                iNewMapViewVectorX = AVVNXpix - GALpix;              
                iNewMapViewVectorY = AVVNYpix - GATpix;              
            }         
            else
            {
                var ax = Math.floor (AVVNXpix / GIWpix);
                var bx = Math.floor ((GWpix - MVWpix) / (GIWpix * 2));                
                iNewLeft = ax - bx;
                iNewMapViewVectorX = AVVNXpix - (iNewLeft * GIWpix);                

                var cx = Math.floor (AVVNYpix / GIHpix);
                var dx = Math.floor ((GHpix - MVHpix) / (GIHpix * 2));                
                iNewTop = cx - dx;
                iNewMapViewVectorY = AVVNYpix - (iNewTop * GIHpix);                                
            }                                                       

            // =======================================================================
                              
            // iMovingSinceLastServerState: load-nal ugyis nullazodik 
	   		me.tmTopoliszMap.iMovingSinceLastServerStateX += (iNewMapViewVectorX - me.iMapViewVectorX);
    		me.tmTopoliszMap.iMovingSinceLastServerStateY -= (iNewMapViewVectorY - me.iMapViewVectorY);    		    		    		
                               
	                                           
            if (me.bCanMoveX && me.bCanMoveY)
            {
                me.iMapViewVectorY = iNewMapViewVectorY;
                me.iMapViewVectorX = iNewMapViewVectorX;                                       
                me.Load(iNewTop - me.iTop, iNewLeft - me.iLeft);
            }
            else if (me.bCanMoveX)
            {
                me.iMapViewVectorX = iNewMapViewVectorX;          
                me.Load(0, iNewLeft - me.iLeft);                             
            }
            else if (me.bCanMoveY)
            {
                me.iMapViewVectorY = iNewMapViewVectorY;          
                me.Load(iNewTop - me.iTop, 0);                             
            }
            else
            {
                if (me.tmTopoliszMap.pMiniMapFrame)
                    me.tmTopoliszMap.pMiniMapFrame.ReArrange ();
                
                me.AllowMove = true;
            }            
        }    
    }
    // --------------------------------------------------------------------------

	this.Move = function (iMoveMapVectorY, iMoveMapVectorX)
	{	 
	    var bRealMoveHappened = false;

	    //me.MoveNew (iMoveMapVectorY, iMoveMapVectorX);
	    //return;
	       
	    // ha ez minimap, akkor a main map gatol-e?
	    var bMainMapAllowMove = true;
	    if (me.tmTopoliszMap.pConnectedMainMap)
	        bMainMapAllowMove = me.tmTopoliszMap.pConnectedMainMap.pGridMain.AllowMove;

	    // ha ez mainmap, akkor a mini map gatol-e?
	    var bMiniMapAllowMove = true;
	    if (me.tmTopoliszMap.pConnectedMiniMap)
	        bMiniMapAllowMove = me.tmTopoliszMap.pConnectedMiniMap.pGridMain.AllowMove;
	        
	    // a szerverkommunikacio miatt (me.AllowMove)	    
	    // me.AllowMove: true: ha nincs folyamatban move
	    
	    if (me.AllowMove && bMainMapAllowMove && bMiniMapAllowMove)	    
	    {             	    	    	    
	        me.RemoveZoomPreview ();
	        me.AllowMove = false;      
    	
            // calculate new indices and coordinates            
            
            var iNewMapViewVectorY = me.iMapViewVectorY;
            var iNewMapViewVectorX = me.iMapViewVectorX;

            // kilog-e az uj view a gridbol?
            
            var GIW = me.tmTopoliszMap.GetMapGridItemWidth ();               
            var GIH = me.tmTopoliszMap.GetMapGridItemHeight ();   
            var GW = GIW * me.GetWidth ();               
            var GH = GIH * me.GetHeight ();               
            var MVW = me.tmTopoliszMap.GetMapViewWidth ();   
            var MVH = me.tmTopoliszMap.GetMapViewHeight ();   
            var MH = me.tmTopoliszMap.GetMapHeight ();
            var MW = me.tmTopoliszMap.GetMapWidth ();
            var MAH = me.tmTopoliszMap.GetActiveHeight();
            var MAW = me.tmTopoliszMap.GetActiveWidth();
                        
            
            var iFullVectorX = me.iMapViewVectorX + iMoveMapVectorX;
            var iFullVectorY = me.iMapViewVectorY + iMoveMapVectorY;
            var iMinCoordX = 0;
            var iMinCoordY = 0;
            var iMaxCoordX = GIW * me.GetWidth() - MVW;
            if (iMaxCoordX < 0) iMaxCoordX = 0;
            var iMaxCoordY = GIH * me.GetHeight() - MVH;
            if (iMaxCoordY < 0) iMaxCoordY = 0;

            var iNewTop = me.iTop;
            var iNewLeft = me.iLeft;
            
            var bHangOut = false;
            if ((iFullVectorX < iMinCoordX) || (iFullVectorX > iMaxCoordX) || (iFullVectorY < iMinCoordY) || (iFullVectorY > iMaxCoordY))
            {
                bHangOut = true;
            }
                        
            // elmozgatas utan a valtozatlan gridben maradunk
            if (!bHangOut)
            {     
                var iMaxMapViewVectorY = Math.min (GH + me.iTop * GIH, MH) - MVH - GIH * me.iTop;
                iNewMapViewVectorY = Math.min (iMaxMapViewVectorY, iFullVectorY);
                var iMaxMapViewVectorX = Math.min (GW + me.iLeft * GIW, MW) - MVW - GIW * me.iLeft;
                iNewMapViewVectorX = Math.min (iMaxMapViewVectorX, iFullVectorX);                
            }
            else
            {                
                var cx = iFullVectorX + GIW * me.iLeft;
                var maxcx = MW - MVW;
                if (cx > maxcx) cx = maxcx;
                if (cx < 0 ) 
                {
                    iNewLeft = 0;
                    iNewMapViewVectorX = 0;                                                
                }
                else
                {                
                    var ax = Math.floor (cx / GIW);
                    var bx = Math.floor ((GW - MVW) / (GIW * 2));
                    
                    iNewLeft = ax - bx;
                    iNewMapViewVectorX = cx - ((ax - bx) * GIW);                
                    if (iNewLeft < 0)
                    {
                        iNewMapViewVectorX += iNewLeft * GIW;
                        iNewLeft = 0;                      
                    }
                }
                
                // --------------------------------------------------------
                
                var cy = iFullVectorY + GIH * me.iTop;
                var maxcy = MH - MVH;
                if (cy > maxcy) cy = maxcy;
                if (cy < 0 ) 
                {
                    iNewTop = 0;
                    iNewMapViewVectorY = 0;                                
                }
                else
                {
                    var ay = Math.floor (cy / GIH);
                    var by = Math.floor ((GH - MVH) / (GIH * 2));
                
                    iNewTop = ay - by;
                    iNewMapViewVectorY = cy - ((ay - by) * GIH);   
                    
                    if (iNewTop < 0)
                    {
                        iNewMapViewVectorY += iNewTop * GIH;
                        iNewTop = 0;                      
                    }
                                 
                }
            }
                              
            if (me.bCanMoveX || me.bCanMoveY)                              
            {
                // iMovingSinceLastServerState: load-nal ugyis nullazodik 
	   			me.tmTopoliszMap.iMovingSinceLastServerStateX += (iNewMapViewVectorX - me.iMapViewVectorX);
    		    me.tmTopoliszMap.iMovingSinceLastServerStateY -= (iNewMapViewVectorY - me.iMapViewVectorY);    		    		    		
    	    }
                               
                                          
            if (me.bCanMoveX && me.bCanMoveY)
            {
                if ((me.iMapViewVectorY != iNewMapViewVectorY) ||
                    (me.iMapViewVectorX != iNewMapViewVectorX) || 
                    (iNewTop != me.iTop) || (iNewLeft != me.iLeft ))
                {
                   bRealMoveHappened = true; 
                }
            
                me.iMapViewVectorY = iNewMapViewVectorY;
                me.iMapViewVectorX = iNewMapViewVectorX;                                       
                me.Load(iNewTop - me.iTop, iNewLeft - me.iLeft);
            }
            else if (me.bCanMoveX)
            {
                if ((me.iMapViewVectorX != iNewMapViewVectorX) || 
                    (iNewLeft != me.iLeft ))
                {
                   bRealMoveHappened = true; 
                }                
            
                me.iMapViewVectorX = iNewMapViewVectorX;          
                me.Load(0, iNewLeft - me.iLeft);                             
            }
            else if (me.bCanMoveY)
            {
                if ((me.iMapViewVectorY != iNewMapViewVectorY) || 
                    (iNewTop != me.iTop ))
                {
                   bRealMoveHappened = true; 
                }                
            
                me.iMapViewVectorY = iNewMapViewVectorY;          
                me.Load(iNewTop - me.iTop, 0);                             
            }
            else
            {
                if (me.tmTopoliszMap.pMiniMapFrame)
                    me.tmTopoliszMap.pMiniMapFrame.ReArrange ();
                
                me.AllowMove = true;
            }                     
        }
	return bRealMoveHappened;
    }

    // --------------------------------------------------------------------------
    // fuggvenyek az utkozes vizsgalatahoz
    // --------------------------------------------------------------------------
    
    this.GetLastTileIndexX = function ()
    {
        return Math.ceil(me.tmTopoliszMap.GetMapWidth() / me.tmTopoliszMap.GetMapGridItemWidth()) - 1;
    }   
    
    // --------------------------------------------------------------------------
    
    this.GetLastTileIndexY = function ()
    {
        return Math.ceil(me.tmTopoliszMap.GetMapHeight() / me.tmTopoliszMap.GetMapGridItemHeight()) - 1;
    }     
    
    // --------------------------------------------------------------------------
    
    this.GetMaxGridItemIndexX = function ()
    {
        var LastTileIdxX = me.GetLastTileIndexX ();
        var ViewWidthInGrid = me.tmTopoliszMap.GetMapViewWidth() / me.tmTopoliszMap.GetMapGridItemWidth();        
        var MaxGridItemIdxX = LastTileIdxX - Math.ceil (ViewWidthInGrid) - me.i_gWbase + 1;
        return MaxGridItemIdxX;
    }
    
    // --------------------------------------------------------------------------
   
    this.GetMaxMapViewVectorX = function ()
    {
        var i_pGridW = me.tmTopoliszMap.GetMapGridItemWidth();
        var i_pWbase = me.i_gWbase * i_pGridW; 
        var ViewWidthInGrid = me.tmTopoliszMap.GetMapViewWidth() / me.tmTopoliszMap.GetMapGridItemWidth();
        var ExtX = (1+Math.floor (ViewWidthInGrid)-ViewWidthInGrid) * me.tmTopoliszMap.GetMapGridItemWidth();          
        var MaxMapViewVectorX = i_pWbase + ExtX;
        return MaxMapViewVectorX;
    }
    
    // --------------------------------------------------------------------------
    
    this.GetMaxGridItemIndexY = function ()
    {
        var LastTileIdxY = me.GetLastTileIndexY();
        var ViewHeightInGrid = me.tmTopoliszMap.GetMapViewHeight() / me.tmTopoliszMap.GetMapGridItemHeight();        
        var MaxGridItemIdxY = LastTileIdxY - Math.ceil (ViewHeightInGrid) - me.i_gHbase + 1;
        return MaxGridItemIdxY;
    }
   
    // --------------------------------------------------------------------------
    
    this.GetMaxMapViewVectorY = function ()
    {
        var i_pGridH = me.tmTopoliszMap.GetMapGridItemHeight();
        var i_pHbase = me.i_gHbase * i_pGridH; 
        var ViewHeightInGrid = me.tmTopoliszMap.GetMapViewHeight() / me.tmTopoliszMap.GetMapGridItemHeight();            
        var ExtY = (1+Math.floor (ViewHeightInGrid)-ViewHeightInGrid) * me.tmTopoliszMap.GetMapGridItemHeight();          
        var MaxMapViewVectorY = i_pHbase + ExtY;
        return MaxMapViewVectorY;
    }
    
    // --------------------------------------------------------------------------
        
    // a view bal felso pixelenek koordinataja a teljes terkep pixel koordinata rendszereben
    
    this.GetViewAbsoluteTop = function ()
    {
        return me.tmTopoliszMap.GetMapGridItemHeight() * me.iTop + me.iMapViewVectorY;
    }
    
    // --------------------------------------------------------------------------
    
    this.GetViewAbsoluteLeft = function ()
    {
        return me.tmTopoliszMap.GetMapGridItemWidth() * me.iLeft + me.iMapViewVectorX;
    }
    
    // beallitja, hogy a view bal-felso pontjaba a teljes terkep melyik pixele keruljon
    this.MoveToAbsolutePos = function (iPosY, iPosX)
    {
        var DY = me.GetViewAbsoluteTop();
        var DX = me.GetViewAbsoluteLeft();
        me.Move (iPosY-DY,iPosX-DX);
    }
    
    // --------------------------------------------------------------------------

    this.ZoomPreviewOld = function (dZoomFactor, iBasePointX, iBasePointY)
    {
        me.RemoveZoomPreview ();
        var Idx = 1;
    	for(var iYIter = me.iTop; iYIter < me.iTop + me.iHeight; iYIter++)
	    {
    	    for(var iXIter = me.iLeft; iXIter < me.iLeft + me.iWidth; iXIter++)
	        {
	        	var image = me.arrGridItems [me.GetArrayCoordinate(iYIter, iXIter)].img;	
	        	
	        	if (image != null)
	        	{
	        	    //if (image.parentNode != null)
	        	    {
	        	        var oldLeft = GetLayerLeft(image.parentNode);  
	        	        var oldTop = GetLayerTop(image.parentNode);        
	        	        var oldHeight =  GetLayerHeight(image); 
	        	        var oldWidth = GetLayerWidth(image);
	        	        
	        	        // kis igazitasok ...
	        	        var iVertVector = 4;
	        	        var iHorizVector = 4;
        	        	
	                    image.className = "mapPreview";
	                    image.id = Idx;
	                    Idx++;	   
	                    image.style.visibility = "hidden";                
	                    image.style.position = "absolute";    
	                    image.style.top = Math.floor(((oldTop-iBasePointY)*dZoomFactor+iBasePointY+iVertVector))+ "px";
	                    image.style.left = Math.floor(((oldLeft-iBasePointX)*dZoomFactor+iBasePointX+iHorizVector))+ "px";	    
	                    image.style.width = Math.floor((oldWidth * dZoomFactor)) + "px";
	                    image.style.height = Math.floor((oldHeight * dZoomFactor)) + "px";
        	            
                        image.parentNode.removeChild (image);        
	                    me.tmTopoliszMap.divMap.appendChild (image);
    	                
	                    me.arrGridItems [me.GetArrayCoordinate(iYIter, iXIter)].img = null;

	                    image.style.visibility = "visible";
	                    StopAnyEvent (image);
	                }
	            }
	        }
	    }	
	    me.MoveBackZoomPreview ();     
    }
    
    this.ZoomPreview = function (dZoomFactor, iBasePointX, iBasePointY, iPreviewMoveX, iPreviewMoveY)
    {
        me.ZoomPreview2 (dZoomFactor, iBasePointX, iBasePointY, iPreviewMoveX, iPreviewMoveY);
    }
    
    // --------------------------------------------------------------------------
    
    this.RemoveZoomPreview = function ()
    {
        var Idx = 1;
        var fc = me.tmTopoliszMap.divMap.firstChild;
        var s = fc;
        
        while (s)
        {
            var ns = s.nextSibling;
            if (s.className == "mapPreview")
            {
                s.style.visibility = "hidden";
                me.tmTopoliszMap.divMap.removeChild (s);
            }
                
            s = ns;
        }
    }
    
    // --------------------------------------------------------------------------
    
    this.ZoomPreviewPhase = function ()
    {
        var i;
        for (i = 0; i < me.zoomPreviewAnim_Images.length; i++)
        {
            var oldTop = me.zoomPreviewAnim_Tops[i];
            var oldLeft = me.zoomPreviewAnim_Lefts[i];
            var oldWidth = me.zoomPreviewAnim_ImageWidth;
            var oldHeight = me.zoomPreviewAnim_ImageHeight;
            var iBasePointX = me.zoomPreviewAnim_BasePointX;
            var iBasePointY = me.zoomPreviewAnim_BasePointY;
            var iPreviewEMoveX = me.zoomPreviewAnim_MoveX;
            var iPreviewEMoveY = me.zoomPreviewAnim_MoveY;

            
            var DZF = me.zoomPreviewAnim_ZoomFactor; // az elerendo zoom faktor
            var PN = me.zoomPreviewAnim_PhasesNum;
            var PL = me.zoomPreviewAnim_PhasesLeft;
            var PAN = PN - PL; // aktuális fázis száma
            
            var dZoomFactor = 1 + ((DZF - 1) / PN) * PAN;
            
            var iStartOpac = 100;
            var iEndOpac = 100;            
            
            var iActOpac;            
            iActOpac = ((iEndOpac - iStartOpac) / PN) * PAN + iStartOpac;
            
            var image = me.zoomPreviewAnim_Images[i];
            // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
            //SetOpac (image, iActOpac);            
            // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
            image.style.visibility = "hidden";
            image.style.top = Math.round(((oldTop - iBasePointY) * dZoomFactor+iBasePointY))+ (iPreviewEMoveY*PAN) +"px";
            image.style.left = Math.round(((oldLeft - iBasePointX) * dZoomFactor+iBasePointX))+ (iPreviewEMoveX*PAN)+"px";	  
            var iw =  Math.round((oldWidth * dZoomFactor)); 
            var ih =  Math.round((oldHeight * dZoomFactor)); 
            image.style.width = iw + "px";
            image.style.height = ih  + "px";
            me.zoomPreviewAnim_Images_Width[i] = iw;
            me.zoomPreviewAnim_Images_Height[i] = ih;
            image.style.visibility = "visible";

        }
        
        me.zoomPreviewAnim_PhasesLeft--;
        if ( me.zoomPreviewAnim_PhasesLeft > 0)
            window.setTimeout (me.ZoomPreviewPhase, 5);
        else
        {  
            me.MoveBackZoomPreview ();
            me.RemoveZoomPreview ();
        }
    }
    
    this.MoveBackZoomPreview = function ()
    {
        if (me.zoomPreviewAnim_Images!=null)
        {
            var i;
            for (i = 0; i < me.zoomPreviewAnim_Images.length; i++)
            {
                var image = me.zoomPreviewAnim_Images[i];
                image.style.zIndex = 3;            
            }        
        }
    }
    
    // dZoomFactor: hanyszoros nagyitas
    // viewban hova:iBasePointX, iBasePointY
    // eltolas a zoomban (az eredmenyezett zoom levelben) : iPreviewMoveX, iPreviewMoveY
    
    this.ZoomPreview2 = function (dZoomFactor, iBasePointX, iBasePointY, iPreviewMoveX, iPreviewMoveY)
    {
		if (me.arrGridItems [0].img == null)
			return;
			
        me.RemoveZoomPreview ();
        
        if (me.zoomPreviewAnim_Images!=null)
        {
            var i;
            for (i = 0; i < me.zoomPreviewAnim_Images.length; i++)
            {
                delete me.zoomPreviewAnim_Images[i];   
                me.zoomPreviewAnim_Images[i] = null;
                me.zoomPreviewAnim_Images_Width[i] = null;
                me.zoomPreviewAnim_Images_Height[i] = null;
            }
            delete me.zoomPreviewAnim_Images;
            delete me.zoomPreviewAnim_Images_Width;
            delete me.zoomPreviewAnim_Images_Height;
            me.zoomPreviewAnim_Images = null;
            me.zoomPreviewAnim_Images_Width = null;
            me.zoomPreviewAnim_Images_Height = null;
        }

        if (me.zoomPreviewAnim_Tops!=null)
        {
            delete me.zoomPreviewAnim_Tops;
            me.zoomPreviewAnim_Tops = null;
        }
        
        if (me.zoomPreviewAnim_Lefts!=null)
        {
            delete me.zoomPreviewAnim_Lefts;
            me.zoomPreviewAnim_Lefts = null;
        }
        
        
        me.zoomPreviewAnim_Images = new Array ();
        me.zoomPreviewAnim_Images_Width = new Array ();
        me.zoomPreviewAnim_Images_Height = new Array ();
        me.zoomPreviewAnim_Tops = new Array ();
        me.zoomPreviewAnim_Lefts = new Array ();
        
        // ------------------------------------------
        
        me.zoomPreviewAnim_ImageHeight = null;
        me.zoomPreviewAnim_ImageWidth = null;
        me.zoomPreviewAnim_ZoomFactor = dZoomFactor;
        me.zoomPreviewAnim_BasePointX = iBasePointX;
        me.zoomPreviewAnim_BasePointY = iBasePointY;
        me.zoomPreviewAnim_PhasesLeft = 10;
        me.zoomPreviewAnim_PhasesNum = 10;        
        me.zoomPreviewAnim_MoveX = iPreviewMoveX / me.zoomPreviewAnim_PhasesNum * me.zoomPreviewAnim_ZoomFactor;
        me.zoomPreviewAnim_MoveY = iPreviewMoveY / me.zoomPreviewAnim_PhasesNum * me.zoomPreviewAnim_ZoomFactor;                
        
        var imwidth = GetLayerWidth(me.arrGridItems [0].img);
        var imheight = GetLayerHeight(me.arrGridItems [0].img);
         
        var Idx = 1;
    	for(var iYIter = me.iTop; iYIter < me.iTop + me.iHeight; iYIter++)
	    {
    	    for(var iXIter = me.iLeft; iXIter < me.iLeft + me.iWidth; iXIter++)
	        {
				var arrc = me.GetArrayCoordinate(iYIter, iXIter);
	        	var image = me.arrGridItems [arrc].img;		        		        	
	        	
	        	if (image != null)
	        	{
	        	    me.zoomPreviewAnim_Images [me.zoomPreviewAnim_Images.length] = image;
	        	    me.zoomPreviewAnim_Tops [me.zoomPreviewAnim_Tops.length] = GetLayerTop(image.parentNode);  
	        	    me.zoomPreviewAnim_Lefts [me.zoomPreviewAnim_Lefts.length] = GetLayerLeft(image.parentNode);
	        	    //me.zoomPreviewAnim_Images_Width[arrc] = GetLayerWidth(image);;
	        	    //me.zoomPreviewAnim_Images_Height[arrc] = GetLayerHeight(image);
	        	    // gyorsitas vegett feltetelezzuk, hogy egyformak a grid kepek meretei:
	        	    
	        	    me.zoomPreviewAnim_Images_Width[arrc] = imwidth;
	        	    me.zoomPreviewAnim_Images_Height[arrc] = imheight;	        	    	        	    
                    me.zoomPreviewAnim_ImageWidth = imwidth;
                    me.zoomPreviewAnim_ImageHeight = imheight;
	        	    
                    image.className = "mapPreview";
                    image.id = Idx;
                    Idx++;	   
                    image.style.visibility = "hidden";                
                    image.style.position = "absolute";    
                        	            
                    image.parentNode.removeChild (image);        
                    me.tmTopoliszMap.divMap.appendChild (image);	                
                    me.arrGridItems [me.GetArrayCoordinate(iYIter, iXIter)].img = null;
                    image.style.visibility = "visible";
                    StopAnyEvent (image);
	            }
	        }
	    }
	    
	    //window.setTimeout (me.ZoomPreviewPhase, 5);
	    me.ZoomPreviewPhase();
	    
    }


// ==================================    
    
    this.Hide = function ()
    {
    	for(var iYIter = me.iTop; iYIter < me.iTop + me.iHeight; iYIter++)
	    {
    	    for(var iXIter = me.iLeft; iXIter < me.iLeft + me.iWidth; iXIter++)
	        {
	        	var image = me.arrGridItems [me.GetArrayCoordinate(iYIter, iXIter)].img;
	        	    image.style.visibility = "hidden";
	        }
	    }	         
    }
}


