path: root/luapatch.cpp

/*
 *  PSX-Tools Bundle Pack
 *  Copyright (C) 2002-2005 Nicolas "Pixel" Noble
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

/* $Id: luapatch.cpp,v 1.13 2005-10-13 16:00:37 pixel Exp $ */

#define PARASITE_EVE_INI \
"[patch]\n" \
"title=Parasite Eve - fr - 0.9\n" \
"options=0\n" \
"type=rebuild\n" \
"filename=main\n" \
"command=\n"

#define OPEN_PATCH_INI(warn) \
    try { \
        Input * t_config_file = new Input("patch.ini"); \
        config_file = new Buffer(true); \
        t_config_file->copyto(config_file); \
    } \
    catch (IOGeneral e) { \
        if (warn) \
            printm(M_WARNING, GetString(PARASITE_EVE)); \
        config_file = new Buffer(true); \
        (*config_file) << PARASITE_EVE_INI; \
    }


#include <windowsx.h>

#include <Input.h>
#include <Output.h>
#include <Buffer.h>
#include <BLua.h>
#include <LuaHandle.h>
#include <Main.h>
#include <ConfigFile.h>

#include "cdabstract.h"
#include "cdutils.h"
#include "isobuilder.h"
#include "luacd.h"
#include "luapsx.h"

#include "luapatch-res.h"

#include "luapatch-languages.h"

class Luabasecdtool : public LuaObject {
  public:
    static void pushstatics(Lua *) throw (GeneralException);
};

typedef void basecdtool;

enum basecdtool_t {
    BASECDTOOL_LOAD = 0,
};

struct lua_functypes_t basecdtool_functions[] = {
    { BASECDTOOL_LOAD,	"load", 	0, 1, { LUA_STRING | LUA_OBJECT } },
    { -1, 0, 0, 0, 0 }
};

class sLua_basecdtool : public Base {
  public:
    DECLARE_FUNCTION(basecdtool, BASECDTOOL_LOAD);
  private:
    static int basecdtool_proceed_statics(Lua * L, int n, int caller);
};

void Luabasecdtool::pushstatics(Lua * L) throw (GeneralException ) {
    CHECK_FUNCTIONS(basecdtool);
    
    PUSH_FUNCTION(basecdtool, BASECDTOOL_LOAD);
}

int sLua_basecdtool::basecdtool_proceed_statics(Lua * L, int n, int caller) {
    int r = 0;

    switch (caller) {
    case BASECDTOOL_LOAD:
        if (!n) {
    	    L->load(&Input("cd-tool.lua"));
        } else {
            if (L->isstring(1)) {
                L->load(&Input(L->tostring(1)));
            } else {
                Handle * t = (Handle *) LuaObject::getme(L, 1);
                L->load(t);
            }
        }
    }

    return r;
}

bool quit = false;
bool canprobe;
bool fromdrive = false;
bool rebuild = false;
bool patch_loaded = false;
bool have_info = false;

int current_option = 0;
String option_variable;

Input * fpatch = 0;
Handle * config_file = 0;
int options = 0;

Handle * options_cmds = 0;

String title;

String source, dest, patch;

int langid;

CODE_BEGINS
static int myprint(lua_State * __L) {
    Lua * L = Lua::find(__L);
    String t = L->tostring();
    char * tc = t.strdup();

    printm(M_STATUS, "%s\n", tc);

    free(tc);

    return 0;
}

static void translate(int ownerid, HWND hW) {
    struct trad_t * t;
    struct texts_t * txt;

    for (t = trads; t->trad && t->langid != langid; t++);

    if (!t->trad)
        return;

    for (txt = t->trad; txt->str; txt++) {
        if (txt->owner == ownerid) {
            if (txt->id == -1) {
                SetWindowText(hW, txt->str);
            } else {
                SetDlgItemText(hW, txt->id, txt->str);
            }
        }
    }
}

static const char * GetString(int id) {
    struct trad_t * t;
    struct texts_t * txt;
    int oldlangid = langid;
    const char * r;

    for (t = trads; t->trad && t->langid != langid; t++);

    if (!t->trad) {
        oldlangid = langid;
        langid = LANG_NEUTRAL;
        r = GetString(id);
        langid = oldlangid;
        return r;
    }

    for (txt = t->trad; txt->str; txt++) {
        if ((txt->owner == 0) && (txt->id == id))
            return txt->str;
    }

    if (langid == LANG_NEUTRAL)
        return NULL;

    oldlangid = langid;
    langid = LANG_NEUTRAL;
    r = GetString(id);
    langid = oldlangid;
    return r;
}

