mainfrm.cpp

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

// MainFrm.cpp : implementation of the RxMainFrame class
//

#include "stdafx.h"
#include "Fusion.h"

#include "MainFrm.h"
#include "Splash.h"

#include "ToolTipCtrl.h"

#include "FrameWnd.h"
#include "FrameTop.h"
#include "FrameBottom.h"
#include "FrameSide.h"
#include "FrameHelp.h"
#include "FrameTuning.h"
#include "FrameMain.h"

#include "FMWnd.h"

#include "rxlocalizermanager.h"

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

/////////////////////////////////////////////////////////////////////////////
// RxMainFrame

IMPLEMENT_DYNAMIC(RxMainFrame, CFrameWnd)

BEGIN_MESSAGE_MAP(RxMainFrame, CFrameWnd)
	//{{AFX_MSG_MAP(RxMainFrame)
	ON_WM_CREATE()
	ON_WM_SETFOCUS()
	ON_WM_GETMINMAXINFO()
	ON_WM_SIZE()
	ON_WM_ACTIVATE()
	ON_WM_ERASEBKGND()
	//}}AFX_MSG_MAP
	ON_MESSAGE_VOID(UM_INITIALUPDATE, OnInitialUpdate)
	ON_NOTIFY(FTB_CHANGED,		RXID_FRAME_TOP,			OnFTTabChanged)
	ON_NOTIFY(FBSB_CHANGED,		RXID_FRAME_BOTTOM,		OnFBSeriesChanged)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// RxMainFrame construction/destruction

RxMainFrame::RxMainFrame()
{
	m_nOldMainMenuID	= -2;
	m_nCurMainMenuID	= -1;

	m_nCurSeries		= -1;

	m_pActiveWnd		= NULL;

	m_bOverlapTuning	= FALSE;
	m_ArrayStatus.SetSize(0, 4);

	m_pWndToolTip		= NULL;

	m_pWndTop			= NULL;
	m_pWndBottom		= NULL;
	m_pWndSide			= NULL;
	m_pWndHelp			= NULL;
	m_pWndTuning		= NULL;
	m_pWndPreset		= NULL;
	m_pWndMain			= NULL;
}

RxMainFrame::~RxMainFrame()
{
	RemoveAllStatus();

	if(m_pWndToolTip)
	{
		m_pWndToolTip->DestroyWindow();
		delete m_pWndToolTip;
	}
}

BOOL RxMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
	if( !CFrameWnd::PreCreateWindow(cs) )
		return FALSE;

	cs.style |= WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
	cs.dwExStyle &= ~WS_EX_CLIENTEDGE;

	// Remove default menu
	if(cs.hMenu!=NULL)
	{
		::DestroyMenu(cs.hMenu);      // delete menu if loaded
		cs.hMenu = NULL;              // no menu for this window
	}

	return TRUE;
}

int RxMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
	// CG: The following line was added by the Splash Screen component.
	RxSplashWnd::ShowSplashScreen(this);

	if (CFrameWnd::OnCreate(lpCreateStruct) == -1)
		return -1;

	// Owner draw caption bar
	m_Caption.Install(this);

	m_pWndToolTip	= new RxToolTipCtrl;
	m_pWndToolTip->Create(this, FALSE);

	UINT		nStyle = WS_CHILD|WS_CLIPCHILDREN|WS_CLIPSIBLINGS;

	// create a top control bar
	m_pWndTop		= new RxFrameTop;
	m_pWndTop->Create		(NULL, NULL, nStyle|WS_VISIBLE, CRect(0,0,0,0), this, RXID_FRAME_TOP);
	m_pWndTop->SetFrameAlign(RXFRAME_ALIGN_TOP);
	m_pWndTop->SetThickness(36);

	// create a bottom control bar
	m_pWndBottom	= new RxFrameBottom;
	m_pWndBottom->Create	(NULL, NULL, nStyle|WS_VISIBLE, CRect(0,0,0,0), this, RXID_FRAME_BOTTOM);
	m_pWndBottom->SetFrameAlign(RXFRAME_ALIGN_BOTTOM);
	m_pWndBottom->SetThickness(37);

	// create a side control bar
	m_pWndSide		= new RxFrameSide;
	m_pWndSide->Create		(NULL, NULL, nStyle, CRect(0,0,0,0), this, RXID_FRAME_SIDE);
	m_pWndSide->SetFrameAlign(RXFRAME_ALIGN_LEFT);
	m_pWndSide->SetThickness(72);

	// create a help control bar
	m_pWndHelp		= new RxFrameHelp;
	m_pWndHelp->Create		(NULL, NULL, nStyle, CRect(0,0,0,0), this, RXID_FRAME_HELP);
	m_pWndHelp->SetFrameAlign(RXFRAME_ALIGN_BOTTOM);
	m_pWndHelp->SetThickness(30);

	m_pWndTuning	= new RxFrameTuning;
	m_pWndTuning->Create	(NULL, NULL, nStyle, CRect(0,0,0,0), this, RXID_FRAME_TUNING);
	m_pWndTuning->SetFrameAlign(RXFRAME_ALIGN_BOTTOM);
	m_pWndTuning->SetThickness(170);

	// create a main window
	m_pWndMain		= new RxFrameMain;
	m_pWndMain->Create		(NULL, NULL, nStyle|WS_VISIBLE, CRect(0,0,0,0), this, RXID_FRAME_MAIN);

	return 0;
}

