wreres.c

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

            WREFreeRCString( text );
        }
        if( ret == IDYES ) {
            return( WRESaveResource( res_info, FALSE ) );
        } else if( ret == IDCANCEL ) {
            return( FALSE );
        }
    }

    return( TRUE );
}

Bool WRESaveResource( WREResInfo *res_info, Bool get_name )
{
    char                *fn;
    WREGetFileStruct    gf;
    int                 fn_offset;
    char                *win_title;
    int                 win_title_len;
    Bool                got_name;
    Bool                ok;

    fn_offset = 0;
    got_name = FALSE;

    ok = ( res_info && res_info->info );

    if( ok ) {
        ok = ( WRCountZeroLengthResources( res_info->info->dir ) == 0 );
        if( !ok ) {
            WREDisplayErrorMsg( WRE_UPDATEBEFORESAVE );
        }
    }

    if( ok ) {
        if( res_info->info->save_name ) {
            fn = res_info->info->save_name;
        } else {
            res_info->info->save_type = res_info->info->file_type;
            fn = WREStrDup( res_info->info->file_name );
            got_name = TRUE;
        }

        if( get_name || !fn || !*fn ) {
            gf.file_name = fn;
            gf.title     = WREResSaveTitle;
            gf.filter    = WREResFilter;
            gf.save_ext  = TRUE;
            fn           = WREGetSaveFileName( &gf );
            got_name     = TRUE;
            res_info->info->save_type = WR_DONT_KNOW;
        }

        ok = ( fn && *fn );
    }

    if( ok ) {
        if( got_name && res_info->info->save_name ) {
            WREMemFree( res_info->info->save_name );
        }
        res_info->info->save_name = fn;
        if( res_info->info->save_type == WR_DONT_KNOW ) {
            res_info->info->save_type =
                WRESelectFileType( fn, res_info->is32bit );
        }
        ok = ( res_info->info->save_type != WR_DONT_KNOW );
    }

    if( ok ) {
        if( WRIsHashTableDirty( res_info->symbol_table ) ) {
            if( res_info->symbol_file == NULL ) {
                res_info->symbol_file = WRECreateSymName( fn );
            }
        }
    }

    if( ok ) {
        WRECreateDLGInclude( &res_info->info->dir, res_info->symbol_file );
        ok = WRESaveResourceToFile( res_info );
        if( !ok ) {
            WREDisplayErrorMsg( WRE_SAVEFAILED );
        }
    }

    if( ok ) {
        if( get_name || WRIsHashTableDirty( res_info->symbol_table ) ) {
            ok = WRESaveSymbols( res_info->symbol_table, &res_info->symbol_file, get_name );
        }
    }

    if( ok ) {
        //fn_offset = WRFindFnOffset( fn );
        win_title_len = strlen( &(fn[fn_offset]) ) + 1;
        win_title_len += 15;
        win_title = (char *)WREMemAlloc( win_title_len );
        if( win_title != NULL ) {
            sprintf( win_title,"%s (%d)", &(fn[fn_offset]),
                                          0xffff & res_info->window_num );
            SendMessage( res_info->res_win, WM_SETTEXT, 0,
                         (LPARAM) (LPCSTR) win_title );
            WREMemFree( win_title );
        } else {
            SendMessage( res_info->res_win, WM_SETTEXT, 0,
                         (LPARAM) (LPCSTR) &(fn[fn_offset]) );
        }
    }

    return( ok );
}

Bool WRESaveResourceToFile( WREResInfo *res_info )
{
    Bool          ok;

    WRESetWaitCursor( TRUE );

    ok = ( res_info && res_info->info );

    if ( ok ) {
        ok = WRSaveResource( res_info->info, TRUE );
    }

    if ( ok ) {
        WRESetResModified( res_info, FALSE );
    }

    WRESetWaitCursor( FALSE );

    return( ok );
}

Bool WREQueryKillApp( Bool fatal_exit )
{
    LIST       *rlist;
    WREResInfo *info;
    Bool        kill_app;

    if( !WRENoInterface && WREResList ) {
        kill_app = TRUE;
        for ( rlist=WREResList; rlist && kill_app; rlist=ListNext(rlist) ) {
            info = (WREResInfo *) ListElement(rlist);
            kill_app = WREQuerySaveResOnDeleteRes( info, fatal_exit ) &&
                       WREQuerySaveSymOnDeleteRes( info, fatal_exit );
            kill_app = kill_app || fatal_exit;
        }
        if ( !fatal_exit && !kill_app ) {
            return ( FALSE );
        }
    }

    return ( TRUE );
}

