frametop.cpp

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

// FrameTop.cpp : implementation file
//

#include "stdafx.h"
#include "fusion.h"
#include "FrameTop.h"

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

/////////////////////////////////////////////////////////////////////////////
// RxFrameTop

RxFrameTop::RxFrameTop()
{
	m_nSeparator	= 8;
	m_ptOrigin.x	= 100;			m_ptOrigin.y	= 4;
	m_szButton.cx	= 98;			m_szButton.cy	= 29;

	m_ArrayButton.SetSize(0, 4);

	m_nCaptureID	= -1;
	m_nCurTabID		= -1;
}

RxFrameTop::~RxFrameTop()
{
}


BEGIN_MESSAGE_MAP(RxFrameTop, RxFrameWnd)
	//{{AFX_MSG_MAP(RxFrameTop)
	ON_WM_DESTROY()
	ON_WM_LBUTTONDOWN()
	ON_WM_MOUSEMOVE()
	ON_WM_LBUTTONUP()
	ON_WM_CREATE()
	ON_WM_PAINT()
	//}}AFX_MSG_MAP
	ON_MESSAGE_VOID(UM_INITIALUPDATE,			OnInitialUpdate)
	ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTW, 0, 0xFFFF, OnToolTipNotify)
	ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTA, 0, 0xFFFF, OnToolTipNotify)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// RxFrameTop message handlers

void RxFrameTop::OnInitialUpdate()
{
	EnableToolTips(TRUE);
}

int RxFrameTop::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
	if (RxFrameWnd::OnCreate(lpCreateStruct) == -1)
		return -1;
	
	AddButton(IDF_TOP_LOAD,		IDB_FTOP_BTN_LOAD, TRUE, TRUE);
	AddButton(IDF_TOP_3DFUSION,	IDB_FTOP_BTN_3DFUSION, TRUE, FALSE);
//	AddButton(IDF_TOP_REPORT,	IDB_FTOP_BTN_REPORT);
	
	return 0;
}

void RxFrameTop::OnSwitchToMainMenu(BOOL bActive, int nOldMainMenuID, int nCurMainMenuID)
{
}

void RxFrameTop::OnDestroy() 
{
	RxFrameWnd::OnDestroy();

	RemoveAllButton();
}

/////////////////////////////////////////////////////////////////////////////
// Tooltip Functions.

int RxFrameTop::OnToolHitTest(CPoint point, TOOLINFO* pTI) const
{
	// check child windows first by calling CWnd
	int nHitTest = CWnd::OnToolHitTest(point, pTI);
	if (nHitTest != -1)		return nHitTest;

	RECT	rect;
	nHitTest = HitTest(point, &rect);

	if(nHitTest != -1 && pTI != NULL)
	{
		pTI->hwnd = m_hWnd;
		pTI->rect = rect;
		pTI->uId = nHitTest;
		pTI->lpszText = LPSTR_TEXTCALLBACK;
	}

	// found matching rect, return the ID of the button
	return nHitTest;
}

// show tool tip message
BOOL RxFrameTop::OnToolTipNotify(UINT id, NMHDR * pNMHDR, LRESULT * pResult)
{
	TOOLTIPTEXT *pTTT = (TOOLTIPTEXT *)pNMHDR;
	UINT nID = pNMHDR->idFrom;

	if(nID)
	{
		pTTT->lpszText = MAKEINTRESOURCE(nID);
		pTTT->hinst = AfxGetResourceHandle();
		return TRUE;
	}

	return FALSE;
}

/////////////////////////////////////////////////////////////////////////////
// Mouse events.

void RxFrameTop::OnLButtonDown(UINT nFlags, CPoint point) 
{
	SetCapture();

	m_nCaptureID = HitTest(point);

	RxFrameWnd::OnLButtonDown(nFlags, point);
}

