// ShowPic22.cpp : implementation file
//

#include "stdafx.h"
#include "ylgl.h"
#include "ShowPic22.h"
#include "MyLock.h"
#include "ShowEffect.h"
#include "CutPhoto.h"
#define   PCL_R(p)   (((RGBQUAD*)(p))->rgbRed)
#define   PCL_G(p)   (((RGBQUAD*)(p))->rgbGreen)
#define   PCL_B(p)   (((RGBQUAD*)(p))->rgbBlue)
#define   PCL_A(p)   (((RGBQUAD*)(p))->rgbReserved)

/////////////////////////////////////////////////////////////////////////////
HANDLE Lock(char* name)
{
	try
	{
		HANDLE mutex;
		// Try to open an exist mutex firstly.
		mutex = OpenMutex(MUTEX_ALL_ACCESS, FALSE, name);
		if (NULL == mutex)     // If the mutex does not exist, create it with the certain name.
		{
			mutex = CreateMutex(NULL, TRUE, name);
		}
		else // If the mutex already exist, wait for other thread release it.
		{
			WaitForSingleObject(mutex, INFINITE);
		}
		return mutex;
	}
	catch (...)
	{
	}
}

bool Unlock(HANDLE mutex)
{
	try
	{
		if (0 == ReleaseMutex(mutex))   // Failed to release mutex
		{
			return false;
		}
		else // Successed in release mutex
		{
			CloseHandle(mutex);
			mutex = NULL;
			return true;
		}
	}
	catch (...)
	{
	}
}

ShowPic22::ShowPic22(CWnd* pParent) : CDialog(ShowPic22::IDD, pParent)
{
	m_pImage = NULL;
	m_pImagesmall = NULL;
	m_pImagetemp = NULL;
	m_pbmp = NULL;
	m_pParent = NULL;
	m_bauto = 0;
	m_fscale = 1;
	m_bScroll = 0;
	m_bTerminate = false;
	m_bRunning = false;
	m_hThread = NULL;
	m_bProcessing = 0;
	m_bInit = 0;
	m_bShowName = 0;
	m_bShowEffect = 0;
	m_pPathArray = NULL;
	m_pPathArrayBigsize = NULL;
	m_bChooseBig = 0;
}

void ShowPic22::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_STATIC1, m_sta1);
}

BEGIN_MESSAGE_MAP(ShowPic22, CDialog)
	ON_WM_PAINT()
	ON_WM_DESTROY()
	ON_WM_LBUTTONDOWN()
	ON_WM_LBUTTONUP()
	ON_WM_MOUSEWHEEL()
	ON_WM_ERASEBKGND()
	ON_WM_RBUTTONDOWN()
	ON_WM_TIMER()
	ON_WM_CLOSE()
	ON_WM_MOUSEMOVE()
	ON_WM_CTLCOLOR()
	ON_MESSAGE(WM_USER + 200, ShowInfo2)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
BOOL ShowPic22::OnEraseBkgnd(CDC* pDC)
{
	return 1;
}

unsigned __stdcall GenThumbImgThread(LPVOID lpParam)
{
	try
	{
		ShowPic22 *pThis = (ShowPic22*)lpParam;
		int posbak = pThis->m_pos;	// m_pos 选片时选中的相片列编号,即要查看的相片;
		
		// 以下4个变量用途何为?
		int pos;
		BOOL bNext = 1;		// 图片位置与posbak一致时保持不变;
		BOOL bFirst = 1;	// 记录第一次运行的什么情况?
		int count;			// 用于记录什么的数量?

		while (1)
		{
			// 对话框销毁,线程退出;
			if (pThis->m_bTerminate)break;

			// 播放幻灯或未初始化时,线程进入睡眠，让出CPU周期;
			if (pThis->m_bauto || (pThis->m_bInit == 0 && bFirst == 0))
			{
				::Sleep(1000);
				continue;
			}


			if (bFirst)
				count = 2;
			else
				count = 5;
			bFirst = 0;
			for (int i = 0; i < count; i++)
			{
				if (pThis->m_bTerminate)break;
				if (pThis->m_bauto)break;
				if (posbak != pThis->m_pos)
				{
					if (pThis->m_pos > posbak)
						bNext = 1;
					else
						bNext = 0;
					posbak = pThis->m_pos;
					i = 0; 
					continue;
				}
				if (bNext)
				{
					switch (i)
					{
					case 0:
						pos = posbak;
						break;
					case 1:
						pos = posbak + 1;
						break;
					case 2:
						pos = posbak + 2;
						break;
					case 3:
						pos = posbak - 1;
						break;
					case 4:
						pos = posbak + 3;
						break;
					}
				}
				else
				{
					switch (i)
					{
					case 0:
						pos = posbak;
						break;
					case 1:
						pos = posbak - 1;
						break;
					case 2:
						pos = posbak - 2;
						break;
					case 3:
						pos = posbak + 1;
						break;
					case 4:
						pos = posbak - 3;
						break;
					}
				}

				HANDLE handle = Lock("shgenimagethread");
				while (pos >= pThis->m_pPathArray->GetSize())
					pos -= pThis->m_pPathArray->GetSize();
				while (pos < 0)
					pos += pThis->m_pPathArray->GetSize();

				// 第一次运行时,m_nPosArray为空;
				BOOL bFind = 0;
				for (int n = 0; n < pThis->m_nPosArray.GetSize(); n++)
				{
					if (pos == pThis->m_nPosArray.ElementAt(n))
					{
						bFind = 1;
						break;
					}
				}
				if (bFind)
				{
					Unlock(handle);
					continue;
				}

				// 获取"m"图路径,m_pPathArray->ElementAt(pos);
				CString path = pThis->m_pPathArray->ElementAt(pos);
				if (pThis->m_bChooseBig  && pThis->m_pos == pos)
				{
					path = pThis->m_pPathArrayBigsize->ElementAt(pos);
					pThis->m_bChooseBig = 0;
				}

				// img为"m"图或大图,加载指定名称的图片;
				Image *img = NULL;
				Image *imgsmall = NULL;
				::LoadImageFromBuf(&img, path);
				if (img == NULL)
				{
					Bitmap *pNULLBmp = new Bitmap(100, 100, PixelFormat24bppRGB);
					Graphics graph2(pNULLBmp);
					graph2.Clear(Color(255, 0, 0, 0));
					Bitmap *pNULLBmp2 = new Bitmap(100, 100, PixelFormat24bppRGB);
					Graphics graph3(pNULLBmp2);
					graph3.Clear(Color(255, 0, 0, 0));
					pThis->m_pImageArray.Add(pNULLBmp);
					pThis->m_pImageSmallArray.Add(pNULLBmp2);
					pThis->m_nPosArray.Add(pos);
					Unlock(handle);
					continue;
				}
				if (img->GetWidth() == 0)
				{
					Bitmap *pNULLBmp = new Bitmap(100, 100, PixelFormat24bppRGB);
					Graphics graph2(pNULLBmp);
					graph2.Clear(Color(255, 0, 0, 0));
					Bitmap *pNULLBmp2 = new Bitmap(100, 100, PixelFormat24bppRGB);
					Graphics graph3(pNULLBmp2);
					graph3.Clear(Color(255, 0, 0, 0));
					pThis->m_pImageArray.Add(pNULLBmp);
					pThis->m_pImageSmallArray.Add(pNULLBmp2);
					pThis->m_nPosArray.Add(pos);
					Unlock(handle);
					continue;
				}

				CRect rc;
				pThis->InitRc(img, rc);	//
				imgsmall = img->GetThumbnailImage(rc.Width(), rc.Height(), NULL, NULL);
				Graphics graphic(imgsmall);//防止GetThumbnailImage影响质量
				graphic.DrawImage(img, 0, 0, imgsmall->GetWidth(), imgsmall->GetHeight());
				int orientation = GetOrientation(img);
				if (orientation == 8)
				{
					imgsmall->RotateFlip(Rotate270FlipNone);
					img->RotateFlip(Rotate270FlipNone);
				}
				else if (orientation == 6)
				{
					imgsmall->RotateFlip(Rotate90FlipNone);
					img->RotateFlip(Rotate90FlipNone);
				}
				pThis->m_pImageArray.Add(img);
				pThis->m_pImageSmallArray.Add(imgsmall);
				pThis->m_nPosArray.Add(pos);
				if (pThis->m_pImageArray.GetSize() > 10)
				{
					if (pThis->m_pImage != pThis->m_pImageArray.ElementAt(0))
					{
						delete pThis->m_pImageArray.ElementAt(0);
						delete pThis->m_pImageSmallArray.ElementAt(0);
						pThis->m_pImageArray.RemoveAt(0);
						pThis->m_pImageSmallArray.RemoveAt(0);
						pThis->m_nPosArray.RemoveAt(0);
					}
				}
				Unlock(handle);
			}
			::Sleep(200);
		}
		pThis->m_bRunning = false;
		pThis->m_bTerminate = false;
		_endthreadex(0);
		return 0;
	}
	catch (...)
	{
	}
}

