// OCRUtilView.cpp : implementation of the COCRUtilView class
//

#include "stdafx.h"
#include "OCRUTIL.h"

#include "OCRUtilDoc.h"
#include "OCRUtilView.h"
#include "SelectPage.h"
#include "InsPage.h"
#include "ExpPages.h"
#include "ZoneFile.h"
#include "ZoneData.h"
#include "ZoneDel.h"
#include "ZoneInfo.h"
#include "ZoneOpts.h"
#include "Language.h"
#include "ModOpts.h"
#include "RecogPage.h"
#include "SaveRes.h"
#include "ZoomPercent.h"
#include "RecogWords.h"

#include "EngineMsg.h"

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

L_INT COCRUtilView::m_nRecogEndIndex = 0;

/////////////////////////////////////////////////////////////////////////////
// COCRUtilView

IMPLEMENT_DYNCREATE(COCRUtilView, CScrollView)

BEGIN_MESSAGE_MAP(COCRUtilView, CScrollView)
   //{{AFX_MSG_MAP(COCRUtilView)
   ON_COMMAND(ID_FILE_CLOSE, OnFileClose)
   ON_COMMAND(ID_FILE_SAVE_AS, OnFileSaveAs)
   ON_UPDATE_COMMAND_UI(ID_FILE_SAVE_AS, OnUpdateFileSaveAs)
   ON_UPDATE_COMMAND_UI(ID_FILE_CLOSE, OnUpdateFileClose)
   ON_WM_ERASEBKGND()
   ON_COMMAND(ID_PAGES_SHOWPAGE, OnPagesShowPage)
   ON_UPDATE_COMMAND_UI(ID_PAGES_SHOWPAGE, OnUpdatePagesShowPage)
   ON_COMMAND(ID_PAGES_DELETEPAGE, OnPagesDeletePage)
   ON_UPDATE_COMMAND_UI(ID_PAGES_DELETEPAGE, OnUpdatePagesDeletePage)
   ON_COMMAND(ID_PAGES_INSERTPAGE, OnPagesInsertPage)
   ON_UPDATE_COMMAND_UI(ID_PAGES_INSERTPAGE, OnUpdatePagesInsertPage)
   ON_COMMAND(ID_PAGES_PAGECOUNT, OnPagesPageCount)
   ON_UPDATE_COMMAND_UI(ID_PAGES_PAGECOUNT, OnUpdatePagesPageCount)
   ON_COMMAND(ID_EDIT_COPY, OnEditCopy)
   ON_UPDATE_COMMAND_UI(ID_EDIT_COPY, OnUpdateEditCopy)
   ON_COMMAND(ID_PAGES_EXPORTPAGE, OnPagesExportPage)
   ON_UPDATE_COMMAND_UI(ID_PAGES_EXPORTPAGE, OnUpdatePagesExportPage)
   ON_COMMAND(ID_ZONE_FINDZONES, OnFindZones)
   ON_UPDATE_COMMAND_UI(ID_ZONE_FINDZONES, OnUpdateFindZones)
   ON_COMMAND(ID_ZONE_DELETEZONE, OnDeleteZone)
   ON_UPDATE_COMMAND_UI(ID_ZONE_DELETEZONE, OnUpdateDeleteZone)
   ON_COMMAND(ID_ZONE_GETZONES_FIRSTZONE, OnGetFirstZone)
   ON_UPDATE_COMMAND_UI(ID_ZONE_GETZONES_FIRSTZONE, OnUpdateGetFirstZone)
   ON_COMMAND(ID_ZONE_GETZONES_NEXTZONE, OnGetNextZone)
   ON_UPDATE_COMMAND_UI(ID_ZONE_GETZONES_NEXTZONE, OnUpdateGetNextZone)
   ON_COMMAND(ID_ZONE_EXPORTZONEFILE, OnExportZoneFile)
   ON_UPDATE_COMMAND_UI(ID_ZONE_EXPORTZONEFILE, OnUpdateExportZoneFile)
   ON_COMMAND(ID_ZONE_LOADZONEFILE, OnLoadZoneFile)
   ON_UPDATE_COMMAND_UI(ID_ZONE_LOADZONEFILE, OnUpdateLoadZoneFile)
   ON_COMMAND(ID_ZONE_ZONESCOUNT, OnZonesCount)
   ON_UPDATE_COMMAND_UI(ID_ZONE_ZONESCOUNT, OnUpdateZonesCount)
   ON_COMMAND(ID_PAGES_PAGEPROCESS_FLIP, OnPagesProcessFlip)
   ON_UPDATE_COMMAND_UI(ID_PAGES_PAGEPROCESS_FLIP, OnUpdatePagesProcessFlip)
   ON_COMMAND(ID_PAGES_PAGEPROCESS_ROTATE, OnPagesProcessRotate)
   ON_UPDATE_COMMAND_UI(ID_PAGES_PAGEPROCESS_ROTATE, OnUpdatePagesProcessRotate)
   ON_COMMAND(ID_PAGES_PAGEPROCESS_SKEW, OnPagesProcessSkew)
   ON_UPDATE_COMMAND_UI(ID_PAGES_PAGEPROCESS_SKEW, OnUpdatePagesProcessSkew)
   ON_COMMAND(ID_LANGUAGE_SELECTLANGUAGE, OnLanguageSelectLanguage)
   ON_UPDATE_COMMAND_UI(ID_LANGUAGE_SELECTLANGUAGE, OnUpdateLanguageSelectLanguage)
   ON_COMMAND(ID_OCR_RECOGNITION_OPTIONS, OnOcrRecognitionOptions)
   ON_UPDATE_COMMAND_UI(ID_OCR_RECOGNITION_OPTIONS, OnUpdateOcrRecognitionOptions)
   ON_COMMAND(ID_OCR_RECOGNIZE_PAGE, OnOcrRecognizePage)
   ON_UPDATE_COMMAND_UI(ID_OCR_RECOGNIZE_PAGE, OnUpdateOcrRecognizePage)
   ON_COMMAND(ID_OCR_SAVE_RESULT, OnOcrSaveResult)
   ON_UPDATE_COMMAND_UI(ID_OCR_SAVE_RESULT, OnUpdateOcrSaveResult)
   ON_COMMAND(ID_ZONE_SHOWZONES, OnZoneShowZones)
   ON_UPDATE_COMMAND_UI(ID_ZONE_SHOWZONES, OnUpdateZoneShowZones)
   ON_WM_LBUTTONDOWN()
   ON_WM_LBUTTONUP()
   ON_WM_MOUSEMOVE()
   ON_COMMAND(ID_VIEW_ZOOM, OnViewZoom)
   ON_UPDATE_COMMAND_UI(ID_VIEW_ZOOM, OnUpdateViewZoom)
   ON_COMMAND(ID_VIEW_ZOOM_IN, OnViewZoomIn)
   ON_UPDATE_COMMAND_UI(ID_VIEW_ZOOM_IN, OnUpdateViewZoomIn)
   ON_COMMAND(ID_VIEW_ZOOM_OUT, OnViewZoomOut)
   ON_UPDATE_COMMAND_UI(ID_VIEW_ZOOM_OUT, OnUpdateViewZoomOut)
   ON_WM_CONTEXTMENU()
   ON_COMMAND(ID_ZONE_UPDATEZONE, OnZoneUpdate)
   ON_UPDATE_COMMAND_UI(ID_ZONE_UPDATEZONE, OnUpdateZoneUpdate)
   ON_WM_SETCURSOR()
   ON_COMMAND(ID_ENGINE_STARTUP, OnEngineStartup)
   ON_UPDATE_COMMAND_UI(ID_ENGINE_STARTUP, OnUpdateEngineStartup)
   ON_COMMAND(ID_ENGINE_SHUTDOWN, OnEngineShutdown)
   ON_UPDATE_COMMAND_UI(ID_ENGINE_SHUTDOWN, OnUpdateEngineShutdown)
   ON_WM_DESTROY()
   ON_COMMAND(ID_PAGES_INSERTCURRENTIMAGE, OnPagesInsertcurrentimage)
   ON_UPDATE_COMMAND_UI(ID_PAGES_INSERTCURRENTIMAGE, OnUpdatePagesInsertcurrentimage)
   ON_COMMAND(ID_FILE_TWAINSELECT, OnFileTwainselect)
   ON_UPDATE_COMMAND_UI(ID_FILE_TWAINSELECT, OnUpdateFileTwainselect)
   ON_COMMAND(ID_FILE_TWAINACQUIRE, OnFileTwainacquire)
   ON_UPDATE_COMMAND_UI(ID_FILE_TWAINACQUIRE, OnUpdateFileTwainacquire)
   ON_WM_KEYUP()
   ON_COMMAND(ID_PAGES_PAGEPROCESS_AUTOORIENT, OnPagesPageprocessAutoorient)
   ON_UPDATE_COMMAND_UI(ID_PAGES_PAGEPROCESS_AUTOORIENT, OnUpdatePagesPageprocessAutoorient)
   ON_COMMAND(ID_OCR_GETRECOGNIZEDWORDS, OnOcrGetrecognizedwords)
   ON_UPDATE_COMMAND_UI(ID_OCR_GETRECOGNIZEDWORDS, OnUpdateOcrGetrecognizedwords)
   ON_COMMAND(ID_VIEW_SCALETOGRAY, OnViewScaletogray)
   ON_UPDATE_COMMAND_UI(ID_VIEW_SCALETOGRAY, OnUpdateViewScaletogray)
   ON_MESSAGE(WM_DOREALIZE, OnDoRealize)
   ON_COMMAND(ID_VIEW_NORMAL, OnViewNormal)
   ON_UPDATE_COMMAND_UI(ID_VIEW_NORMAL, OnUpdateViewNormal)
   ON_COMMAND(ID_VIEW_FAVORTOBLACK, OnViewFavortoblack)
   ON_UPDATE_COMMAND_UI(ID_VIEW_FAVORTOBLACK, OnUpdateViewFavortoblack)
   //}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// COCRUtilView construction/destruction

COCRUtilView::COCRUtilView()
{
   m_hPalette     = NULL;
   m_bImageLoaded = FALSE;
   m_hDoc         = NULL;
   m_nPageIndex   = -1;
   m_bNextZone    = FALSE;
   m_nZoneIndex   = -1;
   m_bShowZones   = TRUE;
   m_hZonePen     = NULL;
   m_hSelZonePen  = NULL;

   m_bLMDown      = FALSE;
   m_bCapWnd      = FALSE;

   m_nSelZoneIndex= -1;
   m_bSelectZone  = FALSE;
   m_fZoomPercent = 100.0;
   m_bRecognized  = FALSE;
   m_bFindZone    = FALSE;
   m_bResize      = FALSE;
   m_nDrawMode    = -1;
   m_ptResize.x   = m_ptResize.y = 0;

   m_bShowPage    = TRUE;
   m_bScanStarted = FALSE;
   m_csRecogDataFileName = _T("");
   m_nRecogEndIndex = 0;

   m_rcRgn.SetRectEmpty();
   m_rcFrame.SetRectEmpty();
   m_rcDst.SetRectEmpty();
   m_rcSelZone.SetRectEmpty();
   m_rcSelOrigZone.SetRectEmpty();
   m_nStartRecogIndex = -1;
   m_nEndRecogIndex = -1;
   m_nViewScale = 0;
}

COCRUtilView::~COCRUtilView()
{
   Free();
}