void WREFreeResList ( void )
{
    LIST       *rlist;
    WREResInfo *info;
    HWND        frame;

    if ( WREResList ) {
        frame = WREGetMDIWindowHandle ();
        for ( rlist = WREResList; rlist; rlist = ListNext(rlist) ) {
            info = (WREResInfo *) ListElement(rlist);
            SendMessage ( frame, WM_MDIACTIVATE, (WPARAM) info->res_win, 0 );
            WREFreeResInfo ( info );
        }
        ListFree ( WREResList );
        WREResList = NULL;
        WRENumRes = 0;
    }
}

Bool WRERemoveResource ( WREResInfo *res_info )
{
    LIST *node;

    if ( WREResList == NULL ) {
        return ( FALSE );
    }

    if ( (node = ListFindElt(WREResList, res_info) ) != NULL ) {
        ListRemoveElt( &WREResList, (void *) ListElement(node) );
    } else {
        return ( FALSE );
    }

    WREFreeResInfo ( res_info );

    WREDecNumRes ();

    if( !WREGetNumRes() ) {
        WRESetCurrentRes( NULL );
    }

    return ( TRUE );
}

Bool WRECreateResourceWindow( WREResInfo *res_info )
{
    MDICREATESTRUCT     mdics;
    LRESULT             ret;
    HWND                win;
    Bool                ok;
    DWORD               style;
    int                 fn_offset;
    char                *title;
    char                *win_title;
    int                 win_title_len;

    _wre_touch(fn_offset);

    win_title = NULL;

    ok = ( res_info != NULL );

    if( ok ) {
        WREResCounter++;
        res_info->window_num = WREResCounter;
        WREIncNumRes();
        if( res_info->info->file_name ) {
            //perhaps I should make this an option
            //fn_offset = WRFindFnOffset( res_info->info->file_name );
            //title = &( res_info->info->file_name[fn_offset] );
            title = res_info->info->file_name;
        } else if( res_info->info->save_name ) {
            title = res_info->info->save_name;
        } else {
            title = WREResUntitled;
        }
        win_title_len = strlen( title ) + 1;
        win_title_len += 15;
        win_title = (char *)WREMemAlloc( win_title_len );
        if( win_title != NULL ) {
            sprintf( win_title,"%s (%d)", title,
                     0xffff & res_info->window_num );
            mdics.szTitle = win_title;
        } else {
            mdics.szTitle = title;
        }
        style = 0;
        if( ( WREGetNumRes() != 1 ) && WREIsCurrentMDIWindowZoomed() ) {
            style = WS_MAXIMIZE;
        }
        mdics.szClass = WREResClass;
        mdics.hOwner  = WREAppInst;
        mdics.x       = CW_USEDEFAULT;
        mdics.y       = CW_USEDEFAULT;
        mdics.cx      = CW_USEDEFAULT;
        mdics.cy      = CW_USEDEFAULT;
        mdics.style   = style;
        mdics.lParam  = (LPARAM) res_info;

        ret = SendMessage ( WREGetMDIWindowHandle(), WM_MDICREATE, 0,
                            (LPARAM) &mdics );
        ok = ( ret != NULL );
    }

    if( ok ) {
#ifdef __NT__
        win = (HWND) ret;
#else
        win = (HWND) LOWORD ( ret );
#endif
        ok = ( res_info->res_win && ( res_info->res_win == win ) );
    }

    if( ok ) {
        ok = WRECreateResInfoWindow( res_info );
    }

    if( ok ) {
        WResizeInfoWindow( res_info );
        ShowWindow( res_info->info_win, SW_SHOW );
        SetFocus( res_info->info_win );
    }

    if( win_title != NULL ) {
        WREMemFree( win_title );
    }

    return ( ok );
}

Bool WREDestroyResourceWindow ( WREResInfo *res_info )
{
    if( res_info && WREQuerySaveResOnDeleteRes( res_info, FALSE ) &&
        WREQuerySaveSymOnDeleteRes( res_info, FALSE ) ) {
        return( WRERemoveResource( res_info ) );
    }
    return( FALSE );
}

