dialog.c

在ｅｃｏｓ 下mingui 的移植开发

// $Id: dialog.c,v 1.6 2000/11/20 05:46:45 ymwei Exp $
//
// dialog.c: The Dialog module.
//
// Copyright (c) 1999, Wei Yongming.
//
// Current maintainer: Wei Yongming.

/*
**  This library is free software; you can redistribute it and/or
**  modify it under the terms of the GNU Library General Public
**  License as published by the Free Software Foundation; either
**  version 2 of the License, or (at your option) any later version.
**
**  This library 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
**  Library General Public License for more details.
**
**  You should have received a copy of the GNU Library General Public
**  License along with this library; if not, write to the Free
**  Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
**  MA 02111-1307, USA
*/

//
// Create date: 1999.09.10
//
// Modify records:
//
//  Who             When        Where       For What                Status
//-----------------------------------------------------------------------------
//
// TODO:
// 

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


#include "common.h"
#include "minigui.h"
#include "gdi.h"
#include "window.h"
#include "control.h"

#include "cliprect.h"
#include "gal.h"
#include "internals.h"
#include "ctrlclass.h"

#ifndef lint
static char fileid[] = "$Id: dialog.c,v 1.6 2000/11/20 05:46:45 ymwei Exp $";
#endif

void GUIAPI DestroyAllControls (HWND hDlg)
{
    PMAINWIN pDlg = (PMAINWIN)hDlg;
    PCONTROL pCtrl = (PCONTROL)(pDlg->hFirstChild);
    PCONTROL pNext;

    while (pCtrl) {
        pNext = pCtrl->next;
        DestroyWindow ((HWND)pCtrl);
        pCtrl = pNext;
    }
}

#define dlgDestroyAllControls   DestroyAllControls

HWND GUIAPI CreateMainWindowIndirect (PDLGTEMPLATE pDlgTemplate, 
                    HWND hOwner, WNDPROC WndProc)
{
    MAINWINCREATE CreateInfo;
    HWND hMainWin;
    int i;
    PCTRLDATA pCtrlData;
    HWND hCtrl;

    if (!pDlgTemplate->controls)
        return HWND_INVALID;

    CreateInfo.dwStyle        = pDlgTemplate->dwStyle & ~WS_VISIBLE;
    CreateInfo.dwExStyle      = pDlgTemplate->dwExStyle;
    CreateInfo.spCaption      = pDlgTemplate->caption;
    CreateInfo.hMenu          = pDlgTemplate->hMenu;
    CreateInfo.hCursor        = GetSystemCursor (IDC_ARROW);
    CreateInfo.hIcon          = pDlgTemplate->hIcon;
    CreateInfo.MainWindowProc = WndProc ? WndProc : DefaultMainWinProc;
    CreateInfo.lx             = pDlgTemplate->x;
    CreateInfo.ty             = pDlgTemplate->y;
    CreateInfo.rx             = pDlgTemplate->x + pDlgTemplate->w;
    CreateInfo.by             = pDlgTemplate->y + pDlgTemplate->h;
    CreateInfo.iBkColor       = PIXEL_lightgray;
    CreateInfo.dwAddData      = pDlgTemplate->dwAddData;
    CreateInfo.hHosting       = hOwner;
    
    hMainWin = CreateMainWindow (&CreateInfo);
    if (hMainWin == HWND_INVALID)
        return HWND_INVALID;

    for (i = 0; i < pDlgTemplate->controlnr; i++) {
        pCtrlData = pDlgTemplate->controls + i;
        hCtrl = CreateWindowEx (pCtrlData->class_name,
                              pCtrlData->caption,
                              pCtrlData->dwStyle | WS_CHILD,
                              pCtrlData->dwExStyle,
                              pCtrlData->id,
                              pCtrlData->x,
                              pCtrlData->y,
                              pCtrlData->w,
                              pCtrlData->h,
                              hMainWin,
                              pCtrlData->dwAddData);
                              
        if (hCtrl == HWND_INVALID) {
            dlgDestroyAllControls (hMainWin);
            DestroyMainWindow (hMainWin);
            MainWindowThreadCleanup (hMainWin);
            return HWND_INVALID;
        }
    }

    ShowWindow (hMainWin, SW_SHOWNORMAL);
    
    return hMainWin;
}

