// JPEG2000View.cpp : implementation of the CJPEG2000View class
//

#include "stdafx.h"
#include "JPEG2000.h"

#include "JPEG2000Doc.h"
#include "JPEG2000View.h"

#include "MainFrm.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

extern CJPEG2000App theApp;

L_INT L_FAR L_EXPORT FileReadCallBack(pFILEINFO pFileInfo,
                                      pBITMAPHANDLE pBitmap,
                                      L_UCHAR L_FAR *pBuffer,
                                      L_UINT uFlags,
                                      L_INT nRow,
                                      L_INT nLines,
                                      L_VOID L_FAR * pData);

/////////////////////////////////////////////////////////////////////////////
// CJPEG2000View


IMPLEMENT_DYNCREATE(CJPEG2000View, CScrollView)

BEGIN_MESSAGE_MAP(CJPEG2000View, CScrollView)
	//{{AFX_MSG_MAP(CJPEG2000View)
   ON_MESSAGE(WM_DOREALIZE, OnDoRealize)
	ON_WM_HSCROLL()
	ON_WM_VSCROLL()
	ON_COMMAND(ID_VIEW_NORMAL, OnViewNormal)
	ON_UPDATE_COMMAND_UI(ID_VIEW_NORMAL, OnUpdateViewNormal)
	ON_COMMAND(ID_VIEW_FITIMAGETOWINDOW, OnViewFitimagetowindow)
   ON_UPDATE_COMMAND_UI(ID_VIEW_FITIMAGETOWINDOW, OnUpdateViewFitimagetowindow)
	ON_COMMAND(ID_VIEW_SNAPWINDOWTOIMAGE, OnViewSnapwindowtoimage)
	ON_UPDATE_COMMAND_UI(ID_VIEW_SNAPWINDOWTOIMAGE, OnUpdateViewSnapwindowtoimage)
	ON_COMMAND(ID_VIEW_ZOOMIN2X, OnViewZoomin2x)
	ON_COMMAND(ID_VIEW_ZOOMOUT2X, OnViewZoomout2x)
	ON_WM_SIZE()
	ON_WM_ERASEBKGND()
	ON_WM_SETFOCUS()
	ON_WM_KILLFOCUS()
	ON_WM_LBUTTONDOWN()
	ON_WM_LBUTTONUP()
	ON_WM_MOUSEMOVE()
	ON_WM_TIMER()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()


/*****************************************************************************/
/*
/*****************************************************************************/
L_VOID SetImageDataDefaults(LPIMAGEDATA lpImageData)
{
   lpImageData->bFitImage     = TRUE; //bFitToWindow;   //if TRUE then fit image to window 
   lpImageData->cxClient      = 0;              //width of client area 
   lpImageData->cyClient      = 0;              //height of client area 
   SetRect(&lpImageData->rcView, 0, 0, 0, 0);
   lpImageData->pBitmap = NULL;
   lpImageData->pointStart.x = 0;
   lpImageData->pointStart.y = 0;
}

/*****************************************************************************/
/*
/*****************************************************************************/
L_INT32 XClientToBitmap(LPIMAGEDATA pImageData, int x)
{
   x = (L_INT)((L_INT32)(x-pImageData->rcView.left)*BITMAPWIDTH(pImageData->pBitmap)/RECTWIDTH(&pImageData->rcView));
   return x;
}

/*****************************************************************************/
/*
/*****************************************************************************/
L_INT32 YClientToBitmap(LPIMAGEDATA pImageData, int y)
{
   y = (L_INT)((L_INT32)(y-pImageData->rcView.top)*BITMAPHEIGHT(pImageData->pBitmap)/RECTHEIGHT(&pImageData->rcView));
   return y;
}

/*****************************************************************************/
/*
/*****************************************************************************/
static L_INT32 XClientToBitmapInverse(LPIMAGEDATA pImageData, int x)
{
   L_INT32 xNew;
   xNew = x * RECTWIDTH(&pImageData->rcView)/BITMAPWIDTH(pImageData->pBitmap) + pImageData->rcView.left;
   return xNew;
}

/*****************************************************************************/
/*
/*****************************************************************************/
static L_INT32 YClientToBitmapInverse(LPIMAGEDATA pImageData, int y)
{
   L_INT32 yNew;
   yNew = y * RECTHEIGHT(&pImageData->rcView)/BITMAPHEIGHT(pImageData->pBitmap) + pImageData->rcView.top;
   return yNew;
}

/*****************************************************************************/
/*
/*****************************************************************************/
L_VOID PixelizePoint(LPIMAGEDATA lpImageData, L_INT32 *px, L_INT32 *py, L_INT32 *pXBitmap, L_INT32 *pYBitmap)
{
   *pXBitmap    = XClientToBitmap(lpImageData, *px);
   *pYBitmap    = YClientToBitmap(lpImageData, *py);
   
   *px  = XClientToBitmapInverse(lpImageData, *pXBitmap);
   *py  = YClientToBitmapInverse(lpImageData, *pYBitmap);
}



