stkreceiver.cpp.svn-base

股票软件源码

// StkReceiver.cpp : implementation file
//
//		股票行情接收窗口程序
//	
//	
////////////////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "Stockdrv.h"		// 通视卡数据结构定义
#include "Tongshi.h"		// 通视卡使用函数
#include "STKDRVContainer.h"
#include "StkReceiver.h"
#include "SelectEngineDlg.h"

#include "tracetool.h"

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

static	CNetSTKDRV			gNetTSDLL;
static	CSTKDRVContainer	gSTOCKDLL;

CStkReceiver & AfxGetStkReceiver()
{
	static	CStkReceiver	gStkReceiver;
	return gStkReceiver;
}


/////////////////////////////////////////////////////////////////////////////
// CStkReceiver

#define	STKRECEIVER_TIMER_YONGXIN	1

HANDLE CStkReceiver::m_hEventKillProcessThread		=	NULL;
HANDLE CStkReceiver::m_hEventProcessThreadKilled	=	NULL;

CCriticalSection	g_mutexCommPacket;
CPtrArray			g_aptrCommPacket;

WinTrace* pWinTrace = NULL;

// 处理接收到的Report数据的线程
UINT StkProcessReceiveReport(LPVOID pParam)
{
	while (TRUE)
	{
		COMMPACKET * pCommPacket = NULL;
		{
			CSingleLock		lock(&g_mutexCommPacket,TRUE);
			if (g_aptrCommPacket.GetSize() > 0)
			{
				pCommPacket = (COMMPACKET *)g_aptrCommPacket.ElementAt(0);
				g_aptrCommPacket.RemoveAt(0);
			}
		}

		if (NULL != pCommPacket && CStock::dataReport == pCommPacket->m_dwDataType)
		{
			// 修改AfxGetStockContainer()
			for(DWORD i=0; i<pCommPacket->m_dwCount; i++)
				AfxGetStkReceiver().OnReceiveReport(&(pCommPacket->m_pReport[i]));

			// 保存至本地文件
			AfxGetDB().StoreReport(pCommPacket->m_pReport, pCommPacket->m_dwCount, FALSE);

			// 通知各股票信息显示窗口，刷新行情数据
			AfxGetStkReceiver().NotifyWndRcvData(CStock::dataReport, (LPARAM)pCommPacket);

			char szText[256];
			sprintf(szText, "DataCount:%d", pCommPacket->m_dwCount);
			pWinTrace->Debug()->Send("StkProcessReceiveReport", szText);

			// 释放备份数据存储空间
			FreeCommPacket(pCommPacket);
		}

		Sleep(1);

		// User wants to quit program
		if (WAIT_OBJECT_0 == WaitForSingleObject(CStkReceiver::m_hEventKillProcessThread,0))
		{
			{
				CSingleLock		lock(&g_mutexCommPacket,TRUE);
				for(int i=0; i<g_aptrCommPacket.GetSize(); i++)
				{
					pCommPacket = (COMMPACKET *)g_aptrCommPacket.ElementAt(i);
					FreeCommPacket(pCommPacket);
				}
				g_aptrCommPacket.RemoveAll();
			}
			SetEvent(CStkReceiver::m_hEventProcessThreadKilled);
			AfxEndThread(0, TRUE);
			return 0;
		}
	}
}

CStkReceiver::CStkReceiver()
{
	m_bFirst = TRUE;
	m_bTongshiRunning	=	FALSE;

	pWinTrace = new WinTrace("StkReceiver", "StkReceiver");
}

CStkReceiver::~CStkReceiver()
{
	if (pWinTrace)
	{
		delete pWinTrace;
		pWinTrace = NULL;
	}
}

BOOL CStkReceiver::CreateReceiver(CWnd * pParentWnd)
{
	return CreateEx(0,NULL,"",WS_OVERLAPPEDWINDOW|WS_CHILDWINDOW,
		CRect(0,0,0,0),pParentWnd,0,NULL);
}

