#include "pch.h"
|
#include "framework.h"
|
#include "app.h"
|
#include "appDlg.h"
|
#include "afxdialogex.h"
|
#include "level2DataDlg.h"
|
#include "codesDataDlog.h"
|
#include "THSActionUtil.h"
|
#include "NetWorkUtil.h"
|
#include "GUITool.h"
|
#include <direct.h>
|
#ifndef _TOOL_H
|
#define _TOOL_H 1
|
#include "tool.h"
|
#include "TaskChecker.h"
|
#endif
|
#include "JsonUtil.h"
|
#include <exception>
|
|
#include "OcrUtil.h"
|
|
|
|
|
#ifdef _DEBUG
|
#define new DEBUG_NEW
|
#endif
|
#include <string>
|
|
#ifdef _DEBUG
|
#define new DEBUG_NEW
|
#endif
|
#include <Win32Util.h>
|
#include "loginDlg.h"
|
#include <psapi.h>
|
#pragma comment(lib,"psapi.lib")
|
#include "ExcelUtil.h"
|
#include "crashpad.h"
|
#include <GPUtil.h>
|
|
long WINAPI exceptionCallBack(EXCEPTION_POINTERS* ExceptionInfo) {
|
AfxMessageBox(_T("未知异常"));
|
return EXCEPTION_EXECUTE_HANDLER;
|
}
|
|
|
// 用于应用程序“关于”菜单项的 CAboutDlg 对话框
|
|
class CAboutDlg : public CDialogEx
|
{
|
|
public:
|
CAboutDlg();
|
|
// 对话框数据
|
#ifdef AFX_DESIGN_TIME
|
enum { IDD = IDD_ABOUTBOX };
|
#endif
|
|
protected:
|
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV 支持
|
|
// 实现
|
protected:
|
DECLARE_MESSAGE_MAP()
|
public:
|
afx_msg void OnBnClickedCheck5();
|
};
|
|
CAboutDlg::CAboutDlg() : CDialogEx(IDD_ABOUTBOX)
|
{
|
}
|
|
void CAboutDlg::DoDataExchange(CDataExchange* pDX)
|
{
|
CDialogEx::DoDataExchange(pDX);
|
}
|
|
BEGIN_MESSAGE_MAP(CAboutDlg, CDialogEx)
|
|
END_MESSAGE_MAP()
|
|
|
// CappDlg 对话框
|
|
RecognitionManager* CappDlg::recognitionManager;
|
RecognitionManager* CappDlg::recognitionManager_L2Code;
|
|
set<Authority> CappDlg::authoritySet;
|
//客户端编号
|
int CappDlg::clientNum;
|
|
CappDlg::CappDlg(CWnd* pParent /*=nullptr*/)
|
: CDialogEx(IDD_APP_DIALOG, pParent)
|
{
|
|
//SetUnhandledExceptionFilter(exceptionCallBack);
|
initCrashPad();
|
|
loginWin = pParent;
|
m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
|
|
socketManager = new SocketManager(CappDlg::OnActionCallback, this);
|
RecognitionUtil::init();
|
ImgUtil::init();
|
//设置安装根路径
|
char* rootpath;
|
if ((rootpath = _getcwd(NULL, 0)) == NULL) {
|
}
|
else {
|
string path = string(rootpath).append("\\");
|
OpenCLExcuter::rootPath = path;
|
}
|
std::cout << "rootpath:" << rootpath << std::endl;
|
|
|
capture = new L2DataCapture();
|
recognitionManager = new RecognitionManager();
|
recognitionManager_L2Code = new RecognitionManager();
|
|
limitUpCapture = new LimitUpCapture();
|
tradeListCapture = new TradeListCapture();
|
industryCapture = new IndustryCapture();
|
gpDataCapture = new THSGPDataCapture();
|
currentPriceCapture = new CurrentPriceCapture();
|
thsL2RepairTool = new THSL2RepairTool();
|
tradeQueueCaptureManager = new TradeQueueCaptureManager;
|
dxjlCapture = new THSDXJLCapture();
|
}
|
|
void CappDlg::DoDataExchange(CDataExchange* pDX)
|
{
|
CDialogEx::DoDataExchange(pDX);
|
DDX_Control(pDX, IDC_CHECK2, limitUpUpload);
|
DDX_Control(pDX, IDC_BUTTON12, limitUpBtn);
|
DDX_Control(pDX, IDC_BUTTON_TRADE, tradeBtn);
|
DDX_Control(pDX, IDC_INDUSTRY, industryBtn);
|
DDX_Control(pDX, IDC_BUTTON5, btnL2);
|
DDX_Control(pDX, IDC_BUTTON8, uploadGPBtn);
|
DDX_Control(pDX, IDC_BUTTON_TRADE_DELEGATE, delegateBtn);
|
DDX_Control(pDX, IDC_CHECK5, tradeTimeCaptureCheck);
|
DDX_Control(pDX, IDC_BUTTON22, refreshHWNDBtn);
|
DDX_Control(pDX, IDC_BUTTON21, resetTHSBtn);
|
DDX_Control(pDX, IDC_CHECK6, autoL2Check);
|
DDX_Control(pDX, IDC_CURRENT_PRICE, currentPriceBtn);
|
DDX_Control(pDX, IDC_STATIC_AUTO_MSG, autoMsgStatic);
|
DDX_Control(pDX, IDC_CHECK_PRICE_TIME_LIMIT, priceTimeLimitCheck);
|
DDX_Control(pDX, IDC_CHECK_TRADE_TIME_TRADE_SUCCESS, tradeSuccessTimeCheck);
|
DDX_Control(pDX, IDC_CHECK_TRADE_TIME_DELEGATE, delegateTimeCheck);
|
DDX_Control(pDX, IDC_CHECK_TRADE_TIME_LIMIT_UP, limitUpTimeCheck);
|
DDX_Control(pDX, IDC_CHECK_BUY1_VOLUMN_TIME_LIMIT, buy1VolumnTimeLimitCheck);
|
DDX_Control(pDX, IDC_BUTTON_BUY_1_VOLUMN, buy1VolumnBtn);
|
DDX_Control(pDX, IDC_CHECK_ONLINE, onlineCheck);
|
DDX_Control(pDX, IDC_BUTTON_UPLOAD_GPCODE, uploadGPCodeBtn);
|
DDX_Control(pDX, IDC_BUTTON_GP_CODE_ADD, addGPCodeBtn);
|
}
|
|
BEGIN_MESSAGE_MAP(CappDlg, CDialogEx)
|
ON_WM_SYSCOMMAND()
|
ON_WM_PAINT()
|
ON_WM_QUERYDRAGICON()
|
ON_BN_CLICKED(IDC_BUTTON6, &CappDlg::OnBnClickedButton6)
|
ON_BN_CLICKED(IDC_BUTTON10, &CappDlg::OnBnClickedButton10)
|
ON_BN_CLICKED(IDC_BUTTON9, &CappDlg::OnBnClickedButton9)
|
ON_BN_CLICKED(IDC_BUTTON4, &CappDlg::OnBnClickedButton4)
|
ON_BN_CLICKED(IDC_BUTTON20, &CappDlg::OnBnClickedButton20)
|
ON_BN_CLICKED(IDC_BUTTON5, &CappDlg::OnBnClickedButton5)
|
ON_BN_CLICKED(IDC_BUTTON7, &CappDlg::OnBnClickedButton7)
|
ON_BN_CLICKED(IDC_BUTTON8, &CappDlg::OnBnClickedButton8)
|
ON_BN_CLICKED(IDC_BUTTON12, &CappDlg::OnBnClickedButton12)
|
ON_BN_CLICKED(IDC_BUTTON_TRADE, &CappDlg::OnBnClickedButtonTrade)
|
ON_BN_CLICKED(IDC_INDUSTRY, &CappDlg::OnBnClickedIndustry)
|
ON_BN_CLICKED(IDC_BUTTON_TRADE_DELEGATE, &CappDlg::OnBnClickedButtonTradeDelegate)
|
ON_BN_CLICKED(IDC_BUTTON_TEST, &CappDlg::OnBnClickedButtonTest)
|
ON_BN_CLICKED(IDC_CHECK5, &CappDlg::OnBnClickedCheck5)
|
ON_BN_CLICKED(IDC_BUTTON21, &CappDlg::OnBnClickedButton21)
|
ON_BN_CLICKED(IDC_BUTTON22, &CappDlg::OnBnClickedButton22)
|
ON_BN_CLICKED(IDC_LOGOUT_BTN, &CappDlg::OnBnClickedLogoutBtn)
|
ON_BN_CLICKED(IDC_CHECK6, &CappDlg::OnBnClickedCheck6)
|
ON_BN_CLICKED(IDC_CURRENT_PRICE, &CappDlg::OnBnClickedCurrentPrice)
|
ON_BN_CLICKED(IDC_BUTTON_THS, &CappDlg::OnBnClickedButtonThs)
|
ON_BN_CLICKED(IDC_CHECK_TRADE_TIME_LIMIT_UP, &CappDlg::OnBnClickedCheckTradeTimeLimitUp)
|
ON_BN_CLICKED(IDC_CHECK_TRADE_TIME_TRADE_SUCCESS, &CappDlg::OnBnClickedCheckTradeTimeTradeSuccess)
|
ON_BN_CLICKED(IDC_CHECK_TRADE_TIME_DELEGATE, &CappDlg::OnBnClickedCheckTradeTimeDelegate)
|
ON_BN_CLICKED(IDC_CHECK_PRICE_TIME_LIMIT, &CappDlg::OnBnClickedCheckPriceTimeLimit)
|
ON_BN_CLICKED(IDC_BUTTON_BUY_1_VOLUMN, &CappDlg::OnBnClickedButtonBuy1Volumn)
|
ON_BN_CLICKED(IDC_BUTTON_UPLOAD_GPCODE, &CappDlg::OnBnClickedButtonUploadGpcode)
|
ON_BN_CLICKED(IDC_CHECK_BUY1_VOLUMN_TIME_LIMIT, &CappDlg::OnBnClickedCheckBuy1VolumnTimeLimit)
|
ON_BN_CLICKED(IDC_BUTTON_GP_CODE_ADD, &CappDlg::OnBnClickedButtonGpCodeAdd)
|
END_MESSAGE_MAP()
|
|
|
// CappDlg 消息处理程序
|
|
BOOL CappDlg::OnInitDialog()
|
{
|
CDialogEx::OnInitDialog();
|
|
// 将“关于...”菜单项添加到系统菜单中。
|
|
// IDM_ABOUTBOX 必须在系统命令范围内。
|
ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
|
ASSERT(IDM_ABOUTBOX < 0xF000);
|
|
CMenu* pSysMenu = GetSystemMenu(FALSE);
|
if (pSysMenu != nullptr)
|
{
|
BOOL bNameValid;
|
CString strAboutMenu;
|
bNameValid = strAboutMenu.LoadString(IDS_ABOUTBOX);
|
ASSERT(bNameValid);
|
if (!strAboutMenu.IsEmpty())
|
{
|
pSysMenu->AppendMenu(MF_SEPARATOR);
|
pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
|
}
|
}
|
|
// 设置此对话框的图标。 当应用程序主窗口不是对话框时，框架将自动
|
// 执行此操作
|
SetIcon(m_hIcon, TRUE); // 设置大图标
|
SetIcon(m_hIcon, FALSE); // 设置小图标
|
|
// 默认选中
|
((CButton*)GetDlgItem(IDC_CHECK1))->SetCheck(TRUE);
|
((CButton*)GetDlgItem(IDC_CHECK2))->SetCheck(TRUE);
|
((CButton*)GetDlgItem(IDC_CHECK3))->SetCheck(TRUE);
|
((CButton*)GetDlgItem(IDC_CHECK4))->SetCheck(TRUE);
|
tradeTimeCaptureCheck.SetCheck(TRUE);
|
L2DataCapture::setTradeTimeCapture(true);
|
|
limitUpTimeCheck.SetCheck(TRUE);
|
LimitUpCapture::setTradeTimeCapture(limitUpTimeCheck.GetCheck());
|
|
tradeSuccessTimeCheck.SetCheck(TRUE);
|
TradeListCapture::setTradeTimeCapture_success(tradeSuccessTimeCheck.GetCheck());
|
|
delegateTimeCheck.SetCheck(TRUE);
|
TradeListCapture::setTradeTimeCapture_delegate(delegateTimeCheck.GetCheck());
|
|
priceTimeLimitCheck.SetCheck(TRUE);
|
CurrentPriceCapture::setTradeTimeCapture(TRUE);
|
|
|
buy1VolumnTimeLimitCheck.SetCheck(TRUE);
|
TradeQueueCaptureManager::setTradeTimeCapture(buy1VolumnTimeLimitCheck.GetCheck());
|
|
onlineCheck.SetCheck(TRUE);
|
|
|
|
|
//是否自动开启功能
|
bool autoOpen = FALSE;
|
list<string> settings = Tool::getSettings("setting.txt");
|
if (settings.size() > 0) {
|
string c = *(settings.begin());
|
if (c == "1") {
|
autoOpen = TRUE;
|
}
|
else {
|
autoMsgStatic.SetWindowTextW(_T(""));
|
autoL2Check.SetCheck(FALSE);
|
}
|
}
|
if (autoOpen) {
|
autoL2Check.SetCheck(TRUE);
|
}
|
|
if (authoritySet.count(AUTHORITY_L2) > 0) {
|
onlineCheck.SetCheck(FALSE);
|
btnL2.EnableWindow(TRUE);
|
resetTHSBtn.EnableWindow(TRUE);
|
refreshHWNDBtn.EnableWindow(TRUE);
|
onlineCheck.EnableWindow(TRUE);
|
if (autoOpen) {
|
autoMsgStatic.SetWindowTextW(_T("正在自动启动中..."));
|
thread rt(&(CappDlg::autoStartL2), this);
|
rt.detach();
|
}
|
}
|
else {
|
btnL2.EnableWindow(FALSE);
|
resetTHSBtn.EnableWindow(FALSE);
|
refreshHWNDBtn.EnableWindow(FALSE);
|
onlineCheck.EnableWindow(FALSE);
|
}
|
|
if (authoritySet.count(AUTHORITY_LIMIT_UP) > 0) {
|
limitUpBtn.EnableWindow(TRUE);
|
//自动开启涨停
|
if (autoOpen) {
|
//等待同花顺主屏是否打开
|
autoMsgStatic.SetWindowTextW(_T("正在等待THS主屏启动..."));
|
for (int i = 0; i < 10; i++) {
|
HWND hwnd = THSActionUtil::getMainWin();
|
Sleep(1000);
|
if (hwnd > 0) {
|
break;
|
}
|
}
|
autoMsgStatic.SetWindowTextW(_T("等待打开副屏1..."));
|
|
for (int i = 0; i < 5; i++) {
|
HWND second = THSActionUtil::getSecondWindow();
|
if (second > 0) {
|
break;
|
}
|
THSActionUtil::openSecondScreen();
|
Sleep(1000);
|
}
|
|
autoMsgStatic.SetWindowTextW(_T("副屏1已打开..."));
|
Sleep(1000);
|
// 开启 涨停识别
|
autoMsgStatic.SetWindowTextW(_T("启动涨停识别中..."));
|
CappDlg::OnBnClickedButton12();
|
autoMsgStatic.SetWindowTextW(_T("启动涨停启动成功"));
|
|
// 开启委托识别
|
|
// 开启交易成功识别
|
|
|
|
}
|
}
|
else {
|
limitUpBtn.EnableWindow(FALSE);
|
}
|
|
if (authoritySet.count(AUTHORITY_TRADE_SUCCESS) > 0) {
|
tradeBtn.EnableWindow(TRUE);
|
if (autoOpen) {
|
//自动打开交易成功页面成功
|
HWND hwnd = THSActionUtil::getTradeSuccessWindow();
|
if (hwnd <= 0) {
|
//打开交易成功页面，在主屏上按F12
|
HWND mainWin = THSActionUtil::getMainWin();
|
if (mainWin > 0) {
|
Win32Util::sendMessage(mainWin, WM_KEYDOWN, VK_F12, 0);
|
Win32Util::sendMessage(mainWin, WM_KEYUP, VK_F12, 0);
|
//等待页面打开
|
for (int i = 0; i < 10; i++) {
|
hwnd = THSActionUtil::getTradeSuccessWindow();
|
Sleep(1000);
|
if (hwnd > 0) {
|
break;
|
}
|
}
|
}
|
}
|
|
if (hwnd > 0) {
|
//交易页面打开
|
THSActionUtil::openTradeSuccessScreen();
|
//启动交易成功识别
|
OnBnClickedButtonTrade();
|
}
|
}
|
}
|
else {
|
tradeBtn.EnableWindow(FALSE);
|
}
|
|
|
if (authoritySet.count(AUTHORITY_TRADE_DELEGATE) > 0) {
|
delegateBtn.EnableWindow(TRUE);
|
currentPriceBtn.EnableWindow(TRUE);
|
if (autoOpen) {
|
thread rt1(&(CappDlg::autoStartTradeDelegate), this);
|
rt1.detach();
|
thread rt2(&(CappDlg::autoStartCurrentPrice), this);
|
rt2.detach();
|
}
|
}
|
else {
|
delegateBtn.EnableWindow(FALSE);
|
currentPriceBtn.EnableWindow(FALSE);
|
}
|
|
|
|
if (authoritySet.count(AUTHORITY_THS_INDUSTRY) > 0) {
|
industryBtn.EnableWindow(TRUE);
|
}
|
else {
|
industryBtn.EnableWindow(FALSE);
|
}
|
|
if (authoritySet.count(AUTHORITY_UPLOAD_CODE) > 0) {
|
uploadGPBtn.EnableWindow(FALSE);
|
addGPCodeBtn.EnableWindow(TRUE);
|
uploadGPCodeBtn.EnableWindow(TRUE);
|
}
|
else {
|
uploadGPBtn.EnableWindow(FALSE);
|
addGPCodeBtn.EnableWindow(FALSE);
|
uploadGPCodeBtn.EnableWindow(FALSE);
|
}
|
|
|
if (authoritySet.count(AUTHORITY_TRADE_QUEUE) > 0) {
|
buy1VolumnBtn.EnableWindow(TRUE);
|
if (autoOpen) {
|
thread rt3(&(CappDlg::autoStartBuy1Volumn), this);
|
rt3.detach();
|
}
|
}
|
else {
|
buy1VolumnBtn.EnableWindow(FALSE);
|
}
|
|
|
CString st;
|
|
CString idStr(to_string(clientNum).c_str());
|
|
st.Format(_T("客户端ID：%s"), idStr);
|
GetDlgItem(IDC_STATIC3)->SetWindowTextW(st);
|
|
//loginWin->DestroyWindow();
|
//隐藏父窗口
|
loginWin->ShowWindow(SW_HIDE);
|
|
//启动心跳
|
thread rt(&(CappDlg::onHeartbeat));
|
rt.detach();
|
|
return TRUE; // 除非将焦点设置到控件，否则返回 TRUE
|
}
|
|
void CappDlg::OnSysCommand(UINT nID, LPARAM lParam)
|
{
|
if ((nID & 0xFFF0) == IDM_ABOUTBOX)
|
{
|
CAboutDlg dlgAbout;
|
dlgAbout.DoModal();
|
}
|
else
|
{
|
CDialogEx::OnSysCommand(nID, lParam);
|
// 关闭按钮退出应用
|
if (nID == 61536) {
|
exit(0);
|
}
|
}
|
}
|
|
|
// 如果向对话框添加最小化按钮，则需要下面的代码
|
// 来绘制该图标。 对于使用文档/视图模型的 MFC 应用程序，
|
// 这将由框架自动完成。
|
|
void CappDlg::OnPaint()
|
{
|
if (IsIconic())
|
{
|
CPaintDC dc(this); // 用于绘制的设备上下文
|
|
SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);
|
|
// 使图标在工作区矩形中居中
|
int cxIcon = GetSystemMetrics(SM_CXICON);
|
int cyIcon = GetSystemMetrics(SM_CYICON);
|
CRect rect;
|
GetClientRect(&rect);
|
int x = (rect.Width() - cxIcon + 1) / 2;
|
int y = (rect.Height() - cyIcon + 1) / 2;
|
|
// 绘制图标
|
dc.DrawIcon(x, y, m_hIcon);
|
}
|
else
|
{
|
CDialogEx::OnPaint();
|
}
|
}
|
|
|
//当用户拖动最小化窗口时系统调用此函数取得光标
|
//显示。
|
HCURSOR CappDlg::OnQueryDragIcon()
|
{
|
return static_cast<HCURSOR>(m_hIcon);
|
}
|
|
|
void CappDlg::OnL2DataCallback(int index, string code, long captureTime, long processTime, list<TradeData*> dataList, void* context) {
|
clock_t time_start = clock();
|
//转为json
|
CappDlg* app = (CappDlg*)context;
|
//cout << "回调:" << std::this_thread::get_id() << ":" << index << endl;
|
CButton* btn = (CButton*)app->GetDlgItem(IDC_CHECK1);
|
bool check = btn->GetCheck();
|
if (check) {
|
if (index == 0)
|
{
|
cout << "\n*****状态判断用时*****：" << (clock() - time_start) << endl;
|
}
|
time_start = clock();
|
string data = JsonUtil::loadL2Data(app->clientNum, index, code, captureTime, processTime, dataList);
|
for (list<TradeData*>::iterator el = dataList.begin(); el != dataList.end(); ++el) {
|
delete (*el);
|
}
|
dataList.clear();
|
if (index == 0)
|
{
|
cout << "\n*****组装数据处理用时*****：" << (clock() - time_start) << endl;
|
}
|
|
time_start = clock();
|
try {
|
app->socketManager->sendMsg(index, data.c_str());
|
}
|
catch (string st) {
|
//重新连接服务器
|
app->socketManager->resetClient(index);
|
app->socketManager->Connect(index);
|
}
|
if (index == 0)
|
{
|
cout << "\n*****服务端数据处理时间*****：" << (clock() - time_start) << endl;
|
}
|
}
|
}
|
|
void CappDlg::OnTradeQueueDataCallback(int index, string code, L2TradeQueue tradeQueue, void* context) {
|
//转为json
|
CappDlg* app = (CappDlg*)context;
|
//cout << "回调:" << std::this_thread::get_id() << ":" << index << endl;
|
CButton* btn = (CButton*)app->GetDlgItem(IDC_CHECK1);
|
bool check = btn->GetCheck();
|
if (check) {
|
string data = JsonUtil::loadTradeQueueData(app->clientNum, index, code, tradeQueue);
|
clock_t time_start = clock();
|
try {
|
app->socketManager->sendMsg(index + 9, data.c_str());
|
}
|
catch (string st) {
|
//重新连接服务器
|
app->socketManager->resetClient(index + 9);
|
app->socketManager->Connect(index + 9);
|
}
|
//cout << "*****数据处理时间：" << (clock() - time_start) << endl;
|
}
|
}
|
|
|
|
void CappDlg::OnLimitUpDataCallback(list<LimitUpData> dataList, void* context) {
|
//转为json
|
CappDlg* app = (CappDlg*)context;
|
//cout << "回调:" << std::this_thread::get_id() << ":" << index << endl;
|
CButton* btn = (CButton*)app->GetDlgItem(IDC_CHECK2);
|
bool check = btn->GetCheck();
|
if (check) {
|
string data = JsonUtil::loadLimitUpData(dataList);
|
clock_t time_start = clock();
|
try {
|
app->socketManager->sendMsg(8, data.c_str());
|
}
|
catch (string st) {
|
//重新连接服务器
|
app->socketManager->resetClient(8);
|
app->socketManager->Connect(8);
|
}
|
cout << "####涨停数据处理时间：" << (clock() - time_start) << endl;
|
}
|
}
|
|
void CappDlg::OnLimitUpFirstDataCallback(list<FirstLimitUpCodeData> dataList, void* context) {
|
|
//转为json
|
CappDlg* app = (CappDlg*)context;
|
//cout << "回调:" << std::this_thread::get_id() << ":" << index << endl;
|
CButton* btn = (CButton*)app->GetDlgItem(IDC_CHECK2);
|
bool check = btn->GetCheck();
|
if (check) {
|
string data = JsonUtil::loadFirstLimitUpData(dataList);
|
clock_t time_start = clock();
|
try {
|
app->socketManager->sendMsg(8, data.c_str());
|
}
|
catch (string st) {
|
//重新连接服务器
|
app->socketManager->resetClient(8);
|
app->socketManager->Connect(8);
|
}
|
cout << "####首板数据处理时间：" << (clock() - time_start) << endl;
|
}
|
|
}
|
|
|
void CappDlg::OnTradeSuccessDataCallback(list<TradeSuccessData> dataList, void* context) {
|
//转为json
|
CappDlg* app = (CappDlg*)context;
|
//cout << "回调:" << std::this_thread::get_id() << ":" << index << endl;
|
CButton* btn = (CButton*)app->GetDlgItem(IDC_CHECK3);
|
bool check = btn->GetCheck();
|
if (check) {
|
string data = JsonUtil::loadTradeSuccessData(dataList);
|
clock_t time_start = clock();
|
try {
|
app->socketManager->sendMsg(8, data.c_str());
|
}
|
catch (string st) {
|
//重新连接服务器
|
app->socketManager->resetClient(8);
|
app->socketManager->Connect(8);
|
}
|
cout << "####交易成功数据处理时间：" << (clock() - time_start) << endl;
|
}
|
}
|
|
void CappDlg::OnTradeDelegateDataCallback(list<TradeDelegateData> dataList, string money, void* context)
|
{
|
//转为json
|
CappDlg* app = (CappDlg*)context;
|
//cout << "回调:" << std::this_thread::get_id() << ":" << index << endl;
|
CButton* btn = (CButton*)app->GetDlgItem(IDC_CHECK4);
|
bool check = btn->GetCheck();
|
if (check) {
|
string data = JsonUtil::loadTradeDelegateData(dataList);
|
clock_t time_start = clock();
|
|
try {
|
SocketManager::sendMsg(data.c_str());
|
}
|
catch (string st) {
|
|
}
|
|
|
//上传账户可用余额
|
data = JsonUtil::loadAvailableMoney(app->clientNum, money);
|
try {
|
SocketManager::sendMsg(data.c_str());
|
}
|
catch (string st) {
|
}
|
|
cout << "####交易成功数据处理时间：" << (clock() - time_start) << endl;
|
}
|
}
|
|
|
void CappDlg::OnIndustryDataCallback(list<IndustryData> dataList, void* context) {
|
//转为json
|
CappDlg* app = (CappDlg*)context;
|
//cout << "回调:" << std::this_thread::get_id() << ":" << index << endl;
|
CButton* btn = (CButton*)app->GetDlgItem(IDC_CHECK3);
|
|
list<list<IndustryData>> _list;
|
_list.push_back(dataList);
|
|
string data = JsonUtil::loadIndustryData(_list);
|
try {
|
app->socketManager->sendMsg(8, data.c_str());
|
//AfxMessageBox(_T("上传成功"));
|
}
|
catch (string st) {
|
//重新连接服务器
|
app->socketManager->resetClient(8);
|
app->socketManager->Connect(8);
|
}
|
dataList.clear();
|
_list.clear();
|
}
|
|
void CappDlg::OnCurrentPriceCallback(list<CurrentPriceData> dataList, void* context)
|
{
|
//转为json
|
CappDlg* app = (CappDlg*)context;
|
|
|
string data = JsonUtil::loadGPPriceData(dataList);
|
try {
|
app->socketManager->sendMsg(8, data.c_str());
|
//AfxMessageBox(_T("上传成功"));
|
}
|
catch (string st) {
|
//重新连接服务器
|
app->socketManager->resetClient(8);
|
app->socketManager->Connect(8);
|
}
|
dataList.clear();
|
}
|
|
void CappDlg::OnTradeQueueCallback(int index, TradeQueueResult result, void* context)
|
{
|
//转为json
|
CappDlg* app = (CappDlg*)context;
|
string data = JsonUtil::loadTradeQueue(index, result.code_name, result.buy_1_volumn, result.buy_1_price, result.time);
|
try {
|
app->socketManager->sendMsg(8, data.c_str());
|
//AfxMessageBox(_T("上传成功"));
|
}
|
catch (string st) {
|
//重新连接服务器
|
app->socketManager->resetClient(8);
|
app->socketManager->Connect(8);
|
}
|
}
|
|
string CappDlg::OnActionProcess(string data, void* context)
|
{
|
//转为json
|
CappDlg* app = (CappDlg*)context;
|
if (!app->onlineCheck) {
|
return "未知错误";
|
}
|
|
cout << "action回调:" << std::this_thread::get_id() << ":" << data << endl;
|
//解析命令
|
Json::Value root = JsonUtil::parseJson(data);
|
bool forceAction = root["force"].asBool();
|
if (!app->onlineCheck.GetCheck() && !forceAction)
|
{
|
throw string("客户端离线");
|
}
|
string action = root["action"].asString();
|
if (action == "setGPCode") {
|
//设置股票代码
|
int index = root["data"]["index"].asInt();
|
string code = root["data"]["code"].asString();
|
string quickCode = "5";
|
quickCode.append(to_string(index + 1));
|
list<string> codeList;
|
if (code.length() > 0)
|
{
|
codeList.push_back(code);
|
}
|
try {
|
|
if (!app->capture->isInited()) {
|
app->initCapture(false);
|
}
|
|
//暂停采集
|
app->capture->stop(index);
|
//暂停涨停识别
|
LimitUpCapture::pause = TRUE;
|
|
//打开Level2监控屏幕
|
THSActionUtil::openL2Screen();
|
|
bool result = THSActionUtil::setGP(quickCode, codeList, recognitionManager,OcrUtil::mat_ocr);
|
if (!result) {
|
throw string("设置版块监控的GP失败");
|
}
|
//刷新L2数据
|
THSActionUtil::setListenL2GP(index, code, recognitionManager);
|
|
//打开Level2监控屏幕
|
THSActionUtil::openL2Screen();
|
|
map<int, string> results = THSActionUtil::getListenL2GPCodes(recognitionManager);
|
//设置代码
|
for (map<int, string>::iterator ele = results.begin(); ele != results.end(); ele++) {
|
int key = (*ele).first;
|
string value = (*ele).second;
|
app->capture->setGPCode(key, value);
|
cout << "代码位：" << key << " CODE:" << value;
|
//TODO 记录日志
|
}
|
Sleep(500);
|
}
|
catch (string e) {
|
throw e;
|
}
|
catch (...) {
|
throw string("未知错误(unknown error)");
|
}
|
|
//恢复采集
|
app->capture->start(index);
|
//恢复涨停识别
|
LimitUpCapture::pause = FALSE;
|
}
|
else if (action == "betchSetGPCodes") {
|
//批量设置代码
|
int len = root["data"].size();
|
for (int i = 0; i < len; i++) {
|
int index = root["data"][i]["index"].asInt();
|
string code = root["data"][i]["code"].asString();
|
string quickCode = "5";
|
quickCode.append(to_string(index + 1));
|
list<string> codeList;
|
if (code.length() > 0)
|
{
|
codeList.push_back(code);
|
}
|
|
try {
|
|
if (!app->capture->isInited()) {
|
app->initCapture(false);
|
}
|
|
//暂停采集
|
app->capture->stop(index);
|
//暂停涨停识别
|
LimitUpCapture::pause = TRUE;
|
|
//打开Level2监控屏幕
|
THSActionUtil::openL2Screen();
|
|
bool result = THSActionUtil::setGP(quickCode, codeList, recognitionManager,OcrUtil::mat_ocr);
|
if (!result) {
|
throw string("设置版块监控的GP失败");
|
}
|
|
}
|
catch (string e) {
|
throw e;
|
}
|
catch (...) {
|
throw string("未知错误(unknown error)");
|
}
|
|
}
|
|
//map<int, string> results = THSActionUtil::getListenL2GPCodes(recognitionManager);
|
//设置代码
|
//for (map<int, string>::iterator ele = results.begin(); ele != results.end(); ele++) {
|
// int key = (*ele).first;
|
// string value = (*ele).second;
|
// app->capture->setGPCode(key, value);
|
// cout << "代码位：" << key << " CODE:" << value;
|
//}
|
for (int i = 0; i < len; i++) {
|
try {
|
int index = root["data"][i]["index"].asInt();
|
string code = root["data"][i]["code"].asString();
|
app->capture->setGPCode(index, code);
|
cout << "代码位：" << index << " CODE:" << code;
|
}
|
catch (...) {
|
|
}
|
Sleep(100);
|
}
|
|
|
|
for (int i = 0; i < len; i++) {
|
try {
|
int index = root["data"][i]["index"].asInt();
|
string code = root["data"][i]["code"].asString();
|
//刷新L2数据
|
THSActionUtil::setListenL2GP(index, code, recognitionManager);
|
|
//打开Level2监控屏幕
|
THSActionUtil::openL2Screen();
|
}
|
catch (...) {
|
|
}
|
Sleep(100);
|
}
|
|
|
//恢复识别
|
for (int i = 0; i < len; i++) {
|
int index = root["data"][i]["index"].asInt();
|
app->capture->start(index);
|
}
|
|
//恢复涨停识别
|
LimitUpCapture::pause = FALSE;
|
//可以接受命令
|
//app->onlineCheck.SetCheck(TRUE);
|
//app->onlineCheck.PostMessage(WM_LBUTTONDOWN, 0, 0);
|
//app->onlineCheck.PostMessage(WM_LBUTTONUP, 0, 0);
|
RECT rect;
|
Win32Util::getWindowRect(app->onlineCheck.m_hWnd, &rect);
|
Win32Util::click((rect.left + rect.right) / 2, (rect.top + rect.bottom) / 2, 10);
|
|
}
|
else if (action == "repairL2Data") {
|
//修正代码与L2行情代码不对应 或者 L2行情无数据的情况
|
cout << "修复L2数据" << endl;
|
if (!app->capture->isInited()) {
|
app->initCapture(false);
|
}
|
try {
|
//修正L2的数据
|
int index = root["data"]["index"].asInt();
|
string code = root["data"]["code"].asString();
|
double min_price = root["data"]["min_price"].asDouble();
|
double max_price = root["data"]["max_price"].asDouble();
|
cout << index << ":" << code << ":" << min_price << ":" << max_price << endl;
|
app->thsL2RepairTool->repairL2Data(recognitionManager, index, code, min_price, max_price);
|
}
|
catch (string st) {
|
throw st;
|
}
|
catch (...) {
|
throw string("未知错误");
|
}
|
|
}
|
else if (action == "getEnvState") {
|
|
app->initCapture(false);
|
|
|
ClientEnvState state;
|
|
//获取同花顺的环境
|
HWND l2 = THSActionUtil::getL2Win();
|
HWND second = THSActionUtil::getSecondWindow();
|
HWND third = THSActionUtil::getThirdWindow();
|
HWND trade_success = THSActionUtil::getTradeSuccessWindow();
|
if (l2 > 0 && Win32Util::isWindowShow(l2)) {
|
state.ths_l2_win = TRUE;
|
}
|
else {
|
state.ths_l2_win = FALSE;
|
}
|
if (second > 0 && Win32Util::isWindowShow(second)) {
|
state.ths_fp_1 = TRUE;
|
}
|
else {
|
state.ths_fp_1 = FALSE;
|
}
|
|
if (third > 0 && Win32Util::isWindowShow(third)) {
|
state.ths_fp_2 = TRUE;
|
}
|
else {
|
state.ths_fp_2 = FALSE;
|
}
|
|
if (trade_success > 0 && Win32Util::isWindowShow(trade_success)) {
|
state.ths_trade_success = TRUE;
|
}
|
else {
|
state.ths_trade_success = FALSE;
|
}
|
|
//获取环境状态
|
int l2_valid_count = 0;
|
int l2_invalid_count = 0;
|
for (int i = 0; i < THS_FRAME_COUNT; i++)
|
{
|
clock_t latestTime = TaskChecker::clientLiveTime.l2[i];
|
if (clock() - latestTime > 5000) {
|
//5s内不再活跃
|
l2_invalid_count++;
|
}
|
else {
|
l2_valid_count++;
|
}
|
}
|
state.l2_channel_valid_count = l2_valid_count;
|
state.l2_channel_invalid_count = l2_invalid_count;
|
|
if (clock() - TaskChecker::clientLiveTime.limitUp > 5000) {
|
state.limitUp = false;
|
}
|
else {
|
state.limitUp = true;
|
}
|
|
if (clock() - TaskChecker::clientLiveTime.tradeSuccess > 5000) {
|
state.tradeSuccess = false;
|
}
|
else {
|
state.tradeSuccess = true;
|
}
|
|
return JsonUtil::toJson(state);
|
|
}
|
else if (action == "repairEnv") {
|
|
app->initCapture(false);
|
|
//同花顺环境修复
|
app->OnBnClickedButton21();
|
|
//l2采集环境修复
|
for (int i = 0; i < THS_FRAME_COUNT; i++)
|
{
|
clock_t latestTime = TaskChecker::clientLiveTime.l2[i];
|
if (clock() - latestTime > 5000) {
|
//5s内不再活跃
|
app->capture->reCreateChannelRunner(i);
|
}
|
}
|
|
if (clock() - TaskChecker::clientLiveTime.tradeSuccess > 5000) {
|
app->tradeListCapture->captureTradeSuccessInfo();
|
}
|
|
if (clock() - TaskChecker::clientLiveTime.limitUp > 5000) {
|
app->limitUpCapture->reCreateRunning();
|
}
|
|
|
}
|
else if (action == "syncTargetCodes") {
|
Json::Value data = root["data"];
|
list<string> codeList;
|
for (int i = 0; i < data.size(); i++) {
|
string code = data[i].asString();
|
codeList.push_back(code);
|
}
|
THSActionUtil::addTargetCodes(codeList, app->recognitionManager);
|
}
|
else if (action == "getIndustryCodes") {
|
//获取行业代码
|
if (!app->industryCapture->isInited()) {
|
app->industryCapture->init(OnIndustryDataCallback, app);
|
}
|
try {
|
app->industryCapture->refreshHWND();
|
}
|
catch (string st) {
|
cout << "初始化行业代码出错" << endl;
|
}
|
//识别行业代码
|
CappDlg::runCaptureIndustryCodes(app);
|
}
|
else if (action == "getL2Codes") {
|
//获取正在监听的L2数据
|
std::list<GPCodeArea> resultList = THSActionUtil::getListenL2GPAreaAndCode(recognitionManager_L2Code);
|
Json::Value root;
|
Json::Value data;
|
int index = 0;
|
for (std::list<GPCodeArea>::iterator ele = resultList.begin(); ele != resultList.end(); ++ele) {
|
Json::Value item;
|
item["index"] = (*ele).cateIndex;
|
item["code"] = (*ele).code;
|
data[index++] = item;
|
}
|
root["data"] = data;
|
root["client"] = clientNum;
|
return JsonUtil::toJsonStr(root);
|
}
|
else if (action == "updateTHSSite") {
|
//如果L2状态为开启，需要暂停L2
|
bool l2_running = app->capture->isRunning();
|
if (l2_running) {
|
app->capture->stop();
|
}
|
try {
|
THSActionUtil::updateMainSite();
|
}
|
catch (string st) {
|
throw st;
|
}
|
catch (...) {
|
throw string("未知错误");
|
}
|
|
if (l2_running) {
|
//非交易时间之前
|
if (!GPUtil::isBeforeTradeTime())
|
{
|
Sleep(10000);
|
}
|
app->capture->start();
|
}
|
}
|
|
return "";
|
}
|
|
|
|
string CappDlg::OnActionCallback(string data, void* context) {
|
Json::Value root;
|
try {
|
string result = OnActionProcess(data, context);
|
root["code"] = 0;
|
root["data"] = result;
|
}
|
catch (string st) {
|
root["code"] = 1;
|
root["msg"] = st;
|
}
|
catch (...) {
|
root["code"] = 2;
|
root["msg"] = "未知错误";
|
}
|
return JsonUtil::jsonValue2String(root);
|
}
|
|
string CappDlg::OnActionCallbackQueue(string data, void* context)
|
{
|
return string();
|
}
|
|
list<OCRResult> CappDlg::MatOcr(string key_regex, cv::Mat mat)
|
{
|
return OcrUtil::mat_ocr(key_regex, mat);
|
}
|
|
//心跳信号
|
void CappDlg::onHeartbeat() {
|
//5s一次心跳
|
while (true)
|
{
|
if (clientNum >= 0)
|
{
|
//用户已经登录
|
MEMORYSTATUS ms;
|
::GlobalMemoryStatus(&ms);
|
DWORD mer = ms.dwMemoryLoad;
|
cout << "内存使用率：" << mer << endl;
|
|
//获取当前进程的内存使用情况
|
HANDLE handle = GetCurrentProcess();
|
PROCESS_MEMORY_COUNTERS pmc;
|
GetProcessMemoryInfo(handle, &pmc, sizeof(pmc));
|
float memoryUsage_M = pmc.WorkingSetSize / (1024.0 * 1024.0);
|
|
string ownMemory = to_string(memoryUsage_M);
|
ownMemory.append("MB");
|
|
|
//获取是否卡死
|
bool thsDead;
|
string deadMsg = "";
|
try {
|
bool result = THSActionUtil::thsIsDead();
|
if (result) {
|
thsDead = true;
|
}
|
else {
|
thsDead = false;
|
}
|
}
|
catch (string e) {
|
thsDead = true;
|
deadMsg = e;
|
}
|
|
|
try {
|
string msg = JsonUtil::loadHeartbeatData(clientNum, to_string(mer), ownMemory, thsDead, deadMsg);
|
SocketManager::sendMsg(msg.c_str());
|
//cout << "心跳信号" << endl;
|
}
|
catch (...) {
|
cout << "心跳信号异常" << endl;
|
}
|
}
|
Sleep(5000);
|
}
|
}
|
|
void CappDlg::initCapture(bool notify)
|
{
|
if (!capture->isInited())
|
{
|
try {
|
capture->init(OnL2DataCallback, OnTradeQueueDataCallback, this);
|
}
|
catch (string st) {
|
if (notify)
|
{
|
CString msg(st.c_str());
|
AfxMessageBox(msg);
|
}
|
}
|
}
|
|
if (!limitUpCapture->isInited())
|
{
|
try {
|
limitUpCapture->init(OnLimitUpDataCallback,OnLimitUpFirstDataCallback, MatOcr, this);
|
}
|
catch (string st) {
|
if (notify)
|
{
|
CString msg(st.c_str());
|
AfxMessageBox(msg);
|
}
|
}
|
}
|
|
if (!tradeListCapture->isInited())
|
{
|
try {
|
tradeListCapture->init(OnTradeSuccessDataCallback, OnTradeDelegateDataCallback, this);
|
}
|
catch (string st) {
|
if (notify)
|
{
|
CString msg(st.c_str());
|
AfxMessageBox(msg);
|
}
|
}
|
}
|
|
if (!currentPriceCapture->isInited())
|
{
|
try {
|
currentPriceCapture->init(OnCurrentPriceCallback, this);
|
}
|
catch (string st) {
|
if (notify)
|
{
|
CString msg(st.c_str());
|
AfxMessageBox(msg);
|
}
|
}
|
}
|
|
|
|
}
|
|
void CappDlg::checkTHSEnv(CappDlg* app)
|
{
|
|
try {
|
THSActionUtil::checkEnv();
|
}
|
catch (string e) {
|
//打开同花顺的所有屏幕
|
try {
|
THSActionUtil::openL2Screen();
|
THSActionUtil::openSecondScreen();
|
Sleep(1000);
|
THSActionUtil::openThirdScreen();
|
Sleep(1000);
|
}
|
catch (...) {
|
|
}
|
}
|
|
|
HWND l2 = THSActionUtil::getL2Win();
|
if (l2 > 0)
|
{
|
Win32Util::showWindow(l2);
|
//初始化l2的各个窗口句柄
|
app->capture->refreshHWND();
|
//选中板块
|
try {
|
//THSActionUtil::correctL2ScreenPlate(OcrUtil::mat_ocr);
|
}
|
catch (string st) {
|
|
}
|
}
|
|
HWND second = THSActionUtil::getSecondWindow();
|
if (second <= 0) {
|
throw string("同花顺副屏1未打开");
|
}
|
|
Win32Util::showWindow(second);
|
|
|
HWND third = THSActionUtil::getThirdWindow();
|
if (third <= 0) {
|
throw string("同花顺副屏2未打开");
|
}
|
|
Win32Util::showWindow(third);
|
|
|
//设置
|
DEVMODE device = Win32Util::getL2ScreenInfo();
|
int device_width = device.dmPelsWidth;
|
int device_height = device.dmPelsHeight;
|
POINTL device_pos = device.dmPosition;
|
//最大化L2
|
Win32Util::moveWin(l2, device_pos.x, device_pos.y, device_width, device_height);
|
//将副屏1与副屏2缩小为屏幕的一半
|
Win32Util::moveWin(second, device_pos.x, device_pos.y + device_height / 2, device_width / 2 - 50, device_height / 2);
|
Win32Util::moveWin(third, device_pos.x + device_width / 2 + 30, device_pos.y + device_height / 2, device_width / 2 - 50, device_height / 2);
|
|
try {
|
Sleep(500);
|
THSActionUtil::correctL2ScreenPlate(OcrUtil::mat_ocr);
|
}
|
catch (...) {
|
|
}
|
}
|
|
void CappDlg::autoStartL2(void* context)
|
{
|
Sleep(1500);
|
CappDlg* app = (CappDlg*)context;
|
app->autoMsgStatic.SetWindowTextW(_T("开始检测同花顺环境..."));
|
//点击检查同花顺
|
for (int i = 0; i < 10; i++)
|
{
|
try {
|
checkTHSEnv(app);
|
app->autoMsgStatic.SetWindowTextW(_T("同花顺环境检测通过..."));
|
//执行一次重置
|
Sleep(500);
|
app->OnBnClickedButton21();
|
break;
|
}
|
catch (string st) {
|
Sleep(2000);
|
CString msg(st.c_str());
|
app->autoMsgStatic.SetWindowTextW(msg);
|
}
|
}
|
Sleep(1000);
|
app->autoMsgStatic.SetWindowTextW(_T("开始启动L2行情识别..."));
|
//启动L2行情识别
|
app->OnBnClickedButton5();
|
app->autoMsgStatic.SetWindowTextW(_T("L2行情识别启动完成..."));
|
//启动交易成功识别
|
//app->OnBnClickedButtonTrade();
|
//启动涨停识别
|
//OnBnClickedButton12();
|
//发送自动化开始成功
|
string data = JsonUtil::loadAutoStartL2(clientNum);
|
clock_t time_start = clock();
|
try {
|
string result_msg = app->socketManager->sendMsg(8, data.c_str());
|
Json::Value v_ = JsonUtil::parseJson(result_msg);
|
if (v_["code"] == 0) {
|
//判断是否需要自动开启在线
|
//可以接受命令
|
app->onlineCheck.SetCheck(TRUE);
|
}
|
else {
|
//不可以接受命令
|
app->onlineCheck.SetCheck(FALSE);
|
}
|
}
|
catch (string st) {
|
//重新连接服务器
|
app->socketManager->resetClient(8);
|
app->socketManager->Connect(8);
|
}
|
|
}
|
|
void CappDlg::autoStartTradeDelegate(void* context)
|
{
|
CappDlg* app = (CappDlg*)context;
|
app->autoMsgStatic.SetWindowTextW(_T("开始委托识别..."));
|
app->OnBnClickedButtonTradeDelegate();
|
app->autoMsgStatic.SetWindowTextW(_T("委托识别启动成功"));
|
}
|
|
void CappDlg::autoStartCurrentPrice(void* context)
|
{
|
CappDlg* app = (CappDlg*)context;
|
app->autoMsgStatic.SetWindowTextW(_T("开始现价识别..."));
|
app->OnBnClickedCurrentPrice();
|
app->autoMsgStatic.SetWindowTextW(_T("现价识别启动成功"));
|
}
|
|
void CappDlg::autoStartBuy1Volumn(void* context)
|
{
|
CappDlg* app = (CappDlg*)context;
|
app->autoMsgStatic.SetWindowTextW(_T("开始买1识别..."));
|
app->OnBnClickedButtonBuy1Volumn();
|
app->autoMsgStatic.SetWindowTextW(_T("买1识别启动成功"));
|
}
|
|
|
|
|
|
|
|
void CappDlg::OnBnClickedButton1()
|
{
|
MessageBox(_T("内容"), _T("标题"), MB_OKCANCEL);
|
}
|
|
|
void CappDlg::OnBnClickedButton3()
|
{
|
try {
|
socketManager->sendMsg(0, "0");
|
socketManager->sendMsg(1, "1");
|
socketManager->sendMsg(2, "2");
|
socketManager->sendMsg(3, "3");
|
socketManager->sendMsg(4, "4");
|
socketManager->sendMsg(5, "5");
|
socketManager->sendMsg(6, "6");
|
socketManager->sendMsg(7, "7");
|
}
|
catch (string st) {
|
CString msg(st.c_str());
|
AfxMessageBox(msg);
|
}
|
}
|
|
|
void CappDlg::OnBnClickedButton2()
|
{
|
for (int i = 0; i < 8; i++)
|
{
|
socketManager->disConnect(i);
|
}
|
}
|
|
|
|
|
|
//服务器检测
|
void CappDlg::OnBnClickedButton6()
|
{
|
int num = socketManager->getClientsNum();
|
int scount = 0;
|
for (int i = 0; i < num; i++)
|
{
|
try {
|
socketManager->sendMsg(i, "test");
|
scount++;
|
|
}
|
catch (string st) {
|
|
}
|
}
|
|
CString msg;
|
msg.Format(_T("检测结果：%d/%d"), scount, num);
|
MessageBox(msg, _T("通道检测结果"), MB_OK);
|
|
}
|
|
|
void CappDlg::OnBnClickedButton10()
|
{
|
socketManager->disConnect();
|
try {
|
socketManager->init(CappDlg::OnActionCallback, this);
|
}
|
catch (string st) {
|
CString msg(st.c_str());
|
AfxMessageBox(msg);
|
}
|
int scount = 0;
|
int num = socketManager->getClientsNum();
|
for (int i = 0; i < num; i++)
|
{
|
socketManager->sendMsg(i, "test");
|
scount++;
|
|
}
|
|
|
CString msg;
|
msg.Format(_T("链接结果：%d/%d"), scount, num);
|
MessageBox(msg, _T("通道链接结果"), MB_OK);
|
}
|
|
//识别测试
|
void CappDlg::OnBnClickedButton9()
|
{
|
|
|
int* a = nullptr;
|
*a = 1;
|
|
return
|
|
initCapture();
|
|
clock_t time = clock();
|
|
CString path = GUITool::selectImage();
|
std:string p = Tool::cstring2String(path);
|
if (p.length() <= 0) {
|
return;
|
}
|
list<TradeData*> result = capture->captureLevel2TradeData(cv::imread(p), 0);
|
time = clock() - time;
|
|
Clevel2DataDlg::level2Data = { time, result };
|
Clevel2DataDlg dlg;
|
dlg.DoModal();
|
}
|
|
|
//截图识别
|
void CappDlg::OnBnClickedButton4()
|
{
|
if (!capture->isInited())
|
{
|
try {
|
capture->init(OnL2DataCallback, OnTradeQueueDataCallback, this);
|
}
|
catch (string st) {
|
CString msg(st.c_str());
|
AfxMessageBox(msg);
|
}
|
}
|
clock_t time = clock();
|
|
CString path = GUITool::selectImage();
|
std:string p = Tool::cstring2String(path);
|
if (p.length() <= 0) {
|
return;
|
}
|
list<TradeData*> result = capture->captureLevel2TradeData(cv::imread(p), 0);
|
time = clock() - time;
|
|
Clevel2DataDlg::level2Data = { time, result };
|
Clevel2DataDlg dlg;
|
dlg.DoModal();
|
}
|
|
//环境检测
|
void CappDlg::OnBnClickedButton20()
|
{
|
try {
|
checkTHSEnv(this);
|
AfxMessageBox(_T("检测通过"));
|
}
|
catch (const string& st) {
|
CString msg(st.c_str());
|
AfxMessageBox(msg);
|
}
|
}
|
|
|
//启动任务
|
void CappDlg::OnBnClickedButton5()
|
{
|
|
CButton* btn = (CButton*)GetDlgItem(IDC_BUTTON5);
|
|
if (!capture->isInited())
|
{
|
try {
|
capture->init(OnL2DataCallback, OnTradeQueueDataCallback, this);
|
}
|
catch (string st) {
|
CString msg(st.c_str());
|
AfxMessageBox(msg);
|
return;
|
}
|
}
|
if (!capture->isRunning()) {
|
|
// 检测环境
|
checkTHSEnv(this);
|
|
try {
|
map<int, string> result = THSActionUtil::getListenL2GPCodes(recognitionManager);
|
if (result.size() == 0) {
|
cout << "尚未获取L2的监听代码" << endl;
|
}
|
//设置代码
|
for (map<int, string>::iterator ele = result.begin(); ele != result.end(); ele++) {
|
int key = (*ele).first;
|
string value = (*ele).second;
|
capture->setGPCode(key, value);
|
}
|
|
}
|
catch (string st) {
|
CString msg(st.c_str());
|
AfxMessageBox(msg);
|
return;
|
}
|
|
//刷新窗口句柄
|
capture->refreshHWND();
|
//句柄初始化
|
capture->start();
|
capture->startAll();
|
btn->SetWindowText(_T("暂停识别任务"));
|
|
//TODO 测试图片切割
|
//THSActionUtil::getListenL2GPAreaActionBar();
|
// 检测同花顺板块是否选中
|
try {
|
Sleep(500);
|
THSActionUtil::correctL2ScreenPlate(OcrUtil::mat_ocr);
|
}
|
catch (...) {
|
|
}
|
|
}
|
else {
|
capture->stop();
|
capture->stopAll();
|
btn->SetWindowText(_T("启动识别任务"));
|
}
|
|
}
|
|
|
//股票代码识别
|
void CappDlg::OnBnClickedButton7()
|
{
|
|
if (!gpDataCapture->isInited())
|
{
|
try {
|
gpDataCapture->init();
|
}
|
catch (string st) {
|
CString msg(st.c_str());
|
AfxMessageBox(msg);
|
return;
|
}
|
}
|
list<CString> paths = GUITool::selectMulImages();
|
std::list<IndustryData> fResultList;
|
|
for (list<CString>::iterator ele = paths.begin(); ele != paths.end(); ele++) {
|
CString path = *ele;
|
std:string p = Tool::cstring2String(path);
|
cv::Mat grayImg = gpDataCapture->grayImgs(cv::imread(p));
|
|
SplitType types[] = { NUM_TYPE_MONEY, NUM_TYPE_CODE };
|
|
list<list<GPDataStruct>> resultList = gpDataCapture->captureGPData(grayImg, types, 6, 1, 2);
|
|
for (list<list<GPDataStruct>>::iterator ele1 = resultList.begin(); ele1 != resultList.end(); ele1++) {
|
IndustryData industryData = IndustryData();
|
|
list<GPDataStruct>::iterator e = (*ele1).begin();
|
industryData.zyltMoney = (*e).content;
|
industryData.zyltMoneyUnit = (*e).unit;
|
advance(e, 1);
|
industryData.code = (*e).content;
|
if (industryData.code == "000000") {
|
continue;
|
}
|
|
|
|
bool contains = false;
|
for (std::list<IndustryData>::iterator e = fResultList.begin(); e != fResultList.end(); e++) {
|
if ((*e).code == industryData.code) {
|
contains = true;
|
break;
|
}
|
}
|
if (!contains) {
|
fResultList.push_back(industryData);
|
}
|
}
|
|
}
|
codesDataDlog::codeData = fResultList;
|
codesDataDlog::upload = false;
|
codesDataDlog dlg;
|
dlg.DoModal();
|
}
|
|
//截图上传股票代码
|
void CappDlg::OnBnClickedButton8()
|
{
|
if (!gpDataCapture->isInited())
|
{
|
try {
|
gpDataCapture->init();
|
}
|
catch (string st) {
|
CString msg(st.c_str());
|
AfxMessageBox(msg);
|
return;
|
}
|
}
|
list<CString> paths = GUITool::selectMulImages();
|
std::list<IndustryData> fResultList;
|
|
for (list<CString>::iterator ele = paths.begin(); ele != paths.end(); ele++) {
|
CString path = *ele;
|
std:string p = Tool::cstring2String(path);
|
cv::Mat img = cv::imread(p);
|
//cv::Mat _img;
|
//cv::resize(img, _img, cv::Size(img.cols * 2 / 3, img.rows * 2 / 3));
|
|
cv::Mat grayImg = gpDataCapture->grayImgs(img);
|
|
|
SplitType types[] = { NUM_TYPE_MONEY, NUM_TYPE_CODE };
|
|
list<list<GPDataStruct>> resultList = gpDataCapture->captureGPData(grayImg, types, 6, 1, 2);
|
|
for (list<list<GPDataStruct>>::iterator ele1 = resultList.begin(); ele1 != resultList.end(); ele1++) {
|
IndustryData industryData = IndustryData();
|
|
list<GPDataStruct>::iterator e = (*ele1).begin();
|
industryData.zyltMoney = (*e).content;
|
industryData.zyltMoneyUnit = (*e).unit;
|
advance(e, 1);
|
industryData.code = (*e).content;
|
if (industryData.code == "000000") {
|
continue;
|
}
|
|
|
|
bool contains = false;
|
for (std::list<IndustryData>::iterator e = fResultList.begin(); e != fResultList.end(); e++) {
|
if ((*e).code == industryData.code) {
|
contains = true;
|
break;
|
}
|
}
|
if (!contains) {
|
fResultList.push_back(industryData);
|
}
|
}
|
|
}
|
codesDataDlog::codeData = fResultList;
|
codesDataDlog::upload = TRUE;
|
codesDataDlog dlg;
|
dlg.DoModal();
|
}
|
|
|
//涨停上传
|
void CappDlg::OnBnClickedButton12()
|
{
|
if (!limitUpCapture->isInited()) {
|
try
|
{
|
limitUpCapture->init(OnLimitUpDataCallback, OnLimitUpFirstDataCallback,MatOcr,this);
|
|
}
|
catch (string st)
|
{
|
CString msg(st.c_str());
|
AfxMessageBox(msg);
|
return;
|
}
|
}
|
if (
|
limitUpCapture->isRunning()) {
|
limitUpCapture->stop();
|
limitUpBtn.SetWindowTextW(_T("启动涨停识别任务"));
|
}
|
else {
|
try
|
{
|
limitUpCapture->refreshHWND();
|
}
|
catch (string st)
|
{
|
CString msg(st.c_str());
|
AfxMessageBox(msg);
|
return;
|
}
|
|
limitUpCapture->start();
|
limitUpBtn.SetWindowTextW(_T("暂停涨停识别任务"));
|
}
|
|
|
|
|
|
|
}
|
|
//当日成交监控
|
void CappDlg::OnBnClickedButtonTrade()
|
{
|
|
|
if (!tradeListCapture->isInited()) {
|
try
|
{
|
tradeListCapture->init(OnTradeSuccessDataCallback, OnTradeDelegateDataCallback, this);
|
}
|
catch (string st)
|
{
|
CString msg(st.c_str());
|
AfxMessageBox(msg);
|
return;
|
}
|
}
|
if (
|
tradeListCapture->isRunningTradeSuccess()) {
|
tradeListCapture->stopTradeSuccess();
|
tradeBtn.SetWindowTextW(_T("启动成交识别任务"));
|
}
|
else {
|
try
|
{
|
tradeListCapture->refreshTradeSuccessHWND();
|
}
|
catch (string st)
|
{
|
CString msg(st.c_str());
|
AfxMessageBox(msg);
|
return;
|
}
|
//如果已经打开了远航版的交易，就需要点击当日委托
|
try {
|
tradeListCapture->selectTradeSuccess(MatOcr);
|
}
|
catch (...) {
|
|
}
|
|
tradeListCapture->startTradeSuccess();
|
tradeBtn.SetWindowTextW(_T("暂停成交识别任务"));
|
}
|
}
|
|
void* CappDlg::runCaptureIndustryCodes(void* context) {
|
CappDlg* app = (CappDlg*)context;
|
app->industryCapture->captureIndustryCodes();
|
|
return context;
|
}
|
|
//行业代码识别
|
void CappDlg::OnBnClickedIndustry()
|
{
|
|
if (!industryCapture->isInited()) {
|
industryCapture->init(OnIndustryDataCallback, this);
|
}
|
try {
|
industryCapture->refreshHWND();
|
}
|
catch (string st) {
|
CString msg(st.c_str());
|
AfxMessageBox(msg);
|
return;
|
}
|
if (!industryPid.p) {
|
int ret = 0;
|
ret = pthread_create(&industryPid, NULL, &(CappDlg::runCaptureIndustryCodes), this);
|
if (ret != 0) {
|
AfxMessageBox(_T("创建运行线程失败"));
|
return;
|
}
|
pthread_detach(industryPid);
|
industryBtn.SetWindowTextW(_T("结束行业识别"));
|
}
|
else {
|
industryCapture->stop();
|
int ret = pthread_cancel(industryPid);
|
industryPid.p = 0;
|
industryBtn.SetWindowTextW(_T("开始行业识别"));
|
}
|
}
|
|
//委托识别任务
|
void CappDlg::OnBnClickedButtonTradeDelegate()
|
{
|
|
//打开同花顺远航版的委托界面
|
HWND win = 0;
|
if (win <= 0) {
|
//判断是否已经打开了同花顺远航版
|
for (int i = 0; i < 10; i++)
|
{
|
win = THSActionUtil::getTradeSimpleDelegateWindow();
|
if (win <= 0)
|
{
|
list<HWND> wlist = Win32Util::searchWindow("同花顺远航版");
|
if (wlist.size() > 0) {
|
HWND mainWin = *(wlist.begin());
|
//按F12
|
Win32Util::sendMessage(mainWin, WM_KEYDOWN, VK_F12, 0);
|
Win32Util::sendMessage(mainWin, WM_KEYUP, VK_F12, 0);
|
//等待反应
|
Sleep(500);
|
}
|
else {
|
//等待远航版打开
|
Sleep(1000);
|
}
|
}
|
else {
|
break;
|
}
|
}
|
}
|
|
|
|
if (!tradeListCapture->isInited()) {
|
try
|
{
|
tradeListCapture->init(OnTradeSuccessDataCallback, OnTradeDelegateDataCallback, this);
|
}
|
catch (string st)
|
{
|
CString msg(st.c_str());
|
AfxMessageBox(msg);
|
return;
|
}
|
}
|
if (
|
tradeListCapture->isRunningTradeDelegate()) {
|
tradeListCapture->stopTradeDelegate();
|
delegateBtn.SetWindowTextW(_T("启动委托识别任务"));
|
}
|
else {
|
|
//如果已经打开了远航版的交易，就需要点击当日委托
|
try {
|
tradeListCapture->selectTradeSimpleDelegate(OcrUtil::mat_ocr);
|
}
|
catch (...) {
|
|
}
|
|
try
|
{
|
tradeListCapture->refreshTradeSimpleDelegateHWND();
|
}
|
catch (string st)
|
{
|
CString msg(st.c_str());
|
AfxMessageBox(msg);
|
return;
|
}
|
tradeListCapture->startTradeDelegate();
|
delegateBtn.SetWindowTextW(_T("暂停委托识别任务"));
|
}
|
}
|
|
|
#include "MyNetWorkManager.h"
|
|
|
//测试按钮
|
void CappDlg::OnBnClickedButtonTest()
|
{
|
//if (!dxjlCapture->is_inited()) {
|
// dxjlCapture->init(OcrUtil::code_ocr_by_name);
|
//}
|
//dxjlCapture->start();
|
|
//clock_t start = clock();
|
//if (THSActionUtil::addGP("000236", OcrUtil::mat_ocr)) {
|
// cout << "整体耗时" << clock() - start << endl;
|
// MessageBox(_T("success"));
|
//}
|
//limitUpCapture->init(OnLimitUpDataCallback,OnLimitUpFirstDataCallback,MatOcr,this);
|
//limitUpCapture->captureLimitUpCodes();
|
//OcrUtil::mat_ocr(".", cv::imread("C:\\Users\\Administrator\\Desktop\\ocr\\dxjl\\code_name_32.png", cv::IMREAD_GRAYSCALE));
|
int max = -1;
|
int min = -1;
|
for (int i = 0; i < 170; i++) {
|
cv::Mat mat = cv::imread(string("C:\\Users\\Administrator\\Desktop\\ocr\\l2分析\\time\\").append(to_string(i)).append(".png"));
|
if (max == -1)
|
max = mat.cols;
|
if (min == -1)
|
min = mat.cols;
|
if (max < mat.cols){
|
max = mat.cols;
|
}
|
|
if (min > mat.cols) {
|
min = mat.cols;
|
}
|
|
|
}
|
CString st(to_string(min).append(":").append(to_string(max)).c_str());
|
MessageBox(st);
|
|
|
}
|
|
void CappDlg::OnBnClickedCheck5()
|
{
|
L2DataCapture::setTradeTimeCapture(tradeTimeCaptureCheck.GetCheck());
|
}
|
|
|
|
void CappDlg::OnBnClickedButton21()
|
{
|
|
try {
|
checkTHSEnv(this);
|
}
|
catch (string st) {
|
CString msg(st.c_str());
|
AfxMessageBox(msg);
|
return;
|
}
|
|
}
|
|
|
void CappDlg::OnBnClickedButton22()
|
{
|
try {
|
//刷新L2窗口句柄
|
capture->refreshHWND();
|
}
|
catch (string e) {
|
CString msg(e.c_str());
|
AfxMessageBox(msg);
|
}
|
catch (...) {
|
AfxMessageBox(_T("未知错误"));
|
}
|
|
try {
|
//刷新L2窗口句柄
|
limitUpCapture->refreshHWND();
|
}
|
catch (string e) {
|
CString msg(e.c_str());
|
AfxMessageBox(msg);
|
}
|
catch (...) {
|
AfxMessageBox(_T("未知错误"));
|
}
|
}
|
|
|
//退出登录
|
void CappDlg::OnBnClickedLogoutBtn()
|
{
|
clientNum = -1;
|
|
SendMessage(WM_CLOSE);
|
loginDlg dlg(this);
|
dlg.setReLogin(true);
|
dlg.DoModal();
|
}
|
|
|
//是否自动开启L2行情
|
void CappDlg::OnBnClickedCheck6()
|
{
|
std::list<string> settings;
|
if (autoL2Check.GetCheck()) {
|
settings.push_back("1");
|
}
|
else {
|
settings.push_back("0");
|
}
|
Tool::saveSettings("setting.txt", settings);
|
}
|
|
//线价识别
|
void CappDlg::OnBnClickedCurrentPrice()
|
{
|
if (!currentPriceCapture->isInited()) {
|
try {
|
currentPriceCapture->init(OnCurrentPriceCallback, this);
|
}
|
catch (string e) {
|
CString msg(e.c_str());
|
AfxMessageBox(msg);
|
}
|
}
|
if (currentPriceCapture->isRunning()) {
|
currentPriceCapture->stop();
|
currentPriceBtn.SetWindowTextW(_T("启动现价识别"));
|
}
|
else {
|
try {
|
currentPriceCapture->refreshHWND();
|
}
|
catch (string e) {
|
CString msg(e.c_str());
|
AfxMessageBox(msg);
|
}
|
currentPriceCapture->start();
|
currentPriceBtn.SetWindowTextW(_T("暂停现价识别"));
|
|
}
|
|
|
}
|
|
|
void CappDlg::OnBnClickedButtonThs()
|
{
|
// TODO 测试设置最小化
|
|
//HWND main = THSActionUtil::getMainWin();
|
//RECT rect;
|
//Win32Util::getWindowRect(main,&rect);
|
//Win32Util::moveWin(main,rect.left,rect.top,1800,1000);
|
|
//return;
|
|
|
try {
|
bool result = THSActionUtil::thsIsDead();
|
if (result) {
|
AfxMessageBox(_T("卡死"));
|
}
|
else {
|
AfxMessageBox(_T("正常"));
|
}
|
}
|
catch (string e) {
|
CString msg(e.c_str());
|
AfxMessageBox(msg);
|
}
|
}
|
|
|
void CappDlg::OnBnClickedCheckTradeTimeLimitUp()
|
{
|
//涨停交易时段识别
|
LimitUpCapture::setTradeTimeCapture(limitUpTimeCheck.GetCheck());
|
}
|
|
|
|
void CappDlg::OnBnClickedCheckTradeTimeTradeSuccess()
|
{
|
// 成交任务交易时段识别
|
TradeListCapture::setTradeTimeCapture_success(tradeSuccessTimeCheck.GetCheck());
|
}
|
|
|
void CappDlg::OnBnClickedCheckTradeTimeDelegate()
|
{
|
// 委托交易时段识别
|
TradeListCapture::setTradeTimeCapture_delegate(delegateTimeCheck.GetCheck());
|
}
|
|
|
void CappDlg::OnBnClickedCheckPriceTimeLimit()
|
{
|
// 现价识别时段限制
|
CurrentPriceCapture::setTradeTimeCapture(priceTimeLimitCheck.GetCheck());
|
}
|
|
|
|
|
// 买1 识别
|
void CappDlg::OnBnClickedButtonBuy1Volumn()
|
{
|
|
if (!tradeQueueCaptureManager->isInited()) {
|
try {
|
tradeQueueCaptureManager->init(OnTradeQueueCallback, this);
|
}
|
catch (string e) {
|
CString msg(e.c_str());
|
AfxMessageBox(msg);
|
}
|
}
|
if (tradeQueueCaptureManager->isRunning()) {
|
tradeQueueCaptureManager->stop();
|
buy1VolumnBtn.SetWindowTextW(_T("启动买1识别"));
|
}
|
else {
|
try {
|
tradeQueueCaptureManager->refreshHWND();
|
}
|
catch (string e) {
|
CString msg(e.c_str());
|
AfxMessageBox(msg);
|
}
|
tradeQueueCaptureManager->start();
|
buy1VolumnBtn.SetWindowTextW(_T("暂停买1识别"));
|
}
|
}
|
|
|
void CappDlg::OnBnClickedButtonUploadGpcode()
|
{
|
std::list<IndustryData> fresult;
|
codesDataDlog::codeData = fresult;
|
codesDataDlog::upload = TRUE;
|
codesDataDlog::add = FALSE;
|
codesDataDlog dlg;
|
dlg.DoModal();
|
}
|
|
|
void CappDlg::OnBnClickedCheckBuy1VolumnTimeLimit()
|
{
|
TradeQueueCaptureManager::setTradeTimeCapture(buy1VolumnTimeLimitCheck.GetCheck());
|
}
|
|
//新增股票代码
|
void CappDlg::OnBnClickedButtonGpCodeAdd()
|
{
|
std::list<IndustryData> fresult;
|
codesDataDlog::codeData = fresult;
|
codesDataDlog::upload = TRUE;
|
codesDataDlog::add = TRUE;
|
codesDataDlog dlg;
|
dlg.DoModal();
|
}
|
