Додаток А

#include <windows.h>

#include <Windowsx.h>

#include <stdio.h>

#include "KWnd.h"

#include "KDocument.h"

#include "resource.h"

#include "h1.h"

#include <fstream>

HINSTANCE hInst;

KDocument doc;

HWND hWnd;

HWND hAnd;

HANDLE hTar;

HWND Button1,Button2,Button3;

#define BUTTON_ID1 123

#define BUTTON_ID2 124

#define BUTTON_ID3 125

static DWORD dwAddrSpace = ACTIVE_ADDR_SPACE_NEEDS_INIT;

/*char * zs = new char[20];*/

WDC_ADDR_RW_OPTIONS options = WDC_ADDR_RW_DEFAULT;

char zs[256];

int current = 0;

WDC_DEVICE_HANDLE *phDev = new WDC_DEVICE_HANDLE(0);

int ssize;

int x;

static BOOL fBlock = FALSE;

static WDC_ADDR_MODE mode = WDC_MODE_32;

HRGN hRg0;

HRGN hRg1;

HRGN hRg2;

HRGN hRg3;

RECT rect0 = {50, 200, 100, 250};

RECT rect1 = {50, 300, 100, 350};

RECT rect2 = {50, 400, 100, 450};

RECT rect3 = {50, 500, 100, 550};

int scan = 0;

int opn = 0;

int ext = 0;

int dev = 0;

FILE * sa;

char * rrr;

char *lpBuf = new char[20];

char * code = "1.txt";

int ncm;

unsigned Convert(char * s, int n);

ifstream fin;

ifstream brin;

ifstream tin;

ifstream rin;

ifstream resread;

ofstream reswrite;

char * vid = new char[11];

char * did = new char[11];

char * line = new char[80];

char * pine = new char[80];

char * byt = new char[11];

char * nums = new char[11];

char * offs = new char[11];

int ivid = 0;

int idid = 0;

char * xx = "0x";

char buf[10];

DWORD dwStatus;

DWORD dwOffset, dwBytes, BlockNum;

PVOID pBuf = NULL;

BYTE bData = 0;

WORD wData = 0;

UINT32 u32Data = 0;

UINT64 u64Data = 0;

BOOL fAutoInc;

char * read = new char[400];

char * write = new char[400];

BOOL CALLBACK AboutDlgProc(HWND, UINT, WPARAM, LPARAM);

BOOL CALLBACK DevDlgProc(HWND, UINT, WPARAM, LPARAM);

BOOL CALLBACK OpenDlgProc(HWND, UINT, WPARAM, LPARAM);

BOOL CALLBACK MemDlgProc(HWND, UINT, WPARAM, LPARAM);

BOOL CALLBACK RegDlgProc(HWND, UINT, WPARAM, LPARAM);

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

DWORD WINAPI fA(LPVOID a);

LRESULT CALLBACK AndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow){

MSG msg;

hInst = hInstance;

WNDCLASSEX wc;

hRg0 = CreateEllipticRgn(50, 200, 100, 250);

hRg1 = CreateEllipticRgn(50, 300, 100, 350);

hRg2 = CreateEllipticRgn(50, 400, 100, 450);

hRg3 = CreateEllipticRgn(50, 500, 100, 550);

WDC_DEVICE_HANDLE hDev = NULL;

DWORD dwStatus;

dwStatus = KR_LibInit();

char szClassName[] = "KWndClass";

wc.cbSize = sizeof(wc);

wc.style = CS_HREDRAW|CS_VREDRAW;

wc.lpfnWndProc = WndProc;

wc.cbClsExtra = 0;

wc.cbWndExtra = 0;

wc.hInstance = hInstance;

wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);

wc.hCursor = LoadCursor(NULL, IDC_ARROW);

wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);

wc.lpszMenuName =MAKEINTRESOURCE(IDR_MENU1);

wc.lpszClassName = szClassName;

wc.hIconSm = LoadIcon(NULL, IDI_APPLICATION);

if (!RegisterClassEx(&wc)) {

char msg[100] = "Cannot register class: ";

strcat(msg, szClassName);

MessageBox(NULL, msg, "Error", MB_OK);

return 0;

} hWnd = CreateWindow(szClassName, "Driver", WS_OVERLAPPEDWINDOW,

200, 100, 550, 650, NULL, (HMENU)NULL, hInstance, NULL);

if (!hWnd) {

char text[100] = "Cannot create window: ";

strcat(text, "Driver");

MessageBox(NULL, text, "Error", MB_OK);

return 0;

}ShowWindow(hWnd, nCmdShow);

while (GetMessage(&msg, NULL, 0, 0)) {

TranslateMessage(&msg);

DispatchMessage(&msg);

}return msg.wParam;

}

LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)

{

HDC hCompatibleDC, hDc;

HBITMAP hBitmap, hOldBitmap, hBp;

RECT rect;

BITMAP Bitmap;

static HFONT Font;

HFONT hOldFont;

HPEN hPen;

static int x = 0;

static int y = 0;

static HINSTANCE hInst;

HDC hDC;

PAINTSTRUCT ps;

static HMENU hMenu; // дескриптор главного меню

static HBRUSH hBrush, hOldBrush;

switch (uMsg){

case WM_CREATE:

hInst = GetModuleHandle(NULL);

hMenu = GetMenu(hWnd);

SetMenuDefaultItem(GetSubMenu(hMenu, 0), IDM_OPEN, FALSE);

break;

case WM_LBUTTONDOWN :

x = LOWORD(lParam);

y = HIWORD(lParam);

if (PtInRegion(hRg0, x, y)) {

dev = 2;

InvalidateRect(hWnd, &rect0, FALSE);

} else if (PtInRegion(hRg1, x, y)) {

opn = 2;

InvalidateRect(hWnd, &rect1, FALSE);

} else if (PtInRegion(hRg2, x, y)) {

scan = 2;

InvalidateRect(hWnd, &rect2, FALSE);

} else if (PtInRegion(hRg3, x, y)){

ext = 2;

InvalidateRect(hWnd, &rect3, FALSE);

} break;

break;

case WM_LBUTTONUP :

x = LOWORD(lParam);

y = HIWORD(lParam);

if (PtInRegion(hRg0, x, y)) {

dev = 0;

InvalidateRect(hWnd, &rect0, FALSE);

DialogBox(hInst, MAKEINTRESOURCE(IDD_DIALOG7), hWnd, DevDlgProc);

} else if (PtInRegion(hRg1, x, y)) {

opn = 0;

InvalidateRect(hWnd, &rect1, FALSE);

DialogBox(hInst, MAKEINTRESOURCE(IDD_DIALOG1), hWnd, OpenDlgProc);

} else if (PtInRegion(hRg2, x, y)) {

scan = 0;

InvalidateRect(hWnd, &rect2, FALSE);

WDC_DIAG_PciDevicesInfoPrintAll(FALSE);

hTar = CreateThread(NULL, 0, fA, 0, 0, 0);

} else if (PtInRegion(hRg3, x, y)) {

ext = 0;

InvalidateRect(hWnd, &rect3, FALSE);

SendMessage(hWnd, WM_DESTROY, 0, 0);

}break;

case WM_COMMAND:

switch (LOWORD(wParam))

{case IDM_DEV :

DialogBox(hInst, MAKEINTRESOURCE(IDD_DIALOG7), hWnd, DevDlgProc);

break;

case BUTTON_ID2:

case IDM_SCAN:

WDC_DIAG_PciDevicesInfoPrintAll(FALSE);

hTar = CreateThread(NULL, 0, fA, 0, 0, 0);

break;

case BUTTON_ID3:

case IDM_OPEN:

DialogBox(hInst, MAKEINTRESOURCE(IDD_DIALOG1), hWnd, OpenDlgProc);

break;

case BUTTON_ID1:

case IDM_EXIT: SendMessage(hWnd, WM_DESTROY, 0, 0);

break;

case IDM_ABOUT:DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUT), hWnd, AboutDlgProc);

break;

default: break;

}InvalidateRect(hWnd, NULL, TRUE);

