wdecust.c

开放源码的编译器open watcom 1.6.0版的源代码

/****************************************************************************
*
*                            Open Watcom Project
*
*    Portions Copyright (c) 1983-2002 Sybase, Inc. All Rights Reserved.
*
*  ========================================================================
*
*    This file contains Original Code and/or Modifications of Original
*    Code as defined in and that are subject to the Sybase Open Watcom
*    Public License version 1.0 (the 'License'). You may not use this file
*    except in compliance with the License. BY USING THIS FILE YOU AGREE TO
*    ALL TERMS AND CONDITIONS OF THE LICENSE. A copy of the License is
*    provided with the Original Code and Modifications, and is also
*    available at www.sybase.com/developer/opensource.
*
*    The Original Code and all software distributed under the License are
*    distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
*    EXPRESS OR IMPLIED, AND SYBASE AND ALL CONTRIBUTORS HEREBY DISCLAIM
*    ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF
*    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR
*    NON-INFRINGEMENT. Please see the License for the specific language
*    governing rights and limitations under the License.
*
*  ========================================================================
*
* Description:  WHEN YOU FIGURE OUT WHAT THIS FILE DOES, PLEASE
*               DESCRIBE IT HERE!
*
****************************************************************************/


#include <windows.h>
#include <win1632.h>
#include "wdecust.h"

#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include "wdemem.h"
#include "wdemain.h"
#include "wdefont.h"
#include "wdegetfn.h"
#include "wdegeted.h"
#include "wdelist.h"
#include "wdemsgbx.h"
#include "wdemsgs.gh"
#include "wdestat.h"
#include "wdedebug.h"
#include "wde_rc.h"
#include "jdlg.h"

/****************************************************************************/
/* macro definitions                                                        */
/****************************************************************************/
#define WDE_NUM_CUSTOMS  2
#define WDE_CHECK_WHICH(w) (((w<0)||(w>=WDE_NUM_CUSTOMS)) ?FALSE :TRUE)
#define WDE_PREVIEW_PAD  10

/****************************************************************************/
/* external function prototypes                                             */
/****************************************************************************/
extern BOOL WINEXPORT WdeSelectCustProc    ( HWND, UINT, WPARAM, LPARAM );
extern BOOL WINEXPORT WdeLoadCustProc      ( HWND, UINT, WPARAM, LPARAM );
extern HGLOBAL WINEXPORT WdeCustLOADRES    ( LPCSTR, LPCSTR );
extern BOOL    WINEXPORT WdeCustEDITRES    ( LPCSTR, LPCSTR );

/****************************************************************************/
/* static function prototypes                                               */
/****************************************************************************/
static BOOL WdeLoadMSCustomControls        ( WdeCustLib * );
static BOOL WdeLoadBorCustomControls       ( WdeCustLib * );
static WdeCustLib       *WdeAllocCustLib   ( void );
static WdeCustControl   *WdeAllocCustControl ( void );
static WdeCustControl   *WdeAllocCustControlFromWDECTLINFO ( WDECTLINFO *, BOOL );
static BOOL WdeCreateAndAddCustControl     ( WdeCustLib *, WdeCustInfoProc,
                                             WdeCustStyleProc,
                                             WdeCustFlagsProc );
static BOOL WdeAddBorControlsToCustLib     ( WdeCustLib *,
                                             WdeBorlandClassList * );
static void WdeAddCustControlToCustLib     ( WdeCustLib *,
                                             WdeCustControl * );
static BOOL WdeFreeCustLib                 ( WdeCustLib * );
static void WdeFreeCustLibControls         ( LIST ** );
static BOOL WdeFreeCustControl             ( WdeCustControl * );
static void WdeFindClassInCustLibControls  ( char *, LIST **, LIST * );
static void WdeFindClassInCustLib          ( char *, LIST **, WdeCustLib * );
static BOOL WdeQueryUnsafeMSLoad           ( void );
static BOOL WdeQueryAssumeMS               ( void );
static void WdeFreeSelectWinCBox           ( HWND );
static Bool WdeSetSelectWinCBox            ( HWND, WdeCustControl * );
static Bool WdeSetSelectWin                ( HWND );
static Bool WdeSetCurrentControl           ( HWND, int );
static Bool WdePreviewSelected             ( HWND );
static void WdeSetLoadCustInfo             ( HWND, WdeCustLib *);
static void WdeSetLoadCustInfoOrd          ( HWND hDlg );
static Bool WdeGetLoadCustInfo             ( HWND, WdeCustLib *);
static void WdeEnableNonStandardCustInfo   ( HWND, Bool, Bool );