BOOL GUIAPI DestroyMainWindowIndirect (HWND hMainWin)
{
    dlgDestroyAllControls (hMainWin);
    DestroyMainWindow (hMainWin);
    ThrowAwayMessages (hMainWin);
    MainWindowThreadCleanup (hMainWin);

    return TRUE;
}

int GUIAPI DialogBoxIndirectParam (PDLGTEMPLATE pDlgTemplate, 
                    HWND hOwner, WNDPROC DlgProc, LPARAM lParam)
{
    MAINWINCREATE CreateInfo;
    HWND hDlg;
    int  retCode = IDCANCEL;
    HWND hFocus;
    MSG Msg;

    if (!pDlgTemplate->controls)
        return -1;

    pDlgTemplate->dwAddData = (DWORD)(&retCode);
    
    CreateInfo.dwStyle        = pDlgTemplate->dwStyle & ~WS_VISIBLE;
    CreateInfo.dwExStyle      = pDlgTemplate->dwExStyle;
    CreateInfo.spCaption      = pDlgTemplate->caption;
    CreateInfo.hMenu          = pDlgTemplate->hMenu;
    CreateInfo.hCursor        = GetSystemCursor (IDC_ARROW);
    CreateInfo.hIcon          = pDlgTemplate->hIcon;
    CreateInfo.MainWindowProc = DlgProc;
    CreateInfo.lx             = pDlgTemplate->x;
    CreateInfo.ty             = pDlgTemplate->y;
    CreateInfo.rx             = pDlgTemplate->x + pDlgTemplate->w;
    CreateInfo.by             = pDlgTemplate->y + pDlgTemplate->h;
    CreateInfo.iBkColor       = PIXEL_lightgray;
    CreateInfo.dwAddData      = (DWORD)pDlgTemplate;
    CreateInfo.hHosting       = hOwner;
    
    hDlg = CreateMainWindow (&CreateInfo);
    if (hDlg == HWND_INVALID)
        return -1;

    if (hOwner)
        EnableWindow (hOwner, FALSE);
    
    hFocus = GetNextDlgTabItem (hDlg, (HWND)0, FALSE);
    if (SendMessage (hDlg, MSG_INITDIALOG, hFocus, lParam)) {
        if (hFocus)
            SetFocus (hFocus);
    }
    
    ShowWindow (hDlg, SW_SHOWNORMAL);
    
    while( GetMessage (&Msg, hDlg) ) {
        TranslateMessage (&Msg);
        DispatchMessage (&Msg);
    }

    dlgDestroyAllControls (hDlg);
    DestroyMainWindow (hDlg);
    ThrowAwayMessages (hDlg);
    MainWindowThreadCleanup (hDlg);
    
    if (hOwner) {
        EnableWindow (hOwner, TRUE);
        ShowWindow (hOwner, SW_SHOWNORMAL);
    }

    return retCode;
}

BOOL GUIAPI EndDialog (HWND hDlg, int endCode)
{
    DWORD dwAddData;
    PDLGTEMPLATE pDlgTmpl; 

    dwAddData = GetWindowAdditionalData (hDlg);

    if (dwAddData == 0)
        return FALSE;

    pDlgTmpl = (PDLGTEMPLATE)dwAddData;

    *((int *)(pDlgTmpl->dwAddData)) = endCode;

    PostQuitMessage (hDlg);

    return TRUE;
}

