/*[]=====================================================================[]*/
/*[]     LEADTOOLS for Windows(Class Library)  - Version 11              []*/
/*[]                                                                     []*/
/*[]                                                                     []*/
/*[]     Copyright (c) 1991-2000 LEAD Technologies, Inc.                 []*/
/*[]     All Rights Reserved.                                            []*/
/*[]=====================================================================[]*/
/*---(SaveMem)------------------------------------------------------------
  
  We have made the assumption that the user has the knowledge of 
  Object Oriented programing of C under Windows.

  This example will:
  1. load an image from a file, selected using Windows' common dialog box for
     opening a file, to a bitmap,
  2. display the image in a window.
  3. get a filename, format, and bits per pixel to save to, using Windows'
     common dialog box,
  4. save the image.

  This is a menu driven example for loading and saving images.

  Usage: SAVEMEM
  --------------------------------------------------------------------------*/
// SMemView.cpp : implementation of the CSMemView class
//

#include "stdafx.h"
#include "SMem.h"
#include <sys/stat.h>
#include "SMemDoc.h"
#include "SMemView.h"
#include <afx.h>

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

/////////////////////////////////////////////////////////////////////////////
// CSMemView

IMPLEMENT_DYNCREATE(CSMemView, CView)

BEGIN_MESSAGE_MAP(CSMemView, CView)
	//{{AFX_MSG_MAP(CSMemView)
	ON_COMMAND(ID_FILE_OPEN, OnFileOpen)
	ON_COMMAND(IDM_FILE_SAVE, OnFileSave)
	ON_WM_CREATE()
	ON_UPDATE_COMMAND_UI(IDM_FILE_SAVE, OnUpdateFileSave)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CSMemView construction/destruction

CSMemView::CSMemView()
{
	m_LBmpWnd.EnableAutoPaint(TRUE);
	EnableSave = FALSE;
}

CSMemView::~CSMemView()
{
}

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

	return CView::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CSMemView drawing

void CSMemView::OnDraw(CDC* pDC)
{
	CSMemDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);
	// TODO: add draw code for native data here
}

/////////////////////////////////////////////////////////////////////////////
// CSMemView diagnostics

#ifdef _DEBUG
void CSMemView::AssertValid() const
{
	CView::AssertValid();
}

void CSMemView::Dump(CDumpContext& dc) const
{
	CView::Dump(dc);
}

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

/////////////////////////////////////////////////////////////////////////////
// CSMemView message handlers

void CSMemView::OnFileOpen() 
{
	int nIdx;
	L_TCHAR szFilter[128];
	L_TCHAR szFileTitle[256];
	CString szFilename;
	L_INT nRetVal;

	lstrcpy (szFilter, _T("All Files|*.*|"));

	for (nIdx = 0; szFilter[nIdx] != '\0'; nIdx++)
	{
		if (szFilter[nIdx] == '|')
			szFilter[nIdx] = '\0';
	}

	CFileDialog OFDlg(TRUE);
	
	OFDlg.m_ofn.lStructSize = sizeof (OPENFILENAME);
	OFDlg.m_ofn.hwndOwner = this->m_hWnd;
	OFDlg.m_ofn.lpstrFilter = szFilter;
	OFDlg.m_ofn.nFilterIndex = 1;
	OFDlg.m_ofn.nMaxFile = 256;
	OFDlg.m_ofn.lpstrFileTitle = szFileTitle;
	OFDlg.m_ofn.nMaxFileTitle = sizeof(szFileTitle)/sizeof(L_TCHAR);
	OFDlg.m_ofn.lpstrTitle = _T("Open File");

	if ((OFDlg.DoModal()) == IDOK)
	{
		szFilename = OFDlg.GetFileName();
		nRetVal = m_LBmpWnd.Load (szFilename.LockBuffer(), 0, ORDER_BGRORGRAY, 1);
		if(nRetVal!=SUCCESS)
			LBase::DisplayError(GetSafeHwnd(), LBase::GetErrorString(nRetVal));
		else
			EnableSave = TRUE;
	}

	szFilename.UnlockBuffer();

}

