C++ 编译为.dll时菜单项不工作

我有一个奇怪的行为，当我使用JNI编译和运行时，我的代码无法调用事件处理程序，但如果我在VS2013中将其编译为.exe，它就可以工作

不起作用的列在case ID_KRUSKAL_defect、case ID_KRUSKAL_PERFECT、case ID_PRIM_defect、case ID_PRIM_PERFECT下。这种情况下，菜单的（见下图的插图）。右边应该会弹出另一个对话框

但是，当我单击case ID\u FILE\u EXIT时，窗口关闭（因此该按钮有效）

源代码见附件：
#包括
#包括
#包括
#包括
//#包括“resource.h”
#包括“maze.h”
#包括
#包括
#包括“HelloWorld.h”
#包括“win_main.h”
#包括“KruskalAlgo.h”
#包括“PrimAlgo.h”
//JNI
#包括
#包括
#包括“Window.h”
//win32 GUI ID
#定义IDR_菜单1 102
#定义IDI_图标103
#定义IDD_对话框1 105
#定义IDC_EDIT1 1005
#定义IDC_宽度1005
#定义IDC_EDIT2 1006
#定义IDC_EDIT3 1007
#定义IDC_WALLBUTTON 1008
#定义IDC_路径按钮1009
#定义IDC_EDIT4 1010
#定义IDC_高度1010
#定义ID\u STUFF\u GO 40001
#定义ID\u文件\u退出40002
#定义ID文件生成码40003
#定义ID\u文件\u上载4
#定义ID_GENERATEMAZE_KRUSKAL 40005
#定义ID_GENERATEMAZE_PRIM 40006
#定义ID_GENERATEMAZE_KRUSKAL40007 40007
#定义ID_GENERATEMAZE_PRIM40008 40008
#定义ID_generatemally_KRUSKAL 40009
#定义ID_generatemally_PRIM 40010
#定义ID_KRUSKAL_完美40011
#定义ID_KRUSKAL_40012
#定义ID_PRIM_PERFECT 40013
#定义ID_PRIM_40014
#定义ID_GENERATEMAZEAUTO 40015
//类名
LPCSTR g_szClassName=“mazeGenerator”；
//用于存储1和0的2d矢量
typedef std：：向量IntMatrix；
INT2D矩阵向量；
//函数头
虚空迷宫（HWND HWND）；
无效文件上传（HWND HWND）；
无效选择颜色（HWND HWND）；
//全球高度
int-inRowCount；
//全局宽度
int inColCount；
int disp；
PrimAlgo p；
PrimAlgo-pi；
克鲁斯卡拉戈；
克鲁斯卡拉戈基；
INT_PTR回调配置对话框（HWND HWND、UINT消息、WPARAM WPARAM、LPARAM LPARAM）
{
//HWND HWND组合框；
开关（信息）
{
案例WM_初始化对话框：
返回TRUE；
case WM_命令：
开关（LOWORD（wParam））
{
案例IDC_Wall按钮：
选择颜色（hwnd）；
打破
案例IDC_路径按钮：
选择颜色（hwnd）；
打破
案例IDOK：
inColCount=GetDlgItemInt（hwnd，IDC\u WIDTH，NULL，FALSE）；
inRowCount=GetDlgItem（hwnd、IDC\U高度、NULL、FALSE）；
EndDialog（hwnd，IDD_DIALOG1）；
打破
案例ID取消：
EndDialog（hwnd，IDD_DIALOG1）；
打破
违约：
返回FALSE；
}
违约：
返回FALSE；
}
返回TRUE；
}
//步骤4：窗口过程
LRESULT回调WndProc（HWND HWND，UINT msg，WPARAM WPARAM，LPARAM LPARAM）
{
HWND温度；
HINSTANCE htemp；
开关（msg）
{
案例WM_创建：
{
//初始化
HMENU-HMENU、hSubMenu1、hSubMenu2、hSubMenu3、hSubMenu4、hSubMenu5；
HICON HICON，hIconSm；
//菜单
humenu=CreateMenu（）；
hSubMenu1=CreatePopupMenu（）；
hSubMenu2=CreatePopupMenu（）；
hSubMenu3=CreatePopupMenu（）；
hSubMenu4=CreatePopupMenu（）；
hSubMenu5=CreatePopupMenu（）；
附录菜单（菜单、MF|U字符串| MF|U弹出菜单，（UINT）菜单1，“&File”）；
附录菜单（菜单1、菜单字符串、菜单弹出窗口、菜单2和新游戏）；
附录菜单（hSubMenu2，MF_字符串，ID_GENERATEMAZEAUTO，“&Generate Automatically”）；
附录菜单（hSubMenu2，MF|U字符串| MF|U弹出菜单，（UINT）hSubMenu3，“&手动生成”）；
附录菜单（hSubMenu3，MF|U字符串| MF|U弹出菜单，（UINT）hSubMenu4，“&Kruskal”）；
附录菜单（hSubMenu4，MF_字符串，ID_KRUSKAL_PERFECT，“&PERFECT”）；
附录菜单（hSubMenu4，MF_字符串，ID_KRUSKAL_不完美，&不完美）；
附录菜单（hSubMenu3，MF|U字符串| MF|U弹出菜单，（UINT）hSubMenu5，“&Prim”）；
附录菜单（hSubMenu5，MF_字符串，ID_KRUSKAL_PERFECT，“&PERFECT”）；
附录菜单（hSubMenu5，MF_字符串，ID_KRUSKAL_不完美，&不完美）；
附录菜单（hSubMenu1、MF_字符串、ID_文件_退出“&EXIT”）；
/*hSubMenu=CreatePopupMenu（）；
附录菜单（hSubMenu、MF_字符串、ID_STUFF_GO、&GO）；
附录菜单（菜单、菜单字符串、菜单弹出菜单、菜单子菜单和内容）*/
设置菜单（hwnd、hMenu）；
hIcon=（hIcon）LoadImage（NULL，“logo.ico”，IMAGE\u图标，32，32，LR\u LOADFROMFILE）；
如果（希肯）
发送消息（hwnd、WM_设置图标、图标大（LPARAM）图标）；
其他的
MessageBox（hwnd，“无法加载大图标！”，“错误”，MB_OK | MB_ICONERROR）；
hIconSm=（HICON）LoadImage（NULL，“logo.ico”，IMAGE\u图标，16,16，LR\u LOADFROMFILE）；
如果（hIconSm）
发送消息（hwnd、WM_设置图标、图标（LPARAM）hIconSm）；
其他的
MessageBox（hwnd，“无法加载小图标！”，“错误”，MB_OK | MB_ICONERROR）；
}
打破
案例WM_油漆：
{
绘图迷宫（hwnd）；
}
打破
case WM_命令：
开关（LOWORD（wParam））
{
案例ID\u文件\u退出：
PostMessage（hwnd，WM_CLOSE，0,0）；
打破
案例ID_GENERATEMAZEAUTO：
文件上传（hwnd）；
无效（hwnd，0，真）；
设置窗口位置（hwnd，0，0，（输入帐户*10）+17，（输入帐户*10）+60，SWP|u NOMOVE | SWP|u NOZORDER | SWP|u NOACTIVATE）；
打破
案例ID_PRIM_PERFECT:
disp=直径
Source code as attached :
#include <windows.h>
#include <iostream>
#include <string>
#include <fstream>
//#include "resource.h"
#include "maze.h"
#include <sstream>
#include <vector>
#include "HelloWorld.h"
#include "win_main.h"
#include "KruskalAlgo.h"
#include "PrimAlgo.h"

//JNI
#include <jni.h>
#include <stdio.h>
#include "Window.h"

//win32 GUI ID
#define IDR_MENU1                       102
#define IDI_ICON1                       103
#define IDD_DIALOG1                     105
#define IDC_EDIT1                       1005
#define IDC_WIDTH                       1005
#define IDC_EDIT2                       1006
#define IDC_EDIT3                       1007
#define IDC_WALLBUTTON                  1008
#define IDC_PATHBUTTON                  1009
#define IDC_EDIT4                       1010
#define IDC_HEIGHT                      1010
#define ID_STUFF_GO                     40001
#define ID_FILE_EXIT                    40002
#define ID_FILE_GENERATEMAZE            40003
#define ID_FILE_UPLOADMAZE              40004
#define ID_GENERATEMAZE_KRUSKAL         40005
#define ID_GENERATEMAZE_PRIM            40006
#define ID_GENERATEMAZE_KRUSKAL40007    40007
#define ID_GENERATEMAZE_PRIM40008       40008
#define ID_GENERATEMANUALLY_KRUSKAL     40009
#define ID_GENERATEMANUALLY_PRIM        40010
#define ID_KRUSKAL_PERFECT              40011
#define ID_KRUSKAL_IMPERFECT            40012
#define ID_PRIM_PERFECT                 40013
#define ID_PRIM_IMPERFECT               40014
#define ID_GENERATEMAZEAUTO             40015
//class name
LPCSTR g_szClassName = "mazeGenerator";

//2d vector to store 1s and 0s
typedef std::vector<std::vector<int>> IntMatrix;
IntMatrix vector2D;

//function header
void drawMaze(HWND hwnd);
void fileUpload(HWND hwnd);
void chooseColour(HWND hwnd);

//global height
int inRowCount;
//global width
int inColCount;

int disp;

PrimAlgo p;
PrimAlgo pi;
KruskalAlgo k;
KruskalAlgo ki;




INT_PTR CALLBACK ConfigDialog(HWND hwnd, UINT Message, WPARAM wParam, LPARAM lParam)
{

    //HWND hWndComboBox;
    switch (Message)
    {
    case WM_INITDIALOG:

        return TRUE;

    case WM_COMMAND:
        switch (LOWORD(wParam))
        {
        case IDC_WALLBUTTON:
            chooseColour(hwnd);
            break;

        case IDC_PATHBUTTON:
            chooseColour(hwnd);
            break;

        case IDOK:
            inColCount = GetDlgItemInt(hwnd, IDC_WIDTH, NULL, FALSE);
            inRowCount = GetDlgItemInt(hwnd, IDC_HEIGHT, NULL, FALSE);
            EndDialog(hwnd, IDD_DIALOG1);

            break;

        case IDCANCEL:
            EndDialog(hwnd, IDD_DIALOG1);
            break;
        default:
            return FALSE;
        }
    default:
        return FALSE;
    }
    return TRUE;
}

// Step 4: the Window Procedure
LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    HWND temp;
    HINSTANCE htemp;
    switch (msg)
    {
    case WM_CREATE:
    {
        //initialization
        HMENU hMenu, hSubMenu1, hSubMenu2, hSubMenu3, hSubMenu4, hSubMenu5;
        HICON hIcon, hIconSm;


        //menu
        hMenu = CreateMenu();
        hSubMenu1 = CreatePopupMenu();
        hSubMenu2 = CreatePopupMenu();
        hSubMenu3 = CreatePopupMenu();
        hSubMenu4 = CreatePopupMenu();
        hSubMenu5 = CreatePopupMenu();

        AppendMenu(hMenu, MF_STRING | MF_POPUP, (UINT)hSubMenu1, "&File");

        AppendMenu(hSubMenu1, MF_STRING | MF_POPUP, (UINT)hSubMenu2, "&New Game");

        AppendMenu(hSubMenu2, MF_STRING, ID_GENERATEMAZEAUTO, "&Generate Automatically");
        AppendMenu(hSubMenu2, MF_STRING | MF_POPUP, (UINT)hSubMenu3, "&Generate Manually");

        AppendMenu(hSubMenu3, MF_STRING | MF_POPUP, (UINT)hSubMenu4, "&Kruskal");

        AppendMenu(hSubMenu4, MF_STRING, ID_KRUSKAL_PERFECT, "&Perfect");
        AppendMenu(hSubMenu4, MF_STRING, ID_KRUSKAL_IMPERFECT, "&Imperfect");

        AppendMenu(hSubMenu3, MF_STRING | MF_POPUP, (UINT)hSubMenu5, "&Prim's");

        AppendMenu(hSubMenu5, MF_STRING, ID_KRUSKAL_PERFECT, "&Perfect");
        AppendMenu(hSubMenu5, MF_STRING, ID_KRUSKAL_IMPERFECT, "&Imperfect");



        AppendMenu(hSubMenu1, MF_STRING, ID_FILE_EXIT, "&Exit");



        /*hSubMenu = CreatePopupMenu();
        AppendMenu(hSubMenu, MF_STRING, ID_STUFF_GO, "&Go");
        AppendMenu(hMenu, MF_STRING | MF_POPUP, (UINT)hSubMenu, "&Stuff");*/

        SetMenu(hwnd, hMenu);


        hIcon = (HICON)LoadImage(NULL, "logo.ico", IMAGE_ICON, 32, 32, LR_LOADFROMFILE);
        if (hIcon)
            SendMessage(hwnd, WM_SETICON, ICON_BIG, (LPARAM)hIcon);
        else
            MessageBox(hwnd, "Could not load large icon!", "Error", MB_OK | MB_ICONERROR);

        hIconSm = (HICON)LoadImage(NULL, "logo.ico", IMAGE_ICON, 16, 16, LR_LOADFROMFILE);
        if (hIconSm)
            SendMessage(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)hIconSm);
        else
            MessageBox(hwnd, "Could not load small icon!", "Error", MB_OK | MB_ICONERROR);
    }

        break;
    case WM_PAINT:
    {
        drawMaze(hwnd);

    }
        break;


    case WM_COMMAND:
        switch (LOWORD(wParam))
        {
        case ID_FILE_EXIT:
            PostMessage(hwnd, WM_CLOSE, 0, 0);
            break;
        case ID_GENERATEMAZEAUTO:
            fileUpload(hwnd);
            InvalidateRect(hwnd, 0, TRUE);
            SetWindowPos(hwnd, 0, 0, 0, (inColCount * 10) + 17, (inRowCount * 10) + 60, SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
            break;
        case ID_PRIM_PERFECT:
            disp = DialogBox(GetModuleHandle(NULL), MAKEINTRESOURCE(IDD_DIALOG1), hwnd, ConfigDialog);

            p.setDimension(inRowCount, inColCount);
            p.setWallPath(0, 1);
            p.generateMaze();
            vector2D = p.get2DOutput();
            InvalidateRect(hwnd, 0, TRUE);
            SetWindowPos(hwnd, 0, 0, 0, (inColCount * 10) + 17, (inRowCount * 10) + 60, SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
            break;
        case ID_PRIM_IMPERFECT:
            disp = DialogBox(GetModuleHandle(NULL), MAKEINTRESOURCE(IDD_DIALOG1), hwnd, ConfigDialog);

            pi.setDimension(inRowCount, inColCount);
            pi.setWallPath(0, 1);
            pi.generateMaze();
            pi.generateImperfect();
            vector2D = pi.get2DOutput();
            InvalidateRect(hwnd, 0, TRUE);
            SetWindowPos(hwnd, 0, 0, 0, (inColCount * 10) + 17, (inRowCount * 10) + 60, SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
            break;
        case ID_KRUSKAL_PERFECT:
            disp = DialogBox(GetModuleHandle(NULL), MAKEINTRESOURCE(IDD_DIALOG1), hwnd, ConfigDialog);
            k.setDimension(inRowCount, inColCount);
            k.setWallPath(0, 1);
            k.generateMaze();
            vector2D = k.get2DOutput();
            InvalidateRect(hwnd, 0, TRUE);
            SetWindowPos(hwnd, 0, 0, 0, (inColCount * 10) + 17, (inRowCount * 10) + 60, SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);

            break;
        case ID_KRUSKAL_IMPERFECT:
            disp = DialogBox(GetModuleHandle(NULL), MAKEINTRESOURCE(IDD_DIALOG1), hwnd, ConfigDialog);

            ki.setDimension(inRowCount, inColCount);
            ki.setWallPath(0, 1);
            ki.generateMaze();
            ki.generateImperfect();
            vector2D = ki.get2DOutput();
            InvalidateRect(hwnd, 0, TRUE);
            SetWindowPos(hwnd, 0, 0, 0, (inColCount * 10) + 17, (inRowCount * 10) + 60, SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
            break;



        }


        break;
    case WM_CLOSE:
    {
        DestroyWindow(hwnd);
        break;
    }
    case WM_DESTROY:
    {

        PostQuitMessage(0);
        break;
    }
    default:
    {
        return DefWindowProc(hwnd, msg, wParam, lParam);
    }
    }
    return 0;
}


int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
    LPSTR lpCmdLine, int nCmdShow)
{
    WNDCLASSEX wc;
    HWND hwnd;
    MSG Msg;

    //Step 1: Registering the Window Class
    wc.cbSize = sizeof(WNDCLASSEX);
    wc.style = 0;
    wc.lpfnWndProc = WndProc;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hInstance = hInstance;
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    wc.lpszMenuName = MAKEINTRESOURCE(IDR_MENU1);
    wc.lpszClassName = g_szClassName;
    wc.hIcon = LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_ICON1));
    wc.hIconSm = (HICON)LoadImage(GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_ICON1), IMAGE_ICON, 16, 16, 0);

    if (!RegisterClassEx(&wc))
    {
        MessageBoxA(NULL, "Window Registration Failed!", "Error!",
            MB_ICONEXCLAMATION | MB_OK);
        return 0;
    }

    // Step 2: Creating the Window

    hwnd = CreateWindowEx(
        WS_EX_WINDOWEDGE,
        g_szClassName,
        "Maze Generator 0.1",
        WS_OVERLAPPEDWINDOW,
        0, 0, 300, 60,
        NULL, NULL, hInstance, NULL);

    if (hwnd == NULL)
    {
        MessageBoxA(NULL, "Window Creation Failed!", "Error!",
            MB_ICONEXCLAMATION | MB_OK);
        return 0;
    }

    ShowWindow(hwnd, nCmdShow);
    UpdateWindow(hwnd);

    // Step 3: The Message Loop
    while (GetMessage(&Msg, NULL, 0, 0) > 0)
    {
        TranslateMessage(&Msg);
        DispatchMessage(&Msg);
    }
    return Msg.wParam;
}

//draws maze based on vector2D
void chooseColour(HWND hwnd){
    CHOOSECOLOR cc;                 // common dialog box structure 
    static COLORREF acrCustClr[16]; // array of custom colors 
    HBRUSH hbrush;                  // brush handle
    static DWORD rgbCurrent;        // initial color selection
    ZeroMemory(&cc, sizeof(cc));
    cc.lStructSize = sizeof(cc);
    cc.hwndOwner = hwnd;
    cc.lpCustColors = (LPDWORD)acrCustClr;
    cc.rgbResult = rgbCurrent;
    cc.Flags = CC_FULLOPEN | CC_RGBINIT;

    if (ChooseColor(&cc) == TRUE)
    {
        hbrush = CreateSolidBrush(cc.rgbResult);
        rgbCurrent = cc.rgbResult;
    }
}
void drawMaze(HWND hwnd){
    RECT rcClient;
    GetClientRect(hwnd, &rcClient);
    PAINTSTRUCT ps;
    //starting x and y value for first maze cell
    int startRow = 0;
    int startCol = 0;
    //displacement
    int dRow = 10;
    int dCol = 10;
    //counter
    int rowCounter = 0;
    int colCounter = 0;

    HDC hdc = BeginPaint(hwnd, &ps);
    FillRect(hdc, &rcClient, (HBRUSH)GetStockObject(LTGRAY_BRUSH));
    for (int rowId = 0; rowId < inRowCount; rowId++){
        for (int colId = 0; colId < inColCount; colId++){
            if (vector2D[rowId][colId] == 1){
                RECT cell = { startCol, startRow, startCol + dCol, startRow + dRow };
                FillRect(hdc, &cell, (HBRUSH)GetStockObject(WHITE_BRUSH));

            }
            if (vector2D[rowId][colId] == 0){
                RECT cell = { startCol, startRow, startCol + dCol, startRow + dRow };
                FillRect(hdc, &cell, (HBRUSH)GetStockObject(BLACK_BRUSH));

            }
            startCol += dCol;
            colCounter++;
            if (colCounter == inColCount)
            {
                startCol = 0;
                colCounter = 0;
            }
        }
        startRow += dRow;
        rowCounter++;
        if (rowCounter == inRowCount)
        {
            startRow = 0;
            rowCounter = 0;
        }
    }
    EndPaint(hwnd, &ps);

}

void fileUpload(HWND hwnd){
    //file upload
    OPENFILENAME ofn;
    HANDLE hFile;
    DWORD dwRead;
    char filechar[20000] = "";
    int countMaze = 0;
    int countValue = 0;
    int x = 0;
    int y = 0;
    int tempx = 0;
    int tempy = 0;
    char szFileName[MAX_PATH] = "";

    ZeroMemory(&ofn, sizeof(ofn));

    ofn.lStructSize = sizeof(ofn); // SEE NOTE BELOW

    ofn.hwndOwner = hwnd;
    ofn.lpstrFilter = (LPCSTR)"Text Files (*.txt)\0*.txt\0All Files (*.*)\0*.*\0";
    ofn.lpstrFile = (LPSTR)szFileName;
    ofn.nMaxFile = MAX_PATH;
    ofn.Flags = OFN_EXPLORER | OFN_FILEMUSTEXIST | OFN_HIDEREADONLY;
    ofn.lpstrDefExt = (LPCSTR)"txt";

    if (GetOpenFileName(&ofn))
    {
        // Load the file name for maze drawing
        // Load the file name for maze drawing
        //MessageBox(hWnd, (LPCWSTR)szFileName, (LPCWSTR)L"Notice",MB_OK | MB_ICONINFORMATION);
        hFile = CreateFile((LPCSTR)szFileName, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
        ReadFile(hFile, filechar, sizeof(filechar), &dwRead, NULL);
        int status = 1;//to track invalid input detected in the readfile

        while (dwRead != countMaze)
        {
            char temp;

            //temp in ASCII value (convert to 0 and 1)
            temp = *&filechar[countMaze];
            if (temp != '\r' && temp != '\n' && temp != '0' && temp != '1')
            {
                status = 0;
                break;
            }

            if (temp == '\r')//For carriage return case.
            {
                countMaze = countMaze + 1;
                continue;
            }
            if (temp == '\n')//For newline case.
            {
                y = dwRead / (x + 2);
                break;
            }
            x = x + 1;
            countMaze = countMaze + 1;
        }


        //return the width and height needed to print maze.
        if (status == 1){
            inColCount = x;
            inRowCount = y;
            //resize maze based on x and y values.
            vector2D.resize(y);
            for (int i = 0; i < y; i++){
                vector2D[i].resize(x);
            }


            while (dwRead > countValue)
            {
                char temp;
                //temp in ASCII value
                temp = *&filechar[countValue];
                if (temp)

                    if (temp == '\r')//For carriage return case.
                    {
                    countValue++;
                    continue;
                    }
                if (temp == '\n')//For newline case.
                {
                    countValue++;
                    tempx++;
                    tempy = 0;
                    continue;
                }
                //minus 48 to convert from ascii value to integer
                vector2D[tempx][tempy] = int(temp - 48);
                tempy = tempy + 1;
                countValue++;
            }
        }
        else{
            MessageBox(hwnd, (LPCSTR)"Invalid maze file found ! Re-upload please with text file containing 0 and 1 only please", (LPCSTR)"Notice",
                MB_OK | MB_ICONINFORMATION);
        }
        if (status == 1){
            //close hFile handler
            CloseHandle(hFile);

        } 
    }


}


// Implementation of native method sayHello() of HelloJNI class
JNIEXPORT void JNICALL Java_Window_load(JNIEnv *env, jobject thisObj) {
    WinMain(0,0,0,1);
    printf("Hello World!\n");
    return;
}

static HINSTANCE sDllInstance;

BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) {
  if (fdwReason == DLL_PROCESS_ATTACH) { 
    sDllInstance = hinstDLL;
  }
  return TRUE;
}

// Implementation of native method sayHello() of HelloJNI class
JNIEXPORT void JNICALL Java_Window_load(JNIEnv *env, jobject thisObj) {
    WinMain(sDllInstance,0,0,1);
    printf("Hello World!\n");
    return;
}