break;

case WM_PAINT:

GetClientRect(hWnd, &rect);

hDC = BeginPaint(hWnd, &ps);

hCompatibleDC = CreateCompatibleDC(hDC);

hBrush = (HBRUSH) GetStockObject(BLACK_BRUSH);

PatBlt(hCompatibleDC, 0, 0, rect.right, rect.bottom, PATCOPY);

SetBkMode(hDC, TRANSPARENT);

Font = CreateFont(40, 20, 0, 0, 100, 0, 0, 0, 0, 0, 0, ANTIALIASED_QUALITY, 2, 0);

hOldFont = (HFONT)SelectObject(hDC, Font);

SetTextColor(hDC, RGB(255, 0, 200));

hBitmap = (HBITMAP)LoadImage(NULL, "12.bmp", IMAGE_BITMAP,

1100, 820, LR_LOADFROMFILE);

GetObject(hBitmap, sizeof(BITMAP), &Bitmap);

hCompatibleDC = CreateCompatibleDC(hDC);

hOldBitmap = (HBITMAP)SelectObject(hCompatibleDC, hBitmap);

GetClientRect(hWnd, &rect);

SelectObject(hDC, hBrush);

StretchBlt(hDC, 0, 0, rect.right, rect.bottom, hCompatibleDC, 0, 0,

Bitmap.bmWidth, Bitmap.bmHeight, SRCCOPY);

SelectObject(hCompatibleDC, hOldBitmap);

DeleteObject(hBitmap);

TextOut(hDC, 60, 40, " KR diagnostic utility", 22);

SelectObject(hCompatibleDC, hOldFont);

Font = CreateFont(30, 14, 0, 0, 80, 0, 0, 0, 0, 0, 0, ANTIALIASED_QUALITY, 2, 0);

hOldFont = (HFONT)SelectObject(hDC, Font);

SetTextColor(hDC, RGB(0, 0, 255));

TextOut(hDC, 60, 100, " Application accesses hardware ", 30);

TextOut(hDC, 135, 130, " using WinDriwer ",17);

