// ABCDoc.cpp : implementation of the CABCDoc class
//

#include "stdafx.h"
#include "ABCDemo.h"

#include "ABCDoc.h"
#include "ABCView.h"
#include "MainFrm.h"

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

extern CABCApp theApp;

/////////////////////////////////////////////////////////////////////////////
// CABCDoc

IMPLEMENT_DYNCREATE(CABCDoc, CDocument)

BEGIN_MESSAGE_MAP(CABCDoc, CDocument)
   //{{AFX_MSG_MAP(CABCDoc)
   //}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CABCDoc construction/destruction

CABCDoc::CABCDoc()
{
   m_pLEADRaster = NULL;
   m_bCompressed = FALSE;
   m_nPageNumber = 0;
}

CABCDoc::~CABCDoc()
{
   if (m_pLEADRaster)
      m_pLEADRaster->Release();
}

BOOL CABCDoc::OnNewDocument()
{
   if (!CDocument::OnNewDocument())
      return FALSE;

   // TODO: add reinitialization code here
   // (SDI documents will reuse this document)

   return TRUE;
}

/////////////////////////////////////////////////////////////////////////////
// CABCDoc serialization

void CABCDoc::Serialize(CArchive& ar)
{
   if (ar.IsStoring())
   {
      // TODO: add storing code here
   }
   else
   {
      // TODO: add loading code here
   }
}

/////////////////////////////////////////////////////////////////////////////
// CABCDoc diagnostics

#ifdef _DEBUG
void CABCDoc::AssertValid() const
{
   CDocument::AssertValid();
}

void CABCDoc::Dump(CDumpContext& dc) const
{
   CDocument::Dump(dc);
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CABCDoc commands

BOOL CABCDoc::OnOpenDocument(LPCTSTR lpszPathName) 
{
   if (!CDocument::OnOpenDocument(lpszPathName))
      return FALSE;

   if (!lpszPathName)
      return FALSE;

   if (m_pLEADRaster)
   {
      m_pLEADRaster->Free();
      m_pLEADRaster->Release();
      m_pLEADRaster = NULL;
   }

   HRESULT hr = CoCreateInstance(CLSID_LEADRaster, NULL, CLSCTX_ALL, IID_ILEADRaster, (void**)&m_pLEADRaster);
   if (FAILED(hr))
      return FALSE;

   m_pLEADRaster->put_EnableMethodErrors(FALSE);

   int nRet = theApp.m_pRasterIO->Load((LPDISPATCH)m_pLEADRaster, lpszPathName, 0, theApp.m_nPageNumber, 1);
   if (nRet != 0)
   {
      theApp.DisplayLEADError(nRet);
      return FALSE;
   }
   else 
   {
      if (theApp.m_bLoadOriginal)
         theApp.m_szOpenedFileName = lpszPathName;
   }

   return (nRet == 0) ? TRUE : FALSE;
}

CView * CABCDoc::GetView()
{
   POSITION pos = GetFirstViewPosition();
   return GetNextView(pos);
}

/*--------------------------------------------------------------------------+
| Function :CancelLoadDlgProc 
| Desc     :cancel image loading dialog proc
| Return   :void
| Notes    :
+--------------------------------------------------------------------------*/
BOOL CALLBACK EXPORT CancelLoadDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
   static BOOL* lpbCancelLoading=0;

   switch (message)
   {
   case WM_INITDIALOG:
      if (lParam)
         lpbCancelLoading = (BOOL*)lParam;
      else
         DestroyWindow(hDlg);
      return(TRUE);
  case WM_COMMAND:
     if (LOWORD(wParam) == IDCANCEL)
     {
        if(lpbCancelLoading)
           *lpbCancelLoading=TRUE;
        else
           DestroyWindow(hDlg);
     }

     return TRUE;
   }

   return FALSE;
}