void RxFrameTop::OnMouseMove(UINT nFlags, CPoint point) 
{
	
	RxFrameWnd::OnMouseMove(nFlags, point);
}

void RxFrameTop::OnLButtonUp(UINT nFlags, CPoint point) 
{
	if(GetCapture() == this)
	{
		ReleaseCapture();

		if(m_nCaptureID == HitTest(point) && m_nCaptureID > 0)
		{
			if(SetCurTab(m_nCaptureID))
			{
				NMFT_BUTTON		nmftb;
				nmftb.hdr.hwndFrom	= m_hWnd;
				nmftb.hdr.idFrom	= GetDlgCtrlID();
				nmftb.hdr.code		= FTB_CHANGED;
				nmftb.nCurTab		= m_nCurTabID;

				CWnd* pOwner = GetOwner();
				if (pOwner)
					pOwner->SendMessage(WM_NOTIFY, nmftb.hdr.idFrom, (LPARAM)&nmftb);
			}
		}
	}
	
	RxFrameWnd::OnLButtonUp(nFlags, point);
}

/////////////////////////////////////////////////////////////////////////////
// Draw Functions

void RxFrameTop::OnPaint() 
{
	CPaintDC dc(this); // device context for painting
	
	// fill the background
	CRect	rcClient;
	GetClientRect(rcClient);

	CDC		dcMem;
	CBitmap bmpMem, *pOldBitmap;
	dcMem.CreateCompatibleDC(&dc);
	bmpMem.CreateCompatibleBitmap(&dc, rcClient.Width(), rcClient.Height());
	pOldBitmap = dcMem.SelectObject(&bmpMem);

	int		nGuideLine = rcClient.Height()-m_nSeparator;

	CBrush brush, *pOldBrush;
	brush.CreateSolidBrush(RXCOLOR_10);
	pOldBrush = dcMem.SelectObject(&brush);
	dcMem.PatBlt(rcClient.left, rcClient.top, rcClient.Width(), nGuideLine, PATCOPY);
	dcMem.SelectObject(pOldBrush);
	brush.DeleteObject();

	brush.CreateSolidBrush(RXCOLOR_11);
	pOldBrush = dcMem.SelectObject(&brush);
	dcMem.PatBlt(rcClient.left, nGuideLine, rcClient.Width(), m_nSeparator, PATCOPY);
	dcMem.SelectObject(pOldBrush);
	brush.DeleteObject();

	CPen LinePen0(PS_SOLID, 1, RGB(106,101, 99));
	CPen LinePen1(PS_SOLID, 1, RGB(255,255,255));	

	CPen *pOldPen = dcMem.SelectObject(&LinePen0);
	dcMem.MoveTo(rcClient.left, nGuideLine);	dcMem.LineTo(rcClient.right, nGuideLine);
	dcMem.SelectObject(pOldPen);

	pOldPen = dcMem.SelectObject(&LinePen1);
	dcMem.MoveTo(rcClient.left, nGuideLine+1);	dcMem.LineTo(rcClient.right, nGuideLine+1);
	dcMem.SelectObject(pOldPen);

	LinePen0.DeleteObject();
	LinePen1.DeleteObject();

	// draw tab buttons.
	POINT		ptButton;
	ptButton.x = m_ptOrigin.x;
	ptButton.y = m_ptOrigin.y;

	int		nButtonCount = m_ArrayButton.GetSize();
	for(int i = 0; i < nButtonCount; i++)
	{
		FT_BUTTON	*pButton = (FT_BUTTON *)m_ArrayButton.GetAt(i);
		if(pButton->bShow)
		{
			ptButton.x = m_ptOrigin.x + (m_szButton.cx * i);

			if(pButton->nID == (UINT)m_nCurTabID)
				DrawBitmap(&dcMem, &ptButton, pButton->nBmpID, FTBS_SELECT);
			else
				DrawBitmap(&dcMem, &ptButton, pButton->nBmpID, FTBS_NORMAL);
		}
	}	

	dc.BitBlt(0, 0, rcClient.Width(), rcClient.Height(), &dcMem, 0, 0, SRCCOPY);
	
	// Do not call RxFrameWnd::OnPaint() for painting messages
}

