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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 查看源码
Findword.c
资源名称：屏幕取词程序VC源码.zip　[点击查看]
上传用户：chzmdj
上传日期：2007-01-22
资源大小：135k
文件大小：40k
源码类别：

源码/资料

开发平台：

C/C++

Findword.c：源码内容
  1. #include <windows.h>
  2. #include "srhword.h"
  3. #include "findword.h"
  4. #include "stdio.h"
  5. #include "string.h"
  6. #include "math.h"
  7. #include "..pub3216.h"
  8. #include <malloc.h>
  10. #ifdef _DEBUG
  11. #include "DbgFunc.h"
  12. #endif //_DEBUG
  14. extern int   g_nCurrWindowVer;
  16. extern char  g_szTotalWord[BUFFERLENGTH];
  17. extern RECT  g_TotalWordRect;
  18. extern int   g_CharType;
  19. extern int   g_nCurCaretPlaceInTotalWord;
  20. extern int   g_bMouseInTotalWord;
  21. //Added by XGL,Sep 29th,1998
  22. extern RECT  g_rcFirstWordRect;
  23. //Adding ends.
  26. extern char  g_szCurWord[BUFFERLENGTH];
  27. extern RECT  g_CurWordRect;
  28. extern int   g_nCurCaretPlace;
  30. extern char szMemDCWordBuff[BUFFERLENGTH];
  31. extern int  pnMemDCCharLeft[BUFFERLENGTH];
  32. extern int  pnMemDCCharRight[BUFFERLENGTH];
  33. extern WORDPARA WordBuffer[MEMDC_MAXNUM];
  34. extern int nWordNum;
  36. extern BOOL  g_bAllowGetCurWord;
  37. extern POINT g_CurMousePos;
  38. extern HWND  g_hNotifyWnd;
  40. extern UINT         g_nTextAlign;
  41. extern DWORD        g_dwDCOrg;
  42. extern int          g_nExtra;
  43. extern POINT        g_CurPos;
  44. extern TEXTMETRIC   g_tm;
  46. ///////////////////////////////////////////////////////////////////////////
  47. // Modify by Yan/Gang 1997/11/18
  48. // 用於修改在计算 TA_CENTER 情况的失误。
  49. extern BOOL bRecAllRect;
  50. extern RECT g_rcTotalRect;
  51. // End Modify
  52. ///////////////////////////////////////////////////////////////////////////
  55. #define RIGHT  1
  56. #define LEFT  -1
  58. #ifdef _DICTING_
  59. ///////////////////////////////////////////////////////////////////////////
  60. // Add by Yan/Gang   11/13/1997
  61. // 用於向查字助理通知取得所需要的单词·
  62. extern UINT BL_HASSTRING;
  63. // Add end.
  64. ///////////////////////////////////////////////////////////////////////////
  65. #endif
  67. #ifdef _DICTING_
  68. /////////////////////////////////////////////////////////////////////////////////
  69. // Modify by Yan/Gang 1997/11/19
  70. // 主要解决通配符的问题。
  71. extern int g_nGetWordStyle;
  72. // End Add.
  73. /////////////////////////////////////////////////////////////////////////////////
  74. //Added by XGL Sep 17th, 1998
  75. extern int g_nWordsInPhrase ;
  76. extern BOOL g_bPhraseNeeded ;
  77. extern int g_nPhraseCharType ;
  78. //Adding ends
  79. /////////////////////////////////////////////////////////////////////////////////
  80. #endif
  82. //////////////////////////////////////////////////////////////////////////////////
  83. // TODO: Return a char type.
  84. __inline int  GetCharType(char ch)
  85. {
  86. BYTE chitem = ch;
  88. if (ch < 0)
  89. return CHAR_TYPE_HZ;
  91. if (((ch >= 'a')&&(ch <= 'z'))||
  92.     ((ch >= 'A')&&(ch <= 'Z')))
  93. {
  94. return CHAR_TYPE_ASCII;
  95. }
  97. return CHAR_TYPE_OTHER;
  98. }
  100. #ifdef _DICTING_
  101. /////////////////////////////////////////////////////////////////////////////////
  102. // Modify by Yan/Gang 1997/11/19
  103. // 主要解决通配符的问题。
  104. __inline int  FindAWord(LPCSTR lpString, int nFromPlace, int nLength)
  105. {
  106. return FindTWWord(lpString, nFromPlace, nLength);
  107. }
  110. __inline int  FindDWord(LPCSTR lpString, int nFromPlace, int nLength)
  111. {
  112. int i = nFromPlace;
  113. while (i < nLength)
  114. {
  115. if (GetCharType(lpString[i]) == CHAR_TYPE_ASCII)
  116. {
  117. i++;
  118. }
  119. else
  120. {
  121. return i-1;
  122. }
  123. } 
  125. return nLength - 1;
  126. }
  128. __inline int  FindTWWord(LPCSTR lpString, int nFromPlace, int nLength)
  129. {
  130. int i = nFromPlace;
  131. // int j;
  132. while (i < nLength)
  133. {
  134. if (lpString[i] == CHAR_LINK)
  135. {
  136. if (IsASCIIWord(lpString, nFromPlace, nLength, i + 1))
  137. {
  138. i++;
  139. }
  140. else
  141. {
  142. return i-1;
  143. }
  144. }
  145. else
  146. {
  147. // 用於处理 '-' 的几种情况·
  148. if (IsASCIIWord(lpString, nFromPlace, nLength, i))
  149. {
  150. i++;
  151. }
  152. else
  153. {
  154. return i-1;
  155. }
  156. }
  157. } 
  159. return nLength - 1;
  160. }
  162. __inline BOOL IsASCIIWord(LPCSTR lpString, int nFromPlace, int nLength, int nCurCharNum)
  163. {
  164. if (GetCharType(lpString[nCurCharNum]) == CHAR_TYPE_ASCII)
  165. {
  166. return TRUE;
  167. }
  168. return FALSE;
  169. }
  170. // End Add.
  171. /////////////////////////////////////////////////////////////////////////////////
  172. #else
  173. __inline int  FindAWord(LPCSTR lpString, int nFromPlace, int nLength)
  174. {
  175. int i = nFromPlace;
  176. while (i < nLength)
  177. {
  178. if (lpString[i] == CHAR_LINK)
  179. {
  180. if (IsASCIIWord(lpString, nFromPlace, nLength, i + 1))
  181. {
  182. i++;
  183. }
  184. else
  185. {
  186. return i-1;
  187. }
  188. }
  189. else
  190. {
  191. // 用於处理 '-' 的几种情况·
  192. if (IsASCIIWord(lpString, nFromPlace, nLength, i))
  193. {
  194. i++;
  195. }
  196. else
  197. {
  198. return i-1;
  199. }
  200. }
  201. } 
  203. return nLength - 1;
  204. }
  206. #define CHAR_WILDCHAR1 '*'
  207. #define CHAR_WILDCHAR2 '?'
  209. __inline BOOL IsASCIIWord(LPCSTR lpString, int nFromPlace, int nLength, int nCurCharNum)
  210. {
  211. if (GetCharType(lpString[nCurCharNum]) == CHAR_TYPE_ASCII)
  212. {
  213. return TRUE;
  214. }
  215.     
  216. return FALSE;
  217. }
  218. #endif
  220. __inline int  FindHZWord(LPCSTR lpString, int nFromPlace, int nLength)
  221. {
  222. int i = nFromPlace;
  224. if ((BYTE)(lpString[nFromPlace]) >= 0xa1
  225. && (BYTE)(lpString[nFromPlace]) <= 0xa9)
  226. {
  227. return nFromPlace + 1 ;
  228. }
  230. while (i < nLength)
  231. {
  232. if (GetCharType(lpString[i]) == CHAR_TYPE_HZ)
  233. {
  234.  //Added by XGL, Nov 13th, 1998
  235.  //We have to filter out Chinese punctuation marks,
  236.  //which is diffent as it is in ASCII.
  237.  if ((BYTE)(lpString[i]) >= 0xa1
  238.  && (BYTE)(lpString[i]) <= 0xa9)
  239.  {
  240.  return i - 1 ;
  241.  }
  242.  //Adding ends. XGL, Nov 13th, 1998
  244. i = i + 2;
  245. }
  246. else
  247. {
  248. return i - 1;
  249. }
  250. } 
  252. return nLength - 1;
  253. }
  255. __inline int FindNextWordBegin(LPCSTR lpString, int nFromPlace, int nLength)
  256. {
  257. int i = nFromPlace;
  258. while (i < nLength)
  259. {
  260. if (GetCharType(lpString[i]) == CHAR_TYPE_OTHER)
  261. {
  262. i++;
  263. }
  264. else
  265. {
  266. return i-1;
  267. }
  268. } 
  270. return i - 1;
  271. }
  273. __inline int GetCurWordEnd(LPCSTR lpString, int nFromPlace, int nLength, int nCharType)
  274. {
  275. switch (nCharType)
  276. {                       
  277. case CHAR_TYPE_ASCII:
  278.  return FindAWord(lpString, nFromPlace, nLength);
  279.  break;
  280. case CHAR_TYPE_HZ:
  281.  return FindHZWord(lpString, nFromPlace, nLength);
  282.  break;
  283. case CHAR_TYPE_OTHER:
  284.  return FindNextWordBegin(lpString, nFromPlace, nLength);
  285.  break;
  286. }
  287. return FindAWord(lpString, nFromPlace, nLength);
  288. }
  290. __inline void CopyWord(LPSTR lpWord, LPCSTR lpString, int nBegin, int nEnd)
  291. {
  292. int i;
  293. for ( i = nBegin; i <= nEnd; i++)
  294. {
  295. lpWord[i - nBegin] = lpString[i];
  296. }
  297. lpWord[nEnd - nBegin + 1] = '';
  298. }
  300. __inline void GetStringTopBottom(HDC hDC, int y, RECT* lpStringRect)
  301. {
  302. POINT  WndPos;
  304. WndPos.y = HIWORD(g_dwDCOrg);
  306.     if (TA_UPDATECP & g_nTextAlign)
  307.     {
  308.      y = g_CurPos.y;
  309.     }
  310.     
  311. switch ((TA_TOP | TA_BOTTOM)&g_nTextAlign)
  312. {
  313. case TA_BOTTOM:
  314.  lpStringRect->top    = y - g_tm.tmHeight + g_tm.tmInternalLeading;
  315.  lpStringRect->bottom = y;
  316.  break;
  317. case TA_BASELINE:
  318.  lpStringRect->top    = y - g_tm.tmAscent;
  319.  lpStringRect->bottom = y + g_tm.tmDescent;
  320.  break;
  321. case TA_TOP:
  322. default:
  323.  lpStringRect->top    = y;
  324.  lpStringRect->bottom = y + g_tm.tmHeight + g_tm.tmInternalLeading;
  325.  break;
  326. }
  328. LPtoDP(hDC, (LPPOINT)lpStringRect, 2);
  330. lpStringRect->top    = lpStringRect->top    + WndPos.y;
  331. lpStringRect->bottom = lpStringRect->bottom + WndPos.y;
  332. }
  334. __inline void GetStringLeftRight(HDC hDC, LPSTR szBuff, int cbLen, int x, RECT* lpStringRect, int FAR* lpDx)
  335. {
  336. SIZE   StringSize;
  337. POINT  WndPos;
  338.     int i;
  340. if (cbLen < 0)
  341. {
  342. lpStringRect->top    = 0;
  343. lpStringRect->bottom = 0;
  344. lpStringRect->left   = 0;
  345. lpStringRect->right  = 0;
  346. return;
  347. }
  349. GetTextExtentPoint(hDC, szBuff, cbLen, &StringSize);
  350. WndPos.x = LOWORD(g_dwDCOrg);
  352. if (lpDx != NULL)
  353. {
  354. StringSize.cx = 0;
  355. for (i = 0; i < cbLen; i++)
  356. {
  357. StringSize.cx += lpDx[i];
  358. }
  359. }
  360.     
  361.     if (TA_UPDATECP & g_nTextAlign)
  362.     {
  363.      x = g_CurPos.x;
  364.     }
  365.     
  366. switch ((TA_LEFT | TA_CENTER | TA_RIGHT)&g_nTextAlign)
  367. {
  368. case TA_RIGHT:
  369.  if (!bRecAllRect)
  370.  {
  371.  lpStringRect->right = x;
  372.  lpStringRect->left  = x - StringSize.cx;
  373.  }
  374.  else
  375.  {
  376.   lpStringRect->left = g_rcTotalRect.left;
  377.   lpStringRect->right= g_rcTotalRect.left + StringSize.cx;
  378.  }
  379.  break;
  380. case TA_CENTER:
  381.  if (!bRecAllRect)
  382.  {
  383.  lpStringRect->right = x + StringSize.cx / 2;
  384.  lpStringRect->left  = x - StringSize.cx / 2;
  385.  }
  386.  else
  387.  {
  388.   lpStringRect->left = g_rcTotalRect.left;
  389.   lpStringRect->right= g_rcTotalRect.left + StringSize.cx;
  390.  }
  391.  break;
  392. case TA_LEFT:
  393. default:
  394.  lpStringRect->left  = x ;
  395.  lpStringRect->right = x + StringSize.cx;
  396.  break;
  397. }
  399. LPtoDP(hDC, (LPPOINT)lpStringRect, 2);
  401. lpStringRect->left   = lpStringRect->left   + WndPos.x;
  402. lpStringRect->right  = lpStringRect->right  + WndPos.x;
  403. }
  405. //#define _TEST
  407. void GetStringRect(HDC hDC, LPSTR szBuff, int cbLen, int x, int y, RECT* lpStringRect, int FAR* lpDx)
  408. {
  409. SIZE   StringSize;
  410. POINT  WndPos;
  411.     int i;
  413. if (cbLen < 0)
  414. {
  415. lpStringRect->top    = 0;
  416. lpStringRect->bottom = 0;
  417. lpStringRect->left   = 0;
  418. lpStringRect->right  = 0;
  419. return;
  420. }
  422. GetTextExtentPoint(hDC, szBuff, cbLen, &StringSize);
  423. WndPos.x = LOWORD(g_dwDCOrg);
  424. WndPos.y = HIWORD(g_dwDCOrg);
  426. if (lpDx != NULL)
  427. {
  428. StringSize.cx = 0;
  429. for (i = 0; i < cbLen; i++)
  430. {
  431. StringSize.cx += lpDx[i];
  432. }
  433. }
  434.     
  435.     if (TA_UPDATECP & g_nTextAlign)
  436.     {
  437.      x = g_CurPos.x;
  438.      y = g_CurPos.y;
  439.     }
  440.     
  441. switch ((TA_LEFT | TA_CENTER | TA_RIGHT)&g_nTextAlign)
  442. {
  443. case TA_RIGHT:
  444.  if (bRecAllRect == FALSE)
  445.  {
  446.  lpStringRect->right = x;
  447.  lpStringRect->left  = x - StringSize.cx;
  448.  }
  449.  else
  450.  {
  451.   lpStringRect->left = g_rcTotalRect.left;
  452.   lpStringRect->right= g_rcTotalRect.left + StringSize.cx;
  453.  }
  454.  break;
  455. case TA_CENTER:
  456.  if (bRecAllRect == FALSE)
  457.  {
  458.  lpStringRect->right = x + StringSize.cx / 2;
  459.  lpStringRect->left  = x - StringSize.cx / 2;
  460.  }
  461.  else
  462.  {
  463.   lpStringRect->left = g_rcTotalRect.left;
  464.   lpStringRect->right= g_rcTotalRect.left + StringSize.cx;
  465.  }
  466.  break;
  467. case TA_LEFT:
  468. default:
  469.  lpStringRect->left  = x ;
  470.  lpStringRect->right = x + StringSize.cx;
  471.  break;
  472. }
  474. switch ((TA_TOP | TA_BOTTOM | TA_BASELINE)&g_nTextAlign)
  475. {
  476. case TA_BOTTOM:
  477.  lpStringRect->top    = y - StringSize.cy;
  478.  lpStringRect->bottom = y;
  479.  break;
  480. case TA_BASELINE:
  481.  lpStringRect->top    = y - g_tm.tmAscent;
  482.  lpStringRect->bottom = y + g_tm.tmDescent;
  483.  break;
  484. case TA_TOP:
  485. default:
  486.  lpStringRect->top    = y;
  487.  lpStringRect->bottom = y + StringSize.cy;
  488.  break;
  489. }
  491. LPtoDP(hDC, (LPPOINT)lpStringRect, 2);
  493. lpStringRect->top    = lpStringRect->top    + WndPos.y;
  494. lpStringRect->bottom = lpStringRect->bottom + WndPos.y;
  495. lpStringRect->left   = lpStringRect->left   + WndPos.x;
  496. lpStringRect->right  = lpStringRect->right  + WndPos.x;
  497. }
  499. DWORD GetCurMousePosWord(HDC   hDC, 
  500.  LPSTR szBuff, 
  501.  int   cbLen, 
  502.  int   x, 
  503.  int   y, 
  504.  int   FAR* lpDx)
  505. {
  506. int   nCurrentWord, nPrevWord;
  507. RECT  StringRect;
  508. int   CharType;
  509. int   nLeft;
  510. DWORD dwReturn;
  512. GetStringTopBottom(hDC, y, &StringRect);
  513. if ((StringRect.top > g_CurMousePos.y) || (StringRect.bottom < g_CurMousePos.y))
  514. {
  515. return NO_CURMOUSEWORD;
  516. }
  518. GetStringRect(hDC, szBuff, cbLen, x, y, &StringRect, lpDx);
  519. nLeft = StringRect.left;
  520. // nLeft = 0;
  522. nPrevWord = nCurrentWord = -1;
  523. while (nCurrentWord < cbLen)
  524. {
  525. CharType     = GetCharType(szBuff[nCurrentWord + 1]);
  526. nPrevWord    = nCurrentWord;
  527. nCurrentWord = GetCurWordEnd(szBuff, nPrevWord + 1, cbLen, CharType);
  528. dwReturn     = CheckMouseInCurWord(hDC, szBuff, cbLen, x, y, lpDx, &nLeft, nPrevWord + 1, nCurrentWord, CharType);
  530. #ifdef _DICTING_
  531. if (dwReturn == HAS_CURMOUSEWORD)
  532. {
  533. if (CharType == CHAR_TYPE_OTHER)
  534. {
  535. PostMessage(g_hNotifyWnd, BL_HASSTRING, 0, 0l);
  536. }
  537. else
  538. {
  539. }
  540. }
  541. else
  542. {
  543. if (g_bMouseInTotalWord)
  544. {
  545. PostMessage(g_hNotifyWnd, BL_HASSTRING, 0, 0l);
  546. }
  547. }
  548. #else
  549. if (dwReturn == HAS_CURMOUSEWORD)
  550. return HAS_CURMOUSEWORD;
  551. #endif
  553. if (nCurrentWord >= cbLen - 1)
  554. return NO_CURMOUSEWORD;
  555. }
  557. return NO_CURMOUSEWORD;   
  558. }
  560. __inline DWORD CheckMouseInCurWord(HDC   hDC, 
  561.    LPSTR szBuff, 
  562.    int   cbLen, 
  563.    int   x, 
  564.    int   y, 
  565.    int   FAR* lpDx,
  566.    int*  lpLeft,
  567.    int   nBegin,    // = nPrevWord + 1
  568.    int   nEnd,
  569.    int   nCharType)
  570. {
  571. RECT  StringRect;
  573. GetStringRect(hDC, szBuff, nEnd + 1, x, y, &StringRect, lpDx);
  574. StringRect.left = *lpLeft;
  575. *lpLeft = StringRect.right;
  577. if (  ((g_CurMousePos.x >= StringRect.left    ) && (g_CurMousePos.x <= StringRect.right))
  578.     || (g_CurMousePos.x == StringRect.left - 1)
  579.     || (g_CurMousePos.x == StringRect.right + 1))
  580. {
  581. switch (nCharType)
  582. {
  583. case CHAR_TYPE_HZ:
  585. case CHAR_TYPE_ASCII:
  586.  CopyWord(g_szCurWord, szBuff, nBegin, nEnd);
  587.  g_CurWordRect.left   = StringRect.left;
  588.  g_CurWordRect.right  = StringRect.right;
  589.  g_CurWordRect.top    = StringRect.top;
  590.  g_CurWordRect.bottom = StringRect.bottom;
  591.  
  592.  g_nCurCaretPlace = -1;
  593.  CalculateCaretPlace(hDC, 
  594.  szBuff, 
  595.  cbLen,
  596.  x,
  597.  y,
  598.  lpDx,
  599.  nBegin,
  600.  nEnd,
  601.  nCharType);
  602.  
  603.  break;
  604. case CHAR_TYPE_OTHER:
  605.  break;
  606. }
  607. AddToTotalWord(szBuff, cbLen, nBegin, nEnd, nCharType, StringRect, TRUE);
  608. if (  (nCharType == CHAR_TYPE_OTHER)
  609.     &&(CalcCaretInThisPlace(g_CurMousePos.x, StringRect.right)))
  610. {
  611. #ifdef _DICTING_
  612. return HAS_CURMOUSEWORD;
  613. #else
  614. return NO_CURMOUSEWORD;
  615. #endif
  616. }
  618. return HAS_CURMOUSEWORD;
  619. }
  620. else
  621. {
  622. }
  624. AddToTotalWord(szBuff, cbLen, nBegin, nEnd, nCharType, StringRect, FALSE);
  626. return NO_CURMOUSEWORD;   
  627. }
  629. // 用於计算指定位置在字串中的位置·
  630. __inline DWORD CalculateCaretPlace(HDC   hDC, 
  631.    LPSTR szBuff, 
  632.    int   cbLen, 
  633.    int   x, 
  634.    int   y, 
  635.    int   FAR* lpDx,
  636.    int   nBegin,    // = nPrevWord + 1
  637.    int   nEnd,
  638.    int   nCharType)
  639. {
  640. RECT  StringRect, BeginRect;
  641. RECT  CaretPrevRect, CaretNextRect;
  642. // int   itemWidth; 
  643. double itemWidth; 
  644. int   TempPlace;
  645. int   i;
  647. if ((nCharType == CHAR_TYPE_HZ) && (nBegin == nEnd))
  648. {
  649. g_nCurCaretPlace = -1;
  650. return 0L;
  651. }
  653. GetStringRect(hDC, szBuff, nBegin, x, y, &BeginRect, lpDx);
  655. GetStringRect(hDC, szBuff, nEnd + 1,   x, y, &StringRect, lpDx);
  656. StringRect.left = BeginRect.right;
  657.     if (StringRect.left == StringRect.right)
  658.     {
  659. g_nCurCaretPlace = -1;
  660. return 0L;
  661.     }
  663. switch (nCharType)
  664. {
  665. case CHAR_TYPE_HZ:
  666. ///////////////////////////////////////////////////////////////////////
  667. // 汉字处理部分·
  668.  // 由於汉字都是等宽的字符，因此对於汉字的计算是通过计算
  669.  // 平均宽度来实现的·
  670. //  itemWidth = (StringRect.right - StringRect.left) / (nEnd - nBegin + 1);
  671. /////////////////////////////////////////////////////////////////
  672. // Modify by GY
  673. // Ver0.036  074号 bug.
  674. // 主要是由於在进行类型转换中有误·  
  675.  itemWidth = ((double)StringRect.right - (double)StringRect.left + 1) / ((double)nEnd - (double)nBegin + 1);
  676. // Modify end
  677. ////////////////////////////////////////////////////////////////////
  678. //  g_nCurCaretPlace = (g_CurMousePos.x - StringRect.left) * (nEnd - nBegin + 1) / (StringRect.right - StringRect.left);
  679.  for (i = 0; i <= (nEnd - nBegin + 1); i++)
  680.  {
  681.   if (CalcCaretInThisPlace(g_CurMousePos.x, (double)((double)StringRect.left + (double)(itemWidth * i))))
  682.   {
  683.   g_nCurCaretPlace = i;
  684.   i = nEnd - nBegin + 2;
  685.   }
  686.  }
  687.              break;
  688. //
  689. ///////////////////////////////////////////////////////////////////////             
  690. case CHAR_TYPE_ASCII:
  691.  // 由於英文字符为不等宽字符· 按以下步骤来计算的：
  692.  // 1. 按等宽计算一个相对位置·
  693.  // 2. 计算该相对位置的的绝对位置·
  694.  // 3. 若在该位置，返回·
  695.  // 4. 若该绝对长小於相对位置乘以宽，转6
  696.  // 5. 向右计算·
  697.  // 6. 向左计算·
  698.  
  699.  // 1. 按等宽计算一个相对位置·
  700.  // 计算宽度·
  701.  itemWidth = (StringRect.right - StringRect.left + 1) / (nEnd - nBegin + 1);
  702.  // 计算位置·
  703.  TempPlace = (g_CurMousePos.x - StringRect.left) * (nEnd - nBegin + 1) / (StringRect.right - StringRect.left);
  704.  
  705.  // 2. 计算该相对位置的的绝对位置·
  706.  GetStringRect(hDC, szBuff, TempPlace,     x, y, &CaretPrevRect, lpDx);
  707.  GetStringRect(hDC, szBuff, TempPlace + 1, x, y, &CaretNextRect, lpDx);
  708.  
  709.  // 3. 若在该位置，返回·
  710.  if (CalcCaretInThisPlace(g_CurMousePos.x, CaretPrevRect.right)) 
  711.  {
  712.   g_nCurCaretPlace = TempPlace - nBegin;
  713.   break;
  714.  }
  715.  if (CalcCaretInThisPlace(g_CurMousePos.x, CaretNextRect.right))
  716.  {
  717.   g_nCurCaretPlace = TempPlace - nBegin + 1;
  718.   break;
  719.  }
  721.  // 4. 若该绝对长小於相对位置乘以宽，转6
  722.  if (g_CurMousePos.x > CaretNextRect.right)
  723.  {
  724.  // 5. 向右计算·      
  725.  GetEngLishCaretPlace(hDC, 
  726.   szBuff,
  727.   x,
  728.   y,
  729.   lpDx,
  730.   nBegin,    // = nPrevWord + 1
  731.   nEnd,
  732.   TempPlace,
  733.   RIGHT);
  734.  }
  735.  else
  736.  {
  737.  // 6. 向左计算·
  738.  GetEngLishCaretPlace(hDC, 
  739.   szBuff,
  740.   x,
  741.   y,
  742.   lpDx,
  743.   nBegin,    // = nPrevWord + 1
  744.   nEnd,
  745.   TempPlace,
  746.   LEFT);
  747.  }
  748.  
  749.  break;
  750. }
  751. return 0L;
  752. }
  754. __inline DWORD GetEngLishCaretPlace(HDC   hDC, 
  755. LPSTR szBuff,
  756. int   x,
  757. int   y,
  758. int   FAR* lpDx,
  759. int   nBegin,    // = nPrevWord + 1
  760. int   nEnd,
  761. int   TempPlace,
  762. int   turnto)
  763. {
  764. int i;
  765. RECT  CaretPrevRect, CaretNextRect;
  767. if (turnto == RIGHT)
  768. {
  769. i = TempPlace;
  770. GetStringRect(hDC, szBuff, i, x, y, &CaretPrevRect, lpDx);
  772. for (i = TempPlace; i <= nEnd; i++)
  773. {
  774.  GetStringRect(hDC, szBuff, i + 1, x, y, &CaretNextRect, lpDx);
  775.  if (CalcCaretInThisPlace(g_CurMousePos.x, CaretPrevRect.right)) 
  776.  {
  777.   g_nCurCaretPlace = i - nBegin;
  778.   return 0;
  779.  }
  780.  if (CalcCaretInThisPlace(g_CurMousePos.x, CaretNextRect.right))
  781.  {
  782.   g_nCurCaretPlace = i - nBegin + 1;
  783.   return 0;
  784.  }
  786.  CopyRect(&CaretPrevRect, &CaretNextRect);
  787. }
  788. g_nCurCaretPlace = nEnd - nBegin + 1;
  789. }
  790. else
  791. {
  792. i = TempPlace;
  793. GetStringRect(hDC, szBuff, i + 1, x, y, &CaretNextRect, lpDx);
  795. for (i = TempPlace; i >= nBegin; i--)
  796. {
  797.  GetStringRect(hDC, szBuff, i, x, y, &CaretPrevRect, lpDx);
  798.  if (CalcCaretInThisPlace(g_CurMousePos.x, CaretPrevRect.right)) 
  799.  {
  800.   g_nCurCaretPlace = i - nBegin;
  801.   return 0;
  802.  }
  803.  if (CalcCaretInThisPlace(g_CurMousePos.x, CaretNextRect.right))
  804.  {
  805.   g_nCurCaretPlace = i - nBegin + 1;
  806.   return 0;
  807.  }
  809.  CopyRect(&CaretNextRect, &CaretPrevRect);
  810. }
  811. g_nCurCaretPlace = nBegin - nBegin;
  812. }
  814. return 0;
  815. }
  817. //BOOL CalcCaretInThisPlace(int CaretX, int nPlace)
  818. BOOL CalcCaretInThisPlace(int CaretX, double nPlace)
  819. {
  820. if (((double)CaretX >= nPlace - 3)&&((double)CaretX <= nPlace + 1))
  821. {
  822. return TRUE;
  823. }
  825. return FALSE;
  826. }
  828. // Get current Chinese char that under the mouse cursor.
  829. // 1.                       2
  830. // mouse place :    |            |
  831. // chinese char:  英业达      英业达
  832. // return place:    |           |
  833. __inline int GetHZBeginPlace(LPSTR lpszHzBuff, int nBegin, int nEnd, LPRECT lpStringRect)
  834. {
  835. int itemWidth; 
  836. int nReturn;
  838. itemWidth = (lpStringRect->right - lpStringRect->left + 1) / (nEnd - nBegin + 1);
  839. // nReturn = (g_CurMousePos.x - lpStringRect->left) / itemWidth;
  840. nReturn = (g_CurMousePos.x - lpStringRect->left) * (nEnd - nBegin + 1) / (lpStringRect->right - lpStringRect->left);
  842. if (nReturn == 0)
  843. return nBegin;
  844.     
  845. if (nReturn % 2 == 1)
  846. {
  847.      lpStringRect->left = lpStringRect->left + (nReturn - 1) * itemWidth;
  848.      return nBegin + nReturn - 1;
  849.     }
  850.     
  851.     lpStringRect->left = lpStringRect->left + nReturn * itemWidth;
  852. return (nBegin + nReturn);
  853. }
  855. //=========================================================
  856. //
  857. //  FUNCTION: void AddToTotalWord(LPSTR, int, int, int, int, RECT, BOOL);
  858. //
  859. //  PURPOSE:  用於将多次文本输出的单词合并为一个完整单词·
  860. //
  861. //  PARAMETER: 
  862. //       
  863. //       LPSTR : 由 TextOut 或 ExtTextOut 函数传递的字符串·
  864. //       int   : 字符串长·
  865. //       int   : 由切词程序处理後的单词在串中的起始位置·( 0 代表串的第一字节 )
  866. //       int   : 由切词程序处理後的单词在串中的结束位置·( 0 代表串的第一字节 )
  867. //       int   : 代表由 nBegin, nEnd 指定的单词的性质 ( 中文／英文／其他字符)
  868. //       RECT  : 代表由 nBegin, nEnd 指定的单词的区域·
  869. //       BOOL  : 用於判断当前鼠标位置是否在该单词中·
  870. //
  871. //  COMMENTS:
  872. //
  873. //
  874. //=========================================================
  875. _inline void AddToTotalWord(LPSTR szBuff, 
  876. int   cbLen, 
  877. int   nBegin,
  878. int   nEnd,
  879. int   nCharType,
  880. RECT  StringRect,   
  881. BOOL  bInCurWord)
  882. {
  883. int nPos = 0 ; //temp variable
  885. if ((nCharType == CHAR_TYPE_OTHER) && (!g_bMouseInTotalWord))
  886. {
  887. // 处理串开始为空格的情况·
  888. g_szTotalWord[0] = 0x00;
  889. g_CharType = nCharType;
  890. g_bMouseInTotalWord = FALSE;
  891. return;
  892. }
  894. //Added by XGL, see GetCurWordEnd for reasons
  895. if (((BYTE)(szBuff[nBegin]) >= 0xa1 && (BYTE)(szBuff[nBegin]) <= 0xa9)
  896. && (!g_bMouseInTotalWord))
  897. {
  898. // 处理串开始为空格的情况·
  899. g_szTotalWord[0] = 0x00;
  900. g_CharType = CHAR_TYPE_HZ;
  901. g_bMouseInTotalWord = FALSE;
  902. return;
  903. }
  905. if ((g_szTotalWord[0] == 0x00)&&(nCharType != CHAR_TYPE_OTHER))
  906. {
  907. // 如果完整词缓冲区为空，并且单词为中文或英文，
  908. // 拷贝字符串·
  909. CopyWord(g_szTotalWord, szBuff, nBegin, nEnd);
  910. g_TotalWordRect.left   = StringRect.left;
  911. g_TotalWordRect.right  = StringRect.right;
  912. g_TotalWordRect.top    = StringRect.top;
  913. g_TotalWordRect.bottom = StringRect.bottom;
  914. g_CharType = nCharType;
  915. if (bInCurWord)
  916. {
  917. g_bMouseInTotalWord = TRUE;
  918. //Added by XGL, Sep 17th, 1998
  919. //When the word pointed to by mouse was got,
  920. //attain it's char-type.
  921. g_nPhraseCharType = nCharType ;
  922. g_nWordsInPhrase++ ;
  923. //Adding ends.
  924. //Added by XGL, Sep 29th, 1998
  925. g_rcFirstWordRect.left   = StringRect.left;
  926. g_rcFirstWordRect.right  = StringRect.right;
  927. g_rcFirstWordRect.top    = StringRect.top;
  928. g_rcFirstWordRect.bottom = StringRect.bottom;
  929. //Adding ends.
  930. }
  931. else
  932. {
  933. g_bMouseInTotalWord = FALSE;
  934. }
  935. g_nCurCaretPlaceInTotalWord = -1;
  936. if (g_nCurCaretPlace != -1)
  937. {
  938. g_nCurCaretPlaceInTotalWord = g_nCurCaretPlace;
  939. }
  940. return;
  941. }
  943. if (!g_bMouseInTotalWord)
  944. {
  945. // Added by XGL
  946. //(nCharType == CHAR_TYPE_OTHER) && (!g_bMouseInTotalWord)
  947. //See the line above. How can conditions
  948. //in the following line happen.
  949. //Adding ends.
  950. /* if ((nCharType == CHAR_TYPE_OTHER)&&(g_CharType != nCharType))
  951. {
  952. // Clear buffer.
  953. g_szTotalWord[0] = 0x00;
  954. g_CharType = CHAR_TYPE_OTHER;
  955. g_bMouseInTotalWord = FALSE;
  956. g_nCurCaretPlaceInTotalWord = -1;
  957. if (g_nCurCaretPlace != -1)
  958. {
  959. g_nCurCaretPlaceInTotalWord = g_nCurCaretPlace;
  960. }
  961. return;
  962. }
  963. */
  964. if (g_CharType != nCharType)
  965. {
  966. CopyWord(g_szTotalWord, szBuff, nBegin, nEnd);
  967. g_TotalWordRect.left   = StringRect.left;
  968. g_TotalWordRect.right  = StringRect.right;
  969. g_TotalWordRect.top    = StringRect.top;
  970. g_TotalWordRect.bottom = StringRect.bottom;
  971. g_CharType = nCharType;
  972. if (bInCurWord)
  973. {
  974. g_bMouseInTotalWord = TRUE;
  975. //Added by XGL, Sep 17th, 1998
  976. //When the word pointed to by mouse was got,
  977. //attain it's char-type.
  978. g_nPhraseCharType = nCharType ;
  979. g_nWordsInPhrase++ ;
  980. //Adding ends.
  981. //Added by XGL, Sep 29th, 1998
  982. g_rcFirstWordRect.left   = StringRect.left;
  983. g_rcFirstWordRect.right  = StringRect.right;
  984. g_rcFirstWordRect.top    = StringRect.top;
  985. g_rcFirstWordRect.bottom = StringRect.bottom;
  986. //Adding ends.
  987. }
  988. else
  989. {
  990. g_bMouseInTotalWord = FALSE;
  991. }
  992. g_nCurCaretPlaceInTotalWord = -1;
  993. if (g_nCurCaretPlace != -1)
  994. {
  995. g_nCurCaretPlaceInTotalWord = g_nCurCaretPlace;
  996. }
  997. return;
  998. }
  999. }
  1001. //Added by XGL
  1002. //g_bMouseInTotalWord == FALSE && g_CharType != nCharType
  1003. //has been dealed with.
  1004. //Adding ends.
  1005. if ((g_CharType != nCharType)) 
  1006. {
  1007. /* if (bInCurWord)
  1008. {
  1009. //Added by XGL
  1010. //How can this condition happen
  1011. //Adding ends.
  1012. if (!g_bMouseInTotalWord)
  1013. {
  1014. CopyWord(g_szTotalWord, szBuff, nBegin, nEnd);
  1015. g_TotalWordRect.left   = StringRect.left;
  1016. g_TotalWordRect.right  = StringRect.right;
  1017. g_TotalWordRect.top    = StringRect.top;
  1018. g_TotalWordRect.bottom = StringRect.bottom;
  1019. g_CharType = nCharType;
  1020. g_bMouseInTotalWord = TRUE;
  1021. g_nCurCaretPlaceInTotalWord = g_nCurCaretPlace;
  1022. }
  1023. }
  1024. */
  1025. //Added by XGL
  1026. //now, g_bMouseInTotalWord == TRUE
  1027. //let space char go through since we want to get phrase
  1028. if ( ((nCharType == CHAR_TYPE_OTHER) && (szBuff[nBegin] == ' '))
  1029.  || ((nCharType != CHAR_TYPE_OTHER)
  1030.  && (g_nPhraseCharType == nCharType)) )
  1031. {
  1032. //Modified by XGL, don't allow space char in Chinese
  1033. // if (   g_bPhraseNeeded 
  1034. //    &&(g_nWordsInPhrase > MIN_WORDS_IN_PHRASE)
  1035. //    &&(g_nWordsInPhrase < MAX_WORDS_IN_PHRASE) )
  1036. if (   g_bPhraseNeeded 
  1037.    &&(g_nWordsInPhrase > MIN_WORDS_IN_PHRASE)
  1038.    &&(g_nWordsInPhrase < MAX_WORDS_IN_PHRASE)
  1039.    &&(!(g_szTotalWord[0] < 0 && szBuff[nBegin] == ' ')) )
  1040. {
  1041. }
  1042. else
  1043. {
  1044. g_nWordsInPhrase = MAX_WORDS_IN_PHRASE + 1 ;
  1045. return;
  1046. }
  1047. }
  1048. else
  1049. {
  1050. g_nWordsInPhrase = MAX_WORDS_IN_PHRASE + 1 ;
  1051. return;
  1052. }
  1053. //Adding ends.
  1054. }
  1056. /* //Added by XGL, Sep 17th, 1998
  1057. if ( g_bMouseInTotalWord && g_bPhraseNeeded
  1058.  && (strlen(g_szTotalWord) > MAX_WORDS_IN_PHRASE * 2)
  1059.  && (g_nPhraseCharType == CHAR_TYPE_HZ) )
  1060. {
  1061. //We cann't count Chinese words using space char
  1062. //so g_nWordsInPhrase is useless now
  1063. g_nWordsInPhrase = MAX_WORDS_IN_PHRASE + 1 ;
  1064. }
  1065. //Adding ends.
  1066. */
  1067. if (  ((UINT)(StringRect.left - g_TotalWordRect.right) <= (UINT)SEPERATOR)
  1068. &&(abs((int)(StringRect.bottom - g_TotalWordRect.bottom)) <= SEPERATOR))
  1069. {
  1070. //Added by XGL, see GetCurWordEnd for reasons. Nov 13th, 1998.
  1071. if ((BYTE)(szBuff[nBegin]) >= 0xa1 
  1072. && (BYTE)(szBuff[nBegin]) <= 0xa9)
  1074. {
  1075. return;
  1076. }
  1077. //Adding ends. XGL, Nov 13th, 1998.
  1078. //Added by XGL, Sep 17th, 1998
  1079. if (g_bMouseInTotalWord && g_bPhraseNeeded
  1080. && (g_nWordsInPhrase > MIN_WORDS_IN_PHRASE)
  1081. && (g_nWordsInPhrase < MAX_WORDS_IN_PHRASE)
  1082. && (szBuff[nBegin] == ' '))
  1083. {
  1084. //other chars between nBegin and nEnd must be space
  1085. nPos = nBegin ;
  1086. while (szBuff[nPos] == ' ' && nPos <= nEnd)
  1087. {
  1088. nPos++ ;
  1089. }      
  1090. //Modified by XGL, Nov 11th, 1998  
  1091. //We allow just one space between words of a phrase
  1092. //if (nPos <= nEnd)      
  1093. if (nPos <= nEnd || nPos - nBegin > 1)
  1094. {
  1095. //stop get word
  1096. g_nWordsInPhrase = MAX_WORDS_IN_PHRASE + 1 ;
  1097. }
  1098. else
  1099. {
  1100. g_nWordsInPhrase++ ;
  1101. }
  1103. }
  1105. if (g_nWordsInPhrase >= MAX_WORDS_IN_PHRASE)
  1106. {
  1107. //enough words, no need to do more work
  1108. return ;
  1109. }
  1110. //Adding ends.
  1112. if ((g_nCurCaretPlace != -1)&&(g_nCurCaretPlaceInTotalWord == -1))
  1113. {
  1114. g_nCurCaretPlaceInTotalWord = strlen(g_szTotalWord) + g_nCurCaretPlace;
  1115. }
  1116. CopyWord(g_szTotalWord + strlen(g_szTotalWord), szBuff, nBegin, nEnd);
  1117. g_TotalWordRect.right  = StringRect.right;
  1119. //Added by XGL, Sep 29th, 1998
  1120. if (!strchr(g_szTotalWord, ' ') && (*(szBuff + nBegin) != ' '))
  1121. {
  1122. g_rcFirstWordRect.right  = StringRect.right;
  1123. }
  1124. //Adding ends.
  1126. if (bInCurWord)
  1127. {
  1128. g_bMouseInTotalWord = TRUE;
  1129. //Added by XGL, Sep 17th, 1998
  1130. //When the word pointed to by mouse was got,
  1131. //attain it's char-type.        
  1133. g_nPhraseCharType = nCharType ;
  1134. g_nWordsInPhrase++ ;
  1136. //Adding ends.
  1138. //Added by XGL, Sep 29th, 1998
  1139. g_rcFirstWordRect.left   = StringRect.left;
  1140. g_rcFirstWordRect.right  = StringRect.right;
  1141. g_rcFirstWordRect.top    = StringRect.top;
  1142. g_rcFirstWordRect.bottom = StringRect.bottom;
  1143. //Adding ends.
  1144. }
  1145. }
  1146. else
  1147. {
  1148. if (!g_bMouseInTotalWord)
  1149. {
  1150. CopyWord(g_szTotalWord, szBuff, nBegin, nEnd);
  1151. g_TotalWordRect.left   = StringRect.left;
  1152. g_TotalWordRect.right  = StringRect.right;
  1153. g_TotalWordRect.top    = StringRect.top;
  1154. g_TotalWordRect.bottom = StringRect.bottom;
  1155. g_CharType = nCharType;
  1156. g_bMouseInTotalWord = FALSE;
  1157. g_nCurCaretPlaceInTotalWord = -1;
  1158. if (g_nCurCaretPlace != -1)
  1159. {
  1160. g_nCurCaretPlaceInTotalWord = g_nCurCaretPlace;
  1161. }
  1162. if (bInCurWord)
  1163. {
  1164. g_bMouseInTotalWord = TRUE;
  1165. //Added by XGL, Sep 17th, 1998
  1166. //When the word pointed to by mouse was got,
  1167. //attain it's char-type.
  1168. g_nPhraseCharType = nCharType ;
  1169. g_nWordsInPhrase++ ;
  1170. //Adding ends.
  1171. //Added by XGL, Sep 29th, 1998
  1172. g_rcFirstWordRect.left   = StringRect.left;
  1173. g_rcFirstWordRect.right  = StringRect.right;
  1174. g_rcFirstWordRect.top    = StringRect.top;
  1175. g_rcFirstWordRect.bottom = StringRect.bottom;
  1176. //Adding ends.
  1177. }
  1178. }
  1179. }
  1180. }
  1182. ////////////////////////////////////////////////////////////////////
  1183. // Deal with memdc string.
  1185. void AddToTextOutBuffer(HDC hMemDC, LPSTR szBuff, int cbLen, int x, int y, int FAR* lpDx)
  1186. {
  1187. int  nPrevWord, nCurrentWord, CharType;
  1188. RECT PrevWordRect, NextWordRect;
  1189. int  nLen, i;
  1191. if (cbLen >= (int)(BUFFERLENGTH - strlen(szMemDCWordBuff) - 2))
  1192. {
  1193. // buffer too small.
  1194. return;
  1195. }
  1197. // Write string to buffer.
  1198. nLen = strlen(szMemDCWordBuff);
  1199. strncpy(szMemDCWordBuff + nLen, szBuff, cbLen);
  1200. szMemDCWordBuff[nLen + cbLen    ] = ' ';
  1201. szMemDCWordBuff[nLen + cbLen + 1] = 0x00;
  1203. nPrevWord = nCurrentWord = -1;
  1204. while (nCurrentWord < cbLen)
  1205. {
  1206. //////////////////////////////////////////////////////////////
  1207. // Modified by Yan/gang 1998.02.20
  1208. // Reason: 
  1209. //         It cause the system destroy when the user run "WBLASTER"
  1210. //         The reason is the the array is overflow.
  1211. //         The WordBuffer array size is MEMDC_MAXNUM.
  1212. //         But it's point (nWordNum) is large than MEMDC_MAXNUM,
  1213. //         also, nWordNum is small than MAXNUM.
  1214. // if (nWordNum >= MAXNUM)
  1215. if (nWordNum >= MEMDC_MAXNUM)
  1216. break;
  1217. // Modify end.
  1218. //////////////////////////////////////////////////////////////
  1220. CharType     = GetCharType(szBuff[nCurrentWord + 1]);
  1221. nPrevWord    = nCurrentWord;
  1222. nCurrentWord = GetCurWordEnd(szBuff, nPrevWord + 1, cbLen, CharType);
  1224. GetStringRect(hMemDC, szBuff, nPrevWord + 1, x, y, &PrevWordRect, lpDx);
  1225. GetStringRect(hMemDC, szBuff, nCurrentWord + 1 , x, y, &NextWordRect, lpDx);
  1227. WordBuffer[nWordNum].nBegin = nLen + nPrevWord + 1;
  1228. WordBuffer[nWordNum].nEnd   = nLen + nCurrentWord;
  1229. WordBuffer[nWordNum].hMemDC = hMemDC;
  1230. WordBuffer[nWordNum].CharType = CharType;
  1231. WordBuffer[nWordNum].wordRect.left   = PrevWordRect.right;
  1232. WordBuffer[nWordNum].wordRect.right  = NextWordRect.right;
  1233. WordBuffer[nWordNum].wordRect.top    = NextWordRect.top;
  1234. WordBuffer[nWordNum].wordRect.bottom = NextWordRect.bottom;
  1236. nWordNum++;
  1238. if (nCurrentWord >= cbLen - 1)
  1239. break;
  1240. }
  1242. GetStringLeftRight(hMemDC, szBuff, 0, x, &PrevWordRect, lpDx);
  1243. for (i = 0; i < cbLen; i++)
  1244. {
  1245. GetStringLeftRight(hMemDC, szBuff, i+1, x, &NextWordRect, lpDx);
  1246. pnMemDCCharLeft[nLen + i]  = PrevWordRect.right;
  1247. pnMemDCCharRight[nLen + i] = NextWordRect.right;
  1249. CopyRect(&PrevWordRect, &NextWordRect);
  1250. }
  1251. }
  1253. void GetMemWordStringRect(int nWordCode, int nOffset, LPRECT lpStringRect)
  1254. {
  1255. POINT  WndPos;
  1256. int    nNum;
  1258. if (nWordCode >= nWordNum)
  1259. {
  1260. lpStringRect->left   = 0;
  1261. lpStringRect->right  = 0;
  1262. lpStringRect->top    = 0;
  1263. lpStringRect->bottom = 0;
  1265. return;
  1266. }
  1268. CopyRect(lpStringRect, &(WordBuffer[nWordCode].wordRect));
  1269. if (nOffset != MEMDC_TOTALWORD)
  1270. {
  1271. nNum = WordBuffer[nWordCode].nBegin + nOffset;
  1272. lpStringRect->left = pnMemDCCharLeft[nNum];
  1273. // lpStringRect->left = pnMemDCCharRight[nNum];
  1274. lpStringRect->right = pnMemDCCharRight[nNum];
  1275. }
  1277. WndPos.x = LOWORD(g_dwDCOrg);
  1278. WndPos.y = HIWORD(g_dwDCOrg);
  1280. lpStringRect->top    = lpStringRect->top    + WndPos.y;
  1281. lpStringRect->bottom = lpStringRect->bottom + WndPos.y;
  1282. lpStringRect->left   = lpStringRect->left   + WndPos.x;
  1283. lpStringRect->right  = lpStringRect->right  + WndPos.x;
  1284. }
  1286. void CheckMemDCWordBuffer(HDC hdcdest, HDC hdcSrc)
  1287. {
  1288. int i;
  1290. for (i = 0; i < nWordNum; i++)
  1291. {
  1292. if (WordBuffer[i].hMemDC == hdcSrc)
  1293. {
  1294. CheckMouseInMemDCWord(i);
  1295. }
  1296. else
  1297. {
  1298. #ifdef _DICTING_
  1299. if (CheckDCWndClassName(hdcdest))
  1300. {
  1301. CheckMouseInMemDCWord(i);
  1302. }
  1303. #endif
  1304. }
  1305. // CheckMouseInMemDCWord(i);
  1306. }                               
  1307. }
  1309. #ifdef _DICTING_
  1311. #define IE4_CLIENT_CLASSNAME "Internet Explorer_Server"// 定义取词中 DC 所属窗口的类名。
  1312. #define OUTLOOK_EDIT_CLASSNAME "RichEdit20A"
  1313. #define MAX_CLASS_NAME 256
  1315. extern WINDOWFROMDC_PROC WindowFromDC;
  1316. int  g_nWorkOnClassNum = 2;
  1317. char g_szWorkOnClassName[2][MAX_CLASS_NAME] = { 
  1318. IE4_CLIENT_CLASSNAME, // IE 4.0
  1319. OUTLOOK_EDIT_CLASSNAME // OutLook
  1320. };
  1322. _inline BOOL CheckDCWndClassName(HDC hDC)
  1323. {
  1324. HWND hWndFromDC;
  1325. char szClassName[MAX_CLASS_NAME];
  1326. int i;
  1328. hWndFromDC = WindowFromDC(hDC);
  1329. GetClassName(hWndFromDC, szClassName, MAX_CLASS_NAME);
  1331. for (i = 0; i < g_nWorkOnClassNum; i++)
  1332. {
  1333. if (lstrcmp(szClassName, (LPSTR)g_szWorkOnClassName[i]) == 0)
  1334. {
  1335. return TRUE;
  1336. }
  1337.     }
  1338. return FALSE;
  1339. }
  1341. #endif
  1343. __inline DWORD CheckMouseInMemDCWord(int nWordCode)
  1344. {
  1345. RECT  StringRect;
  1347. GetMemWordStringRect(nWordCode, MEMDC_TOTALWORD, &StringRect);
  1349. // if (PtInRect(&StringRect, g_CurMousePos))
  1350. if (  (StringRect.left   <= g_CurMousePos.x)
  1351. &&(StringRect.right  >= g_CurMousePos.x)
  1352. &&(StringRect.top    <= g_CurMousePos.y)
  1353. &&(StringRect.bottom >= g_CurMousePos.y))
  1354. {
  1355. switch (WordBuffer[nWordCode].CharType)
  1356. {
  1357. case CHAR_TYPE_HZ:
  1358. case CHAR_TYPE_ASCII:
  1359.  CopyWord(g_szCurWord, szMemDCWordBuff, WordBuffer[nWordCode].nBegin, WordBuffer[nWordCode].nEnd);
  1360.  g_CurWordRect.left   = StringRect.left;
  1361.  g_CurWordRect.right  = StringRect.right;
  1362.  g_CurWordRect.top    = StringRect.top;
  1363.  g_CurWordRect.bottom = StringRect.bottom;
  1364.  
  1365.  g_nCurCaretPlace = -1;
  1366.  CalculateCaretPlaceInMemDCWord(nWordCode);
  1367.  
  1368.  break;
  1369. case CHAR_TYPE_OTHER:
  1370.  break;
  1371. }
  1372. AddToTotalWord(szMemDCWordBuff, 
  1373. 0,  // Ignor
  1374. WordBuffer[nWordCode].nBegin, 
  1375. WordBuffer[nWordCode].nEnd, 
  1376. WordBuffer[nWordCode].CharType, 
  1377. StringRect, 
  1378. TRUE);
  1380. if (  (WordBuffer[nWordCode].CharType == CHAR_TYPE_OTHER)
  1381.     &&(g_CurMousePos.x == StringRect.right))
  1382. {
  1383. return NO_CURMOUSEWORD;
  1384. }
  1385. return HAS_CURMOUSEWORD;
  1386. }
  1387. else
  1388. {
  1389. }
  1391. AddToTotalWord(szMemDCWordBuff, 
  1392.    0,  // Ignor
  1393.    WordBuffer[nWordCode].nBegin, 
  1394.    WordBuffer[nWordCode].nEnd, 
  1395.    WordBuffer[nWordCode].CharType, 
  1396.    StringRect, 
  1397.    FALSE);
  1399. return NO_CURMOUSEWORD;   
  1400. }
  1402. // 用於计算指定位置在字串中的位置·
  1403. __inline DWORD CalculateCaretPlaceInMemDCWord(int nWordCode)
  1404. {
  1405. RECT  StringRect;
  1406. int   i;
  1408. if (  (WordBuffer[nWordCode].CharType == CHAR_TYPE_HZ) 
  1409.     &&(WordBuffer[nWordCode].nBegin    == WordBuffer[nWordCode].nEnd))
  1410. {
  1411. g_nCurCaretPlace = -1;
  1412. return 0L;
  1413. }
  1415. GetMemWordStringRect(nWordCode, MEMDC_TOTALWORD, &StringRect);
  1417. if (CalcCaretInThisPlace(g_CurMousePos.x, StringRect.left))
  1418. {
  1419. // g_nCurCaretPlace = WordBuffer[nWordCode].nBegin;
  1420. g_nCurCaretPlace = 0;
  1421. return 0l;
  1422. }
  1424. if (CalcCaretInThisPlace(g_CurMousePos.x, StringRect.right))
  1425. {
  1426. // g_nCurCaretPlace = WordBuffer[nWordCode].nEnd + 1;
  1427. g_nCurCaretPlace = WordBuffer[nWordCode].nEnd - WordBuffer[nWordCode].nBegin + 1;
  1428. return 0l;
  1429. }
  1431. for (i = WordBuffer[nWordCode].nBegin; i <= WordBuffer[nWordCode].nEnd; i++)
  1432. {
  1433. GetMemWordStringRect(nWordCode, i - WordBuffer[nWordCode].nBegin, &StringRect);
  1434. if (CalcCaretInThisPlace(g_CurMousePos.x, StringRect.right))
  1435. {
  1436. // g_nCurCaretPlace = i + 1;
  1437. g_nCurCaretPlace = i - WordBuffer[nWordCode].nBegin + 1;
  1438. return 0l;
  1439. }
  1440. }
  1442. return 0L;
  1443. }
  1445. /*
  1446. if (nCurCharNum != nFromPlace)
  1447. {
  1448. #ifdef _DEBUG
  1449. DbgPrintf("NhWSrh.DLL          nCurCharNum != nFromPlace");
  1450. #endif
  1451. return TRUE;
  1452. }
  1454. if (  (nCurCharNum == nLength - 1)
  1455. &&(lpString[nCurCharNum] == CHAR_LINK)
  1456.    ||(lpString[nCurCharNum] == '?')
  1457.    ||(lpString[nCurCharNum] == '*'))
  1458. {
  1459. return FALSE;
  1460. }
  1462. if (  (nCurCharNum != nFromPlace)
  1463. &&   (lpString[nCurCharNum] == CHAR_LINK)
  1464.    ||(lpString[nCurCharNum] == '?')
  1465.    ||(lpString[nCurCharNum] == '*'))
  1466. {
  1467. #ifdef _DEBUG
  1468. DbgPrintf("NhWSrh.DLL          3");
  1469. #endif
  1470. return TRUE;
  1471. }
  1473. if ((nCurCharNum == '?') || (nCurCharNum == '*'))
  1474. {
  1475. #ifdef _DEBUG
  1476. DbgPrintf("NhWSrh.DLL          *?");
  1477. #endif
  1478. if (nCurCharNum == nLength - 1)
  1479. {
  1480. #ifdef _DEBUG
  1481. DbgPrintf("NhWSrh.DLL          nCurCharNum == nLength - 1");
  1482. #endif
  1483. return FALSE;
  1484. }
  1485. if (GetCharType(lpString[nCurCharNum + 1]) != CHAR_TYPE_ASCII)
  1486. {
  1487. #ifdef _DEBUG
  1488. DbgPrintf("NhWSrh.DLL          etCharType(lpString[nCurCharNum + 1]) != CHAR_TYPE_ASCII");
  1489. #endif
  1490. return FALSE;
  1491. }
  1492. if (nCurCharNum == nFromPlace)
  1493. {
  1494. #ifdef _DEBUG
  1495. DbgPrintf("NhWSrh.DLL          nCurCharNum == nFromPlace");
  1496. #endif
  1497. return FALSE;
  1498. }
  1500. return TRUE;
  1501. }
  1502. __inline int  FindAWord(LPCSTR lpString, int nFromPlace, int nLength)
  1503. {
  1504. int i = nFromPlace;
  1505. int j;
  1506. while (i < nLength)
  1507. {
  1508. if (  (lpString[i] == '?')
  1509.     ||(lpString[i] == '*'))
  1510. {
  1511. #ifdef _DEBUG
  1512. DbgPrintf("NhWSrh.DLL          ?*");
  1513. #endif
  1514. if (i == nLength - 1)
  1515. {
  1516. #ifdef _DEBUG
  1517. DbgPrintf("NhWSrh.DLL          i == nLength - 1");
  1518. #endif
  1519. // return i - 1;
  1520. return i;
  1521. }
  1522. j = i;
  1523. while(j < nLength)
  1524. {
  1525. if ((lpString[j] != '?')&&(lpString[j] != '*'))
  1526. {
  1527. #ifdef _DEBUG
  1528. DbgPrintf("NhWSrh.DLL          is not ?*");
  1529. #endif
  1530. break;
  1531. }
  1532. j++;
  1533. }
  1535. if (j == nLength)
  1536. return j-1;
  1538. if (IsASCIIWord(lpString, nFromPlace, nLength, j))
  1539. {
  1540. i = j;
  1541. }
  1542. else
  1543. {
  1544. // return i - 1;
  1545. return j - 1;
  1546. }
  1547. }
  1548. // 用於处理 '-' 的几种情况·
  1549. if (IsASCIIWord(lpString, nFromPlace, nLength, i))
  1550. // if (GetCharType(lpString[i]) == CHAR_TYPE_ASCII)
  1551. {
  1552. i++;
  1553. }
  1554. else
  1555. {
  1556. return i-1;
  1557. }
  1558. } 
  1560. return nLength - 1;
  1561. }
  1563. __inline BOOL IsASCIIWord(LPCSTR lpString, int nFromPlace, int nLength, int nCurCharNum)
  1564. {
  1565. if (GetCharType(lpString[nCurCharNum]) == CHAR_TYPE_ASCII)
  1566. {
  1567. return TRUE;
  1568. }
  1570. if (lpString[nCurCharNum] == CHAR_LINK)
  1571. {
  1572. if (nCurCharNum == nLength - 1)
  1573. {
  1574. return FALSE;
  1575. }
  1576. if (GetCharType(lpString[nCurCharNum + 1]) == CHAR_TYPE_ASCII)
  1577. {
  1578. return TRUE;
  1579. }
  1580. }
  1582. /* if (  (lpString[nCurCharNum] == '?')
  1583. ||(lpString[nCurCharNum] == '*'))
  1584. {
  1585. if (nCurCharNum == nLength - 1)
  1586. {
  1587. return FALSE;
  1588. }
  1589. nCurCharNum++;
  1590. while(nCurCharNum < nLength)
  1591. {
  1592. if (GetCharType(lpString[nCurCharNum]) ==
  1593. }
  1594. // if (GetCharType(lpString[nCurCharNum + 1]) == CHAR_TYPE_ASCII)
  1595. // {
  1596. // return TRUE;
  1597. // }
  1598. }*/
  1599. // return FALSE;
  1600. //}
  1601. //*/
  1603. /*
  1605. __inline int  FindAWord(LPCSTR lpString, int nFromPlace, int nLength)
  1606. {
  1607. int i = nFromPlace;
  1608. // int j;
  1609. while (i < nLength)
  1610. {
  1611. if (lpString[i] == CHAR_LINK)
  1612. {
  1613. if (IsASCIIWord(lpString, nFromPlace, nLength, i + 1))
  1614. {
  1615. i++;
  1616. }
  1617. else
  1618. {
  1619. return i-1;
  1620. }
  1621. }
  1622. else
  1623. {
  1624. // 用於处理 '-' 的几种情况·
  1625. if (IsASCIIWord(lpString, nFromPlace, nLength, i))
  1626. // if (GetCharType(lpString[i]) == CHAR_TYPE_ASCII)
  1627. {
  1628. i++;
  1629. }
  1630. else
  1631. {
  1632. return i-1;
  1633. }
  1634. }
  1635. } 
  1637. return nLength - 1;
  1638. }
  1641. __inline BOOL IsASCIIWord(LPCSTR lpString, int nFromPlace, int nLength, int nCurCharNum)
  1642. {
  1643. if (GetCharType(lpString[nCurCharNum]) == CHAR_TYPE_ASCII)
  1644. {
  1645. return TRUE;
  1646. }
  1647.     
  1648. if (lpString[nCurCharNum] == CHAR_WILDCHAR1)
  1649. {
  1650. return TRUE;
  1651. }
  1653. if (lpString[nCurCharNum] == CHAR_WILDCHAR2)
  1654. {
  1655. return TRUE;
  1656. }
  1657. // if (lpString[nCurCharNum] == CHAR_LINK)
  1658. // {
  1659. // if (nCurCharNum == nLength - 1)
  1660. // {
  1661. // return FALSE;
  1662. // }
  1663. // if (GetCharType(lpString[nCurCharNum + 1]) == CHAR_TYPE_ASCII)
  1664. // {
  1665. // return TRUE;
  1666. // }
  1667. // }
  1669. return FALSE;
  1670. }
  1672. */