/*--------------------------------------------------------------------------+
| Function :CancelFileLoading
| Desc     :for cancelling the loading of image files
| Return   :
| Notes    :
+--------------------------------------------------------------------------*/
static int CancelFileLoading(HWND hWnd, int nStatus, int nPageNo, int nTotalPages)
{
   static HWND    hCancelDlg=0;
   static BOOL    bCancelLoading;
   static FARPROC lpDlgProc = (FARPROC) CancelLoadDlgProc;
   int            nRet = SUCCESS;
   MSG            Msg;
   TCHAR          sBuff[10];

   switch (nStatus)
   {
   case L_START_LOADING:
      if(IsWindow(hCancelDlg))
         DestroyWindow(hCancelDlg);

      bCancelLoading = FALSE;
#ifndef _WIN32
      lpDlgProc=(FARPROC)MakeProcInstance((FARPROC)CancelLoadDlgProc,(HINSTANCE)hInst);
#endif
      hCancelDlg = CreateDialogParam(theApp.m_hInstance,
                                     MAKEINTRESOURCE(IDD_LOAD_FILE),
                                     hWnd,
                                     (DLGPROC)lpDlgProc,
                                     (LPARAM)(BOOL FAR*)&bCancelLoading);

      nRet = (hCancelDlg) ? SUCCESS : FAILURE;
      break;
   case L_CHECK_LOADING:
      if (IsWindow(hCancelDlg))
      {
         wsprintf(sBuff, TEXT("%8d"), nPageNo);
         SetDlgItemText(hCancelDlg, IDC_STATIC_PAGENO, sBuff);
      }

      while (IsWindow(hCancelDlg) && PeekMessage(&Msg,0,0,0,PM_REMOVE))
      {
         if (!IsDialogMessage(hCancelDlg,&Msg))
         {
            TranslateMessage(&Msg);
            DispatchMessage(&Msg);
         }

         if (bCancelLoading)
            return FAILURE;
      }

      nRet= (bCancelLoading) ? FAILURE : SUCCESS;
      break;
   case L_END_LOADING:
      if (IsWindow(hCancelDlg))
      {
         DestroyWindow(hCancelDlg);
#ifndef _WIN32
         FreeProcInstance(lpDlgProc);
#endif
         bCancelLoading = FALSE;
         hCancelDlg=0;
         nRet = SUCCESS;
      }
   }

   return nRet;
}

/*--------------------------------------------------------------------------+
| Function :LOADFILE 
| Desc     :Load a file
| Return   :int
| Notes    :
+--------------------------------------------------------------------------*/
int CABCDoc::LOADFILE(int eQuality, CString csInpFile, ILEADRaster * pRaster, int nPageNumber)
{
   int nRet = theApp.m_pRasterIO->Load((LPDISPATCH)pRaster, (LPCTSTR)csInpFile, 0, nPageNumber, 1);
   return nRet;
}

