// ZonesView.cpp : implementation of the CZonesView class
//

/******************************************
1. Select File -> Open to load an image, load "OCR1.tif"
2. Select OCR -> "Add Page" to the loaded image into OCR engine
3. Select OCR -> "Find Zones" to detect all available zone in the added page.
4. Select OCR -> "Get Zones Count" to get the detected zones count.
5. Over the drawn zones you can double click any zone to select it and to get its information.
 ******************************************/

#include "stdafx.h"
#include "FindZones.h"

#include "ZonesDoc.h"
#include "ZonesView.h"

#include "leadraster.h"
#include "leadrasterview.h"

#include "EngineMsg.h"

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

/////////////////////////////////////////////////////////////////////////////
// CZonesView

IMPLEMENT_DYNCREATE(CZonesView, CFormView)

BEGIN_MESSAGE_MAP(CZonesView, CFormView)
   //{{AFX_MSG_MAP(CZonesView)
   ON_WM_ERASEBKGND()
   ON_WM_CREATE()
   ON_WM_DESTROY()
   ON_COMMAND(ID_FILE_OPEN, OnFileOpen)
   ON_COMMAND(ID_FILE_SAVE, OnFileSave)
   ON_UPDATE_COMMAND_UI(ID_FILE_SAVE, OnUpdateFileSave)
   ON_WM_SIZE()
   ON_COMMAND(ID_OCR_ADDPAGE, OnOcrAddpage)
   ON_UPDATE_COMMAND_UI(ID_OCR_ADDPAGE, OnUpdateOcrAddpage)
   ON_COMMAND(ID_OCR_FINDZONES, OnOcrFindzones)
   ON_UPDATE_COMMAND_UI(ID_OCR_FINDZONES, OnUpdateOcrFindzones)
   ON_COMMAND(ID_OCR_GETZONESCOUNT, OnOcrGetzonescount)
   ON_UPDATE_COMMAND_UI(ID_OCR_GETZONESCOUNT, OnUpdateOcrGetzonescount)
	ON_WM_LBUTTONDBLCLK()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CZonesView construction/destruction

CZonesView::CZonesView()
   : CFormView(CZonesView::IDD)
{
   //{{AFX_DATA_INIT(CZonesView)
   //}}AFX_DATA_INIT
   // TODO: add construction code here

   m_pRaster         = NULL;
   m_pRasterIO       = NULL;
   m_pRasterDlgKrn   = NULL;
   m_pRasterDlgFile  = NULL;
   m_pRasterDoc      = NULL;

   m_bImageLoaded    = FALSE;
   m_bPageAdded      = FALSE;
   m_bZones          = FALSE;
   m_bSelectZone     = FALSE;
   m_nSelZoneIndex   = -1;
}

CZonesView::~CZonesView()
{
   if (m_pRaster)
   {
      m_pRaster->Release();
      m_pRaster = NULL;
   }

   if (m_pRasterIO)
   {
      m_pRasterIO->Release();
      m_pRasterIO = NULL;
   }

   if (m_pRasterDlgKrn)
   {
      m_pRasterDlgKrn->Release();
      m_pRasterDlgKrn = NULL;
   }

   if (m_pRasterDlgFile)
   {
      m_pRasterDlgFile->Release();
      m_pRasterDlgFile = NULL;
   }

   if (m_pRasterDoc)
   {
      m_pRasterDoc->ShutDown();

      m_pRasterDoc->Release();
      m_pRasterDoc = NULL;
   }
}

void CZonesView::DoDataExchange(CDataExchange* pDX)
{
   CFormView::DoDataExchange(pDX);
   //{{AFX_DATA_MAP(CZonesView)
   DDX_Control(pDX, IDC_LEADRASTERVIEW, m_LEADRasterView);
   //}}AFX_DATA_MAP
}

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

   return CFormView::PreCreateWindow(cs);
}

void CZonesView::OnInitialUpdate()
{
   CFormView::OnInitialUpdate();
   GetParentFrame()->RecalcLayout();
   ResizeParentToFit();

   // now disable the scroll bars
   SetScrollSizes(MM_TEXT,CSize(1,1));
   m_LEADRasterView.SetAutoPan(TRUE);
   m_LEADRasterView.SetBackErase(FALSE);
}

/////////////////////////////////////////////////////////////////////////////
// CZonesView printing

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

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

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