BOOL COCRUtilView::PreCreateWindow(CREATESTRUCT& cs)
{
   // TODO: Modify the Window class or styles here by modifying
   //  the CREATESTRUCT cs

   return CScrollView::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// COCRUtilView drawing

void COCRUtilView::OnDraw(CDC* pDC)
{
   COCRUtilDoc* pDoc = GetDocument();
   ASSERT_VALID(pDoc);

   HPALETTE OldPalette = NULL;

   COCRUtilApp * pTheApp = (COCRUtilApp *)AfxGetApp();
   if (pTheApp->m_Bitmap.Flags.Allocated && m_bImageLoaded)
   {
      L_SetDisplayMode(DISPLAYMODE_FAVORBLACK | DISPLAYMODE_SCALETOGRAY, m_nViewScale);

      CRect rcClip;
      if (m_hPalette)
      {
         OldPalette = ::SelectPalette(pDC->m_hDC, m_hPalette, TRUE);
         pDC->RealizePalette();
      }

      pDC->GetClipBox(rcClip);
      if (m_bShowPage)
      {
         if (m_hDoc && m_bImageLoaded && m_nPageIndex != -1)
         {
            L_DocDrawPage(m_hDoc,
                          pDC->GetSafeHdc(),
                          m_nPageIndex,
                          NULL,
                          NULL,
                          &m_rcDst,
                          &rcClip,
                          SRCCOPY,
                          m_bShowZones);

            if (m_nSelZoneIndex != -1 && m_bSelectZone && m_bShowZones)
            {
               L_DocSelectZone(m_hDoc,
                               pDC->GetSafeHdc(),
                               m_nPageIndex,
                               m_nSelZoneIndex,
                               m_bSelectZone);
            }
         }
      }
      else
      {
         CRect rcDst;

         L_INT nNewWidth  = (L_INT)(BITMAPWIDTH(&pTheApp->m_Bitmap) * m_fZoomPercent / 100.0);
         L_INT nNewHeight = (L_INT)(BITMAPHEIGHT(&pTheApp->m_Bitmap) * m_fZoomPercent / 100.0);

         rcDst.SetRect(0, 0, nNewWidth, nNewHeight);
         L_PaintDC(pDC->GetSafeHdc(), &pTheApp->m_Bitmap, NULL, NULL, &rcDst, &rcClip, SRCCOPY);
      }

      if (OldPalette)
         ::SelectPalette(pDC->m_hDC, OldPalette, TRUE);
   }
}

void COCRUtilView::OnInitialUpdate()
{
   CScrollView::OnInitialUpdate();
   UpdateScrollView();
}

/////////////////////////////////////////////////////////////////////////////
// COCRUtilView printing

BOOL COCRUtilView::OnPreparePrinting(CPrintInfo* pInfo)
{
   // default preparation
   return DoPreparePrinting(pInfo);
}

void COCRUtilView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
   // TODO: add extra initialization before printing
}

void COCRUtilView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
   // TODO: add cleanup after printing
}

/////////////////////////////////////////////////////////////////////////////
// COCRUtilView diagnostics

#ifdef _DEBUG
void COCRUtilView::AssertValid() const
{
   CScrollView::AssertValid();
}

void COCRUtilView::Dump(CDumpContext& dc) const
{
   CScrollView::Dump(dc);
}

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

/////////////////////////////////////////////////////////////////////////////
// COCRUtilView message handlers

/************************* File Menu *************************/
void COCRUtilView::OnFileSaveAs()
{
   BeginWaitCursor();

   SAVEDLGPARAMS FSParm;
   OPENFILENAME OpenFileName;
   L_TCHAR szFileName[_MAX_PATH]=TEXT("");
   COCRUtilApp * pTheApp = (COCRUtilApp *)AfxGetApp();

   memset(&OpenFileName,0,sizeof(OPENFILENAME));
   memset(&FSParm, 0, sizeof(SAVEDLGPARAMS));

   OpenFileName.lStructSize       = sizeof(OPENFILENAME);
   OpenFileName.lpstrInitialDir   = NULL;
   OpenFileName.lpstrTitle        = TEXT("Save a File");
   OpenFileName.lpstrFile         = szFileName;
   OpenFileName.nMaxFile          = sizeof(szFileName)/sizeof(L_TCHAR);
   OpenFileName.lpstrFileTitle    = FSParm.szFileName;
   OpenFileName.nMaxFileTitle     = sizeof(FSParm.szFileName)/sizeof(L_TCHAR);
   OpenFileName.nFileOffset       = 0;
   OpenFileName.Flags             = 0;

   FSParm.uStructSize = sizeof(SAVEDLGPARAMS);
   FSParm.pBitmap     = &pTheApp->m_Bitmap;
   FSParm.nQFactor    = 2;
   FSParm.uDlgFlags   = DLG_SAVE_AUTOPROCESS                  |
                        DLG_SAVE_SHOW_FILEOPTIONS_MULTIPAGE   |
                        DLG_SAVE_SHOW_FILEOPTIONS_PROGRESSIVE |
                        DLG_SAVE_SHOW_FILEOPTIONS_QFACTOR     |
                        DLG_SAVE_SHOW_FILEOPTIONS_STAMP       |
                        DLG_SAVE_SHOW_FILEOPTIONS_J2KOPTIONS  |
                        DLG_SAVE_SHOW_FILEOPTIONS_BASICJ2KOPTIONS;

   L_INT nRet = L_DlgSave(m_hWnd, &OpenFileName, &FSParm);
   if (!ISDLGSUCCESS(nRet))
   {
      CString csBuffer;

      csBuffer.Format(TEXT("Can not save file,\nError code = %d\n"), nRet);
      AfxMessageBox(csBuffer);
   }

   EndWaitCursor();
}

void COCRUtilView::OnUpdateFileSaveAs(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(!m_bScanStarted && m_bImageLoaded);
}

void COCRUtilView::Free(L_BOOL bPaste /*= FALSE*/)
{
   COCRUtilApp * pTheApp = (COCRUtilApp *)AfxGetApp();
   if (pTheApp && pTheApp->m_Bitmap.Flags.Allocated && !bPaste)
   {
      L_FreeBitmap(&pTheApp->m_Bitmap);
      L_InitBitmap(&pTheApp->m_Bitmap, sizeof(BITMAPHANDLE), 0, 0, 0);
   }

   if (m_hPalette)
   {
      DeleteObject(m_hPalette);
      m_hPalette = NULL;
   }

   if (!m_hDoc)
   {
      m_nPageIndex   = -1;
      m_nZoneIndex   = -1;
      m_fZoomPercent = 100.0;
      m_bImageLoaded = FALSE;
      m_bNextZone    = FALSE;
      m_bShowZones   = TRUE;
      m_bRecognized  = FALSE;
      m_bFindZone    = FALSE;
      m_nRecogEndIndex=0;
   }

   m_bShowPage    = FALSE;
   m_bImageLoaded = FALSE;
   m_bSelectZone  = FALSE;
   m_nSelZoneIndex= -1;
   m_bResize      = FALSE;
   m_nDrawMode    = -1;
   m_ptResize.x   = m_ptResize.y = 0;
   m_rcRgn.SetRectEmpty();
   m_rcFrame.SetRectEmpty();
   m_rcDst.SetRectEmpty();
   m_rcSelZone.SetRectEmpty();
   m_rcSelOrigZone.SetRectEmpty();
   m_nViewScale = 0;
}

void COCRUtilView::OnFileClose()
{
   Free();
   m_bImageLoaded = FALSE;

   CSize sizeTotal;

   sizeTotal.cx = sizeTotal.cy = 0;
   SetScrollSizes(MM_TEXT, sizeTotal);
   UpdateView();
}

void COCRUtilView::OnUpdateFileClose(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(!m_bScanStarted && m_bImageLoaded);
}

/************************* Utility Functions *************************/
BOOL COCRUtilView::OnEraseBkgnd(CDC* pDC) 
{
   CRect rcClient;
   GetClientRect(&rcClient);

   CBrush br(GetSysColor(DKGRAY_BRUSH));
   FillOutsideRect(pDC, &br);
   return TRUE;
}

void COCRUtilView::UpdateView()
{
   CSize sizeTotal;

   COCRUtilDoc * pDoc = (COCRUtilDoc *)GetDocument();
   if (m_nPageIndex != -1 && m_bImageLoaded && m_bShowPage)
   {
      PAGEINFO PageInfo;

      memset(&PageInfo, 0, sizeof(PAGEINFO));
      L_DocGetPageInfo(m_hDoc, m_nPageIndex, &PageInfo, sizeof(PAGEINFO));

      L_INT nNewWidth  = (L_INT)(PageInfo.nWidth  * m_fZoomPercent / 100.0);
      L_INT nNewHeight = (L_INT)(PageInfo.nHeight * m_fZoomPercent / 100.0);

      m_rcDst.SetRect(0, 0, nNewWidth, nNewHeight);
      m_rcSelZone.SetRect((L_INT)(m_rcSelOrigZone.left  * m_fZoomPercent / 100.0),
                          (L_INT)(m_rcSelOrigZone.top   * m_fZoomPercent / 100.0),
                          (L_INT)(m_rcSelOrigZone.right * m_fZoomPercent / 100.0),
                          (L_INT)(m_rcSelOrigZone.bottom* m_fZoomPercent / 100.0));

      sizeTotal.cx = nNewWidth;
      sizeTotal.cy = nNewHeight;

      COCRUtilApp * pTheApp = (COCRUtilApp *)AfxGetApp();
      if (pTheApp && pTheApp->m_Bitmap.Flags.Allocated)
      {
         L_FreeBitmap(&pTheApp->m_Bitmap);
         L_InitBitmap(&pTheApp->m_Bitmap, sizeof(BITMAPHANDLE), 0, 0, 0);
      }

      L_DocExportPage(m_hDoc, &pTheApp->m_Bitmap, sizeof(BITMAPHANDLE), m_nPageIndex);
      L_DocSetActivePage(m_hDoc, m_nPageIndex);
      m_bImageLoaded = TRUE;

      CString csTitle;
      if (m_nPageIndex >= 0)
         csTitle.Format(TEXT("Page Number %d"), m_nPageIndex+1);
      else
         csTitle.Format(TEXT("No attached Page"));

      pDoc->SetTitle(csTitle);
      OnDoRealize((WPARAM)AfxGetApp()->m_pMainWnd->m_hWnd, (LPARAM) FALSE);
   }
   else
   {
      sizeTotal.cx = sizeTotal.cy = 0;
      m_bImageLoaded = FALSE;

      if (IsWindow(m_hWnd))
         pDoc->SetTitle(TEXT("Untitled"));
   }

   if (IsWindow(m_hWnd))
   {
      SetScrollSizes(MM_TEXT, sizeTotal);
      RedrawWindow();
   }
}

void COCRUtilView::UpdateScrollView()
{
   CSize sizeTotal;
   COCRUtilApp * pTheApp = (COCRUtilApp *)AfxGetApp();

   if (pTheApp->m_Bitmap.Flags.Allocated)
   {
      sizeTotal.cx = BITMAPWIDTH(&pTheApp->m_Bitmap);
      sizeTotal.cy = BITMAPHEIGHT(&pTheApp->m_Bitmap);
      m_bImageLoaded = TRUE;
      m_fZoomPercent = 100.0;

      OnDoRealize((WPARAM)AfxGetApp()->m_pMainWnd->m_hWnd, (LPARAM) FALSE);
   }
   else
   {
      sizeTotal.cx = sizeTotal.cy = 0;
      m_bImageLoaded = FALSE;
   }

   SetScrollSizes(MM_TEXT, sizeTotal);
   RedrawWindow();
}