void CStkReceiver::OnReceiveReport(REPORT * pReport)
{
	CStockContainer & container = AfxGetStockContainer();
	REPORT reportLast;
	if (!UpdateStockContainerByREPORT(container, pReport, TRUE, &reportLast))
		return;

	CStockInfo infoCur;

	// 主力大单
	if (container.GetStockInfo(pReport->m_szCode, &infoCur, NULL))
	{
		if (0 != reportLast.m_time && reportLast.m_time < pReport->m_time
			&& pReport->m_fVolume - reportLast.m_fVolume >= 100000
			&& !infoCur.IsIndex() && !infoCur.IsBond() && !infoCur.IsFund() && !infoCur.IsBondIndex())
		{
			REPORT	report;
			memcpy(&report, pReport, sizeof(report));
			report.m_fVolume	=	pReport->m_fVolume - infoCur.m_reportLatest.m_fVolume;
			report.m_fAmount	=	pReport->m_fAmount - infoCur.m_reportLatest.m_fAmount;
			AfxGetDB().StoreReport(&report, 1, TRUE);
		}
	}

	// 指数发生变化
	if (0 == strncmp(pReport->m_szCode, STKLIB_CODE_MAIN, sizeof(pReport->m_szCode))
		|| 0 == strncmp(pReport->m_szCode, STKLIB_CODE_MAINSZN, sizeof(pReport->m_szCode)))
	{
		NotifyWndRcvAlarm(STKRCV_ALARM_REFRESH, 0);
	}

	// 盘中预警在此处加入
	if (AfxGetAlarmContainer().OnReceiveReport(&infoCur, pReport, &reportLast))
	{
		NotifyWndRcvAlarm(STKRCV_ALARM_WARNING, 0);
	}
}

void CStkReceiver::AddRcvAlarmWnd(HWND hWnd)
{
	m_awndRcvAlarm.Add(hWnd);
}

BOOL CStkReceiver::RemoveRcvAlarmWnd(HWND hWnd)
{
	for(int i=0; i<m_awndRcvAlarm.GetSize(); i++)
	{
		if (m_awndRcvAlarm.ElementAt(i) == hWnd)
		{
			m_awndRcvAlarm.RemoveAt(i,1);
			return TRUE;
		}
	}
	return FALSE;
}

void CStkReceiver::NotifyWndRcvAlarm(WPARAM wParam, LPARAM lParam)
{
	for(int i=0; i<m_awndRcvAlarm.GetSize(); i++)
		::PostMessage(m_awndRcvAlarm[i], WM_APP_STKRECEIVER_ALARM, wParam, lParam);
}

void CStkReceiver::AddRcvDataWnd(HWND hWnd)
{
	m_awndRcvData.Add(hWnd);
}

BOOL CStkReceiver::RemoveRcvDataWnd(HWND hWnd)
{
	for(int i=0; i<m_awndRcvData.GetSize(); i++)
	{
		if (m_awndRcvData.ElementAt(i) == hWnd)
		{
			m_awndRcvData.RemoveAt(i,1);
			return TRUE;
		}
	}
	return FALSE;
}

void CStkReceiver::NotifyWndRcvData(WPARAM wParam, LPARAM lParam)
{
	for(int i=0; i<m_awndRcvData.GetSize(); i++)
		::SendMessage(m_awndRcvData[i], WM_APP_STKRECEIVER_DATA , wParam, lParam);
}



BOOL CStkReceiver::NetEngineBeginWorking()
{
	return SendMessage(WM_APP_STKRECEIVER_CONNECTSERVER);
}

BOOL CStkReceiver::NetEngineBeginWorking(LPCTSTR lpszAddress, UINT nPort, LPCTSTR lpszUser, LPCTSTR lpszPasswd)
{
	if (gNetTSDLL.LoadDriver("NetTS.dll")
		&& gNetTSDLL.Stock_Init_Nodialog(m_hWnd,WM_APP_STKRECEIVER_TSDATA,RCV_WORK_SENDMSG,
					lpszAddress,nPort,lpszUser,lpszPasswd) > 0)
		return TRUE;
	return FALSE;
}

