void CZeldaEditorView::UpdateScrollSizes()
{
  //Set new scroll sizes based on map size and current cellsize
  //or grid size  
  CSize size;

  //Get pointer to document class for map info
  CZeldaEditorDoc *pDoc=(CZeldaEditorDoc *)GetDocument();
  size.cx=pDoc->m_iMapSizeX*m_iGridSize;
  size.cy=pDoc->m_iMapSizeY*m_iGridSize;
  SetScrollSizes(MM_TEXT,size);

  //Retrieve width and height of client rect
  CRect rect;
  GetClientRect(&rect);
 
  int mapx=pDoc->m_iMapSizeX;
  int mapy=pDoc->m_iMapSizeY;
  int maxx=pDoc->m_iMapSizeX*m_iGridSize;
  int maxy=pDoc->m_iMapSizeY*m_iGridSize;

  //Set max scroll
  m_iMaxScrollX=(m_iGridSize*(mapx-1))-rect.Width();
  m_iMaxScrollY=(m_iGridSize*mapy)-rect.Height();
  
  //Don't show borders
  if (m_iMaxScrollX<0) m_iMaxScrollX=0;
  if (m_iMaxScrollY<0) m_iMaxScrollY=0;
  
  //If map size won't fit in window because map is too small
  //Re-adjust cell size so map fits perfectly in window
  if (rect.Width()>=maxx-m_iGridSize) 
  {
    m_iGridSize=rect.Width()/mapx;
    m_iScrollX=-m_iMaxScrollX;
    m_iScrollY=-m_iMaxScrollY;
  }

}

//Transforms mouse clicks to always click on nearest tile
//to cursor regardless of zoom and scroll
void CZeldaEditorView::TransformMouseXY(CPoint mouse,CRect &rect,DWORD &offset)
{
  //Find out remainder of m_iScrollX/m_iGridSize
  int offsetx=(m_iScrollX % m_iGridSize);
  int offsety=(m_iScrollY % m_iGridSize);

  //Temporaries so I don't have to use mouse.x, mouse.y every
  //time
  int mx=mouse.x;
  int my=mouse.y;

  //Subtract mouse by offsets
  mx-=offsetx;
  my-=offsety;

  //Snap to grid size
  mx-=(mx % m_iGridSize);
  my-=(my % m_iGridSize);

  //Re-adjust on-screen rect to new grid rectangle
  rect.left=mx+offsetx;
  rect.top=my+offsety;
  rect.right=mx+m_iGridSize+offsetx;
  rect.bottom=my+m_iGridSize+offsety;

  //Compute actual memory location of grid clicked
  int MemoryX=(mouse.x - m_iScrollX)/m_iGridSize;
  int MemoryY=(mouse.y - m_iScrollY)/m_iGridSize;

  //Set offset in document
  CZeldaEditorDoc *ptrDoc=(CZeldaEditorDoc *)GetDocument();
  offset=MemoryY*ptrDoc->m_iMapSizeX+MemoryX;

}

void CZeldaEditorView::OnDraw(CDC* pDC)
{
  //Pointer to document class
  CZeldaEditorDoc* pDoc = (CZeldaEditorDoc *)GetDocument();
  //Pointer to frame clasee
  CMainFrame *ptrFrame=(CMainFrame *)AfxGetMainWnd();
  //Number of maps (layers)
  DWORD numMaps=pDoc->m_pMapManager->GetNumberOfMaps();

  //Handle to destination DC
  HDC dcDest=pDC->GetSafeHdc();
    
  //Black brush for drawing
  CBrush blackbrush;
  blackbrush.CreateSolidBrush(RGB(0,0,0));
  
  //Retrieve client rect
  CRect ScreenRect;
  GetClientRect(&ScreenRect);

  //Fill it with black
  pDC->FillRect(&ScreenRect,&blackbrush);

  //Check for tile manager and map count
  //Don't draw if null or maps=0
  if (pDoc->m_pTileManager && numMaps>1)
  {
    //Tile size from bitmap
    int TileSize=pDoc->m_iTileSize;

    //Horizontal offset - debug info
    int iOffsetHoriz=abs(m_iScrollX/m_iGridSize);

    //Vertical offset - debug info
    int iOffsetVert=abs(m_iScrollY/m_iGridSize);

     //Function to compute relative to center of screenrect
     //Algos don't work right with this yet
    //ComputeStartGrid();
    
    //Iterate through maps
    //m_dwStartMapNum  is starting map
    //m_dwEndMapNum is ending map
    //To view one layer set start to layer and end to start+1
    for (DWORD map=m_dwStartMapNum;map<m_dwEndMapNum;map++)
    {

      //Get pointer to map
      CMap *ptrMap=pDoc->m_pMapManager->GetMapClass(map);

      //Get pointer to movement map - disabled
     //CMap *ptrMove=pDoc->m_pMapManager->GetMapClass(0);
   
      //Screen calculations for memory offset
      int CurrentY=(-m_iScrollY/m_iGridSize);
      int CurrentX=(-m_iScrollX/m_iGridSize);

      //Remember CurrentX before it changes
      int OriginX=CurrentX;

      //Compute memory offset
      DWORD offset=CurrentY*pDoc->m_iMapSizeX+CurrentX;
      int offsetx=m_iScrollX % m_iGridSize;
      int offsety=m_iScrollY % m_iGridSize;
  
      //Save starting offset
      DWORD startoffset=offset;

     //Rect for grid display - if enabled 
     CRect GridRect;
     

      //Draw the map finally
      for (int i=offsety;i<ScreenRect.bottom;i+=m_iGridSize)
      {
        for (int j=offsetx;j<ScreenRect.right;j+=m_iGridSize)
        {
          
          //Retrieve ID from map            
          DWORD ID=ptrMap->GetValueAtOffset(offset);
          
          //If this block is not empty          
          if (ID!=0xFFFFFFFF)
          {
            //Get DC of tile bitmap from tile manager
            CDC *tempDC=pDoc->m_pTileManager->GetTileDC(ID);

            //Get handle to tile bitmap DC
            HDC dcSource=tempDC->GetSafeHdc();

            //Get transparent color of tile
            UINT dwTransColor=pDoc->m_pTileManager->GetTransColor(ID);
            
          //Do a transparent blit
          ::TransparentBlt(dcDest,
                             j,i,
                             m_iGridSize,m_iGridSize,
                             dcSource,
                             0,0,
                             TileSize,TileSize,
                             dwTransColor);
          }

          //Draw the grid
          GridRect.left=j;
          GridRect.top=i;
          GridRect.right=j+m_iGridSize;
          GridRect.bottom=i+m_iGridSize;
          
          //If view->Grid checked then draw grid
          if (m_bGrid) 
          {
                      
            CBrush gridbrush;
            gridbrush.CreateSolidBrush(RGB(255,255,255));

            pDC->FrameRect(&GridRect,&gridbrush);
          }

          //Increment offset into memory                 
          offset++;
          
          //Increment cell column counter
          CurrentX++;

          //If column is at width of map break
          if (CurrentX>=pDoc->m_iMapSizeX-1) break;
        }
          //Set column counter to origin 
          CurrentX=OriginX;

          //Increment startoffset by one row
          startoffset+=pDoc->m_iMapSizeX;

          //Save startoffset
          offset=startoffset;

          //Increment row counter
          CurrentY++;

          //If no more rows, break
          if (CurrentY>pDoc->m_iMapSizeY-1) break;     
      }
    }
  }

}