static bool LoadPatch(HWND hW) {
    char szB[260];

    GetDlgItemText(hW, IDC_PATCH, szB, 259);

    try {
        fpatch = new Input(szB);
        fpatch->seek(0);

        new Archive(fpatch);
    }
    catch (GeneralException e) {
        printm(M_ERROR, GetString(LOAD_ERROR) + String(" - ") + e.GetMsg());
        MessageBox(hW, GetString(LOAD_ERROR), GetString(MSGERROR), MB_OK | MB_ICONERROR);
        return false;
    }

    OPEN_PATCH_INI(true);

    ConfigFile cfg(config_file);
    title = cfg["patch"]["title"];

    if (cfg["patch"]["type"] == "rebuild") {
        rebuild = true;
    } else if (cfg["patch"]["type"] == "patch") {
        rebuild = false;
    } else {
        MessageBox(hW, GetString(VERBOSE_CFG_ERROR), GetString(MSGERROR), MB_OK | MB_ICONERROR);
        return false;
    }

    try {
        char c;
        Input i("readme.txt");
        i.read(&c, 1);
        have_info = true;
    }
    catch (IOGeneral e) {
        have_info = false;
    }

    options = cfg["patch"]["options"].to_int();

    delete config_file;

    return true;
}

static void ChooseFile(HWND hW, int iFType) {
    OPENFILENAME ofn;
    char szB[260];
    BOOL b;

    ofn.lStructSize = sizeof(OPENFILENAME); 
    ofn.hwndOwner = hW;                      
    ofn.hInstance = NULL; 

    switch (iFType) {
    case DEST_SELECT:
        ofn.lpstrFilter = GetString(ISODEST);
        GetDlgItemText(hW, IDC_DEST, szB, 259);
        break;
    case SOURCE_SELECT:
        ofn.lpstrFilter = GetString(ISOSOURCE);
        GetDlgItemText(hW, IDC_SOURCE, szB, 259);
        break;
    case PATCH_SELECT:
        ofn.lpstrFilter = GetString(PATCH);
        GetDlgItemText(hW, IDC_PATCH, szB, 259);
        break;
    }

    ofn.lpstrCustomFilter=NULL; 
    ofn.nMaxCustFilter=0;
    ofn.nFilterIndex=0;  
 
    ofn.lpstrFile = szB;
    ofn.nMaxFile = 259; 
    ofn.lpstrFileTitle = NULL;
    ofn.nMaxFileTitle = 0; 
    ofn.lpstrInitialDir = NULL;
    ofn.lpstrTitle = NULL; 

    ofn.nFileOffset=0; 
    ofn.nFileExtension=0;
    ofn.lpstrDefExt=0; 
    ofn.lCustData=0;
    ofn.lpfnHook=NULL; 
    ofn.lpTemplateName=NULL;

    if (iFType == DEST_SELECT) {
        ofn.Flags = OFN_CREATEPROMPT |
                    OFN_NOCHANGEDIR |
                    OFN_HIDEREADONLY |
                    OFN_OVERWRITEPROMPT;
        b = GetSaveFileName(&ofn);
    } else {
        ofn.Flags = OFN_FILEMUSTEXIST |
                    OFN_NOCHANGEDIR |
                    OFN_HIDEREADONLY;
        b = GetOpenFileName(&ofn);
    }

    if (b) {
        switch (iFType) {
        case DEST_SELECT:
            SetDlgItemText(hW, IDC_DEST, szB);
            break;
        case SOURCE_SELECT:
            SetDlgItemText(hW, IDC_SOURCE, szB);
            break;
        case PATCH_SELECT:
            SetDlgItemText(hW, IDC_PATCH, szB);
            break;
        }
    }
}