/*--------------------------------------------------------------------------+
| Function :SaveTIFFABC 
| Desc     :Save ABC multipage
| Return   :int
| Notes    :
+--------------------------------------------------------------------------*/
int CABCDoc::SaveTIFFABC(int eQuality, CString csInpFile, CString csOutFile)
{
   int nRet = 0;
   if (csInpFile.IsEmpty())
      return ERROR_INV_FILENAME;

   if (csOutFile.IsEmpty())
      return ERROR_INV_FILENAME;

   if (csOutFile.Compare(csInpFile) == 0)
      return ERROR_INV_FILENAME;

   HWND hWndView = NULL;
   POSITION pos = GetFirstViewPosition();
   if (pos != NULL)
   {
      CView* pView = GetNextView(pos);
      hWndView = pView->m_hWnd;
   }

   CStatusBar *pStatusBar = NULL;
   CMainFrame *pMain = (CMainFrame*)AfxGetMainWnd();
   if (pMain)
      pStatusBar = &pMain->m_wndStatusBar;

   CTime ctStart = CTime::GetCurrentTime();
   BOOL bFree = FALSE;

   ILEADRaster * pRaster;
   HRESULT hr = CoCreateInstance(CLSID_LEADRaster, NULL, CLSCTX_ALL, IID_ILEADRaster, (void**)&pRaster);
   if (FAILED(hr))
      return FALSE;

   pRaster->put_EnableMethodErrors(FALSE);

   nRet = theApp.m_pRasterIO->GetFileInfo(pRaster, (LPCTSTR)csInpFile, 1, FILEINFO_TOTALPAGES);
   m_nTotalPages = theApp.m_pRasterIO->InfoTotalPages;

   m_nPageNumber = 1;
   nRet = theApp.m_pRasterIO->GetFileInfo(pRaster, (LPCTSTR)csInpFile, 1, 0);
   nRet = LOADFILE(eQuality, csInpFile, pRaster, 1);

   nRet = theApp.m_pRasterIO->Save(pRaster, (LPCTSTR)csOutFile, FILE_TIF_ABC, 1, (QFactorConstants)eQuality, SAVE_OVERWRITE);
   nRet = theApp.m_pRasterIO->GetFileInfo(pRaster, (LPCTSTR)csOutFile, 1, 0);

   pRaster->Free();
   bFree = TRUE;

   UINT uDirection = CancelFileLoading(hWndView, L_START_LOADING ,0, 0);

   int iii = 2;
   while (m_nPageNumber < m_nTotalPages)
   {
      m_nPageNumber++;
      nRet = theApp.m_pRasterIO->GetFileInfo(pRaster, (LPCTSTR)csInpFile, m_nPageNumber, 0);
      if (nRet != 0)
      {
         TRACE(TEXT("\n GetFileInfo error %d"), nRet);
         break;
      }

      TRACE(TEXT("\n %d"), theApp.m_pRasterIO->LoadIFD);
      TRACE(TEXT("\n %d"), theApp.m_pRasterIO->InfoIFD);

      bFree = FALSE;
      nRet = LOADFILE(eQuality, csInpFile, pRaster, m_nPageNumber);
      if (nRet != 0)
      {
         TRACE(TEXT("\n Load error %d"), nRet);
         nRet = 0;
         break;
      }

      nRet = theApp.m_pRasterIO->Save(pRaster, (LPCTSTR)csOutFile, FILE_TIF_ABC, 1, (QFactorConstants)eQuality, SAVE_APPEND);
      if (nRet != 0)
      {
         TRACE(TEXT("\n Save error %d"), nRet);
         break;
      }

      nRet = theApp.m_pRasterIO->GetFileInfo(pRaster, (LPCTSTR)csOutFile, 2, 0);
      if (nRet != 0)
      {
         TRACE(TEXT("\n GetFileInfo error %d"), nRet);
         break;
      }

      TRACE(TEXT("\n Save %8d "), iii);

      if (pStatusBar)
      {
         CTime ctCurrent = CTime::GetCurrentTime();
         CTimeSpan cts = ctCurrent - ctStart;
         CString cs = cts.Format(TEXT("  Time Consumed :  %H : %M : %S "));
         pStatusBar->SetPaneText(2, cs, TRUE);
      }

      // Progreessive Dailog
      uDirection = CancelFileLoading(hWndView, L_CHECK_LOADING, iii, m_nTotalPages);
      if (uDirection == FAILURE)
         break;

      iii++;
      pRaster->Free();
      bFree = TRUE;
   }

   CancelFileLoading(hWndView, L_END_LOADING, 0, 0);

   if (pRaster != NULL)
   {
      if (!bFree)
         pRaster->Free();
      pRaster->Release();
      pRaster = NULL;
   }

   return nRet;
}