void RxMainFrame::OnInitialUpdate()
{
	// 檬扁 橇饭烙狼 傈眉 农扁甫 啊瘤绊 乐绰促.
	GetClientRect(m_rcInitialFrame);

	// forward UM_INITIALUPDATE message to child windows
	HWND		hWndChild	= NULL;
	CWnd		*pWnd		= NULL;
	for(hWndChild = ::GetTopWindow(m_hWnd); hWndChild != NULL;
		hWndChild = ::GetNextWindow(hWndChild, GW_HWNDNEXT))
	{
		pWnd = (CWnd *)FromHandlePermanent(hWndChild);
		if(pWnd != NULL)
			pWnd->SendMessage(UM_INITIALUPDATE);
	}
}

BOOL RxMainFrame::OnEraseBkgnd(CDC* pDC) 
{
	
	return TRUE;
}

/////////////////////////////////////////////////////////////////////////////
// RxMainFrame diagnostics

#ifdef _DEBUG
void RxMainFrame::AssertValid() const
{
	CFrameWnd::AssertValid();
}

void RxMainFrame::Dump(CDumpContext& dc) const
{
	CFrameWnd::Dump(dc);
}

#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// RxMainFrame message handlers

void RxMainFrame::OnSetFocus(CWnd* pOldWnd)
{
	// forward focus to the view window
	m_pWndMain->SetFocus();
}

BOOL RxMainFrame::OnCmdMsg(UINT nID, int nCode, void* pExtra, AFX_CMDHANDLERINFO* pHandlerInfo)
{
	if (m_pWndBottom && m_pWndBottom->OnCmdMsg(nID, nCode, pExtra, pHandlerInfo))
		return TRUE;
	// let the view have first crack at the command
	if (m_pWndMain && m_pWndMain->OnCmdMsg(nID, nCode, pExtra, pHandlerInfo))
		return TRUE;

	// otherwise, do default handling
	return CFrameWnd::OnCmdMsg(nID, nCode, pExtra, pHandlerInfo);
}

void RxMainFrame::OnGetMinMaxInfo(MINMAXINFO FAR* lpMMI) 
{
	// set the main frame window's minimum tracking size
	lpMMI->ptMinTrackSize.x = lpMMI->ptMaxTrackSize.x / 2;
	lpMMI->ptMinTrackSize.y = lpMMI->ptMaxTrackSize.y / 2;
	
	CFrameWnd::OnGetMinMaxInfo(lpMMI);
}

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

void RxMainFrame::OnSize(UINT nType, int cx, int cy) 
{
	CFrameWnd::OnSize(nType, cx, cy);

	RecalcFrameWnd(cx, cy);
}

