ddemsg.c

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

                SendMessage( info->list.box, LB_ADDSTRING, 0, (DWORD)start );
            }
            SpyLogOut( start );
            *ptr = '\n';
            start = ptr + 1;
        }
        ptr ++;
    }
    if( start != ptr ) {
        if( ConfigInfo.screen_out ) {
            SetHorzExtent( info, start );
            ret = SendMessage( info->list.box, LB_ADDSTRING, 0, (DWORD)start );
        }
        SpyLogOut( start );
    }
    if( ConfigInfo.scroll && ConfigInfo.screen_out ) {
        SendMessage( info->list.box, LB_SETTOPINDEX, ret, 0L );
    }
    // NYI do something if the list box is full
}


/*
 * ProcessCBStruct - convert information in a MONCBSTRUCT to a string for
 *                   display
 */
static void ProcessCBStruct( char *buf, MONCBSTRUCT *info ) {
    char                *type;
    char                *str1;
    char                *str2;
    char                *fmt;
    char                *task;
    char                *conv;
    BOOL                type_not_found;
    char                fbuf[40];

    fmt = GetFmtStr( info->wFmt, fbuf );
    type = SrchMsg( info->wType, XTypMsgs, NULL );
    if( type == NULL ) {
        type = AllocRCString( STR_UNKNOWN );
        type_not_found = TRUE;
    } else {
        type_not_found = FALSE;
    }
    task = DeAlias( (long)info->hTask, DEALIAS_TASK );
    conv = DeAlias( (long)info->hConv, DEALIAS_CONV );
    switch( info->wType ) {
    case XTYP_ADVSTART:
    case XTYP_ADVSTOP:
    case XTYP_REQUEST:
        str1 = HSZToString( info->hsz1 );
        str2 = HSZToString( info->hsz2 );
        RCsprintf( buf, STR_ADVSTART_FMT_STR,
            info->dwTime, task, type,
            info->dwRet, conv, fmt, info->hsz1, str1,
            info->hsz2, str2 );
        MemFree( str1 );
        MemFree( str2 );
        break;
    case XTYP_CONNECT:
    case XTYP_WILDCONNECT:
        str1 = HSZToString( info->hsz1 );
        str2 = HSZToString( info->hsz2 );
        RCsprintf( buf, STR_CONNECT_FMT_STR,
            info->dwTime, task, type,
            info->dwRet, conv, fmt, info->hsz1, str1,
            info->hsz2, str2, info->dwData1, info->dwData2 );
        MemFree( str1 );
        MemFree( str2 );
        break;
    case XTYP_ADVREQ:
        str1 = HSZToString( info->hsz1 );
        str2 = HSZToString( info->hsz2 );
        RCsprintf( buf, STR_ADVREQ_FMT_STR,
            info->dwTime, task, type,
            info->dwRet, conv, fmt, info->hsz1, str1,
            info->hsz2, str2, info->dwData1 );
        MemFree( str1 );
        MemFree( str2 );
        break;
    case XTYP_ADVDATA:
    case XTYP_POKE:
        str1 = HSZToString( info->hsz1 );
        str2 = HSZToString( info->hsz2 );
        RCsprintf( buf, STR_ADVDATA_FMT_STR,
            info->dwTime, task, type,
            info->dwRet, conv, fmt, info->hsz1, str1,
            info->hsz2, str2, info->hData );
        MemFree( str1 );
        MemFree( str2 );
        break;
    case XTYP_EXECUTE:
        str1 = HSZToString( info->hsz1 );
        RCsprintf( buf, STR_EXECUTE_FMT_STR,
            info->dwTime, task, type,
            info->dwRet, conv, fmt, info->hsz1, str1,
            info->hData );
        MemFree( str1 );
        break;
    case XTYP_CONNECT_CONFIRM:
        str1 = HSZToString( info->hsz1 );
        str2 = HSZToString( info->hsz2 );
        RCsprintf( buf, STR_CONFIRM_FRM_STR,
            info->dwTime, task, type,
            info->dwRet, conv, fmt, info->hsz1, str1,
            info->hsz2, str2, info->dwData2 );
        MemFree( str1 );
        MemFree( str2 );
        break;
    case XTYP_DISCONNECT:
        RCsprintf( buf, STR_DISCONNECT_FMT_STR,
            info->dwTime, task, type,
            info->dwRet, conv, fmt,
            info->dwData2 );
        break;
    case XTYP_ERROR:
        RCsprintf( buf, STR_ERROR_FMT_STR,
            info->dwTime, task, type,
            info->dwRet, conv, fmt,
            info->dwData1 );
        break;
    case XTYP_XACT_COMPLETE:
        str1 = HSZToString( info->hsz1 );
        str2 = HSZToString( info->hsz2 );
        RCsprintf( buf, STR_XACT_CPLT_FMT_STR,
            info->dwTime, task, type,
            type, info->dwRet, conv, fmt, info->hsz1, str1,
            info->hsz2, str2, info->hData, info->dwData1, info->dwData2 );
        MemFree( str1 );
        MemFree( str2 );
        break;
    case XTYP_UNREGISTER:
        str1 = HSZToString( info->hsz1 );
        str2 = HSZToString( info->hsz2 );
        RCsprintf( buf, STR_UNREGISTER_FMT_STR,
            info->dwTime, task, type,
            info->hsz1, str1, info->hsz2, str2 );
        MemFree( str1 );
        MemFree( str2 );
        break;
    case XTYP_REGISTER:
        str1 = HSZToString( info->hsz1 );
        str2 = HSZToString( info->hsz2 );
        RCsprintf( buf, STR_REGISTER_FMT_STR,
            info->dwTime, task, type,
            info->hsz1, str1, info->hsz2, str2 );
        MemFree( str1 );
        MemFree( str2 );
        break;
    default:
        str1 = HSZToString( info->hsz1 );
        str2 = HSZToString( info->hsz2 );
        RCsprintf( buf, STR_DEFAULT_FMT_STR,
            info->dwTime, task, type,
            info->dwRet, conv, fmt, info->hsz1, str1,
            info->hsz2, str2, info->hData, info->dwData1, info->dwData2 );
        MemFree( str1 );
        MemFree( str2 );
        break;
    }

    if( type_not_found ) {
        FreeRCString( type );
    }
    MemFree( task );
    MemFree( conv );
}