static BOOL CALLBACK AboutDlgProc(HWND hW, UINT uMsg, WPARAM wParam, LPARAM lParam) {
    RECT r;
    POINT p;
    int bwidth, bheight, wsize;
    HWND button;

    switch (uMsg) {
    case WM_INITDIALOG:
        translate(IDD_ABOUT, hW);

        button = GetDlgItem(hW, IDOK);
        GetWindowRect(button, &r);
        p.x = r.left;
        p.y = r.top;
        ScreenToClient(hW, &p);
        bwidth = r.right - r.left;
        bheight = r.bottom - r.top;
        GetWindowRect(hW, &r);
        wsize = r.right - r.left;
        MoveWindow(button, wsize / 2 - bwidth / 2, p.y, bwidth, bheight, TRUE);
        return TRUE;
    case WM_COMMAND:
	switch (LOWORD(wParam)) {
	case IDOK:
            EndDialog(hW, 0);
            return TRUE;
	}
        break;
    }
    return FALSE;
}

static BOOL CALLBACK InfosDlgProc(HWND hW, UINT uMsg, WPARAM wParam, LPARAM lParam) {
    RECT r;
    POINT p;
    int bwidth, bheight, wsize;
    HWND button;

    switch (uMsg) {
    case WM_INITDIALOG:
        translate(IDD_INFOS, hW);

        button = GetDlgItem(hW, IDOK);
        GetWindowRect(button, &r);
        p.x = r.left;
        p.y = r.top;
        ScreenToClient(hW, &p);
        bwidth = r.right - r.left;
        bheight = r.bottom - r.top;
        GetWindowRect(hW, &r);
        wsize = r.right - r.left;
        MoveWindow(button, wsize / 2 - bwidth / 2, p.y, bwidth, bheight, TRUE);
        if (have_info) {
            Input i("readme.txt");
            Buffer b(true);
            String s, t;
            i.copyto(&b);
            while (!b.IsClosed()) {
                b >> t;
                s += t + "\r\n";
            }
            SetDlgItemText(hW, IDC_INFOS, s.to_charp());
        }
        return TRUE;
    case WM_COMMAND:
	switch (LOWORD(wParam)) {
	case IDOK:
            EndDialog(hW, 0);
            return TRUE;
	}
        break;
    }
    return FALSE;
}

static void set_options_dlg(HWND hW) {
    int i, n;
    HWND control;
    String option_name;

    OPEN_PATCH_INI(false);

    ConfigFile cfg(config_file);

    option_name = cfg["options"][current_option];
    if (cfg[option_name]["type"] != "choices") {
        MessageBox(hW, GetString(VERBOSE_CFG_ERROR), GetString(MSGERROR), MB_OK | MB_ICONERROR);
        throw GeneralException(GetString(VERBOSE_CFG_ERROR));
    }
    n = cfg[option_name]["size"].to_int();
    option_variable = cfg[option_name]["variable"];

    SetDlgItemText(hW, IDC_ST_TITLE, cfg[option_name]["title"].to_charp());

    control = GetDlgItem(hW, IDC_OPTIONS);
    ComboBox_ResetContent(control);

    for (i = 0; i < n; i++) {
        ComboBox_AddString(control, cfg[option_name][i].to_charp());
    }
    ComboBox_SetCurSel(control, 0);

    delete config_file;
}

static BOOL CALLBACK OptionsDlgProc(HWND hW, UINT uMsg, WPARAM wParam, LPARAM lParam) {
    RECT r;
    POINT p;
    int bwidth, bheight, wsize;
    HWND button;

    switch (uMsg) {
    case WM_INITDIALOG:
        translate(IDD_OPTIONS, hW);

        if (options_cmds)
            delete options_cmds;

        options_cmds = new Buffer(true);

        button = GetDlgItem(hW, IDOK);
        GetWindowRect(button, &r);
        p.x = r.left;
        p.y = r.top;
        ScreenToClient(hW, &p);
        bwidth = r.right - r.left;
        bheight = r.bottom - r.top;
        GetWindowRect(hW, &r);
        wsize = r.right - r.left;
        MoveWindow(button, wsize / 2 - bwidth / 2, p.y, bwidth, bheight, TRUE);
        set_options_dlg(hW);
        return TRUE;
    case WM_COMMAND:
	switch (LOWORD(wParam)) {
	case IDOK:
            (*options_cmds) << option_variable + "=" + ComboBox_GetCurSel(GetDlgItem(hW, IDC_OPTIONS)) + "\n";
            if ((++current_option) == options) {
                EndDialog(hW, 0);
            } else {
                set_options_dlg(hW);
            }
            return TRUE;
	}
        break;
    }
    return FALSE;
}