void RxMainFrame::RecalcFrameWnd(int cx, int cy)
{
	CRect	rcFrame(0, 0, cx, cy);

	for (HWND hWndChild = ::GetTopWindow(m_hWnd); hWndChild != NULL;
		hWndChild = ::GetNextWindow(hWndChild, GW_HWNDNEXT))
	{
		RxFrameWnd* pWnd = (RxFrameWnd *)FromHandlePermanent(hWndChild);
		if(pWnd->GetStyle() & WS_VISIBLE)
		{
			UINT	nAlign		= pWnd->GetFrameAlign();
			UINT	nThickness	= pWnd->GetThickness();
			if(nAlign & RXFRAME_ALIGN_TOP)
			{
				pWnd->SetWindowPos(NULL, rcFrame.left, rcFrame.top,
						rcFrame.Width(), nThickness, SWP_FRAMECHANGED|SWP_NOZORDER);
				rcFrame.top += nThickness;
			}
			else if(nAlign & RXFRAME_ALIGN_BOTTOM)
			{
				pWnd->SetWindowPos(NULL, rcFrame.left, rcFrame.bottom-nThickness,
						rcFrame.Width(), nThickness, SWP_FRAMECHANGED|SWP_NOZORDER);
				rcFrame.bottom -= nThickness;
			}
			else if(nAlign & RXFRAME_ALIGN_LEFT)
			{
				pWnd->SetWindowPos(NULL, rcFrame.left, rcFrame.top,
						nThickness, rcFrame.Height(), SWP_FRAMECHANGED|SWP_NOZORDER);
				rcFrame.left += nThickness;
			}
			else if(nAlign & RXFRAME_ALIGN_RIGHT)
			{
				pWnd->SetWindowPos(NULL, rcFrame.right-nThickness, rcFrame.top,
						nThickness, rcFrame.Height(), SWP_FRAMECHANGED|SWP_NOZORDER);
				rcFrame.right -= nThickness;
			}
			else
				pWnd->SetWindowPos(NULL, rcFrame.left, rcFrame.top,
						rcFrame.Width(), rcFrame.Height(), SWP_FRAMECHANGED|SWP_NOZORDER);
		}
	}

	UpdateWindow();
}

void RxMainFrame::GetFrameRectTop(CRect &rect)
{
	rect = m_rcInitialFrame;
	rect.bottom = m_pWndTop->GetThickness();
}

void RxMainFrame::GetFrameRectSide(CRect &rect)
{
	rect = m_rcInitialFrame;
	rect.right = m_pWndSide->GetThickness();
}

void RxMainFrame::GetFrameRectBottom(CRect &rect)
{
	rect = m_rcInitialFrame;
	rect.bottom = m_pWndBottom->GetThickness();
}

void RxMainFrame::GetFrameRectTuning(CRect &rect)
{
	rect = m_rcInitialFrame;
	rect.right -= (m_pWndSide->GetThickness()   + 4);
	rect.bottom = (m_pWndTuning->GetThickness() - 4);
}

void RxMainFrame::GetFrameRectMain(CRect &rect)
{
	rect = m_rcInitialFrame;
	rect.right  = m_rcInitialFrame.right  - 4;
	rect.bottom = m_rcInitialFrame.bottom - m_pWndTop->GetThickness() - m_pWndBottom->GetThickness() - 4;

	_FSTATUS	*pStatus = GetStatus(m_nCurMainMenuID);

	if(pStatus->nSide)
		rect.right -= m_pWndSide->GetThickness();

	if(!m_bOverlapTuning)
	{
		if(pStatus->nHelp)
			rect.bottom -= m_pWndHelp->GetThickness();
		if(pStatus->nTP > 0 && m_nCurSeries != RXSERIES_COM)
			rect.bottom -= m_pWndTuning->GetThickness();
	}
}

void RxMainFrame::GetFMWndRectLoad(CRect &rect)
{
	rect		= m_rcInitialFrame;
	rect.bottom -= (m_pWndTop->GetThickness() + m_pWndBottom->GetThickness() + 4);
	rect.right  -= 4;
}

/////////////////////////////////////////////////////////////////////////////
// main tab management

void RxMainFrame::OnFTTabChanged(NMHDR* pNMHDR, LRESULT* pResult)
{
	NMFT_BUTTON		*pNMFT = (NMFT_BUTTON *)pNMHDR;

	SetCurMainMenu(pNMFT->nCurTab, FALSE);

	*pResult = 0;
}