/****************************************************************************/
/* extern variables                                                         */
/****************************************************************************/
extern char     *WdeCustOpenTitle;
extern char     *WdeCustFilter;

/****************************************************************************/
/* static variables                                                         */
/****************************************************************************/
static HFONT WdeSelectFont = NULL;

static LIST *WdeCustomLibList   = NULL;
static LIST *WdeLibList         = NULL;

static FARPROC  WdeCustLOADRESInst = NULL;
static FARPROC  WdeCustEDITRESInst = NULL;

WdeCurrCustControl WdeCurrControl[WDE_NUM_CUSTOMS]  =
{
    { NULL, 0 }
,   { NULL, 0 }
};

static uint_16 WdeSupportedBorBtnIDs [] =
{
#if 0
    1, 2, 3, 4, 5, 6, 7, 201, 901, 902, 903, 904, 998
,   WDE_PREVIEW_ID
#else
    WDE_PREVIEW_ID
#endif
};

#define NUM_BOR_BTNS (sizeof(WdeSupportedBorBtnIDs) / sizeof(uint_16))


Bool WdeIsBorBtnIDSupported ( uint_16 id )
{
    int i;

    for ( i=0; i<NUM_BOR_BTNS; i++) {
        if ( WdeSupportedBorBtnIDs[i] == id ) {
            return ( TRUE );
        }
    }

    return ( FALSE );
}

void WdeGetCurrentCustControl ( int which, WdeCustControl **control,
                                UINT *type )
{
    if ( !WDE_CHECK_WHICH(which) ) {
        WdeWriteTrail("WdeGetCurrentCustControl: bad which!");
        return;
    }
    *control = WdeCurrControl[which].control;
    *type    = WdeCurrControl[which].type;
}

Bool WdeIsCurrentCustControlSet( int which )
{
    if( WDE_CHECK_WHICH(which) ) {
        if( WdeCurrControl[which].control != NULL ) {
            return( TRUE );
        }
    }
    return( FALSE );
}

Bool WdeCustControlsLoaded( void )
{
    return( WdeCustomLibList != NULL );
}

Bool WdeSetCurrentCustControl( int which )
{
    int       ret;
    HINSTANCE inst;
    FARPROC   proc;

    if( WdeCustomLibList == NULL ) {
        WdeSetStatusByID( -1, WDE_NOCUSTLOADED );
        return ( TRUE );
    }

    if ( !WDE_CHECK_WHICH(which) ) {
        WdeWriteTrail("WdeSetCurrentCustControl: bad which!");
        return ( FALSE );
    }

    inst = WdeGetAppInstance();

    proc = MakeProcInstance ( (FARPROC) WdeSelectCustProc, inst );

    if ( proc == NULL ) {
        WdeWriteTrail("WdeSetCurrentCustomControl: MakeProcInstnce failed!");
        return ( FALSE );
    }

    ret = JDialogBoxParam( inst, "WdeSelectCustom", WdeGetMainWindowHandle(),
                           (DLGPROC) proc, (LPARAM) &which );

    FreeProcInstance( proc );

    /* if the window could not be created return FALSE */
    if ( ret == -1 ) {
        WdeWriteTrail("WdeSetCurrentCustomControl: "
                      "Could not create selection window!");
        return ( FALSE );
    }

    return ( TRUE );
}