#define IDM_TOOLNONE 0
#define IDM_TOOLRECT 1
#define IDM_TOOLFREEHAND 2

/*****************************************************************************/
/*
/*****************************************************************************/
CJPEG2000View::CJPEG2000View()
{
   m_nZoom=100;

   SetImageDataDefaults(&m_Data);

   m_nTool = IDM_TOOLRECT;
   m_pptRegion = NULL;
   m_nNextPt = 0;

   m_bResizePlz = FALSE;
 
}

/*****************************************************************************/
/*
/*****************************************************************************/
CJPEG2000View::~CJPEG2000View()
{
}

/*****************************************************************************/
/*
/*****************************************************************************/
BOOL CJPEG2000View::PreCreateWindow(CREATESTRUCT& cs)
{
	return CScrollView::PreCreateWindow(cs);
}


/*****************************************************************************/
/*
/*****************************************************************************/
L_VOID CJPEG2000View::UpdateDisplayPalette( CDC* pDC, pBITMAPHANDLE pBitmap )
{
   DWORD dwFlags;
   HPALETTE hPal=NULL;
   RECT rcClip;

   ASSERT( pBitmap->Flags.Allocated );
   ASSERT_VALID( pDC );

   dwFlags = theApp.SetDisplayMode();
   pDC->SaveDC();

   hPal = L_CreatePaintPalette(pDC->m_hDC, pBitmap);
   if(hPal)
   {
      ::SelectPalette(pDC->m_hDC, hPal, FALSE);
      ::RealizePalette(pDC->m_hDC);  
   }
   pDC->GetClipBox(&rcClip);
   L_PaintDC(pDC->m_hDC, pBitmap, NULL, NULL, &m_rcDst, &rcClip, SRCCOPY);

   pDC->RestoreDC(-1); 
   
   if(hPal)
      DeleteObject(hPal);
   L_SetDisplayMode(DISPLAYMODE_RESETPOSITIONS, dwFlags);

}

/*****************************************************************************/
/*
/*****************************************************************************/
void CJPEG2000View::OnDraw(CDC* pDC)
{
	CJPEG2000Doc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);

   pBITMAPHANDLE pBitmap = &pDoc->m_LEADBitmap;
   

   if( pBitmap->Flags.Allocated && !m_bResizePlz )
   {
      UpdateDisplayPalette( pDC, pBitmap );
   }
   else //must be first paint after new document for PaintWhileLoad
   {
      L_INT nRet;
      if(theApp.m_bPaintWhileLoad)
      {
         ShowWindow(SW_SHOW);

         CRect rcMainFrame = m_rcDst;
         nRet = L_SetLoadResolution( FILE_J2K, rcMainFrame.Width(), rcMainFrame.Height() );

         if( !pDoc->m_LEADBitmap.Flags.Allocated )
         {
            HCURSOR hCur = SetCursor( LoadCursor(NULL,IDC_WAIT) );
            
            if( pDoc->m_fi.BitsPerPixel > 8 )
            {
               nRet = L_LoadFile((L_TCHAR L_FAR*)(LPCTSTR)pDoc->m_csFilename, &pDoc->m_LEADBitmap, sizeof(BITMAPHANDLE), 0, ORDER_BGRORGRAY,
                                    LOADFILE_ALLOCATE | LOADFILE_STORE,
                                    FileReadCallBack,
                                    (L_VOID L_FAR*)this,
                                    NULL,
                                    NULL);
            }
            else
            {
               // this is for Paletteized images..
               nRet = L_LoadFile((L_TCHAR L_FAR*)(LPCTSTR)pDoc->m_csFilename, &pDoc->m_LEADBitmap, sizeof(BITMAPHANDLE), 0, ORDER_BGRORGRAY,
                                    LOADFILE_ALLOCATE | LOADFILE_STORE,
                                    NULL,
                                    (L_VOID L_FAR*)this,
                                    NULL,
                                    NULL);

               UpdateDisplayPalette( pDC, pBitmap );
            }

            SetCursor( hCur );
            
         }
         else
         {
            if( IS_MULTIRES_FORMAT(pDoc->m_fi.Format) )
            {
               BOOL bUseRGN = FALSE;
               RGNXFORM  XForm;
               int nOldWidth, nOldHeight;

               if(L_BitmapHasRgn(m_Data.pBitmap))
               {
                  bUseRGN = TRUE;
                  L_GetBitmapRgnHandle(m_Data.pBitmap, &XForm, &m_Data.hRgnWindows);
                  nOldWidth = m_Data.pBitmap->Width;
                  nOldHeight = m_Data.pBitmap->Height;
               }

               L_FreeBitmap(&pDoc->m_LEADBitmap);
               
               HCURSOR hCur = SetCursor( LoadCursor(NULL,IDC_WAIT) );
               
               nRet = L_LoadFile((L_TCHAR L_FAR*)(LPCTSTR)pDoc->m_csFilename, &pDoc->m_LEADBitmap, sizeof(BITMAPHANDLE), 0, ORDER_BGRORGRAY,
                        LOADFILE_ALLOCATE | LOADFILE_STORE,
                        FileReadCallBack, (L_VOID L_FAR*)this,
                        NULL, //&theApp.m_lfo,
                        NULL);

               SetCursor( hCur );

               if( bUseRGN )
               {
                  m_Data.pBitmap = &pDoc->m_LEADBitmap;
                  XForm.uViewPerspective = TOP_LEFT;
                  XForm.nXScalarNum = BITMAPWIDTH(m_Data.pBitmap);
                  XForm.nYScalarNum = BITMAPHEIGHT(m_Data.pBitmap);
                  XForm.nXScalarDen = nOldWidth;
                  XForm.nYScalarDen = nOldHeight;
                  XForm.nXOffset = 0;
                  XForm.nYOffset = 0;
                  L_SetBitmapRgnHandle(m_Data.pBitmap, &XForm, m_Data.hRgnWindows, L_RGN_SET);
               }
            }
         }
         if(nRet!=SUCCESS)
         {
            theApp.DisplayLEADError(nRet);
            DestroyWindow();
         }
         else
         {
            //OnViewNormal();
            if(m_nViewMode==VIEW_FIT)
               OnViewFitimagetowindow();
            
            OnSetFocus(this);
         }

         m_bResizePlz = FALSE;
      }
   }
}

      

     
#ifdef _DEBUG
/*****************************************************************************/
/*
/*****************************************************************************/
void CJPEG2000View::AssertValid() const
{
	CScrollView::AssertValid();
}