void CZonesView::OnPrint(CDC* pDC, CPrintInfo* /*pInfo*/)
{
   // TODO: add customized printing code here
}

/////////////////////////////////////////////////////////////////////////////
// CZonesView diagnostics

#ifdef _DEBUG
void CZonesView::AssertValid() const
{
   CFormView::AssertValid();
}

void CZonesView::Dump(CDumpContext& dc) const
{
   CFormView::Dump(dc);
}

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

/////////////////////////////////////////////////////////////////////////////
// CZonesView message handlers

BOOL CZonesView::OnEraseBkgnd(CDC* pDC) 
{
   CRect rcClient;
   GetClientRect(&rcClient);

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

int CZonesView::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
   if (CFormView::OnCreate(lpCreateStruct) == -1)
      return -1;

   //create a temp LEADRaster object and use it to unlock support
   HRESULT hr = S_OK;
   IClassFactory2 *pCF2=NULL;
   CLSID clsid;
   static const WCHAR BASED_CODE _szID[] = 

#ifndef _UNICODE
   L"LEADRaster.LEADRaster";
#else
   L"LEADRaster_U.LEADRaster_U";
#endif
   CLSIDFromProgID(_szID, &clsid);

   hr = CoGetClassObject(clsid, CLSCTX_ALL, NULL, IID_IClassFactory, (void**)&pCF2);
   if (FAILED (hr))
   {
      AfxMessageBox(TEXT("Failed To Create A Class Factory Object, The Demo will not work properly ..."));
      return -1;
   }

   //This object is licensed, so we need to pass a license key
   static const WCHAR BASED_CODE _szLic[] = L"LEADTOOLS OCX Copyright (c) 1991-2004 LEAD Technologies, Inc.";
   BSTR lpLic = SysAllocString(_szLic);
   pCF2->CreateInstanceLic(NULL, NULL, IID_IUnknown, lpLic, (void**)&m_pRaster);
   SysFreeString(lpLic);
   pCF2->Release();

   hr = CoCreateInstance(CLSID_LEADRasterIO, NULL, CLSCTX_ALL, IID_ILEADRasterIO, (void**)&m_pRasterIO);
   if (FAILED(hr))
   {
      AfxMessageBox(TEXT("Can't instantiate the Raster IO Object...")); 
      return -1;
   }

   hr = CoCreateInstance(CLSID_LEADRasterDlgKrn, NULL, CLSCTX_ALL, IID_ILEADRasterDlgKrn, (void**)&m_pRasterDlgKrn);
   if (FAILED(hr))
   {
      AfxMessageBox(TEXT("Can't instantiate the Raster Kernel Dialog Object...")); 
      return -1;
   }

   hr = CoCreateInstance(CLSID_LEADRasterDlgFile, NULL, CLSCTX_ALL, IID_ILEADRasterDlgFile, (void**)&m_pRasterDlgFile);
   if (FAILED(hr)) 
   {
      AfxMessageBox(TEXT("Can't instantiate the Raster File Dialog Object...")); 
      return -1;
   }

   hr = CoCreateInstance(CLSID_LEADRasterDocument, NULL, CLSCTX_ALL, IID_ILEADRasterDocument, (void**)&m_pRasterDoc);
   if (FAILED(hr)) 
   {
      AfxMessageBox(TEXT("Can't instantiate the Raster OCR Document Object...")); 
      return -1;
   }

   m_pRasterDlgKrn->InitDlg(INIT_WITHOUT_COLOR);

   m_pRaster->PutEnableMethodErrors(FALSE);
   m_pRasterIO->PutEnableMethodErrors(FALSE);
   m_pRasterDlgKrn->PutEnableMethodErrors(FALSE);
   m_pRasterDlgFile->PutEnableMethodErrors(FALSE);
   m_pRasterDoc->PutEnableMethodErrors(FALSE);

   UNLOCKSUPPORT(*m_pRaster);

   BeginWaitCursor();

   if (m_pRaster->IsSupportLocked(L_SUPPORT_OCR))
   {
      AfxMessageBox(TEXT("You need to unlock the OCR engine before you can use this demo!"));
      return -1;
   }

   int nRet = m_pRasterDoc->StartUp();
   if (nRet != 0)
   {
      if (nRet != 21218)
         AfxMessageBox(TEXT("Failed while initializing the OCR Engine"));
      else
      {
         CEngineMsg engineDlg;
         engineDlg.DoModal();
      }

      return -1;
   }

   m_pRasterDoc->ZonePenStyle = PS_SOLID;
   m_pRasterDoc->ZonePenWidth = 2;
   m_pRasterDoc->ZonePenColor = RGB(255, 255, 0);
   m_pRasterDoc->SetZonePen();

   m_pRasterDoc->SelectedZonePenStyle = PS_SOLID;
   m_pRasterDoc->SelectedZonePenWidth = 2;
   m_pRasterDoc->SelectedZonePenColor = RGB(255, 0, 0);
   m_pRasterDoc->SetSelectedZonePen();

   EndWaitCursor();
   return 0;
}

