fmwnd.cpp

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

	else
	{
		pDC->SetTextColor(RGB(  0,  0,  0));
		pDC->DrawText(_tabCaption->strText, rcTemp, DT_SINGLELINE|DT_VCENTER|DT_CENTER);
	}

	pDC->SelectObject(pOldPen);
	pDC->SelectObject(pOldBrush);
	pDC->SelectObject(pOldFont);

	pen.DeleteObject();
	brush.DeleteObject();
	font.DeleteObject();
}

void RxFMWnd::DrawButton(CDC *pDC, CPoint point, RX_CAPBUTTON *_btnCaption)
{
	CDC		dcMem;
	dcMem.CreateCompatibleDC(pDC);

	CBitmap bmpMem, *pOldBitmap;
	bmpMem.LoadBitmap(_btnCaption->nBmpID);
	pOldBitmap = dcMem.SelectObject(&bmpMem);

	int		nPos;
	WORD	wStatus = _btnCaption->wStatus;
	if(wStatus & RXCBS_DISABLED)
		nPos = RXSZ_CAP_BUTTON * 3;
	else if((wStatus & RXCBS_CHECK) || (wStatus & RXCBS_SELECT))
		nPos = RXSZ_CAP_BUTTON;
	else if(wStatus & RXCBS_FOCUS)
		nPos = RXSZ_CAP_BUTTON * 2;
	else
		nPos = 0;

	pDC->BitBlt(point.x, point.y, RXSZ_CAP_BUTTON, RXSZ_CAP_BUTTON, &dcMem,
								nPos, 0, SRCCOPY);

	dcMem.SelectObject(pOldBitmap);

	dcMem.DeleteDC();
}