/*****************************************************************************/
/*
/*****************************************************************************/
void CJPEG2000View::Dump(CDumpContext& dc) const
{
	CScrollView::Dump(dc);
}

/*****************************************************************************/
/*
/*****************************************************************************/
CJPEG2000Doc* CJPEG2000View::GetDocument() // non-debug version is inline
{
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CJPEG2000Doc)));
	return (CJPEG2000Doc*)m_pDocument;
}
#endif //_DEBUG

/*****************************************************************************/
/*
/*****************************************************************************/
void CJPEG2000View::OnSizeChange()
{
	CJPEG2000Doc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);
   
   pBITMAPHANDLE pBitmap = &pDoc->m_LEADBitmap;
   if(pDoc->m_LEADBitmap.Flags.Allocated)
   {
      ::SetRect(&m_rcDst,
                0, 0,
                MulDiv(pBitmap->Width, m_nZoom, 100),
                MulDiv(pBitmap->Height, m_nZoom, 100)
                );
   }

   else
   {
      ::SetRect(&m_rcDst,
                0, 0,
                MulDiv(pDoc->m_fi.Width, m_nZoom, 100),
                MulDiv(pDoc->m_fi.Height, m_nZoom, 100)
                );
   }
   
   if(!theApp.m_bPaintWhileLoad)
   {
      BOOL bUseRGN = FALSE;
      BOOL bIsNewResLoaded = FALSE;
      RGNXFORM  XForm;
      int nOldWidth, nOldHeight;

      if(L_BitmapHasRgn(m_Data.pBitmap))
      {
         bUseRGN = TRUE;
         L_GetBitmapRgnHandle(m_Data.pBitmap, &XForm, &m_Data.hRgnWindows);
         nOldWidth = m_Data.pBitmap->Width;
         nOldHeight = m_Data.pBitmap->Height;
      }

      bIsNewResLoaded = pDoc->LoadResolution(m_rcDst);

      if( bUseRGN && bIsNewResLoaded)
      {
         m_Data.pBitmap = &pDoc->m_LEADBitmap;
         XForm.uViewPerspective = TOP_LEFT;
         XForm.nXScalarNum = BITMAPWIDTH(m_Data.pBitmap);
         XForm.nYScalarNum = BITMAPHEIGHT(m_Data.pBitmap);
         XForm.nXScalarDen = nOldWidth;
         XForm.nYScalarDen = nOldHeight;
         XForm.nXOffset = 0;
         XForm.nYOffset = 0;
         L_SetBitmapRgnHandle(m_Data.pBitmap, &XForm, m_Data.hRgnWindows, L_RGN_SET);
      }
   }
   else if( pDoc->m_LEADBitmap.Flags.Allocated )
   {
      if( (theApp.m_bPaintWhileLoad) && IS_MULTIRES_FORMAT(pDoc->m_fi.Format) )
      {
         CRect rcMainFrame = m_rcDst;
         DIMENSION sDIM, sWND;
         sDIM.nWidth  = pDoc->m_LEADBitmap.Width;
         sDIM.nHeight = pDoc->m_LEADBitmap.Height;
         sWND.nWidth  = rcMainFrame.Width();
         sWND.nHeight = rcMainFrame.Height();
         if( (sWND.nWidth>sDIM.nWidth) || (sWND.nHeight>sDIM.nHeight) )
         {
            if(sDIM.nWidth < pDoc->m_pDimensions[0].nWidth)
            {
               Invalidate();
               m_bResizePlz = TRUE;
            }
         }
      }
   }
   
   CStatusBar *pStatusBar=NULL;
   CMainFrame * pMain=NULL;
   pMain = (CMainFrame*)AfxGetMainWnd();
   if(pMain)
   pStatusBar = &pMain->m_wndStatusBar;
   if(pStatusBar)
   {
      CString cs;
      cs.Format(TEXT("%ux%u"), pDoc->m_LEADBitmap.Width, pDoc->m_LEADBitmap.Height);
      pStatusBar->SetPaneText(1, cs, TRUE); 
      cs.Format(TEXT("%uBPP"), pDoc->m_LEADBitmap.BitsPerPixel);
      pStatusBar->SetPaneText(2, cs, TRUE); 
      cs.Format(TEXT("Mem:%u"), pDoc->m_fi.SizeMem);
      pStatusBar->SetPaneText(3, cs, TRUE); 
      cs.Format(TEXT("Disk:%u"), pDoc->m_fi.SizeDisk);
      pStatusBar->SetPaneText(4, cs, TRUE); 
   }      
   CSize sizeTotal(RECTWIDTH(&m_rcDst), RECTHEIGHT(&m_rcDst));
   SetScrollSizes(MM_TEXT, sizeTotal);
}

