// OCRView.cpp : implementation of the COCRView 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 -> "Recognize" to recognize the added page.
4. Select OCR -> "Save Results To Memory" to save the recognition results to memory.
 ******************************************/

#include "stdafx.h"
#include "OCR.h"

#include "OCRDoc.h"
#include "OCRView.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

/////////////////////////////////////////////////////////////////////////////
// COCRView

IMPLEMENT_DYNCREATE(COCRView, CFormView)

BEGIN_MESSAGE_MAP(COCRView, CFormView)
   //{{AFX_MSG_MAP(COCRView)
   ON_WM_ERASEBKGND()
   ON_WM_CREATE()
   ON_WM_DESTROY()
   ON_WM_SIZE()
   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_RECOGNIZE, OnOcrRecognize)
   ON_UPDATE_COMMAND_UI(ID_OCR_RECOGNIZE, OnUpdateOcrRecognize)
   ON_COMMAND(ID_OCR_SAVERESULTSTOMEMORY, OnOcrSaveresultstomemory)
   ON_UPDATE_COMMAND_UI(ID_OCR_SAVERESULTSTOMEMORY, OnUpdateOcrSaveresultstomemory)
   //}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// COCRView construction/destruction

COCRView::COCRView()
   : CFormView(COCRView::IDD)
{
   //{{AFX_DATA_INIT(COCRView)
      // NOTE: the ClassWizard will add member initialization here
   //}}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_bRecog          = FALSE;
}

COCRView::~COCRView()
{
   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 COCRView::DoDataExchange(CDataExchange* pDX)
{
   CFormView::DoDataExchange(pDX);
   //{{AFX_DATA_MAP(COCRView)
   DDX_Control(pDX, IDC_LEADRASTERVIEW, m_LEADRasterView);
   //}}AFX_DATA_MAP
}

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

   return CFormView::PreCreateWindow(cs);
}

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

/////////////////////////////////////////////////////////////////////////////
// COCRView printing

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

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

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

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

/////////////////////////////////////////////////////////////////////////////
// COCRView diagnostics

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

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

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

/////////////////////////////////////////////////////////////////////////////
// COCRView message handlers

int COCRView::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();

   HKEY  hKey = HKEY_LOCAL_MACHINE;
   TCHAR szSubKey[MAX_PATH];
   memset(szSubKey, 0, sizeof(szSubKey));
#ifndef UNICODE
   strcpy(szSubKey, "SOFTWARE\\LEAD Technologies, Inc.\\Images");
#else
   lstrcpy(szSubKey, TEXT("SOFTWARE\\LEAD Technologies, Inc.\\UnicodeImages"));
#endif

   nRet = RegOpenKeyEx(hKey, szSubKey, 0, KEY_READ, &hKey);
   if (nRet == 0)
   {
      DWORD lpType;
      BYTE  data[MAX_PATH];
      DWORD sizeData = MAX_PATH;

      memset(data,0,sizeof(data));
      nRet = RegQueryValueEx(hKey, TEXT(""), NULL, &lpType, data, &sizeData);
      if (nRet == 0)
         m_csImagesPath.Format(TEXT("%s"), (TCHAR *)&data);

      RegCloseKey(hKey);
   }

   EndWaitCursor();
   return 0;
}

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

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

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

void COCRView::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); //long uFlags
         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 COCRView::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 COCRView::OnUpdateFileSave(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(m_bImageLoaded);
}

void COCRView::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_LEADRasterView.SetRasterDocument(m_pRasterDoc);
      m_LEADRasterView.SetEnableOCRDrawing(TRUE);
      m_LEADRasterView.ForceRepaint();

      m_bPageAdded = TRUE;
   }

   EndWaitCursor();
}

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

void COCRView::OnOcrRecognize() 
{
   CString csMsg;
   csMsg.Format(TEXT("Do you want to delete all previous output files?"));
   int nAnswer = MessageBox(csMsg, TEXT("Delete output files"), MB_YESNO);
   if (nAnswer == IDYES)
   {
      CString csFile;

      csFile.Format(TEXT("%s\\ocrmem.rdf"), m_csImagesPath);
      DeleteFile(csFile);
   }

   CString csDataFile;
   csDataFile.Format(TEXT("%s\\ocrmem.rdf"), m_csImagesPath);

   BSTR bstrFile = csDataFile.AllocSysString();

   m_pRasterDoc->EnableSubSystem = TRUE;
   m_pRasterDoc->EnableCorrection = TRUE;
   m_pRasterDoc->SpellLanguageID = LANGID_ENGLISH;
   m_pRasterDoc->EnableFireRecognizeStatus = TRUE;
   m_pRasterDoc->RecognitionDataFileName = bstrFile;

   BeginWaitCursor();
   m_bRecog = FALSE;

   int nRet = m_pRasterDoc->Recognize (0, 1); 
   EndWaitCursor();
   SysFreeString(bstrFile);
   if (nRet != 0)
   {
      AfxMessageBox(TEXT("Can't recognize the specific pages"));
      return;
   }
   else
   {
      CString csMsg;
      csMsg.Format(TEXT("The recognition process successful, you will find the result at (%s)"), csDataFile);
      AfxMessageBox(csMsg);
   }

   m_pRasterDoc->EnableShowZones = TRUE;
   m_LEADRasterView.ForceRepaint();

   m_bRecog = TRUE;
   RedrawWindow();
}

void COCRView::OnUpdateOcrRecognize(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(m_bPageAdded && !m_bRecog);
}

void COCRView::OnOcrSaveresultstomemory() 
{
   int nRet = m_pRasterDoc->SaveResultsToMemory();
   if (nRet == 0)
      MessageBox(m_pRasterDoc->MemoryRecognitionResult, TEXT("Recognition Results"));
   else
      AfxMessageBox(TEXT("Can't save recognition results to memory"));
}

void COCRView::OnUpdateOcrSaveresultstomemory(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(m_bRecog);
}

void COCRView::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_bRecog          = FALSE;
}