LONG COCRUtilView::OnDoRealize(WPARAM wParam, LPARAM lParam)
{
   UINT nColorsChanged = 0;

   COCRUtilApp * pTheApp = (COCRUtilApp *)AfxGetApp();
   if (!pTheApp->m_Bitmap.Flags.Allocated)
      return 0;

   if (lParam)
   {
      if (((HWND) wParam) == m_hWnd)
         return(FALSE);
   }

   if (m_hPalette!=NULL)
   {
      DeleteObject(m_hPalette);
      m_hPalette=NULL;
   }

   CClientDC dc(this);
   m_hPalette = L_CreatePaintPalette(dc.m_hDC, &pTheApp->m_Bitmap);
   if (m_hPalette)
   {
      HPALETTE oldPalette  = ::SelectPalette(dc.m_hDC, m_hPalette, (BOOL) lParam);
      nColorsChanged = RealizePalette(dc);
      if (nColorsChanged > 0)
         Invalidate();

      ::SelectPalette(dc.m_hDC, oldPalette, TRUE);
   }

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

void COCRUtilView::OnActivateView(BOOL bActivate, CView* pActivateView, CView* pDeactiveView) 
{
   if (bActivate)
      OnDoRealize((WPARAM)AfxGetApp()->m_pMainWnd->m_hWnd, (LPARAM) FALSE); // same as SendMessage(WM_DOREALIZE);

   CScrollView::OnActivateView(bActivate, pActivateView, pDeactiveView);
}

L_BOOL COCRUtilView::AddPage()
{
   BeginWaitCursor();

   COCRUtilApp * pTheApp = (COCRUtilApp *)AfxGetApp();
   if (!pTheApp || !pTheApp->m_Bitmap.Flags.Allocated)
      return FALSE;

   L_INT nRet = L_DocAddPage(m_hDoc, &pTheApp->m_Bitmap, -1);
   if (nRet != SUCCESS)
   {
      CString csErr;

      csErr.Format(TEXT("Can't add page to engine\nError = %d\n"), nRet);
      AfxMessageBox(csErr);
   }
   else
   {
      L_INT nPageCount = 0;
      L_DocGetPageCount(m_hDoc, &nPageCount);
      if (m_nPageIndex == -1)
      {
         m_bShowPage = TRUE;
         m_nPageIndex = nPageCount - 1;
         L_DocSetPaintZoomFactor(m_hDoc, m_nPageIndex, 100.0);
         m_bImageLoaded = TRUE;
      }

      UpdateView();
   }

   m_bImageLoaded = (nRet == SUCCESS) ? TRUE : FALSE;
   EndWaitCursor();
   return m_bImageLoaded;
}

L_BOOL COCRUtilView::InitEngine()
{
   if (L_IsSupportLocked(L_SUPPORT_OCR))
   {
      AfxMessageBox(TEXT("You need to unlock the OCR engine before you can use this demo!"));
      return FALSE;
   }

   BeginWaitCursor();
   L_INT nRet = L_DocStartUp(&m_hDoc);
   if (nRet == SUCCESS)
   {
      m_hZonePen = CreatePen(PS_SOLID, 2, RGB(128, 128, 128));
      m_hSelZonePen = CreatePen(PS_SOLID, 2, RGB(0, 255, 255));

      L_DocSetZonePen(m_hDoc, m_hZonePen);
      L_DocSetSelectedZonePen(m_hDoc, m_hSelZonePen);
   }
   else
   {
      if (nRet != ERROR_DOC_INITIALIZE_ENGINE)
         AfxMessageBox(TEXT("Failed while initializing the OCR Engine"));
      else
      {
         CEngineMsg engineDlg;
         engineDlg.DoModal();
      }

      return -1;
   }

   EndWaitCursor();
   return (nRet == SUCCESS) ? TRUE : FALSE;
}

CString COCRUtilView::GetMultiFileName(CString csFileName, L_INT nFormat, L_INT nPage, L_INT nExpCount)
{
   L_BOOL bMulti = FALSE;
   switch (nFormat)
   {
   case FILE_FAX_G4:
   case FILE_FAX_G3_2D:
   case FILE_FAX_G3_1D:
   case FILE_CCITT_GROUP4:
   case FILE_CCITT_GROUP3_2DIM:
   case FILE_CCITT_GROUP3_1DIM:
   case FILE_GIF:
   case FILE_ICA_G3_1D:
   case FILE_ICA_G3_2D:
   case FILE_ICA_G4:
   case FILE_PCX:
   case FILE_TGA:
   case FILE_TIFLZW:
   case FILE_TIFLZW_CMYK:
   case FILE_TIFLZW_YCC:
   case FILE_TIF:
   case FILE_TIF_CMYK:
   case FILE_TIF_YCC:
   case FILE_TIF_PACKBITS:
   case FILE_TIF_PACKBITS_CMYK:
   case FILE_TIF_PACKBITS_YCC:
   case FILE_TIF_CMP:
   case FILE_TIF_JBIG:
   case FILE_TIF_DXF:
   case FILE_TIF_J2K:
   case FILE_TIF_CMW:
   case FILE_LEAD2JTIF:
   case FILE_LEAD1JTIF:
   case FILE_WIN_ICO:
   case FILE_WIN_CUR:
   case FILE_IFF_CAT:
   case FILE_FLC:
   case FILE_ANI:
   case FILE_RAS_PDF:
   case FILE_RAS_PDF_G3_1D:
   case FILE_RAS_PDF_G3_2D:
   case FILE_RAS_PDF_G4:
   case FILE_RAS_PDF_JPEG:
   case FILE_RAS_PDF_JPEG_422:
   case FILE_RAS_PDF_JPEG_411:
      bMulti = TRUE;
      break;
   }

   CString csName;
   if (!bMulti && nExpCount > 1)
   {
      L_TCHAR szScanNo[10];
      L_TCHAR szDrive[_MAX_DRIVE];
      L_TCHAR szDir[_MAX_DIR];
      L_TCHAR szFName[_MAX_FNAME];
      L_TCHAR szExt[_MAX_EXT];

      LPTSTR lptstrFName = csName.GetBuffer(MAX_PATH);

      memset(szDrive, 0, sizeof(szDrive));
      memset(szDir, 0, sizeof(szDir));
      memset(szFName, 0, sizeof(szFName));
      memset(szExt, 0, sizeof(szExt));

      _tsplitpath(csFileName, szDrive, szDir, szFName, szExt);

      memset(szScanNo, 0, sizeof(szScanNo));
      wsprintf(szScanNo, TEXT("%d"), nPage);
      lstrcat(szFName, szScanNo);

      _tmakepath(lptstrFName, szDrive, szDir, szFName, szExt);
      csName.ReleaseBuffer();
   }
   else
      csName = csFileName;

   return csName;
}

/************************* Pages Menu *************************/
void COCRUtilView::OnPagesShowPage() 
{
   if (!ShowOCRErrMsg())
      return;

   L_INT nPageCount=0;
   L_INT nRet = L_DocGetPageCount(m_hDoc, &nPageCount);
   if (nRet != SUCCESS)
   {
      AfxMessageBox(TEXT("Can't initialize Show Page dialog"));
      return;
   }

   CSelectPage dlgSelPage(SELECT_PAGE_SHOW, nPageCount);
   if (dlgSelPage.DoModal() == IDOK)
   {
      m_nPageIndex = dlgSelPage.m_nPageNum - 1;
      m_bShowPage = TRUE;
      m_bImageLoaded = TRUE;
      UpdateView();
   }
}

void COCRUtilView::OnUpdatePagesShowPage(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(!m_bScanStarted);
}

void COCRUtilView::OnPagesDeletePage() 
{
   if (!ShowOCRErrMsg())
      return;

   L_INT nPageCount=0;
   L_INT nRet = L_DocGetPageCount(m_hDoc, &nPageCount);
   if (nRet != SUCCESS)
   {
      AfxMessageBox(TEXT("Can't initialize Show Page dialog"));
      return;
   }

   CSelectPage dlgSelPage(SELECT_PAGE_DEL, nPageCount);
   if (dlgSelPage.DoModal() == IDOK)
   {
      nRet = L_DocRemovePage(m_hDoc, dlgSelPage.m_nPageNum-1);
      if (nRet == SUCCESS)
      {
         L_DocGetPageCount(m_hDoc, &nPageCount);
         if (nPageCount == 0)
            m_nPageIndex = -1;
         else
            m_nPageIndex = (m_nPageIndex >= nPageCount) ? --m_nPageIndex : m_nPageIndex;

         UpdateView();
         if (m_nPageIndex)
         {
            L_INT nZoneCount =0;
            L_DocGetZoneCount(m_hDoc, m_nPageIndex, &nZoneCount);

            m_bFindZone = (nZoneCount > 0) ? TRUE : FALSE;
         }
         else
            m_bFindZone = FALSE;
         m_bRecognized = (m_nPageIndex == -1) ? FALSE : TRUE;
      }
      else
         AfxMessageBox(TEXT("Error, couldn't remove the specified page"));
   }
}

void COCRUtilView::OnUpdatePagesDeletePage(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(!m_bScanStarted);
}

void COCRUtilView::OnPagesInsertPage() 
{
   if (!ShowOCRErrMsg(FALSE))
      return;

   CInsertPage dlgInsert;
   BITMAPHANDLE Bitmap;

   if (dlgInsert.DoModal() != IDOK)
      return;

   FILEINFO FInfo;
   L_INT    nRet = SUCCESS;

   memset(&FInfo, 0, sizeof(FILEINFO));
   nRet = L_FileInfo((L_TCHAR *)(LPCTSTR)dlgInsert.m_csFileName, &FInfo, sizeof(FILEINFO), FILEINFO_TOTALPAGES, NULL);
   if (nRet != SUCCESS)
   {
      CString csError;

      csError.Format(TEXT("Can't insert selected file %s\n"), dlgInsert.m_csFileName);
      AfxMessageBox(csError);
      return;
   }

   LOADFILEOPTION LoadOpt;

   memset(&LoadOpt, 0, sizeof(LOADFILEOPTION));
   L_GetDefaultLoadFileOption(&LoadOpt, sizeof(LOADFILEOPTION));
   L_InitBitmap(&Bitmap, sizeof(BITMAPHANDLE), 0, 0, 0);
   if (dlgInsert.m_bInsertAll)
   {
      for (L_INT i=0; i<FInfo.TotalPages; i++)
      {
         LoadOpt.PageNumber = i;
         nRet = L_LoadBitmap((L_TCHAR *)(LPCTSTR)dlgInsert.m_csFileName,
                             &Bitmap, sizeof(BITMAPHANDLE), 0, ORDER_BGRORGRAY, &LoadOpt, NULL);

         if (nRet != SUCCESS)
            continue;

         nRet = L_DocAddPage(m_hDoc, &Bitmap, dlgInsert.m_nIndex-1);
         if (nRet != SUCCESS)
         {
            CString csError;
            csError.Format(TEXT("Can't add page # %d from file %s\n"), i, dlgInsert.m_csFileName);
            AfxMessageBox(csError);
            break;
         }

         L_FreeBitmap(&Bitmap);
      }

      L_INT nPageCount = 0;
      L_DocGetPageCount(m_hDoc, &nPageCount);
      if (m_nPageIndex == -1 && nPageCount > 0)
      {
         m_bImageLoaded = TRUE;
         m_bShowPage = TRUE;
         m_nPageIndex = nPageCount - 1;
      }

      UpdateView();
   }
   else
   {
      LoadOpt.PageNumber = dlgInsert.m_nPageNumber;
      nRet = L_LoadBitmap((L_TCHAR *)(LPCTSTR)dlgInsert.m_csFileName,
                          &Bitmap, sizeof(BITMAPHANDLE), 0, ORDER_BGRORGRAY, &LoadOpt, NULL);

      if (nRet != SUCCESS)
      {
         CString csError;
         csError.Format(TEXT("Can't load page # %d from file %s\n"), dlgInsert.m_nPageNumber, dlgInsert.m_csFileName);
         AfxMessageBox(csError);
         return;
      }

      nRet = L_DocAddPage(m_hDoc, &Bitmap, dlgInsert.m_nIndex-1);
      if (nRet != SUCCESS)
      {
         CString csError;
         csError.Format(TEXT("Can't add page # %d from file %s\n"), dlgInsert.m_nPageNumber, dlgInsert.m_csFileName);
         AfxMessageBox(csError);
      }
      else
      {
         L_FreeBitmap(&Bitmap);

         L_INT nPageCount = 0;
         L_DocGetPageCount(m_hDoc, &nPageCount);
         if (m_nPageIndex == -1 && nPageCount > 0)
         {
            m_bImageLoaded = TRUE;
            m_bShowPage = TRUE;
            m_nPageIndex = nPageCount - 1;
         }

         UpdateView();
      }
   }
}

void COCRUtilView::OnUpdatePagesInsertPage(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(!m_bScanStarted);
}

void COCRUtilView::OnPagesInsertcurrentimage() 
{
   if (!ShowOCRErrMsg(FALSE))
      return;

   m_nPageIndex = -1;
   AddPage();
}

void COCRUtilView::OnUpdatePagesInsertcurrentimage(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(!m_bScanStarted && m_bImageLoaded);
}

void COCRUtilView::OnPagesPageCount() 
{
   if (!ShowOCRErrMsg())
      return;

   L_INT nPageCount=0;
   L_INT nRet = L_DocGetPageCount(m_hDoc, &nPageCount);
   if (nRet != SUCCESS)
      return;

   CString csMsg;

   csMsg.Format(TEXT("Page Count = %d\n"), nPageCount);
   AfxMessageBox(csMsg);
}

void COCRUtilView::OnUpdatePagesPageCount(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(!m_bScanStarted);
}

void COCRUtilView::OnEditCopy() 
{
   BITMAPHANDLE Bitmap;
   L_INT        nRet = SUCCESS;

   L_InitBitmap(&Bitmap, sizeof(BITMAPHANDLE), 0, 0, 0);

   if (m_hDoc && m_nPageIndex != -1)
   {
      nRet = L_DocExportPage(m_hDoc, &Bitmap, sizeof(BITMAPHANDLE), m_nPageIndex);
      if (nRet != SUCCESS)
      {
         AfxMessageBox(TEXT("Can't copy the active page"));
         return;
      }

      L_CopyToClipboard(GetSafeHwnd(), &Bitmap, COPY2CB_EMPTY | COPY2CB_DIB | COPY2CB_PALETTE);
      L_FreeBitmap(&Bitmap);
   }
   else
   {
      COCRUtilApp * pApp = (COCRUtilApp *)AfxGetApp();
      L_CopyToClipboard(GetSafeHwnd(), &pApp->m_Bitmap, COPY2CB_EMPTY | COPY2CB_DIB | COPY2CB_PALETTE);
   }
}

void COCRUtilView::OnUpdateEditCopy(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(!m_bScanStarted && m_bImageLoaded);
}

void COCRUtilView::OnPagesExportPage() 
{
   L_INT nPageCount=0;
   L_INT nRet = L_DocGetPageCount(m_hDoc, &nPageCount);
   if (nPageCount == 0)
   {
      AfxMessageBox(TEXT("There is no page to export"));
      return;
   }

   CExportPages dlgExprtPage(nPageCount);
   if (dlgExprtPage.DoModal() != IDOK)
      return;

   ExportPages(dlgExprtPage.m_csFileName,
               &dlgExprtPage.m_FSParm,
               dlgExprtPage.m_bExportAll ? 0 : dlgExprtPage.m_nPageNumber-1,
               dlgExprtPage.m_bExportAll ? nPageCount : 1);
}

void COCRUtilView::OnUpdatePagesExportPage(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(!m_bScanStarted && m_hDoc && m_nPageIndex != -1);
}

void COCRUtilView::ExportPages(CString csFileName, SAVEDLGPARAMS * pSParm, L_INT nPage, L_INT nCount)
{
   L_INT          nStartPage = (nCount == 1) ? nPage : 0;
   L_INT          nEndPage = (nCount == 1) ? nPage+1 : nCount;
   L_INT          nRet;
   CString        csError;
   BITMAPHANDLE   Bitmap;
   SAVEFILEOPTION SaveOption;
   L_UINT         uFlags=0;
   CString        csName;

   memset(&SaveOption, 0, sizeof(SAVEFILEOPTION));
   L_GetDefaultSaveFileOption(&SaveOption, sizeof(SAVEFILEOPTION));

   if (pSParm->uSaveMulti & MULTIPAGE_OPERATION_APPEND == MULTIPAGE_OPERATION_APPEND)
      uFlags = SAVEFILE_MULTIPAGE;

   if (pSParm->uSaveMulti & MULTIPAGE_OPERATION_REPLACE == MULTIPAGE_OPERATION_REPLACE)
      SaveOption.Flags |= ESO_REPLACEPAGE;

   if (pSParm->uSaveMulti & MULTIPAGE_OPERATION_INSERT == MULTIPAGE_OPERATION_INSERT)
      SaveOption.Flags |= ESO_INSERTPAGE;

   for (L_INT i=nStartPage; i<nEndPage; i++)
   {
      L_InitBitmap(&Bitmap, sizeof(BITMAPHANDLE), 0, 0, 0);
      nRet = L_DocExportPage(m_hDoc, &Bitmap, sizeof(BITMAPHANDLE), i);
      if (nRet != SUCCESS)
      {
         csError.Format(TEXT("Can't export page #\n"), i);
         AfxMessageBox(csError);
         continue;
      }

      SaveOption.PageNumber = pSParm->nPageNumber;
      csName = GetMultiFileName(csFileName, pSParm->nFormat, i, nCount);

      nRet = L_SaveFile((L_TCHAR *)(LPCTSTR)csName,
                        &Bitmap,
                        pSParm->nFormat,
                        pSParm->nBitsPerPixel,
                        pSParm->nQFactor,
                        uFlags,
                        NULL,
                        NULL,
                        &SaveOption);

      L_FreeBitmap(&Bitmap);
   }
}

void COCRUtilView::OnPagesProcessFlip() 
{
   if (!ShowOCRErrMsg())
      return;

   BITMAPHANDLE Bitmap;

   L_InitBitmap(&Bitmap, sizeof(BITMAPHANDLE), 0, 0, 0);
   L_INT nRet = L_DocExportPage(m_hDoc, &Bitmap, sizeof(BITMAPHANDLE), m_nPageIndex);
   if (nRet != SUCCESS)
   {
      AfxMessageBox(TEXT("Can't export page the current page"));
      return;
   }

   L_FlipBitmap(&Bitmap);
   L_DocLockPage(m_hDoc, m_nPageIndex);
   nRet = L_DocUpdatePage(m_hDoc, &Bitmap, m_nPageIndex);
   if (nRet != SUCCESS)
      AfxMessageBox(TEXT("Can't update the current page"));
   L_DocUnlockPage(m_hDoc, m_nPageIndex);
   UpdateView();
   RedrawWindow();

   L_FreeBitmap(&Bitmap);
}

void COCRUtilView::OnUpdatePagesProcessFlip(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(!m_bScanStarted && m_hDoc && m_nPageIndex != -1);
}

void COCRUtilView::OnPagesProcessRotate() 
{
   if (!ShowOCRErrMsg())
      return;

   BITMAPHANDLE Bitmap;

   L_InitBitmap(&Bitmap, sizeof(BITMAPHANDLE), 0, 0, 0);
   L_INT nRet = L_DocExportPage(m_hDoc, &Bitmap, sizeof(BITMAPHANDLE), m_nPageIndex);
   if (nRet != SUCCESS)
   {
      AfxMessageBox(TEXT("Can't export page the current page"));
      return;
   }

   ROTATEDLGPARAMS RotateDlgParam;

   memset(&RotateDlgParam, 0, sizeof(ROTATEDLGPARAMS));

   RotateDlgParam.uStructSize = sizeof(ROTATEDLGPARAMS);
   RotateDlgParam.pBitmap     = &Bitmap;
   RotateDlgParam.bResize     = TRUE ;
   RotateDlgParam.crBack      = RGB(255, 255, 255);
   RotateDlgParam.uDlgFlags   = DLG_ROTATE_AUTOPROCESS |
                                DLG_ROTATE_SHOW_PREVIEW|
                                DLG_ROTATE_SHOW_RESIZE |
                                DLG_ROTATE_SHOW_BACKCOLOR;

   nRet = L_DlgRotate(m_hWnd, &RotateDlgParam);
   if (nRet == SUCCESS_DLG_OK)
   {
      L_DocLockPage(m_hDoc, m_nPageIndex);
      nRet = L_DocUpdatePage(m_hDoc, RotateDlgParam.pBitmap, m_nPageIndex);
      if (nRet != SUCCESS)
         AfxMessageBox(TEXT("Can't update the current page"));
      L_DocUnlockPage(m_hDoc, m_nPageIndex);

      UpdateView();
      RedrawWindow();
   }

   L_FreeBitmap(&Bitmap);
}

void COCRUtilView::OnUpdatePagesProcessRotate(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(!m_bScanStarted && m_hDoc && m_nPageIndex != -1);
}

void COCRUtilView::OnPagesProcessSkew() 
{
   if (!ShowOCRErrMsg())
      return;

   BITMAPHANDLE Bitmap;

   L_InitBitmap(&Bitmap, sizeof(BITMAPHANDLE), 0, 0, 0);
   L_INT nRet = L_DocExportPage(m_hDoc, &Bitmap, sizeof(BITMAPHANDLE), m_nPageIndex);
   if (nRet != SUCCESS)
   {
      AfxMessageBox(TEXT("Can't export page the current page"));
      return;
   }

   L_DeskewBitmap(&Bitmap, NULL, RGB(255, 255, 255), DSKW_PROCESS | DSKW_NOFILL);
   L_DocLockPage(m_hDoc, m_nPageIndex);
   nRet = L_DocUpdatePage(m_hDoc, &Bitmap, m_nPageIndex);
   if (nRet != SUCCESS)
      AfxMessageBox(TEXT("Can't update the current page"));
   L_DocUnlockPage(m_hDoc, m_nPageIndex);

   UpdateView();
   RedrawWindow();

   L_FreeBitmap(&Bitmap);
}

void COCRUtilView::OnUpdatePagesProcessSkew(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(!m_bScanStarted && m_hDoc && m_nPageIndex != -1);
}

/************************* Zone Menu *************************/
void COCRUtilView::OnFindZones() 
{
   if (!ShowOCRErrMsg())
      return;

   if (!m_bImageLoaded || m_nPageIndex < 0)
   {
      AfxMessageBox(TEXT("There is no active page, to active page:\nUse Page -> Show Page"));
      return;
   }


   AUTOZONEOPTS AutoOpts;

   memset(&AutoOpts, 0, sizeof(AUTOZONEOPTS));
   L_INT nRet = L_DocGetZoneOptions(m_hDoc, &AutoOpts, sizeof(AUTOZONEOPTS));
   if (nRet == SUCCESS)
   {
      CAutoZoneOptions dlgZoneOpts(&AutoOpts);

      if (dlgZoneOpts.DoModal() == IDOK)
         L_DocSetZoneOptions(m_hDoc, &AutoOpts);
      else
         return;
   }
   else
   {
      AfxMessageBox(TEXT("Can't show Zone Options dialog"));
      return;
   }

   BeginWaitCursor();
   m_bFindZone = FALSE;
   nRet = L_DocFindZones(m_hDoc, m_nPageIndex, NULL);
   if (nRet == SUCCESS)
   {
      AfxMessageBox(TEXT("Find Zones process successful"));
      m_nZoneIndex = 0;
      m_bNextZone = FALSE;
      m_bFindZone = TRUE;
      RedrawWindow();
   }
   else
      AfxMessageBox(TEXT("Failed during Find Zones"));
   EndWaitCursor();
}

void COCRUtilView::OnUpdateFindZones(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(!m_bScanStarted);
}

void COCRUtilView::OnDeleteZone() 
{
   L_INT nRet = SUCCESS;
   L_INT nZoneCount = 0;
   nRet = L_DocGetZoneCount(m_hDoc, m_nPageIndex, &nZoneCount);

   CZoneRemove dlgDelZone(nZoneCount);
   if (dlgDelZone.DoModal() != IDOK)
      return;

   nRet = L_DocRemoveZone(m_hDoc, m_nPageIndex, (dlgDelZone.m_bDelZones) ? -1 : dlgDelZone.m_nZoneIndex-1);
   if (nRet == SUCCESS)
      AfxMessageBox(TEXT("The selected zones were deleted successfully."));
   else
   {
      CString csError;

      if (dlgDelZone.m_bDelZones)
         csError.Format(TEXT("Can't delete all zones"));
      else
         csError.Format(TEXT("Can't delete zone # %d\n"));

      AfxMessageBox(csError);
   }

   nZoneCount = 0;
   L_DocGetZoneCount(m_hDoc, m_nPageIndex, &nZoneCount);
   m_bFindZone = (nZoneCount != 0);

   if (!m_bFindZone)
   {
      m_nSelZoneIndex = -1;
      m_bSelectZone   = FALSE;
      m_nDrawMode     = -1;
   }

   RedrawWindow();
}

void COCRUtilView::OnUpdateDeleteZone(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(!m_bScanStarted && m_hDoc && m_nPageIndex != -1 && m_bFindZone);
}

void COCRUtilView::OnGetFirstZone() 
{
   L_INT nRet = SUCCESS;
   ZONEDATA Zone;

   memset(&Zone, 0, sizeof(ZONEDATA));
   nRet = L_DocGetZone(m_hDoc, m_nPageIndex, 0, &Zone, sizeof(ZONEDATA));
   if (nRet != SUCCESS)
   {
      AfxMessageBox(TEXT("Can't get first zone information"));
      m_bNextZone = FALSE;
      m_nZoneIndex = 0;
      return;
   }

   m_bNextZone = TRUE;
   m_nZoneIndex = 0;

   CZoneInfo dlgZoneInfo(&Zone, m_nZoneIndex);
   dlgZoneInfo.DoModal();
}

void COCRUtilView::OnUpdateGetFirstZone(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(!m_bScanStarted && m_hDoc && m_nPageIndex != -1 && m_nZoneIndex != -1 && m_bFindZone);
}

void COCRUtilView::OnGetNextZone() 
{
   L_INT nZoneCount = 0;
   L_DocGetZoneCount(m_hDoc, m_nPageIndex, &nZoneCount);
   if (m_nZoneIndex+1 >= nZoneCount)
   {
      AfxMessageBox(TEXT("Zone list is reached to end"));
      m_bNextZone = FALSE;
      m_nZoneIndex = 0;
      return;
   }

   L_INT nRet = SUCCESS;
   ZONEDATA Zone;

   memset(&Zone, 0, sizeof(ZONEDATA));
   nRet = L_DocGetZone(m_hDoc, m_nPageIndex, m_nZoneIndex+1, &Zone, sizeof(ZONEDATA));
   if (nRet != SUCCESS)
   {
      AfxMessageBox(TEXT("Can't get zone information"));
      m_bNextZone = FALSE;
      m_nZoneIndex = 0;
      return;
   }

   m_bNextZone = TRUE;
   m_nZoneIndex++;

   CZoneInfo dlgZoneInfo(&Zone, m_nZoneIndex);
   dlgZoneInfo.DoModal();
}

void COCRUtilView::OnUpdateGetNextZone(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(!m_bScanStarted && m_hDoc && m_nPageIndex != -1 && m_bNextZone && m_bFindZone);
}

void COCRUtilView::OnExportZoneFile() 
{
   CZoneFile dlgZoneFile(FALSE);

   if (dlgZoneFile.DoModal() != IDOK)
      return;

   L_INT    nRet;
   CString  csErr;

   nRet = L_DocExportZones(m_hDoc, m_nPageIndex, (L_TCHAR *)(LPCTSTR)dlgZoneFile.m_csZoneFileName);
   if (nRet == SUCCESS)
   {
      csErr.Format(TEXT("The Zone file %s is exported successfully"), dlgZoneFile.m_csZoneFileName);
      AfxMessageBox(csErr);
   }
   else
   {
      csErr.Format(TEXT("Failed exporting Zone file %s\n"), dlgZoneFile.m_csZoneFileName);
      AfxMessageBox(csErr);
   }
}

void COCRUtilView::OnUpdateExportZoneFile(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(!m_bScanStarted && m_hDoc && m_nPageIndex != -1 && m_bFindZone);
}

void COCRUtilView::OnLoadZoneFile() 
{
   if (!ShowOCRErrMsg())
      return;

   CZoneFile dlgZoneFile(TRUE);

   if (dlgZoneFile.DoModal() != IDOK)
      return;

   L_INT    nRet;
   CString  csErr;

   nRet = L_DocImportZones(m_hDoc, m_nPageIndex, (L_TCHAR *)(LPCTSTR)dlgZoneFile.m_csZoneFileName);
   if (nRet == SUCCESS)
   {
      csErr.Format(TEXT("The Zone file %s is loaded successfully"), dlgZoneFile.m_csZoneFileName);
      AfxMessageBox(csErr);

      m_nZoneIndex = 0;
      m_bNextZone = FALSE;
      m_bFindZone = TRUE;
      RedrawWindow();
   }
   else
   {
      csErr.Format(TEXT("Failed loading Zone file %s\n"), dlgZoneFile.m_csZoneFileName);
      AfxMessageBox(csErr);
   }
}

void COCRUtilView::OnUpdateLoadZoneFile(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(!m_bScanStarted);
}

void COCRUtilView::OnZonesCount() 
{
   if (!ShowOCRErrMsg())
      return;

   L_INT nZoneCount = 0;

   L_INT nRet = L_DocGetZoneCount(m_hDoc, m_nPageIndex, &nZoneCount);
   if (nRet == SUCCESS)
   {
      CString csBuffer;

      csBuffer.Format(TEXT("Zone Count = %d\n"), nZoneCount);
      AfxMessageBox(csBuffer);
   }
}

void COCRUtilView::OnUpdateZonesCount(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(!m_bScanStarted);
}

void COCRUtilView::OnZoneShowZones() 
{
   m_bShowZones = !m_bShowZones;
   RedrawWindow();
}

void COCRUtilView::OnUpdateZoneShowZones(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(!m_bScanStarted && m_hDoc && m_bFindZone);
   pCmdUI->SetCheck(m_bShowZones);
}

void COCRUtilView::OnZoneUpdate()
{
   ZONEDATA ZoneData;

   memset(&ZoneData, 0, sizeof(ZONEDATA));
   L_INT nRet = L_DocGetSelectedZone(m_hDoc, m_nPageIndex, &ZoneData, sizeof(ZONEDATA));
   if (nRet != SUCCESS)
   {
      AfxMessageBox(TEXT("Can't get Zone data for the selected zone"));
      return;
   }

   CZoneData ZoneDataDlg(&ZoneData);
   if (ZoneDataDlg.DoModal() != IDOK)
      return;

   nRet = L_DocUpdateZone(m_hDoc, m_nPageIndex, m_nSelZoneIndex, ZoneDataDlg.m_pZoneData);
   if (nRet == SUCCESS)
   {
      AfxMessageBox(TEXT("The selected zone data is updated successfully"));
      RedrawWindow();
   }
   else
      AfxMessageBox(TEXT("Error ocurrd during updatin the selected zone data"));
}

void COCRUtilView::OnUpdateZoneUpdate(CCmdUI* pCmdUI)
{
   pCmdUI->Enable(!m_bScanStarted && m_hDoc && m_nPageIndex != -1 && m_nSelZoneIndex != -1 && m_bSelectZone);
}

/************************* Language Menu *************************/
void COCRUtilView::OnLanguageSelectLanguage() 
{
   if (!ShowOCRErrMsg(FALSE))
      return;

   CLanguage dlgLang;
   if (dlgLang.DoModal() != IDOK)
      return;

   L_INT nRet = L_DocSelectLanguages(m_hDoc, dlgLang.m_pLangIds, dlgLang.m_nLangCount);
   if (nRet != SUCCESS)
      AfxMessageBox(TEXT("Can't set selected languages successfully"));
}

void COCRUtilView::OnUpdateLanguageSelectLanguage(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(!m_bScanStarted);
}

/************************* OCR Menu *************************/
void COCRUtilView::OnOcrRecognitionOptions() 
{
   if (!ShowOCRErrMsg())
      return;

   CModuleOptions dlgModOpts;
   if (dlgModOpts.DoModal() != IDOK)
      return;

   HANDPRINTOPTIONS hnrOpts;
   MOROPTIONS       morOpts;
   OMROPTIONS       omrOpts;
   L_INT            nRet;

   memset(&hnrOpts, 0, sizeof(HANDPRINTOPTIONS));
   memset(&morOpts, 0, sizeof(MOROPTIONS));
   memset(&omrOpts, 0, sizeof(OMROPTIONS));

   nRet = L_DocSetRecognizeModuleTradeOff(m_hDoc, (RECOGMODULE_TRADEOFF)dlgModOpts.m_nAccuracy);
   if (nRet != SUCCESS)
      AfxMessageBox(TEXT("Can't set the selected Trade-off option"));

   switch (dlgModOpts.m_nModule)
   {
   case RECOG_MODULE_HNR:
      hnrOpts.uStructSize  = sizeof(HANDPRINTOPTIONS);
      hnrOpts.style        = (HANDRECOG_STYLE)dlgModOpts.m_nHNRStyle;
      hnrOpts.bSpace       = dlgModOpts.m_bHNRSpaceInc;
      hnrOpts.nCharHeight  = dlgModOpts.m_nHNRHeight;
      hnrOpts.nCharWidth   = dlgModOpts.m_nHNRWidth;
      hnrOpts.nCharSpace   = dlgModOpts.m_nHNRSpace;

      nRet = L_DocSetHandPrintOptions(m_hDoc, &hnrOpts);
      break;
   case RECOG_MODULE_MOR:
      morOpts.uStructSize= sizeof(MOROPTIONS);
      morOpts.bEnableFax = dlgModOpts.m_bMORFax;

      nRet = L_DocSetMOROptions(m_hDoc, &morOpts);
      break;
   case RECOG_MODULE_OMR:
      omrOpts.uStructSize = sizeof(OMROPTIONS);
      omrOpts.bFill       = dlgModOpts.m_bOMRFillZone;
      omrOpts.Frame       = (OMRFRAME)dlgModOpts.m_nOMRFrame;
      omrOpts.Sense       = (OMRSENSE)dlgModOpts.m_nOMRSense;

      nRet = L_DocSetOMROptions(m_hDoc, &omrOpts);
      break;
   }

   if (nRet != SUCCESS)
      AfxMessageBox(TEXT("Can't set the selected recognition module options"));
}

void COCRUtilView::OnUpdateOcrRecognitionOptions(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(!m_bScanStarted);
}

L_INT EXT_CALLBACK COCRUtilView::RecognizeStatusCB(L_INT nRecogPage, L_INT nError, L_VOID L_FAR * pUserData)
{
   CString csBuffer;
   CString csMsg;
   L_BOOL bShowOK=TRUE;

   if (nError == SUCCESS)
      csBuffer.Format(TEXT("The Page Number %d is recognized successfuly"), nRecogPage+1);
   else
      csBuffer.Format(TEXT("OCR Engine faild to recognize the page number %d"), nRecogPage+1);

   if (nRecogPage < m_nRecogEndIndex)
   {
      bShowOK = FALSE;
      csMsg.Format(TEXT("%s\nDo you need to recognize next page?"), csBuffer);
   }
   else
   {
      bShowOK = TRUE;
      csMsg = csBuffer;
   }

   L_INT nMsgID = AfxMessageBox(csMsg, bShowOK ? MB_OK : MB_YESNO);
   if (bShowOK)
      return SUCCESS;

   return (nMsgID == IDYES) ? SUCCESS : FAILURE;
}

void COCRUtilView::OnOcrRecognizePage() 
{
   if (!ShowOCRErrMsg())
      return;

   L_INT nPageCount=0;
   L_INT nRet = L_DocGetPageCount(m_hDoc, &nPageCount);
   if (nRet != SUCCESS)
   {
      AfxMessageBox(TEXT("Can't initialize Recognize dialog"));
      return;
   }

   CRecognizePage dlgRecog(m_csRecogDataFileName, m_hDoc, nPageCount);
   if (dlgRecog.DoModal() != IDOK)
      return;

   m_csRecogDataFileName = dlgRecog.m_csDataFile;

   RECOGNIZEOPTS RecogOpts;

   memset(&RecogOpts, 0, sizeof(RECOGNIZEOPTS));
   RecogOpts.uStructSize         = sizeof(RECOGNIZEOPTS);
   RecogOpts.nPageIndexStart     = dlgRecog.m_nStartPage-1;
   RecogOpts.nPagesCount         = dlgRecog.m_nEndPage;
   RecogOpts.bEnableSubSystem    = dlgRecog.m_bEnableSubSystem;
   RecogOpts.bEnableCorrection   = dlgRecog.m_bCorrectionMode;
   RecogOpts.SpellLangId         = dlgRecog.m_bUseDefaultSpellLang ? LANG_ID_ENGLISH : dlgRecog.m_SpellLang;
   RecogOpts.pszFileName         = (L_TCHAR *)(LPCTSTR)m_csRecogDataFileName;

   m_nRecogEndIndex = dlgRecog.m_nEndPage-1;
   m_bRecognized = FALSE;

   m_nStartRecogIndex = RecogOpts.nPageIndexStart;
   m_nEndRecogIndex = m_nRecogEndIndex;

   BeginWaitCursor();
   nRet = L_DocRecognize(m_hDoc,
                         &RecogOpts,
                         (dlgRecog.m_bUsePageStatus) ? RecognizeStatusCB : NULL,
                         this);

   EndWaitCursor();
   if (nRet != SUCCESS)
   {
      AfxMessageBox(TEXT("Can't recognize the specific pages"));
      return;
   }

   m_bRecognized = TRUE;

   // Check if the active page contains Zones or not to enable Show Zones menu item
   L_INT nZoneCount = 0;
   nRet = L_DocGetZoneCount(m_hDoc, m_nPageIndex, &nZoneCount);
   if (nRet == SUCCESS)
   {
      m_bFindZone = (nZoneCount != 0);
      RedrawWindow();
   }
}

void COCRUtilView::OnUpdateOcrRecognizePage(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(!m_bScanStarted);
}

void COCRUtilView::OnOcrSaveResult() 
{
   CSaveResult saveResDlg(m_hDoc);
   if (saveResDlg.DoModal() != IDOK)
      return;

   L_INT nRet = L_DocSaveResultsToFile(m_hDoc, (L_TCHAR *)(LPCTSTR)saveResDlg.m_csFileName);
   if (nRet != SUCCESS)
      AfxMessageBox(TEXT("Can't save recognition result to specific format"));
}

void COCRUtilView::OnUpdateOcrSaveResult(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(!m_bScanStarted && m_hDoc && m_nPageIndex != -1 && m_bRecognized);
}

/************************* Drawing Regions *************************/
void COCRUtilView::OnLButtonDown(UINT nFlags, CPoint point)
{
   if (m_bImageLoaded && !ShowOCRErrMsg())
      return;

   COCRUtilApp * pTheApp = (COCRUtilApp *)AfxGetApp();
   if (!pTheApp->m_Bitmap.Flags.Allocated)
      return;

   if (!m_bCapWnd)
   {
      SetCapture();
      m_bCapWnd = TRUE;
   }

   m_bLMDown = TRUE;
   if (m_nDrawMode != -1)
   {
      if (m_bShowZones)
      {
         if (m_nSelZoneIndex != -1 && m_bSelectZone)
         {
            CClientDC dc(this);
            L_DocSelectZone(m_hDoc, dc.m_hDC, m_nPageIndex, m_nSelZoneIndex, FALSE);
            RedrawWindow();
            m_bSelectZone = FALSE;

            m_bResize = TRUE;
            m_rcFrame = m_rcSelZone;
            m_rcFrame.OffsetRect(-GetScrollPos(SB_HORZ), -GetScrollPos(SB_VERT));

            m_ptResize.x = point.x;
            m_ptResize.y = point.y;
         }

         DrawRect();
      }
   }
   else if (!m_bResize)
   {
      m_rcFrame.SetRectEmpty();
      m_rcFrame.right  = m_rcFrame.left = point.x;
      m_rcFrame.bottom = m_rcFrame.top = point.y;

      DrawRect();
   }

   CScrollView::OnLButtonDown(nFlags, point);
}

void COCRUtilView::OnLButtonUp(UINT nFlags, CPoint point)
{
   COCRUtilApp * pTheApp = (COCRUtilApp *)AfxGetApp();
   if (!pTheApp->m_Bitmap.Flags.Allocated)
      return;

   L_BOOL bUpdateZoneArea = TRUE;
   if (m_bCapWnd)
   {
      ReleaseCapture();
      m_bCapWnd = FALSE;
   }

   m_bLMDown = FALSE;
   DrawRect();

   if ((m_rcFrame.left != m_rcFrame.right) || (m_rcFrame.top != m_rcFrame.bottom))
   {
      SetRect(&m_rcRgn,
              min(m_rcFrame.left, m_rcFrame.right),
              min(m_rcFrame.top,  m_rcFrame.bottom),
              max(m_rcFrame.left, m_rcFrame.right),
              max(m_rcFrame.top,  m_rcFrame.bottom));

      m_rcFrame.NormalizeRect();
      m_rcRgn.NormalizeRect();

      PAGEINFO PageInfo;

      memset(&PageInfo, 0, sizeof(PAGEINFO));
      L_DocGetPageInfo(m_hDoc, m_nPageIndex, &PageInfo, sizeof(PAGEINFO));

      L_INT nNewWidth  = (L_INT)(PageInfo.nWidth  * m_fZoomPercent / 100.0);
      L_INT nNewHeight = (L_INT)(PageInfo.nHeight * m_fZoomPercent / 100.0);

      CRect rcPage;
      rcPage.SetRect(0, 0, nNewWidth, nNewHeight);

      POINT ptLT, ptRB;

      ptLT.x = m_rcRgn.left;
      ptLT.y = m_rcRgn.top;

      ptRB.x = m_rcRgn.right;
      ptRB.y = m_rcRgn.bottom;

      if (!rcPage.PtInRect(ptLT) && !rcPage.PtInRect(ptRB))
         bUpdateZoneArea = FALSE;

      // Check if Left-Top point is in Page Area...
      if (!rcPage.PtInRect(ptLT))
      {
         m_rcFrame.left = max(m_rcFrame.left, 0);
         m_rcFrame.top  = max(m_rcFrame.top, 0);
      }

      // Check if Right-Bottom point is in Page Area...
      if (!rcPage.PtInRect(ptRB))
      {
         m_rcFrame.right  = min(m_rcFrame.right, nNewWidth);
         m_rcFrame.bottom = min(m_rcFrame.bottom, nNewHeight);
      }

      m_rcRgn = m_rcFrame;
   }

   L_INT nZoneIndex=-1;
   CClientDC dc(this);
   CPoint pt = point;
   pt.Offset(GetScrollPos(SB_HORZ), GetScrollPos(SB_VERT));

   if (!m_bResize)
   {
      L_BOOL bSelZone = TRUE;
      L_DocSelectZoneByPoint(m_hDoc, dc.m_hDC, m_nPageIndex, pt, &nZoneIndex);
      if (nZoneIndex != -1)
      {
         if (m_bShowZones)
         {
            if (m_nSelZoneIndex != -1)
               L_DocSelectZone(m_hDoc, dc.m_hDC, m_nPageIndex, m_nSelZoneIndex, FALSE);

            m_nSelZoneIndex= nZoneIndex;
            m_bSelectZone  = TRUE;
            m_bResize      = FALSE;

            L_DocSelectZone(m_hDoc, dc.m_hDC, m_nPageIndex, m_nSelZoneIndex, TRUE);

            ZONEDATA ZoneData;
            memset(&ZoneData, 0, sizeof(ZONEDATA));

            L_DocGetSelectedZone(m_hDoc, m_nPageIndex, &ZoneData, sizeof(ZONEDATA));
            m_rcSelZone.SetRect((L_INT)(ZoneData.rcArea.left  * m_fZoomPercent / 100.0),
                                (L_INT)(ZoneData.rcArea.top   * m_fZoomPercent / 100.0),
                                (L_INT)(ZoneData.rcArea.right * m_fZoomPercent / 100.0),
                                (L_INT)(ZoneData.rcArea.bottom* m_fZoomPercent / 100.0));

            m_rcSelOrigZone = ZoneData.rcArea;
         }
         else
            bSelZone = FALSE;
      }
      else
      {
         m_nSelZoneIndex= -1;
         m_bSelectZone  = FALSE;
         m_bResize      = FALSE;
         bSelZone       = FALSE;
      }

      if (!bSelZone)
      {
         L_BOOL bAddZone=TRUE;
         if ((m_rcFrame.left == m_rcFrame.right) && (m_rcFrame.top == m_rcFrame.bottom))
            bAddZone = FALSE;
         if ((m_rcFrame.left == m_rcFrame.right) || (m_rcFrame.top == m_rcFrame.bottom))
            bAddZone = FALSE;

         if (bAddZone)
            SetRectRgn();
      }
   }
   else
   {
      if (m_bShowZones)
      {
         m_bResize = FALSE;

         m_rcFrame.OffsetRect(GetScrollPos(SB_HORZ), GetScrollPos(SB_VERT));
         m_rcFrame.SetRect((L_INT)(m_rcFrame.left * 100.0 / m_fZoomPercent),
                           (L_INT)(m_rcFrame.top * 100.0 / m_fZoomPercent),
                           (L_INT)(m_rcFrame.right * 100.0 / m_fZoomPercent),
                           (L_INT)(m_rcFrame.bottom * 100.0 / m_fZoomPercent));

         if (bUpdateZoneArea)
         {
            L_INT nRet = L_DocZone(m_hDoc, m_nPageIndex, m_nSelZoneIndex, m_rcFrame);
            if (nRet == SUCCESS)
            {
               m_bSelectZone = TRUE;
               m_rcSelZone.SetRect((L_INT)(m_rcFrame.left  * m_fZoomPercent / 100.0),
                                   (L_INT)(m_rcFrame.top   * m_fZoomPercent / 100.0),
                                   (L_INT)(m_rcFrame.right * m_fZoomPercent / 100.0),
                                   (L_INT)(m_rcFrame.bottom* m_fZoomPercent / 100.0));
            }
         }
         else
            m_nDrawMode = -1;
      }
   }

   RedrawWindow();
   CScrollView::OnLButtonUp(nFlags, point);
}

void COCRUtilView::OnMouseMove(UINT nFlags, CPoint point) 
{
   COCRUtilApp * pTheApp = (COCRUtilApp *)AfxGetApp();
   if (!pTheApp->m_Bitmap.Flags.Allocated)
      return;

   if (m_bCapWnd)
      if (GetCapture() != this)
         SetCapture();

   if (m_bResize)
   {
      DrawRect();
      switch (m_nDrawMode)
      {
      case 0: /* LT*/
         m_rcFrame.left = point.x;
         m_rcFrame.top  = point.y;
         break;
      case 1: /* RT */
         m_rcFrame.right= point.x;
         m_rcFrame.top  = point.y;
         break;
      case 2: /* LB */
         m_rcFrame.left   = point.x;
         m_rcFrame.bottom = point.y;
         break;
      case 3: /* RB */
         m_rcFrame.right  = point.x;
         m_rcFrame.bottom = point.y;
         break;
      case 4: /* LT-RT*/
         m_rcFrame.top = point.y;
         break;
      case 5: /* LB-RB */
         m_rcFrame.bottom = point.y;
         break;
      case 6: /* LT-LB */
         m_rcFrame.left = point.x;
         break;
      case 7: /* RT-RB */
         m_rcFrame.right  = point.x;
         break;
      case 8: /* Move Rect */
         m_rcFrame = m_rcSelZone;
         m_rcFrame.OffsetRect(-GetScrollPos(SB_HORZ), -GetScrollPos(SB_VERT));
         m_rcFrame.OffsetRect(point.x - m_ptResize.x, point.y - m_ptResize.y);
         break;
      }

      DrawRect();
   }
   else if (m_bLMDown)
   {
      DrawRect();

      COCRUtilApp * pTheApp = (COCRUtilApp *)AfxGetApp();

      L_INT nBmpWidth = BITMAPWIDTH(&pTheApp->m_Bitmap);
      L_INT nBmpHeight = BITMAPHEIGHT(&pTheApp->m_Bitmap);

      m_rcFrame.right = (point.x > nBmpWidth) ? nBmpWidth : ((point.x < 0) ? 0 : point.x);
      m_rcFrame.bottom= (point.y > nBmpHeight) ? nBmpHeight : ((point.y < 0) ? 0 : point.y);
      DrawRect();
   }

   CScrollView::OnMouseMove(nFlags, point);
}

void COCRUtilView::DrawRect()
{
   CDC * pDC = GetDC();

   pDC->SetROP2(R2_NOT);
   pDC->MoveTo(m_rcFrame.left, m_rcFrame.top);
   pDC->LineTo(m_rcFrame.right, m_rcFrame.top);
   pDC->LineTo(m_rcFrame.right, m_rcFrame.bottom);
   pDC->LineTo(m_rcFrame.left, m_rcFrame.bottom);
   pDC->LineTo(m_rcFrame.left, m_rcFrame.top);

   ReleaseDC(pDC);
}

void COCRUtilView::SetRectRgn()
{
   ZONEDATA Zone;
   CRect    rc = m_rcRgn;

   rc.SetRect((L_INT)(m_rcRgn.left  * 100.0 / m_fZoomPercent),
              (L_INT)(m_rcRgn.top   * 100.0 / m_fZoomPercent),
              (L_INT)(m_rcRgn.right * 100.0 / m_fZoomPercent),
              (L_INT)(m_rcRgn.bottom* 100.0 / m_fZoomPercent));
   rc.OffsetRect((L_INT)(GetScrollPos(SB_HORZ) * 100.0 / m_fZoomPercent),
                 (L_INT)(GetScrollPos(SB_VERT) * 100.0 / m_fZoomPercent));

   memset(&Zone, 0, sizeof(ZONEDATA));
   Zone.uStructSize = sizeof(ZONEDATA);
   SetRect(&Zone.rcArea, rc.left, rc.top, rc.right, rc.bottom);
   m_rcSelOrigZone = rc;

   CZoneData ZoneDataDlg(&Zone);
   if (ZoneDataDlg.DoModal() != IDOK)
      return;

   L_INT nRet = L_DocAddZone(m_hDoc, m_nPageIndex, -1, ZoneDataDlg.m_pZoneData);
   if (nRet != SUCCESS)
   {
      CString csError;
      csError.Format(TEXT("Can't add the selected zone\nnRet = %d"), nRet);
      AfxMessageBox(csError);
      return;
   }

   m_bFindZone = TRUE;
   L_INT nZoneCount = 0;
   L_DocGetZoneCount(m_hDoc, m_nPageIndex, &nZoneCount);
   m_nSelZoneIndex = nZoneCount-1;
   if (m_nZoneIndex == -1)
      m_nZoneIndex = 0;

   CClientDC dc(this);
   L_DocSelectZone(m_hDoc, dc.m_hDC, m_nPageIndex, m_nSelZoneIndex, TRUE);
}

void COCRUtilView::OnViewZoom() 
{
   CZoomPercent ZoomDlg(m_fZoomPercent);
   if (ZoomDlg.DoModal() != IDOK)
      return;

   m_fZoomPercent = ZoomDlg.m_fZoomPercent;
   L_DocSetPaintZoomFactor(m_hDoc, m_nPageIndex, m_fZoomPercent);
   UpdateView();
}

void COCRUtilView::OnUpdateViewZoom(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(!m_bScanStarted && m_hDoc && m_nPageIndex != -1 && m_bShowPage);
}

void COCRUtilView::OnViewZoomIn() 
{
   m_fZoomPercent += ZOOM_STEP;
   if (m_fZoomPercent > MAX_ZOOM_VALUE)
      m_fZoomPercent = MAX_ZOOM_VALUE;

   L_DocSetPaintZoomFactor(m_hDoc, m_nPageIndex, m_fZoomPercent);
   UpdateView();
}

void COCRUtilView::OnUpdateViewZoomIn(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(!m_bScanStarted && m_hDoc && m_nPageIndex != -1 && m_fZoomPercent < MAX_ZOOM_VALUE && m_bShowPage);
}

void COCRUtilView::OnViewZoomOut() 
{
   m_fZoomPercent -= ZOOM_STEP;
   if (m_fZoomPercent < MIN_ZOOM_VALUE)
      m_fZoomPercent = MIN_ZOOM_VALUE;

   L_DocSetPaintZoomFactor(m_hDoc, m_nPageIndex, m_fZoomPercent);
   UpdateView();
}

void COCRUtilView::OnUpdateViewZoomOut(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(!m_bScanStarted && m_hDoc && m_nPageIndex != -1 && m_fZoomPercent > MIN_ZOOM_VALUE && m_bShowPage);
}

void COCRUtilView::OnContextMenu(CWnd* pWnd, CPoint point) 
{
   if (!m_bImageLoaded)
      return;

   if (m_nSelZoneIndex != -1 && m_bSelectZone && m_bShowZones)
   {
      CMenu menu;
      menu.LoadMenu(IDR_ZONE);

      CMenu * pPopup = menu.GetSubMenu(0);
      pPopup->TrackPopupMenu(TPM_RIGHTBUTTON | TPM_LEFTBUTTON, point.x, point.y, this);
   }
}

BOOL COCRUtilView::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message) 
{
   if (!m_bResize)
   {
      if (m_nSelZoneIndex != -1 && m_bSelectZone)
      {
         POINT ptCurPos;

         GetCursorPos(&ptCurPos);
         ScreenToClient(&ptCurPos);
         ptCurPos.x += GetScrollPos(SB_HORZ);
         ptCurPos.y += GetScrollPos(SB_VERT);

         m_nDrawMode = GetCurCornerPos(ptCurPos);
      }
   }

   switch (m_nDrawMode)
   {
   case -1:
      SetCursor(AfxGetApp()->LoadStandardCursor(IDC_ARROW));
      break;
   case 0:
   case 3:
      SetCursor(AfxGetApp()->LoadStandardCursor(IDC_SIZENWSE));
      break;
   case 1:
   case 2:
      SetCursor(AfxGetApp()->LoadStandardCursor(IDC_SIZENESW));
      break;
   case 4:
   case 5:
      SetCursor(AfxGetApp()->LoadStandardCursor(IDC_SIZENS));
      break;
   case 6:
   case 7:
      SetCursor(AfxGetApp()->LoadStandardCursor(IDC_SIZEWE));
      break;
   case 8:
      SetCursor(AfxGetApp()->LoadStandardCursor(IDC_SIZEALL));
      break;
   }
   return TRUE;
}