/*--------------------------------------------------------------------------+
| Function :LoadCombineBitmap 
| Desc     :load and combine two bitmaps 
| Return   :int
| Notes    :
+--------------------------------------------------------------------------*/
int CABCDoc::LoadCombineBitmap(int eQuality, CString csInpFile, ILEADRaster * pRaster, int TotalPages)
{
   int nRet = 0;

   if (pRaster && pRaster->Bitmap)
      pRaster->Free();

   ILEADRaster * pRaster1 = NULL;
   ILEADRaster * pRaster2 = NULL;

   HRESULT hr = CoCreateInstance(CLSID_LEADRaster, NULL, CLSCTX_ALL, IID_ILEADRaster, (void**)&pRaster1);
   hr = CoCreateInstance(CLSID_LEADRaster, NULL, CLSCTX_ALL, IID_ILEADRaster, (void**)&pRaster2);

   int nWidth, nHeight;

   m_nPageNumber++;
   nRet = theApp.m_pRasterIO->GetFileInfo(pRaster, (LPCTSTR)csInpFile, m_nPageNumber, 0);
   ASSERT(nRet == 0);

   if ((theApp.m_pRasterIO->InfoIFD == theApp.m_pRasterIO->LoadIFD) && (theApp.m_pRasterIO->InfoIFD != 0))
      return -1;

   nRet = LOADFILE(eQuality, (LPCTSTR)csInpFile, pRaster1, m_nPageNumber);
   if (nRet != 0)
   {
      TRACE(TEXT("\n Load Raster1 error %d"), nRet);
      return nRet;
   }

   nWidth  = (int)pRaster1->BitmapWidth;
   nHeight = (int)pRaster1->BitmapHeight;

   if (m_nPageNumber == TotalPages) 
   {
      pRaster1->put_RefBitmap(FALSE);
      pRaster->put_RefBitmap(FALSE);

      pRaster->Bitmap = pRaster1->Bitmap;
      pRaster1->Free();
      pRaster1->Release();
      pRaster2->Release();
      return 0;
   }
   else
   {
      m_nPageNumber++;
      nRet = theApp.m_pRasterIO->GetFileInfo(pRaster1, (LPCTSTR)csInpFile, m_nPageNumber, 0);
      ASSERT(nRet == 0);

      nRet = LOADFILE(eQuality, csInpFile, pRaster2, m_nPageNumber);
      if (nRet != 0)
      {
         TRACE(TEXT("\n Load Raster2 error %d"), nRet);

         pRaster1->put_RefBitmap(FALSE);
         pRaster->put_RefBitmap(FALSE);

         pRaster->Bitmap = pRaster1->Bitmap;
         pRaster1->Free();
         pRaster1->Release();
         pRaster2->Release();
         return 0;
      }

      nWidth  = max(nWidth, (int)pRaster2->BitmapWidth);
      nHeight = nHeight + (int)pRaster2->BitmapHeight;

      nRet = pRaster->CreateBitmap((float)nWidth, (float)nHeight, 1);
      ASSERT(nRet == 0);

      nRet = theApp.m_pRasterProc->CombineExt(pRaster,
                                              0, 0,
                                              pRaster1->BitmapWidth, pRaster1->BitmapHeight,
                                              pRaster1,
                                              0, 0,
                                              (CombineConstants)(CB_DST_0 | CB_SRC_NOP | CB_OP_OR));
      ASSERT(nRet == 0);

      nRet = theApp.m_pRasterProc->CombineExt(pRaster,
                                              0, pRaster1->BitmapHeight,
                                              pRaster2->BitmapWidth, pRaster2->BitmapHeight,
                                              pRaster2,
                                              0, 0,
                                              (CombineConstants)(CB_DST_0 | CB_SRC_NOP | CB_OP_OR));
      ASSERT(nRet == 0);
      pRaster2->Free();
      pRaster1->Free();
      return 0;
   }
}

