memview.cpp

PNX系列设备驱动 PNX系列设备驱动

                else if (yPos < 0) 
                    SendMessage(hWnd,WM_KEYDOWN, VK_UP,0L);
                else
                {
                    yCaret=yPos;
                    if(xPos < 13)
                        xCaret=13;
                    else if(globaldumptype == 0)        // Byte
                    {
                        if(xPos-13 > 15*3+1)
                            xCaret=13+15*3+1;
                        else
                        {
                            if(((xPos-13+1)%3) == 0)
                                xCaret=xPos+1;
                            else
                                xCaret=xPos;
                        }
                    }
                    else if(globaldumptype == 1)        // Word
                    {
                        if(xPos-13 > 7*5+3)
                            xCaret=13+7*5+3;
                        else
                        {
                            if(((xPos-13+1)%5) == 0)
                                xCaret=xPos+1;
                            else
                                xCaret=xPos;
                        }
                    }
                    else                                // Dword
                    {
                        if(xPos-13 > 3*9+7)
                            xCaret=13+3*9+7;
                        else
                        {
                            if(((xPos-13+1)%9) == 0)
                                xCaret=xPos+1;
                            else
                                xCaret=xPos;
                        }
                    }
                    CheckMemUpdate();
                    SetCaretPos(xCaret*xChar,yCaret*yChar);
                }
                selectionEnd=((PBYTE)(pmv->lpMem)+16*(yCaret+pmv->PosV));
            }
            InvalidateRect (hWnd, NULL, FALSE);
        }
        break;

    case WM_VSCROLL:
        VScrollBytes (hWnd, LOWORD (wParam),HIWORD(wParam) /* GetScrollPos (hWnd, SB_VERT) */, pmv);
        break;

    case WM_CHAR:
            {
            char temp[2];
            char x;
            unsigned int no,pos;
            HDC hDC;
            x=toupper(wParam);
            if (x==3)       // Ctrl-C
            {
                SendMessage(hWnd,WM_COMMAND,IDM_COPY,0);
                break;
            }
            else if (x==1)       // Ctrl-A
            {
                SendMessage(hWnd,WM_COMMAND,IDM_SELECT_ALL,0);
                break;
            }
            else if (x==13) // CR
            {
                CheckMemUpdate();
                break;
            }
            if(isdigit(x) || (x >= 'A' && x <= 'F'))
            {
            temp[0]=wParam;
            temp[1]=0;
            sscanf(temp,"%x",&no);

            if(mem == 0)            // If no pointer already
            {
                if(globaldumptype == 0)         // BYTE
                {
                    mem=((PBYTE)(pmv->lpMem)+16*(yCaret+pmv->PosV)+(xCaret-13)/3);
                    value=*(PBYTE)mem;
                }
                else if(globaldumptype == 1)    // WORD
                {
                    mem=((PWORD)(pmv->lpMem)+8*(yCaret+pmv->PosV)+(xCaret-13)/5);
                    value=*(PWORD)mem;
                }

                else if(globaldumptype == 2)    // DWORD
                {
                    mem=((PDWORD)(pmv->lpMem) + 4*(yCaret+pmv->PosV) + (xCaret-13)/9);
                    value=*(PDWORD)mem;
                }
            }
            if(globaldumptype == 0)         // BYTE
            {
                    pos=(xCaret-13)%3;
                    if(pos==0)
                    {
                        value &= 0x0f;
                        value |= (no <<4);
                    }
                    if(pos==1)
                    {
                        value &= 0xf0;
                        value |= no;
                    }
            }
            else if(globaldumptype == 1)    // WORD
            {
                    pos=(xCaret-13)%5;
                    if(pos==0)
                    {
                        value &= 0x0fff;
                        value |= (no << 12);
                    }
                    if(pos==1)
                    {
                        value &= 0xf0ff;
                        value |= (no << 8);
                    }
                    if(pos==2)
                    {
                        value &= 0xff0f;
                        value |= (no << 4);
                    }
                    if(pos==3)
                    {
                        value &= 0xfff0;
                        value |= no;
                    }
            }
            else if(globaldumptype == 2)    // DWORD
            {
                    pos=(xCaret-13)%9;
                    if(pos == 0)
                    {
                        value &= 0x0fffffff;
                        value |= (no << 28);
                    }
                    else if(pos == 1)
                    {
                        value &= 0xf0ffffff;
                        value |= (no << 24);
                    }
                    else if(pos == 2)
                    {
                        value &= 0xff0fffff;
                        value |= (no << 20);
                    }
                    else if(pos == 3)
                    {
                        value &= 0xfff0ffff;
                        value |= (no << 16);
                    }
                    else if(pos == 4)
                    {
                        value &= 0xffff0fff;
                        value |= (no << 12);
                    }
                    else if(pos == 5)
                    {
                        value &= 0xfffff0ff;
                        value |= (no << 8);
                    }
                    else if(pos == 6)
                    {
                        value &= 0xffffff0f;
                        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;
            case IDM_SELECT_ALL:
                selectionStart = pmv->lpMem;
                selectionEnd = (BYTE *)pmv->lpMem + pmv->nSize - 16;
                selectionComplete=TRUE;
                InvalidateRect (hWnd, NULL, FALSE);
                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;