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

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

源码/资料

开发平台：

C/C++

Findword.c：源码内容
  2. #include <windows.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>
  9. #include "import.h"
  11. extern char  g_szCurWord[];
  12. extern RECT  g_CurWordRect;
  13. extern int   g_nCurCaretPlace;
  15. extern BOOL  g_bAllowGetCurWord;
  16. extern POINT g_CurMousePos;
  17. extern HWND  g_hNotifyWnd;
  19. extern UINT         g_nTextAlign;
  20. extern POINT        g_dwDCOrg;
  21. extern int          g_nExtra;
  22. extern POINT        g_CurPos;
  23. extern TEXTMETRIC   g_tm;
  25. #define CHAR_WILDCHAR1 '*'
  26. #define CHAR_WILDCHAR2 '?'
  28. ///////////////////////////////////////////////////////////////////////////
  29. // Modify by Yan/Gang 1997/11/18
  30. // 用於修改在计算 TA_CENTER 情况的失误。
  31. extern BOOL bRecAllRect;
  32. extern RECT g_rcTotalRect;
  33. // End Modify
  34. ///////////////////////////////////////////////////////////////////////////
  36. #ifdef _DICTING_
  37. /////////////////////////////////////////////////////////////////////////////////
  38. // Modify by Yan/Gang 1997/11/19
  39. // 主要解决通配符的问题。
  40. extern int g_nGetWordStyle;
  41. // End Add.
  42. /////////////////////////////////////////////////////////////////////////////////
  43. #endif
  45. #define RIGHT  1
  46. #define LEFT  -1
  48. //////////////////////////////////////////////////////////////////////////////////
  49. // TODO: Return a char type.
  50. __inline int  GetCharType(char ch)
  51. {
  52. BYTE chitem = ch;
  54. if (ch < 0)
  55. return CHAR_TYPE_HZ;
  57. if (((ch >= 'a')&&(ch <= 'z'))||
  58.     ((ch >= 'A')&&(ch <= 'Z')))
  59. {
  60. return CHAR_TYPE_ASCII;
  61. }
  63. return CHAR_TYPE_OTHER;
  64. }
  66. #ifdef _DICTING_
  67. /////////////////////////////////////////////////////////////////////////////////
  68. // Modify by Yan/Gang 1997/11/19
  69. // 主要解决通配符的问题。
  70. __inline int  FindAWord(LPCSTR lpString, int nFromPlace, int nLength)
  71. {
  72. if (g_nGetWordStyle == GETWORD_TW_ENABLE)
  73. {
  74. return FindTWWord(lpString, nFromPlace, nLength);
  75. }
  76. else
  77. {
  78. return FindDWord(lpString, nFromPlace, nLength);
  79. }
  81. return 0;
  82. }
  84. __inline int  FindDWord(LPCSTR lpString, int nFromPlace, int nLength)
  85. {
  86. int i = nFromPlace;
  87. while (i < nLength)
  88. {
  89. if (GetCharType(lpString[i]) == CHAR_TYPE_ASCII)
  90. {
  91. i++;
  92. }
  93. else
  94. {
  95. return i-1;
  96. }
  97. } 
  99. return nLength - 1;
  100. }
  102. __inline int  FindTWWord(LPCSTR lpString, int nFromPlace, int nLength)
  103. {
  104. int i = nFromPlace;
  106. while (i < nLength)
  107. {
  108. if (lpString[i] == CHAR_LINK)
  109. {
  110. if (IsASCIIWord(lpString, nFromPlace, nLength, i + 1))
  111. {
  112. i++;
  113. }
  114. else
  115. {
  116. return i-1;
  117. }
  118. }
  119. else
  120. {
  121. // 用於处理 '-' 的几种情况·
  122. if (IsASCIIWord(lpString, nFromPlace, nLength, i))
  123. // if (GetCharType(lpString[i]) == CHAR_TYPE_ASCII)
  124. {
  125. i++;
  126. }
  127. else
  128. {
  129. return i-1;
  130. }
  131. }
  132. } 
  134. return nLength - 1;
  135. }
  137. __inline BOOL IsASCIIWord(LPCSTR lpString, int nFromPlace, int nLength, int nCurCharNum)
  138. {
  139. if (GetCharType(lpString[nCurCharNum]) == CHAR_TYPE_ASCII)
  140. {
  141. return TRUE;
  142. }
  143.     
  144. if (lpString[nCurCharNum] == CHAR_WILDCHAR1)
  145. {
  146. return TRUE;
  147. }
  149. if (lpString[nCurCharNum] == CHAR_WILDCHAR2)
  150. {
  151. return TRUE;
  152. }
  154. return FALSE;
  155. }
  156. // End Add.
  157. /////////////////////////////////////////////////////////////////////////////////
  158. #else
  159. __inline int  FindAWord(LPCSTR lpString, int nFromPlace, int nLength)
  160. {
  161. int i = nFromPlace;
  162. // int j;
  163. while (i < nLength)
  164. {
  165. if (lpString[i] == CHAR_LINK)
  166. {
  167. if (IsASCIIWord(lpString, nFromPlace, nLength, i + 1))
  168. {
  169. i++;
  170. }
  171. else
  172. {
  173. return i-1;
  174. }
  175. }
  176. else
  177. {
  178. // 用於处理 '-' 的几种情况·
  179. if (IsASCIIWord(lpString, nFromPlace, nLength, i))
  180. {
  181. i++;
  182. }
  183. else
  184. {
  185. return i-1;
  186. }
  187. }
  188. } 
  190. return nLength - 1;
  191. }
  193. #define CHAR_WILDCHAR1 '*'
  194. #define CHAR_WILDCHAR2 '?'
  196. __inline BOOL IsASCIIWord(LPCSTR lpString, int nFromPlace, int nLength, int nCurCharNum)
  197. {
  198. if (GetCharType(lpString[nCurCharNum]) == CHAR_TYPE_ASCII)
  199. {
  200. return TRUE;
  201. }
  202.     
  203. if (lpString[nCurCharNum] == CHAR_WILDCHAR1)
  204. {
  205. return TRUE;
  206. }
  208. if (lpString[nCurCharNum] == CHAR_WILDCHAR2)
  209. {
  210. return TRUE;
  211. }
  212. return FALSE;
  213. }
  214. #endif
  216. __inline int  FindHZWord(LPCSTR lpString, int nFromPlace, int nLength)
  217. {
  218. int i = nFromPlace;
  219. while (i < nLength)
  220. {
  221. if (GetCharType(lpString[i]) == CHAR_TYPE_HZ)
  222. {
  223. i = i + 2;
  224. }
  225. else
  226. {
  227. return i - 1;
  228. }
  229. } 
  231. return nLength - 1;
  232. }
  234. __inline int FindNextWordBegin(LPCSTR lpString, int nFromPlace, int nLength)
  235. {
  236. int i = nFromPlace;
  237. while (i < nLength)
  238. {
  239. if (GetCharType(lpString[i]) == CHAR_TYPE_OTHER)
  240. {
  241. i++;
  242. }
  243. else
  244. {
  245. return i-1;
  246. }
  247. } 
  249. return i - 1;
  250. }
  252. __inline int GetCurWordEnd(LPCSTR lpString, int nFromPlace, int nLength, int nCharType)
  253. {
  254. switch (nCharType)
  255. {                       
  256. case CHAR_TYPE_ASCII:
  257.  return FindAWord(lpString, nFromPlace, nLength);
  258.  break;
  259. case CHAR_TYPE_HZ:
  260.  return FindHZWord(lpString, nFromPlace, nLength);
  261.  break;
  262. case CHAR_TYPE_OTHER:
  263.  return FindNextWordBegin(lpString, nFromPlace, nLength);
  264.  break;
  265. }
  266. return FindAWord(lpString, nFromPlace, nLength);
  267. }
  269. __inline void CopyWord(LPSTR lpWord, LPCSTR lpString, int nBegin, int nEnd)
  270. {
  271. int i;
  272. for ( i = nBegin; i <= nEnd; i++)
  273. {
  274. lpWord[i - nBegin] = lpString[i];
  275. }
  276. lpWord[nEnd - nBegin + 1] = '';
  277. }
  279. __inline void GetStringTopBottom(HDC hDC, int y, RECT* lpStringRect)
  280. {
  281. POINT  WndPos;
  283. WndPos.y = g_dwDCOrg.y;
  285.     if (TA_UPDATECP & g_nTextAlign)
  286.     {
  287.      y = g_CurPos.y;
  288.     }
  289.     
  290. switch ((TA_TOP | TA_BOTTOM)&g_nTextAlign)
  291. {
  292. case TA_BOTTOM:
  293.  lpStringRect->top    = y - g_tm.tmHeight + g_tm.tmInternalLeading;
  294.  lpStringRect->bottom = y;
  295.  break;
  296. case TA_BASELINE:
  297.  lpStringRect->top    = y - g_tm.tmAscent;
  298.  lpStringRect->bottom = y + g_tm.tmDescent;
  299.  break;
  300. case TA_TOP:
  301. default:
  302.  lpStringRect->top    = y;
  303.  lpStringRect->bottom = y + g_tm.tmHeight + g_tm.tmInternalLeading;
  304.  break;
  305. }
  307. LPtoDP(hDC, (LPPOINT)lpStringRect, 2);
  309. lpStringRect->top    = lpStringRect->top    + WndPos.y;
  310. lpStringRect->bottom = lpStringRect->bottom + WndPos.y;
  311. }
  313. __inline void GetStringLeftRight(HDC hDC, LPSTR szBuff, int cbLen, int x, RECT* lpStringRect, int FAR* lpDx)
  314. {
  315. SIZE   StringSize;
  316. POINT  WndPos;
  317.     int i;
  319. if (cbLen < 0)
  320. {
  321. lpStringRect->top    = 0;
  322. lpStringRect->bottom = 0;
  323. lpStringRect->left   = 0;
  324. lpStringRect->right  = 0;
  325. return;
  326. }
  328. GetTextExtentPoint(hDC, szBuff, cbLen, &StringSize);
  329. WndPos.x = g_dwDCOrg.x;
  331. if (lpDx != NULL)
  332. {
  333. StringSize.cx = 0;
  334. for (i = 0; i < cbLen; i++)
  335. {
  336. StringSize.cx += lpDx[i];
  337. }
  338. }
  339.     
  340.     if (TA_UPDATECP & g_nTextAlign)
  341.     {
  342.      x = g_CurPos.x;
  343.     }
  344.     
  345. switch ((TA_LEFT | TA_CENTER | TA_RIGHT)&g_nTextAlign)
  346. {
  347. case TA_RIGHT:
  348. ///////////////////////////////////////////////////////////////////////////
  349. // Modify by Yan/Gang 1997/11/21
  350. // 用於修改在计算 TA_RIGHT 情况的失误。
  351. //  lpStringRect->right = x;
  352. //  lpStringRect->left  = x - StringSize.cx;
  353.  if (!bRecAllRect)
  354.  {
  355.  lpStringRect->right = x;
  356.  lpStringRect->left  = x - StringSize.cx;
  357.  }
  358.  else
  359.  {
  360.   lpStringRect->left = g_rcTotalRect.left;
  361.   lpStringRect->right= g_rcTotalRect.left + StringSize.cx;
  362.  }
  363. // End Modify
  364. ///////////////////////////////////////////////////////////////////////////
  365. //  lpStringRect->right = x;
  366. //  lpStringRect->left  = x - StringSize.cx;
  367.  break;
  368. case TA_CENTER:
  369. ///////////////////////////////////////////////////////////////////////////
  370. // Modify by Yan/Gang 1997/11/18
  371. // 用於修改在计算 TA_CENTER 情况的失误。
  372. //  lpStringRect->right = x + StringSize.cx / 2;
  373. //  lpStringRect->left  = x - StringSize.cx / 2;
  374.  if (!bRecAllRect)
  375.  {
  376.  lpStringRect->right = x + StringSize.cx / 2;
  377.  lpStringRect->left  = x - StringSize.cx / 2;
  378.  }
  379.  else
  380.  {
  381.   lpStringRect->left = g_rcTotalRect.left;
  382.   lpStringRect->right= g_rcTotalRect.left + StringSize.cx;
  383.  }
  384. // End Modify
  385. ///////////////////////////////////////////////////////////////////////////
  386. //  lpStringRect->right = x + StringSize.cx / 2;
  387. //  lpStringRect->left  = x - StringSize.cx / 2;
  388.  break;
  389. case TA_LEFT:
  390. default:
  391.  lpStringRect->left  = x ;
  392.  lpStringRect->right = x + StringSize.cx;
  393.  break;
  394. }
  396. LPtoDP(hDC, (LPPOINT)lpStringRect, 2);
  398. lpStringRect->left   = lpStringRect->left   + WndPos.x;
  399. lpStringRect->right  = lpStringRect->right  + WndPos.x;
  400. }
  402. void GetStringRect(HDC hDC, LPSTR szBuff, int cbLen, int x, int y, RECT* lpStringRect, int FAR* lpDx)
  403. {
  404. SIZE   StringSize;
  405. POINT  WndPos;
  406.     int i;
  408. if (cbLen < 0)
  409. {
  410. lpStringRect->top    = 0;
  411. lpStringRect->bottom = 0;
  412. lpStringRect->left   = 0;
  413. lpStringRect->right  = 0;
  414. return;
  415. }
  417. GetTextExtentPoint(hDC, szBuff, cbLen, &StringSize);
  418. WndPos.x = g_dwDCOrg.x;
  419. WndPos.y = g_dwDCOrg.y;
  421. if (lpDx != NULL)
  422. {
  423. StringSize.cx = 0;
  424. for (i = 0; i < cbLen; i++)
  425. {
  426. StringSize.cx += lpDx[i];
  427. }
  428. }
  429.     
  430.     if (TA_UPDATECP & g_nTextAlign)
  431.     {
  432.      x = g_CurPos.x;
  433.      y = g_CurPos.y;
  434.     }
  435.     
  436. switch ((TA_LEFT | TA_CENTER | TA_RIGHT)&g_nTextAlign)
  437. {
  438. case TA_RIGHT:
  439. ///////////////////////////////////////////////////////////////////////////
  440. // Modify by Yan/Gang 1997/11/21
  441. // 用於修改在计算 TA_RIGHT 情况的失误。
  442. //  lpStringRect->right = x;
  443. //  lpStringRect->left  = x - StringSize.cx;
  444.  if (!bRecAllRect)
  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. // End Modify
  455. ///////////////////////////////////////////////////////////////////////////
  456. //  lpStringRect->right = x;
  457. //  lpStringRect->left  = x - StringSize.cx;
  458.  break;
  459. case TA_CENTER:
  460. ///////////////////////////////////////////////////////////////////////////
  461. // Modify by Yan/Gang 1997/11/18
  462. // 用於修改在计算 TA_CENTER 情况的失误。
  463. //  lpStringRect->right = x + StringSize.cx / 2;
  464. //  lpStringRect->left  = x - StringSize.cx / 2;
  465.  if (!bRecAllRect)
  466.  {
  467.  lpStringRect->right = x + StringSize.cx / 2;
  468.  lpStringRect->left  = x - StringSize.cx / 2;
  469.  }
  470.  else
  471.  {
  472.   lpStringRect->left = g_rcTotalRect.left;
  473.   lpStringRect->right= g_rcTotalRect.left + StringSize.cx;
  474.  }
  475. // End Modify
  476. ///////////////////////////////////////////////////////////////////////////
  477. //  lpStringRect->right = x + StringSize.cx / 2;
  478. //  lpStringRect->left  = x - StringSize.cx / 2;
  479.  break;
  480. case TA_LEFT:
  481. default:
  482.  lpStringRect->left  = x ;
  483.  lpStringRect->right = x + StringSize.cx;
  484.  break;
  485. }
  487. switch ((TA_TOP | TA_BOTTOM | TA_BASELINE)&g_nTextAlign)
  488. {
  489. case TA_BOTTOM:
  490.  lpStringRect->top    = y - StringSize.cy;
  491.  lpStringRect->bottom = y;
  492.  break;
  493. case TA_BASELINE:
  494.  lpStringRect->top    = y - g_tm.tmAscent;
  495.  lpStringRect->bottom = y + g_tm.tmDescent;
  496.  break;
  497. case TA_TOP:
  498. default:
  499.  lpStringRect->top    = y;
  500.  lpStringRect->bottom = y + StringSize.cy;
  501.  break;
  502. }
  504. LPtoDP(hDC, (LPPOINT)lpStringRect, 2);
  506. lpStringRect->top    = lpStringRect->top    + WndPos.y;
  507. lpStringRect->bottom = lpStringRect->bottom + WndPos.y;
  508. lpStringRect->left   = lpStringRect->left   + WndPos.x;
  509. lpStringRect->right  = lpStringRect->right  + WndPos.x;
  510. }
  512. DWORD GetCurMousePosWord(HDC   hDC, 
  513.  LPSTR szBuff, 
  514.  int   cbLen, 
  515.  int   x, 
  516.  int   y, 
  517.  int   FAR* lpDx)
  518. {
  519. int   nCurrentWord, nPrevWord;
  520. RECT  StringRect;
  521. int   CharType;
  522. int   nLeft;
  523. DWORD dwReturn;
  525. GetStringTopBottom(hDC, y, &StringRect);
  526. if ((StringRect.top > g_CurMousePos.y) || (StringRect.bottom < g_CurMousePos.y))
  527. {
  528. return NO_CURMOUSEWORD;
  529. }
  531. GetStringRect(hDC, szBuff, cbLen, x, y, &StringRect, lpDx);
  532. nLeft = StringRect.left;
  533. // nLeft = 0;
  535. nPrevWord = nCurrentWord = -1;
  536. while (nCurrentWord < cbLen)
  537. {
  538. CharType     = GetCharType(szBuff[nCurrentWord + 1]);
  539. nPrevWord    = nCurrentWord;
  540. nCurrentWord = GetCurWordEnd(szBuff, nPrevWord + 1, cbLen, CharType);
  541. dwReturn     = CheckMouseInCurWord(hDC, szBuff, cbLen, x, y, lpDx, &nLeft, nPrevWord + 1, nCurrentWord, CharType);
  543. if (dwReturn == HAS_CURMOUSEWORD)
  544. return HAS_CURMOUSEWORD;
  545. if (nCurrentWord >= cbLen - 1)
  546. return NO_CURMOUSEWORD;
  547. }
  549. return NO_CURMOUSEWORD;   
  550. }
  552. __inline DWORD CheckMouseInCurWord(HDC   hDC, 
  553.    LPSTR szBuff, 
  554.    int   cbLen, 
  555.    int   x, 
  556.    int   y, 
  557.    int   FAR* lpDx,
  558.    int*  lpLeft,
  559.    int   nBegin,    // = nPrevWord + 1
  560.    int   nEnd,
  561.    int   nCharType)
  562. {
  563. RECT  StringRect;
  565. GetStringRect(hDC, szBuff, nEnd + 1, x, y, &StringRect, lpDx);
  566. StringRect.left = *lpLeft;
  567. *lpLeft = StringRect.right;
  569. if (  ((g_CurMousePos.x >= StringRect.left    ) && (g_CurMousePos.x <= StringRect.right))
  570.     || (g_CurMousePos.x == StringRect.left - 1)
  571.     || (g_CurMousePos.x == StringRect.right + 1))
  572. {
  573. switch (nCharType)
  574. {
  575. case CHAR_TYPE_HZ:
  577. case CHAR_TYPE_ASCII:
  578.  CopyWord(g_szCurWord, szBuff, nBegin, nEnd);
  579.  g_CurWordRect.left   = StringRect.left;
  580.  g_CurWordRect.right  = StringRect.right;
  581.  g_CurWordRect.top    = StringRect.top;
  582.  g_CurWordRect.bottom = StringRect.bottom;
  583.  
  584.  g_nCurCaretPlace = -1;
  585.  CalculateCaretPlace(hDC, 
  586.  szBuff, 
  587.  cbLen,
  588.  x,
  589.  y,
  590.  lpDx,
  591.  nBegin,
  592.  nEnd,
  593.  nCharType);
  594.  
  595.  break;
  596. case CHAR_TYPE_OTHER:
  597.  break;
  598. }
  599. Nh16_AddToTotalWord(szBuff, cbLen, nBegin, nEnd, nCharType, &StringRect, TRUE, g_nCurCaretPlace);
  600. if (  (nCharType == CHAR_TYPE_OTHER)
  601.     &&(CalcCaretInThisPlace(g_CurMousePos.x, StringRect.right)))
  602. {
  603. return NO_CURMOUSEWORD;
  604. }
  605. return HAS_CURMOUSEWORD;
  606. }
  607. else
  608. {
  609. }
  611. Nh16_AddToTotalWord(szBuff, cbLen, nBegin, nEnd, nCharType, &StringRect, FALSE, g_nCurCaretPlace);
  613. return NO_CURMOUSEWORD;   
  614. }
  616. // 用於计算指定位置在字串中的位置·
  617. __inline DWORD CalculateCaretPlace(HDC   hDC, 
  618.    LPSTR szBuff, 
  619.    int   cbLen, 
  620.    int   x, 
  621.    int   y, 
  622.    int   FAR* lpDx,
  623.    int   nBegin,    // = nPrevWord + 1
  624.    int   nEnd,
  625.    int   nCharType)
  626. {
  627. RECT  StringRect, BeginRect;
  628. RECT  CaretPrevRect, CaretNextRect;
  629. int   itemWidth; 
  630. int   TempPlace;
  632. if ((nCharType == CHAR_TYPE_HZ) && (nBegin == nEnd))
  633. {
  634. g_nCurCaretPlace = -1;
  635. return 0L;
  636. }
  638. GetStringRect(hDC, szBuff, nBegin, x, y, &BeginRect, lpDx);
  640. GetStringRect(hDC, szBuff, nEnd + 1,   x, y, &StringRect, lpDx);
  641. StringRect.left = BeginRect.right;
  642.     
  643.     if (StringRect.left == StringRect.right)
  644.     {
  645. g_nCurCaretPlace = -1;
  646. return 0L;
  647.     }
  649. switch (nCharType)
  650. {
  651. case CHAR_TYPE_HZ:
  652.  // 由於汉字都是等宽的字符，因此对於汉字的计算是通过计算
  653.  // 平均宽度来实现的·
  654.  itemWidth = (StringRect.right - StringRect.left) / (nEnd - nBegin + 1);
  655.  g_nCurCaretPlace = (g_CurMousePos.x - StringRect.left) * (nEnd - nBegin + 1) / (StringRect.right - StringRect.left);
  656.              break;
  657.              
  658. case CHAR_TYPE_ASCII:
  659.  // 由於英文字符为不等宽字符· 按以下步骤来计算的：
  660.  // 1. 按等宽计算一个相对位置·
  661.  // 2. 计算该相对位置的的绝对位置·
  662.  // 3. 若在该位置，返回·
  663.  // 4. 若该绝对长小於相对位置乘以宽，转6
  664.  // 5. 向右计算·
  665.  // 6. 向左计算·
  666.  
  667.  // 1. 按等宽计算一个相对位置·
  668.  // 计算宽度·
  669.  itemWidth = (StringRect.right - StringRect.left) / (nEnd - nBegin + 1);
  670.  // 计算位置·
  671.  TempPlace = (g_CurMousePos.x - StringRect.left) * (nEnd - nBegin + 1) / (StringRect.right - StringRect.left);
  672.  
  673.  // 2. 计算该相对位置的的绝对位置·
  674.  GetStringRect(hDC, szBuff, TempPlace,     x, y, &CaretPrevRect, lpDx);
  675.  GetStringRect(hDC, szBuff, TempPlace + 1, x, y, &CaretNextRect, lpDx);
  676.  
  677.  // 3. 若在该位置，返回·
  678.  if (CalcCaretInThisPlace(g_CurMousePos.x, CaretPrevRect.right)) 
  679.  {
  680.   g_nCurCaretPlace = TempPlace - nBegin;
  681.   break;
  682.  }
  683.  if (CalcCaretInThisPlace(g_CurMousePos.x, CaretNextRect.right))
  684.  {
  685.   g_nCurCaretPlace = TempPlace - nBegin + 1;
  686.   break;
  687.  }
  689.  // 4. 若该绝对长小於相对位置乘以宽，转6
  690.  if (g_CurMousePos.x > CaretNextRect.right)
  691.  {
  692.  // 5. 向右计算·      
  693.  GetEngLishCaretPlace(hDC, 
  694.   szBuff,
  695.   x,
  696.   y,
  697.   lpDx,
  698.   nBegin,    // = nPrevWord + 1
  699.   nEnd,
  700.   TempPlace,
  701.   RIGHT);
  702.  }
  703.  else
  704.  {
  705.  // 6. 向左计算·
  706.  GetEngLishCaretPlace(hDC, 
  707.   szBuff,
  708.   x,
  709.   y,
  710.   lpDx,
  711.   nBegin,    // = nPrevWord + 1
  712.   nEnd,
  713.   TempPlace,
  714.   LEFT);
  715.  }
  716.  
  717.  break;
  718. }
  719. return 0L;
  720. }
  722. __inline DWORD GetEngLishCaretPlace(HDC   hDC, 
  723. LPSTR szBuff,
  724. int   x,
  725. int   y,
  726. int   FAR* lpDx,
  727. int   nBegin,    // = nPrevWord + 1
  728. int   nEnd,
  729. int   TempPlace,
  730. int   turnto)
  731. {
  732. int i;
  733. RECT  CaretPrevRect, CaretNextRect;
  735. if (turnto == RIGHT)
  736. {
  737. i = TempPlace;
  738. GetStringRect(hDC, szBuff, i, x, y, &CaretPrevRect, lpDx);
  740. for (i = TempPlace; i <= nEnd; i++)
  741. {
  742.  GetStringRect(hDC, szBuff, i + 1, x, y, &CaretNextRect, lpDx);
  743.  if (CalcCaretInThisPlace(g_CurMousePos.x, CaretPrevRect.right)) 
  744.  {
  745.   g_nCurCaretPlace = i - nBegin;
  746.   return 0;
  747.  }
  748.  if (CalcCaretInThisPlace(g_CurMousePos.x, CaretNextRect.right))
  749.  {
  750.   g_nCurCaretPlace = i - nBegin + 1;
  751.   return 0;
  752.  }
  754.  CopyRect(&CaretPrevRect, &CaretNextRect);
  755. }
  756. g_nCurCaretPlace = nEnd - nBegin + 1;
  757. }
  758. else
  759. {
  760. i = TempPlace;
  761. GetStringRect(hDC, szBuff, i + 1, x, y, &CaretNextRect, lpDx);
  763. for (i = TempPlace; i >= nBegin; i--)
  764. {
  765.  GetStringRect(hDC, szBuff, i, x, y, &CaretPrevRect, lpDx);
  766.  if (CalcCaretInThisPlace(g_CurMousePos.x, CaretPrevRect.right)) 
  767.  {
  768.   g_nCurCaretPlace = i - nBegin;
  769.   return 0;
  770.  }
  771.  if (CalcCaretInThisPlace(g_CurMousePos.x, CaretNextRect.right))
  772.  {
  773.   g_nCurCaretPlace = i - nBegin + 1;
  774.   return 0;
  775.  }
  777.  CopyRect(&CaretNextRect, &CaretPrevRect);
  778. }
  779. g_nCurCaretPlace = nBegin - nBegin;
  780. }
  782. return 0;
  783. }
  785. BOOL CalcCaretInThisPlace(int CaretX, int nPlace)
  786. {
  787. if (CaretX == nPlace)
  788. {
  789. return TRUE;
  790. }
  792. if (CaretX == nPlace - 1)
  793. {
  794. return TRUE;
  795. }
  797. if (CaretX == nPlace + 1)
  798. {
  799. return TRUE;
  800. }
  802. return FALSE;
  803. }
  805. // Get current Chinese char that under the mouse cursor.
  806. // 1.                       2
  807. // mouse place :    |            |
  808. // chinese char:  英业达      英业达
  809. // return place:    |           |
  810. __inline int GetHZBeginPlace(LPSTR lpszHzBuff, int nBegin, int nEnd, LPRECT lpStringRect)
  811. {
  812. int itemWidth; 
  813. int nReturn;
  815. itemWidth = (lpStringRect->right - lpStringRect->left) / (nEnd - nBegin + 1);
  817. nReturn = (g_CurMousePos.x - lpStringRect->left) * (nEnd - nBegin + 1) / (lpStringRect->right - lpStringRect->left);
  819. if (nReturn == 0)
  820. return nBegin;
  821.     
  822. if (nReturn % 2 == 1)
  823. {
  824.      lpStringRect->left = lpStringRect->left + (nReturn - 1) * itemWidth;
  825.      return nBegin + nReturn - 1;
  826.     }
  827.     
  828.     lpStringRect->left = lpStringRect->left + nReturn * itemWidth;
  829. return (nBegin + nReturn);
  830. }
  833. ////////////////////////////////////////////////////////////////////
  834. // Deal with memdc string.
  836. void AddToTextOutBuffer(HDC hMemDC, LPSTR szBuff, int cbLen, int x, int y, int FAR* lpDx)
  837. {
  838. int  nPrevWord, nCurrentWord, CharType;
  839. RECT PrevWordRect, NextWordRect;
  840. int  nLen, i;
  842. nLen = Nh16_GetTempLen();
  843. if (!Nh16_AddToTempBuff(szBuff, cbLen))
  844. {
  845. return;
  846. }
  848. nPrevWord = nCurrentWord = -1;
  849. while (nCurrentWord < cbLen)
  850. {
  851. CharType     = GetCharType(szBuff[nCurrentWord + 1]);
  852. nPrevWord    = nCurrentWord;
  853. nCurrentWord = GetCurWordEnd(szBuff, nPrevWord + 1, cbLen, CharType);
  855. GetStringRect(hMemDC, szBuff, nPrevWord + 1, x, y, &PrevWordRect, lpDx);
  856. GetStringRect(hMemDC, szBuff, nCurrentWord + 1 , x, y, &NextWordRect, lpDx);
  858. NextWordRect.left = PrevWordRect.right;
  859. if (!Nh16_AddToWordStruct(nLen + nPrevWord + 1, nLen + nCurrentWord, hMemDC, CharType, &NextWordRect))
  860. {
  861. break;
  862. }
  864. if (nCurrentWord >= cbLen - 1)
  865. break;
  866. }
  868. GetStringLeftRight(hMemDC, szBuff, 0, x, &PrevWordRect, lpDx);
  869. for (i = 0; i < cbLen; i++)
  870. {
  871. GetStringLeftRight(hMemDC, szBuff, i+1, x, &NextWordRect, lpDx);
  872. Nh16_AddToCharStruct(nLen + i, PrevWordRect.right, NextWordRect.right);
  873. CopyRect(&PrevWordRect, &NextWordRect);
  874. }
  875. }