if (dev == 0) {

hPen = CreatePen(PS_NULL, 3, RGB(150, 70, 150));

SelectObject(hDC, hPen);

hBrush = CreateSolidBrush(RGB(230, 100, 230));

SelectObject(hDC, hBrush);

Ellipse(hDC, 50, 200, 100, 250);

DeleteObject(hBrush);

hBrush = CreateSolidBrush(RGB(220, 30, 220));

SelectObject(hDC, hBrush);

Ellipse(hDC, 51, 201, 99, 249);

DeleteObject(hBrush);

hBrush = CreateSolidBrush(RGB(225, 80, 200));

SelectObject(hDC, hBrush);

Ellipse(hDC, 55, 205, 95, 245);

DeleteObject(hBrush);

hBrush = CreateSolidBrush(RGB(245, 100, 245));

SelectObject(hDC, hBrush);

Ellipse(hDC, 57, 207, 93, 243);

DeleteObject(hBrush);

hBp = (HBITMAP)LoadImage(NULL, "88.bmp", IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);

hBrush = CreatePatternBrush(hBp);

SelectObject(hDC, hBrush);

Ellipse(hDC, 57, 207, 93, 243);

DeleteObject(hBrush);

SetTextColor(hDC, RGB(240, 130, 255));

TextOut(hDC, 120, 210, "Device driver", 13);

}else {

hPen = CreatePen(PS_NULL, 3, RGB(150, 70, 150));

SelectObject(hDC, hPen);

hBrush = CreateSolidBrush(RGB(0, 0, 0));

SelectObject(hDC, hBrush);

Ellipse(hDC, 50, 200, 100, 250);

DeleteObject(hBrush);

hBrush = CreateSolidBrush(RGB(180, 0, 150));

SelectObject(hDC, hBrush);

Ellipse(hDC, 51, 201, 99, 249);

DeleteObject(hBrush);

hBrush = CreateSolidBrush(RGB(220, 0, 180));

SelectObject(hDC, hBrush);

Ellipse(hDC, 55, 205, 95, 245);

DeleteObject(hBrush);

hBrush = CreateSolidBrush(RGB(255, 50, 220));

SelectObject(hDC, hBrush);

Ellipse(hDC, 57, 207, 93, 243);

DeleteObject(hBrush);

HBITMAP hBp = (HBITMAP)LoadImage(NULL, "66.bmp", IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);

hBrush = CreatePatternBrush(hBp);

SelectObject(hDC, hBrush);

Ellipse(hDC, 57, 207, 93, 243);

DeleteObject(hBrush);

SetTextColor(hDC, RGB(240, 130, 255));

TextOut(hDC, 120, 210, "Device driver", 13);

} if (opn == 0){ hPen = CreatePen(PS_NULL, 3, RGB(150, 70, 150));

SelectObject(hDC, hPen);

hBrush = CreateSolidBrush(RGB(230, 100, 230));

SelectObject(hDC, hBrush);

Ellipse(hDC, 50, 300, 100, 350);

DeleteObject(hBrush);

hBrush = CreateSolidBrush(RGB(220, 30, 220));

SelectObject(hDC, hBrush);

Ellipse(hDC, 51, 301, 99, 349);

DeleteObject(hBrush);

hBrush = CreateSolidBrush(RGB(225, 80, 200));

SelectObject(hDC, hBrush);

Ellipse(hDC, 55, 305, 95, 345);

DeleteObject(hBrush);

hBrush = CreateSolidBrush(RGB(245, 100, 245));

SelectObject(hDC, hBrush);

Ellipse(hDC, 57, 307, 93, 343);

DeleteObject(hBrush);

hBp = (HBITMAP)LoadImage(NULL, "88.bmp", IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);

hBrush = CreatePatternBrush(hBp);

SelectObject(hDC, hBrush);

Ellipse(hDC, 57, 307, 93, 343);

DeleteObject(hBrush);

SetTextColor(hDC, RGB(240, 130, 255));

TextOut(hDC, 120, 310, "Open KR device", 14);

} else {

hPen = CreatePen(PS_NULL, 3, RGB(150, 70, 150));

SelectObject(hDC, hPen);

hBrush = CreateSolidBrush(RGB(0, 0, 0));

SelectObject(hDC, hBrush);

Ellipse(hDC, 50, 300, 100, 350);

DeleteObject(hBrush);

hBrush = CreateSolidBrush(RGB(180, 0, 150));

SelectObject(hDC, hBrush);

Ellipse(hDC, 51, 301, 99, 349);

DeleteObject(hBrush);

hBrush = CreateSolidBrush(RGB(220, 0, 180));

SelectObject(hDC, hBrush);

Ellipse(hDC, 55, 305, 95, 345);

DeleteObject(hBrush);

hBrush = CreateSolidBrush(RGB(255, 50, 220));

SelectObject(hDC, hBrush);

Ellipse(hDC, 57, 307, 93, 343);

DeleteObject(hBrush);

HBITMAP hBp = (HBITMAP)LoadImage(NULL, "66.bmp", IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);

hBrush = CreatePatternBrush(hBp);

SelectObject(hDC, hBrush);

Ellipse(hDC, 57, 307, 93, 343);

DeleteObject(hBrush);

SetTextColor(hDC, RGB(240, 130, 255));

TextOut(hDC, 120, 310, "Open KR device", 14);

} if (scan == 0) {

hPen = CreatePen(PS_NULL, 3, RGB(150, 70, 150));

SelectObject(hDC, hPen);

hBrush = CreateSolidBrush(RGB(230, 100, 230));

SelectObject(hDC, hBrush);

Ellipse(hDC, 50, 400, 100, 450);

DeleteObject(hBrush);

hBrush = CreateSolidBrush(RGB(220, 30, 220));

SelectObject(hDC, hBrush);

Ellipse(hDC, 51, 401, 99, 449);

DeleteObject(hBrush);

hBrush = CreateSolidBrush(RGB(225, 80, 200));

SelectObject(hDC, hBrush);

Ellipse(hDC, 55, 405, 95, 445);

DeleteObject(hBrush);

hBrush = CreateSolidBrush(RGB(245, 100, 245));

SelectObject(hDC, hBrush);

Ellipse(hDC, 57, 407, 93, 443);

DeleteObject(hBrush);

hBp = (HBITMAP)LoadImage(NULL, "88.bmp", IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);

hBrush = CreatePatternBrush(hBp);

SelectObject(hDC, hBrush);

Ellipse(hDC, 57, 407, 93, 443);

DeleteObject(hBrush);

SetTextColor(hDC, RGB(240, 130, 255));

TextOut(hDC, 120, 410, "Scan PCI bus", 12);

}else {

hPen = CreatePen(PS_NULL, 3, RGB(150, 70, 150));

SelectObject(hDC, hPen);

hBrush = CreateSolidBrush(RGB(0, 0, 0));

SelectObject(hDC, hBrush);

Ellipse(hDC, 50, 400, 100, 450);

DeleteObject(hBrush);

hBrush = CreateSolidBrush(RGB(180, 0, 150));

SelectObject(hDC, hBrush);

Ellipse(hDC, 51, 401, 99, 449);

DeleteObject(hBrush);

hBrush = CreateSolidBrush(RGB(220, 0, 180));

SelectObject(hDC, hBrush);

Ellipse(hDC, 55, 405, 95, 445);

DeleteObject(hBrush);

hBrush = CreateSolidBrush(RGB(255, 50, 220));

SelectObject(hDC, hBrush);

Ellipse(hDC, 57, 407, 93, 443);

DeleteObject(hBrush);

HBITMAP hBp = (HBITMAP)LoadImage(NULL, "66.bmp", IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);

hBrush = CreatePatternBrush(hBp);

SelectObject(hDC, hBrush);

Ellipse(hDC, 57, 407, 93, 443);

DeleteObject(hBrush);

SetTextColor(hDC, RGB(240, 130, 255));

TextOut(hDC, 120, 410, "Scan PCI bus", 12);

} if (ext == 0) { hPen = CreatePen(PS_NULL, 3, RGB(150, 70, 150));

SelectObject(hDC, hPen);

hBrush = CreateSolidBrush(RGB(230, 100, 230));

SelectObject(hDC, hBrush);

Ellipse(hDC, 50, 500, 100, 550);

DeleteObject(hBrush);

hBrush = CreateSolidBrush(RGB(220, 30, 220));

SelectObject(hDC, hBrush);

Ellipse(hDC, 51, 501, 99, 549);

DeleteObject(hBrush);

hBrush = CreateSolidBrush(RGB(225, 80, 200));

SelectObject(hDC, hBrush);

Ellipse(hDC, 55, 505, 95, 545);

DeleteObject(hBrush);

hBrush = CreateSolidBrush(RGB(245, 100, 245));

SelectObject(hDC, hBrush);

Ellipse(hDC, 57, 507, 93, 543);

DeleteObject(hBrush);

hBp = (HBITMAP)LoadImage(NULL, "88.bmp", IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);

hBrush = CreatePatternBrush(hBp);

SelectObject(hDC, hBrush);

Ellipse(hDC, 57, 507, 93, 543);

DeleteObject(hBrush);

SetTextColor(hDC, RGB(240, 130, 255));

TextOut(hDC, 120, 510, "EXIT", 4);

} else {

SelectObject(hDC, hPen);

hBrush = CreateSolidBrush(RGB(0, 0, 0));

SelectObject(hDC, hBrush);

Ellipse(hDC, 50, 500, 100, 550);

DeleteObject(hBrush);

hBrush = CreateSolidBrush(RGB(180, 0, 150));

SelectObject(hDC, hBrush);

Ellipse(hDC, 51, 501, 99, 549);

DeleteObject(hBrush);

hBrush = CreateSolidBrush(RGB(220, 0, 180));

SelectObject(hDC, hBrush);

Ellipse(hDC, 55, 505, 95, 545);

DeleteObject(hBrush);

hBrush = CreateSolidBrush(RGB(255, 50, 220));

SelectObject(hDC, hBrush);

Ellipse(hDC, 57, 507, 93, 543);

DeleteObject(hBrush);

HBITMAP hBp = (HBITMAP)LoadImage(NULL, "66.bmp", IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);

hBrush = CreatePatternBrush(hBp);

SelectObject(hDC, hBrush);

Ellipse(hDC, 57, 507, 93, 543);

DeleteObject(hBrush);

SetTextColor(hDC, RGB(240, 130, 255));

TextOut(hDC, 120, 510, "EXIT", 4);

} DeleteDC(hCompatibleDC);

EndPaint(hWnd, &ps);

break;

case WM_DESTROY:

PostQuitMessage(0);

break;

default: return DefWindowProc(hWnd, uMsg, wParam, lParam);

}return 0;

}

BOOL CALLBACK AboutDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)