/*****************************************************************************/
/*
/*****************************************************************************/
void CJPEG2000View::OnUpdate(CScrollView* pSender, LPARAM lHint, CObject* pHint) 
{
   UINT uFlags = (UINT) lHint;

   if(uFlags & CHANGED_COLOR)
      OnSizeChange();
   CScrollView::OnUpdate(pSender, lHint, pHint);
}

/*****************************************************************************/
/*
/*****************************************************************************/
void CJPEG2000View::OnHScroll(UINT nCode, UINT nPos, CScrollBar* pScrollBar) 
{
	CScrollView::OnHScroll(nCode, nPos, pScrollBar);
}

/*****************************************************************************/
/*
/*****************************************************************************/
void CJPEG2000View::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar) 
{
   CScrollView::OnVScroll(nSBCode, nPos, pScrollBar);
}

/*****************************************************************************/
/*
/*****************************************************************************/
void CJPEG2000View::OnInitialUpdate() 
{
   RECT rcMain,rc,rcParent;
   CFrameWnd * pParent;
   HWND hWndMDIClient;
   CJPEG2000Doc *pDoc = (CJPEG2000Doc*)GetDocument();

   CScrollView::OnInitialUpdate();

   SetZoom(100);
   //Snap window or fit image?
   hWndMDIClient = ((CMDIFrameWnd *)AfxGetMainWnd())->m_hWndMDIClient;
   ::GetClientRect(hWndMDIClient,&rcMain);
   pParent = GetParentFrame();
   pParent->RecalcLayout();
   CopyRect(&rc,&m_rcDst);
   pParent->GetWindowRect(&rcParent);
    
   rcMain.right -= rcMain.left;
   rcMain.bottom -= rcMain.top;

   rc.right -= rc.left;
   rc.bottom -= rc.top;

   if (rcMain.right >= rc.right && 
       rcMain.bottom >= rc.bottom)
   {
      pParent->SetWindowPos(NULL,0,0,0,0,SWP_NOZORDER|SWP_NOSIZE);
      OnViewSnapwindowtoimage();            
   }    
   else
   {
      OnViewFitimagetowindow();
      pParent->SetWindowPos(NULL,0,0,rcMain.right,rcMain.bottom,SWP_NOZORDER);
   }
   OnDoRealize((WPARAM)m_hWnd, (LPARAM) FALSE);   // same as SendMessage(WM_DOREALIZE);


   
}

