miniGui中创建多个子窗体及子窗体资源的回收

1.一个工程中只要一个消息循环检测就可
while(GetMessage(&Msg,hMainWnd))
{
TranslateMessage(&Msg);
DispatchMessage(&Msg)
}
MainWindowThreadCleanup(hMainWnd);


在MSG_CLOSE中的代码调用DestroyMainWindow(hWnd);
来销毁CreateMainWindow(&CreateInfo);的窗体，如果要退出整个工程，在
MSG_CLOSE中还要调用PostQuitMessage (hWnd);来是主消息循环退出，最后
调用MainWindowThreadCleanup(hMainWnd);来清理剩余资源


2.对于通过主循环界面弹出新增加的界面
1>如果是通过对话框模板 DLGTEMPLATE和 CTRLDATA来创建的，则对控件的一
些初始化可在过程回调函数的MSG_INITDIALOG中设置，设置完返回0,如果要
退出对应的模板只要在过程回调函数的MSG_CLOSE中调用EndDialog (hDlg, IDCANCEL);
并返回0就可
2>如果新弹出的对话框也是通过CreateMainWindow (&CreateInfo);创建的
则不需要在次调用
while(GetMessage(&Msg,hMainWnd))
{
TranslateMessage(&Msg);
DispatchMessage(&Msg)
}来循环读取消息，因为这个可以和主界面消息循环共用.这时窗体内的控件需要在
本窗体的过程回调函数中的MSG_CREATE中通过CreateWindow(TRL_STATIC, 
                            This_is_a_simple_static_control, 
                            WS_CHILD | SS_NOTIFY | SS_SIMPLE | WS_VISIBLE |    WS_BORDER,
                            IDC_STATIC1, 
                            10, 10, 180, 20, hWnd, 0);来创建,结束用break;
控件始化则可在MSG_INITDIALOG中设置。需要关闭对话框时，在MSG_CLOSE中调用
DestroyMainWindow(hWnd) 和 MainWindowCleanup(hWnd);来关闭窗体，结束返回0, 同时在 MSG_DESTROY中调用DestroyAllControls(hWnd)；来销毁控件资源,结束返回0;


实例：


#include <stdio.h>
#include <stdlib.h>
#include <string.h>


#include <minigui/common.h>
#include <minigui/minigui.h>
#include <minigui/gdi.h>
#include <minigui/window.h>
#include <minigui/control.h>


#define    IDC_DLGBUTTON          100
#define    IDC_CREATEBUTTON     101


#define    IDC_PROMPTINFO         200
#define    IDC_PROGRESS               201


#define    IDC_BUTTON                   300

//通过对话框模板 DLGTEMPLATE和 CTRLDATA来创建
DLGTEMPLATE DlgInitProgress=
{
    WS_BORDER | WS_CAPTION,
    WS_EX_NONE,
    120, 150, 400, 130,
    "initializing...",
    0, 0,
    3, NULL,
    0
};
CTRLDATA CtrlInitProgress[]=
{
    {
        "static",
        WS_VISIBLE | SS_SIMPLE,
        10, 10, 380, 16,
        IDC_PROMPTINFO,
        "initializing...",
        0
    },
    {
        CTRL_PROGRESSBAR,
        WS_VISIBLE,
        10, 40, 380, 20,
        IDC_PROGRESS,
        NULL,
        0
    },
    {
        "button",
        WS_TABSTOP | WS_VISIBLE | BS_DEFPUSHBUTTON,
        170, 70, 60, 25,
        IDOK,
        "sure",
        0
    }
};


static int
DialogBoxProc1 (HWND hDlg, int message, WPARAM wParam, LPARAM lParam)
{
    switch (message) {
    case MSG_INITDIALOG:
        return 1;


    case MSG_COMMAND:
        switch (wParam) {
        case IDOK:
        case IDCANCEL:
            EndDialog (hDlg, wParam);
            break;
        }
        break;
    case MSG_CLOSE:
        EndDialog (hDlg, IDCANCEL);
        return 0;
    }


    return DefaultDialogProc (hDlg, message, wParam, lParam);
}


