magichouseview.cpp

"MagicHouse框架"目录： 含有MagicHouse的原始框架

{
	m_nEffectDisplayType = EDT_RAND;
}

void CMagicHouseView::OnEffectScan()
{
	m_nEffectDisplayType = EDT_SCANDOWN;
}

void CMagicHouseView::OnEffectDscan()
{
	m_nEffectDisplayType = EDT_VSCAN;
}

void CMagicHouseView::OnEffectMove()
{
	m_nEffectDisplayType = EDT_MOVERIGHT;
}

void CMagicHouseView::OnEffectHsmove()
{
	m_nEffectDisplayType = EDT_HSMOVE;
}

void CMagicHouseView::OnEffectVBlind()
{
	m_nEffectDisplayType = EDT_VBLIND;
}

void CMagicHouseView::OnEffectSblind()
{
	m_nEffectDisplayType = EDT_HBLIND;
}

void CMagicHouseView::OnEffectVraster()
{
	m_nEffectDisplayType = EDT_VRASTER;
}

void CMagicHouseView::OnEffectHRaster()
{
	m_nEffectDisplayType = EDT_HRASTER;
}

void CMagicHouseView::OnEffectMosaic()
{
	m_nEffectDisplayType = EDT_MOSAIC;
}

void CMagicHouseView::OnEffectRaindrop()
{
	m_nEffectDisplayType = EDT_RAINDROP;
}

void CMagicHouseView::OnUpdateEffectNone(CCmdUI *pCmdUI)
{
	pCmdUI->SetCheck(m_nEffectDisplayType == EDT_NONE);
}

void CMagicHouseView::OnUpdateEffectRand(CCmdUI *pCmdUI)
{
	pCmdUI->SetCheck(m_nEffectDisplayType == EDT_RAND);
}

void CMagicHouseView::OnUpdateEffectScan(CCmdUI *pCmdUI)
{
	pCmdUI->SetCheck(m_nEffectDisplayType == EDT_SCANDOWN);
}

void CMagicHouseView::OnUpdateEffectDscan(CCmdUI *pCmdUI)
{
	pCmdUI->SetCheck(m_nEffectDisplayType == EDT_VSCAN);
}

void CMagicHouseView::OnUpdateEffectMove(CCmdUI *pCmdUI)
{
	pCmdUI->SetCheck(m_nEffectDisplayType == EDT_MOVERIGHT);
}

void CMagicHouseView::OnUpdateEffectBlind(CCmdUI *pCmdUI)
{
	pCmdUI->SetCheck(m_nEffectDisplayType == EDT_VBLIND);
}

void CMagicHouseView::OnUpdateEffectRaster(CCmdUI *pCmdUI)
{
	pCmdUI->SetCheck(m_nEffectDisplayType == EDT_HRASTER);
}

void CMagicHouseView::OnUpdateEffectMosaic(CCmdUI *pCmdUI)
{
	pCmdUI->SetCheck(m_nEffectDisplayType == EDT_MOSAIC);
}

void CMagicHouseView::OnUpdateEffectHsmove(CCmdUI *pCmdUI)
{
	pCmdUI->SetCheck(m_nEffectDisplayType == EDT_HSMOVE);
}

void CMagicHouseView::OnUpdateEffectSblind(CCmdUI *pCmdUI)
{
	pCmdUI->SetCheck(m_nEffectDisplayType == EDT_HBLIND);
}

void CMagicHouseView::OnUpdateEffectVraster(CCmdUI *pCmdUI)
{
	pCmdUI->SetCheck(m_nEffectDisplayType == EDT_VRASTER);
}

void CMagicHouseView::OnUpdateEffectRaindrop(CCmdUI *pCmdUI)
{
	pCmdUI->SetCheck(m_nEffectDisplayType == EDT_RAINDROP);
}

void CMagicHouseView::OnModeBrowse()
{
	if (!m_bIsEditMode)
		return;

	FreeImageBuffer();
	m_bIsEditMode = false;
}

void CMagicHouseView::OnModeEdit()
{
	if (m_bIsEditMode)
		return;

	m_bIsEditMode = true;

	if (m_nPos != -1)
	{
		CString strPath = GetFilePath(m_nPos);
		GetImageBuffer(strPath);
	}
}