void RxFrameTop::DrawBitmap(CDC *pDC, LPPOINT point, UINT nBmpID, UINT nStatus)
{
	CDC		dcMem;
	dcMem.CreateCompatibleDC(pDC);

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

	pDC->BitBlt(point->x, point->y, m_szButton.cx, m_szButton.cy, &dcMem,
								nStatus * m_szButton.cx, 0, SRCCOPY);

	dcMem.SelectObject(pOldBitmap);

	dcMem.DeleteDC();
}

/////////////////////////////////////////////////////////////////////////////
// Management array variable

void RxFrameTop::AddButton(UINT nID, UINT nBmpID, BOOL bShow, BOOL bEnable)
{
	FT_BUTTON	*pButton = new FT_BUTTON;
	pButton->nID		= nID;
	pButton->nBmpID		= nBmpID;
	pButton->bShow		= bShow;
	pButton->bEnable	= bEnable;

	m_ArrayButton.Add(pButton);
}

void RxFrameTop::EnableButton(int nIndex, BOOL bEnable)
{
	if(nIndex >= 0 && nIndex < m_ArrayButton.GetSize())
		((FT_BUTTON *)m_ArrayButton.GetAt(nIndex))->bEnable = bEnable;
}

int  RxFrameTop::HitTest(CPoint point, LPRECT rect) const
{
	CRect	rcButton;
	rcButton.left	= m_ptOrigin.x;		rcButton.right	= rcButton.left + m_szButton.cx;
	rcButton.top	= m_ptOrigin.y;		rcButton.bottom = rcButton.top  + m_szButton.cy;

	int		nButtonCount = m_ArrayButton.GetSize();
	for(int i = 0; i < nButtonCount; i++)
	{
		FT_BUTTON	*pButton = (FT_BUTTON *)m_ArrayButton.GetAt(i);
		if(pButton->bShow && pButton->bEnable)
		{
			rcButton.left  = m_ptOrigin.x + (m_szButton.cx * i);
			rcButton.right = rcButton.left + m_szButton.cx;

			if(rcButton.PtInRect(point))
			{
				if(rect != NULL)
				{
					rect->left = rcButton.left;		rect->right = rcButton.right;
					rect->top  = rcButton.top;		rect->bottom = rcButton.bottom;
				}

				return pButton->nID;
			}
		}
	}

	return -1;
}

void RxFrameTop::GetButtonRect(UINT nID, LPRECT rect) const
{
	rect->left	= m_ptOrigin.x;		rect->right	 = rect->left + m_szButton.cx;
	rect->top	= m_ptOrigin.y;		rect->bottom = rect->top  + m_szButton.cy;

	int		nButtonCount = m_ArrayButton.GetSize();
	for(int i = 0; i < nButtonCount; i++)
	{
		FT_BUTTON	*pButton = (FT_BUTTON *)m_ArrayButton.GetAt(i);
		if(pButton->bShow)
		{
			rect->left += (m_szButton.cx * i);
			rect->right = rect->left + m_szButton.cx;

			if(pButton->nID == nID)
				return;
		}
	}
}

void RxFrameTop::RemoveAllButton()
{
	for(int i = 0; i < m_ArrayButton.GetSize(); i++)
		delete (FT_BUTTON *)m_ArrayButton.GetAt(i);
	m_ArrayButton.RemoveAll();	
}

/////////////////////////////////////////////////////////////////////////////

BOOL RxFrameTop::SetCurTab(int nTabID)
{
	if(m_nCurTabID == nTabID)
		return FALSE;

	m_nCurTabID = nTabID;

	Invalidate();
	UpdateWindow();

	return TRUE;
}