{

static HWND hStatic1;

static LOGFONT lf;

static HFONT hFont1;

switch (uMsg) {

case WM_INITDIALOG:

hStatic1 = GetDlgItem(hDlg, IDC_STATIC_1);

lf.lfHeight = 28;

lstrcpy( (LPSTR)&lf.lfFaceName, "Verdana" );

hFont1 = CreateFontIndirect(&lf);

SendMessage(hStatic1, WM_SETFONT, (WPARAM)hFont1, TRUE );

return TRUE;

case WM_COMMAND:

switch (LOWORD(wParam)) {

case IDOK:

case IDCANCEL:

DeleteObject(hFont1);

EndDialog(hDlg, 0);

return TRUE;

} break;

}return FALSE;

}

DWORD WINAPI fA(LPVOID a){

MSG msg;

if (!doc.Open(code))

return 0;

char * ClassName = "assm";

ncm = 1;

WNDCLASSEX wc;

wc.cbSize = sizeof(wc);

wc.style = CS_HREDRAW|CS_VREDRAW;

wc.lpfnWndProc = AndProc;

wc.cbClsExtra = 0;

wc.cbWndExtra = 0;

wc.hInstance = hInst;

wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);

wc.hCursor = LoadCursor(NULL, IDC_ARROW);

wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);

wc.lpszMenuName = NULL;

wc.lpszClassName = ClassName;

wc.hIconSm = LoadIcon(NULL, IDI_APPLICATION);

RegisterClassEx(&wc);

if (!hAnd){

char text[100] = "Cannot create window: ";

strcat(text, "Devices");

MessageBox(NULL, text, "Devices", MB_OK);

return 0;

}ShowWindow(hAnd, 1);

while (GetMessage(&msg, NULL, 0, 0)) {

TranslateMessage(&msg);

DispatchMessage(&msg);

}

return msg.wParam;

}

LRESULT CALLBACK AndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)

{

HDC hDC;

PAINTSTRUCT ps;

TEXTMETRIC tm;

static HFONT Font;

HFONT hOldFont;

RECT rect;

HBRUSH hBrush;

HPEN hPen;

int cxClient=0, cyClient=0;

static int xInc, yInc;

switch (uMsg)

{

case WM_CREATE:

hDC = GetDC(hWnd);

GetTextMetrics(hDC, &tm);

doc.Initialize(&tm);

ReleaseDC(hWnd, hDC);

break;

case WM_SIZE:

hDC = GetDC(hWnd);

cxClient = LOWORD(lParam);

cyClient = HIWORD(lParam);

if (cxClient > 0)

doc.ScrollSettings(hWnd, cxClient, cyClient);

ReleaseDC(hWnd, hDC);

break;

case WM_VSCROLL:

switch(LOWORD(wParam)) {

case SB_LINEUP:

yInc = -1;

break;

case SB_LINEDOWN:

yInc = 1;

break;

case SB_PAGEUP:

yInc = -(int)doc.vsi.nPage;

break;

case SB_PAGEDOWN:

yInc = (int)doc.vsi.nPage;

break;

case SB_THUMBTRACK:

yInc = HIWORD(wParam) - doc.vsi.nPos;

break;

default:yInc = 0;

}doc.UpdateVscroll(hWnd, yInc);

break;

case WM_HSCROLL:

switch(LOWORD(wParam)) {

case SB_LINELEFT:

xInc = -1;

break;

case SB_LINERIGHT:

xInc = 1;

break;

case SB_PAGELEFT:

xInc = -0.8 * (int)doc.hsi.nPage;

break;

case SB_PAGERIGHT:

xInc = 0.8 * (int)doc.hsi.nPage;

break;

case SB_THUMBTRACK:

xInc = HIWORD(wParam) - doc.hsi.nPos;

break;

default:

xInc = 0;

}doc.UpdateHscroll(hWnd, xInc);

break;

case WM_PAINT:

hDC = BeginPaint(hWnd, &ps);

GetClientRect(hWnd, &rect);

SetBkMode(hDC, TRANSPARENT);

Font = CreateFont(15, 8, 0, 0, 500, false, 0, 0, 0, 0, 0, ANTIALIASED_QUALITY, 1, 0);

hOldFont = (HFONT)SelectObject(hDC, Font);

SetTextColor(hDC, RGB(200, 0, 255));

doc.PutText(hWnd, hDC);

EndPaint(hWnd, &ps);

break;

case WM_DESTROY:

PostQuitMessage(0);

break;

default:

return DefWindowProc(hWnd, uMsg, wParam, lParam);

}return 0;

}

BOOL CALLBACK OpenDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)

{

static HWND hEdit1;

static HWND hEdit2;

static int reggi = 0;

static HWND hStatic1;

static HWND hStatic2;

static LOGFONT lf;

static HFONT hFont1;

BOOL fRegister;

switch (uMsg) {

case WM_INITDIALOG:

case WM_COMMAND:

switch (LOWORD(wParam)) {

case IDC_OPEN1 :

SendDlgItemMessage(hDlg,IDC_EDIT1,WM_GETTEXT, 10, (LPARAM)vid);

SendDlgItemMessage(hDlg,IDC_EDIT2,WM_GETTEXT, 10, (LPARAM)did);

ivid = Convert(vid, strlen(vid));

idid = Convert(did, strlen(did));

if (!ivid || ! idid) {

if (!ivid) MessageBox(hDlg, " Vendor ID is needed.", "WARNING", MB_OK);

if (!idid) MessageBox(hDlg, " Device ID is needed.", "WARNING", MB_OK);

}else {

SendDlgItemMessage(hDlg, IDC_LIST2, LB_RESETCONTENT, 0, 0);

if (*phDev)

DeviceClose(*phDev);

*phDev = DeviceFindAndOpen(ivid, idid);

fin.open("device.txt");

while (!fin.eof()) {

fin.getline(line, 80);

SendDlgItemMessage(hDlg, IDC_LIST2, LB_ADDSTRING, 0, (LPARAM)line);

if (fin.eof()) break;

} fin.close();

fin.clear();

tin.open("info.txt");

while (!tin.eof()) {

tin.getline(line, 80);

if (line == "\0" || line == "\n")

continue;

SendDlgItemMessage(hDlg, IDC_LIST2, LB_ADDSTRING, 0, (LPARAM)line);

if (tin.eof()) break;

}tin.close();

tin.clear();

} break;

case IDC_BUTTON2 :

DialogBox(hInst, MAKEINTRESOURCE(IDD_DIALOG2), hWnd,MemDlgProc);

break;

case IDC_BUTTON3 :

DialogBox(hInst, MAKEINTRESOURCE(IDD_DIALOG4), hWnd,RegDlgProc);

break;

case IDC_BUTTON4 :

fRegister = !KR_EventIsRegistered(&phDev);

reggi = !reggi;

if (!reggi) {

KR_EventRegister(&phDev, DiagEventHandler);

SetDlgItemText(hDlg, IDC_STATIC_1, "Unregister plug-and-play and power managment events");

} if (reggi) {

KR_EventUnregister(&phDev);

SetDlgItemText(hDlg, IDC_STATIC_1, "Register plug-and-play and power managment events");

} break;

case IDOK:

case IDCANCEL :

EndDialog(hDlg, 0);

return TRUE;

}break;

}return FALSE;

}

