---

emu6502.c

Go to the documentation of this file.

#define WIN32_LEAN_AND_MEAN             // Exclude rarely-used stuff from Windows headers

#include <windows.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <tchar.h>
#include <commdlg.h>
#include <commctrl.h>
#include <stdio.h>


#include "emu6502.h"
#define MAX_LOADSTRING 512
#define CR 13
#define LF 10

HINSTANCE hInst;        
HWND hMainWnd;
HWND hToolBar;

DllMsgList* DMList = NULL;
PtrList* DHInstList = NULL;


TCHAR szTitle[MAX_LOADSTRING];
TCHAR szWindowClass[MAX_LOADSTRING];


int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
                     LPSTR lpCmdLine, int nCmdShow)
{
        MSG msg;
        int gotMsg = FALSE;
        BOOL run = TRUE;
        int i = 0;

        LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
        LoadString(hInstance, IDC_EMU6502, szWindowClass, MAX_LOADSTRING);
        MyRegisterClass(hInstance);

        InitMem();

        if (!InitInstance(hInstance, nCmdShow)) {
                return FALSE;
        }

        // Main message loop
        while (GetMessage(&msg, NULL, 0, 0)) {
                TranslateMessage(&msg);
                DispatchMessage(&msg);
        }

        return msg.wParam;
}


ATOM MyRegisterClass(HINSTANCE hInstance)
{
        WNDCLASSEX wcex;

        wcex.cbSize = sizeof(WNDCLASSEX); 

        wcex.style                      = CS_HREDRAW | CS_VREDRAW;
        wcex.lpfnWndProc        = (WNDPROC)WndProc;
        wcex.cbClsExtra         = 0;
        wcex.cbWndExtra         = 0;
        wcex.hInstance          = hInstance;
        wcex.hIcon                      = LoadIcon(hInstance, (LPCTSTR)IDI_EMU6502);
        wcex.hCursor            = LoadCursor(NULL, IDC_ARROW);
        wcex.hbrBackground      = (HBRUSH)(COLOR_BTNFACE+1);   //(COLOR_WINDOW+1);
        wcex.lpszMenuName       = (LPCSTR)IDC_EMU6502;
        wcex.lpszClassName      = szWindowClass;
        wcex.hIconSm            = LoadIcon(wcex.hInstance, (LPCTSTR)IDI_SMALL);

        return RegisterClassEx(&wcex);
}


BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
        RECT rc, rcToolB;

        hInst = hInstance; 

        hMainWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX,
                0, 0, 0, 0, NULL, NULL, hInstance, NULL);

        if (!hMainWnd) {
                return FALSE;
        }

        rc.top = GetSystemMetrics(SM_CYSCREEN) / 2 - 138;
        rc.left = GetSystemMetrics(SM_CXSCREEN) / 2 - 128;
        rc.right = GetSystemMetrics(SM_CXSCREEN) / 2 + 127;
        rc.bottom = GetSystemMetrics(SM_CYSCREEN) / 2 + 117;
        AdjustWindowRect(&rc, WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX, TRUE);

        hToolBar = CreateToolBar(hMainWnd);

        GetWindowRect(hToolBar, &rcToolB);
        rc.bottom += rcToolB.bottom - rcToolB.top;

        SetWindowPos(hMainWnd, HWND_TOP, rc.left, rc.top, 
                rc.right - rc.left + 1, rc.bottom - rc.top + 1, SWP_NOZORDER);
        SendMessage(hToolBar, TB_AUTOSIZE, 0, 0);

        LoadPlugins(&DMList, &DHInstList);
        
        ShowWindow(hMainWnd, nCmdShow);
        UpdateWindow(hMainWnd);

        return TRUE;
}

HWND CreateToolBar(HWND hParentWnd)
{
        HWND hTb;
        TBBUTTON TBtns[3];
        INITCOMMONCONTROLSEX iccs;

        iccs.dwSize = sizeof(INITCOMMONCONTROLSEX);
        iccs.dwICC = ICC_BAR_CLASSES;

        if (!InitCommonControlsEx(&iccs)) {
                return NULL;
        }

        ZeroMemory(&TBtns, sizeof(TBBUTTON) * 1);
        TBtns[0].fsState = TBSTATE_ENABLED;
        TBtns[0].fsStyle = TBSTYLE_BUTTON | TBSTYLE_AUTOSIZE ;
        TBtns[0].iBitmap = 0;
        TBtns[0].idCommand = IDM_FILE_LOADMEMORYFILE;

        hTb = CreateToolbarEx(hParentWnd, WS_CHILD | TBSTYLE_FLAT,
                0, 1, hInst, IDR_TOOLBAR, TBtns, 1, 16, 16, 16, 16, sizeof(TBBUTTON));

        ShowWindow(hTb, SW_SHOW); 
        return hTb;
}


LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
        int wmId, wmEvent;
        BOOL MsgProcessed;
        

        MsgProcessed = ForwardDllMessage(message, wParam, lParam, DMList);

        switch (message) 
        {
                case WM_COMMAND:
                        wmId    = LOWORD(wParam); 
                        wmEvent = HIWORD(wParam); 
                        // Parse the menu selections:
                        switch (wmId)
                        {
                                case IDM_ABOUT:
                                        DialogBox(hInst, (LPCTSTR)IDD_ABOUTBOX, hWnd, (DLGPROC)About);
                                        break;
                                case IDM_EXIT:
                                        DestroyWindow(hWnd);
                                        break;
                                case IDM_FILE_LOADMEMORYFILE:
                                        LoadMemFile(hWnd);
                                        break;
                                default:
                                        if (MsgProcessed == FALSE) {
                                                return DefWindowProc(hWnd, message, wParam, lParam);
                                        }
                        }
                        break;
                case WM_DESTROY:
                        UnloadPlugins(DHInstList);
                        PostQuitMessage(0);
                        break;
                default:
                        if (MsgProcessed == FALSE) {
                                return DefWindowProc(hWnd, message, wParam, lParam);
                        }
   }
   return 0;
}

LRESULT CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
        switch (message)
        {
                case WM_INITDIALOG:
                                return TRUE;

                case WM_COMMAND:
                        if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL) 
                        {
                                EndDialog(hDlg, LOWORD(wParam));
                                return TRUE;
                        }
                        break;
        }
    return FALSE;
}

BOOL LoadMemFile(HWND hWnd)
{
        OPENFILENAME ofn;
        TCHAR FileName[_MAX_PATH];
        HANDLE hFile;
        DWORD dwSize;
        DWORD dwRead;

        //Open file dialog
        SendMessage(hWnd, PAUSECPU, 0, 0);
        SendMessage(hWnd, WAITEND, 0, 0);

        lstrcpy(FileName, "");
        ZeroMemory(&ofn, sizeof(OPENFILENAME));
        
        ofn.lStructSize = sizeof(OPENFILENAME);
        ofn.lpstrFile = FileName;
        ofn.hwndOwner = hWnd;
        ofn.nMaxFile = sizeof(FileName);
        ofn.lpstrFilter = 
                TEXT("Memory image files (*.img)\0*.img\0All Files (*.*)\0*.*\0");
        ofn.nFilterIndex = 1;
        ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;
        
        if (!GetOpenFileName(&ofn))
                return FALSE;

        //Open given file
        hFile=CreateFile((LPCSTR) FileName, GENERIC_READ, 0,NULL, OPEN_EXISTING, 0, NULL);
        if (hFile==INVALID_HANDLE_VALUE) {
                error(hWnd, IDS_EOPEN, NULL);
                return FALSE;
        }

        dwSize=GetFileSize(hFile, NULL);
        if(dwSize!=MEMSIZE) {
                error(hWnd, IDS_ECORRUPT, NULL);
                return FALSE;
        }
        
        SendMessage(hWnd, STOPVIDEO, 0, 0);

        if (!ReadFile(hFile, &memory, dwSize, &dwRead, NULL) ) {
                CloseHandle(hFile);
                error(hWnd, IDS_EREAD, NULL);
                return FALSE;
        }
        SendMessage(hWnd, RESETMSG, 0, 0);
        CloseHandle(hFile);
        return TRUE;
}

void error(HWND hWnd, UINT uID, TCHAR* name)
{
        TCHAR msg[MAX_LOADSTRING];
        TCHAR out[MAX_LOADSTRING];
        LoadString(hInst, uID, msg, MAX_LOADSTRING);
        _stprintf(out, msg, name);
        MessageBox(hWnd, out, "Error", MB_OK | MB_ICONERROR | MB_DEFBUTTON1);
}

BOOL ForwardDllMessage(UINT message, WPARAM wParam, LPARAM lParam, DllMsgList* actlist)
{
        PtrList* actnode;
        MESSAGEDLLSTRUCT mds;

        actlist = DMList;
        while (actlist != NULL && actlist->MesgID != message) {
                actlist = actlist->next;
        }
        if (actlist == NULL) {
                return FALSE;
        }
        
        mds.lParam = lParam;
        mds.wParam = wParam;
        mds.message = message;

        actnode = actlist->Functions;

        while (actnode != NULL) {
                ((pForwardDllMsgProc) actnode->ptr)(&mds);
                actnode = actnode->next;
        }
        return TRUE;
}