BOOL CStkReceiver::NetEngineEndWorking()
{
	return SendMessage(WM_APP_STKRECEIVER_DISCONNECTSERVER);
}

BOOL CStkReceiver::NetEngineIsWorking()
{
	return gNetTSDLL.IsEngineWorking();
}

BOOL CStkReceiver::NetEngineSetAutoReport(int bAutoReport)
{
	return gNetTSDLL.SetAutoReport(bAutoReport);
}

int CStkReceiver::RequestStockData(int nDataType/*CStock::DataType*/, CStockInfo * pStockInfo, int nSize, int nKType, int nDataCount)
{
	int nDataTypeTS = DataType_to_TSDataType(nDataType);

	if (nSize < 0)
		return 0;

	STOCK_STRUCTEx * pStocks = new STOCK_STRUCTEx[nSize+1];
	memset(pStocks, 0, sizeof(STOCK_STRUCTEx)*(nSize+1));
	
	for(int i=0; i<nSize; i++)
	{
		pStocks[i].m_type = (BYTE)pStockInfo[i].GetType();
		strncpy(pStocks[i].m_code, pStockInfo[i].GetStockCode(), sizeof(pStocks[i].m_code));
	}
	int nRet = gNetTSDLL.RequestStockData(nDataTypeTS, pStocks, nSize, nKType, nDataCount);

	delete [] pStocks;
	return nRet;
}

int	CStkReceiver::RequestKData(CStock *pstock, int period)
{
	int nDataCount = 480;

	CStockInfo & info = pstock->GetStockInfo();
	CKData & kdata = pstock->GetKData(period);

	DWORD dateLatest = info.m_datebegin;
	if (kdata.GetSize() > 0)
		dateLatest = kdata.ElementAt(kdata.GetSize()-1).m_date;
	CSPTime	tmLatest;
	tmLatest.FromStockTime(dateLatest, CKData::IsDayOrMin(period));
	CSPTime tmInitial = CStDatabase::GetTimeInitial();
	if (tmLatest < tmInitial)
		tmLatest	=	tmInitial;
	CSPTime tmNow = CSPTime::GetCurrentTime();
	CSPTimeSpan span = tmNow - tmLatest;
	switch(period)
	{
	case CKData::ktypeDay:		nDataCount = span.GetDays()*5/7+1;	break;
	case CKData::ktypeWeek:		nDataCount = span.GetDays()/7+1;	break;
	case CKData::ktypeMonth:	nDataCount = span.GetDays()/30+1;	break;
	default: ;
	}
	if (nDataCount < 100) nDataCount = 300;
	return RequestStockData(CStock::dataK, &info, 1, period, nDataCount);
}

BOOL CStkReceiver::EngineBeginWorking(BOOL bShowSelectEngineDialog)
{
	return SendMessage(WM_APP_STKRECEIVER_INIT, !bShowSelectEngineDialog);	// 启动通视接收系统
}

BOOL CStkReceiver::EngineSetup()
{
	return SendMessage(WM_APP_STKRECEIVER_SETUP);
}

BOOL CStkReceiver::EngineEndWorking()
{
	return SendMessage(WM_APP_STKRECEIVER_QUIT);
}

BOOL CStkReceiver::EngineIsWorking()
{
	return m_bTongshiRunning;
}