BOOL ShowPic22::OnInitDialog()	// 初始化;
{
	CDialog::OnInitDialog();
	m_bShowName = 1;

	try
	{
		g_nSendCode = 0;
		RunPicThread();
		if (m_bShowName)
			GetDlgItem(IDC_STATIC2)->ShowWindow(SW_SHOW);

		m_rcscreen = CRect(0, 0, g_screenwid, g_screenhei);
		::SetWindowPos(m_hWnd, HWND_TOP, 0, 0, g_screenwid, g_screenhei, SWP_SHOWWINDOW);
		//	m_pbmp=new Bitmap(g_screenwid, g_screenhei, PixelFormat24bppRGB );
		m_pbmp = new Bitmap(g_screenwid, g_screenhei, PixelFormat32bppARGB);
		//	LoadImage();
		if (m_pParent)
			m_pParent->m_showpichwd = m_hWnd;

		m_dlg.Create(IDD_DLGAnimateWindow, this);
		m_dlg.m_pParent = this;
		m_dlg.m_pbmp = m_pbmp;
		m_dlg.m_pRc = &m_rc;
		m_dlg.MoveWindow(m_rcscreen);

		if (m_PicBar.GetSafeHwnd() == NULL)
		{
			if (m_pParent == NULL)
				m_PicBar.m_bShowCut = 0;
			else if (m_pParent->m_Runingmode)
				m_PicBar.m_bShowCut = 0;
			m_PicBar.PreLoad();
			m_PicBar.SetLiaPath("4.lia");
			m_PicBar.Create(IDD_DLGmydlg, this);
		}
		if (m_PreviewDlg.GetSafeHwnd() == NULL)
		{
			m_PreviewDlg.Create(IDD_DIALOG30, this);
			CRect rc;
			rc.top = 50;
			rc.bottom = g_screenhei - 50;
			rc.right = g_screenwid - 10;
			rc.left = rc.right - 100;
			///////////////////////////
			rc.left = g_screenwid - 20;
			rc.right = rc.left + 100;
			///////////////////////////
			m_PreviewDlg.MoveWindow(rc);
			m_PreviewDlg.m_pPathArray = m_pPathArray;
			m_PreviewDlg.InitCtrl();
		}

		//	m_PicBar.SetParent (this);
		if (m_PicBar.m_bInit)
		{
			m_PicBar.m_pParent = this;
			int hei;
			m_PicBar.GetWindowRect(m_picbarrc);
			hei = m_picbarrc.Height();
			m_picbarrc.bottom = g_screenhei - 10;
			m_picbarrc.top = m_picbarrc.bottom - hei;
			m_PicBar.MoveWindow(m_picbarrc);
			m_startpt2.x = m_startpt2.y = 0;
		}

		m_sta1.SetFocus();

		LoadImage();
		m_PreviewDlg.ShowWindow(SW_SHOW);
	}
	catch (...)
	{
	}
	return TRUE;
}

inline void RGBtoHLS(int R, int G, int B, double* H, double* L, double* S)
{
	const int   n_cmax = max(B, max(R, G)),
		n_cmin = min(B, min(R, G));

	*L = (n_cmax + n_cmin) / 2.0 / 255.0;
	if (n_cmax == n_cmin)
	{
		*S = *H = 0.0;
		return;
	}

	const double   r = (double)R / 255.0,
		g = (double)G / 255.0,
		b = (double)B / 255.0,
		cmax = n_cmax / 255.0,
		cmin = n_cmin / 255.0,
		delta = cmax - cmin;

	if (*L < 0.5)
		*S = delta / (cmax + cmin);
	else
		*S = delta / (2.0 - cmax - cmin);

	if (R == n_cmax)
		*H = (g - b) / delta;
	else if (G == n_cmax)
		*H = 2.0 + (b - r) / delta;
	else
		*H = 4.0 + (r - g) / delta;
	*H /= 6.0;
	if (*H < 0.0)
		*H += 1.0;
}

RGBQUAD __DoubleRGB_to_RGB(const double& r, const double& g, const double& b)
{
	RGBQUAD rgb;
	rgb.rgbRed = max(0, min(255, (int)r * 255));
	rgb.rgbGreen = max(0, min(255, (int)g * 255));
	rgb.rgbBlue = max(0, min(255, (int)b * 255));

	return rgb;
}

