memview.cpp

wince host 和 target PCI驱动程序

						value |= (no << 4);
					}
					else
					{
						value &= 0xfffffff0;
						value |= no;
					}
			}
			HideCaret(hWnd);
			hDC=GetDC(hWnd);
		    SelectObject (hDC, hFont);
			SetTextColor (hDC, GetSysColor (COLOR_WINDOWTEXT));
			SetBkColor (hDC, GetSysColor (COLOR_WINDOW));
			TextOut(hDC,xCaret*xChar,yCaret*yChar,temp,1);
			if(globaldumptype == 0)	// BYTE
			{
				char str[2];
				MemToAscii((BYTE)value,str);
				TextOut(hDC,xChar*(61 + (xCaret-13)/3),yCaret*yChar,str,1);
			}
			else if(globaldumptype == 1)	// WORD
			{
				char str[3];
				MemToAscii((WORD)value,str);
				TextOut(hDC,xChar*(60 + 2*((xCaret-13)/5)),yCaret*yChar,str,2);
			}
			else if(globaldumptype == 2)	// DWORD
			{
				char str[5];
				MemToAscii((DWORD)value,str);
				TextOut(hDC,xChar*(60 + 4*((xCaret-13)/9)),yCaret*yChar,str,4);
			}
			ReleaseDC(hWnd,hDC);
			SendMessage(hWnd,WM_KEYDOWN,VK_RIGHT,0L);
			ShowCaret(hWnd);
			}
		}
		break;
	case WM_DESTROY:
	    {
	    LPMEMVIEW	 lpmv;

		hexWindow=FALSE;

	    /* free virtual memory block  and local memory buffer */
	    VirtualFree (pmv->lpMem, 0, MEM_RELEASE);
	    LocalFree ((HANDLE)pmv);

	    /* remove any old view memory */
	    if ((lpmv = (LPMEMVIEW)GetWindowLong (hWnd, WXB_LPMEMVIEW)) != NULL)
		{
		VirtualFree (lpmv->lpMem, 0, MEM_RELEASE);
		LocalFree ((HANDLE)lpmv);
		}
	    }
        break;

	case WM_SETFOCUS:
    // Create a solid black caret. 
        CreateCaret(hWnd, (HBITMAP) NULL, 2, yChar); 
 
    // Adjust the caret position, in client coordinates. 
        SetCaretPos(xCaret*xChar, yCaret*yChar); 
 
    // Display the caret. 
        ShowCaret(hWnd); 
		break;
	case WM_KILLFOCUS:  
 
	// The window is losing the keyboard focus, so destroy the caret. 
		CheckMemUpdate();
 	    DestroyCaret(); 
		break; 
	case WM_COMMAND:
		switch(LOWORD(wParam))
		{
			case IDM_COPY:
				if(selectionStart != 0)
					CopyClipboard(pmv);	// Place selection in clipboard
	
				break;
		}
		break;
    default:
	    return (DefWindowProc(hWnd, uMsg, wParam, lParam));
        break;

	}
    return 0L;
}

void  WINAPI VScrollBytes (
    HWND	 hWnd,
    int 	 cmd,
    int 	 pos,
    LPMEMVIEW	 lpmv)
{
    int    nScrollInc;

	CheckMemUpdate();
    switch (cmd)
	{
        case SB_TOP:
	    nScrollInc = -lpmv->PosV;
            break ;

        case SB_BOTTOM:
	    nScrollInc = lpmv->RangeV - lpmv->PosV;
            break ;

        case SB_LINEUP:
            nScrollInc = -1;
            break;

        case SB_LINEDOWN:
            nScrollInc = 1;
            break;

        case SB_PAGEDOWN:
	    nScrollInc = max (1, lpmv->yWin/yChar);
            break;

        case SB_PAGEUP:
	    nScrollInc = min (-1, -(lpmv->yWin/yChar));
            break;
    
        case SB_THUMBPOSITION:
	    nScrollInc = pos - lpmv->PosV;
            break;

	case SB_THUMBTRACK:
	    nScrollInc = pos - lpmv->PosV;
            break;

        default:
            nScrollInc = 0;
	}
    if (nScrollInc > lpmv->RangeV-lpmv->PosV)
	nScrollInc = lpmv->RangeV-lpmv->PosV;

    if (nScrollInc < -lpmv->PosV)
	nScrollInc = -lpmv->PosV;

    if (nScrollInc)
	{
	lpmv->PosV += nScrollInc;

	if (ABS (nScrollInc) < lpmv->yWin/yChar)
	    ScrollWindow (hWnd, 0, -(yChar*nScrollInc), NULL, NULL);
	else
	    InvalidateRect (hWnd, NULL, TRUE);

	SetScrollPos (hWnd, SB_VERT, lpmv->PosV, TRUE);
	UpdateWindow(hWnd);
    SetCaretPos(xCaret*xChar, yCaret*yChar); 
	}
}