BOOL RxMainFrame::SetCurMainMenu(int nID, BOOL bWithControl)
{
	if(m_nCurMainMenuID == nID)
		return FALSE;

	m_nOldMainMenuID = m_nCurMainMenuID;
	m_nCurMainMenuID = nID;

	//
	HWND		hWndChild;
	RxFrameWnd	*pWnd;

	for (hWndChild = ::GetTopWindow(m_hWnd); hWndChild != NULL;
		hWndChild = ::GetNextWindow(hWndChild, GW_HWNDNEXT))
	{
		pWnd = (RxFrameWnd *)FromHandlePermanent(hWndChild);
		pWnd->OnSwitchToMainMenu(FALSE, m_nOldMainMenuID, m_nCurMainMenuID);
	}

	// frame top 俊 困摹茄 滚瓢甸阑 汲沥秦 霖促.
	if(bWithControl)
		m_pWndTop->SetCurTab(m_nCurMainMenuID);

	// frame 葛剧阑 犁备己茄促.
	SwitchToStatus(m_nCurMainMenuID);

	//
	for (hWndChild = ::GetTopWindow(m_hWnd); hWndChild != NULL;
		hWndChild = ::GetNextWindow(hWndChild, GW_HWNDNEXT))
	{
		pWnd = (RxFrameWnd *)FromHandlePermanent(hWndChild);
		pWnd->OnSwitchToMainMenu(TRUE, m_nOldMainMenuID, m_nCurMainMenuID);
	}

	return TRUE;
}

/////////////////////////////////////////////////////////////////////////////
// series index management

void RxMainFrame::OnFBSeriesChanged(NMHDR* pNMHDR, LRESULT* pResult)
{
	NMFB_SERIES_BUTTON	*pNMFBSB = (NMFB_SERIES_BUTTON *)pNMHDR;

	SetCurSeries(pNMFBSB->nCurSeries, FALSE);

	*pResult = 0;
}

BOOL RxMainFrame::SetCurSeries(int nCurSeries, BOOL bWithControl)
{
	if(m_nCurSeries == nCurSeries)
		return FALSE;

	m_nCurSeries = nCurSeries;

	// frame bottom 俊 困摹茄 滚瓢甸阑 汲沥秦 霖促.
	if(bWithControl)
		m_pWndBottom->SetRadioSeries(m_nCurSeries);

	if(m_nCurMainMenuID == IDF_TOP_3DFUSION)
	{
		SwitchToStatus(m_nCurMainMenuID);
		// frame tuning 俊 困摹茄 Control甸狼 蔼阑 犁汲沥茄促.
		m_pWndTuning->OnChangedSeries(m_nCurSeries);
		m_pWndBottom->UpdateWindowing(TRUE);
		m_pWndMain->Frame3DF_OnChangedSeries(m_nCurSeries);
	}

	// series 啊 官拆锭 zoom factor甫 炼例秦霖促.
	if(m_pWndMain->GetLocalizerManager(m_nCurSeries))
	{
		m_pWndMain->GetLocalizerManager(m_nCurSeries)->DetermineZoomFactor();
		m_pWndMain->GetLocalizerManager(m_nCurSeries)->RedrawAll();
	}

	return TRUE;
}

/////////////////////////////////////////////////////////////////////////////
// Active Window management

void RxMainFrame::OnActivate(UINT nState, CWnd* pWndOther, BOOL bMinimized) 
{
	CFrameWnd::OnActivate(nState, pWndOther, bMinimized);

	m_nActiveTop = nState;

	if(m_pActiveWnd)
		m_pActiveWnd->RedrawNCWnd(RXRS_CAPTION);
}

UINT RxMainFrame::IsTopActived()
{
	return m_nActiveTop;
}

void RxMainFrame::SetActiveWnd(RxFMWnd *pWndCur)
{
	RxFMWnd	*pWndOld = m_pActiveWnd;

	if(pWndOld == pWndCur)
		return;				  // do not re-activate if SetActiveWnd called more than once

	m_pActiveWnd = NULL;

	// deactivate the old one
	if (pWndOld != NULL)
		pWndOld->OnActivateWnd(FALSE, pWndCur, pWndOld);

	// if the OnActivateView moves the active window,
	//    that will veto this change
	if (m_pActiveWnd != NULL)
		return;     // already set

	m_pActiveWnd = pWndCur;

	// activate
	if (pWndCur != NULL)
		pWndCur->OnActivateWnd(TRUE, pWndCur, pWndOld);
}

RxFMWnd* RxMainFrame::GetActiveWnd()
{
	return m_pActiveWnd;
}

void RxMainFrame::ToolTipTrack(CPoint point, LPCTSTR lpszText)
{
	m_pWndToolTip->Track(point, lpszText);
}

void RxMainFrame::ToolTipHide()
{
	m_pWndToolTip->Hide();
}

/////////////////////////////////////////////////////////////////////////////
// frame status management