/*
 * ProcessConvStruct - convert information in a MONCONVSTRUCT to a string for
 *                   display
 */
static void ProcessConvStruct( char *buf, MONCONVSTRUCT *info ) {

    char                *server;
    char                *topic;
    char                *task;
    char                *serverconv;
    char                *clientconv;
    DWORD               fmtstr;

    server = HSZToString( info->hszSvc );
    topic = HSZToString( info->hszTopic );
    task = DeAlias( (long)info->hTask, DEALIAS_TASK );
    clientconv = DeAlias( (long)info->hConvClient, DEALIAS_CLIENT_CONV );
    serverconv = DeAlias( (long)info->hConvServer, DEALIAS_SERVER_CONV );
    if( info->fConnect ) {
        fmtstr = STR_CONV_EST_FMT_STR;
    } else {
        fmtstr = STR_CONV_TERM_FMT_STR;
    }
    RCsprintf( buf, fmtstr,
                info->dwTime, task,
                info->hszSvc, server, info->hszTopic, topic,
                clientconv, serverconv );
    MemFree( server );
    MemFree( topic );
    MemFree( task );
    MemFree( clientconv );
    MemFree( serverconv );
}

/*
 * ProcessErrStruct - convert information in a MONERRSTRUCT to a string for
 *                   display
 */
static void ProcessErrStruct( char *buf, MONERRSTRUCT *info ) {

    char                *type;
    char                *task;

    task = DeAlias( (long)info->hTask, DEALIAS_TASK );
    type = SrchMsg( info->wLastError, DDEErrorMsgs, "" );
    RCsprintf( buf, STR_ERR_STRUCT_FMT_STR, info->dwTime, task, type );
    MemFree( task );
}