inline double __HLS_Value(const double& m1, const double& m2, double h)
{
	if (h > 6.0)
		h -= 6.0;
	else if (h < 0.0)
		h += 6.0;

	if (h < 1.0)
		return m1 + (m2 - m1) * h;
	else if (h < 3.0)
		return m2;
	else if (h < 4.0)
		return m1 + (m2 - m1) * (4.0 - h);
	return m1;
}

inline RGBQUAD HLStoRGB(const double& H, const double& L, const double& S)
{
	double     m1, m2;
	if (L < 0.5)
		m2 = L * (1.0 + S);
	else
		m2 = L + S - L*S;
	m1 = 2.0*L - m2;

	return __DoubleRGB_to_RGB(__HLS_Value(m1, m2, H*6.0 + 2.0),
		__HLS_Value(m1, m2, H*6.0),
		__HLS_Value(m1, m2, H*6.0 - 2.0));
}

void Autocontrast(Bitmap *pBmpImage)
{
	return;
	try
	{
		if (pBmpImage == NULL)return;

		BitmapData bitmapData;
		UINT* pixels;
		Rect rc(0, 0, pBmpImage->GetWidth(), pBmpImage->GetHeight());
		pBmpImage->LockBits(
			rc,
			ImageLockModeWrite,
			PixelFormat32bppARGB,
			&bitmapData);
		// Write to the temporary buffer provided by LockBits. RGB
		pixels = (UINT*)bitmapData.Scan0;
		DWORD wids = bitmapData.Stride / 4;
		Color color;
		BYTE R, G, B;
		double		H, L, S;
		int	iPercent = 128 * 110 / 100; // 转换成x/128

		int	iPercentSat = 128 * 120 / 100; // 转换成x/128

		RGBQUAD rgb2; RGBTRIPLE rgb;
		for (INT row = 0; row < rc.Height; ++row)
		{
			for (INT col = 0; col < rc.Width; ++col)
			{
				color.SetValue(pixels[row * wids + col]);
				R = min(255, max(0, 128 + (color.GetR() - 128) * iPercent / 128));
				G = min(255, max(0, 128 + (color.GetG() - 128) * iPercent / 128));
				B = min(255, max(0, 128 + (color.GetB() - 128) * iPercent / 128));

				rgb.rgbtRed = color.GetR();
				rgb.rgbtGreen = color.GetG();
				rgb.rgbtBlue = color.GetB();
				FCColor::RGBtoHLS(&rgb, &H, &L, &S);
				S = S * iPercentSat / 128;
				rgb2 = FCColor::HLStoRGB(H, L, S);
				pixels[row * wids + col] = Color::MakeARGB(255, rgb2.rgbRed, rgb2.rgbGreen, rgb2.rgbBlue);
				// 	  pixels[row * wids + col]=Color::MakeARGB(255, R, G, B );
			}
		}
		pBmpImage->UnlockBits(&bitmapData);
	}
	catch (...)
	{
	}
}

void Autosaturation(Bitmap *pBmpImage)
{
#ifdef HIGH_VERSION
	try
	{
		if(pBmpImage==NULL)return;
		if(g_pMainWnd->m_pToneColorDlg2->m_saturation==100)return;
		BitmapData bitmapData;
		UINT* pixels;
		Rect rc(0, 0, pBmpImage->GetWidth(), pBmpImage->GetHeight() );
		pBmpImage->LockBits(
			rc,
			ImageLockModeWrite,
			PixelFormat32bppARGB ,
			&bitmapData);
		// Write to the temporary buffer provided by LockBits. RGB
		pixels = (UINT*)bitmapData.Scan0;
		DWORD wids=bitmapData.Stride/4;
		Color color;

		double		H, L, S ;
		RGBTRIPLE rgb;
		RGBQUAD rgb2;
		int	iPercentSat = 128 * g_pMainWnd->m_pToneColorDlg2->m_saturation / 100 ; // 转换成x/128
		for(INT  row = 0; row < rc.Height; ++row)
		{
			for(INT col = 0; col < rc.Width; ++col)
			{
				color.SetValue(pixels[row * wids + col]);
				rgb.rgbtRed =color.GetR();
				rgb.rgbtGreen  =color.GetG();
				rgb.rgbtBlue =color.GetB();
				FCColor::RGBtoHLS (&rgb, &H, &L, &S) ;
				S = S * iPercentSat / 128 ;
				rgb2 = FCColor::HLStoRGB (H, L, S) ;
				pixels[row * wids + col]=Color::MakeARGB(color.GetA(), rgb2.rgbRed, rgb2.rgbGreen, rgb2.rgbBlue );
			}
		}
		pBmpImage->UnlockBits(&bitmapData);
	}
	catch(...)
	{
	}
#endif
}

void ShowPic22::OnPaint()
{
	CPaintDC dc(this);
	try
	{
		CRect rc;
		GetClientRect(rc);
		if (m_pImage && m_bauto == 0)
		{
			Graphics graph(m_pbmp);
			graph.Clear(Color(255, 0, 0, 0));

			Image *img;
			if (m_pImagetemp && m_bScroll == 0)
				img = m_pImagetemp;
			else
				img = m_pImagesmall;

			m_bScroll = 0;
			int width, height;
			width = img->GetWidth();
			height = img->GetHeight();
			///////////////
			Rect destinationRect(m_rc.left, m_rc.top, m_rc.Width(), m_rc.Height());
			//	graph.SetInterpolationMode(InterpolationModeHighQualityBicubic); 
			graph.DrawImage(img, destinationRect, 0, 0, width, height, UnitPixel);

			Graphics graph2(dc.GetSafeHdc());
			Autocontrast(m_pbmp);
			graph2.DrawImage(m_pbmp, 0, 0);
		}
		else
		{
			//	dc.FillSolidRect (rc, 0);
		}
	}
	catch (...)
	{
	}
}

void ShowPic22::OnDestroy()
{
	try
	{
		g_nSendCode = 0;
		for (int n = 0; n < m_nPosArray.GetSize(); n++)
		{
			m_pImage = m_pImageArray.ElementAt(n);
			m_pImagesmall = m_pImageSmallArray.ElementAt(n);
			delete m_pImage;
			delete m_pImagesmall;
		}

		if (m_pImagetemp) delete m_pImagetemp; m_pImagetemp = NULL;
		if (m_pbmp) delete m_pbmp; m_pbmp = NULL;
		KillTimer(1);
	}
	catch (...)
	{
	}
	CDialog::OnDestroy();
}