static void testDialogBox1 (HWND hWnd)
{
    DlgInitProgress.controls = CtrlInitProgress;

    DialogBoxIndirectParam (&DlgInitProgress, hWnd, DialogBoxProc1, 0L);
}

//通过CreateMainWindow (&CreateInfo);创建

static HWND hMainWnd = HWND_INVALID;


static int ControlTestWinProc(HWND hWnd, int message, WPARAM wParam, LPARAM lParam)
{
    switch (message) {
        case MSG_CREATE:
            CreateWindow (CTRL_BUTTON,
                          "Push_Button",
                          WS_CHILD | BS_PUSHBUTTON | BS_CHECKED | WS_VISIBLE,
                          IDC_BUTTON,
                          10, 10, 80, 40, hWnd, 0);


            CreateWindow (CTRL_BUTTON,
                          "Multiple_Lines_Push_Button",
                          BS_PUSHBUTTON | BS_MULTLINE | WS_VISIBLE,
                          IDC_BUTTON + 1,
                          110, 10, 80, 40, hWnd, 0);


            CreateWindow (CTRL_BUTTON,
                          "Normal_check_box",
                          BS_CHECKBOX | BS_CHECKED | WS_VISIBLE,
                          IDC_BUTTON + 2,
                          220, 10, 150, 40, hWnd, 0);


        break;


        case MSG_COMMAND:
        {
            if (wParam == IDCANCEL) {
                PostMessage (hWnd, MSG_CLOSE, 0, 0);
            }
        }
        break;


        case MSG_DESTROY:
            DestroyAllControls (hWnd);
            hMainWnd = HWND_INVALID;
        return 0;


        case MSG_CLOSE:
            DestroyMainWindow (hWnd);
            MainWindowCleanup (hWnd);
            return 0;
    }


    return DefaultMainWinProc (hWnd, message, wParam, lParam);
}



static void InitCreateInfo2(PMAINWINCREATE pCreateInfo)
{
    pCreateInfo->dwStyle = WS_CAPTION | WS_BORDER | WS_VISIBLE;
    pCreateInfo->dwExStyle = WS_EX_NONE;
    pCreateInfo->spCaption = "Button_controls";
    pCreateInfo->hMenu = 0;
    pCreateInfo->hCursor = GetSystemCursor(1);
    pCreateInfo->hIcon = 0;
    pCreateInfo->MainWindowProc = ControlTestWinProc;
    pCreateInfo->lx = 0;
    pCreateInfo->ty = 0;
    pCreateInfo->rx = 520;
    pCreateInfo->by = 350;
    pCreateInfo->iBkColor = GetWindowElementColor (WE_MAINC_THREED_BODY);
    pCreateInfo->dwAddData = 0;
    pCreateInfo->hHosting = HWND_DESKTOP;
}


void button_demo (HWND hwnd)
{
    MAINWINCREATE CreateInfo;


    if (hMainWnd != HWND_INVALID) {
        ShowWindow (hMainWnd, SW_SHOWNORMAL);
        return;
    }


    InitCreateInfo2 (&CreateInfo);
    CreateInfo.hHosting = hwnd;


    hMainWnd = CreateMainWindow (&CreateInfo);
}