L_INT COCRUtilView::GetCurCornerPos(POINT ptCur)
{
   if (m_nSelZoneIndex == -1 || !m_bSelectZone)
      return -1;

   RECT rcCorner;
   GetLTSelCorner(&rcCorner);
   if (PtInRect(&rcCorner, ptCur))
   {
      m_nDrawMode = 0;
      return m_nDrawMode;
   }

   GetRTSelCorner(&rcCorner);
   if (PtInRect(&rcCorner, ptCur))
   {
      m_nDrawMode = 1;
      return m_nDrawMode;
   }

   GetLBSelCorner(&rcCorner);
   if (PtInRect(&rcCorner, ptCur))
   {
      m_nDrawMode = 2;
      return m_nDrawMode;
   }

   GetRBSelCorner(&rcCorner);
   if (PtInRect(&rcCorner, ptCur))
   {
      m_nDrawMode = 3;
      return m_nDrawMode;
   }

   CRect rcLine;
   rcLine.SetRect(m_rcSelZone.left - 1, m_rcSelZone.top - 1, m_rcSelZone.right + 1, m_rcSelZone.top + 1);
   if (PtInRect(rcLine, ptCur))
   {
      m_nDrawMode = 4;
      return m_nDrawMode;
   }

   rcLine.SetRect(m_rcSelZone.left - 1, m_rcSelZone.bottom - 1, m_rcSelZone.right + 1, m_rcSelZone.bottom + 1);
   if (PtInRect(rcLine, ptCur))
   {
      m_nDrawMode = 5;
      return m_nDrawMode;
   }

   rcLine.SetRect(m_rcSelZone.left - 1, m_rcSelZone.top - 1, m_rcSelZone.left + 1, m_rcSelZone.bottom + 1);
   if (PtInRect(rcLine, ptCur))
   {
      m_nDrawMode = 6;
      return m_nDrawMode;
   }

   rcLine.SetRect(m_rcSelZone.right - 1, m_rcSelZone.top - 1, m_rcSelZone.right + 1, m_rcSelZone.bottom + 1);
   if (PtInRect(rcLine, ptCur))
   {
      m_nDrawMode = 7;
      return m_nDrawMode;
   }

   if (PtInRect(m_rcSelZone, ptCur))
   {
      m_nDrawMode = 8;
      return m_nDrawMode;
   }

   return -1;
}