void RxFMWnd::DrawSlider(CDC *pDC, CRect rect)
{
	CBrush		brush, *pOldBrush;
	CBitmap		bmpPattern;
	COLORREF	aPattern[] = {RGB(122,122,122), RGB(192,192,192), RGB(192,192,192), RGB(122,122,122)};
	bmpPattern.CreateBitmap(2, 2, 1, 32, aPattern);
	brush.CreatePatternBrush(&bmpPattern);
	pOldBrush = pDC->SelectObject(&brush);
	pDC->PatBlt(rect.left, rect.top, rect.Width(), rect.Height(), PATCOPY);
	pDC->SelectObject(pOldBrush);
	brush.DeleteObject();
	bmpPattern.DeleteObject();

	// Draw header border
	pDC->Draw3dRect(rect, RXCOLOR_100, RXCOLOR_100);

	CPen		penBorder, penArrow1, penArrow2, *pOldPen;
	penBorder.CreatePen(PS_SOLID, 1, RXCOLOR_100);
	penArrow1.CreatePen(PS_SOLID, 1, RGB(  0,  0,  0));
	penArrow2.CreatePen(PS_SOLID, 1, RGB(255,255,255));

	pOldPen		= pDC->SelectObject(&penBorder);

	CBrush		brNormal, brFocus, brSelect;
	brNormal.CreateSolidBrush(RGB(198,194,193));
	brFocus.CreateSolidBrush(RGB(238,234,233));
	brSelect.CreateSolidBrush(RGB(138,134,133));

	CRect	rcTemp;
	if(m_bSliderVert)
	{
		// draw up
		if(m_nMouseCheckSlider == 0)			pOldBrush = pDC->SelectObject(&brSelect);
		else
		{
			if(m_nMouseOverSlider == 0)			pOldBrush = pDC->SelectObject(&brFocus);
			else								pOldBrush = pDC->SelectObject(&brNormal);
		}
		pOldPen = pDC->SelectObject(&penBorder);
		rcTemp.SetRect(1, m_nMinPi-RXSZ_LOCAL_GRIP, rect.right-1, m_nMinPi);
		pDC->Rectangle(rcTemp);

		pDC->SelectObject(&penArrow1);
		pDC->MoveTo( 3, rcTemp.top+ 8);
		pDC->LineTo( 7, rcTemp.top+ 4);
		pDC->LineTo(12, rcTemp.top+ 9);

		pDC->SelectObject(&penArrow2);
		pDC->MoveTo( 3, rcTemp.top+ 9);
		pDC->LineTo( 7, rcTemp.top+ 5);
		pDC->LineTo(12, rcTemp.top+10);

		// draw center
		if(m_nMouseCheckSlider == 1)			pOldBrush = pDC->SelectObject(&brSelect);
		else
		{
			if(m_nMouseOverSlider == 1)			pOldBrush = pDC->SelectObject(&brFocus);
			else								pOldBrush = pDC->SelectObject(&brNormal);
		}
		pDC->SelectObject(&penBorder);
		rcTemp.SetRect(1, m_nMinPi-1, rect.right-1, m_nMaxPi+1);
		pDC->Rectangle(rcTemp);

		// draw down
		if(m_nMouseCheckSlider == 2)			pOldBrush = pDC->SelectObject(&brSelect);
		else
		{
			if(m_nMouseOverSlider == 2)			pOldBrush = pDC->SelectObject(&brFocus);
			else								pOldBrush = pDC->SelectObject(&brNormal);
		}
		pDC->SelectObject(&penBorder);
		rcTemp.SetRect(1, m_nMaxPi, rect.right-1, m_nMaxPi+RXSZ_LOCAL_GRIP);
		pDC->Rectangle(rcTemp);

		pDC->SelectObject(&penArrow1);
		pDC->MoveTo( 3, rcTemp.top+ 5);
		pDC->LineTo( 7, rcTemp.top+ 9);
		pDC->LineTo(12, rcTemp.top+ 4);

		pDC->SelectObject(&penArrow2);
		pDC->MoveTo( 3, rcTemp.top+ 4);
		pDC->LineTo( 7, rcTemp.top+ 8);
		pDC->LineTo(12, rcTemp.top+ 3);

		pDC->SelectObject(pOldPen);
		pDC->SelectObject(pOldBrush);
	}
	else
	{
		// draw left
		if(m_nMouseCheckSlider == 0)			pOldBrush = pDC->SelectObject(&brSelect);
		else
		{
			if(m_nMouseOverSlider == 0)			pOldBrush = pDC->SelectObject(&brFocus);
			else								pOldBrush = pDC->SelectObject(&brNormal);
		}
		pOldPen = pDC->SelectObject(&penBorder);
		rcTemp.SetRect(m_nMinPi-RXSZ_LOCAL_GRIP, 1, m_nMinPi, rect.bottom-1);
		pDC->Rectangle(rcTemp);
		pDC->SelectObject(&penArrow1);
		pDC->MoveTo(rcTemp.left+ 8, 3);
		pDC->LineTo(rcTemp.left+ 4, 7);
		pDC->LineTo(rcTemp.left+ 9,12);

		pDC->SelectObject(&penArrow2);
		pDC->MoveTo(rcTemp.left+ 9, 3);
		pDC->LineTo(rcTemp.left+ 5, 7);
		pDC->LineTo(rcTemp.left+10,12);

		// draw center
		if(m_nMouseCheckSlider == 1)			pOldBrush = pDC->SelectObject(&brSelect);
		else
		{
			if(m_nMouseOverSlider == 1)			pOldBrush = pDC->SelectObject(&brFocus);
			else								pOldBrush = pDC->SelectObject(&brNormal);
		}
		pDC->SelectObject(&penBorder);
		rcTemp.SetRect(m_nMinPi-1, 1, m_nMaxPi+1, rect.bottom-1);
		pDC->Rectangle(rcTemp);

		// draw right
		if(m_nMouseCheckSlider == 2)			pOldBrush = pDC->SelectObject(&brSelect);
		else
		{
			if(m_nMouseOverSlider == 2)			pOldBrush = pDC->SelectObject(&brFocus);
			else								pOldBrush = pDC->SelectObject(&brNormal);
		}
		pDC->SelectObject(&penBorder);
		rcTemp.SetRect(m_nMaxPi, 1, m_nMaxPi+RXSZ_LOCAL_GRIP, rect.bottom-1);
		pDC->Rectangle(rcTemp);

		pDC->SelectObject(&penArrow1);
		pDC->MoveTo(rcTemp.left+ 5, 3);
		pDC->LineTo(rcTemp.left+ 9, 7);
		pDC->LineTo(rcTemp.left+ 4,12);

		pDC->SelectObject(&penArrow2);
		pDC->MoveTo(rcTemp.left+ 4, 3);
		pDC->LineTo(rcTemp.left+ 8, 7);
		pDC->LineTo(rcTemp.left+ 3,12);

		pDC->SelectObject(pOldPen);
		pDC->SelectObject(pOldBrush);

	}

	penBorder.DeleteObject();
	penArrow1.DeleteObject();
	penArrow2.DeleteObject();

	brNormal.DeleteObject();
	brFocus.DeleteObject();
	brSelect.DeleteObject();
}