void  WINAPI KeyToScrollMsg (HWND hWnd,WPARAM    wParam)
{
    int       i, nKeys;
    static    struct
	{
        WORD wVirtKey;
        int  iMessage;
        WORD wRequest;
	}key2scroll [] = {
			 VK_HOME,  WM_VSCROLL, SB_TOP,	  VK_END,   WM_VSCROLL,
			 SB_BOTTOM, VK_PRIOR, WM_VSCROLL, SB_PAGEUP, VK_NEXT,
			 WM_VSCROLL, SB_PAGEDOWN, VK_UP,    WM_VSCROLL, SB_LINEUP,
			 VK_DOWN,  WM_VSCROLL, SB_LINEDOWN, VK_LEFT,  WM_HSCROLL,
			 SB_LINEUP, VK_RIGHT, WM_HSCROLL, SB_LINEDOWN,
			 };

    nKeys = sizeof key2scroll / sizeof key2scroll[0];

    for (i=0; i<nKeys; i++)
	{
        if (wParam == key2scroll[i].wVirtKey)   
	    {
			SendMessage (hWnd, key2scroll[i].iMessage, key2scroll[i].wRequest, 0L);
            return;
	    }
	}
}



void  WINAPI DisplayBytes (
    HDC 	 hDC,
    RECT	 *pRect,
    LPMEMVIEW	 lpmv)
{
    UINT      i, iFirst, iLast, y;
    char      szBuf[MAX_PATH];
    LPBYTE    pMem = (LPBYTE)lpmv->lpMem;
	PVOID	startSel,endSel; 

    SelectObject (hDC, hFont);

    y = lpmv->PosV;

    iFirst = y + pRect->top/yChar-1;

    if (iFirst == 0xFFFFFFFFL)
	iFirst = 0;

    iLast = min (y + pRect->bottom/yChar+1, (UINT)lpmv->nLines-1);
    pMem += iFirst << 4;

    if (lpmv->nExtraBytes)
	{
		if(iLast != 0)
			iLast--;
	}

    /* paint complete lines (lines with 16 bytes) */
    y = (iFirst - y) * yChar;
	if(lpmv->nSize >= 16)
    for (i = iFirst; i<=iLast; i++)				// ?????? Originally < only
	{
	GetBytesLine (pMem, i, lpmv->nBase, 16, szBuf);
	if(selectionStart == 0)
	{
		SetTextColor (hDC, GetSysColor(COLOR_WINDOWTEXT));
		SetBkColor(hDC,GetSysColor(COLOR_WINDOW));
	}
	else		// Text selected
	{
		startSel=min(selectionStart,selectionEnd);
		endSel=max(selectionStart,selectionEnd);
		if(pMem >= startSel && pMem <= endSel)
		{
			SetTextColor(hDC,GetSysColor (COLOR_WINDOW));
			SetBkColor(hDC,GetSysColor(COLOR_WINDOWTEXT));
		}
		else
		{
			SetTextColor (hDC, GetSysColor(COLOR_WINDOWTEXT));
			SetBkColor(hDC,GetSysColor(COLOR_WINDOW));
		}
	}
	TextOut (hDC, xChar, LOWORD (y), szBuf, lstrlen (szBuf));
	pMem += 16;
	y += yChar;
	}

    /* paint last partial line if any (line with less than 16 bytes) */
    if (lpmv->nExtraBytes)
	{
	GetBytesLine (pMem, i, lpmv->nBase, lpmv->nExtraBytes, szBuf);
	SetTextColor (hDC, GetSysColor(COLOR_WINDOWTEXT));
	TextOut(hDC, xChar, y, szBuf, lstrlen (szBuf));
	}

    SelectObject(hDC, GetStockObject(SYSTEM_FONT));
}