int DefaultDialogProc (HWND hWnd, int message, WPARAM wParam, LPARAM lParam)
{
    switch (message) {
    case MSG_CREATE:
    {
        int i;
        PCTRLDATA pCtrlData;
        HWND hCtrl;
            
        PDLGTEMPLATE pDlgTmpl 
                    = (PDLGTEMPLATE)(((PMAINWINCREATE)lParam)->dwAddData);
            
        for (i = 0; i < pDlgTmpl->controlnr; i++) {
            pCtrlData = pDlgTmpl->controls + i;
            hCtrl = CreateWindowEx (pCtrlData->class_name,
                              pCtrlData->caption,
                              pCtrlData->dwStyle | WS_CHILD,
                              pCtrlData->dwExStyle,
                              pCtrlData->id,
                              pCtrlData->x,
                              pCtrlData->y,
                              pCtrlData->w,
                              pCtrlData->h,
                              hWnd,
                              pCtrlData->dwAddData);
                              
            if (hCtrl == HWND_INVALID) {
                dlgDestroyAllControls (hWnd);
                return -1;
            }
        }

        return 0;
    }

    case MSG_DLG_GETDEFID:
    {
        HWND hDef;

        hDef = GetDlgDefPushButton (hWnd);
        if (hDef)
            return GetDlgCtrlID (hDef);
        return 0;
    }
    
    case MSG_DLG_SETDEFID:
    {
        HWND hOldDef;
        HWND hNewDef;

        hNewDef = GetDlgItem (hWnd, wParam);
        if (SendMessage (hNewDef, MSG_GETDLGCODE, 0, 0L) & DLGC_PUSHBUTTON) {
            hOldDef = GetDlgDefPushButton (hWnd);
            if (hOldDef) {
                ExcludeWindowStyle (hOldDef, BS_DEFPUSHBUTTON);
                InvalidateRect (hOldDef, NULL, TRUE);
            }
            IncludeWindowStyle (hNewDef, BS_DEFPUSHBUTTON);
            InvalidateRect (hNewDef, NULL, TRUE);

            return (int)hOldDef;
        }
        break;
    }
        
    case MSG_KEYDOWN:
        switch (LOWORD (wParam)) {
        case SCANCODE_ENTER:
        {
            HWND hDef;
            hDef = GetDlgDefPushButton (hWnd);
            if (hDef)
                SendMessage (hWnd, MSG_COMMAND, GetDlgCtrlID (hDef), 0L);
            break;
        }

        case SCANCODE_ESCAPE:
            SendMessage (hWnd, MSG_COMMAND, IDCANCEL, 0L);
            break;

        case SCANCODE_TAB:
        {
            HWND hNewFocus;
            HWND hCurFocus;
                
            hCurFocus = GetFocusChild (hWnd);
            if (hCurFocus) {
                if (SendMessage (hCurFocus, MSG_GETDLGCODE, 0, 0L) 
                        & DLGC_WANTTAB)
                    break;
            }

            if (lParam & KS_SHIFT)
                hNewFocus = GetNextDlgTabItem (hWnd, hCurFocus, TRUE);
            else
                hNewFocus = GetNextDlgTabItem (hWnd, hCurFocus, FALSE);

            if (hNewFocus != hCurFocus) {
                SetFocus (hNewFocus);
                SendMessage (hWnd, 
                    MSG_DLG_SETDEFID, GetDlgCtrlID (hNewFocus), 0L);
            }

            return 0;
        }

        case SCANCODE_CURSORBLOCKDOWN:
        case SCANCODE_CURSORBLOCKRIGHT:
        case SCANCODE_CURSORBLOCKUP:
        case SCANCODE_CURSORBLOCKLEFT:
        {
            HWND hNewFocus;
            HWND hCurFocus;
                
            hCurFocus = GetFocusChild (hWnd);
            if (hCurFocus) {
                if (SendMessage (hCurFocus, MSG_GETDLGCODE, 0, 0L) 
                        & DLGC_WANTARROWS)
                    break;
            }

            if (LOWORD (wParam) == SCANCODE_CURSORBLOCKDOWN
                    || LOWORD (wParam) == SCANCODE_CURSORBLOCKRIGHT)
                hNewFocus = GetNextDlgGroupItem (hWnd, hCurFocus, FALSE);
            else
                hNewFocus = GetNextDlgGroupItem (hWnd, hCurFocus, TRUE);
            
            if (hNewFocus != hCurFocus) {
                if (SendMessage (hCurFocus, MSG_GETDLGCODE, 0, 0L) 
                        & DLGC_STATIC)
                    return 0;

                SetFocus (hNewFocus);
                SendMessage (hWnd, 
                    MSG_DLG_SETDEFID, GetDlgCtrlID (hNewFocus), 0L);

                if (SendMessage (hNewFocus, MSG_GETDLGCODE, 0, 0L)
                        & DLGC_RADIOBUTTON) {
                    SendMessage (hNewFocus, BM_CLICK, 0, 0L);
                    ExcludeWindowStyle (hCurFocus, WS_TABSTOP);
                    IncludeWindowStyle (hNewFocus, WS_TABSTOP);
                }
            }

            return 0;
        }
        break;
    }

    case MSG_CHAR:
    break;

    case MSG_COMMAND:
        if (wParam == IDCANCEL) {
            HWND hCancel;
            
            hCancel = GetDlgItem (hWnd, IDCANCEL);
            if (hCancel && IsWindowEnabled (hCancel) 
                    && IsWindowVisible (hCancel))
                EndDialog (hWnd, IDCANCEL);
            else
                Ping ();
        }
        break;

    case MSG_CLOSE:
    {
        HWND hCancel;
            
        hCancel = GetDlgItem (hWnd, IDCANCEL);

        if (hCancel && IsWindowEnabled (hCancel) 
                    && IsWindowVisible (hCancel))
            SendNotifyMessage (hWnd, MSG_COMMAND,
                        MAKELONG (IDCANCEL, BN_CLICKED), hCancel);
        else
            Ping ();

        return 0;
    }

    default:
        break;
    }
    
    return DefaultMainWinProc (hWnd, message, wParam, lParam);
}

