开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 行业应用 > 金融证券系统 > 查看源码
HQ_TCP.C
资源名称：inet_stock.zip　[点击查看]
上传用户：bjghjy
上传日期：2007-01-07
资源大小：379k
文件大小：41k
源码类别：

金融证券系统

开发平台：

Visual C++

HQ_TCP.C：源码内容
  1. #include <windows.h>
  2. #include <windowsx.h>
  3. #include <stdlib.h>
  4. #include <stdio.h>
  5. #include <string.h>
  6. #include <malloc.h>
  7. #include <winsock.h>
  8. #include <time.h>
  9. #include <dos.h>
  10. #include <io.h>
  12. #include "appmain.h"
  13. #include "pctcp.h"
  14. #include "hq.h"
  15. #include "hq_cl.h"
  16. #include "hq_tcp.h" 
  17. #include "caption.h"
  18. #include "msg.h"
  20. #include "fx.h"
  21. #include "lzw.h"
  22. #include "zlib.h"
  24. extern BOOL ErrMsg(HWND, LPSTR);
  25. extern HWND ghWndMain, ghWndHq, ghWndXlt, ghWndJlt, ghWndCj, ghWndLitHq,
  26. ghWndMmp, ghWndMaxMin, ghWndStatus, ghWndCaption;
  27. extern HWND ghDlgJy, ghDlgChkUsr, ghDlgChgPwd, ghDlgBuySell, ghDlgCancel,
  28. ghDlgYecx, ghDlgWtcx, ghDlgCjcx;
  30. extern BOOL run_cancelled;
  31. extern int sdHq, sdJy;
  32. extern char * ReadBuf; //[MAX_READ_BUF_SIZE+1];  
  34. extern char szDataPath[128];
  36. extern BOOL IsZsRec(int, int);
  37. extern LPSTR GetError(LPSTR);
  38. extern HFILE hfZx;
  39. extern int FxInit(LPFX Fx);
  40. extern LPFX Fx;
  41. extern BOOL gfOnLine,gfConnecting;
  43. BOOL HqAllocMem(int);
  45. int date_num =-1;
  46. int GraRecalcJgMax();
  47. int GraRecalcLcMax();
  48. int MaxMinChangeHqData(int jys, int maxmin);
  49. int GraGetMinPos(void);
  50. void WriteMsg(LPSTR msg);
  51. int UDP_Read_GetZqmc(LPSTR lpTmp, int len);
  52. int UDP_Read_DataDay(LPSTR lpTmp, int len);
  53. int UDP_Read_ChkUsr(LPSTR lpTmp, int len);
  55. #define  DATA_START_SIGN  -16
  57. extern char *IpSendBuffer,*IpCommitBuffer;
  58. extern unsigned int IpSendLen,IpCommitLen;
  60. void Ip_Commit_Pack(int len,char *buff)
  61. {   
  62. IpCommitLen =len;
  63. memcpy(IpCommitBuffer,buff,len);
  64. }
  66. BOOL  Ip_Send_Pack()
  67. {   
  68. int x,k,this;
  69.     char tmp[100];
  71. if(IpCommitLen ==0)
  72. return TRUE;
  73. if(IpSendLen!=0)
  74. return TRUE;
  75. //if((x=check_socket_status(sdHq))!=0)
  76. // return TRUE;
  78. memcpy(IpSendBuffer,IpCommitBuffer,IpCommitLen);
  79. IpSendLen = IpCommitLen;
  80. IpCommitLen =0;
  82. for(k=0,x=0;k<1000;k++)
  83. {
  84. this = send(sdHq,IpSendBuffer, IpSendLen-x, 0);
  85. if (this == SOCKET_ERROR)
  86. {                          
  87. if ((this =h_errno) != WSAEWOULDBLOCK)
  88. {
  89. strcpy(tmp,"不能接收主机信息！");
  90. ErrMsg(ghWndMain, GetError(tmp));
  91. gfOnLine=FALSE;
  92. return FALSE;
  93. }
  94. }
  95. if(x+this!=(int)IpSendLen)
  96. x+=this;
  97. else
  98. break;
  99. }
  100. IpSendLen =0;
  101. return TRUE;
  102. }   
  104. int UDP_Send_Hq(LPSTR lpString, LPSTR lpHead, int len)
  105. {
  106. char tmp2[MAX_WRITE_BUF_SIZE+1];
  107. int x=0,tlen;
  109. if(!gfOnLine||gfConnecting) return 0;
  110.     
  111.     memset(&tmp2[0],0,sizeof(MAX_WRITE_BUF_SIZE));
  112.     tmp2[0]=DATA_START_SIGN;
  113.     *(int *)&tmp2[1]=len;    
  114. memcpy(&tmp2[1+sizeof(int)], lpString, len);
  116. tlen = 1+sizeof(int) + len;
  118. Ip_Commit_Pack(tlen, &tmp2[0]);
  119. return len;
  120. }
  122. extern FILE *fp;
  124. #define DATA_HEAD_SIZE 3
  126. char dataHead[DATA_HEAD_SIZE+1];
  127. int  HeadPrt=0,dataPrt=0 ;
  128.  
  129. int AnaRecvData(void)
  130. {
  131.   int prt,len,try_times,dataNum,ret;
  132.   char temp[MAX_READ_BUF_SIZE+1];  
  134.    prt=len=try_times=dataNum=0;
  135.    
  136. retry_read:
  137. if(try_times ++>MAX_UDP_TRY_TIMES)
  138. {
  139. ErrMsg(ghDlgJy, "recv error");
  140. DrawTime(RED_SIGN);
  141. return -1;
  142. }
  143. DrawTime(GREEN_SIGN);
  144. memset((char *)&temp[0],0,MAX_READ_BUF_SIZE*sizeof(char));
  145. len = recv(sdHq,(char *)&temp[0],MAX_READ_BUF_SIZE*sizeof(char),0);
  146. if (len == SOCKET_ERROR) 
  147. {
  148. ret =h_errno;
  149. if (ret == WSAEWOULDBLOCK)
  150. goto retry_read;
  151. else if(ret ==WSAEINPROGRESS)
  152. return 0;
  153. else
  154. {
  155. ErrMsg(ghDlgJy, GetError("recv cancel error"));
  156. if(ConnectHost(0, -1)<0)
  157. {
  158. ErrMsg(ghDlgJy, "Reconnect failed");
  159. DrawTime(RED_SIGN);
  160. return -1;
  161. }
  162. }
  163. }
  164. if(len <=0) 
  165. {
  166. DrawTime(RED_SIGN);
  167. return -1;
  168.     } 
  169.     if(len>4)
  170.     {
  171.      if(temp[0]==DATA_START_SIGN && HeadPrt!=0 &&temp[3]>='A' && temp[3]<='Z')
  172.      {
  173.       dataPrt=0; 
  174.       HeadPrt=0;
  175.      }
  176.     }
  177.     while(prt<len)
  178.     {
  179.       if(HeadPrt<DATA_HEAD_SIZE)
  180.       {
  181.       if(HeadPrt==0)
  182.       {
  183.       if(temp[prt]!=DATA_START_SIGN)
  184.       {
  185.       prt++;         //Data frame lose its start mark!
  186. DrawTime(RED_SIGN);
  187.       continue;
  188.       }     
  189.       else
  190.       {
  191. DrawTime(GREEN_SIGN);
  192.           dataHead[HeadPrt]=temp[prt];
  193.           HeadPrt++;
  194.       prt++;
  195.       }
  196.       }
  197.       if(prt>=len)
  198.       {                      //Data frame just include its start mark
  199.       DrawTime(YELLOW_SIGN);
  200.       return 0;
  201.       }
  202.       if(DATA_HEAD_SIZE - HeadPrt >len-prt)
  203.       {                      //data frame not total head info
  204.       memcpy((char*)&dataHead[HeadPrt],(char*)&temp[prt],len-prt);
  205.       HeadPrt+=len-prt;
  206. DrawTime(YELLOW_SIGN);
  207.     return 0;
  208.       }
  209.       else
  210.       {
  211.       memcpy((char*)&dataHead[HeadPrt],(char*)&temp[prt],DATA_HEAD_SIZE - HeadPrt);
  212.       prt+=DATA_HEAD_SIZE - HeadPrt;
  213.       HeadPrt=DATA_HEAD_SIZE;
  214.       }     
  215.       }
  216.      
  217.       if(prt>=len)
  218.       {                          //Just head info
  219. DrawTime(YELLOW_SIGN);
  220.       return 0;
  221.       }
  222.       dataNum=*(int *)&dataHead[1];
  223.       if(dataNum<=0)
  224.       {                          //Data Error,we must lose this bad data frame!
  225. DrawTime(RED_SIGN);
  226.       return -1;
  227.       }
  228.       if(dataNum-dataPrt  > len - prt)
  229.       {                          //Not total data frame
  230.       memcpy((char FAR *)&ReadBuf[dataPrt],(char*)&temp[prt],len-prt);
  231.       dataPrt+=len-prt;
  232. DrawTime(YELLOW_SIGN);
  233.       return 0;
  234.       }
  235.       else
  236.       {
  237.       memcpy((char FAR *)&ReadBuf[dataPrt],(char*)&temp[prt],dataNum-dataPrt);
  238.       prt+=dataNum-dataPrt;
  239.       dataPrt=dataNum;
  241.       UDP_Client_ReadHq();
  242.       dataPrt=0; 
  243.       HeadPrt=0;
  244.       dataNum=0;
  245.       }
  246.      
  247.       if(prt>=len)
  248.       {
  249.       dataPrt=0; 
  250.       HeadPrt=0;
  251.       dataNum=0;
  252. DrawTime(BLACK_SIGN);
  253.       return 0;     
  254.       }
  255.     }
  256.     DrawTime(BLACK_SIGN);
  257.     return 0;    
  258.     
  259. }
  261. int curPos =0, curLen =0;;
  262. int UDP_Client_ReadHq(void)
  263. {
  264. LPSTR lpTmp;
  265. int len;        
  266.     
  267.     len=dataPrt;
  268.     
  269. lpTmp =&ReadBuf[0];
  271. if(!strnicmp(HQ00_HEAD, lpTmp, strlen(HQ00_HEAD)))
  272. UDP_Read_Hq00(lpTmp+strlen(HQ00_HEAD)+sizeof(short), len -strlen(HQ00_HEAD)-sizeof(short));
  273. else if(!strnicmp(HQ01_HEAD, lpTmp, strlen(HQ01_HEAD)))
  274. UDP_Read_Hq01(lpTmp+strlen(HQ01_HEAD)+sizeof(short), len -strlen(HQ01_HEAD)-sizeof(short));
  275. else if(!strnicmp(HQ10_HEAD, lpTmp, strlen(HQ10_HEAD)))
  276. UDP_Read_Hq10(lpTmp+strlen(HQ10_HEAD)+sizeof(short), len -strlen(HQ10_HEAD)-sizeof(short));
  277. else if(!strnicmp(GRA00_HEAD, lpTmp, strlen(GRA00_HEAD)))
  278. UDP_Read_Gra00(lpTmp+strlen(GRA00_HEAD)+sizeof(short), len -strlen(GRA00_HEAD)-sizeof(short));
  279. else if(!strnicmp(GRA01_HEAD, lpTmp, strlen(GRA01_HEAD)))
  280. UDP_Read_Gra01(lpTmp+strlen(GRA01_HEAD)+sizeof(short), len -strlen(GRA01_HEAD)-sizeof(short));
  281. else if(!strnicmp(GRA10_HEAD, lpTmp, strlen(GRA10_HEAD)))
  282. UDP_Read_Gra10(lpTmp+strlen(GRA10_HEAD)+sizeof(short), len -strlen(GRA10_HEAD)-sizeof(short));
  283. else if(!strnicmp(MMP_HEAD, lpTmp, strlen(MMP_HEAD)))
  284. UDP_Read_Mmp(lpTmp+strlen(MMP_HEAD)+sizeof(short), len -strlen(MMP_HEAD)-sizeof(short));
  285. else if(!strnicmp(MAXMIN10_HEAD, lpTmp, strlen(MAXMIN10_HEAD)))
  286. UDP_Read_MaxMin10(lpTmp+strlen(MAXMIN10_HEAD)+sizeof(short), len -strlen(MAXMIN10_HEAD)-sizeof(short));
  287. else if(!strnicmp(DP_HEAD, lpTmp, strlen(DP_HEAD)))
  288. UDP_Read_Dp(lpTmp+strlen(DP_HEAD)+sizeof(short), len -strlen(DP_HEAD)-sizeof(short));
  289. else if(!strnicmp(ZX_HEAD, lpTmp, strlen(ZX_HEAD)))
  290. UDP_Read_Zx(lpTmp+strlen(ZX_HEAD)+sizeof(short), len -strlen(ZX_HEAD)-sizeof(short));
  291. else if(!strnicmp(MSG_HEAD, lpTmp, strlen(MSG_HEAD)))
  292. MessageBox(NULL, lpTmp+strlen(MSG_HEAD)+sizeof(short),"主机信息", MB_OK);
  293. else if(!strnicmp(GETZQMC_HEAD, lpTmp, strlen(GETZQMC_HEAD)))
  294. UDP_Read_GetZqmc(lpTmp+strlen(GETZQMC_HEAD)+sizeof(short), len -strlen(GETZQMC_HEAD)-sizeof(short));
  295. else if(!strnicmp(DATA_DAY_HEAD,lpTmp,strlen(DATA_DAY_HEAD)))
  296. UDP_Read_DataDay(lpTmp+strlen(DATA_DAY_HEAD)+sizeof(short),len -strlen(DATA_DAY_HEAD)-sizeof(short));
  297. else if(!strnicmp(HQ_CHKUSR_HEAD, lpTmp, strlen(HQ_CHKUSR_HEAD)))
  298. UDP_Read_ChkUsr(lpTmp+strlen(HQ_CHKUSR_HEAD)+sizeof(short),len -strlen(HQ_CHKUSR_HEAD)-sizeof(short));
  299. else if(!strnicmp(RECV_FILE_HEAD, lpTmp, strlen(RECV_FILE_HEAD)))
  300. UDP_Recv_File(lpTmp+strlen(RECV_FILE_HEAD),len-strlen(RECV_FILE_HEAD));
  301. else if(!strnicmp(ERROR_HEAD, lpTmp, strlen(ERROR_HEAD)))
  302. MessageBeep(0);
  303. else
  304. {
  305. DrawTime(3);
  306. MessageBeep(0);
  307. }       
  308. curPos =len-curLen;
  310. return 0;
  311. }
  313. int UDP_Read_NotRun(LPSTR lpTmp, int len)
  314. {
  315. HqTime[HqPaintData.jys].fRunning =FALSE;
  317. return 0;
  318. }
  320. extern int CheckTime(BOOL);
  321. int hq_state =-1, hq_jys =0, hq_rec_first =0, hq_rec_count =0;
  322. int UDP_Read_Hq00(LPSTR lpTmp, int len)
  323. {
  324. int i, j, jys;
  325. static int fFirst[2];
  326. time_t ltime;
  327. //struct tm *ptm;
  328. //struct _dostime_t dtime;
  330. jys =*lpTmp;
  332. lpTmp +=1;          
  333. len -=1;
  334. if(len <=0) goto readhq00Err;
  336. HqData[jys].recCount =*(short *)lpTmp;
  337. if(jys ==HqPaintData.jys)
  338. HqPaintData.recCount =HqData[jys].recCount;
  340. if(HqData[jys].recCount >MAX_HQ_REC_COUNT) goto readhq00Err;
  341. lpTmp +=sizeof(short);
  342. len -=sizeof(short);
  344. if(len <sizeof(short)*4) goto readhq00Err;
  346. memcpy(&HqTime[jys], lpTmp, sizeof(HqTime[jys])-sizeof(BOOL));
  348. len -=sizeof(HqTime[jys])-sizeof(BOOL);
  349. lpTmp +=sizeof(HqTime[jys])-sizeof(BOOL);
  351. if(jys ==0 && len >0)
  352. {
  353. memcpy(&ltime, lpTmp, sizeof(time_t));
  354. len -=sizeof(time_t);
  355. lpTmp +=sizeof(time_t);
  356. //ptm =gmtime(&ltime);
  357. //dtime.hour =ptm->tm_hour;
  358. //dtime.minute =ptm->tm_min;
  359. //dtime.second =ptm->tm_sec;
  360. //_dos_settime(&dtime);
  361. date_num =*lpTmp;
  362. lpTmp ++;
  363. len --;
  364. }
  366. HqTime[jys].am_min_count -=HqTime[jys].am_min_start;
  367. HqTime[jys].pm_min_count -=HqTime[jys].pm_min_start;
  369. i =HqTime[0].am_min_count+HqTime[0].pm_min_count+2;
  370. j =HqTime[1].am_min_count+HqTime[1].pm_min_count+2;
  371. if(j>i) i =j;
  373. if(GraphData.lpMinPos ==NULL)
  374. GraphData.lpMinPos =(short *)GlobalAllocPtr(GHND, i*sizeof(short));
  375. else
  376. GraphData.lpMinPos =(short *)GlobalReAllocPtr(GraphData.lpMinPos,
  377. i*sizeof(short), GMEM_MOVEABLE);
  379. if(GraphData.lpMinPos ==NULL)
  380. {
  381. GraphData.minEnd =0;
  382. ErrMsg(NULL,"alloc record data memory failed!");
  383. return FALSE;
  384. }
  386. if(GraphData.lpMinLc ==NULL)
  387. GraphData.lpMinLc =(long *)GlobalAllocPtr(GHND, i*sizeof(long));
  388. else
  389. GraphData.lpMinLc =(long *)GlobalReAllocPtr(GraphData.lpMinLc,
  390. i*sizeof(long), GHND);
  392. if(GraphData.lpMinLc ==NULL)
  393. {
  394. GraphData.minEnd =0;
  395. ErrMsg(NULL,"alloc record data memory failed!");
  396. return FALSE;
  397. }
  399. if(!HqAllocMem(jys))
  400. goto readhq00Err;
  402. if(HqPaintData.fldCount <=0)
  403. {
  404. HqPaintData.fldCount =HQ_FLDS_COUNT;
  405. for(i =0; i<HqPaintData.fldCount; i++)
  406. HqPaintData.fldNum[i] =i;
  407. }
  408. for(i =0; i<HqData[jys].recCount; i++)
  409. HqPaintData.sortData.key[i] =i;
  411. fFirst[jys] =0;
  412. CheckTime(FALSE);
  413. hq_state =1;
  414. return 0;
  415. readhq00Err:
  416. DrawTime(3);
  417. MessageBeep(0);
  418. return -1;
  419. }
  421. int UDP_Read_Hq01(LPSTR lpTmp, int len)
  422. {
  423. int i, jys;
  424. int recCount, recNum;
  425. BOOL isRefresh =FALSE, isSel =FALSE;
  427. jys =(BOOL)*lpTmp;
  428. lpTmp +=1; len -=1;
  429. if(len <=0)
  430. {
  431. KillTimer(ghWndHq, 5);
  432. ErrMsg(ghWndMain, "读HQ01错，数据包长度不足!");
  433.   goto readhq01Err;  
  434. }
  435. if(HqData[jys].recCount <=0)
  436. { 
  437. KillTimer(ghWndHq, 5);
  438. ErrMsg(ghWndMain, "读HQ01错，数据包记录数错！");
  439. goto readhq01Err;
  440. }
  441. isRefresh =(BOOL)*lpTmp;
  442. lpTmp++; len --;
  443. isSel =(BOOL)*lpTmp;
  444. lpTmp++; len --;
  445. recCount =*(short *)lpTmp; 
  446. if(recCount <=0)
  447. {
  448. KillTimer(ghWndHq, 5);
  449. ErrMsg(ghWndMain, "读HQ01错，读记录数为零!");
  450. goto readhq01Err;
  451. }
  452. lpTmp +=sizeof(short);
  453. len -=sizeof(short);
  454. if(len <=0) goto readhq01Err;   
  456. for(i =0; i<recCount; i++)
  457. {
  458. if(len <0) break;
  459. recNum =*(short *)lpTmp;
  460. len-=2; lpTmp +=2;
  461. if(recNum >=HqData[jys].recCount)
  462. {
  463. ErrMsg(ghWndMain, "读HQ01错，读记录编号大于记录数!");
  464. goto readhq01Err;
  465. }   
  466. if(!isRefresh)
  467. {
  468. memcpy(&HqData[jys].lpPreData[recNum],
  469. lpTmp, sizeof(HQ_PRE_DATA));
  470. len -=sizeof(HQ_PRE_DATA);
  471. lpTmp +=sizeof(HQ_PRE_DATA);
  472. }
  473. memcpy(&HqData[jys].lpRefData[recNum],
  474. lpTmp, sizeof(HQ_REF_DATA));
  475. len -=sizeof(HQ_REF_DATA);
  476. lpTmp +=sizeof(HQ_REF_DATA);
  477. HqData[jys].isReadOK[recNum] =TRUE;
  478. }
  479. if(IsWindowVisible(ghWndHq))
  480. SendMessage(ghWndHq, WM_HQ_REFRESH, jys, 0L);
  481. return 0;
  482. readhq01Err:
  483. DrawTime(3);
  484. MessageBeep(0);
  485. return -1;
  486. }
  488. int UDP_Read_Hq10(LPSTR lpTmp, int len)
  489. {
  490. int i, jys;
  491. int rec_count, rec_num;
  492. float oldjg;
  493. //long lc;
  495. jys =*lpTmp++;
  496. len --;
  497. if(jys >1) goto readhq10Err;
  499. rec_count =*(short *)lpTmp; 
  500. lpTmp+=2; len -=2;
  501. if(rec_count >HqData[jys].recCount || rec_count <=0) goto readhq10Err;
  502. //if(rec_count >MAX_HQ_SENDCOUNT) goto readhq10Err;
  503. if(len <rec_count*(int)sizeof(HQ_REF_DATA))
  504. goto readhq10Err;
  506. //memcpy(&HqData[jys].lpRefData[rec_first], rec_count*sizeof(HQ_REF_DATA));
  508. for(i =0; i<rec_count; i++)
  509. {
  510. if(len <=0) break;
  511. rec_num =*(short *)lpTmp;
  512. if(rec_num >HqData[jys].recCount) break;
  513. lpTmp+=sizeof(short);
  514. len -=sizeof(short);
  515. oldjg =HqData[jys].lpRefData[rec_num].zjjg;
  516. memcpy(&HqData[jys].lpRefData[rec_num], lpTmp, sizeof(HQ_REF_DATA));
  517. HqData[jys].isJgChanged[rec_num] =(BOOL)((HqData[jys].lpRefData[rec_num].zjjg-oldjg)*100);
  518. if(HqData[jys].isJgChanged[rec_num])    MessageBeep(0);
  519. len -=sizeof(HQ_REF_DATA);
  520. lpTmp +=sizeof(HQ_REF_DATA);
  522. HqData[jys].isLcChanged[rec_num] =TRUE;
  523. }
  525. if(IsWindowVisible(ghWndHq))
  526. SendMessage(ghWndHq, WM_HQ_REFRESH, jys, 0L);
  527. else if(IsWindowVisible(ghWndLitHq))
  528. {
  529. SendMessage(ghWndLitHq, WM_READ_OK, jys, 0L);
  530. }
  532. return 0;
  534. readhq10Err:
  535. DrawTime(3);
  536. return -1;
  537. }
  538. ////////////////////////////////////////////////////////////////////////////
  539. //Function:This func receive deatial pricr voulmn file head information data
  540. //         from server,then get memory according to minTotal data.
  541. //
  542. int UDP_Read_Gra00(LPSTR lpTmp, int len)
  543. {
  544. int jys;
  546. jys =*lpTmp;
  547. if(GraphData.jys !=jys) return 0;
  549. lpTmp +=1; len -=1;
  550. if(len <=0) return -1;
  552. memcpy(&GraphData.GraHead, lpTmp, sizeof(GRA_HEAD));
  553. //GraphData.GraHead.zrsp =HqData[jys].lpPreData[GraphData.recNum].zrsp;
  555. if(GraphData.lpGraData ==NULL)
  556. GraphData.lpGraData =(GRA_DATA huge *)GlobalAllocPtr(GHND,
  557. (long)GraphData.GraHead.minTotal*sizeof(GRA_DATA));
  558. else
  559. GraphData.lpGraData =(GRA_DATA huge *)GlobalReAllocPtr(
  560. GraphData.lpGraData,(long)GraphData.GraHead.minTotal*sizeof(GRA_DATA),
  561. GMEM_MOVEABLE);
  563. if(GraphData.lpGraData ==NULL)
  564. {
  565. ErrMsg(NULL, "不能分配成交明细数据内存!");
  566. return -1;
  567. }
  569. GraRecalcJgMax();
  570. GraRecalcLcMax();
  571. return 0;
  572. }
  574. ////////////////////////////////////////////////////////////////////////
  575. //This func to get data info from server,then compute it
  576. //
  577. int UDP_Read_Gra01(LPSTR lpTmp, int len)
  578. {
  579. int min_num, min_count;
  580. char temp[128];
  581. HFILE hf;
  582. OFSTRUCT os;
  584. if(GraphData.lpGraData ==NULL)
  585. return 0;
  586. if(*lpTmp++ !=GraphData.jys)
  587. return -1;
  588. len -=1;
  589. if(len <=0) return -1;
  591. if(*(int *)lpTmp !=GraphData.recNum)
  592. return -1;
  593. lpTmp +=sizeof(int);
  594. len -=sizeof(int);
  595. if(len <=0) return -1;
  597. min_count =*(int *)lpTmp; //data num this times
  598. lpTmp +=sizeof(int);
  599. len -=sizeof(int);
  600. if(len <=0) return -1;
  602. min_num =*(int *)lpTmp;   //Last data tail
  603. lpTmp +=sizeof(int);
  604. len -=sizeof(int);
  605. if(len <=0) return -1;
  606. if(min_num +min_count >GraphData.GraHead.minTotal) return -1;
  608. min_count =len/sizeof(GRA_DATA);
  609. memcpy(&GraphData.lpGraData[min_num], lpTmp, min_count*sizeof(GRA_DATA));
  610. //GraphData.GraHead.zrsp =HqData[GraphData.jys].lpPreData[GraphData.recNum].zrsp;
  612. GraphData.minEndPrev =min_num;
  613. GraphData.minEnd =min_num+min_count;
  614. GraphData.fRefreshDraw =TRUE;
  616. GraGetMinPos();
  617. wsprintf(temp, "%s\%s.dat", szDataPath, HqData[GraphData.jys].lpPreData[GraphData.recNum].zqdm);
  618. hf =OpenFile(temp, &os, OF_SHARE_DENY_NONE|OF_READWRITE);
  619. if(hf ==HFILE_ERROR)
  620. hf =OpenFile(temp, &os, OF_SHARE_DENY_NONE|OF_CREATE|OF_WRITE);
  621. if(hf !=HFILE_ERROR)
  622. {
  623. if(_lwrite(hf, &GraphData.GraHead, sizeof(GraphData.GraHead))
  624. ==sizeof(GraphData.GraHead))
  625. {
  626. if(_llseek(hf, (long)sizeof(GRA_HEAD)
  627. +(long)sizeof(GRA_DATA)*min_num, SEEK_SET)
  628. ==HFILE_ERROR)
  629. {
  630. _llseek(hf, sizeof(GRA_HEAD), SEEK_SET);
  631. _hwrite(hf, &GraphData.lpGraData[0],
  632. (long)sizeof(GRA_DATA)*min_num);
  633. }
  634. _hwrite(hf, &GraphData.lpGraData[min_num],
  635. (long)sizeof(GRA_DATA)*min_count);
  636. }
  637. _lclose(hf);
  638. }
  640. GraphData.fRefreshDraw =FALSE;
  641. if(IsWindowVisible(ghWndXlt))
  642. {
  643. if(GraRecalcJgMax() ==0)
  644. SendMessage(ghWndXlt, WM_READ_OK, 1, 0L);
  645. else SendMessage(ghWndXlt, WM_READ_OK, 0, 0L);
  647. if(GraRecalcLcMax() ==0)
  648. InvalidateRect(ghWndJlt, NULL, TRUE);
  649. else
  650. InvalidateRect(ghWndJlt, NULL, FALSE);
  651. SendMessage(ghWndCj, WM_READ_OK, 0, 0L);
  652. }
  653. return 0;
  654. }
  656. int UDP_Read_Gra10(LPSTR lpTmp, int len)
  657. {
  658. int min_num, min_count;
  659. char temp[128];
  660. HFILE hf;
  661. OFSTRUCT os;
  662. GRA_HEAD GraHead;
  664. if(GraphData.lpGraData ==NULL) return 0;
  665. if(*lpTmp++ !=GraphData.jys !=0) goto readgra10Err;
  666.     
  667. len -=1;
  668. if(len <=0) goto readgra10Err;
  670. if(*(int *)lpTmp !=GraphData.recNum) goto readgra10Err;
  671. lpTmp+=sizeof(int);
  672. len-=sizeof(int);
  674. min_count =*(int *)lpTmp;
  675. lpTmp +=sizeof(int);
  676. len -=sizeof(int);
  677. if(len <=0) goto readgra10Err;
  679. min_num =*(int *)lpTmp;
  680. if(min_num !=GraphData.minEnd)
  681. {
  682. MessageBeep(0);
  683. //goto readgra10Err;
  684. }
  685. lpTmp +=sizeof(int);
  686. len -=sizeof(int);
  687. if(len <=0) goto readgra10Err;
  689. //memcpy(&GraHead, lpTmp, sizeof(GRA_HEAD));
  690. //lpTmp +=sizeof(GRA_HEAD);
  691. //len -=sizeof(GRA_HEAD);
  693. min_count =len/sizeof(GRA_DATA);
  694. GraphData.lpGraData =(GRA_DATA huge *)GlobalReAllocPtr(
  695. GraphData.lpGraData,
  696. (long)(min_num+min_count)*sizeof(GRA_DATA),
  697. GMEM_MOVEABLE);
  698. if(GraphData.lpGraData ==NULL)
  699. {
  700. ErrMsg(NULL, "Gra10: alloc mem failed");
  701. return -1;
  702. }
  703. memcpy(&GraphData.lpGraData[min_num], lpTmp, min_count*sizeof(GRA_DATA));
  705. GraphData.minEndPrev =min_num;
  706. GraphData.GraHead.minTotal =GraphData.minEnd =min_num+min_count;
  708. GraphData.fRefreshDraw =TRUE;
  710. GraGetMinPos();
  712. if(IsWindowVisible(ghWndXlt))
  713. {
  714. if(GraRecalcJgMax() ==0)
  715. SendMessage(ghWndXlt, WM_READ_OK, 1, 0L);
  716. else SendMessage(ghWndXlt, WM_READ_OK, 0, 0L);
  718. if(GraRecalcLcMax() ==0)
  719. InvalidateRect(ghWndJlt, NULL, TRUE);
  720. else
  721. InvalidateRect(ghWndJlt, NULL, FALSE);
  722. InvalidateRect(ghWndCj, NULL, TRUE);
  723. }
  725. wsprintf(temp, "%s\%s.dat", szDataPath, HqData[GraphData.jys].lpPreData[GraphData.recNum].zqdm);
  726. hf =OpenFile(temp, &os, OF_SHARE_DENY_NONE|OF_READ);
  727. if(hf !=HFILE_ERROR)
  728. {
  729. memcpy(&GraHead, &GraphData.GraHead, sizeof(GraHead));
  730. GraHead.minTotal =GraphData.minEnd;
  731. if(_lwrite(hf, &GraHead, sizeof(GraHead)) ==sizeof(GraHead))
  732. {
  733. if(_llseek(hf, (long)sizeof(GRA_HEAD)
  734. +(long)sizeof(GRA_DATA)*min_num, SEEK_SET)
  735. ==HFILE_ERROR)
  736. {
  737. _llseek(hf, sizeof(GRA_HEAD), SEEK_SET);
  738. _hwrite(hf, &GraphData.lpGraData[0],
  739. (long)sizeof(GRA_DATA)*min_num);
  740. }
  741. _hwrite(hf, &GraphData.lpGraData[min_num],
  742. (long)sizeof(GRA_DATA)*min_count);
  743. }
  744. _lclose(hf);
  745. }
  746. GraphData.fRefreshDraw =FALSE;
  748. if(IsWindowVisible(ghWndXlt))
  749. {
  750. if(GraRecalcJgMax() ==0)
  751. SendMessage(ghWndXlt, WM_READ_OK, 1, 0L);
  752. else SendMessage(ghWndXlt, WM_READ_OK, 0, 0L);
  754. if(GraRecalcLcMax() ==0)
  755. InvalidateRect(ghWndJlt, NULL, TRUE);
  756. else
  757. InvalidateRect(ghWndJlt, NULL, FALSE);
  758. InvalidateRect(ghWndCj, NULL, TRUE);
  759. }
  761. return 0;
  763. readgra10Err:
  764. DrawTime(3);
  765. return -1;      
  766. }
  768. int UDP_Read_Mmp(LPSTR lpTmp, int len)
  769. {
  770. int jys;
  772. jys =*lpTmp;
  774. lpTmp ++;          
  775. len --;
  776. if(len <=0) goto readmmpErr;
  778. //if(*(int *)lpTmp !=rec_num) goto sendmmp;
  779. len -=sizeof(int);
  780. lpTmp +=sizeof(int);
  781.     
  782. if(len !=sizeof(MMP_DATA)-2*sizeof(int)) goto readmmpErr;
  783. memcpy(&MmpData.jwBuy[0], lpTmp, sizeof(MMP_DATA)-2*sizeof(int));
  785. InvalidateRect(ghWndMmp, NULL, TRUE);
  786. return 0;
  788. readmmpErr:
  789. DrawTime(3);
  790. return -1;
  791. }
  793. int UDP_Read_MaxMin10(LPSTR lpTmp, int len)
  794. {
  795. int jys, i, j, recCount;
  796. int maxmin;
  797. char  WriteBuf[MAX_WRITE_BUF_SIZE+1];
  798.    
  799. jys =*lpTmp;
  800. if(jys !=GraphData.jys) return 0;
  801. lpTmp +=1;          
  802. len -=1;
  804. maxmin =*lpTmp;
  805. if(maxmin >1)
  806. {
  807. MessageBeep(0);
  808. return -1;
  809. }
  811. lpTmp++;
  812. len --;
  813. if(len <sizeof(MAXMIN_DATA)) goto readmaxmin10Err;
  815. memcpy(&MaxMinData[jys][maxmin], lpTmp, sizeof(MAXMIN_DATA));
  816. MaxMinChangeHqData(jys, maxmin);
  817. strcpy(WriteBuf, GETZQMC_HEAD);
  818. len =strlen(WriteBuf);
  819. WriteBuf[len++] =jys;
  820. *(short *)&WriteBuf[len] =0;
  821. len +=sizeof(short);
  823. recCount =0;
  824. for(i =0; i<4; i++)
  825. {
  826. for(j =0; j<10; j++)
  827. {
  828. if(HqData[jys].lpPreData[MaxMinData[jys][maxmin].recNum[i][j]].zqmc[0] ==0)
  829. {
  830. *(short *)&WriteBuf[len] =MaxMinData[jys][maxmin].recNum[i][j];
  831. len +=sizeof(short);
  832. recCount ++;
  833. }
  834. }
  835. }
  836. if(recCount)
  837. {
  838. *(short *)&WriteBuf[strlen(GETZQMC_HEAD)+1] =recCount;
  839. UDP_Send_Hq(WriteBuf, GETZQMC_HEAD, len);
  840. }       
  841. InvalidateRect(ghWndMaxMin, NULL, TRUE);
  843. return 0;
  845. readmaxmin10Err:
  846. DrawTime(3);
  847. return -1;
  848. }
  850. int UDP_Read_GetZqmc(LPSTR lpTmp, int len)
  851. {
  852. int jys, i, recCount, recNum;
  854. jys =*lpTmp++;
  855. recCount =*(short *)lpTmp;
  856. lpTmp +=sizeof(short);
  857. for(i =0; i<recCount; i++)
  858. {
  859. recNum =*(short *)lpTmp;
  860. lpTmp+=sizeof(short);
  861. if(recNum >HqData[jys].recCount) return -1;
  862. strncpy(HqData[jys].lpPreData[recNum].zqmc, lpTmp, MAX_ZQMC_SIZE);
  863. lpTmp +=MAX_ZQMC_SIZE;
  864. }
  865. if(IsWindowVisible(ghWndMaxMin))
  866. InvalidateRect(ghWndMaxMin, NULL, FALSE);
  868. return 0;
  869. }
  871. int UDP_Read_Dp(LPSTR lpTmp, int len)
  872. {
  873. int jys;
  875. if(len <sizeof(DpData)) goto readdpErr;
  876. memcpy(&DpData, lpTmp, sizeof(DpData));
  877. for(jys =0; jys<2; jys ++)
  878. if(DpData[jys].npbl >(float)1 || DpData[jys].npbl <(float)0)
  879. DpData[jys].npbl =(float)0.5;
  880. if(ghWndStatus) InvalidateRect(ghWndStatus, NULL, FALSE);
  881. return 0;
  883. readdpErr:
  884. DrawTime(3);
  885. return -1;
  886. }
  888. int UDP_Send_Zx(void)
  889. {
  890. int len;
  891. char  WriteBuf[MAX_WRITE_BUF_SIZE+1];
  893. strcpy(WriteBuf, ZX_HEAD);
  894. len =strlen(WriteBuf);
  895. *(long *)&WriteBuf[len] =ZxData.len;
  896. len +=sizeof(long);
  897. return UDP_Send_Hq(WriteBuf, ZX_HEAD, len);
  898. }
  900. int UDP_Send_Stock_Info(STOCK_INFO_FRAME *StockInfoFrame)
  901. {
  902.    int len;
  903.    char  WriteBuf[MAX_WRITE_BUF_SIZE+1];
  904.    
  905.    strcpy(WriteBuf,STOCK_INFO_HEAD);
  906.    len=strlen(STOCK_INFO_HEAD);
  907.    memcpy(&WriteBuf[len],StockInfoFrame,sizeof(STOCK_INFO_FRAME));
  908.    len+=sizeof(STOCK_INFO_FRAME);
  909.    return UDP_Send_Hq(WriteBuf,STOCK_INFO_HEAD,len);
  910. }
  912. int UDP_Read_Zx(LPSTR lpTmp, int len)
  913. {
  914.     char temp[80];
  915.     OFSTRUCT os;
  916.     
  917. strcpy(temp, szDataPath);
  918. strcat(temp, "\zx.txt");
  919. hfZx =OpenFile(temp, &os, OF_SHARE_DENY_NONE|OF_READWRITE);
  920. if(hfZx ==HFILE_ERROR) return(-1);
  921. if(len <=0)
  922. {
  923. _lclose(hfZx);
  924. return(-1);
  925. }
  926. _llseek(hfZx, 0, SEEK_END);
  927. ZxData.len +=len;
  928. _lwrite(hfZx, lpTmp, len);
  929. _lclose(hfZx);
  930. SendMessage(ghWndCaption, WM_USER+1, 0, (LPARAM)(ZxData.len-len));
  931. return 0;
  932. }
  934. int UDP_Send_Hq00(int jys, BOOL fFirst, int fRefresh, int fSel, int recCount, short *recList)
  935. {
  936. int i, len, rec_num, list_count;
  937. char WriteBuf[MAX_WRITE_BUF_SIZE+1];
  939. //hq_state =0;
  940. //hq_jys =jys;
  941. KillTimer(ghWndHq, 5);
  942. SetTimer(ghWndHq, 5, 5000, NULL);
  944. strcpy(WriteBuf, HQ00_HEAD);
  945. len =strlen(HQ00_HEAD);
  946. WriteBuf[len++] =CLIENT_VERSION;
  947. WriteBuf[len++] =(BYTE)jys;
  948. if(HqData[jys].isReadOK ==NULL || HqData[jys].isReadOK[0] ==FALSE)
  949. fFirst =TRUE;
  950. WriteBuf[len++] =(BYTE)fFirst;
  951. WriteBuf[len++] =(BYTE)fRefresh;
  952. WriteBuf[len++] =(BYTE)fSel;
  953. *(short *)&WriteBuf[len] =recCount;
  954. len +=sizeof(short);
  956. if(!fSel) list_count =1;
  957. else list_count =recCount;
  959. memcpy(&WriteBuf[len], recList, sizeof(short)*list_count);
  960. len +=sizeof(short)*list_count;
  961. if(fRefresh)
  962. {
  963. for(i =0; i<recCount; i++)
  964. {
  965. if(fSel) rec_num =recList[i];
  966. else rec_num =recList[0]+i;
  967. *(long *)&WriteBuf[len] =HqData[jys].lpRefData[rec_num].cjss;
  968. len +=sizeof(long);
  969. }
  970. }
  971. return UDP_Send_Hq(&WriteBuf[0], HQ00_HEAD, len);
  972. }
  974. ////////////////////////////////////////////////////////////////////////
  975. //Function :to draw price-volumn diagram per min,This func open deatail 
  976. //           data file according to stock code,compute it,biuld integer
  977. //  set diagram data.then send a requst to server to get other 
  978. //           deatail voulmn file on server
  979. //
  980. //
  982. int UDP_Send_Gra00(int jys, int rec_num)
  983. {
  984. HFILE hf;
  985. OFSTRUCT os;
  986. char temp[100];
  987. int len = 0;   
  988. char  WriteBuf[MAX_WRITE_BUF_SIZE+1];
  989.                 
  990. KillTimer(ghWndHq, 5);
  992. GraphData.jys =jys;
  993. GraphData.recNum =rec_num;
  995. GraphData.minEndPrev =0;
  996. GraphData.minEnd =0;
  997. GraphData.GraHead.dateNum =date_num;
  998.     
  999. wsprintf(temp, "%s\%s.dat", szDataPath, HqData[jys].lpPreData[rec_num].zqdm);
  1000. hf =OpenFile(temp, &os, OF_SHARE_DENY_NONE|OF_READ);
  1001. if(hf !=HFILE_ERROR)
  1002. {
  1003. if(_lread(hf, &GraphData.GraHead, sizeof(GraphData.GraHead))
  1004. ==sizeof(GraphData.GraHead))
  1005. {
  1006. if(gfOnLine && GraphData.GraHead.dateNum !=date_num)
  1007. {
  1008. GraphData.GraHead.dateNum =date_num;
  1009. GraphData.minEnd =GraphData.minEndPrev =GraphData.GraHead.minTotal =0;
  1010. goto read_ok;
  1011. }
  1012. if(GraphData.GraHead.minTotal)
  1013. {
  1014. if(GraphData.lpGraData ==NULL)
  1015. GraphData.lpGraData =(GRA_DATA huge *)GlobalAllocPtr(GHND,
  1016. (long)GraphData.GraHead.minTotal*sizeof(GRA_DATA));
  1017. else
  1018. GraphData.lpGraData =(GRA_DATA huge *)GlobalReAllocPtr(
  1019. GraphData.lpGraData,
  1020. (long)GraphData.GraHead.minTotal*sizeof(GRA_DATA),
  1021. GHND);
  1023. if(GraphData.lpGraData !=NULL)
  1024. {
  1025. if(_hread(hf, &GraphData.lpGraData[0],
  1026. (long)GraphData.GraHead.minTotal*sizeof(GRA_DATA))
  1027. !=(long)GraphData.GraHead.minTotal*sizeof(GRA_DATA))
  1028. {
  1029. GraphData.GraHead.dateNum =date_num;
  1030. GraphData.minEndPrev =GraphData.minEnd =0;
  1031. }
  1032. else
  1033. {
  1034. GraphData.minEndPrev =0;
  1035. GraphData.minEnd =GraphData.GraHead.minTotal;
  1036. GraGetMinPos();
  1037. GraRecalcJgMax();
  1038. GraRecalcLcMax();
  1040. if(IsWindowVisible(ghWndXlt))
  1041. {
  1042. SendMessage(ghWndJlt, WM_READ_OK, 0, 0L);
  1043. if(!IsZsRec(GraphData.jys, GraphData.recNum))
  1044. SendMessage(ghWndCj, WM_READ_OK, 0, 0L);
  1045. }
  1046. }
  1047. }
  1048. else
  1049. {
  1050. ErrMsg(NULL, "Alloc mem failed!");
  1051. _lclose(hf);
  1052. return -1;
  1053. }
  1054. }
  1055. }
  1056. read_ok:
  1057. _lclose(hf);
  1058. }                       
  1059. //GraphData.GraHead.zrsp =HqData[jys].lpPreData[rec_num].zrsp;
  1061. strcpy(WriteBuf, GRA00_HEAD);
  1062. len =strlen(WriteBuf);
  1063. WriteBuf[len++] =jys;
  1064. WriteBuf[len++] =(BYTE)GraphData.GraHead.dateNum;
  1065. *((int *)&WriteBuf[len]) =rec_num;
  1066. len +=sizeof(int);
  1067. *(short *)&WriteBuf[len] =GraphData.minEnd;
  1068. len +=sizeof(short);
  1070. return UDP_Send_Hq(&WriteBuf[0], GRA00_HEAD, len);
  1071. }
  1073. int UDP_Send_Gra01(void)//int min_first, int min_count)
  1074. {
  1075. int len= 0;   
  1076. char  WriteBuf[MAX_WRITE_BUF_SIZE+1];
  1078. strcpy(WriteBuf, GRA01_HEAD);
  1079. len =strlen(WriteBuf);
  1080. WriteBuf[len++] =(BYTE)GraphData.jys;
  1081. *((int *)&WriteBuf[len]) =GraphData.recNum;
  1082. len +=sizeof(int);
  1083. *((int *)&WriteBuf[len]) =GraphData.minEnd;
  1084. len +=sizeof(int);
  1086. return UDP_Send_Hq(&WriteBuf[0], GRA00_HEAD, len);
  1087. }
  1089. /////////////////////////////////////////////////////////
  1090. int CompString(LPSTR lpstr1, LPSTR lpstr2)
  1091. {
  1092. int len;
  1094. if(*lpstr1 =='-' && *lpstr2 !='-') return -1;
  1095. if(*lpstr1 !='-' && *lpstr2 =='-') return 1;
  1097. len =strlen(lpstr1) -strlen(lpstr2);
  1098. if(*lpstr1 =='-' && *lpstr2 =='-')
  1099. {
  1100. if(len) return 0-len;
  1101. return (0-strcmp(lpstr1, lpstr2));
  1102. }
  1103. else
  1104. {
  1105.     if(len) return len;
  1106. return strcmp(lpstr1, lpstr2);
  1107. }
  1108. }
  1110. int StringSub(LPSTR lpstr1, LPSTR lpstr2, LPSTR lpres, int s_type)
  1111. {
  1112. int n;
  1113. double f;
  1114. long l;
  1116. switch(s_type)
  1117. {
  1118. case SSUB_FLOAT:
  1119. f =atof(lpstr1)-atof(lpstr2);
  1120. wsprintf(lpres, "%f", (float)f);
  1121. break;
  1122. case SSUB_INT:
  1123. n =atoi(lpstr1)-atoi(lpstr2);
  1124. wsprintf(lpres, "%d", n);
  1125. break;
  1126. case SSUB_LONG:
  1127. l =atol(lpstr1)-atol(lpstr2);
  1128. wsprintf(lpres, "%ld", l);
  1129. break;
  1130. default:
  1131. return -1;
  1132. }
  1134. return 0;
  1135. }
  1137. int GraGetMinPos(void)
  1138. {
  1139. int i, j;
  1140. int tim, tim1;
  1141. long lc;
  1143. if(GraphData.minEnd <=0)
  1144. {
  1145. GraphData.minCount =0;
  1146. return 0;
  1147. }
  1149. tim =GraphData.lpGraData[0].tim;
  1151. tim1 =tim;
  1153. GraphData.minCount =0;
  1154. GraphData.lpMinPos[0] =0;
  1156. for(i =0; i<GraphData.minEnd;)
  1157. {      
  1158.     
  1159. lc =0;
  1160. while(i<GraphData.minEnd)
  1161. {
  1162. tim1 =GraphData.lpGraData[i].tim;
  1163. if(tim1 >tim)
  1164. {
  1165. //i++;
  1166. //tim=tim1;
  1167. break;
  1168. }
  1169. lc +=GraphData.lpGraData[i].lc;
  1170. i++;
  1171. }
  1172. if(i-1<GraphData.minEnd && tim >0)
  1173. {
  1174. j =i-1;
  1175. GraphData.lpMinLc[GraphData.minCount] =lc;
  1176. GraphData.lpMinPos[GraphData.minCount++] =j;
  1177. }
  1178. tim =tim1;
  1179. }
  1180. return 0;
  1181. }
  1183. int GraRecalcJgMax()
  1184. {
  1185. int i;
  1186. float min_val, max_val, f1;
  1188. if(GraphData.minCount <=0) return 0;
  1190. min_val =max_val =GraphData.lpGraData[0].zjjg;
  1191. //max_val =GraphData.GraHead.zgjg;
  1193. for(i =1; i<GraphData.minCount && i<GraphData.minEnd; i++)
  1194. {
  1195. if(min_val >GraphData.lpGraData[GraphData.lpMinPos[i]].zjjg)
  1196. min_val =GraphData.lpGraData[GraphData.lpMinPos[i]].zjjg;
  1197. if(max_val <GraphData.lpGraData[GraphData.lpMinPos[i]].zjjg)
  1198. max_val =GraphData.lpGraData[GraphData.lpMinPos[i]].zjjg;
  1199. }
  1200. if(min_val ==0) min_val -=(float)0.001;
  1201. if(max_val ==0) max_val +=(float)0.001;
  1202. //min_val =(float)(min_val*(1-0.001)-0.01);
  1203. //max_val =(float)(max_val*(1+0.001)+0.01);
  1205. if(max_val <0) max_val *=-1;
  1206. if(min_val <0) min_val *=-1;
  1207. if(min_val >max_val) max_val =min_val;
  1209. f1 =0;
  1210. /*while(1)
  1211. {
  1212. if((f1+0.05)*5>max_val)
  1213. {
  1214. max_val =(float)((f1+0.05)*5);
  1215. f1+=(float)0.05;
  1216. break;
  1217. }
  1218. f1+=(float)0.05;
  1219. }
  1220. */
  1221. max_val =max_val+GraphData.GraHead.zrsp*(float)0.002;
  1223. GraphData.GraHead.zgjg =max_val;
  1224. GraphData.GraHead.zdjg =0-max_val;
  1226. return 0;
  1227. }
  1229. int GraRecalcLcMax()
  1230. {
  1231. int i;
  1233. long max_val =GraphData.lpMinLc[0];
  1235. if(GraphData.minCount <=0) return 0;
  1237. for(i =1; i<GraphData.minCount && i<GraphData.minEnd; i++)
  1238. {
  1239. if(max_val <GraphData.lpMinLc[i])
  1240. max_val =GraphData.lpMinLc[i];
  1241. }
  1242. max_val =(long)((double)max_val*(1+0.2)+5);
  1244. GraphData.GraHead.zglc =max_val;
  1246. return 0;
  1247. }
  1249. int MaxMinChangeHqData(int jys, int maxmin)
  1250. {
  1251. int i, j;
  1253. for(i =0; i<4; i++)
  1254. for(j =0; j<10; j++)
  1255. {
  1256. /////////////
  1257. if(MaxMinData[jys][maxmin].recNum[i][j] >=HqData[jys].recCount)
  1258. return -1;
  1259. HqData[jys].lpRefData[MaxMinData[jys][maxmin].recNum[i][j]].zjjg
  1260. =MaxMinData[jys][maxmin].MaxMin[i][j].zjjg;
  1261. HqData[jys].lpRefData[MaxMinData[jys][maxmin].recNum[i][j]].zdf
  1262. =MaxMinData[jys][maxmin].MaxMin[i][j].zdf;
  1263. HqData[jys].lpRefData[MaxMinData[jys][maxmin].recNum[i][j]].cjss
  1264. =MaxMinData[jys][maxmin].MaxMin[i][j].cjss;
  1265. }
  1266. return 0;
  1267. }
  1269. void UDP_Send_Exit(void)
  1270. {
  1271. int i, len,x,tlen;
  1272. char temp[40];
  1274. temp[0]=DATA_START_SIGN;
  1275. *(int*)&temp[1]=strlen(CLNT_EXIT);
  1276. memcpy(&temp[1+sizeof(int)],CLNT_EXIT,strlen(CLNT_EXIT));
  1277. tlen =1+sizeof(int)+strlen(CLNT_EXIT);
  1278. for(i =0,x=0; i<10; i++)
  1279. {
  1280. len =send(sdHq, &temp[x],tlen -x, 0);
  1281. if (len == SOCKET_ERROR)
  1282. {
  1283. if (h_errno == WSAEWOULDBLOCK)
  1284. continue;
  1285. else 
  1286. return;
  1287. }
  1288. if(x+len!=tlen)
  1289. x+=len;
  1290. else
  1291. break;
  1292. }
  1293. }
  1296. int UDP_Read_DataDay(LPSTR lpTmp, int len)
  1297. {
  1299. char temp[128];
  1300. char jys;
  1301. int gp_rec_num,sendCount,sendNum,i;
  1302. HFILE hf;
  1303. OFSTRUCT os;
  1304. DAY_DATA DataDayBuff;
  1306. jys=*lpTmp++;
  1307. len -=1;
  1308. if(len <=0) goto ReadDataDayErr;
  1310. gp_rec_num=*(int *)lpTmp;
  1311. lpTmp +=sizeof(int);
  1312. len -=sizeof(int);
  1313. if(len <=0) goto ReadDataDayErr;
  1315. sendCount=*(int *)lpTmp;
  1316. lpTmp +=sizeof(int);
  1317. len -=sizeof(int);
  1318. if(len <=0) goto ReadDataDayErr;
  1320. sendNum=*(int *)lpTmp;
  1321. lpTmp +=sizeof(int);
  1322. len -=sizeof(int);
  1323. if(len <=0) goto ReadDataDayErr;
  1325. wsprintf(temp, "%s\%s.day",szDataPath, HqData[GraphData.jys].lpPreData[GraphData.recNum].zqdm);
  1326. hf =OpenFile(temp, &os, OF_SHARE_DENY_NONE|OF_READWRITE);
  1327. if(hf ==HFILE_ERROR)
  1328. hf =OpenFile(temp, &os, OF_SHARE_DENY_NONE|OF_CREATE|OF_WRITE);
  1329. if(hf !=HFILE_ERROR)
  1330. {
  1331. for(i=0;i<sendCount;i++) 
  1332. {
  1333.        memset(&DataDayBuff,0,sizeof(DAY_DATA));
  1334.        memcpy(&DataDayBuff,lpTmp,sizeof(DAY_DATA));
  1335.        lpTmp+=sizeof(DAY_DATA);
  1336.        len-=sizeof(DAY_DATA);
  1337.        if(len<0)
  1338.        {
  1339.     goto  ReadDataDayErr;
  1340.        }
  1341.        _llseek(hf, 0l, SEEK_END);
  1342.        _lwrite(hf, &DataDayBuff, sizeof(DAY_DATA));
  1343. }
  1344. _lclose(hf);
  1345. }
  1347. if(IsWindowVisible(ghWndFx))
  1348. {   
  1349.     Fx->IsDataOk=FALSE;
  1350. InvalidateRect(ghWndFx, NULL, TRUE);
  1352. }
  1354. return TRUE;
  1356. ReadDataDayErr:
  1358. return FALSE;
  1359. }
  1362. int UDP_Send_DataDay(int jys, int rec_num)
  1363. {
  1364. int len = 0,data_rec_end;   
  1365.     char temp[128];
  1366. char  WriteBuf[MAX_WRITE_BUF_SIZE+1];
  1367.     
  1368. HFILE hf;
  1369. OFSTRUCT os;
  1370. wsprintf(temp, "%s\%s.day", szDataPath,HqData[GraphData.jys].lpPreData[GraphData.recNum].zqdm);
  1371. hf =OpenFile(temp, &os, OF_SHARE_DENY_NONE|OF_READWRITE);
  1372. if(hf ==HFILE_ERROR)
  1373. data_rec_end=0;
  1374.     else
  1375.     {
  1376. data_rec_end=(int)_llseek(hf, 0l, SEEK_END)/sizeof(DAY_DATA);
  1377.     }           
  1378.     _lclose(hf);
  1379. strcpy(WriteBuf, DATA_DAY_HEAD);
  1380. len=strlen(DATA_DAY_HEAD);
  1381. WriteBuf[len]=jys;
  1382. len++;
  1383. *((int *)&WriteBuf[len]) =rec_num;
  1384. len +=sizeof(int);
  1385. *((int *)&WriteBuf[len]) =data_rec_end;        
  1386. len +=sizeof(int);
  1388. return UDP_Send_Hq(&WriteBuf[0], DATA_DAY_HEAD, len);
  1389. }
  1391. int HqCheckUser(char *userID, char *userPwd)
  1392. {
  1393. int len;
  1394. char  WriteBuf[MAX_WRITE_BUF_SIZE+1];
  1395.                
  1396.                
  1397. strcpy(WriteBuf, HQ_CHKUSR_HEAD);
  1398. len=strlen(HQ_CHKUSR_HEAD);
  1399. memcpy(&WriteBuf[len], userID, HQ_USERID_SIZE);
  1400. len +=HQ_USERID_SIZE;
  1401. memcpy(&WriteBuf[len], userPwd, HQ_USERPWD_SIZE);
  1402. len +=HQ_USERPWD_SIZE;
  1404. return UDP_Send_Hq(&WriteBuf[0], HQ_CHKUSR_HEAD, len);
  1405. }
  1407. extern HWND ghDlgChkUsr;
  1408. int UDP_Read_ChkUsr(LPSTR lpTmp, int len)
  1409. {
  1410. SendMessage(ghDlgChkUsr, WM_COMMAND, 100, (LPARAM)(int)*lpTmp);
  1411. return 0;
  1412. }
  1414. BOOL HqAllocMem(int jys)
  1415. {
  1416. if(HqData[jys].lpPreData ==NULL)
  1417. HqData[jys].lpPreData =(LPHQ_PRE_DATA)GlobalAllocPtr(GHND,
  1418. HqData[jys].recCount*sizeof(HQ_PRE_DATA));
  1419. else
  1420. HqData[jys].lpPreData =(LPHQ_PRE_DATA)GlobalReAllocPtr(HqData[jys].lpPreData,
  1421. HqData[jys].recCount*sizeof(HQ_PRE_DATA), GMEM_MOVEABLE);
  1423. if(HqData[jys].lpRefData ==NULL)
  1424. HqData[jys].lpRefData =(LPHQ_REF_DATA)GlobalAllocPtr(GHND,
  1425. HqData[jys].recCount*sizeof(HQ_REF_DATA));
  1426. else
  1427. HqData[jys].lpRefData =(LPHQ_REF_DATA)GlobalReAllocPtr(HqData[jys].lpRefData,
  1428. HqData[jys].recCount*sizeof(HQ_REF_DATA), GMEM_MOVEABLE);
  1430. if(HqData[jys].lpPreData ==NULL || HqData[jys].lpRefData ==NULL)
  1431. {
  1432. HqData[jys].recCount =0;
  1433. ErrMsg(NULL,"alloc record data memory failed!");
  1434. return FALSE;
  1435. }
  1436. if(HqData[jys].isLcChanged ==NULL)
  1437. HqData[jys].isLcChanged =(BOOL *)GlobalAllocPtr(GHND,
  1438. HqData[jys].recCount*sizeof(BOOL));
  1439. else
  1440. HqData[jys].isLcChanged =(BOOL *)GlobalReAllocPtr(HqData[jys].isLcChanged,
  1441. HqData[jys].recCount*sizeof(BOOL), GHND);
  1443. if(HqData[jys].isJgChanged ==NULL)
  1444. HqData[jys].isJgChanged =(BOOL *)GlobalAllocPtr(GHND,
  1445. HqData[jys].recCount*sizeof(BOOL));
  1446. else
  1447. HqData[jys].isJgChanged =(BOOL *)GlobalReAllocPtr(HqData[jys].isJgChanged,
  1448. HqData[jys].recCount*sizeof(BOOL), GHND);
  1450. if(HqData[jys].isJgChanged ==NULL || HqData[jys].isLcChanged ==NULL)
  1451. {
  1452. HqData[jys].recCount =0;
  1453. ErrMsg(NULL,"alloc changed data memory failed!");
  1454. return FALSE;
  1455. }
  1457. if(HqData[jys].isReadOK ==NULL)
  1458. HqData[jys].isReadOK =(BOOL *)GlobalAllocPtr(GHND,
  1459. HqData[jys].recCount*sizeof(BOOL));
  1460. else
  1461. HqData[jys].isReadOK =(BOOL *)GlobalReAllocPtr(HqData[jys].isReadOK,
  1462. HqData[jys].recCount*sizeof(BOOL), GHND);
  1464. if(HqData[jys].isReadOK ==NULL)
  1465. {
  1466. HqData[jys].recCount =0;
  1467. ErrMsg(NULL,"alloc readok data memory failed!");
  1468. return FALSE;
  1469. }
  1471. return TRUE;
  1472. }
  1474. /*
  1475. int UDP_Recv_File(LPSTR lpTmp,int len)
  1476. {
  1477.     RECV_FILE_FRAME RecvFileFrame;
  1478.     char temp[80],tmp[80],*ptr,file[14];
  1479.     HFILE hf;
  1480.     OFSTRUCT os;
  1481.     
  1482.     if(len<sizeof(RECV_FILE_FRAME))
  1483.     {
  1484.      ErrMsg(NULL,"接收文件帧头长度不足"); 
  1485.      return FALSE;
  1486.     }
  1487.     memcpy(&RecvFileFrame,lpTmp,sizeof(RECV_FILE_FRAME));
  1488.     lpTmp+=sizeof(RECV_FILE_FRAME);
  1489.     len-=sizeof(RECV_FILE_FRAME);
  1490.     if(len!=RecvFileFrame.filelen)
  1491.     {
  1492.      ErrMsg(NULL,"接收文件数据区长度不足"); 
  1493.      return FALSE;    
  1494.     }
  1495.     
  1496.     memset(file,0,14);
  1497.     strncpy(file,RecvFileFrame.filename,12);
  1498.     file[12] =0;
  1500.     strcpy(tmp,file);
  1501.     ptr=strchr(tmp,'.');
  1502.     if(ptr!=NULL)
  1503.      *ptr=0;
  1504. wsprintf(temp, "%s\%s.tmp",szDataPath,tmp);
  1505.     if(RecvFileFrame.sign=='B'||RecvFileFrame.sign=='e'||
  1506.      RecvFileFrame.sign=='f')
  1507. unlink(temp);
  1508. if(access(temp,0)==0)
  1509. hf =OpenFile(temp, &os, OF_SHARE_DENY_NONE|OF_WRITE);
  1510. else
  1511. hf =OpenFile(temp, &os, OF_CREATE|OF_SHARE_DENY_NONE|OF_WRITE);
  1512. if(hf==HFILE_ERROR)
  1513. {
  1514. sprintf(tmp,"不能建立接收文件:%s",temp);
  1515.      ErrMsg(NULL,tmp); 
  1516.      return FALSE;
  1517. }
  1519. if(_lseek(hf,0L,SEEK_END)==-1)
  1520. {
  1521.      ErrMsg(NULL,"接收文件不能定位到尾部!");
  1522.      return FALSE;
  1523. }
  1524. if(_lwrite(hf,lpTmp,len)!=(UINT)len)
  1525. {
  1526.      ErrMsg(NULL,"接收文件不能正确写入数据!");
  1527.      return FALSE;
  1528. }
  1529. _lclose(hf);
  1530. if(RecvFileFrame.sign=='E'||RecvFileFrame.sign=='e')
  1531. {
  1532. sprintf(tmp,"%s\%s",szDataPath,file);
  1533. unlink(tmp);
  1534. rename(temp,tmp);
  1536. _strlwr(tmp);
  1537. if(strstr(tmp,"szhq.dat")!=NULL)
  1538. PostMessage(ghWndMain,WM_USER +5,0,0L);
  1539. if(strstr(tmp,"shhq.dat")!=NULL)
  1540. PostMessage(ghWndMain,WM_USER +6,0,0L);
  1541. }
  1543. if(RecvFileFrame.sign=='F'||RecvFileFrame.sign=='f')
  1544. {
  1545. sprintf(tmp,"%s\%s",szDataPath,file);
  1546. unlink(tmp);
  1547. ExpandFile(temp,tmp);
  1548. unlink(temp);
  1550. _strlwr(tmp);
  1551. if(strstr(tmp,"szhq.dat")!=NULL)
  1552. PostMessage(ghWndMain,WM_USER +5,0,0L);
  1553. if(strstr(tmp,"shhq.dat")!=NULL)
  1554. PostMessage(ghWndMain,WM_USER +6,0,0L);
  1556. }
  1558. return TRUE;
  1559. }
  1560. */
  1562. int UDP_Recv_File(LPSTR lpTmp,int len)
  1563. {
  1564.     RECV_FILE_FRAME RecvFileFrame;
  1565.     char temp[80],tmp[80],*ptr,file[14];
  1566.     
  1567.     char buf[4096];
  1568.     int bytes;
  1569.     gzFile in;   
  1570.     
  1571.     HFILE hf;
  1572.     OFSTRUCT os;
  1573.     
  1574.     if(len<sizeof(RECV_FILE_FRAME))
  1575.     {
  1576.      ErrMsg(NULL,"接收文件帧头长度不足"); 
  1577.      return FALSE;
  1578.     }
  1579.     memcpy(&RecvFileFrame,lpTmp,sizeof(RECV_FILE_FRAME));
  1580.     lpTmp+=sizeof(RECV_FILE_FRAME);
  1581.     len-=sizeof(RECV_FILE_FRAME);
  1582.     if(len!=RecvFileFrame.filelen)
  1583.     {
  1584.      ErrMsg(NULL,"接收文件数据区长度不足"); 
  1585.      return FALSE;    
  1586.     }
  1587.     
  1588.     memset(file,0,14);
  1589.     strncpy(file,RecvFileFrame.filename,12);
  1590.     file[12] =0;
  1592.     if(RecvFileFrame.sign<=GZ_OVER)
  1593.     {   
  1594.      wsprintf(temp, "%s\temp.tmp",szDataPath);    
  1595.      switch(RecvFileFrame.sign)
  1596.      {
  1597.      case GZ_STAR:
  1598.      hf =OpenFile(temp, &os, OF_CREATE|OF_SHARE_DENY_NONE|OF_WRITE);
  1599.      break;
  1600.      case GZ_SING:
  1601.          hf =OpenFile(temp, &os, OF_CREATE|OF_SHARE_DENY_NONE|OF_WRITE);
  1602.      break; 
  1603.      case GZ_CONT:
  1604.      hf =OpenFile(temp, &os, OF_SHARE_DENY_NONE|OF_WRITE);    
  1605.      break;
  1606.      case GZ_OVER:
  1607.      hf =OpenFile(temp, &os, OF_SHARE_DENY_NONE|OF_WRITE);    
  1608.      break;
  1609.      }
  1610. if(hf==HFILE_ERROR)
  1611. {
  1612. sprintf(tmp,"不能建立接收文件:%s",temp);
  1613.      ErrMsg(NULL,tmp); 
  1614.      return FALSE;
  1615. }
  1616.      _lseek(hf,0L,SEEK_END);
  1617. if(_lwrite(hf,lpTmp,len)!=(UINT)len)
  1618. {
  1619.      ErrMsg(NULL,"接收文件不能正确写入数据!");
  1620.      return FALSE;
  1621. }
  1622.      _lclose(hf);
  1623.      if(RecvFileFrame.sign ==GZ_SING ||RecvFileFrame.sign ==GZ_OVER)
  1624.      {    
  1625.           in = gzopen(temp, "rb");
  1626.           if(in ==NULL)
  1627.           {
  1628.              ErrMsg(NULL,"不能打开压缩文件!");
  1629.      return FALSE;
  1630.           }            
  1631.           
  1632.           _strlwr(file);
  1633.           if(strstr(file,"winpy.dat")!=NULL)
  1634.            strcpy(tmp,file);
  1635.           else
  1636.           wsprintf(tmp, "%s\%s",szDataPath,file);          
  1637.           
  1638.           hf =OpenFile(tmp, &os, OF_CREATE|OF_SHARE_DENY_NONE|OF_WRITE);
  1641.       for (;;) 
  1642.       {
  1643.          bytes = gzread(in, buf, sizeof(buf));
  1644.          if (bytes < 0)
  1645.          {
  1646.      ErrMsg(NULL,"不能解压数据文件!");
  1647.      break;
  1648.          }
  1649.          if (bytes == 0) break;
  1650. if(_lwrite(hf,buf,bytes)!=(UINT)bytes)
  1651. {
  1652.      ErrMsg(NULL,"解压数据不能正确写入文件!");
  1653.      break;
  1654. }
  1656.       }
  1657.       
  1658.       _lclose(hf);
  1659.       if (gzclose(in) != Z_OK)
  1660.       {
  1661.      ErrMsg(NULL,"压缩文件不能正常关闭!");
  1662.      return FALSE;      
  1663.       }      
  1664. if(strstr(tmp,"szhq.dat")!=NULL)
  1665. PostMessage(ghWndMain,WM_USER +5,0,0L);
  1666. else if(strstr(tmp,"shhq.dat")!=NULL)
  1667. PostMessage(ghWndMain,WM_USER +6,0,0L);
  1668. else if(strstr(tmp,"winpy.dat")!=NULL)
  1669. PostMessage(ghWndMain,WM_USER +7,0,0L);
  1670. else
  1671. {
  1672. sprintf(tmp,"接收文件%s",file);
  1673. Msg(tmp,MSG_VERT);
  1674. }
  1675.      }
  1676.      return 0;
  1677.     }
  1679.     strcpy(tmp,file);
  1680.     ptr=strchr(tmp,'.');
  1681.     if(ptr!=NULL)
  1682.      *ptr=0;
  1683. wsprintf(temp, "%s\%s.tmp",szDataPath,tmp);
  1684.     if(RecvFileFrame.sign=='B'||RecvFileFrame.sign=='e'||
  1685.      RecvFileFrame.sign=='f')
  1686. unlink(temp);
  1687. if(access(temp,0)==0)
  1688. hf =OpenFile(temp, &os, OF_SHARE_DENY_NONE|OF_WRITE);
  1689. else
  1690. hf =OpenFile(temp, &os, OF_CREATE|OF_SHARE_DENY_NONE|OF_WRITE);
  1691. if(hf==HFILE_ERROR)
  1692. {
  1693. sprintf(tmp,"不能建立接收文件:%s",temp);
  1694.      ErrMsg(NULL,tmp); 
  1695.      return FALSE;
  1696. }
  1698. if(_lseek(hf,0L,SEEK_END)==-1)
  1699. {
  1700.      ErrMsg(NULL,"接收文件不能定位到尾部!");
  1701.      return FALSE;
  1702. }
  1703. if(_lwrite(hf,lpTmp,len)!=(UINT)len)
  1704. {
  1705.      ErrMsg(NULL,"接收文件不能正确写入数据!");
  1706.      return FALSE;
  1707. }
  1708. _lclose(hf);
  1709. if(RecvFileFrame.sign=='E'||RecvFileFrame.sign=='e')
  1710. {
  1711. sprintf(tmp,"%s\%s",szDataPath,file);
  1712. unlink(tmp);
  1713. rename(temp,tmp);
  1715. _strlwr(tmp);
  1716. if(strstr(tmp,"szhq.dat")!=NULL)
  1717. PostMessage(ghWndMain,WM_USER +5,0,0L);
  1718. if(strstr(tmp,"shhq.dat")!=NULL)
  1719. PostMessage(ghWndMain,WM_USER +6,0,0L);
  1720. }
  1722. if(RecvFileFrame.sign=='F'||RecvFileFrame.sign=='f')
  1723. {
  1724. sprintf(tmp,"%s\%s",szDataPath,file);
  1725. unlink(tmp);
  1726. ExpandFile(temp,tmp);
  1727. unlink(temp);
  1729. _strlwr(tmp);
  1730. if(strstr(tmp,"szhq.dat")!=NULL)
  1731. PostMessage(ghWndMain,WM_USER +5,0,0L);
  1732. if(strstr(tmp,"shhq.dat")!=NULL)
  1733. PostMessage(ghWndMain,WM_USER +6,0,0L);
  1734. }
  1735. return TRUE;
  1736. }