/*****************************************************************************/
/*
/*****************************************************************************/
LRESULT CJPEG2000View::OnDoRealize(WPARAM wParam, LPARAM lParam)
{
   UINT nColorsChanged = 0;
   CJPEG2000Doc* pDoc = GetDocument();
   CDC* pdc;
   DWORD dwFlags;
   CWnd * pWnd=NULL;
   HPALETTE hPal=NULL;

   if(lParam)
   {
      if(((HWND) wParam) == m_hWnd)
         return(FALSE);
      pdc = GetDC();
   }
   else
   {
      pWnd =theApp.m_pMainWnd;
      //pWnd = this;
      pdc = pWnd->GetDC();
      dwFlags = theApp.SetDisplayMode();
      hPal = L_CreatePaintPalette(pdc->m_hDC, &pDoc->m_LEADBitmap);
      L_SetDisplayMode (DISPLAYMODE_RESETPOSITIONS, dwFlags);
   }   
   if(hPal)
   {
      pdc->SaveDC();
      ::SelectPalette(pdc->m_hDC, hPal, (BOOL) lParam);
      nColorsChanged = ::RealizePalette(pdc->m_hDC);
      if(nColorsChanged > 0)
         GetParent()->InvalidateRect(NULL, FALSE);
      pdc->RestoreDC(-1); 
   }
   if(lParam)
      ReleaseDC(pdc);
   else
      pWnd->ReleaseDC(pdc);


   CRect rcC;
   GetClientRect(&rcC);
   
   m_Data.bFitImage = FALSE;            //if TRUE then fit image to window 
   m_Data.cxClient = rcC.Width();              //width of client area 
   m_Data.cyClient = rcC.Height();              //height of client area 
   m_Data.rcView = rcC;
   m_Data.pBitmap = &pDoc->m_LEADBitmap;        

   return ((LRESULT) (BOOL) (nColorsChanged > 0));
}

/*****************************************************************************/
/*
/*****************************************************************************/
void CJPEG2000View::SetZoom(int nZoom) 
{
   CJPEG2000Doc* pDoc = GetDocument();
   ASSERT_VALID(pDoc);
   m_nZoom = nZoom;
   
   OnSizeChange();
   pDoc->UpdateAllViews(NULL);
}

/*****************************************************************************/
/*
/*****************************************************************************/
void CJPEG2000View::OnViewNormal() 
{
   m_nViewMode = VIEW_NORMAL;
   SetZoom(100);
}

/*****************************************************************************/
/*
/*****************************************************************************/
void CJPEG2000View::OnUpdateViewNormal(CCmdUI* pCmdUI) 
{
   pCmdUI->SetCheck(m_nViewMode==VIEW_NORMAL);
}

/*****************************************************************************/
/*
/*****************************************************************************/
void CJPEG2000View::OnViewFitimagetowindow() 
{
   CJPEG2000Doc* pDoc = GetDocument();
   int cxZoom, cyZoom; 
   pBITMAPHANDLE pBitmap = &pDoc->m_LEADBitmap;
   CSize size;
   CSize sizeSb;

   GetTrueClientSize(size, sizeSb);
   if(pBitmap->Flags.Allocated)
   {
      cxZoom = (int) ((long) size.cx * 100 / pBitmap->Width);
      cyZoom = (int) ((long) size.cy * 100 / pBitmap->Height);
   }
   else
   {
      if( pDoc->m_fi.Width > 0  )
         cxZoom = (int) ((long) size.cx * 100 / pDoc->m_fi.Width);

      if( pDoc->m_fi.Height > 0 )
         cyZoom = (int) ((long) size.cy * 100 / pDoc->m_fi.Height);
   }
   SetZoom(max(min(cxZoom, cyZoom), 1));
   m_nViewMode = VIEW_FIT;
}


/*****************************************************************************/
/*
/*****************************************************************************/
void CJPEG2000View::OnUpdateViewFitimagetowindow(CCmdUI* pCmdUI) 
{
   pCmdUI->SetCheck(m_nViewMode==VIEW_FIT);   
}


/*****************************************************************************/
/*
/*****************************************************************************/
void CJPEG2000View::OnViewSnapwindowtoimage() 
{
   m_nViewMode = VIEW_SNAP;
   WINDOWPLACEMENT wndpl;
   wndpl.length = sizeof(WINDOWPLACEMENT);
   wndpl.flags = 0;
   GetParent()->GetWindowPlacement(&wndpl);
   wndpl.flags = 0;
   wndpl.showCmd = SW_RESTORE;
   GetParent()->SetWindowPlacement(&wndpl);
   ResizeParentToFit(FALSE);   
}


/*****************************************************************************/
/*
/*****************************************************************************/
void CJPEG2000View::OnUpdateViewSnapwindowtoimage(CCmdUI* pCmdUI) 
{
   pCmdUI->SetCheck(m_nViewMode==VIEW_SNAP);
   pCmdUI->Enable(m_nViewMode!=VIEW_FIT);   
}

/*****************************************************************************/
/*
/*****************************************************************************/
void CJPEG2000View::OnViewZoomin2x() 
{
   if(m_nZoom<=800)
      m_nZoom = min(800, m_nZoom * 2);
   if(m_nZoom==100)
      m_nViewMode = VIEW_NORMAL;
   else
      m_nViewMode = VIEW_ZOOM;

   SetZoom(m_nZoom);
}