int GetDlgCtrlID (HWND hwndCtl)
{
    PCONTROL pCtrl = (PCONTROL)hwndCtl;

    if (pCtrl) {
        return pCtrl->id;
    }

    return -1;
}

HWND GetDlgItem (HWND hDlg, int nIDDlgItem)
{
    PCONTROL pCtrl;
    PMAINWIN pMainWin = (PMAINWIN)hDlg;

    pCtrl = (PCONTROL)(pMainWin->hFirstChild);

    while (pCtrl) {
        if (pCtrl->id == nIDDlgItem)
            return (HWND)pCtrl;

        pCtrl = pCtrl->next;
    }
   
    return 0;
}

HWND GUIAPI GetDlgDefPushButton (HWND hWnd)
{
    PCONTROL pCtrl;
    PMAINWIN pMainWin = (PMAINWIN)hWnd;

    pCtrl = (PCONTROL)(pMainWin->hFirstChild);

    while (pCtrl) {
        if (SendMessage ((HWND)pCtrl, 
                MSG_GETDLGCODE, 0, 0L) & DLGC_DEFPUSHBUTTON)
            return (HWND)pCtrl;

        pCtrl = pCtrl->next;
    }
   
    return 0;
}

HWND GetNextDlgGroupItem (HWND hDlg, HWND hCtl, BOOL bPrevious)
{
    PCONTROL pStartCtrl, pCtrl;
    PMAINWIN pMainWin = (PMAINWIN)hDlg;

    if (hCtl)
        pStartCtrl = (PCONTROL)hCtl;
    else {
        pStartCtrl = (PCONTROL)(pMainWin->hFirstChild);
        if (bPrevious) {
            while (pStartCtrl->next) {
                pStartCtrl = pStartCtrl->next;
            }
        }
    }

    if (bPrevious) {
        if (pStartCtrl->dwStyle & WS_GROUP) {
            pCtrl = pStartCtrl->next;
            while (pCtrl && pCtrl->next) {
                if (pCtrl->dwStyle & WS_GROUP)
                    break;
                pCtrl = pCtrl->next;
            }
        }
        else
            pCtrl = pStartCtrl;
        
        if (pCtrl->dwStyle & WS_GROUP || pCtrl == pStartCtrl)
            pCtrl = pCtrl->prev; 

        while (pCtrl) {
            if (pCtrl->dwStyle & WS_VISIBLE
                    && !(pCtrl->dwStyle & WS_DISABLED) )
                return (HWND)pCtrl;

            pCtrl = pCtrl->prev;
        }
    }
    else {
        pCtrl = pStartCtrl->next;
        while (pCtrl) {
            if ( !(pCtrl->dwStyle & WS_GROUP) ) {
                if (pCtrl->dwStyle & WS_VISIBLE
                        && !(pCtrl->dwStyle & WS_DISABLED) )
                    return (HWND)pCtrl;
            }
            else
                break;

            pCtrl = pCtrl->next;
        }
        
        pCtrl = pStartCtrl->prev;
        while (pCtrl) {