void CZonesView::OnDestroy() 
{
   if (m_pRaster)
   {
      m_pRaster->Release();
      m_pRaster = NULL;
   }

   if (m_pRasterIO)
   {
      m_pRasterIO->Release();
      m_pRasterIO = NULL;
   }

   if (m_pRasterDlgKrn)
   {
      m_pRasterDlgKrn->Release();
      m_pRasterDlgKrn = NULL;
   }

   if (m_pRasterDlgFile)
   {
      m_pRasterDlgFile->Release();
      m_pRasterDlgFile= NULL;
   }

   if (m_pRasterDoc)
   {
      m_pRasterDoc->ShutDown();

      m_pRasterDoc->Release();
      m_pRasterDoc = NULL;
   }

   CFormView::OnDestroy();
}

void CZonesView::OnFileOpen() 
{
   m_pRasterDlgFile->PutEnableMethodErrors(FALSE);
   m_pRasterDlgFile->PutFilter("");
   m_pRasterDlgFile->PutFileDlgFlags(0);
   m_pRasterDlgFile->PutDialogTitle("Open File");
   m_pRasterDlgFile->PutUIFlags(OPEN_SHOW_PROGRESSIVE    |
                                OPEN_SHOW_MULTIPAGE      |
                                OPEN_SHOW_LOADROTATED    |
                                OPEN_SHOW_LOADCOMPRESSED |
                                OPEN_SHOW_FILEINFO       |
                                OPEN_SHOW_PREVIEW        |
                                OPEN_SHOW_DELPAGE        |
                                OPEN_SHOW_LOADOPTIONS    |
                                OPEN_SHOW_RASTEROPTIONS  |
                                OPEN_SHOW_PDFOPTIONS     |
                                OPEN_SHOW_VECTOROPTIONS  |
                                OPEN_VIEWTOTALPAGES      |
                                OPEN_ENABLESIZING        |
                                OPEN_NOFILEMUSTEXIST     |
                                OPEN_NOPATHMUSTEXIST     |
                                OPEN_USEFILESTAMP);

   int nRet = m_pRasterDlgFile->ShowOpenDlg((long)m_hWnd);
   if (nRet == 0)
   {
      if(m_pRasterDlgFile->GetDialogStatus() == DLG_OK)
      {
         CString strFileName = (LPCTSTR)m_pRasterDlgFile->FileName;
         int m_nPageNum = m_pRasterDlgFile->GetPageNumber();

         Reset();

         nRet = m_pRasterIO->GetFileInfo(m_pRaster, (LPCTSTR)strFileName, 0, 0);
         if (nRet != 0)
            return;

         m_pRasterIO->PutEnableMethodErrors (VARIANT_FALSE);
         nRet = m_pRasterIO->Load(m_pRaster, (LPCTSTR)strFileName, 0, m_nPageNum, -1);
         if (nRet == 0)
         {
            m_LEADRasterView.GetRaster().SetBitmap(m_pRaster->Bitmap);
            m_bImageLoaded = TRUE;
         }
      }
   }
}

void CZonesView::OnFileSave() 
{
   m_pRasterDlgFile->PutBitmap(m_pRaster->Bitmap);
   m_pRasterDlgFile->PutEnableMethodErrors(FALSE);
   m_pRasterDlgFile->PutFileDlgFlags(0);
   m_pRasterDlgFile->PutUIFlags(SAVE_AUTOPROCESS                     |
                                SAVE_SHOW_FILEOPTIONS_MULTIPAGE      |
                                SAVE_SHOW_FILEOPTIONS_PROGRESSIVE    |
                                SAVE_SHOW_FILEOPTIONS_QFACTOR        |
                                SAVE_SHOW_FILEOPTIONS_STAMP          |
                                SAVE_SHOW_FILEOPTIONS_BASICJ2KOPTIONS|
                                SAVE_SHOW_FILEOPTIONS_J2KOPTIONS);

   m_pRasterDlgFile->PutDialogTitle("Save File");
   m_pRasterDlgFile->ShowSaveDlg((long)m_hWnd);
}