void COCRUtilView::GetLTSelCorner(LPRECT prcCorner)
{
   SetRect(prcCorner, m_rcSelZone.left-2, m_rcSelZone.top-2, m_rcSelZone.left+2, m_rcSelZone.top+2);
}

void COCRUtilView::GetRTSelCorner(LPRECT prcCorner)
{
   SetRect(prcCorner, m_rcSelZone.right-2, m_rcSelZone.top-2, m_rcSelZone.right+2, m_rcSelZone.top+2);
}

void COCRUtilView::GetLBSelCorner(LPRECT prcCorner)
{
   SetRect(prcCorner, m_rcSelZone.left-2, m_rcSelZone.bottom-2, m_rcSelZone.left+2, m_rcSelZone.bottom+2);
}

void COCRUtilView::GetRBSelCorner(LPRECT prcCorner)
{
   SetRect(prcCorner, m_rcSelZone.right-2, m_rcSelZone.bottom-2, m_rcSelZone.right+2, m_rcSelZone.bottom+2);
}

L_BOOL COCRUtilView::ShowOCRErrMsg(L_BOOL bCheckPages /*= TRUE*/)
{
   if (!m_hDoc)
   {
      AfxMessageBox(TEXT("Engine Ended,\nUse Engine -> Start Up"));
      return FALSE;
   }

   if (bCheckPages)
   {
      L_INT nPageCount = 0;
      L_DocGetPageCount(m_hDoc, &nPageCount);
      if (nPageCount <= 0)
      {
         AfxMessageBox(TEXT("No images have been inserted to the OCR Document, to insert an image:\nUse Page -> Insert Current Image or\nUse Page -> Insert"));
         return FALSE;
      }
   }

   return TRUE;
}