static BOOL CALLBACK FileSelectDlgProc(HWND hW, UINT uMsg, WPARAM wParam, LPARAM lParam) {
    RECT r;
    POINT p;
    int bwidth, bheight, wsize;
    HWND button, control;

    switch (uMsg) {
    case WM_INITDIALOG:
        translate(IDD_FILESELECT, hW);
        
        control = GetDlgItem(hW, IDC_SOURCETYPE);
        ComboBox_ResetContent(control);

        ComboBox_AddString(control, GetString(ISOFILE));
        ComboBox_SetCurSel(control, 0);
        if (canprobe) {
            ComboBox_AddString(control, GetString(CDDRIVE));
            ComboBox_SetCurSel(control, 1);

            control = GetDlgItem(hW, IDC_DRIVE);

            std::vector<String> p;
            p = cdabstract::probe();

            for (std::vector<String>::iterator i = p.begin(); i != p.end(); i++) {
                ComboBox_AddString(control, i->to_charp());
            }
            ComboBox_SetCurSel(control, 0);
            fromdrive = true;
            ShowWindow(GetDlgItem(hW, IDC_DRIVE), SW_SHOW);
            ShowWindow(GetDlgItem(hW, IDC_SOURCE), SW_HIDE);
            ShowWindow(GetDlgItem(hW, IDC_SOURCE_SELECT), SW_HIDE);
        }

        button = GetDlgItem(hW, IDOK);
        GetWindowRect(button, &r);
        p.x = r.left;
        p.y = r.top;
        ScreenToClient(hW, &p);
        bwidth = r.right - r.left;
        bheight = r.bottom - r.top;
        GetWindowRect(hW, &r);
        wsize = r.right - r.left;
        MoveWindow(button, wsize / 2 - bwidth / 2, p.y, bwidth, bheight, TRUE);
        return TRUE;
    case WM_COMMAND:
	switch (LOWORD(wParam)) {
	case IDOK:
            if (Verify(hW))
                EndDialog(hW, 0);
            return TRUE;
        case IDCANCEL:
            EndDialog(hW, 0);
            quit = true;
            return TRUE;
        case IDC_ABOUT:
            DialogBox(0, MAKEINTRESOURCE(IDD_ABOUT),
                GetActiveWindow(), AboutDlgProc);
            return TRUE;
        case IDC_INFOS:
            DialogBox(0, MAKEINTRESOURCE(IDD_INFOS),
                GetActiveWindow(), InfosDlgProc);
            return TRUE;
        case IDC_OPTIONS:
            DialogBox(0, MAKEINTRESOURCE(IDD_OPTIONS),
                GetActiveWindow(), OptionsDlgProc);
            return TRUE;
        case IDC_SOURCETYPE:
            if (HIWORD(wParam) != CBN_SELCHANGE)
                return FALSE;
            if (ComboBox_GetCurSel(GetDlgItem(hW, IDC_SOURCETYPE))) {
                fromdrive = true;
                ShowWindow(GetDlgItem(hW, IDC_DRIVE), SW_SHOW);
                ShowWindow(GetDlgItem(hW, IDC_SOURCE), SW_HIDE);
                ShowWindow(GetDlgItem(hW, IDC_SOURCE_SELECT), SW_HIDE);
            } else {
                fromdrive = false;
                ShowWindow(GetDlgItem(hW, IDC_DRIVE), SW_HIDE);
                ShowWindow(GetDlgItem(hW, IDC_SOURCE), SW_SHOW);
                ShowWindow(GetDlgItem(hW, IDC_SOURCE_SELECT), SW_SHOW);
            }
            return TRUE;
        case IDC_SOURCE_SELECT:
            ChooseFile(hW, SOURCE_SELECT);
            return TRUE;
        case IDC_PATCH_SELECT:
            ChooseFile(hW, PATCH_SELECT);
            if (LoadPatch(hW)) {
                if (canprobe) {
                    EnableWindow(GetDlgItem(hW, IDC_SOURCETYPE), true);
                    EnableWindow(GetDlgItem(hW, IDC_ST_SOURCETYPE), true);
                }

                if (rebuild) {
                    EnableWindow(GetDlgItem(hW, IDC_ST_SOURCE), true);
                    EnableWindow(GetDlgItem(hW, IDC_DRIVE), true);
                    EnableWindow(GetDlgItem(hW, IDC_SOURCE), true);
                    EnableWindow(GetDlgItem(hW, IDC_SOURCE_SELECT), true);
                } else {
                    SetDlgItemText(hW, IDC_ST_DEST, GetString(ISOFILEPATCH));
                }

                EnableWindow(GetDlgItem(hW, IDC_ST_DEST), true);
                EnableWindow(GetDlgItem(hW, IDC_DEST), true);
                EnableWindow(GetDlgItem(hW, IDC_DEST_SELECT), true);

                EnableWindow(GetDlgItem(hW, IDC_PATCH), false);
                EnableWindow(GetDlgItem(hW, IDC_PATCH_SELECT), false);

                SetDlgItemText(hW, IDC_ST_PATCH_TITLE, title.to_charp());

                if (options)
                    EnableWindow(GetDlgItem(hW, IDC_OPTIONS), true);

                if (have_info)
                    EnableWindow(GetDlgItem(hW, IDC_INFOS), true);
            } else {
                SetDlgItemText(hW, IDC_PATCH, "");
            }
            return TRUE;
        case IDC_DEST_SELECT:
            ChooseFile(hW, DEST_SELECT);
            return TRUE;
	}
        break;
    }
    return FALSE;
}