void CZonesView::OnUpdateFileSave(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(m_bImageLoaded);
}

void CZonesView::OnSize(UINT nType, int cx, int cy) 
{
   CFormView::OnSize(nType, cx, cy);

   if (IsWindow(m_LEADRasterView.m_hWnd))
   {
      m_LEADRasterView.SetBackErase(FALSE);
      m_LEADRasterView.MoveWindow(0, 0, cx, cy);
   }
}

void CZonesView::OnOcrAddpage() 
{
   BeginWaitCursor();
   int nRet = m_pRasterDoc->AddPage(m_pRaster, -1);
   if (nRet != 0)
   {
      CString csErr;

      csErr.Format(TEXT("Can't add page to engine\nError = %d\n"), nRet);
      AfxMessageBox(csErr);
   }
   else
   {
      m_pRasterDoc->ActivePageIndex = 0;
      m_pRasterDoc->ExportPage(m_pRaster, 0);

      m_bPageAdded = TRUE;

      m_LEADRasterView.SetRasterDocument((LPDISPATCH)m_pRasterDoc);
      m_LEADRasterView.SetEnableOCRDrawing(TRUE);
      RedrawWindow();
   }

   EndWaitCursor();
}

void CZonesView::OnUpdateOcrAddpage(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(m_bImageLoaded && !m_bPageAdded);
}

void CZonesView::OnOcrFindzones() 
{
   BeginWaitCursor();
   int nRet = m_pRasterDoc->FindZones(0, TRUE);
   if (nRet == 0)
      AfxMessageBox(TEXT("Find Zones process successful"));
   else
      AfxMessageBox(TEXT("Failed during Find Zones"));

   m_bZones = (nRet == 0) ? TRUE : FALSE;
   m_pRasterDoc->EnableShowZones = TRUE;
   RedrawWindow();
   EndWaitCursor();
}

void CZonesView::OnUpdateOcrFindzones(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(m_bPageAdded && !m_bZones);
}