void RxFMWnd::OnNcLButtonDown(UINT nHitTest, CPoint point) 
{
	if(nHitTest == RXHT_CAPTION)
	{
		int		nHitTest_Button;

		if((nHitTest_Button = HitTest_Button(point)) < 0)
		{
			CWnd::OnNcLButtonDown(nHitTest, point);
			return;
		}

		RX_CAPBUTTON	*pButton = (RX_CAPBUTTON *)m_ArrayButton.GetAt(nHitTest_Button);
		if(pButton->wStatus & RXCBS_DISABLED)
		{
			CWnd::OnNcLButtonDown(nHitTest, point);
			return;
		}

		pButton->wStatus = (pButton->wStatus & RXCBS_REMOVE) | RXCBS_SELECT;
		RedrawNCWnd(RXRS_CAPTION);

//		m_nMouseOverButton = -1;
		RxGetMainFrame()->ToolTipHide();
//		KillTimer(MOVER_TIMER_BUTTON);

		BOOL	bCancelLBtnDown = FALSE;
		SetCapture();

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

			switch (msg.message)
			{
				case WM_MOUSEMOVE :
					if(nHitTest_Button == HitTest_Button(msg.pt))
					{
						if(bCancelLBtnDown)
						{
							pButton->wStatus = (pButton->wStatus & RXCBS_REMOVE) | RXCBS_SELECT;
							RedrawNCWnd(RXRS_CAPTION);
							bCancelLBtnDown = FALSE;
						}
					}
					else
					{
						if(!bCancelLBtnDown)
						{
							pButton->wStatus = (pButton->wStatus & RXCBS_REMOVE) | RXCBS_NORMAL;
							RedrawNCWnd(RXRS_CAPTION);
							bCancelLBtnDown = TRUE;
						}
					}
					break;
				case WM_LBUTTONUP :
					goto EndLButtonCaption;
					break;
				default :	// just dispatch rest of the messages
					DispatchMessage(&msg);
					break;
			}
		}

	EndLButtonCaption :
		ReleaseCapture();

		pButton->wStatus = (pButton->wStatus & RXCBS_REMOVE) | RXCBS_NORMAL;
		if(bCancelLBtnDown)
		{
			RedrawNCWnd(RXRS_CAPTION);
			return;
		}

		RedrawNCWnd(RXRS_CAPTION);

		if(!bCancelLBtnDown)
			SendMessage(WM_COMMAND, pButton->nID);
	}
	else if(nHitTest == RXHT_CROP_SLIDER)
	{
		int		nHitTest_Slider = HitTest_Slider(point);

		if(nHitTest_Slider < 0)
		{
			CWnd::OnNcLButtonDown(nHitTest, point);
			return;
		}

		int		nDiff1, nDiff2, nPoint, nOldPoint, nRangeMinPi, nRangeMaxPi;
		CRect	rcWindow;
		GetWindowRect(rcWindow);

		if(m_bSliderVert)
		{
			nRangeMinPi	= RXSZ_LOCAL_BORDER + RXSZ_LOCAL_GRIP;
			nRangeMaxPi	= rcWindow.Height() - RXSZ_CAP_HEIGHT - RXSZ_LOCAL_BORDER - RXSZ_LOCAL_GRIP;
			nPoint		= point.y;
		}
		else
		{
			nRangeMinPi	= RXSZ_LOCAL_BORDER + RXSZ_LOCAL_GRIP;
			nRangeMaxPi	= rcWindow.Width() - RXSZ_LOCAL_BORDER - RXSZ_LOCAL_GRIP;
			nPoint		= point.x;
		}

		if(nHitTest_Slider == 0)
			nDiff1 = nPoint - m_nMinPi;
		else if(nHitTest_Slider == 1)
		{
			nDiff1 = nPoint - m_nMinPi;
			nDiff2 = nPoint - m_nMaxPi;
		}
		else if(nHitTest_Slider == 2)
			nDiff2 = nPoint - m_nMaxPi;

		m_nMouseOverSlider = -1;
		KillTimer(MOVER_TIMER_SLIDER);

		m_nMouseCheckSlider = nHitTest_Slider;
		RedrawNCWnd(RXRS_CROP_SLIDER);

		SetCapture();

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

			switch (msg.message)
			{
				case WM_MOUSEMOVE :
					if(m_bSliderVert)		nPoint = msg.pt.y;
					else					nPoint = msg.pt.x;

					if(nHitTest_Slider == 0)
					{
						nOldPoint = m_nMinPi;

						m_nMinPi = nPoint - nDiff1;
						if(m_nMinPi < nRangeMinPi)
							m_nMinPi = nRangeMinPi;
						if(m_nMinPi > m_nMaxPi)
							m_nMinPi = m_nMaxPi;
						
						if(nOldPoint != m_nMinPi)
						{
							m_nMinPo = PiToPo(m_nMinPi, nRangeMinPi, nRangeMaxPi);
							RedrawNCWnd(RXRS_CROP_SLIDER);
							SendMessage(WM_COMMAND, IDFM_NC_SLIDER_CHANGING);
						}
					}
					else if(nHitTest_Slider == 1)
					{
						nOldPoint = m_nMinPi;

						m_nMinPi = nPoint - nDiff1;
						m_nMaxPi = nPoint - nDiff2;
						if(m_nMinPi < nRangeMinPi)
						{
							m_nMaxPi = nRangeMinPi + (m_nMaxPi-m_nMinPi);
							m_nMinPi = nRangeMinPi;
						}
						else if(m_nMaxPi > nRangeMaxPi)
						{
							m_nMinPi = nRangeMaxPi - (m_nMaxPi-m_nMinPi);
							m_nMaxPi = nRangeMaxPi;
						}

						if(nOldPoint != m_nMinPi)
						{
							m_nMinPo = PiToPo(m_nMinPi, nRangeMinPi, nRangeMaxPi);
							m_nMaxPo = PiToPo(m_nMaxPi, nRangeMinPi, nRangeMaxPi);
							RedrawNCWnd(RXRS_CROP_SLIDER);
							SendMessage(WM_COMMAND, IDFM_NC_SLIDER_CHANGING);
						}
					}
					else if(nHitTest_Slider == 2)
					{
						nOldPoint = m_nMaxPi;

						m_nMaxPi = nPoint - nDiff2;
						if(m_nMaxPi > nRangeMaxPi)
							m_nMaxPi = nRangeMaxPi;
						if(m_nMaxPi < m_nMinPi)
							m_nMaxPi = m_nMinPi;

						if(nOldPoint != m_nMaxPi)
						{
							m_nMaxPo = PiToPo(m_nMaxPi, nRangeMinPi, nRangeMaxPi);
							RedrawNCWnd(RXRS_CROP_SLIDER);
							SendMessage(WM_COMMAND, IDFM_NC_SLIDER_CHANGING);
						}
					}
					break;
				case WM_LBUTTONUP :
					goto EndLButtonSlider;
					break;
				default :	// just dispatch rest of the messages
					DispatchMessage(&msg);
					break;
			}
		}

	EndLButtonSlider :
		m_nMouseCheckSlider = -1;
		RedrawNCWnd(RXRS_CROP_SLIDER);
		SendMessage(WM_COMMAND, IDFM_NC_SLIDER_CHANGED);

		ReleaseCapture();
	}
	
	CWnd::OnNcLButtonDown(nHitTest, point);
}

