dialog.c

linux下的图形界面开发minigui最新源代码

/*
** $Id: dialog.c,v 1.37 2003/09/04 03:15:07 weiym Exp $
**
** dialog.c: The Dialog module.
**
** Copyright (C) 2003 Feynman Software.
** Copyright (C) 1999 ~ 2002 Wei Yongming.
**
** Current maintainer: Wei Yongming.
**
** Create date: 1999.09.10
*/

/*
** 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
*/


#include <stdio.h>
#include <stdlib.h>
#include <string.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"

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 CreateMainWindowIndirectParam (PDLGTEMPLATE pDlgTemplate, 
                    HWND hOwner, WNDPROC WndProc, LPARAM lParam)
{
    MAINWINCREATE CreateInfo;
    HWND hMainWin;
    int i;
    PCTRLDATA pCtrlData;
    HWND hCtrl;
    HWND hFocus;

    if (!pDlgTemplate->controls)
        return HWND_INVALID;

    hOwner = GetMainWindowHandle (hOwner);

    CreateInfo.dwReserved     = pDlgTemplate->dwAddData;

    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       = GetWindowElementColor (BKC_DIALOG);
    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;
        }
    }

    hFocus = GetNextDlgTabItem (hMainWin, (HWND)0, FALSE);
    if (SendMessage (hMainWin, MSG_INITDIALOG, hFocus, lParam)) {
        if (hFocus)
            SetFocus (hFocus);
    }
    
    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;

    hOwner = GetMainWindowHandle (hOwner);

    CreateInfo.dwReserved = pDlgTemplate->dwAddData;
    
    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       = GetWindowElementColor (BKC_DIALOG);
    CreateInfo.dwAddData      = (DWORD)pDlgTemplate;
    CreateInfo.hHosting       = hOwner;
    
    hDlg = CreateMainWindow (&CreateInfo);
    if (hDlg == HWND_INVALID)
        return -1;

    SetWindowAdditionalData2 (hDlg, (DWORD)(&retCode));

    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);
        SetActiveWindow (hOwner);
    }

    return retCode;
}

BOOL GUIAPI EndDialog (HWND hDlg, int endCode)
{
    DWORD dwAddData2;

    dwAddData2 = GetWindowAdditionalData2 (hDlg);

    if (dwAddData2 == 0)
        return FALSE;

    *((int *)(dwAddData2)) = endCode;

    PostQuitMessage (hDlg);

    return TRUE;
}

int GUIAPI DefaultDialogProc (HWND hWnd, int message, WPARAM wParam, LPARAM lParam)
{
    HWND hCurFocus;

    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;
            if (pCtrlData->class_name)
                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);
            else
                break;
                              
            if (hCtrl == HWND_INVALID) {
                dlgDestroyAllControls (hWnd);
                return -1;
            }
        }

        /* set back dwAddData to be the value from dialog template */
        SetWindowAdditionalData (hWnd, pDlgTmpl->dwAddData);
        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_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))
            EndDialog (hWnd, IDCANCEL);
        else
            Ping ();

        return 0;
    }

    case MSG_KEYDOWN:
        if ((hCurFocus = GetFocusChild (hWnd)) 
                && SendMessage (hCurFocus, MSG_GETDLGCODE, 0, 0L) & DLGC_WANTALLKEYS)
            break;

        switch (wParam) {
        case SCANCODE_ESCAPE:
            SendMessage (hWnd, MSG_COMMAND, IDCANCEL, 0L);
            return 0;

        case SCANCODE_TAB:
        {
            HWND hNewFocus;
                
            if (hCurFocus && 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_ENTER:
        {
            HWND hDef;

            if (hCurFocus && SendMessage (hCurFocus, MSG_GETDLGCODE, 0, 0L) & DLGC_WANTENTER)
                break;

            if (SendMessage (hCurFocus, MSG_GETDLGCODE, 0, 0L) & DLGC_PUSHBUTTON)
                break;

            hDef = GetDlgDefPushButton (hWnd);
            if (hDef) {
                SendMessage (hWnd, MSG_COMMAND, GetDlgCtrlID (hDef), 0L);
                return 0;
            }
            break;
        }

        case SCANCODE_CURSORBLOCKDOWN:
        case SCANCODE_CURSORBLOCKRIGHT:
        case SCANCODE_CURSORBLOCKUP:
        case SCANCODE_CURSORBLOCKLEFT:
        {
            HWND hNewFocus;
                
            if (hCurFocus && 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;

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

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

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

    return -1;
}

HWND GUIAPI 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) {
            if (pCtrl->dwStyle & WS_GROUP) {
                if (pCtrl->dwStyle & WS_VISIBLE
                        && !(pCtrl->dwStyle & WS_DISABLED) )
                    return (HWND)pCtrl;
                else
                    break;
            }

            pCtrl = pCtrl->prev;
        }
        
        if (pCtrl) {        // pCtrl is the first control in group.
            pCtrl = pCtrl->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;
            }
        }
    }

    return hCtl;
}

HWND GUIAPI GetNextDlgTabItem (HWND hDlg, HWND hCtl, BOOL bPrevious)
{
    PCONTROL pFirstCtrl, pLastCtrl, pCtrl;
    PMAINWIN pMainWin = (PMAINWIN)hDlg;

    pFirstCtrl = pCtrl = (PCONTROL)(pMainWin->hFirstChild);
    if (!pCtrl) return hCtl;

    while (pCtrl->next) {
        pCtrl = pCtrl->next;
    }
    pLastCtrl = pCtrl;