unsigned Convert(char * s, int n){

int res = 0;

int temp = 0;

int step = 1;

while (n > 0){

--n;

if (isdigit(s[n])) {

if (s[n] == '0')

temp = 0;

else if (s[n] == '1')

temp = step;

else if (s[n] == '2')

temp = 2 * step;

else if (s[n] == '3')

temp = 3 * step;

else if (s[n] == '4')

temp = 4 * step;

else if (s[n] == '5')

temp = 5 * step;

else if (s[n] == '6')

temp = 6 * step;

else if (s[n] == '7')

temp = 7 * step;

else if (s[n] == '8')

temp = 8 * step;

else if (s[n] == '9')

temp = 9 * step;

}else if (isalpha(s[n])) {

if (toupper(s[n]) == 'A')

temp = 10 * step;

else if (toupper(s[n]) == 'B')

temp = 11 * step;

else if (toupper(s[n]) == 'C')

temp = 12 * step;

else if (toupper(s[n]) == 'D')

temp = 13 * step;

else if (toupper(s[n]) == 'E')

temp = 14 * step;

else if (toupper(s[n]) == 'F')

temp = 15 * step;

}step *= 16;

res += temp;

}return res;

}

BOOL CALLBACK MemDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)

{

DWORD dwAddr = 0;

char * s[5] = { "BAR 0", "BAR 1", "BAR 2", "BAR 3", "BAR 4" };

static HWND hComb;

static HWND Button1;

static HWND Check1;

ifstream it;

char * itt = new char[200];

int t;

DWORD dwNumAddrSpaces = KR_GetNumAddrSpaces(*phDev);

if (ACTIVE_ADDR_SPACE_NEEDS_INIT == dwAddrSpace) {

for (dwAddr = 0; dwAddr < dwNumAddrSpaces; dwAddr++) {

if (WDC_AddrSpaceIsActive(*phDev, dwAddr))

break;

} dwAddrSpace = dwAddr;

}switch (uMsg) {

case WM_INITDIALOG:

Button1 = GetDlgItem(hDlg, IDC_EDIT7);

Check1 = GetDlgItem(hDlg, IDC_CHECK2);

hComb = GetDlgItem(hDlg, IDC_COMBO1);

if (dwAddr == dwNumAddrSpaces) {

MessageBox(hDlg, "no active address spaces found", "Error", MB_OK);

dwAddr = ACTIVE_ADDR_SPACE_NEEDS_INIT;

return 0;

}for (int i = 0; i < dwNumAddrSpaces; ++i)

SendMessage(hComb, CB_ADDSTRING, 0, (LPARAM)s[i]);

t = (int)mode;

CheckRadioButton(hDlg, IDC_RADIO1, IDC_RADIO4, IDC_RADIO1 + t);

CheckDlgButton(hDlg, IDC_CHECK1, fBlock);

SendDlgItemMessage(hDlg, IDC_COMBO1, CB_SETCURSEL, dwAddrSpace, 0);

break;

case WM_COMMAND:

switch (LOWORD(wParam)) {

case IDC_COMBO1 :

switch (HIWORD(wParam)){

case CBN_SELCHANGE :

dwAddrSpace = SendMessage(hComb, CB_GETCURSEL, 0, 0);

break;

} break;

case IDC_RADIO1 :

case IDC_RADIO2 :

case IDC_RADIO3 :

case IDC_RADIO4 :

mode = WDC_ADDR_MODE(LOWORD(wParam) - IDC_RADIO1);

ssize = (int)mode;

break;

case IDC_CHECK1 :

fBlock = !fBlock;

if (fBlock){

Button_Enable(Button1, TRUE);

Button_Enable(Check1, TRUE);

}else if (!fBlock) {

Button_Enable(Button1, FALSE);

if (fAutoInc) {

CheckDlgButton(hDlg, IDC_CHECK2, BST_UNCHECKED);

fAutoInc = !fAutoInc;

}Button_Enable(Check1, FALSE);

}break;

case IDC_CHECK2 :

fAutoInc = !fAutoInc;

break;

case IDC_READ :

SendDlgItemMessage(hDlg,IDC_EDIT6,WM_GETTEXT, 10, (LPARAM)offs);

dwOffset = Convert(offs, strlen(offs));

if (!dwOffset) dwOffset = 0;

if (fBlock){

SendDlgItemMessage(hDlg,IDC_EDIT7,WM_GETTEXT, 10, (LPARAM)byt);

dwBytes = atoi(byt);

pBuf = malloc(dwBytes);

memset(pBuf, 0, dwBytes);

if (WDC_AD_CFG_SPACE == dwAddrSpace) {

WD_BUS_TYPE busType = WDC_GetBusType(*phDev);

if (WD_BUS_PCI == busType dwStatus = WDC_PciReadCfg(*phDev, dwOffset, pBuf, dwBytes);

else if (WD_BUS_PCMCIA == busType) dwStatus = WDC_PcmciaReadAttribSpace(*phDev, dwOffset, pBuf, dwBytes);

else

MessageBox(hDlg, "Error - Cannot read/write configuration space address space ", "Error", MB_OK);

} else {

options = (fAutoInc ? WDC_ADDR_RW_DEFAULT : WDC_ADDR_RW_NO_AUTOINC);

WDC_ReadAddrBlock(*phDev, dwAddrSpace, dwOffset, dwBytes, pBuf, mode, options);

}if (WD_STATUS_SUCCESS == dwStatus)

DIAG_PrintHexBuffer(pBuf, dwBytes, FALSE);

else MessageBox(hDlg, "Read operation failed", "Error", MB_OK);

}else {

switch (mode) {

case WDC_MODE_8:

WDC_ReadAddr8(*phDev, dwAddrSpace, dwOffset, &bData);

if (WD_STATUS_SUCCESS == dwStatus) { sa = fopen("read.txt", "w");

fprintf(sa, "%X", (UINT32)bData);

fclose(sa);

} break;

case WDC_MODE_16:

WDC_ReadAddr16(*phDev, dwAddrSpace, dwOffset, &wData) ;

if (WD_STATUS_SUCCESS == dwStatus) {

sa = fopen("read.txt", "w");

fprintf(sa, "%hX", wData);

fclose(sa);

} break;

case WDC_MODE_32:

WDC_ReadAddr32(*phDev, dwAddrSpace, dwOffset, &u32Data) ;

if (WD_STATUS_SUCCESS == dwStatus) {

sa = fopen("read.txt", "w");

fprintf(sa, "%X", u32Data);

fclose(sa);

} break;

case WDC_MODE_64:

WDC_ReadAddr64(*phDev, dwAddrSpace, dwOffset, &u64Data);

if (WD_STATUS_SUCCESS == dwStatus) {

sa = fopen("read.txt", "w");

fprintf(sa, "%"PRI64"X", u64Data);

fclose(sa);

}break;

default: return 0;

}

} it.open("read.txt");

it.getline(itt, 200);

SetDlgItemText(hDlg, IDC_EDIT1, itt);

it.close();

break;

case IDC_WRITE :

SendDlgItemMessage(hDlg,IDC_EDIT6,WM_GETTEXT, 10, (LPARAM)offs);

dwOffset = Convert(offs, strlen(offs));

if (!dwOffset) dwOffset= 0;

if (fBlock) {

SendDlgItemMessage(hDlg,IDC_EDIT7,WM_GETTEXT, 10, (LPARAM)byt);

dwBytes = atoi(byt);

if (dwBytes == 0){

essageBox(hDlg, "Size is needed", "Input error", MB_OK);

return 0;

}pBuf = malloc(dwBytes);

memset(pBuf, 0, dwBytes);

SendDlgItemMessage(hDlg,IDC_EDIT1,WM_GETTEXT, 400, (LPARAM)write);

x = Convert(write, strlen(write));

if (!DIAG_GetHexBuffer(pBuf, 200, write, 200)) {

MessageBox(hDlg, "Input data is needed", "Error", MB_OK);

return 0;

} if (WDC_AD_CFG_SPACE == dwAddrSpace) {

WD_BUS_TYPE busType = WDC_GetBusType(*phDev);

if (WD_BUS_PCI == busType)

dwStatus = WDC_PciWriteCfg(*phDev, dwOffset, pBuf, dwBytes);

else if (WD_BUS_PCMCIA == busType) dwStatus = WDC_PcmciaWriteAttribSpace(*phDev, dwOffset, pBuf, dwBytes);

else

MessageBox(hDlg, "Write operation failed", "Error", MB_OK);

}else {

options = (fAutoInc ? WDC_ADDR_RW_DEFAULT : WDC_ADDR_RW_NO_AUTOINC);

dwStatus = WDC_WriteAddrBlock(*phDev, dwAddrSpace, dwOffset, dwBytes, pBuf, mode, options);

}if (WD_STATUS_SUCCESS != dwStatus) {

MessageBox(hDlg, "Writing failed", "Error", MB_OK);

} if (pBuf) free(pBuf);

}else {

SendDlgItemMessage(hDlg,IDC_EDIT1,WM_GETTEXT, 400, (LPARAM)write);

if (!WDC_DIAG_InputWriteData((WDC_MODE_8 == mode) ? (PVOID)&bData :

(WDC_MODE_16 == mode) ? (PVOID)&wData :

(WDC_MODE_32 == mode) ? (PVOID)&u32Data : (PVOID)&u64Data,

WDC_ADDR_MODE_TO_SIZE(mode), x))

return 0;

switch (mode) {

case WDC_MODE_8:

WDC_WriteAddr8(*phDev, dwAddrSpace, dwOffset, bData);

break;

case WDC_MODE_16:

WDC_WriteAddr16(*phDev, dwAddrSpace, dwOffset, wData);

break;

case WDC_MODE_32:

WDC_WriteAddr32(*phDev, dwAddrSpace, dwOffset, u32Data);

break;

case WDC_MODE_64:

WDC_WriteAddr64(*phDev, dwAddrSpace, dwOffset, u64Data);

break;

default:

MessageBox(hDlg, "Incorrect operation", "Error", MB_OK);

return 0;

}if (WD_STATUS_SUCCESS != dwStatus)

MessageBox(hDlg, "Write operation failled", "Error", MB_OK);

}break;

case IDCANCEL :

case IDOK:

EndDialog(hDlg, 0);

return TRUE;

} break;

}return FALSE;

}

BOOL CALLBACK RegDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)