void RxFMWnd::OnNcMouseMove(UINT nHitTest, CPoint point) 
{
	if(nHitTest == RXHT_CAPTION && m_nMouseOverButton < 0)
	{
		m_nMouseOverButton = HitTest_Button(point);

		if(m_nMouseOverButton > -1)
		{
			RX_CAPBUTTON	*pButton = (RX_CAPBUTTON *)m_ArrayButton.GetAt(m_nMouseOverButton);
			if(!(pButton->wStatus & RXCBS_DISABLED) && !(pButton->wStatus & RXCBS_CHECK))
			{
				pButton->wStatus = (pButton->wStatus & RXCBS_REMOVE) | RXCBS_FOCUS;
				RedrawNCWnd(RXRS_CAPTION);
			}

			SetTimer(MOVER_TIMER_BUTTON, 50, NULL);

			CString		strText;
			if(strText.LoadString(pButton->nID))
			{
				CPoint		ptCursor;
				::GetCursorPos(&ptCursor);
				ptCursor += CPoint(0, GetSystemMetrics(SM_CYCURSOR)/2+4);

				RxGetMainFrame()->ToolTipTrack(ptCursor, strText);
			}
		}
	}
	else if(nHitTest == RXHT_CROP_SLIDER && m_nMouseOverSlider < 0)
	{
		m_nMouseOverSlider = HitTest_Slider(point);

		if(m_nMouseOverSlider > -1)
		{
			RedrawNCWnd(RXRS_CROP_SLIDER);
			SetTimer(MOVER_TIMER_SLIDER, 50, NULL);
		}
	}

	CWnd::OnNcMouseMove(nHitTest, point);
}