static bool Verify(HWND hW) {
    char szB[260];

    GetDlgItemText(hW, IDC_DEST, szB, 259);
    if (!szB[0]) {
        MessageBox(hW, GetString(NO_DESTINATION), GetString(MSGERROR), MB_OK | MB_ICONERROR);
        return false;
    }
    dest = szB;

    GetDlgItemText(hW, IDC_PATCH, szB, 259);
    if (!szB[0]) {
        MessageBox(hW, GetString(NO_PATCH), GetString(MSGERROR), MB_OK | MB_ICONERROR);
        return false;
    }
    patch = szB;

    GetDlgItemText(hW, IDC_SOURCE, szB, 259);
    if (!szB[0] && !fromdrive) {
        MessageBox(hW, GetString(NO_SOURCE), GetString(MSGERROR), MB_OK | MB_ICONERROR);
        return false;
    }
    if (fromdrive) {
        GetDlgItemText(hW, IDC_DRIVE, szB, 259);
        source = String("cd:") + szB;
    } else {
        source = szB;
    }

    return true;
}

virtual int startup(void) throw (GeneralException) {
    verbosity = M_INFO;
    printm(M_BARE, "CD-Tool core (C) 2003-2005 Nicolas \"Pixel\" Noble\nCompiled the " __DATE__ " at " __TIME__ "\n\n");
    printm(M_BARE, "LuaPatch (C) 2003-2005 Nicolas \"Pixel\" Noble\nFront-end starting.\n");

    int lang;
    lang = GetUserDefaultLangID();
    langid = PRIMARYLANGID(lang);

    canprobe = cdabstract::canprobe();

    DialogBox(0, MAKEINTRESOURCE(IDD_FILESELECT),
           GetActiveWindow(), FileSelectDlgProc);

    if (quit)
        exit(0);

    Output * o;
    cdutils * cdutil;
    Handle * iso_r;
    Handle * iso_w = 0;
    isobuilder * b;

    if (rebuild) {
        iso_r = cdabstract::open_cd(source);
        b = new isobuilder(o = new Output(dest));
    } else {
        iso_r = new Input(source);
        iso_w = new Output(source, 0, 0);
    }

    cdutil = new cdutils(iso_r, iso_w);

    Lua * L = new Lua();
    L->open_base();
    L->open_math();
    L->open_string();
    L->open_table();
    L->open_dir();
    LuaInput::pushconstruct(L);
    LuaOutput::pushconstruct(L);
    LuaBuffer::pushconstruct(L);
    CD_PUSHSTATICS(L);
    Luapsx::pushstatics(L);
    L->push("print");
    L->push(myprint);
    L->settable(LUA_GLOBALSINDEX);
    Luabasecdtool::pushstatics(L);

    Luacdutils lcdutil(cdutil);
    L->push("cdutil");
    lcdutil.push(L);
    L->setvar();

    if (rebuild) {
        Luaisobuilder liso(b);
        L->push("iso");
        liso.push(L);
        L->setvar();
    }

    OPEN_PATCH_INI(false);

    ConfigFile cfg(config_file);
    Buffer cmd;

    if (options_cmds)
        L->load(options_cmds);
    L->load(&Input(cfg["patch"]["filename"]));
    cmd << cfg["patch"]["command"];
    L->load(&cmd);

    delete options_cmds;
    delete config_file;

    delete b;
    delete o;
    delete cdutil;
    delete iso_r;

    MessageBox(0, GetString(END_MSG), GetString(END_TITLE), MB_ICONINFORMATION | MB_OK);

    return 0;
}
CODE_ENDS