void ShowPic22::LoadImage()
{
	try
	{
		::SetForegroundWindow(m_hWnd);
		KillTimer(5);
		if (m_pPathArray->GetSize() == 0)return;//2011-03-09
		m_pImage = m_pImagesmall = NULL;

		for (int n = 0; n < m_nPosArray.GetSize(); n++)
		{
			if (m_pos == m_nPosArray.ElementAt(n))
			{
				m_pImage = m_pImageArray.ElementAt(n);
				m_pImagesmall = m_pImageSmallArray.ElementAt(n);
				break;
			}
		}

		if (m_pImage == NULL && (m_bauto || m_bInit == 0))
		{
			HANDLE handle = Lock("shgenimagethread");
			CString path = m_pPathArray->ElementAt(m_pos);
			if (m_bChooseBig)
			{
				path = m_pPathArrayBigsize->ElementAt(m_pos);
			}
			::LoadImageFromBuf(&m_pImage, path);
			if (m_pImage == NULL)
			{
				Bitmap *pNULLBmp = new Bitmap(100, 100, PixelFormat24bppRGB);
				Graphics graph2(pNULLBmp);
				graph2.Clear(Color(255, 0, 0, 0));
				m_pImage = pNULLBmp;
			}
			if (m_pImage->GetWidth() == 0)
			{
				m_bChooseBig = 0;
				Unlock(handle);
				return;
			}
			InitRc();
			m_pImagesmall = m_pImage->GetThumbnailImage(m_rc.Width(), m_rc.Height(), NULL, NULL);
			Graphics graphic(m_pImagesmall);//防止GetThumbnailImage影响质量
			graphic.DrawImage(m_pImage, 0, 0, m_pImagesmall->GetWidth(), m_pImagesmall->GetHeight());

			int orientation = GetOrientation(m_pImage);
			if (orientation == 8)
			{
				m_pImage->RotateFlip(Rotate270FlipNone);
				m_pImagesmall->RotateFlip(Rotate270FlipNone);
			}
			else if (orientation == 6)
			{
				m_pImage->RotateFlip(Rotate90FlipNone);
				m_pImagesmall->RotateFlip(Rotate90FlipNone);
			}

			m_pImageArray.Add(m_pImage);
			m_pImageSmallArray.Add(m_pImagesmall);
			m_nPosArray.Add(m_pos);
			if (m_pImageArray.GetSize() > 10)
			{
				if (m_pImage != m_pImageArray.ElementAt(0))
				{
					delete m_pImageArray.ElementAt(0);
					delete m_pImageSmallArray.ElementAt(0);
					m_pImageArray.RemoveAt(0);
					m_pImageSmallArray.RemoveAt(0);
					m_nPosArray.RemoveAt(0);
				}
			}

			m_bChooseBig = 0;
			Unlock(handle);
		}
		else if (m_pImage == NULL)
		{
			SetTimer(5, 1, NULL);
			return;
		}

		if (m_pImagetemp)
			delete m_pImagetemp;
		m_pImagetemp = NULL;

		InitRc();
		if (m_bauto)
		{
			if (m_dlg.m_effect == 1 || m_dlg.m_effect == 2)
			{
				CDC *pDC = GetDC();
				HDC hdc = ::GetDC(NULL);
				::BitBlt(pDC->GetSafeHdc(), 0, 0, g_screenwid, g_screenhei, hdc, 0, 0, SRCCOPY);
				ReleaseDC(pDC);
			}

			m_dlg.m_time = m_PicBar.m_time * 1000;
			m_dlg.SetImage(m_pImagesmall);
			if (m_dlg.m_effect == 1 || m_dlg.m_effect == 2)
			{
				m_dlg.ShowWindow(SW_HIDE);
			}
			m_dlg.ShowAlpha();
		}
		else
		{
			ShowInfo();
			Invalidate();
		}
	}
	catch (...)
	{
	}
}

void ShowPic22::OnLButtonDown(UINT nFlags, CPoint point)
{
	SetCapture();
	m_startpt = m_startpt3 = point;
	CDialog::OnLButtonDown(nFlags, point);
}

void ShowPic22::OnMouseMove(UINT nFlags, CPoint point)
{
	if (GetCapture() != this)return;
	if (m_rc.Width() > m_rcscreen.Width())
	{
		if (m_rc.left <m_rcscreen.left && point.x>m_startpt.x)
		{
			int dt = min(point.x - m_startpt.x, m_rcscreen.left - m_rc.left);
			m_rc.left += dt;
			m_rc.right += dt;
		}
		else if (m_rc.right > m_rcscreen.right && point.x < m_startpt.x)
		{
			int dt = min(m_startpt.x - point.x, m_rc.right - m_rcscreen.right);
			m_rc.left -= dt;
			m_rc.right -= dt;
		}m_startpt3 = point;
	}

	if (m_rc.Height() > m_rcscreen.Height())
	{
		if (m_rc.top <m_rcscreen.top && point.y>m_startpt.y)
		{
			int dt = min(point.y - m_startpt.y, m_rcscreen.top - m_rc.top);
			m_rc.top += dt;
			m_rc.bottom += dt;
		}
		else if (m_rc.bottom > m_rcscreen.bottom && point.y < m_startpt.y)
		{
			int dt = min(m_startpt.y - point.y, m_rc.bottom - m_rcscreen.bottom);
			m_rc.top -= dt;
			m_rc.bottom -= dt;
		}m_startpt3 = point;
	}

	m_startpt = point;
	Invalidate();
	CDialog::OnMouseMove(nFlags, point);
}

void ShowPic22::OnLButtonUp(UINT nFlags, CPoint point)
{
	if (GetCapture() != this)return;
	ReleaseCapture();
	if (point.x - m_startpt3.x > 30)
		Next();
	else if (m_startpt3.x - point.x > 30)
		Pre();

	CDialog::OnLButtonUp(nFlags, point);
}