LRESULT WINEXPORT WREResWndProc( HWND hWnd, UINT message,
                                 WPARAM wParam, LPARAM lParam )
{
    WREResInfo  *res_info;
    int         msg_processed;
    LRESULT     ret;

    msg_processed = FALSE;
    ret           = FALSE;
    res_info      = NULL;

    switch( message ) {
        case WM_CREATE:
            res_info = (WREResInfo *) ((MDICREATESTRUCT *)
                           ((CREATESTRUCT *)lParam)->lpCreateParams)->lParam;
            res_info->res_win = hWnd;
            SetWindowLong( hWnd, 0, (LONG) res_info );
            break;
        case WM_SIZE:
        case WM_MDIACTIVATE:
        case WM_CLOSE:
        case WM_SETFOCUS:
            res_info = (WREResInfo *) GetWindowLong( hWnd, 0 );
            break;
        case WM_DESTROY:
            SetWindowLong( hWnd, 0, (LONG) NULL );
            break;
    }

    if( res_info ) {
        switch ( message ) {
            case WM_SETFOCUS:
                if( res_info->info_win != (HWND)NULL ) {
                    SetFocus( res_info->info_win );
                }
                break;
            case WM_SIZE:
                WResizeInfoWindow( res_info );
                break;

            case WM_MDIACTIVATE:
                WREActivateResourceWindow( res_info, wParam, lParam );
                break;

            case WM_CLOSE:
                WREEndResAccelSessions( res_info );
                WREEndResMenuSessions( res_info );
                WREEndResStringSessions( res_info );
                WREEndResDialogSessions( res_info );
                WREEndResImageSessions( res_info );
                WREDestroyResourceWindow( res_info );
                return( (LRESULT) FALSE );
        }
    }

    if( !msg_processed ) {
        ret = DefMDIChildProc( hWnd, message, wParam, lParam );
    }

    return( ret );
}

Bool WREInitResources( HINSTANCE inst )
{
    WREResInfoBrush = CreateSolidBrush( GetSysColor ( COLOR_BTNFACE ) );
    WREAppInst = inst;
    WREResInfoWinProc =  (DLGPROC)
        MakeProcInstance( (FARPROC)WREResInfoProc, inst );
    return( WREInitStaticVars() );
}

void WREFiniResources ( void )
{
    if ( WREResInfoBrush ) {
        DeleteObject ( WREResInfoBrush );
    }
    FreeProcInstance ( (FARPROC) WREResInfoWinProc );
    WREFiniStaticVars();
}

Bool WRECreateResInfoWindow( WREResInfo *info )
{
    info->info_win =
        JCreateDialogParam( WREAppInst, "WREResource", info->res_win,
                            WREResInfoWinProc, (LPARAM)info );

    if( info->info_win == (HWND) NULL ) {
        return ( FALSE );
    }

    return( TRUE );
}

LRESULT WINEXPORT WREResInfoProc ( HWND hDlg, UINT message,
                                   WPARAM wParam, LPARAM lParam )
{
    WREResInfo *info;
    LRESULT     ret;
    WORD        wp;
    UINT        cmd;

    ret = FALSE;

    switch ( message ) {
        case WM_INITDIALOG:
            info = (WREResInfo *) lParam;
            info->info_win = hDlg;
            SetWindowLong ( hDlg, DWL_USER, (LONG) info );
            if( !WREInitResourceWindow( info, 0 ) ) {
                DestroyWindow( hDlg );
            } else {
                ret = TRUE;
            }
            break;

        case WM_SYSCOLORCHANGE:
#if defined (__NT__)
            SetClassLong( hDlg, GCL_HBRBACKGROUND, (LONG)(HBRUSH)(COLOR_BTNFACE+1) );
#endif
            WRECtl3dColorChange ();
            break;

        case WM_COMMAND:
            wp = LOWORD(wParam);
            switch ( wp ) {
                case IDM_RNRES:
                    cmd = GET_WM_COMMAND_CMD(wParam,lParam);
                    if ( cmd == LBN_DBLCLK ) {
                        WREHandleResEdit();
                    }
                    break;

                case IDM_RNTYPE:
                    info = (WREResInfo *) GetWindowLong ( hDlg, DWL_USER );
                    cmd = GET_WM_COMMAND_CMD(wParam,lParam);
                    if ( cmd == LBN_SELCHANGE ) {
                        WREAddResNames( info );
                    }
                    break;

            }
            break;
    }

    return( ret );
}