sliderctrl.cpp

3D reconstruction, medical image processing from colons, using intel image processing for based clas

// SliderCtrl.cpp : implementation file
//

#include "stdafx.h"
#include "fusion.h"
#include "SliderCtrl.h"

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

/////////////////////////////////////////////////////////////////////////////
// RxSliderCtrl

RxSliderCtrl::RxSliderCtrl()
{
	m_nPixelMin			= 0;
	m_nPixelMax			= 100;
	m_nPixelLeft		= 0;
	m_nPixelRight		= 0;
	m_nPixelCenter		= 0;

	m_nPosMin			= 0;
	m_nPosMax			= 100;
	m_nPosLeft			= 0;
	m_nPosRight			= 0;
	m_nPosCenter		= 0;
}

RxSliderCtrl::~RxSliderCtrl()
{
	if(m_hWnd)			DestroyWindow();
}

BEGIN_MESSAGE_MAP(RxSliderCtrl, CWnd)
	//{{AFX_MSG_MAP(RxSliderCtrl)
	ON_WM_MOUSEACTIVATE()
	ON_WM_LBUTTONDOWN()
	ON_WM_ERASEBKGND()
	ON_WM_MOUSEWHEEL()
	ON_WM_LBUTTONDBLCLK()
	ON_WM_LBUTTONUP()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()


/////////////////////////////////////////////////////////////////////////////
// RxSliderCtrl message handlers

BOOL RxSliderCtrl::Create(DWORD dwStyle, DWORD dwExStyle, const RECT &rect, CWnd *pParentWnd, UINT nID)
{
	CWnd::Create(NULL, NULL, dwStyle, rect, pParentWnd, nID);

	m_dwExStyle		= dwExStyle;
	m_nSelGrip		= 0;
	m_nSelGripOld	= RXSC_MOUSE_GRIP_LEFT;
	m_nSelText		= m_nSelGripOld;

	m_crBkgnd  = RGB(192,192,192);
	m_crNFace  = RGB(255,255,255);	m_crDFace  = RGB(198,198,198);
	m_crNSel   = RGB(255,230,230);	m_crDSel   = RGB(178,178,178);
	m_crNGrip  = RGB(192,192,192);	m_crSGrip  = RGB(172,172,172);	m_crDGrip  = RGB(152,152,152);
	m_crNCGrip = RGB(255, 80, 80);	m_crSCGrip = RGB(155,  0,  0);	m_crDCGrip = RGB(198,198,198);

	// deside the axis thickness
	if(m_dwExStyle & RXSC_BT_THIN)
		m_nBarThickness = 2;
	else if(m_dwExStyle & RXSC_BT_THICK)
		m_nBarThickness = 5;

	RecalcLayout();

	return TRUE;
}

void RxSliderCtrl::EnableWindow(BOOL bEnable)
{
	CWnd::EnableWindow(bEnable);

	RedrawWindow();
}

int RxSliderCtrl::OnMouseActivate(CWnd* pDesktopWnd, UINT nHitTest, UINT message) 
{
	HWND hWndFocus = ::GetFocus();
	if (m_hWnd != hWndFocus && !::IsChild(m_hWnd, hWndFocus))
		::SetFocus(m_hWnd);
	
	return CWnd::OnMouseActivate(pDesktopWnd, nHitTest, message);
}


BOOL RxSliderCtrl::OnMouseWheel(UINT nFlags, short zDelta, CPoint pt) 
{
	if(zDelta >= 0)
	{
		if(Increase())
			GetParent()->SendMessage(UM_GRIP_MOVE, m_nSelGripOld, (WPARAM)this);
	}
	else
	{
		if(Decrease())
			GetParent()->SendMessage(UM_GRIP_MOVE, m_nSelGripOld, (WPARAM)this);
	}
	
	return CWnd::OnMouseWheel(nFlags, zDelta, pt);
}