int CStkReceiver::RefreshStockContainer(CStockContainer & container, BOOL bAddIfNotExist)
{
	if (gNetTSDLL.IsEngineWorking() || gNetTSDLL.GetTotalNumber() > 0)
	{
		int	nMaxNumber	=	gNetTSDLL.GetTotalNumber();
		ASSERT(nMaxNumber >= 0);
		if (nMaxNumber <= 0)
			return 0;

		int	nNO	=	0;
		while (TRUE)
		{
			RCV_REPORT_STRUCTEx	tsreport;
			memset(&tsreport,0,sizeof(tsreport));
			int	nRet	=	gNetTSDLL.GetStockByNoEx(nNO, &tsreport);
			if (nRet <= 0)
				break;
			REPORT	report;
			if (convert_TSREPORT_to_REPORT(&tsreport, &report))
				UpdateStockContainerByREPORT(container, &report, bAddIfNotExist);

			nNO	++;
		}
		return nNO;
	}

	if (m_bTongshiRunning)
	{
		int	nMaxNumber	=	gSTOCKDLL.GetTotalNumber();
		ASSERT(nMaxNumber >= 0);
		if (nMaxNumber <= 0)
			return 0;

		int	nNO	=	0;
		while (TRUE)
		{
			RCV_REPORT_STRUCTEx	tsreport;
			memset(&tsreport,0,sizeof(tsreport));
			int	nRet	=	gSTOCKDLL.GetStockByNoEx(nNO, &tsreport);
			if (nRet <= 0)
				break;
			REPORT	report;
			if (convert_TSREPORT_to_REPORT(&tsreport, &report))
				UpdateStockContainerByREPORT(container, &report, bAddIfNotExist);

			nNO	++;
		}
		return nNO;
	}

	return 0;
}

int CStkReceiver::GetReport(CStockInfo &info, CReport &aReport)
{
	if (m_bTongshiRunning)
	{
		int	nMarket	=	SH_MARKET_EX;
		if (info.IsShangHai())
			nMarket	=	SH_MARKET_EX;
		else if (info.IsShenZhen())
			nMarket	=	SZ_MARKET_EX;
		RCV_REPORT_STRUCTEx tsreport;
		REPORT	 report;
		int	nRet	=	gSTOCKDLL.GetStockByCodeEx((char *)info.GetStockCode(), nMarket, &tsreport);
		if (nRet > 0 && 0 == strncmp(info.GetStockCode(),tsreport.m_szLabel,min(strlen(info.GetStockCode()),sizeof(tsreport.m_szLabel)))
			&& convert_TSREPORT_to_REPORT(&tsreport, &report))
		{
			UpdateStockInfoByREPORT(info, &report);
			return 1;
		}
	}

	return 0;
}

BEGIN_MESSAGE_MAP(CStkReceiver, CWnd)
	//{{AFX_MSG_MAP(CStkReceiver)
	ON_WM_CREATE()
	ON_WM_DESTROY()
	//}}AFX_MSG_MAP
	ON_MESSAGE(WM_APP_STKRECEIVER_CONNECTSERVER,OnStkReceiverConnectserver)
	ON_MESSAGE(WM_APP_STKRECEIVER_DISCONNECTSERVER,OnStkReceiverDisconnectserver)
	ON_MESSAGE(WM_APP_STKRECEIVER_INIT,OnStkReceiverInit)
	ON_MESSAGE(WM_APP_STKRECEIVER_SETUP,OnStkReceiverSetup)
	ON_MESSAGE(WM_APP_STKRECEIVER_QUIT,OnStkReceiverQuit)
	ON_MESSAGE(WM_APP_STKRECEIVER_TSDATA,OnStkReceiverTsdata)
END_MESSAGE_MAP()


/////////////////////////////////////////////////////////////////////////////
// CStkReceiver message handlers

int CStkReceiver::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
	if (CWnd::OnCreate(lpCreateStruct) == -1)
		return -1;

	CStkReceiver::m_hEventKillProcessThread = CreateEvent(NULL,FALSE,FALSE,NULL);
	CStkReceiver::m_hEventProcessThreadKilled = CreateEvent(NULL,FALSE,FALSE,NULL);

	AfxBeginThread(StkProcessReceiveReport, NULL, THREAD_PRIORITY_NORMAL);

	return 0;
}

void CStkReceiver::OnDestroy()
{
	OnStkReceiverQuit(0, 0);
	OnStkReceiverDisconnectserver(0, 0);

/*
	// These codes do not work well. system will terminate the thread auto, but cause some memory leaks
	if (CStkReceiver::m_hEventKillProcessThread)
		SetEvent(CStkReceiver::m_hEventKillProcessThread);

	if (WAIT_OBJECT_0 == WaitForSingleObject(CStkReceiver::m_hEventKillProcessThread,2000))
	{
		if (CStkReceiver::m_hEventKillProcessThread)