void COCRUtilView::OnEngineStartup() 
{
   if (!m_hDoc)
   {
      L_BOOL bRet = InitEngine();
      if (!bRet)
         return;
   }
}

void COCRUtilView::OnUpdateEngineStartup(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(!m_bScanStarted && !m_hDoc);
}

void COCRUtilView::OnEngineShutdown() 
{
   if (m_hDoc)
   {
      BeginWaitCursor();
      if (m_hZonePen)
      {
         DeleteObject(m_hZonePen);
         m_hZonePen = NULL;
      }

      if (m_hSelZonePen)
      {
         DeleteObject(m_hSelZonePen);
         m_hSelZonePen = NULL;
      }

      m_nPageIndex   = -1;
      m_nZoneIndex   = -1;
      m_nSelZoneIndex= -1;
      m_fZoomPercent = 100.0;
      m_bImageLoaded = FALSE;
      m_bNextZone    = FALSE;
      m_bShowZones   = TRUE;
      m_bSelectZone  = FALSE;
      m_bRecognized  = FALSE;
      m_bFindZone    = FALSE;
      m_bResize      = FALSE;
      m_nDrawMode    = -1;
      m_ptResize.x   = m_ptResize.y = 0;
      m_nRecogEndIndex=0;

      m_rcRgn.SetRectEmpty();
      m_rcFrame.SetRectEmpty();
      m_rcDst.SetRectEmpty();
      m_rcSelZone.SetRectEmpty();
      m_rcSelOrigZone.SetRectEmpty();

      L_DocShutDown(&m_hDoc);
      m_hDoc = NULL;
      UpdateView();
      EndWaitCursor();
   }
}