void  WINAPI GetBytesLine (
    PVOID   pMemory,
    UINT     LineNum,
    DWORD    dwBase,
    int      nBytes,
    char     *szLine)
{
    int 	     j;
    unsigned char    ch;
	WORD ch2;
	DWORD ch4;
	
    char	     szAscii[17]="";
	PBYTE pBytes=(PBYTE)pMemory;
	PWORD pWord=(PWORD)pMemory;
	PDWORD pDWord=(PDWORD)pMemory;

    wsprintf (szLine, "%#08lx  ", dwBase + (LineNum*16));

	if(globaldumptype == 0)		//Byte
    for (j = 0; j < nBytes; j++)
	{
	ch = *pBytes++;
	MemToAscii(ch,szAscii+j);
	wsprintf (szLine, "%s%02X ", (LPSTR)szLine, (WORD)ch);
	}

	if(globaldumptype == 1)			//Word
    for (j = 0; j < nBytes;j+=2)
	{
		ch2 = *pWord++;
		MemToAscii(ch2,szAscii+j);
		wsprintf (szLine, "%s%04X ", (LPSTR)szLine, (WORD)ch2);
	}

	if(globaldumptype == 2)				//Dword
    for (j = 0; j < nBytes;j+=4)
	{
		ch4 = *pDWord++;
		MemToAscii(ch4,szAscii+j);
		wsprintf (szLine, "%s%08X ", (LPSTR)szLine, (DWORD)ch4);
	}

    szAscii[nBytes] = 0;
    wsprintf(szLine, "%-59s%s", (LPSTR)szLine, (LPSTR)szAscii);
}

void CheckMemUpdate(void)
{
	if(mem != 0)
	{
		if(globaldumptype == 0)
			*(PBYTE)mem=value;
		else if (globaldumptype == 1)
			*(PWORD)mem=value;
		else
			*(PDWORD)mem=value;
		mem=0;
		InvalidateRect (hWnd, NULL, FALSE);
	}
}

void ProcessKey(HWND hWnd,WPARAM wParam,MEMVIEW *pmv)
{
	switch(wParam)
	{
				case VK_DOWN:
					CheckMemUpdate();
					if((yCaret+1) < pmv->yWin/yChar)
					{
						if((yCaret+1) < pmv->nLines)
							yCaret++;
					}
					else
						SendMessage(hWnd,WM_VSCROLL, SB_LINEDOWN,0L);
			        SetCaretPos(xCaret*xChar,yCaret*yChar);
					break;
				case VK_UP:
					CheckMemUpdate();
					if(yCaret != 0)
						yCaret--;
					else
					{
						if(pmv->PosV != 0)
						SendMessage(hWnd,WM_VSCROLL, SB_LINEUP,0L);
					}
			        SetCaretPos(xCaret*xChar,yCaret*yChar);
					break;
				case VK_RIGHT:
					if(globaldumptype == 0)
					{
						if(xCaret-13 < 15*3+1)
						{
							if(((xCaret-13+2) % 3) == 0)
							{
								CheckMemUpdate();
								xCaret+=2;
							}
							else
								xCaret++;
						}
					}
					else if (globaldumptype == 1)
					{
						if(xCaret-13 < 7*5+3)
						{
							if(((xCaret-13+2) % 5) == 0)
							{
								CheckMemUpdate();
								xCaret+=2;
							}
							else
								xCaret++;
						}
					}
					else
					{
						if(xCaret-13 < 3*9+7)
						{
							if(((xCaret-13+2) % 9) == 0)
							{
								CheckMemUpdate();
								xCaret+=2;
							}
							else
								xCaret++;
						}
					}
			        SetCaretPos(xCaret*xChar,yCaret*yChar);
					break;
				case VK_LEFT:
					if(xCaret == 13)
						break;
					if(globaldumptype == 0)
					{
						if(((xCaret-13)%3) == 0)
						{
							CheckMemUpdate();
							xCaret-=2;
						}
						else
							xCaret--;
					}
					else if (globaldumptype == 1)
					{
						if(((xCaret-13)%5) == 0)
						{
							CheckMemUpdate();
							xCaret-=2;
						}
						else
							xCaret--;
					}
					else
					{
						if(((xCaret-13)%9) == 0)
						{
							CheckMemUpdate();
							xCaret-=2;
						}
						else
							xCaret--;
					}
			        SetCaretPos(xCaret*xChar,yCaret*yChar);
					break;
				case VK_HOME:
					CheckMemUpdate();
					if(GetKeyState(VK_CONTROL) < 0)		//Ctrl pressed
						SendMessage(hWnd,WM_VSCROLL, SB_TOP,NULL);
					else
					{
						xCaret=13;
				        SetCaretPos(xCaret*xChar,yCaret*yChar);
					}
					break;
				case VK_END:
					CheckMemUpdate();
					if(GetKeyState(VK_CONTROL) < 0)		//Ctrl pressed
						SendMessage(hWnd,WM_VSCROLL, SB_BOTTOM,NULL);
					else
					{
						if(globaldumptype == 0)
							xCaret=13+15*3;
						else if(globaldumptype == 1)
							xCaret=13+7*5;
						else
							xCaret=13+3*9;
				        SetCaretPos(xCaret*xChar,yCaret*yChar);
					}
					break;

				default:

				    KeyToScrollMsg (hWnd, wParam);
					break;
			}
}