void CZonesView::OnOcrGetzonescount() 
{
   int nZoneCount = m_pRasterDoc->ZoneCount[0];

   CString csBuffer;

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

void CZonesView::OnUpdateOcrGetzonescount(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(m_bZones);
}

void CZonesView::OnLButtonDblClk(UINT nFlags, CPoint point) 
{
   if (m_bZones)
   {
      int nZoneIndex = -1;
      CPoint pt = point;
      CClientDC dc(this);

      if (m_nSelZoneIndex != -1)
      {
         m_pRasterDoc->SelectZone(NULL,
                                  (long)dc.GetSafeHdc(),
                                  0,
                                  m_nSelZoneIndex,
                                  FALSE);

         m_bSelectZone = FALSE;
         RedrawWindow();
      }

      pt.Offset(GetScrollPos(SB_HORZ), GetScrollPos(SB_VERT));
      m_pRasterDoc->SelectZoneByPoint(NULL, (long)dc.GetSafeHdc(), 0, (float)pt.x, (float)pt.y);

      m_bSelectZone = FALSE;
      m_nSelZoneIndex = -1;

      if (m_pRasterDoc->SelectZoneIndex != -1)
      {
         m_bSelectZone = TRUE;
         m_nSelZoneIndex = m_pRasterDoc->SelectZoneIndex;

         m_pRasterDoc->SelectZone(NULL,
                                  (long)dc.GetSafeHdc(),
                                  0,
                                  m_nSelZoneIndex,
                                  m_bSelectZone);

         RedrawWindow();
         ShowSelectedZoneInfo();
      }
   }

   CFormView::OnLButtonDblClk(nFlags, point);
}

void CZonesView::ShowSelectedZoneInfo()
{
   if (m_nSelZoneIndex == -1)
      return;

   ILTZoneData* pZoneData = NULL;
   HRESULT hr = CoCreateInstance(CLSID_LTZoneData, NULL, CLSCTX_ALL, IID_ILTZoneData, (void**)&pZoneData); 
   if (FAILED(hr))
   {
      AfxMessageBox(TEXT("Can't instantiate the Zone Data COM Object..."));
      return;
   }

   int nRet = m_pRasterDoc->GetZoneInfo(0, m_nSelZoneIndex, pZoneData);
   if (nRet == 0)
   {
      CString csZoneData="";
      CString csTemp;
      csTemp.Format(TEXT("Area: {%d, %d, %d, %d}\n"),
                    pZoneData->Left,
                    pZoneData->Top,
                    pZoneData->Right,
                    pZoneData->Bottom);

      csZoneData += csTemp;
      csTemp.Format(TEXT("Zone Number: %d\n"), m_nSelZoneIndex+1);
      csZoneData += csTemp;
      csTemp.Format(TEXT("Id: %d\n"), pZoneData->ID);
      csZoneData += csTemp;

      CString csFill="";
      switch (pZoneData->GetFillMethod())
      {
      case FM_DEFAULT:      csFill = "Default"; break;
      case FM_OMNIFONT:     csFill = "Omnifont"; break;
      case FM_DRAFTDOT9:    csFill = "Draft Dot9"; break;
      case FM_OMR:          csFill = "OMR"; break;
      case FM_HANDPRINT:    csFill = "HandPrint"; break;
      case FM_DRAFTDOT24:   csFill = "Draft Dot24"; break;
      case FM_OCRA:         csFill = "OCRA"; break;
      case FM_OCRB:         csFill = "OCRB"; break;
      case FM_MICR:         csFill = "MICR"; break;
      case FM_DOTDIGIT:     csFill = "Dot Digit"; break;
      case FM_DASHDIGIT:    csFill = "Dash Digit"; break;
      case FM_NO_OCR:       csFill = "No OCR"; break;
      default:
         return;
      }

      csTemp.Format(TEXT("Fill Method: %s\n"), csFill);
      csZoneData += csTemp;

      CString csRecog="";
      switch (pZoneData->GetRecognizeModule())
      {
      case RECOGNIZE_MODULE_AUTO:                    csRecog = "Auto"; break;
      case RECOGNIZE_MODULE_MTEXT_OMNIFONT:          csRecog = "MTEXT Omnifont"; break;
      case RECOGNIZE_MODULE_MULTI_LINGUAL_OMNIFONT:  csRecog = "Multi Lingual Omnifont"; break;
      case RECOGNIZE_MODULE_DOT_MATRIX:              csRecog = "Dot Matrix"; break;
      case RECOGNIZE_MODULE_OMR:                     csRecog = "OMR"; break;
      case RECOGNIZE_MODULE_HAND_PRINTED_NUMERAL:    csRecog = "HNR"; break;
      case RECOGNIZE_MODULE_RER_PRINTED:             csRecog = "RER"; break;
      case RECOGNIZE_MODULE_MATRIX:                  csRecog = "Matrix"; break;
      case RECOGNIZE_MODULE_OMNIFONT_PLUS2W:         csRecog = "Plus2w"; break;
      case RECOGNIZE_MODULE_OMNIFONT_FRX:            csRecog = "FRX"; break;
      case RECOGNIZE_MODULE_OMNIFONT_PLUS3W:         csRecog = "Plus3w"; break;
      default:
         return;
      }

      csTemp.Format(TEXT("Recognize Module: %s\n"), csRecog);
      csZoneData += csTemp;

      CString csCharFilter="";
      switch (pZoneData->GetCharacterFilter())
      {
      case CHAR_FILTER_DEFAULT:         csCharFilter = "Default"; break;
      case CHAR_FILTER_DIGIT:           csCharFilter = "Digit"; break;
      case CHAR_FILTER_UPPERCASE:       csCharFilter = "Uppercase"; break;
      case CHAR_FILTER_LOWERCASE:       csCharFilter = "Lowercase"; break;
      case CHAR_FILTER_PUNCTUATION:     csCharFilter = "Punctuation"; break;
      case CHAR_FILTER_MISCELLANEOUS:   csCharFilter = "Misc"; break;
      case CHAR_FILTER_PLUS:            csCharFilter = "Plus"; break;
      case CHAR_FILTER_ALL:             csCharFilter = "All"; break;
      case CHAR_FILTER_ALPHA:           csCharFilter = "Alpha"; break;
      case CHAR_FILTER_NUMBERS:         csCharFilter = "Numbers"; break;
      default:
         return;
      }

      csTemp.Format(TEXT("Character Filter: %s\n"), csCharFilter);
      csZoneData += csTemp;

      CString csType="";
      switch (pZoneData->GetType())
      {
      case ZONE_TYPE_FLOWTEXT:  csType = "Flow Text"; break;
      case ZONE_TYPE_TABLE:     csType = "Table"; break;
      case ZONE_TYPE_GRAPHIC:   csType = "Graphic"; break;
      case ZONE_TYPE_COLUMN:    csType = "Column"; break;
      case ZONE_TYPE_HEADER:    csType = "Header"; break;
      case ZONE_TYPE_FOOTER:    csType = "Footer"; break;
      case ZONE_TYPE_CAPTION:   csType = "Caption"; break;
      case ZONE_TYPE_TITLE:     csType = "Title"; break;
      case ZONE_TYPE_OTHER:     csType = "Other"; break;
      case ZONE_TYPE_SGRAPHIC:  csType = "S Graphic"; break;
      case ZONE_TYPE_HORZTEXT:  csType = "Horz Text"; break;
      case ZONE_TYPE_VERTTEXT:  csType = "Vert Text"; break;
      default:
         return;
      }

      csTemp.Format(TEXT("Type: %s\n"), csType);
      csZoneData += csTemp;
      MessageBox(csZoneData, TEXT("Zone Data"), MB_OK);
   }

   pZoneData->Release();
}

BEGIN_EVENTSINK_MAP(CZonesView, CFormView)
    //{{AFX_EVENTSINK_MAP(CZonesView)
	ON_EVENT(CZonesView, IDC_LEADRASTERVIEW, 5 /* MouseUp */, OnMouseUpLeadrasterview, VTS_I2 VTS_I2 VTS_R4 VTS_R4)
	//}}AFX_EVENTSINK_MAP
END_EVENTSINK_MAP()

void CZonesView::OnMouseUpLeadrasterview(short Button, short Shift, float x, float y) 
{
   if (m_bZones)
   {
      int nZoneIndex = -1;
      CPoint pt;
      pt.x = (LONG)x;
      pt.y = (LONG)y;
      CClientDC dc(&m_LEADRasterView);

      if (m_nSelZoneIndex != -1)
      {
         m_pRasterDoc->SelectZone(NULL,
                                  (long)dc.GetSafeHdc(),
                                  0,
                                  m_nSelZoneIndex,
                                  FALSE);

         m_LEADRasterView.SetSelectedZoneIndex(-1);
         m_bSelectZone = FALSE;
         RedrawWindow();
      }

      pt.Offset(::GetScrollPos(m_LEADRasterView.m_hWnd, SB_HORZ), ::GetScrollPos(m_LEADRasterView.m_hWnd, SB_VERT));
      m_pRasterDoc->SelectZoneByPoint(NULL, (long)dc.GetSafeHdc(), 0, (float)pt.x, (float)pt.y);

      m_bSelectZone = FALSE;
      m_nSelZoneIndex = -1;

      if (m_pRasterDoc->SelectZoneIndex != -1)
      {
         m_bSelectZone = TRUE;
         m_nSelZoneIndex = m_pRasterDoc->SelectZoneIndex;

         m_pRasterDoc->SelectZone(NULL,
                                  (long)dc.GetSafeHdc(),
                                  0,
                                  m_nSelZoneIndex,
                                  m_bSelectZone);
         m_LEADRasterView.SetSelectedZoneIndex(m_nSelZoneIndex);

         RedrawWindow();
         ShowSelectedZoneInfo();
      }
   }
}

void CZonesView::Reset()
{
   if (m_pRaster->GetBitmap() != 0)
      m_pRaster->Free();

   if (m_LEADRasterView.GetRaster().GetBitmap() != 0)
      m_LEADRasterView.GetRaster().Free();

   m_LEADRasterView.SetEnableOCRDrawing(FALSE);
   m_LEADRasterView.ForceRepaint();

   if (m_bPageAdded)
      m_pRasterDoc->RemovePage(0);

   m_bImageLoaded    = FALSE;
   m_bPageAdded      = FALSE;
   m_bZones          = FALSE;
   m_bSelectZone     = FALSE;
   m_nSelZoneIndex   = -1;
}