findword.c

屏幕取词源码.zip

// Modify by Yan/Gang 1997/11/21
// 用於修改在计算 TA_RIGHT 情况的失误。
//			 lpStringRect->right = x;
//			 lpStringRect->left  = x - StringSize.cx;
			 if (!bRecAllRect)
			 {
				 lpStringRect->right = x;
				 lpStringRect->left  = x - StringSize.cx;
			 }
			 else
			 {
			 	lpStringRect->left = g_rcTotalRect.left;
			 	lpStringRect->right= g_rcTotalRect.left + StringSize.cx;
			 }
// End Modify
///////////////////////////////////////////////////////////////////////////
//			 lpStringRect->right = x;
//			 lpStringRect->left  = x - StringSize.cx;
			 break;
		case TA_CENTER:
///////////////////////////////////////////////////////////////////////////
// Modify by Yan/Gang 1997/11/18
// 用於修改在计算 TA_CENTER 情况的失误。
//			 lpStringRect->right = x + StringSize.cx / 2;
//			 lpStringRect->left  = x - StringSize.cx / 2;
			 if (!bRecAllRect)
			 {
				 lpStringRect->right = x + StringSize.cx / 2;
				 lpStringRect->left  = x - StringSize.cx / 2;
			 }
			 else
			 {
			 	lpStringRect->left = g_rcTotalRect.left;
			 	lpStringRect->right= g_rcTotalRect.left + StringSize.cx;
			 }
// End Modify
///////////////////////////////////////////////////////////////////////////
//			 lpStringRect->right = x + StringSize.cx / 2;
//			 lpStringRect->left  = x - StringSize.cx / 2;
			 break;
		case TA_LEFT:
		default:
			 lpStringRect->left  = x ;
			 lpStringRect->right = x + StringSize.cx;
			 break;
	}
	
	switch ((TA_TOP | TA_BOTTOM | TA_BASELINE)&g_nTextAlign)
	{
		case TA_BOTTOM:
			 lpStringRect->top    = y - StringSize.cy;
			 lpStringRect->bottom = y;
			 break;
		case TA_BASELINE:
			 lpStringRect->top    = y - g_tm.tmAscent;
			 lpStringRect->bottom = y + g_tm.tmDescent;
			 break;
		case TA_TOP:
		default:
			 lpStringRect->top    = y;
			 lpStringRect->bottom = y + StringSize.cy;
			 break;
	}
	
	LPtoDP(hDC, (LPPOINT)lpStringRect, 2);

	lpStringRect->top    = lpStringRect->top    + WndPos.y;
	lpStringRect->bottom = lpStringRect->bottom + WndPos.y;
	lpStringRect->left   = lpStringRect->left   + WndPos.x;
	lpStringRect->right  = lpStringRect->right  + WndPos.x;
}

DWORD GetCurMousePosWord(HDC   hDC, 
						 LPSTR szBuff, 
						 int   cbLen, 
						 int   x, 
						 int   y, 
						 int   FAR* lpDx)
{
	int   nCurrentWord, nPrevWord;
	RECT  StringRect;
	int   CharType;
	int   nLeft;
	DWORD dwReturn;

	GetStringTopBottom(hDC, y, &StringRect);
	if ((StringRect.top > g_CurMousePos.y) || (StringRect.bottom < g_CurMousePos.y))
	{
		return NO_CURMOUSEWORD;
	}

	GetStringRect(hDC, szBuff, cbLen, x, y, &StringRect, lpDx);
	nLeft = StringRect.left;
//	nLeft = 0;

	nPrevWord = nCurrentWord = -1;
	while (nCurrentWord < cbLen)
	{
		CharType     = GetCharType(szBuff[nCurrentWord + 1]);
		nPrevWord    = nCurrentWord;
		nCurrentWord = GetCurWordEnd(szBuff, nPrevWord + 1, cbLen, CharType);
		dwReturn     = CheckMouseInCurWord(hDC, szBuff, cbLen, x, y, lpDx, &nLeft, nPrevWord + 1, nCurrentWord, CharType);

		if (dwReturn == HAS_CURMOUSEWORD)
			return HAS_CURMOUSEWORD;
		if (nCurrentWord >= cbLen - 1)
			return NO_CURMOUSEWORD;
	}
		
	return NO_CURMOUSEWORD;   
}