void CopyClipboard(MEMVIEW *pmv)
{
	PBYTE	startSel,endSel,pMem; 
	HGLOBAL hCopyBuffer;
	PSTR pCopyBuffer;
	UINT LineNum;
	char szLine[100];

	startSel=(PBYTE)min(selectionStart,selectionEnd);
	endSel=(PBYTE)max(selectionStart,selectionEnd);
	LineNum=(startSel-pmv->lpMem)/16;
	

		hCopyBuffer=GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE,
			( (endSel-startSel)/16+1)*100) ;
		pCopyBuffer=(PSTR)GlobalLock(hCopyBuffer);
		*pCopyBuffer=0;
		for(pMem=startSel;pMem<=endSel;pMem+=16,LineNum++)
		{
			GetBytesLine(pMem,LineNum,pmv->nBase,16,szLine);
			strcat(pCopyBuffer,szLine);
			strcat(pCopyBuffer,"\r\n");
		}
		OpenClipboard(hWnd);
		EmptyClipboard();
		SetClipboardData(CF_TEXT,hCopyBuffer);
		CloseClipboard();
		GlobalUnlock(hCopyBuffer);
		GlobalFree(hCopyBuffer);
}

void MemToAscii(BYTE number,char* str)
{
	str[0]=((number & 0x7F) >= ' ') ? number : '.';
	str[1]=0;
	return;
}

void MemToAscii(WORD number,char* szAscii)
{
	BYTE ch;
	PBYTE pBytes;
	pBytes=(PBYTE)&number;

	ch=pBytes[0];
    szAscii[0] = ((ch & 0x7F) >= ' ') ? ch : '.';
	ch=pBytes[1];
    szAscii[1] = ((ch & 0x7F) >= ' ') ? ch : '.';
	szAscii[2]=0;
}

void MemToAscii(DWORD number,char* szAscii)
{
	BYTE ch;
	PBYTE pBytes;
	pBytes=(PBYTE)&number;

	ch=pBytes[0];
    szAscii[0] = ((ch & 0x7F) >= ' ') ? ch : '.';
	ch=pBytes[1];
    szAscii[1] = ((ch & 0x7F) >= ' ') ? ch : '.';
	ch=pBytes[2];
    szAscii[2] = ((ch & 0x7F) >= ' ') ? ch : '.';
	ch=pBytes[3];
    szAscii[3] = ((ch & 0x7F) >= ' ') ? ch : '.';
	szAscii[4]=0;
}