void RxMainFrame::OnOpenDicom()
{
	// extended bottom dialog bar狼 惑怕甫 檬扁拳 秦霖促.
	InitStatus();

	// default combine mode
	SetCurSeries(RXSERIES_COM);

	m_pWndTop->EnableButton(1, TRUE);
	m_pWndMain->OnOpenDicom();
	m_pWndTuning->OnOpenDicom();

	SetCurMainMenu(IDF_TOP_3DFUSION);
}

void RxMainFrame::InitStatus()
{
	if(m_ArrayStatus.GetSize())
		RemoveAllStatus();

	// AddStatus : nID, side frame, help frame, tuning/preset frame
	AddStatus(IDF_TOP_LOAD,		0, 0, 0);
	AddStatus(IDF_TOP_3DFUSION,	1, 0, 1);
	AddStatus(IDF_TOP_REPORT,	1, 0, 0);
}

void RxMainFrame::AddStatus(int nID, int nSide, int nHelp, int nTP)
{
	_FSTATUS	*pStatus	= new _FSTATUS;

	pStatus->nID	= nID;
	pStatus->nSide	= nSide;
	pStatus->nHelp	= nHelp;
	pStatus->nTP	= nTP;

	m_ArrayStatus.Add(pStatus);
}

void RxMainFrame::SwitchToStatus(int nID)
{
	_FSTATUS	*pStatus = GetStatus(nID);

	if(pStatus)
	{
		if(pStatus->nSide)
		{
			m_pWndSide->ShowWindow(SW_SHOW);
		}
		else
			m_pWndSide->ShowWindow(SW_HIDE);

		if(pStatus->nHelp)
		{
			m_pWndHelp->ShowWindow(SW_SHOW);
			m_pWndBottom->SetCheckHelp(TRUE);
		}
		else
		{
			m_pWndHelp->ShowWindow(SW_HIDE);
			m_pWndBottom->SetCheckHelp(FALSE);
		}

		if(pStatus->nTP)
		{
			if(m_nCurSeries == RXSERIES_COM)
				m_pWndTuning->ShowWindow(SW_HIDE);
			else
				m_pWndTuning->ShowWindow(SW_SHOW);
			m_pWndBottom->SetCheckTuning(TRUE);
		}
		else
		{
			m_pWndTuning->ShowWindow(SW_HIDE);
			m_pWndBottom->SetCheckTuning(FALSE);
		}
	}

	CRect	rcClient;
	GetClientRect(rcClient);
	RecalcFrameWnd(rcClient.Width(), rcClient.Height());
}

void RxMainFrame::SetStatusHelp(int nHelp)
{
	_FSTATUS	*pStatus;
	pStatus = GetStatus(m_nCurMainMenuID);

	if(nHelp < 0)
	{
		if(pStatus->nHelp == 0)		nHelp = 1;
		else						nHelp = 0;
	}

	pStatus->nHelp = nHelp;

	SwitchToStatus(m_nCurMainMenuID);
	m_pWndMain->RecalcLayout(FRAME_RECALC_PART);
}

void RxMainFrame::SetStatusTP(int nTP)
{
	_FSTATUS	*pStatus;
	pStatus = GetStatus(m_nCurMainMenuID);

	if(nTP < 0)
	{
		if(pStatus->nTP == 0)			nTP = 1;
		else if(pStatus->nTP == 1)		nTP = 0;
	}

	pStatus->nTP = nTP;

	SwitchToStatus(m_nCurMainMenuID);
	m_pWndMain->RecalcLayout(FRAME_RECALC_PART);
}

_FSTATUS* RxMainFrame::GetStatus(int nID)
{
	int		nCount = m_ArrayStatus.GetSize();

	_FSTATUS	*pStatus;
	for(int i = 0; i < nCount; i++)
	{
		pStatus = (_FSTATUS *)m_ArrayStatus.GetAt(i);
		if(nID == pStatus->nID)
			return pStatus;
	}

	return NULL;
}

void RxMainFrame::RemoveAllStatus()
{
	int		nCount = m_ArrayStatus.GetSize();

	_FSTATUS	*pStatus;
	for(int i = 0; i < nCount; i++)
	{
		pStatus = (_FSTATUS *)m_ArrayStatus.GetAt(i);
		delete pStatus;
	}

	m_ArrayStatus.RemoveAll();
}