void RxFMWnd::OnTimer(UINT nIDEvent) 
{
	if(nIDEvent == MOVER_TIMER_BUTTON)
	{
		POINT		point;
		GetCursorPos(&point);

		if(m_nMouseOverButton != HitTest_Button(point))
		{
			RxGetMainFrame()->ToolTipHide();

			RX_CAPBUTTON	*pButton = (RX_CAPBUTTON *)m_ArrayButton.GetAt(m_nMouseOverButton);
			if(!(pButton->wStatus & RXCBS_DISABLED) && !(pButton->wStatus & RXCBS_CHECK))
			{
				pButton->wStatus = (pButton->wStatus & RXCBS_REMOVE) | RXCBS_NORMAL;
				RedrawNCWnd(RXRS_CAPTION);
			}

			m_nMouseOverButton = -1;
			KillTimer(nIDEvent);
		}
	}
	else if(nIDEvent == MOVER_TIMER_SLIDER)
	{
		POINT		point;
		GetCursorPos(&point);
		int			nMouseOverSlider = HitTest_Slider(point);

		if(m_nMouseOverSlider != nMouseOverSlider)
		{
			m_nMouseOverSlider = nMouseOverSlider;
			RedrawNCWnd(RXRS_CROP_SLIDER);

			if(nMouseOverSlider < 0)
				KillTimer(nIDEvent);
		}
	}

	CWnd::OnTimer(nIDEvent);
}