BOOL ShowPic22::OnMouseWheel(UINT nFlags, short zDelta, CPoint pt)
{
	if (m_pImage == NULL)return 1;
	if (m_bauto)return 1; if (m_bProcessing)return 1;
	m_bScroll = 1;
	if (zDelta > 0)
	{
		//	if(m_fscale>4)return 1;
		m_fscale *= 1.2;
		int dtx = (m_fscale*m_rcbak.Width() - m_rc.Width()) / 2.0;
		int dty = (m_fscale*m_rcbak.Height() - m_rc.Height()) / 2.0;

		m_rc.left -= dtx;
		m_rc.right += dtx;
		m_rc.top -= dty;
		m_rc.bottom += dty;

		Invalidate();
	}
	else
	{
		if (m_fscale <= 1)return 1;
		m_fscale /= 1.2;
		if (m_fscale < 1)m_fscale = 1;
		int dtx = (m_fscale*m_rcbak.Width() - m_rc.Width()) / 2.0;
		int dty = (m_fscale*m_rcbak.Height() - m_rc.Height()) / 2.0;

		m_rc.left -= dtx;
		m_rc.right += dtx;
		m_rc.top -= dty;
		m_rc.bottom += dty;

		if (m_rcbak.Height() == m_rcscreen.Height())
		{
			if (m_rc.top < m_rcscreen.top && m_rc.bottom < m_rcscreen.bottom)
			{
				dtx = m_rcscreen.bottom - m_rc.bottom;
				m_rc.top += dtx;
				m_rc.bottom += dtx;
			}
			else if (m_rc.top >m_rcscreen.top && m_rc.bottom > m_rcscreen.bottom)
			{
				dtx = m_rc.top - m_rcscreen.top;
				m_rc.top -= dtx;
				m_rc.bottom -= dtx;
			}

			dtx = m_rc.Width();
			m_rc.left = (m_rcscreen.Width() - dtx) / 2;
			m_rc.right = m_rc.left + dtx;
		}

		if (m_rcbak.Width() == m_rcscreen.Width())
		{
			if (m_rc.left < m_rcscreen.left && m_rc.right < m_rcscreen.right)
			{
				dtx = m_rcscreen.right - m_rc.right;
				m_rc.left += dtx;
				m_rc.right += dtx;
			}
			else if (m_rc.left >m_rcscreen.left && m_rc.right > m_rcscreen.right)
			{
				dtx = m_rc.left - m_rcscreen.left;
				m_rc.left -= dtx;
				m_rc.right -= dtx;
			}

			dtx = m_rc.Height();
			m_rc.top = (m_rcscreen.Height() - dtx) / 2;
			m_rc.bottom = m_rc.top + dtx;
		}

		Invalidate();

		/*	int dtx=(m_fscale-1)*m_rcbak.Width ()/2.0;
		int dty=(m_fscale-1)*m_rcbak.Height ()/2.0;
		m_rc=m_rcbak;
		m_rc.left -=dtx;
		m_rc.right +=dtx;
		m_rc.top -=dty;
		m_rc.bottom +=dty;
		Invalidate();*/
	}
	KillTimer(2);
	SetTimer(2, 100, NULL);
	return CDialog::OnMouseWheel(nFlags, zDelta, pt);
}

BOOL ShowPic22::PreTranslateMessage(MSG* pMsg)	// 键盘和按钮响应事件;
{
	if (pMsg->message == WM_MOUSEMOVE)
	{
		if (m_bShowEffect)return 1;
		if (m_PicBar.m_bInit && m_pImage)
		{
			CPoint point;
			::GetCursorPos(&point);
			if (abs(m_startpt2.x - point.x) > 5 || abs(m_startpt2.y - point.y) > 5)
			{
				m_startpt2 = point;
				m_PicBar.ShowWindow(SW_SHOW);
				SetTimer(3, 1500, NULL);
			}
		}
	}
	else if (pMsg->message == WM_KEYDOWN)
	{
		if (m_bShowEffect)return 1;
		switch (pMsg->wParam)
		{
		case VK_RETURN:
			return 1;
		case VK_ESCAPE:
			KillTimer(6);
			SetTimer(6, 100, NULL);
			return 1;
		case VK_F2:
			return 1;
			if (m_pParent == NULL)return 1;
			if (m_pParent->m_Runingmode)return 1;
			if (m_bShowEffect)return 1;
			if (m_bauto)
			{
				m_bauto = 0;
				KillTimer(1);
				m_dlg.TerminateThread();
				m_dlg.ShowWindow(SW_HIDE);
			}
			if (m_pImage)
			{
				m_bShowEffect = 1;
				CutPhoto2();
				//	ShowEffectDlg dlg;
				//	dlg.DoModal();
				m_bShowEffect = 0;
			}
			return 1;
		case VK_F3:
			AutoPic();
			break;
		case VK_UP:
			Rotate1();
			return 1;
		case VK_PRIOR:
		case VK_LEFT:
			Pre();
			return 1;
		case VK_DOWN:
			Rotate2();
			return 1;
		case VK_RIGHT:
		case VK_NEXT:
			Next();
			return 1;
		case VK_SHIFT:
		{
			if (m_bauto)return 1; if (m_bProcessing)return 1;
			if (m_pPathArrayBigsize && m_bChooseBig == 0)
			{
				HANDLE handle = Lock("shgenimagethread");
				for (int n = 0; n < m_nPosArray.GetSize(); n++)
				{
					if (m_pos == m_nPosArray.ElementAt(n))
					{
						delete m_pImageArray.ElementAt(n);
						delete m_pImageSmallArray.ElementAt(n);
						m_pImageArray.RemoveAt(n);
						m_pImageSmallArray.RemoveAt(n);
						m_nPosArray.RemoveAt(n);
						break;
					}
				}
				Unlock(handle);
				m_bChooseBig = 1;
				LoadImage();
			}
		}
			return 1;
		case VK_DELETE:
			if (m_bauto)return 1;
			if (m_pParent)
			{
				if (m_bProcessing)return 1;
				m_bProcessing = 1;
				::SetForegroundWindow(m_hWnd);
				if (m_pParent)
				{
					for (int i = 0; i < m_pParent->m_List1.GetItemCount(); i++)
					{
						m_pParent->m_List1.SetItemState(i, 0, -1);
					}
					m_pParent->m_List1.SetItemState(m_pos, LVIS_SELECTED, LVIS_SELECTED);
				}

				//	HANDLE handle=Lock("shgenimagethread");
				if (m_pParent->OnDel())
				{
					TerminateThread();
					::SetForegroundWindow(m_hWnd);

					m_pImage = m_pImagesmall = NULL;
					for (int n = m_nPosArray.GetSize() - 1; n >= 0; n--)
					{
						//if(m_pos==m_nPosArray.ElementAt (n))
						{
							delete m_pImageArray.ElementAt(n);
							delete m_pImageSmallArray.ElementAt(n);
							m_pImageArray.RemoveAt(n);
							m_pImageSmallArray.RemoveAt(n);
							m_nPosArray.RemoveAt(n);
						}
					}

					if (m_pPathArrayBigsize)
					{
						m_pPathArrayBigsize->RemoveAll();
						m_pPathArray->RemoveAll();
						CStringArray *pArray = m_pParent->GetCurArray();
						m_pPathArrayBigsize->Copy(*pArray);
						for (int i = 0; i < m_pPathArrayBigsize->GetSize(); i++)
						{
							CString str = m_pPathArrayBigsize->ElementAt(i);
							CString spath = str.Left(str.ReverseFind('\\') + 1);
							spath += "m";
							spath += str.Right(str.GetLength() - str.ReverseFind('\\') - 1);
							if (::PathFileExists(spath))
								m_pPathArray->Add(spath);
							else
								m_pPathArray->Add(str);
						}
					}

					if (m_pos >= this->m_pPathArray->GetSize())
						m_pos = 0;
					//	Unlock(handle);
					RunPicThread();
					LoadImage();
					m_pParent->m_List1.SetItemState(m_pos, LVIS_SELECTED, LVIS_SELECTED);
				}
				m_bProcessing = 0;
				return 1;
			}
		}
		::SetForegroundWindow(m_hWnd);
	}
	return CDialog::PreTranslateMessage(pMsg);
}

