// 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 "EngineMsg.h"

#include "windowsx.h"

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

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

IMPLEMENT_DYNCREATE(CZonesView, CScrollView)

BEGIN_MESSAGE_MAP(CZonesView, CScrollView)
   //{{AFX_MSG_MAP(CZonesView)
   ON_WM_CREATE()
   ON_WM_DESTROY()
   ON_WM_ERASEBKGND()
   ON_COMMAND(ID_FILE_OPEN, OnFileOpen)
   ON_COMMAND(ID_FILE_SAVE, OnFileSave)
   ON_UPDATE_COMMAND_UI(ID_FILE_SAVE, OnUpdateFileSave)
   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()
   ON_MESSAGE(WM_DOREALIZE, OnDoRealize)
   //}}AFX_MSG_MAP
END_MESSAGE_MAP()

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

CZonesView::CZonesView()
{
   L_InitBitmap(&m_LEADBitmap, sizeof(BITMAPHANDLE), 0, 0, 0);

   m_hDoc         = NULL;
   m_bPageAdded   = FALSE;
   m_bZones       = FALSE;
   m_hZonePen     = NULL;
   m_hSelZonePen  = NULL;
   m_hPalette     = NULL;
   m_bSelectZone  = FALSE;
   m_nSelZoneIndex= -1;
}

CZonesView::~CZonesView()
{
   if (m_LEADBitmap.Flags.Allocated)
      L_FreeBitmap(&m_LEADBitmap);
}

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

   return CScrollView::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CZonesView drawing