/*****************************************************************************/
/*
/*****************************************************************************/
void CJPEG2000View::OnViewZoomout2x() 
{
   if(m_nZoom>=6)
      m_nZoom = max(6, m_nZoom / 2);
   if(m_nZoom==100)
      m_nViewMode = VIEW_NORMAL;
   else
      m_nViewMode = VIEW_ZOOM;
   SetZoom(m_nZoom);
}

/*****************************************************************************/
/*
/*****************************************************************************/
void CJPEG2000View::OnSize(UINT nType, int cx, int cy) 
{
   CScrollView::OnSize(nType, cx, cy);
   if (m_nViewMode == VIEW_FIT)
       OnViewFitimagetowindow();
}

/*****************************************************************************/
/*
/*****************************************************************************/
BOOL CJPEG2000View::OnEraseBkgnd(CDC* pDC) 
{
   CBrush br;
   br.CreateStockObject(GRAY_BRUSH);
   FillOutsideRect(pDC, &br);
   return(TRUE);
}

/*****************************************************************************/
/*
/*****************************************************************************/
void CJPEG2000View::OnSetFocus(CWnd* pOldWnd) 
{
   CJPEG2000Doc* pDoc = GetDocument();
	CScrollView::OnSetFocus(pOldWnd);
   CStatusBar *pStatusBar=NULL;
   CMainFrame * pMain=NULL;
   pMain = (CMainFrame*)AfxGetMainWnd();
   if(pMain)
      pStatusBar = &pMain->m_wndStatusBar;
   if(pStatusBar)
   {
      CString cs;
      cs.Format(TEXT("%ux%u"), pDoc->m_LEADBitmap.Width, pDoc->m_LEADBitmap.Height);
      pStatusBar->SetPaneText(1, cs, TRUE); 
      cs.Format(TEXT("%uBPP"), pDoc->m_LEADBitmap.BitsPerPixel);
      pStatusBar->SetPaneText(2, cs, TRUE); 
      cs.Format(TEXT("Mem:%u"), pDoc->m_fi.SizeMem);
      pStatusBar->SetPaneText(3, cs, TRUE); 
      cs.Format(TEXT("Disk:%u"), pDoc->m_fi.SizeDisk);
      pStatusBar->SetPaneText(4, cs, TRUE); 
   }
}

/*****************************************************************************/
/*
/*****************************************************************************/
void CJPEG2000View::OnKillFocus(CWnd* pNewWnd) 
{
	CScrollView::OnKillFocus(pNewWnd);
   CMainFrame* pMain=NULL;
   CStatusBar *pStatusBar=NULL;
   pMain = (CMainFrame*)AfxGetMainWnd();
   if(pMain)
      pStatusBar = &pMain->m_wndStatusBar;
   if(pStatusBar)
   {
      pStatusBar->SetPaneText(1, TEXT(" "), TRUE); 
      pStatusBar->SetPaneText(2, TEXT(" "), TRUE); 
      pStatusBar->SetPaneText(3, TEXT(" "), TRUE); 
      pStatusBar->SetPaneText(4, TEXT(" "), TRUE); 
   }
}

/*****************************************************************************/
/*
/*****************************************************************************/
L_INT L_FAR L_EXPORT FileReadCallBack(pFILEINFO pFileInfo,
                                      pBITMAPHANDLE pBitmap,
                                      L_UCHAR L_FAR *pBuffer,
                                      L_UINT uFlags,
                                      L_INT nRow,
                                      L_INT nLines,
                                      L_VOID L_FAR * pData)
{
   CJPEG2000View* pView=NULL;
   L_UINT32 ulFlags;
   HPALETTE hPal=NULL;
   CDC *pDC=NULL;
   RECT rcClip;

   pView = (CJPEG2000View*)pData;
   pDC = pView->GetDC();
   if( pDC )
   {
      ulFlags = theApp.SetDisplayMode();
      pDC->SaveDC();
      hPal = NULL;
      hPal = L_CreatePaintPalette(pDC->m_hDC, pBitmap);
      if(hPal)
      {
         ::SelectPalette(pDC->m_hDC, hPal, FALSE);
         ::RealizePalette(pDC->m_hDC);
      }

      pDC->GetClipBox(&rcClip);
      L_PaintDCBuffer(pDC->m_hDC, pBitmap, NULL, NULL, &pView->m_rcDst, &rcClip, SRCCOPY, pBuffer, nRow, nLines);

      pDC->RestoreDC(-1);
      if(hPal)
         DeleteObject(hPal);
      L_SetDisplayMode (DISPLAYMODE_ORDEREDDITHER, ulFlags);

      pView->ReleaseDC( pDC );
   }
   return(SUCCESS);
}