__inline DWORD CheckMouseInCurWord(HDC   hDC, 
								   LPSTR szBuff, 
								   int   cbLen, 
								   int   x, 
								   int   y, 
								   int   FAR* lpDx,
								   int*  lpLeft,
								   int   nBegin,    // = nPrevWord + 1
								   int   nEnd,
								   int   nCharType)
{
	RECT  StringRect;

	GetStringRect(hDC, szBuff, nEnd + 1, x, y, &StringRect, lpDx);
	StringRect.left = *lpLeft;
	*lpLeft = StringRect.right;

	if (  ((g_CurMousePos.x >= StringRect.left    ) && (g_CurMousePos.x <= StringRect.right))
	    || (g_CurMousePos.x == StringRect.left - 1)
	    || (g_CurMousePos.x == StringRect.right + 1))
	{
		switch (nCharType)
		{
			case CHAR_TYPE_HZ:

			case CHAR_TYPE_ASCII:
				 CopyWord(g_szCurWord, szBuff, nBegin, nEnd);
				 g_CurWordRect.left   = StringRect.left;
				 g_CurWordRect.right  = StringRect.right;
				 g_CurWordRect.top    = StringRect.top;
				 g_CurWordRect.bottom = StringRect.bottom;
				 
				 g_nCurCaretPlace = -1;
				 CalculateCaretPlace(hDC, 
									 szBuff, 
									 cbLen,
									 x,
									 y,
									 lpDx,
									 nBegin,
									 nEnd,
									 nCharType);
				 
				 break;
			case CHAR_TYPE_OTHER:
				 break;
		}
		Nh16_AddToTotalWord(szBuff, cbLen, nBegin, nEnd, nCharType, &StringRect, TRUE, g_nCurCaretPlace);
		if (  (nCharType == CHAR_TYPE_OTHER)
		    &&(CalcCaretInThisPlace(g_CurMousePos.x, StringRect.right)))
		{
			return NO_CURMOUSEWORD;
		}
		return HAS_CURMOUSEWORD;
	}
	else
	{
	}					

	Nh16_AddToTotalWord(szBuff, cbLen, nBegin, nEnd, nCharType, &StringRect, FALSE, g_nCurCaretPlace);

	return NO_CURMOUSEWORD;   
}