//---------------------------------------------------------------
// Remark by Jeff 2014.11.05
// 函数：OnRButtonDown
// 描述：鼠标右键
// 参数：
//		nFlags：表示各种虚拟按键是否下降
//		point：	指定x和光标的y坐标
// 返回：无
//---------------------------------------------------------------
void ShowPic22::OnRButtonDown(UINT nFlags, CPoint point)	// 鼠标右键;
{
	if (m_bauto)return;
	if (m_bProcessing)return;
	if (m_pParent)
	{
		for (int i = 0; i < m_pParent->m_List1.GetItemCount(); i++)
		{
			m_pParent->m_List1.SetItemState(i, 0, -1);
		}
		m_pParent->m_List1.SetItemState(m_pos, LVIS_SELECTED, LVIS_SELECTED);
		m_pParent->OnRclickList1();
	}
	CDialog::OnRButtonDown(nFlags, point);
}

//---------------------------------------------------------------
// Remark by Jeff 2014.11.05
// 函数：AutoPic
// 描述：播放幻灯片按钮
// 参数：无
// 返回：无
//---------------------------------------------------------------
void ShowPic22::AutoPic()	// 自动播放幻灯片按钮;
{
	try
	{
		if (m_bProcessing)return;
		m_dlg.m_effect = m_PicBar.m_nType;
		m_bauto = !m_bauto;
		m_PicBar.ChangeBtn();
		if (m_bauto)
		{
			m_PreviewDlg.ShowMin();
			if (m_pos >= this->m_pPathArray->GetSize())
				m_pos = 0;
			LoadImage();
		}
		else
		{
			KillTimer(1);
			m_dlg.TerminateThread();
			m_dlg.ShowWindow(SW_HIDE);
		}
		::SetForegroundWindow(m_hWnd);
	}
	catch (...)
	{
	}
}

void ShowPic22::OnTimer(UINT nIDEvent)
{
	try
	{
		if (m_bShowEffect)return;
		::SetForegroundWindow(m_hWnd);
		if (nIDEvent == 1)
		{
			KillTimer(1);
			m_pos++;
			if (m_pos >= this->m_pPathArray->GetSize())
			{
				KillTimer(1);

				m_dlg.TerminateThread();
				m_dlg.ShowWindow(SW_HIDE);
				m_PicBar.ChangeBtn();
				AfxMessageBox("您的照片已浏览完毕!", MB_ICONINFORMATION);
				m_bauto = 0;		
				m_bProcessing = 0;
				m_pos -= 2; 
				Next();
				return;
			}
			LoadImage();
		}
		else if (nIDEvent == 2)
		{
			KillTimer(2);
			if (m_pImagetemp)
			{
				if (m_rc.Width() > m_pImagetemp->GetWidth())
				{
					if (m_pImagetemp) delete m_pImagetemp; m_pImagetemp = NULL;
					m_pImagetemp = m_pImage->GetThumbnailImage(min(m_pImage->GetWidth(), m_rc.Width()), min(m_pImage->GetHeight(), m_rc.Height()), NULL, NULL);

					Graphics graphic(m_pImagetemp);//防止GetThumbnailImage影响质量
					graphic.DrawImage(m_pImage, 0, 0, m_pImagetemp->GetWidth(), m_pImagetemp->GetHeight());
				}
			}
			else
			{
				m_pImagetemp = m_pImage->GetThumbnailImage(min(m_pImage->GetWidth(), m_rc.Width()), min(m_pImage->GetHeight(), m_rc.Height()), NULL, NULL);
				Graphics graphic(m_pImagetemp);//防止GetThumbnailImage影响质量
				graphic.DrawImage(m_pImage, 0, 0, m_pImagetemp->GetWidth(), m_pImagetemp->GetHeight());
			}
			Invalidate();
		}
		else if (nIDEvent == 3)
		{
			KillTimer(3);
			CPoint pt;
			::GetCursorPos(&pt);
			if (m_picbarrc.PtInRect(pt))
			{
				SetTimer(3, 1500, NULL);
			}
			else
				m_PicBar.ShowWindow(SW_HIDE);
			::SetForegroundWindow(m_hWnd);
		}
		else if (nIDEvent == 4)
		{
			KillTimer(4);
			m_PicBar.SetLiaPath("4.lia");

			m_PicBar.Create(IDD_DLGmydlg, this);

			if (m_PicBar.m_bInit)
			{
				m_PicBar.m_pParent = this;
				int hei;
				m_PicBar.GetWindowRect(m_picbarrc);
				hei = m_picbarrc.Height();
				m_picbarrc.bottom = g_screenhei - 10;
				m_picbarrc.top = m_picbarrc.bottom - hei;
				m_PicBar.MoveWindow(m_picbarrc);
				SetTimer(3, 1500, NULL);
				m_startpt2.x = m_startpt2.y = 0;
			}
			::SetForegroundWindow(m_hWnd);
		}
		else if (nIDEvent == 5)
		{
			KillTimer(5);
			LoadImage();
		}
		else if (nIDEvent == 6)
		{
			if (m_bProcessing)return;
			m_bProcessing = 1;
			g_nSendCode = 0;
			TerminateThread();
			m_dlg.TerminateThread();

			CDialog::OnOK();
			m_bProcessing = 0;
		}
	}
	catch (...)
	{
	}
}