Bool WdeLoadCustomLib ( Bool ms_lib, Bool load_only )
{
    char              *name;
    HINSTANCE          inst;
    WdeCustLib        *lib;
    BOOL               ret;
    WdeGetFileStruct   gf;

    gf.file_name = NULL;
    gf.title     = WdeCustOpenTitle;
    gf.filter    = WdeCustFilter;

    name = WdeGetOpenFileName ( &gf );

    if ( !name ) {
        return ( FALSE );
    }

    inst = LoadLibrary ( name );

    if ( inst <= HINSTANCE_ERROR ) {
        WdeWriteTrail("WdeLoadCustomLib: LoadLibrary call failed!");
        WdeMemFree ( name );
        return ( FALSE );
    }

    lib = WdeAllocCustLib ();
    if ( lib == NULL ) {
        WdeWriteTrail("WdeLoadCustomLib: WdeAllocCustLib failed!");
        WdeMemFree ( name );
        FreeLibrary ( inst );
        return ( FALSE );
    }

    lib->inst      = inst;
    lib->ms_lib    = ms_lib;
    lib->load_only = load_only;
    lib->file_name = name;

    if( load_only ) {
        WdeSetStatusByID( -1, WDE_LIBRARYLOADED );
        ret = TRUE;
    } else {
        if( ms_lib ) {
            ret = WdeLoadMSCustomControls( lib );
        } else {
            ret = WdeLoadBorCustomControls( lib );
        }
    }

    if ( !ret ) {
        WdeFreeCustLib ( lib );
        return ( FALSE );
    }

    if ( load_only ) {
        WdeInsertObject ( &WdeLibList, (void *) lib );
    } else {
        WdeInsertObject ( &WdeCustomLibList, (void *) lib );
    }

    return( TRUE );
}

BOOL WdeLoadMSCustomControls ( WdeCustLib *lib )
{
    WdeCustInfoProc  info_proc;
    WdeCustStyleProc style_proc;
    WdeCustFlagsProc flags_proc;
    HWND             dialog_owner;
    DLGPROC          proc_inst;
    HINSTANCE        app_inst;
    BOOL             ok;

    dialog_owner  = WdeGetMainWindowHandle();

    app_inst = WdeGetAppInstance();

    proc_inst = (DLGPROC) MakeProcInstance ( (FARPROC) WdeLoadCustProc,
                                             app_inst );

    ok = JDialogBoxParam( app_inst, "WdeLoadCustom", dialog_owner,
                          proc_inst, (LPARAM) lib );

    FreeProcInstance ( (FARPROC) proc_inst );

    if ( ok == -1 ) {
        WdeWriteTrail("WdeLoadMSCustomControls: Dialog not created!");
        return ( FALSE );
    }

    if ( !ok ) {
        return ( FALSE );
    }

    if ( !HIWORD((uint_32)lib->info_name) ) {
        if ( !WdeQueryUnsafeMSLoad () ) {
            WdeWriteTrail("WdeLoadMSCustomControls: "
                          "User aborted unsafe load!");
            return ( FALSE );
        }
    }

    info_proc = (WdeCustInfoProc)
        GetProcAddress ( lib->inst, lib->info_name );
    style_proc = ( WdeCustStyleProc )
        GetProcAddress ( lib->inst, lib->style_name );
    flags_proc = ( WdeCustFlagsProc )
        GetProcAddress ( lib->inst, lib->flags_name );

    if ( !info_proc || !style_proc || !flags_proc ) {
        WdeWriteTrail("WdeLoadMSCustomControls: "
                          "Could not get proc address of ordinal!");
        return ( FALSE );
    }

    if ( !WdeCreateAndAddCustControl ( lib, info_proc,
                                       style_proc, flags_proc ) ) {
        WdeWriteTrail("WdeLoadMSCustomControls: Control not added to list!");
        return ( FALSE );
    }

    WdeMemValidate ( lib );

    return ( TRUE );
}