// 用於计算指定位置在字串中的位置·
__inline DWORD CalculateCaretPlace(HDC   hDC, 
								   LPSTR szBuff, 
								   int   cbLen, 
								   int   x, 
								   int   y, 
								   int   FAR* lpDx,
								   int   nBegin,    // = nPrevWord + 1
								   int   nEnd,
								   int   nCharType)
{
	RECT  StringRect, BeginRect;
	RECT  CaretPrevRect, CaretNextRect;
	int   itemWidth; 
	int   TempPlace;

	if ((nCharType == CHAR_TYPE_HZ) && (nBegin == nEnd))
	{
		g_nCurCaretPlace = -1;
		return 0L;
	}

	GetStringRect(hDC, szBuff, nBegin, x, y, &BeginRect, lpDx);
	
	GetStringRect(hDC, szBuff, nEnd + 1,   x, y, &StringRect, lpDx);
	StringRect.left = BeginRect.right;
    
    if (StringRect.left == StringRect.right)
    {
		g_nCurCaretPlace = -1;
		return 0L;
    }
	
	switch (nCharType)
	{
		case CHAR_TYPE_HZ:
			 // 由於汉字都是等宽的字符，因此对於汉字的计算是通过计算
			 // 平均宽度来实现的·
			 itemWidth = (StringRect.right - StringRect.left) / (nEnd - nBegin + 1);
			 g_nCurCaretPlace = (g_CurMousePos.x - StringRect.left) * (nEnd - nBegin + 1) / (StringRect.right - StringRect.left);
             break;
             
		case CHAR_TYPE_ASCII:
			 // 由於英文字符为不等宽字符· 按以下步骤来计算的：
			 // 1. 按等宽计算一个相对位置·
			 // 2. 计算该相对位置的的绝对位置·
			 // 3. 若在该位置，返回·
			 // 4. 若该绝对长小於相对位置乘以宽，转6
			 // 5. 向右计算·
			 // 6. 向左计算·
			 
			 // 1. 按等宽计算一个相对位置·
			 // 计算宽度·
			 itemWidth = (StringRect.right - StringRect.left) / (nEnd - nBegin + 1);
			 // 计算位置·
			 TempPlace = (g_CurMousePos.x - StringRect.left) * (nEnd - nBegin + 1) / (StringRect.right - StringRect.left);
			 
			 // 2. 计算该相对位置的的绝对位置·
			 GetStringRect(hDC, szBuff, TempPlace,     x, y, &CaretPrevRect, lpDx);
			 GetStringRect(hDC, szBuff, TempPlace + 1, x, y, &CaretNextRect, lpDx);
			 
			 // 3. 若在该位置，返回·
			 if (CalcCaretInThisPlace(g_CurMousePos.x, CaretPrevRect.right)) 
			 {
			 	g_nCurCaretPlace = TempPlace - nBegin;
			 	break;
			 }
			 if (CalcCaretInThisPlace(g_CurMousePos.x, CaretNextRect.right))
			 {
			 	g_nCurCaretPlace = TempPlace - nBegin + 1;
			 	break;
			 }

			 // 4. 若该绝对长小於相对位置乘以宽，转6
			 if (g_CurMousePos.x > CaretNextRect.right)
			 {
				 // 5. 向右计算·      
				 GetEngLishCaretPlace(hDC, 
									  szBuff,
									  x,
									  y,
									  lpDx,
									  nBegin,    // = nPrevWord + 1
									  nEnd,
									  TempPlace,
									  RIGHT);
			 }
			 else
			 {
				 // 6. 向左计算·
				 GetEngLishCaretPlace(hDC, 
									  szBuff,
									  x,
									  y,
									  lpDx,
									  nBegin,    // = nPrevWord + 1
									  nEnd,
									  TempPlace,
									  LEFT);
			 }
			 
			 break;
	}
	return 0L;
}

__inline DWORD GetEngLishCaretPlace(HDC   hDC, 
									LPSTR szBuff,
									int   x,
									int   y,
									int   FAR* lpDx,
									int   nBegin,    // = nPrevWord + 1
									int   nEnd,
									int   TempPlace,
									int   turnto)
{
	int i;
	RECT  CaretPrevRect, CaretNextRect;
	
	if (turnto == RIGHT)
	{
		i = TempPlace;
		GetStringRect(hDC, szBuff, i, x, y, &CaretPrevRect, lpDx);
		
		for (i = TempPlace; i <= nEnd; i++)
		{
			 GetStringRect(hDC, szBuff, i + 1, x, y, &CaretNextRect, lpDx);
			 if (CalcCaretInThisPlace(g_CurMousePos.x, CaretPrevRect.right)) 
			 {
			 	g_nCurCaretPlace = i - nBegin;
			 	return 0;
			 }
			 if (CalcCaretInThisPlace(g_CurMousePos.x, CaretNextRect.right))
			 {
			 	g_nCurCaretPlace = i - nBegin + 1;
			 	return 0;
			 }

			 CopyRect(&CaretPrevRect, &CaretNextRect);
		}
		g_nCurCaretPlace = nEnd - nBegin + 1;
	}
	else
	{
		i = TempPlace;
		GetStringRect(hDC, szBuff, i + 1, x, y, &CaretNextRect, lpDx);

		for (i = TempPlace; i >= nBegin; i--)
		{
			 GetStringRect(hDC, szBuff, i, x, y, &CaretPrevRect, lpDx);
			 if (CalcCaretInThisPlace(g_CurMousePos.x, CaretPrevRect.right)) 
			 {
			 	g_nCurCaretPlace = i - nBegin;
			 	return 0;
			 }
			 if (CalcCaretInThisPlace(g_CurMousePos.x, CaretNextRect.right))
			 {
			 	g_nCurCaretPlace = i - nBegin + 1;
			 	return 0;
			 }

			 CopyRect(&CaretNextRect, &CaretPrevRect);
		}
		g_nCurCaretPlace = nBegin - nBegin;
	}
	
	return 0;
}