/*
 * ProcessHSZStruct - convert information in a MONHSZSTRUCT to a string for
 *                   display
 */
static BOOL ProcessHSZStruct( char *buf, MONHSZSTRUCT *info ) {

    char                *task;
    DWORD               fmtid;
    char                *str;
    BOOL                str_alloced;

    switch( info->fsAction ) {
    case MH_CLEANUP:
    case MH_DELETE:
        fmtid = STR_HSZ_STRUCT_DEL;
        break;
    case MH_CREATE:
        fmtid = STR_HSZ_STRUCT_CREATE;
        break;
    case MH_KEEP:
        fmtid = STR_HSZ_STRUCT_KEPT;
        break;
    default:
        return( FALSE );
    }
    task = DeAlias( (long)info->hTask, DEALIAS_TASK );
    str = info->str;
    str_alloced = FALSE;
#ifdef __NT__
    {
        DWORD   ver;

        ver = GetVersion();
        // in NT 3.1 the string is in unicode otherwise it is ASCII
        if( ( ver & 0xFF ) == 3 && ( ver & 0xFF00 ) <= 0x0A00 ) {
            str = MemAlloc( lstrlenW( (LPCWSTR)info->str ) + 1 );
            str_alloced = TRUE;
            wsprintf( str, "%ls", info->str );
        }
    }
#endif
    RCsprintf( buf, fmtid,
             info->dwTime, task, HSZ_FMT_LEN, info->hsz, str );
    if( str_alloced ) MemFree( str );
    MemFree( task );
    return( TRUE );
}

/*
 * ProcessLinkStruct - convert information in a MONLINKSTRUCT to a string for
 *                   display
 */
static void ProcessLinkStruct( char *buf, MONLINKSTRUCT *info ) {

    char                fbuf[40];
    char                *fmt;
    char                *service;
    char                *topic;
    char                *item;
    char                *task;
    char                *clientconv;
    char                *serverconv;
    DWORD               fmtid;

    if( info->fNoData ) {
        if( info->fEstablished ) {
            fmtid = STR_LNK_STRUCT_FMT_STR_1;
        } else {
            fmtid = STR_LNK_STRUCT_FMT_STR_3;
        }
    } else {
        if( info->fEstablished ) {
            fmtid = STR_LNK_STRUCT_FMT_STR_2;
        } else {
            fmtid = STR_LNK_STRUCT_FMT_STR_3;
        }
    }
    service = HSZToString( info->hszSvc );
    topic = HSZToString( info->hszTopic );
    item = HSZToString( info->hszItem );
    fmt = GetFmtStr( info->wFmt, fbuf );
    task = DeAlias( (long)info->hTask, DEALIAS_TASK );
    clientconv = DeAlias( (long)info->hConvClient, DEALIAS_CLIENT_CONV );
    serverconv = DeAlias( (long)info->hConvServer, DEALIAS_SERVER_CONV );
    // NYI what does fServer mean????
    RCsprintf( buf, fmtid,
        info->dwTime, task,
        info->hszSvc, service, info->hszTopic, topic, info->hszItem, item,
        fmt, serverconv, clientconv );
    MemFree( task );
    MemFree( clientconv );
    MemFree( serverconv );
}

/*
 * ProcessMsgStruct - convert information in a MONMSGSTRUCT to a string for
 *                   display
 */