void CZonesView::OnDraw(CDC* pDC)
{
   CZonesDoc* pDoc = GetDocument();
   ASSERT_VALID(pDoc);

   HPALETTE OldPalette = NULL;
   if (m_LEADBitmap.Flags.Allocated)
   {
      CRect rcDst;
      rcDst.SetRect(0, 0, BITMAPWIDTH(&m_LEADBitmap), BITMAPHEIGHT(&m_LEADBitmap));

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

      pDC->GetClipBox(rcClip);
      if (m_bPageAdded)
      {
         if (m_hDoc && m_bPageAdded)
         {
            L_DocDrawPage(m_hDoc,
                          pDC->GetSafeHdc(),
                          0,
                          NULL,
                          NULL,
                          &rcDst,
                          &rcClip,
                          SRCCOPY,
                          TRUE);
         }

         if (m_bSelectZone)
            L_DocSelectZone(m_hDoc, pDC->GetSafeHdc(), 0, m_nSelZoneIndex, m_bSelectZone);
      }
      else
         L_PaintDC(pDC->GetSafeHdc(), &m_LEADBitmap, NULL, NULL, &rcDst, &rcClip, SRCCOPY);

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

void CZonesView::OnInitialUpdate()
{
   CScrollView::OnInitialUpdate();

   CSize sizeTotal;
   // TODO: calculate the total size of this view
   sizeTotal.cx = sizeTotal.cy = 0;
   SetScrollSizes(MM_TEXT, sizeTotal);
}

/////////////////////////////////////////////////////////////////////////////
// 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
}

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

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

void CZonesView::Dump(CDumpContext& dc) const
{
   CScrollView::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

void CZonesView::CleanOpenDlgParam(LPOPENDLGPARAMS pFOParam)
{
   if (pFOParam && pFOParam->pFileData != NULL)
   {
      for (L_INT i=0; i < pFOParam->nNumOfFiles; i++)
      {
         if (pFOParam->pFileData[i].pBitmap)
         {
            if (pFOParam->pFileData[i].pBitmap->Flags.Allocated)
               L_FreeBitmap(pFOParam->pFileData[i].pBitmap);
            GlobalFreePtr(pFOParam->pFileData[i].pBitmap);
         }

         if (pFOParam->pFileData[i].pThumbnail)
         {
            if (pFOParam->pFileData[i].pThumbnail->Flags.Allocated)
               L_FreeBitmap(pFOParam->pFileData[i].pThumbnail);
            GlobalFreePtr(pFOParam->pFileData[i].pThumbnail);
         }

         if (pFOParam->pFileData[i].pFileInfo)
            GlobalFreePtr(pFOParam->pFileData[i].pFileInfo);
      }

      GlobalFreePtr(pFOParam->pFileData);

      pFOParam->pFileData    = NULL;
      pFOParam->nNumOfFiles  = 0;
   }
}

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

   if (!m_LEADBitmap.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, &m_LEADBitmap);
   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 CZonesView::UpdateScrollView()
{
   CSize sizeTotal;
   if (m_LEADBitmap.Flags.Allocated)
   {
      sizeTotal.cx = BITMAPWIDTH(&m_LEADBitmap);
      sizeTotal.cy = BITMAPHEIGHT(&m_LEADBitmap);

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

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

void CZonesView::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);
}

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

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

   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 0;
}

void CZonesView::OnDestroy() 
{
   if (m_LEADBitmap.Flags.Allocated)
      L_FreeBitmap(&m_LEADBitmap);

   if (m_hDoc)
      L_DocShutDown(&m_hDoc);

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

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

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

   CScrollView::OnDestroy();
}

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

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

void CZonesView::OnFileOpen() 
{
   OPENFILENAME   OpenFileName;
   OPENDLGPARAMS  FOParm;

   memset(&FOParm, 0, sizeof(OPENDLGPARAMS));
   memset(&OpenFileName, 0, sizeof(OPENFILENAME));

   FOParm.uStructSize     = sizeof(OPENDLGPARAMS);
   FOParm.bPreviewEnabled = TRUE;
   FOParm.uDlgFlags       = DLG_OPEN_SHOW_PROGRESSIVE    |
                            DLG_OPEN_SHOW_MULTIPAGE      |
                            DLG_OPEN_SHOW_LOADROTATED    |
                            DLG_OPEN_SHOW_LOADCOMPRESSED |
                            DLG_OPEN_SHOW_FILEINFO       |
                            DLG_OPEN_SHOW_PREVIEW        |
                            DLG_OPEN_SHOW_DELPAGE        |
                            DLG_OPEN_SHOW_LOADOPTIONS    |
                            DLG_OPEN_SHOW_RASTEROPTIONS  |
                            DLG_OPEN_SHOW_PDFOPTIONS     |
                            DLG_OPEN_SHOW_VECTOROPTIONS  |
                            DLG_OPEN_VIEWTOTALPAGES      |
                            DLG_OPEN_ENABLESIZING        |
                            DLG_OPEN_NOFILEMUSTEXIST     |
                            DLG_OPEN_NOPATHMUSTEXIST     |
                            DLG_OPEN_USEFILESTAMP;

   OpenFileName.lStructSize       = sizeof(OPENFILENAME);
   OpenFileName.hwndOwner         = NULL;
   OpenFileName.lpstrFilter       = NULL;
   OpenFileName.lpstrCustomFilter = NULL;
   OpenFileName.nMaxCustFilter    = 0;
   OpenFileName.nFilterIndex      = 0;
   OpenFileName.lpstrInitialDir   = NULL;
   OpenFileName.lpstrTitle        = TEXT("Open a File");
   OpenFileName.nFileOffset       = 0;
   OpenFileName.nFileExtension    = 0;
   OpenFileName.lpstrDefExt       = NULL;
   OpenFileName.Flags             = 0;

   L_INT nRet = L_DlgOpen(m_hWnd, &OpenFileName, &FOParm);
   if (nRet == SUCCESS_DLG_OK)
   {
      FILEINFO FileInfo;
      memset(&FileInfo, 0, sizeof(FILEINFO));
      L_INT nRet = L_FileInfo((L_TCHAR *)FOParm.pFileData[0].szFileName, &FileInfo, sizeof(FILEINFO), 0, NULL);
      if (nRet != SUCCESS)
         return;

      LOADFILEOPTION LoadOptions;

      if (m_LEADBitmap.Flags.Allocated)
      {
         L_FreeBitmap(&m_LEADBitmap);
         Reset();
      }

      L_GetDefaultLoadFileOption(&LoadOptions, sizeof(LOADFILEOPTION));
      LoadOptions.PageNumber = FOParm.pFileData[0].nPageNumber;
      nRet = L_LoadBitmap((L_TCHAR *)FOParm.pFileData[0].szFileName,
                          &m_LEADBitmap,
                          sizeof(BITMAPHANDLE),
                          0,
                          ORDER_BGRORGRAY,
                          &LoadOptions,
                          NULL);
      if (nRet == SUCCESS)
      {
         UpdateScrollView();
         m_bPageAdded = FALSE;
      }

      CleanOpenDlgParam(&FOParm);
   }
}

void CZonesView::OnFileSave() 
{
   BeginWaitCursor();

   SAVEDLGPARAMS  FSParm;
   OPENFILENAME   OpenFileName;
   L_TCHAR        szFileName[_MAX_PATH]=TEXT("");

   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     = &m_LEADBitmap;
   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 CZonesView::OnUpdateFileSave(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(m_LEADBitmap.Flags.Allocated);
}

void CZonesView::OnOcrAddpage() 
{
   BeginWaitCursor();

   if (!m_LEADBitmap.Flags.Allocated)
      return;

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

      csErr.Format(_T("Can't add page to engine\nError = %d\n"), nRet);
      AfxMessageBox(csErr);
   }
   else
   {
      L_DocExportPage(m_hDoc, &m_LEADBitmap, sizeof(BITMAPHANDLE), 0);
      L_DocSetActivePage(m_hDoc, 0);
      UpdateScrollView();
      m_bPageAdded = TRUE;
   }

   EndWaitCursor();
}

void CZonesView::OnUpdateOcrAddpage(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(m_hDoc && m_LEADBitmap.Flags.Allocated && !m_bPageAdded);
}

void CZonesView::OnOcrFindzones() 
{
   AUTOZONEOPTS AutoOpts;
   memset(&AutoOpts, 0, sizeof(AUTOZONEOPTS));

   BeginWaitCursor();
   L_INT nRet = L_DocFindZones(m_hDoc, 0, NULL);
   if (nRet == SUCCESS)
      AfxMessageBox(_T("Find Zones process successful"));
   else
      AfxMessageBox(_T("Failed during Find Zones"));

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

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

void CZonesView::OnOcrGetzonescount() 
{
   L_INT nZoneCount = 0;

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

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

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

void CZonesView::OnLButtonDblClk(UINT nFlags, CPoint point) 
{
   CScrollView::OnLButtonDblClk(nFlags, point);

   if (m_bZones)
   {
      L_INT nZoneIndex = -1;
      CPoint pt = point;
      CClientDC dc(this);

      if (m_nSelZoneIndex != -1)
      {
         L_DocSelectZone(m_hDoc, dc.m_hDC, 0, m_nSelZoneIndex, FALSE);
         m_bSelectZone = FALSE;
         RedrawWindow();
      }

      pt.Offset(GetScrollPos(SB_HORZ), GetScrollPos(SB_VERT));
      L_DocSelectZoneByPoint(m_hDoc, dc.m_hDC, 0, pt, &nZoneIndex);

      m_bSelectZone = FALSE;
      m_nSelZoneIndex = -1;

      if (nZoneIndex != -1)
      {
         m_bSelectZone = TRUE;
         m_nSelZoneIndex = nZoneIndex;

         L_DocSelectZone(m_hDoc, dc.m_hDC, 0, m_nSelZoneIndex, m_bSelectZone);
         RedrawWindow();
         ShowSelectedZoneInfo();
      }
   }
}

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

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

   L_INT nRet = L_DocGetZone(m_hDoc, 0, m_nSelZoneIndex, &ZoneData, sizeof(ZONEDATA));
   if (nRet == SUCCESS)
   {
      CString csZoneData=_T("");
      CString csTemp;
      csTemp.Format(_T("Area: {%d, %d, %d, %d}\n"),
                    ZoneData.rcArea.left,
                    ZoneData.rcArea.top,
                    ZoneData.rcArea.right,
                    ZoneData.rcArea.bottom);

      csZoneData += csTemp;
      csTemp.Format(_T("Zone Number: %d\n"), m_nSelZoneIndex+1);
      csZoneData += csTemp;
      csTemp.Format(_T("Id: %d\n"), ZoneData.Id);
      csZoneData += csTemp;

      CString csFill=_T("");
      switch (ZoneData.FillMethod)
      {
      case FILL_DEFAULT:      csFill = _T("Default"); break;
      case FILL_OMNIFONT:     csFill = _T("Omnifont"); break;
      case FILL_DRAFTDOT9:    csFill = _T("Draft Dot9"); break;
      case FILL_OMR:          csFill = _T("OMR"); break;
      case FILL_HANDPRINT:    csFill = _T("HandPrint"); break;
      case FILL_DRAFTDOT24:   csFill = _T("Draft Dot24"); break;
      case FILL_OCRA:         csFill = _T("OCRA"); break;
      case FILL_OCRB:         csFill = _T("OCRB"); break;
      case FILL_MICR:         csFill = _T("MICR"); break;
      case FILL_DOTDIGIT:     csFill = _T("Dot Digit"); break;
      case FILL_DASHDIGIT:    csFill = _T("Dash Digit"); break;
      case FILL_NO_OCR:       csFill = _T("No OCR"); break;
      default:
         return;
      }

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

      CString csRecog=_T("");
      switch (ZoneData.RecogModule)
      {
      case RECOGMODULE_AUTO:                    csRecog = _T("Auto"); break;
      case RECOGMODULE_MTEXT_OMNIFONT:          csRecog = _T("MTEXT Omnifont"); break;
      case RECOGMODULE_MULTI_LINGUAL_OMNIFONT:  csRecog = _T("Multi Lingual Omnifont"); break;
      case RECOGMODULE_DOT_MATRIX:              csRecog = _T("Dot Matrix"); break;
      case RECOGMODULE_OMR:                     csRecog = _T("OMR"); break;
      case RECOGMODULE_HAND_PRINTED_NUMERAL:    csRecog = _T("HNR"); break;
      case RECOGMODULE_RER_PRINTED:             csRecog = _T("RER"); break;
      case RECOGMODULE_MATRIX:                  csRecog = _T("Matrix"); break;
      case RECOGMODULE_OMNIFONT_PLUS2W:         csRecog = _T("Plus2w"); break;
      case RECOGMODULE_OMNIFONT_FRX:            csRecog = _T("FRX"); break;
      case RECOGMODULE_OMNIFONT_PLUS3W:         csRecog = _T("Plus3w"); break;
      default:
         return;
      }

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

      CString csCharFilter=_T("");
      switch (ZoneData.CharFilter)
      {
      case ZONE_CHAR_FILTER_DEFAULT:         csCharFilter = _T("Default"); break;
      case ZONE_CHAR_FILTER_DIGIT:           csCharFilter = _T("Digit"); break;
      case ZONE_CHAR_FILTER_UPPERCASE:       csCharFilter = _T("Uppercase"); break;
      case ZONE_CHAR_FILTER_LOWERCASE:       csCharFilter = _T("Lowercase"); break;
      case ZONE_CHAR_FILTER_PUNCTUATION:     csCharFilter = _T("Punctuation"); break;
      case ZONE_CHAR_FILTER_MISCELLANEOUS:   csCharFilter = _T("Misc"); break;
      case ZONE_CHAR_FILTER_PLUS:            csCharFilter = _T("Plus"); break;
      case ZONE_CHAR_FILTER_ALL:             csCharFilter = _T("All"); break;
      case ZONE_CHAR_FILTER_ALPHA:           csCharFilter = _T("Alpha"); break;
      case ZONE_CHAR_FILTER_NUMBERS:         csCharFilter = _T("Numbers"); break;
      default:
         return;
      }

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

      CString csType=_T("");
      switch (ZoneData.Type)
      {
      case ZONE_FLOWTEXT:  csType = _T("Flow Text"); break;
      case ZONE_TABLE:     csType = _T("Table"); break;
      case ZONE_GRAPHIC:   csType = _T("Graphic"); break;
      case ZONE_COLUMN:    csType = _T("Column"); break;
      case ZONE_HEADER:    csType = _T("Header"); break;
      case ZONE_FOOTER:    csType = _T("Footer"); break;
      case ZONE_CAPTION:   csType = _T("Caption"); break;
      case ZONE_TITLE:     csType = _T("Title"); break;
      case ZONE_OTHER:     csType = _T("Other"); break;
      case ZONE_SGRAPHIC:  csType = _T("S Graphic"); break;
      case ZONE_HORZTEXT:  csType = _T("Horz Text"); break;
      case ZONE_VERTTEXT:  csType = _T("Vert Text"); break;
      default:
         return;
      }

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

void CZonesView::Reset()
{
   L_InitBitmap(&m_LEADBitmap, sizeof(BITMAPHANDLE), 0, 0, 0);

   if (m_bPageAdded)
      L_DocRemovePage(m_hDoc, 0);

   m_bPageAdded   = FALSE;
   m_bZones       = FALSE;
   m_hZonePen     = NULL;
   m_hSelZonePen  = NULL;
   m_hPalette     = NULL;
   m_bSelectZone  = FALSE;
   m_nSelZoneIndex= -1;
}