BOOL WdeLoadBorCustomControls ( WdeCustLib *lib )
{
    WdeListClassesProc   list_proc;
    HGLOBAL              list_global;
    uint_8              *list_locked;
    uint_16              num_classes;
    WdeBorlandClassList *class_list;
    uint_32              class_list_size;

    /* touch unused var to get rid of warning */
    _wde_touch( lib );

    list_proc = (WdeListClassesProc) GetProcAddress(lib->inst, "ListClasses");

    if ( list_proc == NULL ) {
        if ( WdeQueryAssumeMS () ) {
            lib->ms_lib = TRUE;
            return ( WdeLoadMSCustomControls ( lib ) );
        } else {
            WdeWriteTrail("WdeLoadBorCustomControls: User aborted load!");
            return ( FALSE );
        }
    }

    if ( WdeCustLOADRESInst == NULL ) {
        WdeCustLOADRESInst = MakeProcInstance ( (FARPROC) WdeCustLOADRES,
                                                WdeGetAppInstance() );
    }

    if ( WdeCustEDITRESInst == NULL ) {
        WdeCustEDITRESInst = MakeProcInstance ( (FARPROC) WdeCustEDITRES,
                                                WdeGetAppInstance() );
    }

#if 0
    list_global = (*list_proc) ( "WdeMainClass", WDE_VERSION,
                                 (LPFNLOADRES) WdeCustLOADRES,
                                 (LPFNEDITRES) WdeCustEDITRES );
#else
    list_global = (*list_proc) ( "WdeMainClass", WDE_VERSION,
                                 (LPFNLOADRES) WdeCustLOADRESInst,
                                 (LPFNEDITRES) WdeCustEDITRESInst );
#endif

    if ( list_global == NULL ) {
        WdeWriteTrail("WdeLoadBorCustomControls: ListClasses returned NULL!");
        return ( FALSE );
    }

    list_locked = (uint_8 *) GlobalLock ( list_global );
    if ( list_locked == NULL ) {
        WdeWriteTrail("WdeLoadBorCustomControls: Could lock global memory!");
        GlobalFree( list_global );
        return ( FALSE );
    }

    num_classes = *((uint_16 *) list_locked);

    class_list_size = sizeof(WdeBorlandClassList) +
                      (num_classes-1) * sizeof(WdeBorlandCtlClass);

    class_list = ( WdeBorlandClassList *) WdeMemAlloc ( class_list_size );
    if ( class_list == NULL ) {
        WdeWriteTrail("WdeLoadBorCustomControls: class list alloc failed!");
        GlobalUnlock ( list_global );
        GlobalFree( list_global );
        return ( FALSE );
    }

    memcpy ( class_list, list_locked, class_list_size );

    lib->class_list = list_global;

    if ( !WdeAddBorControlsToCustLib ( lib, class_list ) ) {
        WdeWriteTrail("WdeLoadBorCustomControls: Add to CustLib failed!");
        WdeMemFree    ( class_list );
        GlobalUnlock ( list_global );
        GlobalFree   ( list_global );
        return ( FALSE );
    }

    WdeMemFree    ( class_list );
    GlobalUnlock ( list_global );

    WdeMemValidate ( lib );

    return ( TRUE );
}

BOOL WdeAddBorControlsToCustLib ( WdeCustLib *lib,
                                  WdeBorlandClassList *class_list )
{
    uint_16 num;

    for ( num=0; num < class_list->nClasses; num++) {
        if (!WdeCreateAndAddCustControl( lib,
                                         class_list->Classes[num].info_proc,
                                         class_list->Classes[num].style_proc,
                                         class_list->Classes[num].flags_proc)
                                          ) {
            WdeWriteTrail("WdeAddBorControlsToCustLib: "
                          "Control not added to list!");
            return ( FALSE );
        }
    }

    WdeMemValidate ( lib );

    return ( TRUE );
}

BOOL WdeCreateAndAddCustControl ( WdeCustLib *lib,
                                  WdeCustInfoProc  info_proc,
                                  WdeCustStyleProc style_proc,
                                  WdeCustFlagsProc flags_proc )
{
    HGLOBAL          info_global;
    uint_8          *info_locked;
    WdeCustControl  *control;

    if ( !lib || !info_proc || !style_proc || !flags_proc ) {