/*****************************************************************************/
/*
/*****************************************************************************/
void CJPEG2000View::OnLButtonDown(UINT nFlags, CPoint point) 
{
   RECT rcClient;
   POINT pt;
   LPIMAGEDATA lpImageData = &m_Data;
   L_INT32 XBitmap, YBitmap;


   if( lpImageData->pBitmap->Flags.Allocated && theApp.m_bEnableROI )
   {
   
      HWND hWnd = GetSafeHwnd( );
      BOOL bDoubleClick = FALSE ;
      long x = point.x;
      long y = point.y;
      UINT keyFlags = nFlags;
   

      PixelizePoint(lpImageData, &x, &y, &XBitmap, &YBitmap);

      //Store location of mouse down
      lpImageData->pointStart.x = XBitmap;
      lpImageData->pointStart.y = YBitmap;
   
   
      if(
         !GetCapture() &&  
         !::IsIconic(hWnd) && lpImageData->pBitmap->Flags.Allocated
        )
      {
         ::GetClientRect(hWnd, &rcClient);
         IntersectRect(&rcClient, &rcClient, &lpImageData->rcView);
         pt.x = x;
         pt.y = y;
         if(PtInRect(&rcClient, pt) ) //&& (nTool != IDM_TOOLMAGNIFY))
         {
         
            m_pptRegion = (LPPOINT) GlobalAllocPtr(GHND, (L_UINT32) sizeof(POINT) * 2);
         
            if( m_pptRegion )
            {
               m_nNextPt = 0;
               m_pptRegion[m_nNextPt].x = x;
               m_pptRegion[m_nNextPt].y = y;
               m_nNextPt++;
               ::SetCapture(hWnd);
            }
         }
      }

   }

	CScrollView::OnLButtonDown(nFlags, point);
}


/*****************************************************************************/
/*
/*****************************************************************************/
L_VOID CJPEG2000View::OutlineRegion(HWND hWnd, HDC hdc)
{
   LPIMAGEDATA lpImageData = &m_Data;
   HDC         hdcDraw;
   RGNXFORM    XForm;

   if( lpImageData->pBitmap->Flags.Allocated && theApp.m_bEnableROI )
   {

      if(L_BitmapHasRgn(lpImageData->pBitmap))
      {
         if(hdc)
            hdcDraw = hdc;
         else
            hdcDraw = ::GetDC(hWnd);
         XForm.uViewPerspective = TOP_LEFT; //lpImageData->pBitmap.ViewPerspective; //;
         XForm.nXOffset = (lpImageData->rcView.left - GetScrollPosition().x);
         XForm.nYOffset = (lpImageData->rcView.top - GetScrollPosition().y);
         XForm.nXScalarDen = BITMAPWIDTH(lpImageData->pBitmap);
         XForm.nYScalarDen = BITMAPHEIGHT(lpImageData->pBitmap);
         XForm.nXScalarNum = RECTWIDTH(&m_rcDst);
         XForm.nYScalarNum = RECTHEIGHT(&m_rcDst);

         L_FrameBitmapRgn(hdcDraw, lpImageData->pBitmap, &XForm, lpImageData->uFrameType);

         if(!hdc)
            ::ReleaseDC(hWnd, hdcDraw);
      }
   }
}

/*****************************************************************************/
/*
/*****************************************************************************/
void CJPEG2000View::OnLButtonUp(UINT nFlags, CPoint point) 
{

   LPIMAGEDATA lpImageData;
   RGNXFORM XForm;
   L_INT nRet;
   RECT rc;
   HCURSOR  hOldCursor;

   lpImageData = &m_Data;
        
   if( lpImageData->pBitmap->Flags.Allocated && theApp.m_bEnableROI )
   {
      
      HWND hWnd = GetSafeHwnd( );
      BOOL bDoubleClick = FALSE ;
      long x = point.x;
      long y = point.y;
      UINT keyFlags = nFlags;
            
      if(::GetCapture() == hWnd)
      {
         HiliteMark(hWnd, FALSE);
         if (m_nTool != IDM_TOOLNONE)
         {
            hOldCursor = ::SetCursor(::LoadCursor(NULL,IDC_WAIT));
            
            //Free the region no matter what
            //1.  If REGION_NEW, we must replace the existing region
            //2.  If REGION_ADD or REGION_SUBTRACT,  must convert to windows region and combine with new LEAD region
            L_FreeBitmapRgn(lpImageData->pBitmap);
            
            if(m_nNextPt > 1)
            {
               XForm.uViewPerspective = TOP_LEFT;
               XForm.nXScalarNum = BITMAPWIDTH(lpImageData->pBitmap);
               XForm.nYScalarNum = BITMAPHEIGHT(lpImageData->pBitmap);
               XForm.nXScalarDen = RECTWIDTH(&m_rcDst);
               XForm.nYScalarDen = RECTHEIGHT(&m_rcDst);
               XForm.nXOffset = -(lpImageData->rcView.left - GetScrollPosition().x);
               XForm.nYOffset = -(lpImageData->rcView.top - GetScrollPosition().y);
               
               switch(m_nTool)
               {
               case IDM_TOOLRECT:
                  SetRect(&rc, min(m_pptRegion[0].x, m_pptRegion[1].x),
                     min(m_pptRegion[0].y, m_pptRegion[1].y),
                     max(m_pptRegion[0].x, m_pptRegion[1].x),
                     max(m_pptRegion[0].y, m_pptRegion[1].y));
                  
                  nRet = L_SetBitmapRgnRect(lpImageData->pBitmap, &XForm, &rc, L_RGN_SET);
                  
                  
                  break;
               }
            }
            
            if (m_nNextPt <= 1)
            {
               L_SetBitmapRgnHandle(lpImageData->pBitmap, NULL, lpImageData->hRgnWindows, L_RGN_SET);
            }
            
            ::InvalidateRect(hWnd, NULL, FALSE);
            ::UpdateWindow(hWnd);
            
            
            if (L_BitmapHasRgn(lpImageData->pBitmap))
            {
               ::SetTimer(
                  hWnd,                // handle to window
                  ID_REGIONEVENT,      // timer identifier
                  REGIONEVENTDELAY,    // time-out value,
                  NULL                 // timer procedure
                  );
               
               OutlineRegion(hWnd, NULL);
            }
            else
            {
               ::KillTimer(hWnd, ID_REGIONEVENT);
            }
         }
         
         ::ReleaseCapture();
         GlobalFreePtr(m_pptRegion);
         m_pptRegion = NULL;
         
         ::SetCursor(hOldCursor);
      }
   }
   
	
	CScrollView::OnLButtonUp(nFlags, point);
}