void CSMemView::OnFileSave() 
{
	L_INT		   nIdx;
	L_INT		   nRetVal;
	L_TCHAR		szFilter[1024];
	L_TCHAR		szFileTitle[256];
	static BOOL fInit = FALSE;
	CString		szFilename;

	lstrcpy (szFilter,
            _T("CALS 1|*.cal|")
			_T("CCITT 1|*.tif|CCITT G3 1D|*.tif|CCITT G3 2D|*.tif|CCITT G4|*.tif|")
            _T("EPS|*.eps|")
            _T("GIF|*.gif|")
            _T("GEM Image 1|*.img|")
            _T("JFIF 4:1:1|*.jff|JFIF 4:2:2|*.jff|")
            _T("JTIF 4:1:1|*.jtf|JTIF 4:2:2|*.jtf|")
            _T("JFIF 4:4:4|*.jpg|JTIF 4:4:4|*.jpg|")
            _T("LEAD|*.cmp|LEAD 1 bit|*.cmp|")
            _T("MacPaint 1|*.mac|")
            _T("Microsoft Paint 1|*.msp|")
            _T("OS/2 BMP 1|*.bmp|OS/2 BMP 4|*.bmp|")
            _T("OS/2 BMP 8|*.bmp|OS/2 BMP 24|*.bmp|")
            _T("Macintosh PICTURE 1|*.pct|Macintosh PICTURE 4|*.pct|")
            _T("Macintosh PICTURE 8|*.pct|Macintosh PICTURE 24|*.pct|")
            _T("PCX 1|*.pcx|PCX 4|*.pcx|PCX 8|*.pcx|PCX 24|*.pcx|")
            _T("SUN Raster 1|*.ras|SUN Raster 4|*.ras|")
            _T("SUN Raster 8|*.ras|SUN Raster 24|*.ras|SUN Raster 32|*.ras|")
            _T("TGA 8|*.tga|TGA 16|*.tga|TGA 24|*.tga|TGA 32|*.tga|")
            _T("TIF 1|*.tif|TIF LZW 1|*.tif|TIF 4|*.tif|TIF LZW 4|*.tif|TIF 8|*.tif|TIF LZW 8|*.tif|")
            _T("TIF 16|*.tif|TIF LZW 16|*.tif|TIF 24|*.tif|TIF LZW 24|*.tif|")
            _T("Windows BMP 1|*.bmp|Windows BMP 4|*.bmp|")
            _T("Windows BMP 8|*.bmp|Windows BMP 16|*.bmp|")
            _T("Windows BMP 24|*.bmp|Windows BMP 32|*.bmp|")
            _T("WordPerfect 1|*.wpg|WordPerfect 4|*.wpg|WordPerfect 8|*.wpg|")
            _T("WMF 8|*.wmf|WMF 24|*.wmf|"));

	for (nIdx = 0; szFilter[nIdx] != '\0'; nIdx++)
	{
		if (szFilter[nIdx] == '|')
			szFilter[nIdx] = '\0';
	}

	CFileDialog SFDlg(FALSE);

	SFDlg.m_ofn.lStructSize = sizeof (OPENFILENAME);
	SFDlg.m_ofn.hwndOwner = this->m_hWnd;
	SFDlg.m_ofn.lpstrFilter = szFilter;
	SFDlg.m_ofn.nFilterIndex = 15;
	SFDlg.m_ofn.nMaxFile = 256;
	SFDlg.m_ofn.lpstrFileTitle = szFileTitle;
	SFDlg.m_ofn.nMaxFileTitle = sizeof(szFileTitle)/sizeof(L_TCHAR);

	if (!fInit)
	{
		SFDlg.m_ofn.lpstrInitialDir = _T("f:\\images");
		fInit = TRUE;
	}	
	SFDlg.m_ofn.lpstrTitle = _T("Save Bitmap File");

	if ((SFDlg.DoModal()) == IDOK)
	{
		szFilename = SFDlg.GetFileName();	
		nRetVal = SaveMemFunction (szFilename.LockBuffer(),m_LBmpWnd,SFDlg.m_ofn.nFilterIndex);
		if (nRetVal == SUCCESS)
			EnableSave = FALSE;
	}
	szFilename.UnlockBuffer();
}