/******************************************************************************
*	作用:			将指定路径的图像信息提取到数组中
*	参数:			
*		strPath		图像文件地址
******************************************************************************/
bool CMagicHouseView::GetImageBuffer(CString& strPath)
{
	CString fileNameExt = strPath.Right(3);
	string filePath = (LPCSTR)CStringA(strPath);

	if (fileNameExt == "jpg" || fileNameExt == "JPG")
	{
		FILE *fp;

		fp = fopen(filePath.c_str(), "rb");

		JpegDecoder dec(fp);
		fclose(fp);

		m_nPicWidth = m_nTempWidth = dec.GetWidth();
		m_nPicHeight = m_nTempHeight = dec.GetHeight();
		dec.GetJPEGBuffer(m_nPicWidth, m_nPicHeight,&m_pImageBuffer);
		int sizeb = m_nPicWidth * m_nPicHeight * 4;

		m_pImageTempBuffer = (BYTE*)malloc(sizeb);
		memcpy(m_pImageTempBuffer, m_pImageBuffer, sizeb);
	}

	if (fileNameExt == "bmp" || fileNameExt == "BMP")
	{
		MyDib* dib = new MyDib(strPath);

		int b = dib->GetBitsPerPixel();

		m_nPicWidth = m_nTempWidth = dib->GetWidth();
		m_nPicHeight = m_nTempHeight = dib->GetHeight();
		int sizeofbuffer = m_nPicWidth * m_nPicHeight * 4;
		m_pImageTempBuffer = (BYTE *)malloc(sizeofbuffer);

		m_pImageBuffer = (BYTE *)malloc(dib->GetBodySize());
		memcpy(m_pImageBuffer, dib->GetBits(), dib->GetBodySize());	

		SAFE_DELETE (dib);

		if ( b != 24 && b != 32 && b != 8 ) 
		{
			free(m_pImageTempBuffer);
			free(m_pImageBuffer);
			MessageBox(L"本程序仅能处理24位与32位彩色图和8位灰度图!");
			return false;
		}

		if (b == 32) 
		{
			for(unsigned int i = 0; i < m_nPicWidth * 4; i += 4) 
			{
				for (unsigned int j = 0; j < m_nPicHeight / 2; j++) 
				{
					swap(m_pImageBuffer[j*m_nPicWidth*4+i], m_pImageBuffer[(m_nPicHeight-j-1)*m_nPicWidth*4+i]);
					swap(m_pImageBuffer[j*m_nPicWidth*4+i+1], m_pImageBuffer[(m_nPicHeight-j-1)*m_nPicWidth*4+i+1]);
					swap(m_pImageBuffer[j*m_nPicWidth*4+i+2], m_pImageBuffer[(m_nPicHeight-j-1)*m_nPicWidth*4+i+2]);
					swap(m_pImageBuffer[j*m_nPicWidth*4+i+3], m_pImageBuffer[(m_nPicHeight-j-1)*m_nPicWidth*4+i+3]);
				}
			}
			memcpy(m_pImageTempBuffer, m_pImageBuffer, sizeofbuffer);
		}

		if (b == 24) 
		{
			int externWidth;
			externWidth = m_nPicWidth * 3;
			if(externWidth % 4 != 0)
				externWidth = 4 - externWidth % 4;
			else
				externWidth = 0;

			int k = 0;

			for (int n = m_nPicHeight - 1; n >= 0; n--) 
			{
				for (UINT m = 0; m < m_nPicWidth * 3; m += 3) 
				{
					m_pImageTempBuffer[k]   = m_pImageBuffer[n*(m_nPicWidth*3+externWidth)+m];	//blue
					m_pImageTempBuffer[k+1] = m_pImageBuffer[n*(m_nPicWidth*3+externWidth)+m+1];//green
					m_pImageTempBuffer[k+2] = m_pImageBuffer[n*(m_nPicWidth*3+externWidth)+m+2];//red
					m_pImageTempBuffer[k+3] = 255;
					k += 4;
				}
			}

			free(m_pImageBuffer);
			m_pImageBuffer = (BYTE *)malloc(sizeofbuffer);
			memcpy(m_pImageBuffer, m_pImageTempBuffer, sizeofbuffer);
		}

		if (b==8) {

			int externWidth;
			externWidth = m_nPicWidth;
			if(externWidth%4!=0)
				externWidth=4-externWidth%4;
			else
				externWidth=0;

			int k = 0;

			for (int n=m_nPicHeight-1; n>=0; n--) {
				for (UINT m=0; m<m_nPicWidth; m+=1) {

					m_pImageTempBuffer[k]  =m_pImageBuffer[n*(m_nPicWidth+externWidth)+m];//blue
					m_pImageTempBuffer[k+1]=m_pImageBuffer[n*(m_nPicWidth+externWidth)+m];//green
					m_pImageTempBuffer[k+2]=m_pImageBuffer[n*(m_nPicWidth+externWidth)+m];//red
					m_pImageTempBuffer[k+3]=0;
					k+=4;
				}
			}

			free(m_pImageBuffer);
			m_pImageBuffer = (BYTE*)malloc(sizeofbuffer);
			memcpy(m_pImageBuffer, m_pImageTempBuffer, sizeofbuffer);
		}
	}

	return true;
}

/******************************************************************************
*	作用:		释放图像信息占用的内存
******************************************************************************/
void CMagicHouseView::FreeImageBuffer(void)
{
	if (m_pImageBuffer != NULL)
	{
		free(m_pImageBuffer);
		m_pImageBuffer = NULL;
	}

	if (m_pImageTempBuffer != NULL)
	{
		free(m_pImageTempBuffer);
		m_pImageTempBuffer = NULL;
	}
}