void COCRUtilView::OnUpdateEngineShutdown(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(!m_bScanStarted && m_hDoc);
}

void COCRUtilView::OnDestroy() 
{
   OnEngineShutdown();
   CScrollView::OnDestroy();
}

void COCRUtilView::OnFileTwainselect() 
{
   if (!ShowOCRErrMsg(FALSE))
      return;

   COCRUtilApp * pApp = (COCRUtilApp *)AfxGetApp();
   L_TwainSelectSource(pApp->m_hTwnSession, NULL);
}

void COCRUtilView::OnUpdateFileTwainselect(CCmdUI* pCmdUI) 
{
   COCRUtilApp * pApp = (COCRUtilApp *)AfxGetApp();
   pCmdUI->Enable(!m_bScanStarted && pApp->m_bTwnExist);
}

L_INT EXT_FUNCTION COCRUtilView::TwainCallBack(HTWAINSESSION hSession, pBITMAPHANDLE pBitmap, L_VOID * pUserData)
{
   COCRUtilApp * pApp = (COCRUtilApp *)pUserData;

   if (pApp->m_Bitmap.Flags.Allocated)
   {
      L_FreeBitmap(&pApp->m_Bitmap);
      L_InitBitmap(&pApp->m_Bitmap, sizeof(BITMAPHANDLE), 0, 0, 0);
   }

   L_CopyBitmap(&pApp->m_Bitmap, pBitmap, sizeof(BITMAPHANDLE));
   pApp->m_nPageMode = NEW_PAGE_FROM_TWAIN;
   pApp->AddTwainImage();

   L_FreeBitmap(pBitmap);
   GlobalFreePtr(pBitmap);
   return SUCCESS;
}