L_INT CSMemView::SaveMemFunction(L_TCHAR L_FAR * pFileName,LBitmapWindow &LeadBitmap,L_INT uSaveIndex)
{
	LMemoryFile		userLeadMemFile ;
	LBuffer			LeadMemBuffer ;
	L_INT          nRetVal;
	L_UINT			uSize;
	L_UCHAR L_FAR * pImageData;
	LPCSTR			pDataMover;
	HANDLE			hFile;
	
	if (!(LeadBitmap.IsAllocated()))
	{
		LBase::DisplayError(GetSafeHwnd(), _T("Bitmap Not Allocated"));
		return FAILURE;
	}

	userLeadMemFile.SetBitmap(&LeadBitmap);

	userLeadMemFile.EnableCallBack(FALSE);

	uSize = LeadBitmap.GetBytesPerLine() * LeadBitmap.GetHeight();
	LeadMemBuffer.Reallocate (uSize);

	switch (uSaveIndex)
	{
		case SAVEMEM_TGA8:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_TGA,8,0) ;
			break;
		case SAVEMEM_TGA16:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_TGA,16,0) ;
			break;
		case SAVEMEM_TGA24:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_TGA,24,0) ;
			break;
		case SAVEMEM_TGA32:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_TGA,32,0) ;
			break;
		case SAVEMEM_TIF1:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_TIF,1,0) ;
			break;
		case SAVEMEM_TIFLZW1:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_TIFLZW,1,0) ;
			break;
		case SAVEMEM_CCITT:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_CCITT,1,0) ;
			break;
		case SAVEMEM_LEAD1BIT:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_LEAD1BIT,1,0) ;
			break;
		case SAVEMEM_TIF_G3_1D:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_CCITT_GROUP3_1DIM,1,0) ;
			break;
		case SAVEMEM_TIF_G3_2D:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_CCITT_GROUP3_2DIM,1,0) ;
			break;
		case SAVEMEM_TIF_G4:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_CCITT_GROUP4,1,0) ;
			break;
		case SAVEMEM_CALS_G4:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_CALS,1,0) ;
			break;
		case SAVEMEM_MAC:
			nRetVal = LeadBitmap.Size(567, 720, SIZE_NORMAL);
			if (nRetVal == SUCCESS)
			{
				userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_MAC,1,0) ;				
			}
			break;
		case SAVEMEM_IMG1:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_IMG,1,0) ;
			break;
		case SAVEMEM_MSP:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_MSP,1,0) ;
			break;
		case SAVEMEM_WPG1:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_WPG,1,0) ;
			break;
		case SAVEMEM_WPG4:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_WPG,4,0) ;
			break;
		case SAVEMEM_WPG8:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_WPG,8,0) ;
			break;
		case SAVEMEM_RAS1:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_RAS,1,0) ;
			break;
		case SAVEMEM_RAS4:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_RAS,4,0) ;
			break;
		case SAVEMEM_RAS8:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_RAS,8,0) ;
			break;
		case SAVEMEM_RAS24:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_RAS,24,0) ;
			break;
		case SAVEMEM_RAS32:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_RAS,32,0) ;
			break;
		case SAVEMEM_PCT1:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_PCT,1,0) ;
			break;
		case SAVEMEM_PCT4:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_PCT,4,0) ;
			break;
		case SAVEMEM_PCT8:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_PCT,8,0) ;
			break;
		case SAVEMEM_PCT24:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_PCT,24,0) ;
			break;
		case SAVEMEM_TIF4:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_TIF,4,0) ;
			break;
		case SAVEMEM_TIF8:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_TIF,8,0) ;
			break;
		case SAVEMEM_TIF16:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_TIF,16,0) ;
			break;
		case SAVEMEM_TIF24:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_TIF,24,0) ;
			break;
		case SAVEMEM_TIFLZW4:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_TIFLZW,4,0) ;
			break;
		case SAVEMEM_TIFLZW8:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_TIFLZW,8,0) ;
			break;
		case SAVEMEM_TIFLZW16:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_TIFLZW,16,0) ;
			break;
		case SAVEMEM_TIFLZW24:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_TIFLZW,24,0) ;
			break;
		case SAVEMEM_WBMP1:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_BMP,1,0) ;
			break;
		case SAVEMEM_WBMP4:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_BMP,4,0) ;
			break;
		case SAVEMEM_WBMP8:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_BMP,8,0) ;
			break;
		case SAVEMEM_WBMP16:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_BMP,16,0) ;
			break;
		case SAVEMEM_WBMP24:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_BMP,24,0) ;
			break;
		case SAVEMEM_WBMP32:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_BMP,32,0) ;
			break;
		case SAVEMEM_OBMP1:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_OS2,1,0) ;
			break;
		case SAVEMEM_OBMP4:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_OS2,4,0) ;
			break;
		case SAVEMEM_OBMP8:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_OS2,8,0) ;
			break;
		case SAVEMEM_OBMP24:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_OS2,24,0) ;
			break;
		case SAVEMEM_PCX1:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_PCX,1,0) ;
			break;
		case SAVEMEM_PCX4:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_PCX,4,0) ;
			break;
		case SAVEMEM_PCX8:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_PCX,8,0) ;
			break;
		case SAVEMEM_PCX24:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_PCX,24,0) ;
			break;
		case SAVEMEM_GIF:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_GIF,8,0) ;
			break;
		case SAVEMEM_WMF8:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_WMF,8,0) ;
			break;
		case SAVEMEM_WMF24:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_WMF,24,0) ;
			break;
		case SAVEMEM_EPS:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_EPS,8,0) ;
			break;
		case SAVEMEM_LEAD:
			if (LeadBitmap.IsGrayScale() == GRAY_ORDEREDNORMAL)
			{
				userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_LEAD,8,PQ1) ;
			}
			else
			{
				userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_LEAD,24,PQ1) ;
			}
			break;
		case SAVEMEM_LEAD1JFIF:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_LEAD1JFIF,24,30) ;
			break;
		case SAVEMEM_LEAD2JFIF:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_LEAD2JFIF,24,30) ;
			break;
		case SAVEMEM_LEAD1JTIF:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_LEAD1JTIF,24,30) ;
			break;
		case SAVEMEM_LEAD2JTIF:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_LEAD2JTIF,24,30) ;
			break;
		case SAVEMEM_JFIF:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_JFIF,24,30) ;
			break;
		case SAVEMEM_JTIF:
			userLeadMemFile.SaveBitmap(&LeadMemBuffer,FILE_JTIF,24,30) ;
			break;
		default:
			return FAILURE;
	}

	pImageData = (L_UCHAR L_FAR *) LeadMemBuffer.Lock();
	
	pDataMover = (LPCSTR) pImageData;

	MessageBox (_T("Save To Memory Successful"),_T("Save to Memory"),MB_OK);
	
	nRetVal = LeadBitmap.Free();
	if (nRetVal != SUCCESS)
	{
		LBase::DisplayError(GetSafeHwnd(), LBase::GetErrorString(nRetVal));
		return nRetVal;
	}
	
	/* Open/Create the file to write. */
   hFile = CreateFile(pFileName,GENERIC_WRITE, 0, 
                      NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );

   if(hFile == NULL || hFile == INVALID_HANDLE_VALUE)
	{
		LBase::DisplayError(GetSafeHwnd(), _T("Error Create File"));
		return (FALSE);           /* Failure on creation! */
   }

	/* Write the file in a loop, because the file could be larger than a
	  single write can request. */
	uSize = LeadMemBuffer.GetSize();

	while (uSize > 0)
	{
      DWORD dwBuff ;
		UINT Size = (UINT) min (uSize, (L_UINT32) 32000);
      
		if (!WriteFile(hFile, pDataMover, Size, &dwBuff, NULL))
		{
			LBase::DisplayError(GetSafeHwnd(), _T("Error Write To File"));
			return FAILURE;          /* Failure on write! */
		}
		else
		{
			uSize -= dwBuff;
			pDataMover += dwBuff;
		}
	}

	if (nRetVal != -1)
		MessageBox (_T("Memory File Has Been Written To Disk!"), _T("SUCCESS"), MB_OK);

	CloseHandle (hFile);

	LeadMemBuffer.Unlock();
	
	InvalidateRect(NULL);
	UpdateWindow();
	
	return SUCCESS;
}



int CSMemView::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
	if (CView::OnCreate(lpCreateStruct) == -1)
		return -1;
	
	m_LBmpWnd.SetWndHandle(GetSafeHwnd());
	
	return 0;
}

void CSMemView::OnActivateView(BOOL bActivate, CView* pActivateView, CView* pDeactiveView) 
{
	// TODO: Add your specialized code here and/or call the base class
	if(bActivate && pActivateView == this)
		m_LBmpWnd.HandlePalette(WM_QUERYNEWPALETTE, 0, 0);

	CView::OnActivateView(bActivate, pActivateView, pDeactiveView);
}

void CSMemView::OnUpdateFileSave(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
	if (EnableSave == TRUE)
		pCmdUI->Enable (TRUE);
	else
		pCmdUI->Enable (FALSE);
}