{

const WDC_REG *pReg;

BOOL fPciCfg = true;

static int current = 0;

static HWND hListBox;

int t;

static DWORD dwOffset = 0;

static DWORD dwBytes = 200;

PVOID pBuf = NULL;

pBuf = malloc(dwBytes);

ifstream z;

string ltt;

if (!pBuf) {

MessageBox(hDlg, "WDC_DIAG_ReadWriteBlock: Failed allocating %s data buffer", "Error", MB_OK); return 0;

} memset(pBuf, 0, dwBytes);

switch (uMsg) {

case WM_INITDIALOG:

hListBox = GetDlgItem(hDlg, IDC_LIST1);

WDC_DIAG_RegsInfoPrint(gpKR_CfgRegs, KR_CFG_REGS_NUM,

WDC_DIAG_REG_PRINT_ALL & ~WDC_DIAG_REG_PRINT_ADDR_SPACE);

fin.open("regs.txt");

while (!fin.eof()) {

fin.getline(pine, 80);

if (isalpha(pine[0])/* && pine[1] != ' ' && pine*/)

SendDlgItemMessage(hDlg, IDC_LIST1, LB_ADDSTRING, 0, (LPARAM)pine);

if (fin.eof()) break;

}fin.close();

fin.clear();

if (!&phDev){

MessageBox(hDlg, "WDC_DIAG_ReadWriteBlock: Error - NULL WDC device handle", "Error", MB_OK);

return 0;}break;

case WM_COMMAND:

switch (LOWORD(wParam)) {

case IDC_LIST1 :

switch (HIWORD(wParam)){

case LBN_SELCHANGE :

current = SendMessage(hListBox, LB_GETCURSEL, 0, 0);

SetDlgItemText(hDlg, IDC_EDIT1, regs[current].name);

t = (int)regs[current].offset;

_itoa(t, buf, 16);

SetDlgItemText(hDlg, IDC_EDIT2, buf);

t = (int)regs[current].size;

_itoa(t, buf, 10);

SetDlgItemText(hDlg, IDC_EDIT3, buf);

SetDlgItemText(hDlg, IDC_EDIT4, regs[current].rw);

SetDlgItemText(hDlg, IDC_EDIT5, regs[current].call);

break;

default : break;

}break;

case IDC_READ :

SendDlgItemMessage(hDlg,IDC_EDIT6,WM_GETTEXT, 10, (LPARAM)offs);

SendDlgItemMessage(hDlg,IDC_EDIT7,WM_GETTEXT, 10, (LPARAM)byt);

dwBytes = atoi(byt);

pBuf = malloc(dwBytes);

memset(pBuf, 0, dwBytes);

dwOffset = Convert(offs, strlen(offs));

if (WDC_AD_CFG_SPACE == dwAddrSpace) {

if (!dwBytes) MessageBox(hDlg, " Size is needed.", "WARNING", MB_OK);

else {

WD_BUS_TYPE busType = WDC_GetBusType(*phDev);

if (WD_BUS_PCI == busType)

dwStatus = WDC_PciReadCfg(*phDev, dwOffset, pBuf, dwBytes);//___read

else if (WD_BUS_PCMCIA == busType)

dwStatus = WDC_PcmciaReadAttribSpace(*phDev, dwOffset, pBuf, dwBytes else {

MessageBox(hDlg, "Error - Cannot read configuration space address space", "Error", MB_OK);

return 0; }

} }

DIAG_PrintHexBuffer(pBuf, dwBytes, FALSE);

rin.open("read.txt");

rin.getline(read, 400);

SetDlgItemText(hDlg, IDC_EDIT8, read);

rin.close();

rin.clear();

SetDlgItemText(hDlg, IDC_EDIT8, (LPCSTR)read);

break;

case IDC_WRITE :

SendDlgItemMessage(hDlg,IDC_EDIT7,WM_GETTEXT, 10, (LPARAM)byt);

SendDlgItemMessage(hDlg,IDC_EDIT6,WM_GETTEXT, 10, (LPARAM)offs);

SendDlgItemMessage(hDlg,IDC_EDIT8,WM_GETTEXT, 400, (LPARAM)write);

if (!DIAG_GetHexBuffer(pBuf, 200, write, 200))

MessageBox(hDlg, "Input data is needed", "Error", MB_OK);

dwBytes = atoi(byt);

dwOffset = Convert(offs, strlen(offs));

if (!dwBytes) MessageBox(hDlg, " Size is needed.", "WARNING", MB_OK);

else {

WD_BUS_TYPE busType = WDC_GetBusType(*phDev); //...

if (WD_BUS_PCI == busType)

dwStatus = WDC_PciWriteCfg(*phDev, dwOffset, pBuf, dwBytes);//__write

else if (WD_BUS_PCMCIA == busType

dwStatus = WDC_PcmciaWriteAttribSpace(*phDev, dwOffset, pBuf, dwBytes

else {

MessageBox(hDlg, "Error - Cannot write configuration space address space", "Error", MB_OK);

return 0;

}}break;

case IDC_READ2 : pReg = & gpKR_CfgRegs[current];

switch (pReg->dwSize) {

case WDC_SIZE_8:

dwStatus = fPciCfg ? WDC_PciReadCfg8(*phDev, pReg->dwOffset, &bData) : WDC_ReadAddr8(*phDev, pReg->dwAddrSpace, pReg->dwOffset, &bData);

if (WD_STATUS_SUCCESS == dwStatus) {

sa = fopen("reggg.txt", "w");

fprintf(sa, "%X", (UINT32)bData);

fclose(sa);

} break;

case WDC_SIZE_16:

dwStatus = fPciCfg ? WDC_PciReadCfg16(*phDev, pReg->dwOffset, &wData) :

WDC_ReadAddr16(*phDev, pReg->dwAddrSpace, pReg->dwOffset, &wData);

if (WD_STATUS_SUCCESS == dwStatus) {

sa = fopen("reggg.txt", "w");

fprintf(sa, "%hX", wData);

fclose(sa); } break;

case WDC_SIZE_32:

dwStatus = fPciCfg ? WDC_PciReadCfg32(*phDev, pReg->dwOffset, &u32Data) :

WDC_ReadAddr32(*phDev, pReg->dwAddrSpace, pReg->dwOffset, &u32Data);

if (WD_STATUS_SUCCESS == dwStatus) {

sa = fopen("reggg.txt", "w");

fprintf(sa, "%X", u32Data);

fclose(sa);

} break;

case WDC_SIZE_64:

dwStatus = fPciCfg ? WDC_PciReadCfg64(*phDev, pReg->dwOffset, &u64Data) :

WDC_ReadAddr64(*phDev, pReg->dwAddrSpace, pReg->dwOffset, &u64Data);

if (WD_STATUS_SUCCESS == dwStatus) {

sa = fopen("reggg.txt", "w");

fprintf(sa, "%"PRI64"X", u64Data);

fclose(sa);

} break;

default: MessageBox(hDlg, "Invalid register size ", "Error", MB_OK);

return 0;

} z.open("reggg.txt");

z.getline(zs, 19);

SetDlgItemText(hDlg, IDC_EDIT9, zs);

z.close();

z.clear();

break;

case IDC_WRITE2 :

SendDlgItemMessage(hDlg,IDC_EDIT9,WM_GETTEXT, 10, (LPARAM)zs);

pReg = & gpKR_CfgRegs[current];

if ((WDC_READ == pReg->direction)) {

MessageBox(hDlg, "You can't write to a read-only register", "Error", MB_OK);

return 0;

} ltt = zs;

if (!WDC_DIAG_InputWriteData((WDC_SIZE_8 == pReg->dwSize) ? (PVOID)&bData :

(WDC_SIZE_16 == pReg->dwSize) ? (PVOID)&wData :

(WDC_SIZE_32 == pReg->dwSize) ? (PVOID)&u32Data : (PVOID)&u64Data, pReg->dwSize, Convert(zs, strlen(zs)))) break;

switch (pReg->dwSize) {

case WDC_SIZE_8:

dwStatus = fPciCfg ? WDC_PciWriteCfg8(*phDev, pReg->dwOffset, bData) :

WDC_WriteAddr8(*phDev, pReg->dwAddrSpace, pReg->dwOffset, bData);

break;

case WDC_SIZE_16:

dwStatus = fPciCfg ? WDC_PciWriteCfg16(*phDev, pReg->dwOffset, wData) :

WDC_WriteAddr16(*phDev, pReg->dwAddrSpace, pReg->dwOffset, wData);

break;

case WDC_SIZE_32:

dwStatus = fPciCfg ? WDC_PciWriteCfg32(*phDev, pReg->dwOffset, u32Data) :

WDC_WriteAddr32(*phDev, pReg->dwAddrSpace, pReg->dwOffset, u32Data);

break;

case WDC_SIZE_64:

dwStatus = fPciCfg ? WDC_PciWriteCfg64(*phDev, pReg->dwOffset, u64Data) :

WDC_WriteAddr64(*phDev, pReg->dwAddrSpace, pReg->dwOffset, u64Data);

break;

default:

MessageBox(hDlg, "Invalid register size ", "Error", MB_OK);

return 0;

} break;

case IDCANCEL :

case IDOK:

EndDialog(hDlg, 0);

return TRUE;

} break;

}return FALSE;

}

BOOL CALLBACK DevDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)

{

static HWND hList2;

static HWND hEdit1;

static HWND hStatic1;

static HWND hStatic2;

static HWND hStatic3;

static HWND hEdit11;

static HWND hEdit12;

static HWND hEdit13;

static HWND hWrite;

static HWND hRead;

static HWND hCheck2;

char * itt = new char[200];

static int t;

ifstream it;

switch (uMsg) {

case WM_INITDIALOG:

mode = WDC_MODE_32;

dwAddrSpace = 2; // TO CHANGE

t = (int)mode;

CheckRadioButton(hDlg, IDC_RADIO1, IDC_RADIO4, IDC_RADIO1 + t);

fAutoInc = 0;

hList2 = GetDlgItem(hDlg, IDC_LIST2);

hEdit1 = GetDlgItem(hDlg, IDC_EDIT1);

hStatic1 = GetDlgItem(hDlg, IDC_STATIC1);

hStatic2 = GetDlgItem(hDlg, IDC_STATIC2);

hStatic3 = GetDlgItem(hDlg, IDC_STATIC3);

hEdit11 = GetDlgItem(hDlg, IDC_EDIT11);

hEdit12 = GetDlgItem(hDlg, IDC_EDIT12);

hEdit13 = GetDlgItem(hDlg, IDC_EDIT13);

hWrite = GetDlgItem(hDlg, IDC_WRITE);

hRead = GetDlgItem(hDlg, IDC_READ);

hCheck2 = GetDlgItem(hDlg, IDC_CHECK2);

break;

case WM_COMMAND:

switch (LOWORD(wParam)) {

case IDC_RADIO1 :

case IDC_RADIO2 :

case IDC_RADIO3 :

case IDC_RADIO4 :

mode = WDC_ADDR_MODE(LOWORD(wParam) - IDC_RADIO1);

ssize = (int)mode;

break;

case IDC_CHECK2 :

fAutoInc = !fAutoInc;

break;

case IDC_OPEN :

ivid = 0x1031;

idid = 0x9031;

SendDlgItemMessage(hDlg, IDC_LIST2, LB_RESETCONTENT, 0, 0);

if (*phDev)

DeviceClose(*phDev);

*phDev = NULL;

*phDev = DeviceFindAndOpen(ivid, idid);

if (!(*phDev)) {

MessageBox(hDlg, "Device was not found", "Error", MB_OK);

return 0;

} else {

Button_Enable(hList2, TRUE);

Button_Enable(hEdit1, TRUE);

Button_Enable(hStatic1, TRUE);

Button_Enable(hStatic2, TRUE);

Button_Enable(hStatic3, TRUE);

Button_Enable(hEdit11, TRUE);

Button_Enable(hEdit12, TRUE);

Button_Enable(hEdit13, TRUE);

Button_Enable(hWrite, TRUE);

Button_Enable(hRead, TRUE);

Button_Enable(hCheck2, TRUE);

brin.open("device.txt");

while (!fin.eof()) {

brin.getline(line, 80);

if (line == "\0" || line == "\n" || line == "") continue;

x = SendDlgItemMessage(hDlg, IDC_LIST2, LB_ADDSTRING, 0, (LPARAM)line);

if (brin.eof()) break;

} brin.close();

brin.clear();

tin.open("info.txt");

while (!tin.eof()) {

tin.getline(line, 80);

if (line == "\0" || line == "\n")

continue;

x = SendDlgItemMessage(hDlg, IDC_LIST2, LB_ADDSTRING, 0, (LPARAM)line);

if (tin.eof()) break;

} tin.close();

tin.clear();

}break;

case IDC_READ :

SendDlgItemMessage(hDlg,IDC_EDIT11,WM_GETTEXT, 10, (LPARAM)offs);

dwOffset = Convert(offs, strlen(offs));

if (!dwOffset) dwOffset = 0;

SendDlgItemMessage(hDlg,IDC_EDIT12,WM_GETTEXT, 10, (LPARAM)byt);

dwBytes = atoi(byt);

SendDlgItemMessage(hDlg,IDC_EDIT13,WM_GETTEXT, 10, (LPARAM)nums);

BlockNum = atoi(nums);

if (! BlockNum) BlockNum = 1;

pBuf = malloc(dwBytes);

memset(pBuf, 0, dwBytes);

reswrite.open("ReadBlocks.txt");

for (int i = 0; i < BlockNum; ++i) {

if (WDC_AD_CFG_SPACE == dwAddrSpace) {

WD_BUS_TYPE busType = WDC_GetBusType(*phDev);

if (WD_BUS_PCI == busType)

dwStatus = WDC_PciReadCfg(*phDev, dwOffset, pBuf, dwBytes);

else if (WD_BUS_PCMCIA == busType)

dwStatus = WDC_PcmciaReadAttribSpace(*phDev, dwOffset, pBuf, dwBytes);

else

MessageBox(hDlg, "Error - Cannot read/write configuration space address space ", "Error", MB_OK);

} else {

options = (fAutoInc ? WDC_ADDR_RW_DEFAULT : WDC_ADDR_RW_NO_AUTOINC);

WDC_ReadAddrBlock(*phDev, dwAddrSpace, dwOffset, dwBytes, pBuf, mode, options);

} if (WD_STATUS_SUCCESS == dwStatus)

DIAG_PrintHexBuffer(pBuf, dwBytes, FALSE);

else MessageBox(hDlg, "Read operation failed", "Error", MB_OK);

it.open("read.txt");

it.getline(itt, 200);

reswrite << itt << endl;

SetDlgItemText(hDlg, IDC_EDIT1, itt);

it.close();

it.clear();

dwOffset += dwBytes;

} reswrite.close();

reswrite.clear();

break;

case IDC_WRITE :

SendDlgItemMessage(hDlg,IDC_EDIT11,WM_GETTEXT, 10, (LPARAM)offs);

dwOffset = Convert(offs, strlen(offs));

if (!dwOffset) dwOffset = 0;

SendDlgItemMessage(hDlg,IDC_EDIT12,WM_GETTEXT, 10, (LPARAM)byt);

dwBytes = atoi(byt);

if (dwBytes == 0){

MessageBox(hDlg, "Size is needed", "Input error", MB_OK);

return 0; }

SendDlgItemMessage(hDlg,IDC_EDIT13,WM_GETTEXT, 10, (LPARAM)nums);

BlockNum = atoi(nums);

if (! BlockNum) BlockNum = 1;

pBuf = malloc(dwBytes);

memset(pBuf, 0, dwBytes);

resread.open("WriteBlocks.txt");

reswrite.open("dob.txt");

for (int i = 0; i < BlockNum; ++i) {

resread.get(write, dwBytes * 2 + 1);

reswrite << write << endl;

if (!DIAG_GetHexBuffer(pBuf, 200, write, 200)) {

MessageBox(hDlg, "Input data is needed", "Error", MB_OK);

return 0;

} if (WDC_AD_CFG_SPACE == dwAddrSpace) {

WD_BUS_TYPE busType = WDC_GetBusType(*phDev);

if (WD_BUS_PCI == busType)dwStatus = WDC_PciWriteCfg(*phDev, dwOffset, pBuf, dwBytes);

else if (WD_BUS_PCMCIA == busType) dwStatus = WDC_PcmciaWriteAttribSpace(*phDev, dwOffset, pBuf, dwBytes);

else MessageBox(hDlg, "Write operation failed", "Error", MB_OK);

} else {

options = (fAutoInc ? WDC_ADDR_RW_DEFAULT : WDC_ADDR_RW_NO_AUTOINC);dwStatus = WDC_WriteAddrBlock(*phDev, dwAddrSpace, dwOffset, dwBytes, pBuf, mode, options);

} if (WD_STATUS_SUCCESS != dwStatus)

MessageBox(hDlg, "Writing failed", "Error", MB_OK);

}if (pBuf) free(pBuf);

resread.close();

resread.clear();

reswrite.close();

reswrite.clear();

break;

case IDOK:

case IDCANCEL:

DeleteObject(hList2);

DeleteObject(hEdit1);

DeleteObject(hStatic1);

DeleteObject(hStatic2);

DeleteObject(hStatic3);

DeleteObject(hEdit11);

DeleteObject(hEdit12);

DeleteObject(hEdit13);

DeleteObject(hWrite);

DeleteObject(hRead);

DeleteObject(hCheck2);

EndDialog(hDlg, 0);

return TRUE;

}break;

}return FALSE;

}