void RxSliderCtrl::OnLButtonDown(UINT nFlags, CPoint point) 
{
	int		nHitTest = HitTest(point);

	if(nHitTest < 0)
	{
		CWnd::OnLButtonDown(nFlags, point);
		return;
	}

	int		nDiffX, nDiffCenter, nDiffRight, nReposition;
	if(nHitTest == RXSC_MOUSE_GRIP_LEFT)
	{
		nDiffX = point.x - m_nPixelLeft;
		nReposition = 0;
	}
	else if(nHitTest == RXSC_MOUSE_GRIP_RIGHT)
	{
		nDiffX = point.x - m_nPixelRight;
		nReposition = 1;
	}
	else if(nHitTest == RXSC_MOUSE_GRIP_CENTER)
	{
		nDiffX = point.x - m_nPixelCenter;
		nReposition = 2;
	}
	else if(nHitTest == RXSC_MOUSE_GRIP_REGION)
	{
		nDiffX      = point.x - m_nPixelLeft;
		nDiffCenter = m_nPixelCenter - (m_nPixelLeft+RXSC_GRIP_WIDTH);
		nDiffRight  = m_nPixelRight  - (m_nPixelLeft+RXSC_GRIP_WIDTH);
		nReposition = 5;
	}

	SetCapture();
	m_nSelGrip = m_nSelText = nHitTest;		// 喘范阑锭 Grip 葛剧 盎脚

	EraseBkgnd(nReposition);

	for (;;)
	{
		MSG		msg;
		VERIFY(::GetMessage(&msg, NULL, 0, 0));
		ScreenToClient(&msg.pt);

		switch (msg.message)
		{
			case WM_MOUSEMOVE :
/*Style Check*/	if(m_dwExStyle & RXSC_GC_SINGLE)
				{
/*Mouse*/			if(nHitTest == RXSC_MOUSE_GRIP_LEFT)
/*Click Check*/		{
						// Set Pixel Position
						m_nPixelLeft = msg.pt.x-nDiffX;
/*Boundary Check*/		if(m_nPixelLeft < m_nPixelMin)
							m_nPixelLeft = m_nPixelMin;
						else if((m_nPixelLeft+RXSC_GRIP_WIDTH) > m_nPixelMax)
							m_nPixelLeft = m_nPixelMax - RXSC_GRIP_WIDTH;
						if(EraseBkgnd() > 0)
							GetParent()->SendMessage(UM_GRIP_MOVE, (LPARAM)nHitTest, (WPARAM)this);
					}
				}
				else if(m_dwExStyle & RXSC_GC_MULTI)
				{
					if(nHitTest == RXSC_MOUSE_GRIP_LEFT)
					{
						nReposition = 0;
						m_nPixelLeft = msg.pt.x-nDiffX;
						if(m_nPixelLeft < m_nPixelMin)
							m_nPixelLeft = m_nPixelMin;
						else if((m_nPixelLeft+RXSC_GRIP_WIDTH) > m_nPixelRight)
						{
							nReposition = 5;
							m_nPixelRight = m_nPixelLeft+RXSC_GRIP_WIDTH;
							if((m_nPixelRight+RXSC_GRIP_WIDTH) > m_nPixelMax)
							{
								m_nPixelRight = m_nPixelMax-RXSC_GRIP_WIDTH;
								m_nPixelLeft  = m_nPixelRight-RXSC_GRIP_WIDTH;
							}
						}
						if(EraseBkgnd(nReposition) > 0)
							GetParent()->SendMessage(UM_GRIP_MOVE, (LPARAM)nHitTest, (WPARAM)this);
					}
					else if(nHitTest == RXSC_MOUSE_GRIP_RIGHT)
					{
						nReposition = 1;
						m_nPixelRight = msg.pt.x-nDiffX;
						if((m_nPixelRight+RXSC_GRIP_WIDTH) > m_nPixelMax)
							m_nPixelRight = m_nPixelMax-RXSC_GRIP_WIDTH;
						else if(m_nPixelRight < (m_nPixelLeft+RXSC_GRIP_WIDTH))
						{
							nReposition = 5;
							m_nPixelLeft = m_nPixelRight-RXSC_GRIP_WIDTH;
							if(m_nPixelLeft < m_nPixelMin)
							{
								m_nPixelLeft  = m_nPixelMin;
								m_nPixelRight = m_nPixelLeft+RXSC_GRIP_WIDTH;
							}
						}
						if(EraseBkgnd(nReposition) > 0)
							GetParent()->SendMessage(UM_GRIP_MOVE, (LPARAM)nHitTest, (WPARAM)this);
					}
					else if(nHitTest == RXSC_MOUSE_GRIP_REGION)
					{
						nReposition = 5;
						m_nPixelLeft  = msg.pt.x-nDiffX;
						m_nPixelRight = m_nPixelLeft+RXSC_GRIP_WIDTH+nDiffRight;
						if(m_nPixelLeft < m_nPixelMin)
						{
							m_nPixelLeft  = m_nPixelMin;
							m_nPixelRight = m_nPixelLeft+RXSC_GRIP_WIDTH+nDiffRight;
						}
						else if((m_nPixelRight+RXSC_GRIP_WIDTH) > m_nPixelMax)
						{
							m_nPixelRight = m_nPixelMax-RXSC_GRIP_WIDTH;
							m_nPixelLeft  = m_nPixelRight-nDiffRight-RXSC_GRIP_WIDTH;
						}
						if(EraseBkgnd(nReposition) > 0)
							GetParent()->SendMessage(UM_GRIP_MOVE, (LPARAM)nHitTest, (WPARAM)this);
					}
				}
				else if(m_dwExStyle & RXSC_GC_MULTI_EX)
				{
					if(nHitTest == RXSC_MOUSE_GRIP_LEFT)
					{
						nReposition = 3;
						m_nPixelLeft   = msg.pt.x-nDiffX;
						m_nPixelCenter = m_nPixelLeft+RXSC_GRIP_WIDTH;
						if(m_nPixelLeft < m_nPixelMin)
						{
							m_nPixelLeft   = m_nPixelMin;
							m_nPixelCenter = m_nPixelLeft+RXSC_GRIP_WIDTH;
						}
						else if((m_nPixelCenter+RXSC_GRIP_WIDTH) > m_nPixelRight)
						{
							nReposition = 5;
							m_nPixelRight = m_nPixelCenter+RXSC_GRIP_WIDTH;
							if((m_nPixelRight+RXSC_GRIP_WIDTH) > m_nPixelMax)
							{
								m_nPixelRight  = m_nPixelMax-RXSC_GRIP_WIDTH;
								m_nPixelCenter = m_nPixelRight-RXSC_GRIP_WIDTH;
								m_nPixelLeft   = m_nPixelCenter-RXSC_GRIP_WIDTH;
							}
						}
						if(EraseBkgnd(nReposition) > 0)
							GetParent()->SendMessage(UM_GRIP_MOVE, (LPARAM)nHitTest, (WPARAM)this);
					}
					else if(nHitTest == RXSC_MOUSE_GRIP_RIGHT)
					{
						nReposition = 4;
						m_nPixelRight  = msg.pt.x-nDiffX;
						m_nPixelCenter = m_nPixelRight-RXSC_GRIP_WIDTH;
						if((m_nPixelRight+RXSC_GRIP_WIDTH) > m_nPixelMax)
						{
							m_nPixelRight  = m_nPixelMax-RXSC_GRIP_WIDTH;
							m_nPixelCenter = m_nPixelRight-RXSC_GRIP_WIDTH;
						}
						else if(m_nPixelCenter < (m_nPixelLeft+RXSC_GRIP_WIDTH))
						{
							nReposition = 5;
							m_nPixelLeft = m_nPixelCenter-RXSC_GRIP_WIDTH;
							if(m_nPixelLeft < m_nPixelMin)
							{
								m_nPixelLeft   = m_nPixelMin;
								m_nPixelCenter = m_nPixelLeft+RXSC_GRIP_WIDTH;
								m_nPixelRight  = m_nPixelCenter+RXSC_GRIP_WIDTH;
							}
						}
						if(EraseBkgnd(nReposition) > 0)
							GetParent()->SendMessage(UM_GRIP_MOVE, (LPARAM)nHitTest, (WPARAM)this);
					}
					else if(nHitTest == RXSC_MOUSE_GRIP_CENTER)
					{
						nReposition = 2;
						m_nPixelCenter = msg.pt.x-nDiffX;

						if(m_nPixelCenter < (m_nPixelLeft+RXSC_GRIP_WIDTH))
							m_nPixelCenter = m_nPixelLeft+RXSC_GRIP_WIDTH;
						else if((m_nPixelCenter+RXSC_GRIP_WIDTH) > m_nPixelRight)
							m_nPixelCenter = m_nPixelRight-RXSC_GRIP_WIDTH;
						if(EraseBkgnd(nReposition) > 0)
							GetParent()->SendMessage(UM_GRIP_MOVE, (LPARAM)nHitTest, (WPARAM)this);
					}
					else if(nHitTest == RXSC_MOUSE_GRIP_REGION)
					{
						nReposition = 5;
						m_nPixelLeft   = msg.pt.x-nDiffX;
						m_nPixelCenter = m_nPixelLeft+RXSC_GRIP_WIDTH+nDiffCenter;
						m_nPixelRight  = m_nPixelLeft+RXSC_GRIP_WIDTH+nDiffRight;

						if(m_nPixelLeft < m_nPixelMin)
						{
							m_nPixelLeft   = m_nPixelMin;
							m_nPixelCenter = m_nPixelLeft+RXSC_GRIP_WIDTH+nDiffCenter;
							m_nPixelRight  = m_nPixelLeft+RXSC_GRIP_WIDTH+nDiffRight;
						}
						else if((m_nPixelRight+RXSC_GRIP_WIDTH) > m_nPixelMax)
						{
							m_nPixelRight  = m_nPixelMax-RXSC_GRIP_WIDTH;
							m_nPixelLeft   = m_nPixelRight-nDiffRight-RXSC_GRIP_WIDTH;
							m_nPixelCenter = m_nPixelLeft+RXSC_GRIP_WIDTH+nDiffCenter;
						}
						if(EraseBkgnd(nReposition) > 0)
							GetParent()->SendMessage(UM_GRIP_MOVE, (LPARAM)nHitTest, (WPARAM)this);
					}
				}
				break;
			case WM_LBUTTONUP :
				goto EndLButtonDown;
			default :	// just dispatch rest of the messages
				DispatchMessage(&msg);
				break;
		}
	}

EndLButtonDown :
	ReleaseCapture();
	m_nSelGripOld	= m_nSelGrip;		// Mouse Wheel阑 困秦 弥辆栏肺 付快胶啊 急琶等 惑怕甫 历厘秦 初绰促.
	m_nSelGrip		= 0;				// 促矫 付快胶甫 救穿弗 惑怕肺 父电促.
	EraseBkgnd(nReposition);
	GetParent()->SendMessage(UM_GRIP_MOVE_END, (LPARAM)nHitTest, (WPARAM)this);

	CWnd::OnLButtonDown(nFlags, point);
}