BOOL CalcCaretInThisPlace(int CaretX, int nPlace)
{
	if (CaretX == nPlace)
	{
		return TRUE;
	}
	
	if (CaretX == nPlace - 1)
	{
		return TRUE;
	}
	
	if (CaretX == nPlace + 1)
	{
		return TRUE;
	}
	
	return FALSE;
}

// Get current Chinese char that under the mouse cursor.
// 1.                       2
// mouse place :    |            |
// chinese char:  英业达      英业达
// return place:    |           |
__inline int GetHZBeginPlace(LPSTR lpszHzBuff, int nBegin, int nEnd, LPRECT lpStringRect)
{
	int itemWidth; 
	int nReturn;

	itemWidth = (lpStringRect->right - lpStringRect->left) / (nEnd - nBegin + 1);

	nReturn = (g_CurMousePos.x - lpStringRect->left) * (nEnd - nBegin + 1) / (lpStringRect->right - lpStringRect->left);

	if (nReturn == 0)
		return nBegin;		
    
	if (nReturn % 2 == 1)
	{
    	lpStringRect->left = lpStringRect->left + (nReturn - 1) * itemWidth;
    	return nBegin + nReturn - 1;
    }
    
   	lpStringRect->left = lpStringRect->left + nReturn * itemWidth;
	return (nBegin + nReturn);
}


////////////////////////////////////////////////////////////////////
// Deal with memdc string.

void AddToTextOutBuffer(HDC hMemDC, LPSTR szBuff, int cbLen, int x, int y, int FAR* lpDx)
{
	int  nPrevWord, nCurrentWord, CharType;
	RECT PrevWordRect, NextWordRect;
	int  nLen, i;
	
	nLen = Nh16_GetTempLen();
	if (!Nh16_AddToTempBuff(szBuff, cbLen))
	{
		return;
	}

	nPrevWord = nCurrentWord = -1;
	while (nCurrentWord < cbLen)
	{
		CharType     = GetCharType(szBuff[nCurrentWord + 1]);
		nPrevWord    = nCurrentWord;
		nCurrentWord = GetCurWordEnd(szBuff, nPrevWord + 1, cbLen, CharType);

		GetStringRect(hMemDC, szBuff, nPrevWord + 1, x, y, &PrevWordRect, lpDx);
		GetStringRect(hMemDC, szBuff, nCurrentWord + 1 , x, y, &NextWordRect, lpDx);
		
		NextWordRect.left = PrevWordRect.right;
		if (!Nh16_AddToWordStruct(nLen + nPrevWord + 1, nLen + nCurrentWord, hMemDC, CharType, &NextWordRect))
		{
			break;
		}

		if (nCurrentWord >= cbLen - 1)
			break;
	}
	
	GetStringLeftRight(hMemDC, szBuff, 0, x, &PrevWordRect, lpDx);
	for (i = 0; i < cbLen; i++)
	{
		GetStringLeftRight(hMemDC, szBuff, i+1, x, &NextWordRect, lpDx);
		Nh16_AddToCharStruct(nLen + i, PrevWordRect.right, NextWordRect.right);
		CopyRect(&PrevWordRect, &NextWordRect);
	}
}