void ShowPic22::OnClose()
{
	if (m_pParent)
	{
		if (m_bProcessing)return;
		m_bProcessing = 1;
		{
			TerminateThread();
			::SetForegroundWindow(m_hWnd);
			m_pImage = m_pImagesmall = NULL;
			for (int n = m_nPosArray.GetSize() - 1; n >= 0; n--)
			{
				delete m_pImageArray.ElementAt(n);
				delete m_pImageSmallArray.ElementAt(n);
				m_pImageArray.RemoveAt(n);
				m_pImageSmallArray.RemoveAt(n);
				m_nPosArray.RemoveAt(n);
			}

			if (m_pPathArrayBigsize)
			{
				m_pPathArrayBigsize->RemoveAll();
				m_pPathArray->RemoveAll();
				CStringArray *pArray = m_pParent->GetCurArray();
				m_pPathArrayBigsize->Copy(*pArray);
				for (int i = 0; i < m_pPathArrayBigsize->GetSize(); i++)
				{
					CString str = m_pPathArrayBigsize->ElementAt(i);
					CString spath = str.Left(str.ReverseFind('\\') + 1);
					spath += "m";
					spath += str.Right(str.GetLength() - str.ReverseFind('\\') - 1);
					if (::PathFileExists(spath))
						m_pPathArray->Add(spath);
					else
						m_pPathArray->Add(str);
				}
			}

			if (m_pos >= this->m_pPathArray->GetSize())
				m_pos = 0;
			if (this->m_pPathArray->GetSize() == 0)
			{
				m_bProcessing = 0;
				KillTimer(6);
				SetTimer(6, 100, NULL);
			}
			else
			{
				RunPicThread();
				LoadImage();
			}
		}
		m_bProcessing = 0;
	}
}

void ShowPic22::InitRc()
{
	try
	{
		if (m_pImage == NULL)return;
		CRect rc;
		GetClientRect(rc);
		m_rc = rc;

		int width, height;
		if (m_pImagesmall)
		{
			width = m_pImagesmall->GetWidth();
			height = m_pImagesmall->GetHeight();
		}
		else
		{
			width = m_pImage->GetWidth();
			height = m_pImage->GetHeight();
		}
		//////////
		float fscale = (float)width / (float)height;
		float rcscale = ((float)m_rc.Width()) / ((float)m_rc.Height());
		int rcwid = m_rc.Width();
		int rchei = m_rc.Height();
		int dt = 0;
		if (rcscale < fscale)
		{
			dt = (rchei - rcwid / fscale) / 2;
			m_rc.top += dt;
			m_rc.bottom -= dt;
		}
		else
		{
			dt = (rcwid - rchei*fscale) / 2;
			m_rc.left += dt;
			m_rc.right -= dt;
		}
		m_rcbak = m_rc;
	}
	catch (...)
	{
	}
}

//---------------------------------------------------------------
// Remark by Jeff 2014.11.05
// 函数：Rotate1
// 描述：旋转相片270度;
// 参数：无
// 返回：无
//---------------------------------------------------------------
void ShowPic22::Rotate1()	// 逆时针旋转相片按钮;
{
	if (m_bauto)return;
	if (m_bProcessing)return;
	try
	{
		if (m_pImage)
		{
			m_pImage->RotateFlip(Rotate270FlipNone);
			if (m_pImagesmall)  m_pImagesmall->RotateFlip(Rotate270FlipNone);
			if (m_pImagetemp) m_pImagetemp->RotateFlip(Rotate270FlipNone);
			InitRc();
			Invalidate();
		}
	}
	catch (...)
	{
	}
}

//---------------------------------------------------------------
// Remark by Jeff 2014.11.05
// 函数：Rotate2
// 描述：旋转相片90度;
// 参数：无
// 返回：无
//---------------------------------------------------------------
void ShowPic22::Rotate2()	// 顺时针旋转相片按钮;
{
	if (m_bauto)return;
	if (m_bProcessing)return;
	try
	{
		if (m_pImage)
		{
			m_pImage->RotateFlip(Rotate90FlipNone);
			if (m_pImagesmall)  m_pImagesmall->RotateFlip(Rotate90FlipNone);
			if (m_pImagetemp) m_pImagetemp->RotateFlip(Rotate90FlipNone);
			InitRc();
			Invalidate();
		}
	}
	catch (...)
	{
	}
}

//---------------------------------------------------------------
// Remark by Jeff 2014.11.05
// 函数：Pre
// 描述：上一张按钮
// 参数：无
// 返回：无
//---------------------------------------------------------------
void ShowPic22::Pre()	// 上一张按钮;
{
	if (m_bauto)return;
	if (m_bProcessing)return;
	m_bInit = 1;
	try
	{
		m_pos--;
		if (m_pos < 0)
			m_pos = this->m_pPathArray->GetSize() - 1;
		m_bChooseBig = 0;
		LoadImage(); 
		m_PreviewDlg.ShowPic(m_pos);
	}
	catch (...)
	{
	}
}

//---------------------------------------------------------------
// Remark by Jeff 2014.11.05
// 函数：Next
// 描述：下一张按钮
// 参数：无
// 返回：无
//---------------------------------------------------------------
void ShowPic22::Next()	// 下一张按钮;
{
	if (m_bauto)return;
	if (m_bProcessing)return;
	m_bInit = 1;
	try
	{
		m_pos++;
		if (m_pos >= this->m_pPathArray->GetSize())
		{
			m_pos = 0;	
			AfxMessageBox("您的照片已浏览完毕!", MB_ICONINFORMATION);
		}
		m_bChooseBig = 0;
		LoadImage();
		m_PreviewDlg.ShowPic(m_pos);
	}
	catch (...)
	{
	}
}

//------------------------------------------------------
// Remark by Jeff 2014.11.05
// 函数：SetEffect
// 描述：设置显示相片效果;
// 参数：effect:效果类型;
// 返回：无
//------------------------------------------------------
void ShowPic22::SetEffect(int effect)
{
	::SetForegroundWindow(m_hWnd);
	m_dlg.m_effect = effect;
}

void ShowPic22::TerminateThread()
{
	try
	{
		if (m_bRunning)
		{
			m_bTerminate = true;
			for (;;)
			{
				if (::WaitForSingleObject(m_hThread, 0) == WAIT_OBJECT_0)
					break;

				MSG msg;
				while (::PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE))
				{
					if (!AfxGetApp()->PumpMessage())
						break;
				}
			}
			::CloseHandle(m_hThread);
		}
	}
	catch (...)
	{
	}
}

void ShowPic22::InitRc(Image *img, CRect &rc)
{
	try
	{
		if (img == NULL)return;
		CRect rc2;
		GetClientRect(rc2);
		rc = rc2;

		int width, height;
		width = img->GetWidth();
		height = img->GetHeight();
		//////////
		float fscale = (float)width / (float)height;
		float rcscale = ((float)rc.Width()) / ((float)rc.Height());
		int rcwid = rc.Width();
		int rchei = rc.Height();
		int dt = 0;
		if (rcscale < fscale)
		{
			dt = (rchei - rcwid / fscale) / 2;
			rc.top += dt;
			rc.bottom -= dt;
		}
		else
		{
			dt = (rcwid - rchei*fscale) / 2;
			rc.left += dt;
			rc.right -= dt;
		}
	}
	catch (...)
	{
	}
}