void RxSliderCtrl::OnLButtonDblClk(UINT nFlags, CPoint point) 
{
	int		nHitTest = HitTest(point);

	if(nHitTest == RXSC_MOUSE_GRIP_LEFT)
	{
		if(m_nPosLeft != m_nPosMin)
		{
			m_nPosLeft  = m_nPosMin;

			RedrawWindow();
			GetParent()->SendMessage(UM_GRIP_MOVE, (LPARAM)nHitTest, (WPARAM)this);
		}
	}
	else if(nHitTest == RXSC_MOUSE_GRIP_RIGHT)
	{
		if(m_nPosRight != m_nPosMax)
		{
			m_nPosRight = m_nPosMax;

			RedrawWindow();
			GetParent()->SendMessage(UM_GRIP_MOVE, (LPARAM)nHitTest, (WPARAM)this);
		}
	}
	if(nHitTest == RXSC_MOUSE_GRIP_REGION)
	{
		if(m_nPosLeft != m_nPosMin || m_nPosRight != m_nPosMax)
		{
			m_nPosLeft  = m_nPosMin;
			m_nPosRight = m_nPosMax;

			RedrawWindow();
			GetParent()->SendMessage(UM_GRIP_MOVE, (LPARAM)nHitTest, (WPARAM)this);
		}
	}
	
	CWnd::OnLButtonDblClk(nFlags, point);
}