static void ProcessMsgStruct( char *buf, MONMSGSTRUCT *info, BOOL posted ) {

    char                *msg;
    char                *task;
    char                *tohwnd;
    char                msg_not_found;
    DWORD               fmtid;

    task = DeAlias( (long)info->hTask, DEALIAS_TASK );
    tohwnd = DeAlias( (long)info->hwndTo, DEALIAS_HWND );
    msg = SrchMsg( info->wMsg, DDEMsgs, NULL );
    if( msg == NULL ) {
        msg = AllocRCString( STR_UNKNOWN );
        msg_not_found = TRUE;
    } else {
        msg_not_found = FALSE;
    }
    if( posted ) {
        fmtid = STR_MSG_STRUC_FMT_STR_2;
    } else {
        fmtid = STR_MSG_STRUC_FMT_STR_1;
    }
    RCsprintf( buf, fmtid,
            info->dwTime, task, msg,
            tohwnd, WPARAM_FMT_LEN, info->wParam, info->lParam );
    if( msg_not_found ) {
        FreeRCString( msg );
    }
    MemFree( task );
    MemFree( tohwnd );
}

/*
 * DDEMsgProc - process dde messages received from the DDE manager
 */
HDDEDATA __export FAR PASCAL DDEMsgProc( UINT type, UINT fmt, HCONV hconv,
                HSZ hsz1, HSZ hsz2, HDDEDATA hdata, DWORD data1, DWORD data2 )
{
    char        buf[400];
    void        *info;

    //RecordMsg( "In Message Proc..." );
    fmt = fmt;
    hsz1 = hsz1;
    hsz2 = hsz2;
    data1 = data1;
    hconv = hconv;
    if( type != XTYP_MONITOR ) return( NULL );
    info = DdeAccessData( hdata, NULL );
    if( info == NULL ) return( NULL );
    switch( data2 ) {
    case MF_HSZ_INFO:
        //RecordMsg( "MF_HSZ_INFO msg\n" );
        if( Monitoring[MON_STR_IND] ) {
            if( !ProcessHSZStruct( buf, info ) ) break;
            RecordMsg( buf );
        }
        TrackStringMsg( info );
        break;
    case MF_SENDMSGS:
        //RecordMsg( "MF_SENDMSG msg\n" );
        if( Monitoring[MON_SENT_IND] ) {
            if( DoFilter( ( (MONMSGSTRUCT *)info )->wMsg, FILTER_MESSAGE ) ) {
                ProcessMsgStruct( buf, info, FALSE );
                RecordMsg( buf );
            }
        }
        break;
    case MF_POSTMSGS:
        //RecordMsg( "MF_POSTMSG msg\n" );
        if( Monitoring[MON_POST_IND] ) {
            if( DoFilter( ( (MONMSGSTRUCT *)info )->wMsg, FILTER_MESSAGE ) ) {
                ProcessMsgStruct( buf, info, TRUE );
                RecordMsg( buf );
            }
        }
        break;
    case MF_CALLBACKS:
        //RecordMsg( "MF_CB msg\n" );
        if( Monitoring[MON_CB_IND] ) {
            if( DoFilter( ( (MONCBSTRUCT *)info )->wType, FILTER_CB ) ) {
                ProcessCBStruct( buf, info );
                RecordMsg( buf );
            }
        }
        if( ( (MONCBSTRUCT *)info )->wType == XTYP_REGISTER
            ||( (MONCBSTRUCT *)info )->wType == XTYP_UNREGISTER ) {
            TrackServerMsg( info );
        }
        break;
    case MF_ERRORS:
        //RecordMsg( "MF_ERROR msg\n" );
        if( Monitoring[MON_ERR_IND] ) {
            ProcessErrStruct( buf, info );
            RecordMsg( buf );
        }
        break;
    case MF_LINKS:
        //RecordMsg( "MF_LINKS msg\n" );
        if( Monitoring[MON_LNK_IND] ) {
            ProcessLinkStruct( buf, info );
            RecordMsg( buf );
        }
        TrackLinkMsg( info );
        break;
    case MF_CONV:
        //RecordMsg( "MF_CONV msg\n" );
        if( Monitoring[MON_LNK_IND] ) {
            ProcessConvStruct( buf, info );
            RecordMsg( buf );
        }
        TrackConvMsg( info );
        break;
    default:
        //RecordMsg( "Unknown message\n" );
        break;
    }
    DdeUnaccessData( hdata );
    return( (HDDEDATA)0 );
}