/******************************************************************************
*	作用:		"保存"的命令相应函数
******************************************************************************/
void CMagicHouseView::OnFileSave()
{
	if (m_nPos == -1) 
	{
		MessageBox(L"工作区中未加载图片文件!", L"Magic House", MB_ICONWARNING);
		return;
	}
	if (m_pImageTempBuffer == NULL) 
	{
		MessageBox(L"没有可以保存的文件!", L"Magic House", MB_ICONWARNING);
		return;
	}
	CFileDialog SaveDlg( FALSE, L"bmp", L"未命名", OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT | OFN_NOCHANGEDIR, L"图像文件格式(*.bmp) |*.bmp||", NULL);
	if(SaveDlg.DoModal() == IDOK)
	{
		CString tempname = SaveDlg.GetPathName();
		string savePath = (LPCSTR)CStringA(tempname);
		WriteBufferToBMP(m_pImageTempBuffer, m_nTempWidth, m_nTempHeight, savePath.c_str());
		tempname.ReleaseBuffer();
		MessageBox(L"文件已成功保存!");
	}
}

/******************************************************************************
*	作用:			将图像信息写入bmp文件中
*	参数:		
*		im_buffer	图像信息
*		X_bitmap	宽度
*		Y_bitmap	高度
*		BMPname		保存bmp文件路径
******************************************************************************/
void CMagicHouseView::WriteBufferToBMP(BYTE *im_buffer, WORD X_bitmap, WORD Y_bitmap, const char* BMPname)
{
	SWORD x,y;
	RGB *pixel;
	BM_header BH;
	FILE *fp_bitmap;
	DWORD im_loc_bytes;
	BYTE nr_fillingbytes, i;
	BYTE zero_byte=0;

	fp_bitmap=fopen(BMPname,"wb");
	if (fp_bitmap==NULL) 
	{
			AfxMessageBox(L"错误! 文件无法创建.", MB_ICONWARNING);
			return;
	}

	if (X_bitmap%4!=0) nr_fillingbytes=4-((X_bitmap*3L)%4);
	else nr_fillingbytes=0;

	BH.BMP_id = 'M'*256+'B';     fwrite(&BH.BMP_id,2,1,fp_bitmap);
	BH.size=54+Y_bitmap*(X_bitmap*3+nr_fillingbytes);fwrite(&BH.size,4,1,fp_bitmap);
	BH.zero_res = 0;             fwrite(&BH.zero_res,4,1,fp_bitmap);
	BH.offbits = 54;             fwrite(&BH.offbits,4,1,fp_bitmap);
	BH.biSize = 0x28;            fwrite(&BH.biSize,4,1,fp_bitmap);
	BH.Width = X_bitmap;	      fwrite(&BH.Width,4,1,fp_bitmap);
	BH.Height = Y_bitmap;	      fwrite(&BH.Height,4,1,fp_bitmap);
	BH.biPlanes = 1;             fwrite(&BH.biPlanes,2,1,fp_bitmap);
	BH.biBitCount = 24;          fwrite(&BH.biBitCount,2,1,fp_bitmap);
	BH.biCompression = 0;        fwrite(&BH.biCompression,4,1,fp_bitmap);
	BH.biSizeImage = 0;          fwrite(&BH.biSizeImage,4,1,fp_bitmap);
	BH.biXPelsPerMeter = 0xB40;  fwrite(&BH.biXPelsPerMeter,4,1,fp_bitmap);
	BH.biYPelsPerMeter = 0xB40;  fwrite(&BH.biYPelsPerMeter,4,1,fp_bitmap);
	BH.biClrUsed = 0;	          fwrite(&BH.biClrUsed,4,1,fp_bitmap);
	BH.biClrImportant = 0;	      fwrite(&BH.biClrImportant,4,1,fp_bitmap);

	im_loc_bytes=(DWORD)im_buffer+((DWORD)Y_bitmap-1)*X_bitmap*4;

	for (y=0;y<Y_bitmap;y++)
	{
		for (x=0;x<X_bitmap;x++)
		{
			pixel=(RGB *)im_loc_bytes;
			fwrite(pixel, 3, 1, fp_bitmap);
			im_loc_bytes+=4;
		}
		for (i=0;i<nr_fillingbytes;i++)
			fwrite(&zero_byte,1,1,fp_bitmap);
		im_loc_bytes-=2L*X_bitmap*4;
	}
	fclose(fp_bitmap);
}
void CMagicHouseView::OnUpdateModeBrowse(CCmdUI *pCmdUI)
{
	pCmdUI->SetCheck(!m_bIsEditMode);
}

void CMagicHouseView::OnUpdateModeEdit(CCmdUI *pCmdUI)
{
	pCmdUI->SetCheck(m_bIsEditMode);
}

void CMagicHouseView::ResetImage()
{
	m_nTempWidth = m_nPicWidth;
	m_nTempHeight = m_nPicHeight;

	int sizeofbuffer = m_nTempWidth * m_nTempHeight * 4;
	SAFE_DELETE (m_pImageTempBuffer);

	m_pImageTempBuffer = new BYTE[sizeofbuffer];
	memcpy(m_pImageTempBuffer, m_pImageBuffer, sizeofbuffer);
}