BOOL RxSliderCtrl::OnEraseBkgnd(CDC* pDC) 
{
	CRect	rcClient, rcTemp;
	GetClientRect(rcClient);

	// Create a mem DC for drawing
	CDC dcMem;
	CBitmap bmpMem;
	dcMem.CreateCompatibleDC(pDC);
	bmpMem.CreateCompatibleBitmap(pDC, rcClient.Width(), rcClient.Height());
	CBitmap *pOldBmp = dcMem.SelectObject(&bmpMem);

	int nSaveDC = dcMem.SaveDC();

	// Draw Background
	DrawBack(&dcMem, rcClient);

	if(m_dwExStyle & RXSC_GC_SINGLE)
	{
		if(m_nPosMin == m_nPosMax)
			m_nPixelLeft = m_nPixelMin;
		else
			m_nPixelLeft = PosToPixel(m_nPosLeft, m_nPixelMin, m_nPixelMax-RXSC_GRIP_WIDTH);

		rcTemp = GetGripRect(m_nPixelLeft);
		DrawGrip(&dcMem, rcTemp, (m_nSelGrip == RXSC_MOUSE_GRIP_LEFT));

		if(m_dwExStyle & RXSC_CD_SHOW)
			DrawGripPosition(&dcMem, m_nPixelLeft, m_nPosLeft);
	}
	else if(m_dwExStyle & RXSC_GC_MULTI)
	{
		if(m_nPosMin == m_nPosMax)
		{
			m_nPixelLeft  = m_nPixelMin;
			m_nPixelRight = m_nPixelMax-RXSC_GRIP_WIDTH;
		}
		else
		{
			m_nPixelLeft  = PosToPixel(m_nPosLeft,  m_nPixelMin, m_nPixelMax-(RXSC_GRIP_WIDTH*2));
			m_nPixelRight = PosToPixel(m_nPosRight, m_nPixelMin+RXSC_GRIP_WIDTH, m_nPixelMax-RXSC_GRIP_WIDTH);
		}

		// draw selected bar region
		rcTemp = GetGripRect(m_nPixelLeft, TRUE);
		rcTemp.SetRect(rcTemp.right, rcTemp.top, m_nPixelRight, rcTemp.bottom);
		dcMem.FillSolidRect(rcTemp, m_crNSel);
		// draw left grip
		rcTemp = GetGripRect(m_nPixelLeft);
		DrawGrip(&dcMem, rcTemp, (m_nSelGrip == RXSC_MOUSE_GRIP_LEFT || m_nSelGrip == RXSC_MOUSE_GRIP_REGION));
		// draw right grip
		rcTemp = GetGripRect(m_nPixelRight);
		DrawGrip(&dcMem, rcTemp, (m_nSelGrip == RXSC_MOUSE_GRIP_RIGHT || m_nSelGrip == RXSC_MOUSE_GRIP_REGION));

		if(m_dwExStyle & RXSC_CD_SHOW)
		{
			if(m_nSelText == RXSC_MOUSE_GRIP_LEFT)
			{
				DrawGripPosition(&dcMem, m_nPixelRight,  m_nPosRight);
				DrawGripPosition(&dcMem, m_nPixelLeft,   m_nPosLeft, TRUE);
			}
			else if(m_nSelText == RXSC_MOUSE_GRIP_RIGHT)
			{
				DrawGripPosition(&dcMem, m_nPixelLeft,   m_nPosLeft);
				DrawGripPosition(&dcMem, m_nPixelRight,  m_nPosRight, TRUE);
			}
			else
			{
				DrawGripPosition(&dcMem, m_nPixelLeft,   m_nPosLeft);
				DrawGripPosition(&dcMem, m_nPixelRight,  m_nPosRight);
			}
		}
	}
	else if(m_dwExStyle & RXSC_GC_MULTI_EX)
	{
		if(m_nPosMin == m_nPosMax)
		{
			m_nPixelLeft   = m_nPixelMin;
			m_nPixelRight  = m_nPixelMax-RXSC_GRIP_WIDTH;
			m_nPixelCenter = m_nPixelMin+RXSC_GRIP_WIDTH;
		}
		else
		{
			m_nPixelLeft   = PosToPixel(m_nPosLeft,   m_nPixelMin, m_nPixelMax-(RXSC_GRIP_WIDTH*3));
			m_nPixelRight  = PosToPixel(m_nPosRight,  m_nPixelMin+(RXSC_GRIP_WIDTH*2), m_nPixelMax-RXSC_GRIP_WIDTH);
			m_nPixelCenter = PosToPixel(m_nPosCenter, m_nPixelMin+RXSC_GRIP_WIDTH, m_nPixelMax-(RXSC_GRIP_WIDTH*2));
		}

		// draw selected bar region
		rcTemp = GetGripRect(m_nPixelLeft, TRUE);
		rcTemp.SetRect(rcTemp.right, rcTemp.top, m_nPixelRight, rcTemp.bottom);
		dcMem.FillSolidRect(rcTemp, m_crNSel);
		// draw left grip
		rcTemp = GetGripRect(m_nPixelLeft);
		DrawGrip(&dcMem, rcTemp, (m_nSelGrip == RXSC_MOUSE_GRIP_LEFT || m_nSelGrip == RXSC_MOUSE_GRIP_REGION));
		// draw right grip
		rcTemp = GetGripRect(m_nPixelRight);
		DrawGrip(&dcMem, rcTemp, (m_nSelGrip == RXSC_MOUSE_GRIP_RIGHT || m_nSelGrip == RXSC_MOUSE_GRIP_REGION));
		// draw center grip
		rcTemp = GetGripRect(m_nPixelCenter, TRUE);
		DrawCenterGrip(&dcMem, rcTemp, (m_nSelGrip == RXSC_MOUSE_GRIP_CENTER || m_nSelGrip == RXSC_MOUSE_GRIP_REGION));

		if(m_dwExStyle & RXSC_CD_SHOW)
		{
			if(m_nSelText == RXSC_MOUSE_GRIP_LEFT)
			{
				DrawGripPosition(&dcMem, m_nPixelRight,  m_nPosRight);
				DrawGripPosition(&dcMem, m_nPixelCenter, m_nPosCenter);
				DrawGripPosition(&dcMem, m_nPixelLeft,   m_nPosLeft, TRUE);
			}
			else if(m_nSelText == RXSC_MOUSE_GRIP_CENTER)
			{
				DrawGripPosition(&dcMem, m_nPixelRight,  m_nPosRight);
				DrawGripPosition(&dcMem, m_nPixelLeft,   m_nPosLeft);
				DrawGripPosition(&dcMem, m_nPixelCenter, m_nPosCenter, TRUE);
			}
			else if(m_nSelText == RXSC_MOUSE_GRIP_RIGHT)
			{
				DrawGripPosition(&dcMem, m_nPixelLeft,   m_nPosLeft);
				DrawGripPosition(&dcMem, m_nPixelCenter, m_nPosCenter);
				DrawGripPosition(&dcMem, m_nPixelRight,  m_nPosRight, TRUE);
			}
			else
			{
				DrawGripPosition(&dcMem, m_nPixelLeft,   m_nPosLeft);
				DrawGripPosition(&dcMem, m_nPixelCenter, m_nPosCenter);