void LoadPlugins(DllMsgList** list, PtrList** InstList)
{
        HANDLE hFile;
        TCHAR buf[65536];
        TCHAR* str;
        TCHAR* param;
        DWORD dwRead;

        hFile = CreateFile("plugins.txt", GENERIC_READ, FILE_SHARE_READ,
                NULL, OPEN_EXISTING, 0, NULL);
        if (hFile == INVALID_HANDLE_VALUE) {
                error(hMainWnd, IDS_EPLUGINSTXT, NULL);
                return;
        }

        if (!ReadFile(hFile, buf, 65536, &dwRead, NULL)) {
                error(hMainWnd, IDS_EPLUGINSTXT, NULL);
                return;
        }
        buf[dwRead] = '\0';
        
        param = (TCHAR*) buf;
        while((str = GetNextStrToken(&param)) != NULL) {
                if (LoadPlugin(str, list, InstList) == FALSE) {
                        error(hMainWnd, IDS_EPLUGIN, str);
                }
        }

        CloseHandle(hFile);
}

BOOL LoadPlugin(TCHAR* name, DllMsgList** list, PtrList** InstList)
{
        HINSTANCE hInstLib;
        pInitDllProc IDProc;
        pForwardDllMsgProc FDMProc;
        pIOFunc IOFunc;
        INITDLLSTRUCT ids;
        INITDLLINFO idi;
        RECT rcT, rcC;
        int i;

        // try to load library of given name
        hInstLib = LoadLibrary(name);
        if (hInstLib == NULL) {
                error(hMainWnd, IDS_EOPEN, NULL);
                return FALSE;
        }

        // get handles to the two common plugin procedures
        IDProc = (pInitDllProc) GetProcAddress(hInstLib, "InitDll");
        FDMProc = (pForwardDllMsgProc) GetProcAddress(hInstLib, "OnMessage");
        IOFunc = (pIOFunc) GetProcAddress(hInstLib, "IOFunc");

        // save this library handle
        AddToPtrList((void*) hInstLib, InstList);

        // fill ids
        ids.hInst = hInst;
        ids.hWnd = hMainWnd;
        ids.hTb = hToolBar;
        ids.memory = memory;
        ids.optional = NULL;
        ids.CSMemory = CSMemory;
        ids.memgetb = &memgetb;
        ids.memsetb = &memsetb;
        GetClientRect(hMainWnd, &rcC);
        GetWindowRect(hToolBar, &rcT);
        rcC.top += rcT.bottom  - rcT.top;
        ids.rcPaint = rcC;

        
        // call InitDll proc, receive list of messages to be catched
        // and lower/higher end of demanded io memory
        (IDProc) (&ids, &idi);

        // add this list to DllMsgList structure
        if (idi.msglist != NULL) {
                for (i=0; idi.msglist[i]!=ENDOFMSGLIST; i++) {
                        AddDllMsg(list, idi.msglist[i], FDMProc);
                }
        }
        
        // register the io memory
        if (idi.iolo !=0 && idi.iohi != 0) {
                if (IOFunc == NULL) {
                        error(hMainWnd, IDS_EIOFNOTFOUND, name);
                } 
                else {
                        SetIOFunc(IOFunc, idi.iolo, idi.iohi);
                }
        }

        return TRUE;
}

void AddDllMsg(DllMsgList** list, UINT message, 
                           pForwardDllMsgProc FDMProc)
{
        DllMsgList* newlist;
        DllMsgList* prev = NULL;
        DllMsgList* actlist = *list;
        
        while (actlist != NULL && actlist->MesgID != message) {
                prev = actlist;
                actlist = actlist->next;
        }

        if (actlist == NULL) {
                newlist = (DllMsgList*) malloc(sizeof(DllMsgList));
                newlist->MesgID = message;
                newlist->Functions = NULL;
                newlist->next = NULL;
                AddToPtrList((void*) FDMProc, &newlist->Functions);
                // New list
                if (prev == NULL) {
                        *list = newlist;
                        return;
                }
                else {
                // New message code
                        prev->next = newlist;
                        return;
                }
        }

        // Add function to existing message
        AddToPtrList((void*) FDMProc, &actlist->Functions);
        return;
}

void UnloadPlugins(PtrList* list)
{
        PtrList* p = list;
        while (p != NULL) {
                FreeLibrary((HINSTANCE) list->ptr);
                p = list->next;
                free(list);
                list = p;
        }
}


void AddToPtrList(void* ptr, PtrList** list)
{
        PtrList* node = (PtrList*) malloc(sizeof(PtrList));
        node->ptr = ptr;
        node->next = *list;
        *list = node;
}

TCHAR* GetNextStrToken(TCHAR** buf)
{
        TCHAR* start = *buf;

        if (*buf == NULL || **buf == '\0' || **buf == CR || **buf == LF) {
                return NULL;
        }

        while (**buf != CR && **buf != '\0') {
                (*buf)++;
        }

        if (**buf == CR) {
                **buf = '\0';
                (*buf)++;
                if (**buf == LF) {
                        (*buf)++;
                }
        }
        return start;
}

        

---