/*****************************************************************************/
/*
/*****************************************************************************/
L_VOID CJPEG2000View::HiliteMark(HWND hWnd, L_BOOL bUpdate)
{
   HDC hdc;
   HBRUSH hBrush;
   HPEN hPen;
   L_INT nDrawMode;
   LPIMAGEDATA lpImageData;
   HRGN hRgn;

   lpImageData = &m_Data;

   if(m_nNextPt <= 1)
      return;

   hdc = ::GetDC(hWnd);
   hBrush = (HBRUSH)::SelectObject (hdc, ::GetStockObject(NULL_BRUSH));
   hPen = (HPEN)::SelectObject (hdc, GetStockObject(WHITE_PEN));
   hRgn = ::CreateRectRgnIndirect(&lpImageData->rcView);
   ::SelectObject(hdc, hRgn);
   ::DeleteObject(hRgn);
   nDrawMode = GetROP2 (hdc);
   ::SetROP2 (hdc, R2_NOT);

   switch(m_nTool)
   {
   case IDM_TOOLNONE:
   case IDM_TOOLRECT:
      {
         Rectangle(
            hdc, 
            min(m_pptRegion[0].x, m_pptRegion[1].x),
            min(m_pptRegion[0].y, m_pptRegion[1].y),
            max(m_pptRegion[0].x, m_pptRegion[1].x),
            max(m_pptRegion[0].y, m_pptRegion[1].y)
            );

      }
      break;
   }
   ::SetROP2 (hdc, nDrawMode);
   ::SelectObject(hdc, hBrush);
   ::SelectObject(hdc, hPen);
   ::ReleaseDC(hWnd, hdc);

}

/*****************************************************************************/
/*
/*****************************************************************************/
void CJPEG2000View::OnMouseMove(UINT nFlags, CPoint point) 
{
   L_INT32 XBitmap, YBitmap;
   LPIMAGEDATA lpImageData = &m_Data;

   if( lpImageData->pBitmap->Flags.Allocated && theApp.m_bEnableROI )

   {
      HWND hWnd = GetSafeHwnd( );
      long x = point.x;
      long y = point.y;
      UINT keyFlags = nFlags;
      PixelizePoint(lpImageData, &x, &y, &XBitmap, &YBitmap);
      if(( ::GetCapture() == hWnd))
      {
         HiliteMark(hWnd, FALSE);
         m_pptRegion[1].x = x;
         m_pptRegion[1].y = y;
         m_nNextPt = 2;
         HiliteMark(hWnd, TRUE);
      }
   }
   
	
	CScrollView::OnMouseMove(nFlags, point);
}

/*****************************************************************************/
/*
/*****************************************************************************/
void CJPEG2000View::OnTimer(UINT nIDEvent) 
{
   LPIMAGEDATA lpImageData = &m_Data;
   HWND hWnd = GetSafeHwnd( );
   
   switch(nIDEvent)
   {
   case ID_REGIONEVENT:
      lpImageData->uFrameType = (lpImageData->uFrameType + 2) % 8;
      OutlineRegion(hWnd, NULL);
      break;      

   }
	
	CScrollView::OnTimer(nIDEvent);
}