/*--------------------------------------------------------------------------+
| Function :SaveTIFFABCCombined 
| Desc     :save multipage combined images
| Return   :void
| Notes    :
+--------------------------------------------------------------------------*/
int CABCDoc::SaveTIFFABCCombined(int eQuality, CString csInpFile, CString csOutFile)
{
   int nRet = 0;
   BOOL bFree = FALSE;

   if (csInpFile.IsEmpty())
      return ERROR_INV_FILENAME;

   if(csOutFile.IsEmpty())
      return ERROR_INV_FILENAME;

   if(csInpFile.Compare(csOutFile) == 0)
      return ERROR_INV_FILENAME;

   HWND hWndView;
   POSITION pos = GetFirstViewPosition();
   if (pos != NULL)
   {
      CView* pView = GetNextView(pos);
      hWndView = pView->m_hWnd;
   }

   CStatusBar * pStatusBar=NULL;
   CMainFrame * pMain = (CMainFrame*)AfxGetMainWnd();
   if (pMain)
      pStatusBar = &pMain->m_wndStatusBar;

   CTime ctStart = CTime::GetCurrentTime();

   ILEADRaster * pRaster = NULL;
   HRESULT hr = CoCreateInstance(CLSID_LEADRaster, NULL, CLSCTX_ALL, IID_ILEADRaster, (void**)&pRaster);
   if (FAILED(hr))
      return FALSE;

   nRet = theApp.m_pRasterIO->GetFileInfo(pRaster, (LPCTSTR)csInpFile, 1, FILEINFO_TOTALPAGES);
   m_nPageNumber = 0;
   m_nTotalPages = theApp.m_pRasterIO->InfoTotalPages;

   nRet = LoadCombineBitmap(eQuality, csInpFile, pRaster, m_nTotalPages);
   if (nRet != 0)
   {
      pRaster->Free();
      pRaster->Release();
      return nRet;
   }

   nRet = theApp.m_pRasterIO->Save(pRaster, (LPCTSTR)csOutFile, FILE_TIF_ABC, 1, (QFactorConstants)eQuality, 0);
   pRaster->Free();
   bFree = TRUE;

   UINT uDirection = CancelFileLoading(hWndView, L_START_LOADING , 0, 0);

   int iii = 2;
   while (m_nPageNumber < m_nTotalPages)
   {
      nRet = LoadCombineBitmap(eQuality, csInpFile, pRaster, m_nTotalPages);
      if (nRet != 0)
      {
         CancelFileLoading(hWndView, L_END_LOADING, 0,0);
         pRaster->Release();
         return 0;
      }

      nRet = theApp.m_pRasterIO->Save(pRaster, (LPCTSTR)csOutFile, FILE_TIF_ABC, 1, (QFactorConstants)eQuality, SAVE_APPEND);
      if (nRet != 0)
      {
         TRACE(TEXT("\n Save error %d"), nRet);
         break;
      }

      nRet = theApp.m_pRasterIO->GetFileInfo(pRaster, (LPCTSTR)csOutFile, m_nPageNumber, 0);
      if (nRet != 0)
      {
         TRACE(TEXT("\n GetFileInfo error %d"), nRet);
         break;
      }

      TRACE(TEXT("\n Save %8d "), iii);

      if( pStatusBar )
      {
         CTime ctCurrent = CTime::GetCurrentTime();
         CTimeSpan cts = ctCurrent - ctStart;
         CString cs = cts.Format(TEXT("  Time Consumed :  %H : %M : %S "));
         pStatusBar->SetPaneText(2, cs, TRUE); 
      }

      // Progreessive Dailog
      uDirection = CancelFileLoading(hWndView, L_CHECK_LOADING, iii, m_nTotalPages);
      if (uDirection == FAILURE)
         break;

      iii += 2;

      pRaster->Free();
      bFree = TRUE;
   }

   CancelFileLoading(hWndView, L_END_LOADING, 0, 0);

   if (pRaster != NULL)
   {
      if (!bFree)
         pRaster->Free();
      pRaster->Release();
   }

   return nRet;
}