HBRUSH ShowPic22::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor)
{
	HBRUSH hbr = CDialog::OnCtlColor(pDC, pWnd, nCtlColor);

	if (nCtlColor == CTLCOLOR_STATIC)
	{
		pDC->SetBkMode(TRANSPARENT);
		pDC->SetTextColor(RGB(255, 255, 255));
		return (HBRUSH)::GetStockObject(NULL_BRUSH);
	}
	return hbr;
}

void ShowPic22::RunPicThread()
{
	// 1.是否有播放相片路径;
	if (m_pPathArray->GetSize() == 0)
		return;//2011-03-09

	TerminateThread();
	m_hThread = (HANDLE)_beginthreadex(NULL, 0, GenThumbImgThread, (LPVOID)this, 0/* CREATE_SUSPENDED*/, &m_dwThreadID);
	m_bRunning = true;
}

//-------------------------------------------------------------------
// Remark by Jeff
// 函数：OnMouseWheel2
// 描述：鼠标滚轮缩放图片
// 参数：bZoomOut : TRUE 表示放大;FALSE表示缩小;
// 返回：无
//-------------------------------------------------------------------
void ShowPic22::OnMouseWheel2(BOOL bZoomOut)	// 鼠标滚轮缩放图片;
{
	if (m_pImage == NULL)return;
	if (m_bauto)return;
	if (m_bProcessing)return;
	m_bScroll = 1;
	if (bZoomOut)
	{
		//	if(m_fscale>4)return 1;
		m_fscale *= 1.2;
		int dtx = (m_fscale*m_rcbak.Width() - m_rc.Width()) / 2.0;
		int dty = (m_fscale*m_rcbak.Height() - m_rc.Height()) / 2.0;

		m_rc.left -= dtx;
		m_rc.right += dtx;
		m_rc.top -= dty;
		m_rc.bottom += dty;

		Invalidate();
	}
	else
	{
		if (m_fscale <= 1)return;
		m_fscale /= 1.2;
		if (m_fscale < 1)m_fscale = 1;
		int dtx = (m_fscale*m_rcbak.Width() - m_rc.Width()) / 2.0;
		int dty = (m_fscale*m_rcbak.Height() - m_rc.Height()) / 2.0;

		m_rc.left -= dtx;
		m_rc.right += dtx;
		m_rc.top -= dty;
		m_rc.bottom += dty;

		if (m_rcbak.Height() == m_rcscreen.Height())
		{
			if (m_rc.top < m_rcscreen.top && m_rc.bottom < m_rcscreen.bottom)
			{
				dtx = m_rcscreen.bottom - m_rc.bottom;
				m_rc.top += dtx;
				m_rc.bottom += dtx;
			}
			else if (m_rc.top >m_rcscreen.top && m_rc.bottom > m_rcscreen.bottom)
			{
				dtx = m_rc.top - m_rcscreen.top;
				m_rc.top -= dtx;
				m_rc.bottom -= dtx;
			}

			dtx = m_rc.Width();
			m_rc.left = (m_rcscreen.Width() - dtx) / 2;
			m_rc.right = m_rc.left + dtx;
		}

		if (m_rcbak.Width() == m_rcscreen.Width())
		{
			if (m_rc.left < m_rcscreen.left && m_rc.right < m_rcscreen.right)
			{
				dtx = m_rcscreen.right - m_rc.right;
				m_rc.left += dtx;
				m_rc.right += dtx;
			}
			else if (m_rc.left >m_rcscreen.left && m_rc.right > m_rcscreen.right)
			{
				dtx = m_rc.left - m_rcscreen.left;
				m_rc.left -= dtx;
				m_rc.right -= dtx;
			}

			dtx = m_rc.Height();
			m_rc.top = (m_rcscreen.Height() - dtx) / 2;
			m_rc.bottom = m_rc.top + dtx;
		}
		Invalidate();
	}
	KillTimer(2);
	SetTimer(2, 100, NULL);
}

long ShowPic22::ShowInfo2(WPARAM inWParam, LPARAM inLParam)
{
	if (inWParam == 1)
	{
		if (m_bauto)AutoPic();
		return 1;
	}
	ShowInfo();
	return 1;
}

void ShowPic22::ShowInfo()
{
	Invalidate();
	if (m_bShowName)
	{
		CString str = m_pPathArray->ElementAt(m_pos);
		str = str.Right(str.GetLength() - str.ReverseFind('\\') - 1);
		str = str.Left(str.GetLength() - 4);
		str.TrimLeft("m");
		str = "编号:" + str + " ";
		if (m_pParent)
			str += m_pParent->GetZSInfo(m_pos);
		SetDlgItemText(IDC_STATIC2, str);
	}
}

//----------------------------------------------------------------
// Remark by Jeff 2014.11.05
// 函数：CutPhoto2
// 描述：剪裁按钮对应的剪裁功能;
// 参数：无
// 返回：无
// ----------------------------------------------------------------
void ShowPic22::CutPhoto2()
{
	if (m_pParent == NULL)return;
	CutPhoto dlg;
	CString path = m_pPathArray->ElementAt(m_pos);
	if (m_pPathArrayBigsize)path = m_pPathArrayBigsize->ElementAt(m_pos);
	path = path.Right(path.GetLength() - path.ReverseFind('\\') - 1);
	path = path.Left(path.Find("."));
	// path其实不是路径，只是文件名;如005
	dlg.m_strImgName = path;
	dlg.m_photowidth = m_pImage->GetWidth();
	dlg.m_photoheight = m_pImage->GetHeight();
	dlg.m_pImg = m_pImagesmall;
	dlg.m_strOrderNumber = m_pParent->m_strOrderNumber;
	dlg.DoModal();
}

//----------------------------------------------------------------
// Remark by Jeff 2014.11.05
// 函数：CutPhoto3
// 描述：剪裁按钮;
// 参数：无
// 返回：无
// ----------------------------------------------------------------
void ShowPic22::CutPhoto3()
{
	if (m_pParent == NULL)return;
	if (m_pParent->m_Runingmode)return;

	if (m_bShowEffect)return;
	if (m_bauto)
	{
		m_bauto = 0;
		KillTimer(1);
		m_dlg.TerminateThread();
		m_dlg.ShowWindow(SW_HIDE);
	}
	if (m_pImage)
	{
		m_bShowEffect = 1;
		CutPhoto2();
		m_bShowEffect = 0;
	}
}