//主循环窗体过程回调函数
int DialogTestMainWinProc (HWND hWnd, int message, WPARAM wParam, LPARAM lParam)
{
    switch (message) {
        case MSG_CREATE:
            CreateWindow (CTRL_BUTTON,
                          "打开 DLGTEMPLATE界面",
                          WS_CHILD | BS_PUSHBUTTON | WS_VISIBLE | BS_CHECKED,
                          IDC_DLGBUTTON,
                          20, 120, 230, 30, hWnd, 0);


            CreateWindow (CTRL_BUTTON,
                          "打开 CreateWindow界面",
                          WS_CHILD | BS_PUSHBUTTON | WS_VISIBLE | BS_CHECKED,
                          IDC_CREATEBUTTON,
                          20, 170, 230, 30, hWnd, 0);
        break;


        case MSG_COMMAND:
        switch (wParam)
        {
        case IDC_DLGBUTTON:
            testDialogBox1 (hWnd);
            break;
        case IDC_CREATEBUTTON:
            button_demo (hWnd);
            break;
        }
        break;
        case MSG_DESTROY:
            DestroyAllControls(hWnd);
            return 0;


        case MSG_CLOSE:
            if (MessageBox (hWnd, "Are_you_sure_to_quit", "DlgTest",
                            MB_YESNOCANCEL | MB_ICONQUESTION |
                            MB_BASEDONPARENT) != IDYES)
                return 0;


            DestroyMainWindow (hWnd);
            PostQuitMessage (hWnd);
        return 0;
    }


    return DefaultMainWinProc (hWnd, message, wParam, lParam);
}


static void InitCreateInfo (PMAINWINCREATE pCreateInfo)
{
    pCreateInfo->dwStyle = WS_CAPTION | WS_BORDER  | WS_MINIMIZEBOX | WS_MAXIMIZEBOX;
    pCreateInfo->dwExStyle = WS_EX_NONE | WS_EX_USEPRIVATECDC;
    pCreateInfo->spCaption = "main widget";
    pCreateInfo->hMenu =  0;
    pCreateInfo->hCursor = GetSystemCursor (IDC_ARROW);
    pCreateInfo->hIcon = 0;
    pCreateInfo->MainWindowProc = DialogTestMainWinProc;
    pCreateInfo->lx = 0;
    pCreateInfo->ty = 0;
    pCreateInfo->rx = 500;
    pCreateInfo->by = 400;
    pCreateInfo->iBkColor = COLOR_lightwhite;
    pCreateInfo->dwAddData = 0;
    pCreateInfo->hHosting = HWND_DESKTOP;
}

//主函数入口
//BITMAP bmp_bkgnd;
int MiniGUIMain (int args, const char* arg[])
{
    MSG Msg;
    MAINWINCREATE CreateInfo;
    HWND hMainWnd;


#ifdef _MGRM_PROCESSES
    int i;
    const char* layer = NULL;


    for (i = 1; i < args; i++) {
        if (strcmp (arg[i], "-layer") == 0) {
            layer = arg[i + 1];
            break;
        }
    }


    GetLayerInfo (layer, NULL, NULL, NULL);


    if (JoinLayer (layer, arg[0], 0, 0 ) == INV_LAYER_HANDLE) {
        printf ("JoinLayer: invalid layer handle.\n");
        exit (1);
    }
#endif
//    if (LoadBitmap (HDC_SCREEN, &bmp_bkgnd, "./bkgnd.jpg"))
//        return 1;


    //MGPlusRegisterFashionLFRDR();
    if(args > 1)
        SetDefaultWindowElementRenderer(arg[1]);


    InitCreateInfo (&CreateInfo);


    hMainWnd = CreateMainWindow (&CreateInfo);
    if (hMainWnd == HWND_INVALID)
        return -1;


    ShowWindow (hMainWnd, SW_SHOWNORMAL);


    while( GetMessage (&Msg, hMainWnd) ) {
        TranslateMessage (&Msg);
        DispatchMessage (&Msg);
    }


    MainWindowThreadCleanup (hMainWnd);
//    UnloadBitmap (&bmp_bkgnd);




    return 0;
}


#ifdef _MGRM_THREADS
#include <minigui/dti.c>
#endif




//Makefile

helloworld:miniguiHelloWorld.o
gcc -o helloworld  miniguiHelloWorld.c -L/usr/local/lib -lminigui_ths -lpng -ldl -lm -lpthread -ljpeg
clean:
rm helloworld miniguiHelloWorld.o