/*[]=====================================================================[]*/
/*[]     LeadTools Run Time Library - Version 14                         []*/
/*[]                                                                     []*/
/*[]                                                                     []*/
/*[]     Copyright (c)1991-2004 LEAD Technologies, Inc.                  []*/
/*[]     All Rights Reserved.                                            []*/
/*[]=====================================================================[]*/

#include "stdafx.h"
#include "ABC.h"

#include "ABCDoc.h"

#include "MainFrm.h"

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

extern CABCApp theApp;



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

   switch(message)
   {
   case WM_INITDIALOG:
      if(lParam)
         lpbCancelLoading=(L_BOOL*)lParam;
      else
         DestroyWindow(hDlg);
      return(TRUE);

  case WM_COMMAND:
      if(GET_WM_COMMAND_ID(wParam,lParam)==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 L_INT CancelFileLoading( HWND hWnd, L_INT nStatus,L_INT nPageNo,L_INT nTotalPages)
{
   static   HWND     hCancelDlg=0;
   static   L_BOOL   bCancelLoading;
   static   FARPROC  lpDlgProc = (FARPROC) CancelLoadDlgProc;
   L_INT             nRet = SUCCESS;
   MSG               Msg;
   L_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)(L_BOOL L_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);
}

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

IMPLEMENT_DYNCREATE(CABCDoc, CDocument)

BEGIN_MESSAGE_MAP(CABCDoc, CDocument)
	//{{AFX_MSG_MAP(CABCDoc)
	ON_COMMAND(ID_FILE_SAVE_AS, OnFileSaveAs)
   ON_COMMAND(ID_FILE_SAVE_AS_TIFF, OnFileSaveAsTiff)
	ON_COMMAND(ID_COPY, OnCopy)
	ON_COMMAND(ID_FILE_SAVE_MULTI_PAGE, OnFileSaveMultiPage)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/*--------------------------------------------------------------------------+
| Function :CABCDoc 
| Desc     :Constructor
| Return   :void
| Notes    :
+--------------------------------------------------------------------------*/
CABCDoc::CABCDoc()
{
   m_pDimensions = NULL;
   m_DimensionCount = 0;
   memset(&m_fi, 0, sizeof(FILEINFO));
   m_fi.uStructSize = sizeof(FILEINFO);

   m_bCompressed = FALSE;
}

/*--------------------------------------------------------------------------+
| Function :CABCDoc 
| Desc     :Destructor
| Return   :void
| Notes    :
+--------------------------------------------------------------------------*/
CABCDoc::~CABCDoc()
{
   if(m_pDimensions != NULL)
      free(m_pDimensions);  
}

/*--------------------------------------------------------------------------+
| Function :OnNewDocument 
| Desc     :initialization
| Return   :bool
| Notes    :
+--------------------------------------------------------------------------*/
BOOL CABCDoc::OnNewDocument()
{
	if (!CDocument::OnNewDocument())
		return FALSE;

	// add reinitialization code here
	// (SDI documents will reuse this document)
	return TRUE;
}

/*--------------------------------------------------------------------------+
| Function :OnOpenDocument 
| Desc     :Load a file 
| Return   :bool
| Notes    :
+--------------------------------------------------------------------------*/
BOOL CABCDoc::OnOpenDocument( LPCTSTR lpszPathName ) 
{
   L_INT nRet;

   LOADFILEOPTION lfo; memset(&lfo, 0, sizeof(LOADFILEOPTION)); SET_SIZE(&lfo);
   L_GetDefaultLoadFileOption( &lfo, sizeof(LOADFILEOPTION) );
   lfo.PageNumber = theApp.m_nPageNumber;
   L_InitBitmap(&m_LEADBitmap, sizeof(BITMAPHANDLE), 0, 0, 0);
   
   m_fi.uStructSize = sizeof(FILEINFO);
   nRet = L_FileInfo((L_TCHAR*)lpszPathName, &m_fi, sizeof(FILEINFO), 0, &lfo);
   
   m_csCurrentFilename = lpszPathName;
  
   m_pDimensions = NULL;
   m_DimensionCount = 0;

   nRet = SUCCESS ;
      
   if( nRet == SUCCESS )
   {
      CRect rcMainFrame;
      theApp.m_pMainWnd->GetClientRect(&rcMainFrame);
      HCURSOR hCur = SetCursor( LoadCursor(NULL,IDC_WAIT) );
    
      nRet = L_LoadBitmap((L_TCHAR *)lpszPathName, &m_LEADBitmap, sizeof(BITMAPHANDLE), 0, ORDER_BGRORGRAY, &lfo, &m_fi );
      if( SUCCESS != nRet) return FALSE;
      SetCursor( hCur );
   }
   else
   {
      theApp.DisplayLEADError(nRet);
      return(FALSE);
   }

   return (TRUE);
}



/*--------------------------------------------------------------------------+
| Function :OnCloseDocument 
| Desc     :free
| Return   :void
| Notes    :
+--------------------------------------------------------------------------*/
void CABCDoc::OnCloseDocument() 
{
   m_csCurrentFilename.Empty();
   if(m_pDimensions)
   {
      free(m_pDimensions);
      m_pDimensions = NULL;
   }

   if(m_LEADBitmap.Flags.Allocated)
      L_FreeBitmap(&m_LEADBitmap);
   CDocument::OnCloseDocument();
}

/*--------------------------------------------------------------------------+
| Function :LOADFILE 
| Desc     :Load a file
| Return   :int
| Notes    :
+--------------------------------------------------------------------------*/
L_INT CABCDoc::LOADFILE( L_INT eQuality, L_TCHAR* pszInpFile, BITMAPHANDLE *pBitmapHandle, LOADFILEOPTION* pLoadFileOption, FILEINFO* pLoadFileInfo  )
{
   L_INT nRet;
   
   nRet = L_LoadBitmap( pszInpFile, pBitmapHandle, sizeof(BITMAPHANDLE), 0, ORDER_BGR, pLoadFileOption, pLoadFileInfo );
   
   return nRet;
}


/*--------------------------------------------------------------------------+
| Function :SaveTIFFABC 
| Desc     :Save ABC multipage
| Return   :int
| Notes    :
+--------------------------------------------------------------------------*/
L_INT CABCDoc::SaveTIFFABC( L_INT eQuality, L_TCHAR* pszInpFile, L_TCHAR* pszOutFile )
{
   if( lstrlen( pszInpFile ) == 0 ) return ERROR_INV_FILENAME;
   if( lstrlen( pszOutFile ) == 0 ) return ERROR_INV_FILENAME;
   if( lstrcmp( pszInpFile, pszOutFile ) == 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=NULL;
   pMain = (CMainFrame*)AfxGetMainWnd();
   if(pMain) pStatusBar = &pMain->m_wndStatusBar;
   CTime ctStart = CTime::GetCurrentTime();
   L_INT nRet = SUCCESS;
   
   BITMAPHANDLE   BitmapHandle;

   FILEINFO LoadFileInfo; LoadFileInfo.uStructSize = sizeof(LOADFILEOPTION);
   FILEINFO SaveFileInfo; SaveFileInfo.uStructSize = sizeof(LOADFILEOPTION);
   LOADFILEOPTION LoadFileOption; memset(&LoadFileOption,  0, sizeof(LOADFILEOPTION)); LoadFileOption.uStructSize  = sizeof(LOADFILEOPTION);
   LOADFILEOPTION LoadFileOption2;memset(&LoadFileOption2, 0, sizeof(LOADFILEOPTION)); LoadFileOption2.uStructSize = sizeof(LOADFILEOPTION);
   SAVEFILEOPTION SaveFileOption; memset(&SaveFileOption,  0, sizeof(SAVEFILEOPTION)); SaveFileOption.uStructSize  = sizeof(SAVEFILEOPTION);
   FILEINFO LoadFileInfoTmp;memset(&LoadFileInfoTmp, 0, sizeof(FILEINFO)); LoadFileInfoTmp.uStructSize = sizeof(FILEINFO);
   nRet = L_FileInfo( pszInpFile, &LoadFileInfoTmp, sizeof(FILEINFO), FILEINFO_TOTALPAGES, NULL );
   
   LoadFileOption.PageNumber = 1;
   nRet = L_FileInfo( pszInpFile, &LoadFileInfo, sizeof(FILEINFO), 0, &LoadFileOption);
   nRet = LOADFILE( eQuality, pszInpFile, &BitmapHandle, &LoadFileOption, &LoadFileInfo );
   nRet = L_SaveFile( pszOutFile, &BitmapHandle, FILE_TIF_ABC, 1, eQuality, SAVEFILE_FIXEDPALETTE, NULL, NULL, NULL );
   LoadFileOption2.PageNumber = 1;
   nRet = L_FileInfo( pszOutFile, &SaveFileInfo, sizeof(FILEINFO), 0, &LoadFileOption2 );
   L_FreeBitmap( &BitmapHandle );

   L_UINT uDirection = CancelFileLoading( hWndView, L_START_LOADING ,0, 0 );
   
   int iii = 2;
   while( LoadFileOption.PageNumber <  LoadFileInfoTmp.TotalPages)
   {
      SETLOADOPTIONS( LoadFileOption, LoadFileInfo )      
      nRet = L_FileInfo( pszInpFile, &LoadFileInfo, sizeof(FILEINFO), 0, &LoadFileOption);
      if( nRet != SUCCESS ){ TRACE(TEXT("\n L_SaveFile error %d"), nRet ); break; }

      TRACE(TEXT("\n %d"), LoadFileOption.IFD );
      TRACE(TEXT("\n %d"), LoadFileInfo.IFD );

      nRet = LOADFILE( eQuality, pszInpFile, &BitmapHandle, &LoadFileOption, &LoadFileInfo );
      if( nRet != SUCCESS ){ TRACE(TEXT("\n L_LoadBitmap error %d"), nRet ); nRet = SUCCESS; break; }
      SETLOADOPTIONS( SaveFileOption, SaveFileInfo )

      nRet = L_SaveFile( pszOutFile, &BitmapHandle, FILE_TIF_ABC, 1, eQuality, SAVEFILE_MULTIPAGE|SAVEFILE_FIXEDPALETTE	, NULL, NULL, &SaveFileOption );
      if( nRet != SUCCESS ){ TRACE(TEXT("\n L_SaveFile error %d"), nRet ); break; }

      SETLOADOPTIONS( LoadFileOption2, SaveFileInfo )
      nRet = L_FileInfo( pszOutFile, &SaveFileInfo, sizeof(FILEINFO), 0, &LoadFileOption2 );
      if( nRet != SUCCESS ){ TRACE(TEXT("\n L_SaveFile 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++;

      L_FreeBitmap( &BitmapHandle );

   }

   CancelFileLoading( hWndView, L_END_LOADING,0,0);

   L_FreeBitmap( &BitmapHandle );

   return nRet;
}


/*--------------------------------------------------------------------------+
| Function :LoadCombineBitmap 
| Desc     :load and combine two bitmaps 
| Return   :int
| Notes    :
+--------------------------------------------------------------------------*/
L_INT CABCDoc::LoadCombineBitmap( L_INT eQuality, L_TCHAR* pszInpFile, BITMAPHANDLE *pBitmap, L_INT TotalPages )
{
   L_INT nRet = SUCCESS;
   L_FreeBitmap( pBitmap );
   BITMAPHANDLE BitmapHandle1, BitmapHandle2;
   L_INT nWidth, nHeight;
   
   SETLOADOPTIONS( m_LoadFileOption, m_LoadFileInfo )   
   nRet = L_FileInfo( pszInpFile, &m_LoadFileInfo, sizeof(FILEINFO), 0, &m_LoadFileOption); ASSERT( nRet == SUCCESS );
   if( (m_LoadFileInfo.IFD == m_LoadFileOption.IFD) && (m_LoadFileInfo.IFD != 0) )
      return (0);

   nRet = LOADFILE( eQuality, pszInpFile, &BitmapHandle1, &m_LoadFileOption, &m_LoadFileInfo );
   if( nRet != SUCCESS ){ TRACE(TEXT("\n LoadBitmap1 error %d"), nRet ); return (0); }

   nWidth  = BitmapHandle1.Width;
   nHeight = BitmapHandle1.Height;

   
   if( m_LoadFileOption.PageNumber == TotalPages)
   {
      nRet = L_CopyBitmap( pBitmap, &BitmapHandle1, sizeof(BITMAPHANDLE) ); ASSERT( nRet == SUCCESS );
      L_FreeBitmap( &BitmapHandle1 );
      return (1);
   }
   else
   {
      SETLOADOPTIONS( m_LoadFileOption, m_LoadFileInfo )
      nRet = L_FileInfo( pszInpFile, &m_LoadFileInfo, sizeof(FILEINFO), 0, &m_LoadFileOption); ASSERT( nRet == SUCCESS );
   
      nRet = LOADFILE( eQuality, pszInpFile, &BitmapHandle2, &m_LoadFileOption, &m_LoadFileInfo );
      if( nRet != SUCCESS )
      {
         TRACE(TEXT("\n LoadBitmap2 error %d"), nRet );
         nRet = L_CopyBitmap( pBitmap, &BitmapHandle1, sizeof(BITMAPHANDLE) ); ASSERT( nRet == SUCCESS );
         L_FreeBitmap( &BitmapHandle1 );
         return (1);
      }
      

      nWidth  = max( nWidth, (BitmapHandle2.Width) );
      nHeight = nHeight + BitmapHandle2.Height;

      nRet = L_CreateBitmap( pBitmap, sizeof(BITMAPHANDLE), TYPE_CONV, nWidth, nHeight, 1, ORDER_RGB, NULL, BitmapHandle1.ViewPerspective, NULL, 0 ); ASSERT( nRet == SUCCESS );
   
      nRet = L_CombineBitmapExt( pBitmap, 0, 0,                    BitmapHandle1.Width, BitmapHandle1.Height, &BitmapHandle1, 0, 0, L_SRC_COPY ); ASSERT( nRet == SUCCESS );
      nRet = L_CombineBitmapExt( pBitmap, 0, BitmapHandle1.Height, BitmapHandle2.Width, BitmapHandle2.Height, &BitmapHandle2, 0, 0, L_SRC_COPY ); ASSERT( nRet == SUCCESS );
      L_FreeBitmap( &BitmapHandle2 );
      L_FreeBitmap( &BitmapHandle1 );
      return (2);
   }
}

/*--------------------------------------------------------------------------+
| Function :SaveTIFFABCCombined 
| Desc     :save multipage combined images
| Return   :void
| Notes    :
+--------------------------------------------------------------------------*/
L_INT CABCDoc::SaveTIFFABCCombined( L_INT eQuality, L_TCHAR* pszInpFile, L_TCHAR* pszOutFile )
{
   if( lstrlen( pszInpFile ) == 0 ) return ERROR_INV_FILENAME;
   if( lstrlen( pszOutFile ) == 0 ) return ERROR_INV_FILENAME;
   if( lstrcmp( pszInpFile, pszOutFile ) == 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=NULL;
   pMain = (CMainFrame*)AfxGetMainWnd();
   if(pMain) pStatusBar = &pMain->m_wndStatusBar;
   CTime ctStart = CTime::GetCurrentTime();
   L_INT nRet = SUCCESS;
   long ret;
   
   BITMAPHANDLE   BitmapHandle;
   
   FILEINFO SaveFileInfo; SaveFileInfo.uStructSize = sizeof(LOADFILEOPTION);
   
   LOADFILEOPTION LoadFileOption2;memset(&LoadFileOption2, 0, sizeof(LOADFILEOPTION)); LoadFileOption2.uStructSize = sizeof(LOADFILEOPTION);
   SAVEFILEOPTION SaveFileOption; memset(&SaveFileOption,  0, sizeof(SAVEFILEOPTION)); SaveFileOption.uStructSize  = sizeof(SAVEFILEOPTION);
   FILEINFO LoadFileInfoTmp;memset(&LoadFileInfoTmp, 0, sizeof(FILEINFO)); LoadFileInfoTmp.uStructSize = sizeof(FILEINFO);
   nRet = L_FileInfo( pszInpFile, &LoadFileInfoTmp, sizeof(FILEINFO), FILEINFO_TOTALPAGES, NULL );
   
   m_LoadFileOption.PageNumber = 0;
   ret = LoadCombineBitmap( eQuality, pszInpFile, &BitmapHandle, LoadFileInfoTmp.TotalPages );
   if( ret == 0 )
   {
      L_FreeBitmap( &BitmapHandle );
      return nRet;
   }

   nRet = L_SaveFile( pszOutFile, &BitmapHandle, FILE_TIF_ABC, 1, eQuality, SAVEFILE_FIXEDPALETTE, NULL, NULL, NULL );
   LoadFileOption2.PageNumber = 1;
   nRet = L_FileInfo( pszOutFile, &SaveFileInfo, sizeof(FILEINFO), 0, &LoadFileOption2 );
   L_FreeBitmap( &BitmapHandle );

   if( ret == 1 )
      return SUCCESS;


   L_UINT uDirection = CancelFileLoading( hWndView, L_START_LOADING ,0, 0 );
   int iii = 2;

   while( m_LoadFileOption.PageNumber < LoadFileInfoTmp.TotalPages)
   {
      ret = LoadCombineBitmap( eQuality, pszInpFile, &BitmapHandle, LoadFileInfoTmp.TotalPages);
      if( ret == 0 )
      {
         CancelFileLoading( hWndView, L_END_LOADING,0,0);
         L_FreeBitmap( &BitmapHandle );
         return nRet;
      }      
      SETLOADOPTIONS( SaveFileOption, SaveFileInfo )

      nRet = L_SaveFile( pszOutFile, &BitmapHandle, FILE_TIF_ABC, 1, eQuality, SAVEFILE_MULTIPAGE|SAVEFILE_FIXEDPALETTE	, NULL, NULL, &SaveFileOption );
      if( nRet != SUCCESS ){ TRACE(TEXT("\n L_SaveFile error %d"), nRet ); break; }

      SETLOADOPTIONS( LoadFileOption2, SaveFileInfo )
      nRet = L_FileInfo( pszOutFile, &SaveFileInfo, sizeof(FILEINFO), 0, &LoadFileOption2 );
      if( nRet != SUCCESS ){ TRACE(TEXT("\n L_SaveFile 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;

      L_FreeBitmap( &BitmapHandle );

   }
   CancelFileLoading( hWndView, L_END_LOADING,0,0);

   L_FreeBitmap( &BitmapHandle );

   return nRet;
}




/*--------------------------------------------------------------------------+
| Function :OnFileSaveAs 
| Desc     :save as a single page file
| Return   :void
| Notes    :
+--------------------------------------------------------------------------*/
void CABCDoc::OnFileSaveAs() 
{
   HCURSOR hCursor;
   L_INT nRet;
   m_LoadFileInfo.uStructSize = sizeof(LOADFILEOPTION);
   memset( &m_LoadFileOption,  0, sizeof(LOADFILEOPTION)); m_LoadFileOption.uStructSize  = sizeof(LOADFILEOPTION);
 
#if(WINVER >= 0x0400)
   theApp.m_OpenFileName.Flags |= OFN_ENABLESIZING;
#endif /* WINVER >= 0x0400 */

   CString csFileName(theApp.m_szOpenedFileName);
   
   if( csFileName.IsEmpty() )
   {
      csFileName = TEXT("Test.abc");
   }
   else
   {
      int z = csFileName.ReverseFind('.');
      if( z > 0 )
         csFileName = csFileName.Left( z );

      csFileName += TEXT("_Abc_");
      csFileName += theApp.m_szQuality;
      csFileName += TEXT(".abc");
   }

   CFileDialog cfdSave( FALSE, 
                        TEXT("abc"), 
                        csFileName, 
                        OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, 
                        TEXT("LEAD ABC Format (*.abc)|*.abc||"), 
                        NULL );
   cfdSave.m_ofn.lpstrTitle = TEXT("Save Current As ABC");
   nRet = cfdSave.DoModal();
   csFileName = cfdSave.GetPathName();

   if( nRet == IDOK )
   {
      hCursor = SetCursor (LoadCursor (NULL, IDC_WAIT));
      
      BITMAPHANDLE BitmapHandle;
      LOADFILEOPTION lfo; memset(&lfo, 0, sizeof(LOADFILEOPTION)); SET_SIZE(&lfo);
      L_GetDefaultLoadFileOption( &lfo, sizeof(LOADFILEOPTION) );
      lfo.PageNumber = theApp.m_nPageNumber;
      nRet = L_LoadBitmap( theApp.m_szOpenedFileName, &BitmapHandle, sizeof(BITMAPHANDLE), 0, ORDER_BGR, &lfo, NULL );
      
      nRet = L_SaveFile( (L_TCHAR *)((LPCTSTR)csFileName),&BitmapHandle,FILE_ABC,1,theApp.m_Quality,SAVEFILE_FIXEDPALETTE, NULL, NULL, NULL );
      
      if( nRet != SUCCESS )
      {
         theApp.DisplayLEADError(nRet);
         SetCursor (hCursor);
         return;
      }
      else
      {
         SetModifiedFlag(FALSE);
      }
      
      OnSaveDocument((L_TCHAR *)(LPCTSTR)theApp.m_szFileName);
      SetCursor (hCursor);
   }

   return;
}

/*--------------------------------------------------------------------------+
| Function :OnFileSaveAsTiff 
| Desc     :save as a single page file
| Return   :void
| Notes    :
+--------------------------------------------------------------------------*/
void CABCDoc::OnFileSaveAsTiff() 
{
   HCURSOR hCursor;
   L_INT nRet;
   m_LoadFileInfo.uStructSize = sizeof(LOADFILEOPTION);
   memset( &m_LoadFileOption,  0, sizeof(LOADFILEOPTION)); m_LoadFileOption.uStructSize  = sizeof(LOADFILEOPTION);
 
#if(WINVER >= 0x0400)
   theApp.m_OpenFileName.Flags |= OFN_ENABLESIZING;
#endif /* WINVER >= 0x0400 */

   CString csFileName(theApp.m_szOpenedFileName);
   
   if( csFileName.IsEmpty() )
   {
      csFileName = TEXT("Test.tif");
   }
   else
   {
      int z = csFileName.ReverseFind('.');
      if( z > 0 )
         csFileName = csFileName.Left( z );

      csFileName += TEXT("_Tiff_");
      csFileName += theApp.m_szQuality;
      csFileName += TEXT(".tif");
   }

   CFileDialog cfdSave( FALSE, 
                        TEXT("tif"), 
                        csFileName, 
                        OFN_HIDEREADONLY, 
                        TEXT("TIFF LEAD ABC Format (*.tif)|*.tif||"), 
                        NULL );
   cfdSave.m_ofn.lpstrTitle = TEXT("Save Current As TIFF");
   nRet = cfdSave.DoModal();
   csFileName = cfdSave.GetPathName();

   if( nRet == IDOK )
   {
      hCursor = SetCursor (LoadCursor (NULL, IDC_WAIT));
      
      BITMAPHANDLE BitmapHandle;
      LOADFILEOPTION lfo; memset(&lfo, 0, sizeof(LOADFILEOPTION)); SET_SIZE(&lfo);
      L_GetDefaultLoadFileOption( &lfo, sizeof(LOADFILEOPTION) );
      lfo.PageNumber = theApp.m_nPageNumber;
      nRet = L_LoadBitmap( theApp.m_szOpenedFileName, &BitmapHandle, sizeof(BITMAPHANDLE), 0, ORDER_BGR, &lfo, NULL );
      
      SAVEFILEOPTION SaveFileOption; memset(&SaveFileOption,  0, sizeof(SAVEFILEOPTION)); SaveFileOption.uStructSize  = sizeof(SAVEFILEOPTION);
      SaveFileOption.PageNumber = 2;//it must be greater than 1 to append a file
      nRet = L_SaveFile( (L_TCHAR *)((LPCTSTR)csFileName),&BitmapHandle,FILE_TIF_ABC,1,theApp.m_Quality,SAVEFILE_MULTIPAGE|SAVEFILE_FIXEDPALETTE, NULL, NULL, &SaveFileOption);
      
      if( nRet != SUCCESS )
      {
         theApp.DisplayLEADError(nRet);
         SetCursor (hCursor);
         return;
      }
      else
      {
         SetModifiedFlag(FALSE);
      }
      
      OnSaveDocument((L_TCHAR *)(LPCTSTR)theApp.m_szFileName);
      SetCursor (hCursor);
   }

   return;
}

/*--------------------------------------------------------------------------+
| Function :OnFileSaveMultiPage 
| Desc     :save a multipage file
| Return   :void
| Notes    :
+--------------------------------------------------------------------------*/
void CABCDoc::OnFileSaveMultiPage() 
{
   HCURSOR hCursor;
   L_INT nRet;
   m_LoadFileInfo.uStructSize = sizeof(LOADFILEOPTION);
   memset( &m_LoadFileOption,  0, sizeof(LOADFILEOPTION)); m_LoadFileOption.uStructSize  = sizeof(LOADFILEOPTION);
  
 
#if(WINVER >= 0x0400)
   theApp.m_OpenFileName.Flags |= OFN_ENABLESIZING;
#endif /* WINVER >= 0x0400 */

   CString csFileName(theApp.m_szOpenedFileName);
   if( csFileName.IsEmpty() )
   {
      csFileName = TEXT("Test.tif");
   }
   else
   {
      int z = csFileName.ReverseFind('.');
      if( z > 0 )
         csFileName = csFileName.Left( z );

      csFileName += TEXT("_M_");
      csFileName += theApp.m_szQuality;
      csFileName += TEXT(".tif");
   }
   
   CString csFilter;
   csFilter = TEXT("TIFF LEAD ABC Format (*.tif)|*.tif||");
   
   CFileDialog cfdSave( FALSE, 
                        TEXT("tif"), 
                        csFileName, 
                        OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, 
                        csFilter, 
                        NULL );
   cfdSave.m_ofn.lpstrTitle = TEXT("Save All Pages");
   nRet = cfdSave.DoModal();
   csFileName = cfdSave.GetPathName();

   if( nRet == IDOK )
   {
      hCursor = SetCursor (LoadCursor (NULL, IDC_WAIT));

      if( theApp.m_bCombine )
         nRet = SaveTIFFABCCombined( theApp.m_Quality, theApp.m_szOpenedFileName, (L_TCHAR*)((LPCTSTR)csFileName) );
      else
         nRet = SaveTIFFABC( theApp.m_Quality, theApp.m_szOpenedFileName, (L_TCHAR*)((LPCTSTR)csFileName) );
      
      if( nRet != SUCCESS )
      {
         theApp.DisplayLEADError(nRet);
         SetCursor (hCursor);
         return;
      }
      else
      {
         SetModifiedFlag(FALSE);
      }
      
      OnSaveDocument(theApp.m_szFileName);
      SetCursor (hCursor);
   }

   return;
}


/*--------------------------------------------------------------------------+
| Function :OnSaveDocument 
| Desc     :On Save
| Return   :bool
| Notes    :
+--------------------------------------------------------------------------*/
BOOL CABCDoc::OnSaveDocument(LPCTSTR  lpszPathName) 
{
   SetModifiedFlag(FALSE);
   return(TRUE);
}


/*--------------------------------------------------------------------------+
| Function :OnCopy 
| Desc     :compy bitmap
| Return   :void
| Notes    :
+--------------------------------------------------------------------------*/
void CABCDoc::OnCopy() 
{
   if( m_LEADBitmap.Flags.Allocated )
   {
      L_INT nRet;
      HWND hWndView;
      POSITION pos = GetFirstViewPosition();
      if( pos != NULL )
      {
         CView* pView = GetNextView(pos);
         hWndView = pView->m_hWnd;
      }

	   nRet = L_CopyToClipboard( hWndView, &m_LEADBitmap, COPY2CB_EMPTY | COPY2CB_DIB | COPY2CB_DDB );
      ASSERT( nRet == SUCCESS );
   }
	
}