void COCRUtilView::OnFileTwainacquire() 
{
   if (!ShowOCRErrMsg(FALSE))
      return;

   COCRUtilApp * pApp = (COCRUtilApp *)AfxGetApp();

   m_bScanStarted = TRUE;
   L_TwainAcquire(pApp->m_hTwnSession,
                  NULL,
                  sizeof(BITMAPHANDLE),
                  TwainCallBack,
                  LTWAIN_SHOW_USER_INTERFACE | LTWAIN_MODAL_USER_INTERFACE,
                  NULL, pApp);

   m_bScanStarted = FALSE;
}

void COCRUtilView::OnUpdateFileTwainacquire(CCmdUI* pCmdUI) 
{
   COCRUtilApp * pApp = (COCRUtilApp *)AfxGetApp();
   pCmdUI->Enable(!m_bScanStarted && pApp->m_bTwnExist);
}

void COCRUtilView::OnKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags)
{
   if (m_nSelZoneIndex != -1 && m_bSelectZone && m_bShowZones)
   {
      if (nChar == 46) /* DELETE Key was pressed */
      {
         if (AfxMessageBox(TEXT("Are you sure you want to delete the selected zone?"), MB_YESNO) == IDNO)
            return;

         // deselect the selected Zone...
         CClientDC dc(this);
         L_DocSelectZone(m_hDoc, dc.m_hDC, m_nPageIndex, m_nSelZoneIndex, FALSE);

         // delete the selected zone...
         L_INT nRet = L_DocRemoveZone(m_hDoc, m_nPageIndex, m_nSelZoneIndex);
         if (nRet == SUCCESS)
         {
            AfxMessageBox(TEXT("The selected zone is deleted successfully"));

            m_nSelZoneIndex = -1;
            m_bSelectZone   = FALSE;
            m_nDrawMode     = -1;

            // refresh the window...
            RedrawWindow();
         }
      }
   }

   CScrollView::OnKeyUp(nChar, nRepCnt, nFlags);
}

void COCRUtilView::OnPagesPageprocessAutoorient() 
{
   if (!ShowOCRErrMsg())
      return;

   L_INT nRet = L_DocAutoOrientPage(m_hDoc, m_nPageIndex);
   if (nRet != SUCCESS)
      AfxMessageBox(TEXT("Failure during auto orient the current page"));

   UpdateView();
   RedrawWindow();
}

void COCRUtilView::OnUpdatePagesPageprocessAutoorient(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(!m_bScanStarted && m_hDoc && m_nPageIndex != -1);
}

void COCRUtilView::OnOcrGetrecognizedwords() 
{
   pRECOGWORDS pRecogWords = NULL;
   L_INT nWordsCount = 0, nRet = SUCCESS;

   L_INT nPageCount;
   L_DocGetPageCount(m_hDoc, &nPageCount);
   if (m_nStartRecogIndex < nPageCount && m_nEndRecogIndex < nPageCount)
   {
      for (int i=m_nStartRecogIndex; i<=m_nEndRecogIndex; i++)
      {
         nRet = L_DocGetRecognizedWords(m_hDoc, i, &pRecogWords, sizeof(RECOGWORDS), &nWordsCount);
         if (nRet == SUCCESS)
         {
            CRecogWords dlgRecogWords(i, pRecogWords, nWordsCount);
            dlgRecogWords.DoModal();

            L_DocFreeRecognizedWords(m_hDoc, &pRecogWords);
            pRecogWords = NULL;
         }
      }
   }
   else
   {
      MessageBox(TEXT("One of recognized pages is deleted, please re-recognize the page(s) before select (Get Recognized Words)"));
      m_bRecognized = FALSE;
   }
}

void COCRUtilView::OnUpdateOcrGetrecognizedwords(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(!m_bScanStarted && m_hDoc && m_nPageIndex != -1 && m_bRecognized);
}

void COCRUtilView::OnViewScaletogray() 
{
   m_nViewScale = DISPLAYMODE_SCALETOGRAY;
   L_SetDisplayMode(DISPLAYMODE_FAVORBLACK | DISPLAYMODE_SCALETOGRAY, m_nViewScale);

   OnDoRealize((WPARAM)AfxGetApp()->m_pMainWnd->m_hWnd, (LPARAM) FALSE);
   RedrawWindow();
}

void COCRUtilView::OnUpdateViewScaletogray(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(!m_bScanStarted && m_bImageLoaded && m_nPageIndex != -1);
   pCmdUI->SetRadio(m_nViewScale == DISPLAYMODE_SCALETOGRAY);
}

void COCRUtilView::OnViewNormal() 
{
   m_nViewScale = 0;
   L_SetDisplayMode(DISPLAYMODE_FAVORBLACK | DISPLAYMODE_SCALETOGRAY, m_nViewScale);

   OnDoRealize((WPARAM)AfxGetApp()->m_pMainWnd->m_hWnd, (LPARAM) FALSE);
   RedrawWindow();
}

void COCRUtilView::OnUpdateViewNormal(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(!m_bScanStarted && m_bImageLoaded && m_nPageIndex != -1);
   pCmdUI->SetRadio(m_nViewScale == 0);
}

void COCRUtilView::OnViewFavortoblack() 
{
   m_nViewScale = DISPLAYMODE_FAVORBLACK;
   L_SetDisplayMode(DISPLAYMODE_FAVORBLACK | DISPLAYMODE_SCALETOGRAY, m_nViewScale);

   OnDoRealize((WPARAM)AfxGetApp()->m_pMainWnd->m_hWnd, (LPARAM) FALSE);
   RedrawWindow();
}

void COCRUtilView::OnUpdateViewFavortoblack(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(!m_bScanStarted && m_bImageLoaded && m_nPageIndex != -1);
   pCmdUI->SetRadio(m_nViewScale == DISPLAYMODE_FAVORBLACK);
}