#if 0
    String message;
    char bleh[256];
    switch (uMsg) {
case 0x0000: message="WM_NULL"; break;
case 0x0001: message="WM_CREATE"; break;
case 0x0002: message="WM_DESTROY"; break;
case 0x0003: message="WM_MOVE"; break;
case 0x0005: message="WM_SIZE"; break;
case 0x0006: message="WM_ACTIVATE"; break;
case 0x0007: message="WM_SETFOCUS"; break;
case 0x0008: message="WM_KILLFOCUS"; break;
case 0x000A: message="WM_ENABLE"; break;
case 0x000B: message="WM_SETREDRAW"; break;
case 0x000C: message="WM_SETTEXT"; break;
case 0x000D: message="WM_GETTEXT"; break;
case 0x000E: message="WM_GETTEXTLENGTH"; break;
case 0x000F: message="WM_PAINT"; break;
case 0x0010: message="WM_CLOSE"; break;
case 0x0011: message="WM_QUERYENDSESSION"; break;
case 0x0013: message="WM_QUERYOPEN"; break;
case 0x0016: message="WM_ENDSESSION"; break;
case 0x0012: message="WM_QUIT"; break;
case 0x0014: message="WM_ERASEBKGND"; break;
case 0x0015: message="WM_SYSCOLORCHANGE"; break;
case 0x0018: message="WM_SHOWWINDOW"; break;
case 0x001A: message="WM_WININICHANGE"; break;
case 0x001B: message="WM_DEVMODECHANGE"; break;
case 0x001C: message="WM_ACTIVATEAPP"; break;
case 0x001D: message="WM_FONTCHANGE"; break;
case 0x001E: message="WM_TIMECHANGE"; break;
case 0x001F: message="WM_CANCELMODE"; break;
case 0x0020: message="WM_SETCURSOR"; break;
case 0x0021: message="WM_MOUSEACTIVATE"; break;
case 0x0022: message="WM_CHILDACTIVATE"; break;
case 0x0023: message="WM_QUEUESYNC"; break;
case 0x0024: message="WM_GETMINMAXINFO"; break;
case 0x0026: message="WM_PAINTICON"; break;
case 0x0027: message="WM_ICONERASEBKGND"; break;
case 0x0028: message="WM_NEXTDLGCTL"; break;
case 0x002A: message="WM_SPOOLERSTATUS"; break;
case 0x002B: message="WM_DRAWITEM"; break;
case 0x002C: message="WM_MEASUREITEM"; break;
case 0x002D: message="WM_DELETEITEM"; break;
case 0x002E: message="WM_VKEYTOITEM"; break;
case 0x002F: message="WM_CHARTOITEM"; break;
case 0x0030: message="WM_SETFONT"; break;
case 0x0031: message="WM_GETFONT"; break;
case 0x0032: message="WM_SETHOTKEY"; break;
case 0x0033: message="WM_GETHOTKEY"; break;
case 0x0037: message="WM_QUERYDRAGICON"; break;
case 0x0039: message="WM_COMPAREITEM"; break;
case 0x003D: message="WM_GETOBJECT"; break;
case 0x0041: message="WM_COMPACTING"; break;
case 0x0044: message="WM_COMMNOTIFY"; break;
case 0x0046: message="WM_WINDOWPOSCHANGING"; break;
case 0x0047: message="WM_WINDOWPOSCHANGED"; break;
case 0x0048: message="WM_POWER"; break;
case 0x004A: message="WM_COPYDATA"; break;
case 0x004B: message="WM_CANCELJOURNAL"; break;
case 0x004E: message="WM_NOTIFY"; break;
case 0x0050: message="WM_INPUTLANGCHANGEREQUEST"; break;
case 0x0051: message="WM_INPUTLANGCHANGE"; break;
case 0x0052: message="WM_TCARD"; break;
case 0x0053: message="WM_HELP"; break;
case 0x0054: message="WM_USERCHANGED"; break;
case 0x0055: message="WM_NOTIFYFORMAT"; break;
case 0x007B: message="WM_CONTEXTMENU"; break;
case 0x007C: message="WM_STYLECHANGING"; break;
case 0x007D: message="WM_STYLECHANGED"; break;
case 0x007E: message="WM_DISPLAYCHANGE"; break;
case 0x007F: message="WM_GETICON"; break;
case 0x0080: message="WM_SETICON"; break;
case 0x0081: message="WM_NCCREATE"; break;
case 0x0082: message="WM_NCDESTROY"; break;
case 0x0083: message="WM_NCCALCSIZE"; break;
case 0x0084: message="WM_NCHITTEST"; break;
case 0x0085: message="WM_NCPAINT"; break;
case 0x0086: message="WM_NCACTIVATE"; break;
case 0x0087: message="WM_GETDLGCODE"; break;
case 0x0088: message="WM_SYNCPAINT"; break;
case 0x00A0: message="WM_NCMOUSEMOVE"; break;
case 0x00A1: message="WM_NCLBUTTONDOWN"; break;
case 0x00A2: message="WM_NCLBUTTONUP"; break;
case 0x00A3: message="WM_NCLBUTTONDBLCLK"; break;
case 0x00A4: message="WM_NCRBUTTONDOWN"; break;
case 0x00A5: message="WM_NCRBUTTONUP"; break;
case 0x00A6: message="WM_NCRBUTTONDBLCLK"; break;
case 0x00A7: message="WM_NCMBUTTONDOWN"; break;
case 0x00A8: message="WM_NCMBUTTONUP"; break;
case 0x00A9: message="WM_NCMBUTTONDBLCLK"; break;
case 0x00AB: message="WM_NCXBUTTONDOWN"; break;
case 0x00AC: message="WM_NCXBUTTONUP"; break;
case 0x00AD: message="WM_NCXBUTTONDBLCLK"; break;
case 0x00FF: message="WM_INPUT"; break;
case 0x0100: message="WM_KEYFIRST"; break;
case 0x0101: message="WM_KEYUP"; break;
case 0x0102: message="WM_CHAR"; break;
case 0x0103: message="WM_DEADCHAR"; break;
case 0x0104: message="WM_SYSKEYDOWN"; break;
case 0x0105: message="WM_SYSKEYUP"; break;
case 0x0106: message="WM_SYSCHAR"; break;
case 0x0107: message="WM_SYSDEADCHAR"; break;
case 0x0109: message="WM_UNICHAR"; break;
case 0x0108: message="WM_KEYLAST"; break;
case 0x010D: message="WM_IME_STARTCOMPOSITION"; break;
case 0x010E: message="WM_IME_ENDCOMPOSITION"; break;
case 0x010F: message="WM_IME_COMPOSITION"; break;
case 0x0110: message="WM_INITDIALOG"; break;
case 0x0111: message="WM_COMMAND"; break;
case 0x0112: message="WM_SYSCOMMAND"; break;
case 0x0113: message="WM_TIMER"; break;
case 0x0114: message="WM_HSCROLL"; break;
case 0x0115: message="WM_VSCROLL"; break;
case 0x0116: message="WM_INITMENU"; break;
case 0x0117: message="WM_INITMENUPOPUP"; break;
case 0x011F: message="WM_MENUSELECT"; break;
case 0x0120: message="WM_MENUCHAR"; break;
case 0x0121: message="WM_ENTERIDLE"; break;
case 0x0122: message="WM_MENURBUTTONUP"; break;
case 0x0123: message="WM_MENUDRAG"; break;
case 0x0124: message="WM_MENUGETOBJECT"; break;
case 0x0125: message="WM_UNINITMENUPOPUP"; break;
case 0x0126: message="WM_MENUCOMMAND"; break;
case 0x0127: message="WM_CHANGEUISTATE"; break;
case 0x0128: message="WM_UPDATEUISTATE"; break;
case 0x0129: message="WM_QUERYUISTATE"; break;
default: message="Unknown"; break;
    }
    sprintf(bleh, " (0x%04x)\n", uMsg);
    message = "AboutDlgProc: uMsg = " + message + bleh;
    Base::printm(M_STATUS, message);
#endif