Changeset 2768 for trunk/src


Ignore:
Timestamp:
Feb 12, 2000, 7:09:50 PM (26 years ago)
Author:
cbratschi
Message:

added v5.00 messages

Location:
trunk/src/user32
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/user32/HOOK.CPP

    r2469 r2768  
    1 /* $Id: HOOK.CPP,v 1.9 2000-01-18 20:10:30 sandervl Exp $ */
     1/* $Id: HOOK.CPP,v 1.10 2000-02-12 18:09:49 cbratschi Exp $ */
    22
    33/*
    … …  
    2727#include <os2win.h>
    2828#include "hook.h"
    29 #include "win.h"
    3029#include "queue.h"
    3130#include "task.h"
    … …  
    7069typedef VOID (*HOOK_MapFunc)(INT, INT, WPARAM *, LPARAM *);
    7170typedef VOID (*HOOK_UnMapFunc)(INT, INT, WPARAM, LPARAM, WPARAM,
    72                                LPARAM);
     71                               LPARAM);
    7372
    7473/***********************************************************************
    … …  
    7675 */
    7776static void HOOK_Map32ATo32W(INT id, INT code, WPARAM *pwParam,
    78                              LPARAM *plParam)
     77                             LPARAM *plParam)
    7978{
    8079    if (id == WH_CBT && code == HCBT_CREATEWND)
    8180    {
    82         LPCBT_CREATEWNDA lpcbtcwA = (LPCBT_CREATEWNDA)*plParam;
    83         LPCBT_CREATEWNDW lpcbtcwW = (LPCBT_CREATEWNDW)HeapAlloc(GetProcessHeap(), 0,
    84                                                                 sizeof(*lpcbtcwW) );
    85         lpcbtcwW->lpcs = (CREATESTRUCTW*)HeapAlloc( GetProcessHeap(), 0, sizeof(*lpcbtcwW->lpcs) );
    86 
    87         lpcbtcwW->hwndInsertAfter = lpcbtcwA->hwndInsertAfter;
    88         *lpcbtcwW->lpcs = *(LPCREATESTRUCTW)lpcbtcwA->lpcs;
    89 
    90         if (HIWORD(lpcbtcwA->lpcs->lpszName))
    91         {
    92             lpcbtcwW->lpcs->lpszName = HEAP_strdupAtoW( GetProcessHeap(), 0,
     81        LPCBT_CREATEWNDA lpcbtcwA = (LPCBT_CREATEWNDA)*plParam;
     82        LPCBT_CREATEWNDW lpcbtcwW = (LPCBT_CREATEWNDW)HeapAlloc(GetProcessHeap(), 0,
     83                                                                sizeof(*lpcbtcwW) );
     84        lpcbtcwW->lpcs = (CREATESTRUCTW*)HeapAlloc( GetProcessHeap(), 0, sizeof(*lpcbtcwW->lpcs) );
     85
     86        lpcbtcwW->hwndInsertAfter = lpcbtcwA->hwndInsertAfter;
     87        *lpcbtcwW->lpcs = *(LPCREATESTRUCTW)lpcbtcwA->lpcs;
     88
     89        if (HIWORD(lpcbtcwA->lpcs->lpszName))
     90        {
     91            lpcbtcwW->lpcs->lpszName = HEAP_strdupAtoW( GetProcessHeap(), 0,
    9392                                                    lpcbtcwA->lpcs->lpszName );
    94         }
    95         else
    96           lpcbtcwW->lpcs->lpszName = (LPWSTR)lpcbtcwA->lpcs->lpszName;
    97 
    98         if (HIWORD(lpcbtcwA->lpcs->lpszClass))
    99         {
    100             lpcbtcwW->lpcs->lpszClass = HEAP_strdupAtoW( GetProcessHeap(), 0,
     93        }
     94        else
     95          lpcbtcwW->lpcs->lpszName = (LPWSTR)lpcbtcwA->lpcs->lpszName;
     96
     97        if (HIWORD(lpcbtcwA->lpcs->lpszClass))
     98        {
     99            lpcbtcwW->lpcs->lpszClass = HEAP_strdupAtoW( GetProcessHeap(), 0,
    101100                                                   lpcbtcwA->lpcs->lpszClass );
    102         }
    103         else
    104           lpcbtcwW->lpcs->lpszClass = (LPCWSTR)lpcbtcwA->lpcs->lpszClass;
    105         *plParam = (LPARAM)lpcbtcwW;
     101        }
     102        else
     103          lpcbtcwW->lpcs->lpszClass = (LPCWSTR)lpcbtcwA->lpcs->lpszClass;
     104        *plParam = (LPARAM)lpcbtcwW;
    106105    }
    107106    return;
    … …  
    113112 */
    114113static void HOOK_UnMap32ATo32W(INT id, INT code, WPARAM wParamOrig,
    115                                LPARAM lParamOrig, WPARAM wParam,
    116                                LPARAM lParam)
     114                               LPARAM lParamOrig, WPARAM wParam,
     115                               LPARAM lParam)
    117116{
    118117    if (id == WH_CBT && code == HCBT_CREATEWND)
    119118    {
    120         LPCBT_CREATEWNDW lpcbtcwW = (LPCBT_CREATEWNDW)lParam;
    121         if (HIWORD(lpcbtcwW->lpcs->lpszName))
     119        LPCBT_CREATEWNDW lpcbtcwW = (LPCBT_CREATEWNDW)lParam;
     120        if (HIWORD(lpcbtcwW->lpcs->lpszName))
    122121            HeapFree( GetProcessHeap(), 0, (LPWSTR)lpcbtcwW->lpcs->lpszName );
    123         if (HIWORD(lpcbtcwW->lpcs->lpszClass))
     122        if (HIWORD(lpcbtcwW->lpcs->lpszClass))
    124123            HeapFree( GetProcessHeap(), 0, (LPWSTR)lpcbtcwW->lpcs->lpszClass );
    125         HeapFree( GetProcessHeap(), 0, lpcbtcwW->lpcs );
    126         HeapFree( GetProcessHeap(), 0, lpcbtcwW );
     124        HeapFree( GetProcessHeap(), 0, lpcbtcwW->lpcs );
     125        HeapFree( GetProcessHeap(), 0, lpcbtcwW );
    127126    }
    128127    return;
    … …  
    134133 */
    135134static void HOOK_Map32WTo32A(INT id, INT code, WPARAM *pwParam,
    136                              LPARAM *plParam)
     135                             LPARAM *plParam)
    137136{
    138137    if (id == WH_CBT && code == HCBT_CREATEWND)
    139138    {
    140         LPCBT_CREATEWNDW lpcbtcwW = (LPCBT_CREATEWNDW)*plParam;
    141         LPCBT_CREATEWNDA lpcbtcwA = (LPCBT_CREATEWNDA)HeapAlloc(GetProcessHeap(), 0,
    142                                                                 sizeof(*lpcbtcwA) );
    143         lpcbtcwA->lpcs = (CREATESTRUCTA*)HeapAlloc( GetProcessHeap(), 0, sizeof(*lpcbtcwA->lpcs) );
    144 
    145         lpcbtcwA->hwndInsertAfter = lpcbtcwW->hwndInsertAfter;
    146         *lpcbtcwA->lpcs = *(LPCREATESTRUCTA)lpcbtcwW->lpcs;
    147 
    148         if (HIWORD(lpcbtcwW->lpcs->lpszName))
    149           lpcbtcwA->lpcs->lpszName = HEAP_strdupWtoA( GetProcessHeap(), 0,
     139        LPCBT_CREATEWNDW lpcbtcwW = (LPCBT_CREATEWNDW)*plParam;
     140        LPCBT_CREATEWNDA lpcbtcwA = (LPCBT_CREATEWNDA)HeapAlloc(GetProcessHeap(), 0,
     141                                                                sizeof(*lpcbtcwA) );
     142        lpcbtcwA->lpcs = (CREATESTRUCTA*)HeapAlloc( GetProcessHeap(), 0, sizeof(*lpcbtcwA->lpcs) );
     143
     144        lpcbtcwA->hwndInsertAfter = lpcbtcwW->hwndInsertAfter;
     145        *lpcbtcwA->lpcs = *(LPCREATESTRUCTA)lpcbtcwW->lpcs;
     146
     147        if (HIWORD(lpcbtcwW->lpcs->lpszName))
     148          lpcbtcwA->lpcs->lpszName = HEAP_strdupWtoA( GetProcessHeap(), 0,
    150149                                                    lpcbtcwW->lpcs->lpszName );
    151         else
    152           lpcbtcwA->lpcs->lpszName = (LPSTR)lpcbtcwW->lpcs->lpszName;
    153 
    154         if (HIWORD(lpcbtcwW->lpcs->lpszClass))
    155           lpcbtcwA->lpcs->lpszClass = HEAP_strdupWtoA( GetProcessHeap(), 0,
     150        else
     151          lpcbtcwA->lpcs->lpszName = (LPSTR)lpcbtcwW->lpcs->lpszName;
     152
     153        if (HIWORD(lpcbtcwW->lpcs->lpszClass))
     154          lpcbtcwA->lpcs->lpszClass = HEAP_strdupWtoA( GetProcessHeap(), 0,
    156155                                                   lpcbtcwW->lpcs->lpszClass );
    157         else
    158           lpcbtcwA->lpcs->lpszClass = (LPSTR)lpcbtcwW->lpcs->lpszClass;
    159         *plParam = (LPARAM)lpcbtcwA;
     156        else
     157          lpcbtcwA->lpcs->lpszClass = (LPSTR)lpcbtcwW->lpcs->lpszClass;
     158        *plParam = (LPARAM)lpcbtcwA;
    160159    }
    161160    return;
    … …  
    167166 */
    168167static void HOOK_UnMap32WTo32A(INT id, INT code, WPARAM wParamOrig,
    169                                LPARAM lParamOrig, WPARAM wParam,
    170                                LPARAM lParam)
     168                               LPARAM lParamOrig, WPARAM wParam,
     169                               LPARAM lParam)
    171170{
    172171    if (id == WH_CBT && code == HCBT_CREATEWND)
    173172    {
    174         LPCBT_CREATEWNDA lpcbtcwA = (LPCBT_CREATEWNDA)lParam;
    175         if (HIWORD(lpcbtcwA->lpcs->lpszName))
     173        LPCBT_CREATEWNDA lpcbtcwA = (LPCBT_CREATEWNDA)lParam;
     174        if (HIWORD(lpcbtcwA->lpcs->lpszName))
    176175            HeapFree( GetProcessHeap(), 0, (LPSTR)lpcbtcwA->lpcs->lpszName );
    177         if (HIWORD(lpcbtcwA->lpcs->lpszClass))
     176        if (HIWORD(lpcbtcwA->lpcs->lpszClass))
    178177            HeapFree( GetProcessHeap(), 0, (LPSTR)lpcbtcwA->lpcs->lpszClass );
    179         HeapFree( GetProcessHeap(), 0, lpcbtcwA->lpcs );
    180         HeapFree( GetProcessHeap(), 0, lpcbtcwA );
     178        HeapFree( GetProcessHeap(), 0, lpcbtcwA->lpcs );
     179        HeapFree( GetProcessHeap(), 0, lpcbtcwA );
    181180    }
    182181    return;
    … …  
    187186 *           Map Function Tables
    188187 */
    189 static const HOOK_MapFunc HOOK_MapFuncs[3][3] = 
     188static const HOOK_MapFunc HOOK_MapFuncs[3][3] =
    190189{
    191190    { NULL, NULL,             NULL },
    … …  
    194193};
    195194
    196 static const HOOK_UnMapFunc HOOK_UnMapFuncs[3][3] = 
     195static const HOOK_UnMapFunc HOOK_UnMapFuncs[3][3] =
    197196{
    198197    { NULL, NULL,               NULL },
    … …  
    234233  HANDLE hook = 0;
    235234  THDB *thdb;
    236    
     235
    237236    thdb = GetTHDBFromThreadId(threadId);
    238237    if(thdb) {
    239         hook = thdb->hooks[id - WH_MINHOOK];
     238        hook = thdb->hooks[id - WH_MINHOOK];
    240239    }
    241240    if (!hook) hook = HOOK_systemHooks[id - WH_MINHOOK];
    … …  
    251250 */
    252251static HHOOK HOOK_SetHook( INT id, LPVOID proc, INT type,
    253                            HMODULE hModule, DWORD dwThreadId )
     252                           HMODULE hModule, DWORD dwThreadId )
    254253{
    255254  HOOKDATA *data;
    256255  THDB     *thdb;
    257  
     256
    258257    if ((id < WH_MINHOOK) || (id > WH_MAXHOOK) || !proc )
    259258    {
    260         SetLastError(ERROR_INVALID_PARAMETER);
     259        SetLastError(ERROR_INVALID_PARAMETER);
    261260        return 0;
    262261    }
    … …  
    275274    if (dwThreadId)  /* Task-specific hook */
    276275    {
    277         if ((id == WH_JOURNALRECORD) || (id == WH_JOURNALPLAYBACK) ||
    278             (id == WH_SYSMSGFILTER)) {
    279                 SetLastError(ERROR_INVALID_PARAMETER);
    280                 return 0;  /* System-only hooks */
    281         }
     276        if ((id == WH_JOURNALRECORD) || (id == WH_JOURNALPLAYBACK) ||
     277            (id == WH_SYSMSGFILTER)) {
     278                SetLastError(ERROR_INVALID_PARAMETER);
     279                return 0;  /* System-only hooks */
     280        }
    282281    }
    283282
    … …  
    295294    if(dwThreadId)
    296295    {
    297         thdb = GetTHDBFromThreadId(dwThreadId);
    298         if(!thdb) {
    299                 dprintf(("HOOK_SetHook: can't find thread database for thread %x", dwThreadId));
    300                 return 0;
    301         }
    302         threadHookMutex.enter();
     296        thdb = GetTHDBFromThreadId(dwThreadId);
     297        if(!thdb) {
     298                dprintf(("HOOK_SetHook: can't find thread database for thread %x", dwThreadId));
     299                return 0;
     300        }
     301        threadHookMutex.enter();
    303302        data->next = thdb->hooks[id - WH_MINHOOK];
    304303        thdb->hooks[id - WH_MINHOOK] = (DWORD)data;
    305         threadHookMutex.leave();
     304        threadHookMutex.leave();
    306305    }
    307306    else
    308307    {
    309         systemHookMutex.enter();
     308        systemHookMutex.enter();
    310309        data->next = HOOK_systemHooks[id - WH_MINHOOK];
    311310        HOOK_systemHooks[id - WH_MINHOOK] = (HANDLE)data;
    312         systemHookMutex.leave();
     311        systemHookMutex.leave();
    313312    }
    314313
    … …  
    329328
    330329    dprintf(("Removing hook %08x\n", data));
    331    
     330
    332331    if (data->flags & HOOK_INUSE)
    333332    {
    … …  
    341340    if (data->id == WH_JOURNALPLAYBACK) EnableHardwareInput16(TRUE);
    342341#endif
    343      
     342
    344343    /* Remove it from the linked list */
    345344
    346345    if (data->ownerThread)
    347346    {
    348         thdb = GetTHDBFromThreadId(data->ownerThread);
    349         if(!thdb) {
    350                 dprintf(("HOOK_RemoveHook: can't find thread database for thread %x", data->ownerThread));
    351                 return FALSE;
    352         }
    353         hookMutex = &threadHookMutex;
    354         hookMutex->enter();
     347        thdb = GetTHDBFromThreadId(data->ownerThread);
     348        if(!thdb) {
     349                dprintf(("HOOK_RemoveHook: can't find thread database for thread %x", data->ownerThread));
     350                return FALSE;
     351        }
     352        hookMutex = &threadHookMutex;
     353        hookMutex->enter();
    355354        prevHook = (HOOKDATA **)&thdb->hooks[data->id - WH_MINHOOK];
    356355    }
    357356    else {
    358         hookMutex = &systemHookMutex;
    359         hookMutex->enter();
    360         prevHook = (HOOKDATA **)&HOOK_systemHooks[data->id - WH_MINHOOK];
     357        hookMutex = &systemHookMutex;
     358        hookMutex->enter();
     359        prevHook = (HOOKDATA **)&HOOK_systemHooks[data->id - WH_MINHOOK];
    361360    }
    362361    while (*prevHook && *prevHook != data)
    … …  
    364363
    365364    if (!prevHook) {
    366         hookMutex->leave();
    367         return FALSE;
     365        hookMutex->leave();
     366        return FALSE;
    368367    }
    369368    *prevHook = (HOOKDATA *)data->next;
    … …  
    384383    for (;;)
    385384    {
    386         if (!(data = (HOOKDATA *)hook)) return 0;
    387         if (data->proc) return hook;
    388         hook = data->next;
     385        if (!(data = (HOOKDATA *)hook)) return 0;
     386        if (data->proc) return hook;
     387        hook = data->next;
    389388    }
    390389}
    … …  
    444443BOOL HOOK_IsHooked( INT id )
    445444{
    446     /* Hmmm. Use GetThreadQueue(0) instead of GetFastQueue() here to 
     445    /* Hmmm. Use GetThreadQueue(0) instead of GetFastQueue() here to
    447446       avoid queue being created if someone wants to merely check ... */
    448447
    … …  
    458457                           LPARAM lParam )
    459458{
    460     HANDLE hook; 
     459    HANDLE hook;
    461460
    462461    if (!(hook = HOOK_GetHook( id, GetCurrentThreadId() ))) return 0;
    … …  
    473472                           LPARAM lParam )
    474473{
    475     HANDLE hook; 
     474    HANDLE hook;
    476475
    477476    if (!(hook = HOOK_GetHook( id, GetCurrentThreadId() ))) return 0;
    478477    if (!(hook = HOOK_FindValidHook(hook))) return 0;
    479478    return HOOK_CallHook( hook, HOOK_WIN32W, code, wParam,
    480                           lParam );
     479                          lParam );
    481480}
    482481
    … …  
    492491    if ((queue = (MESSAGEQUEUE *)QUEUE_Lock( hQueue )) != NULL)
    493492    {
    494         HOOKDATA*       data;
    495         HHOOK           hook;
    496         int             id;
    497         for( id = WH_MINHOOK; id <= WH_MAXHOOK; id++ )
    498         {
    499             hook = queue->hooks[id - WH_MINHOOK];
    500             while( hook )
    501             {
    502                 if( (data = (HOOKDATA *)hook) )
    503                 {
    504                   data->ownerQueue = hQueue;
    505                   hook = data->next;
    506                 } else break;
    507             }
    508         }
     493        HOOKDATA*       data;
     494        HHOOK           hook;
     495        int             id;
     496        for( id = WH_MINHOOK; id <= WH_MAXHOOK; id++ )
     497        {
     498            hook = queue->hooks[id - WH_MINHOOK];
     499            while( hook )
     500            {
     501                if( (data = (HOOKDATA *)hook) )
     502                {
     503                  data->ownerQueue = hQueue;
     504                  hook = data->next;
     505                } else break;
     506            }
     507        }
    509508
    510509        QUEUE_Unlock( queue );
    … …  
    514513
    515514/***********************************************************************
    516  *           HOOK_FreeModuleHooks
     515 *           HOOK_FreeModuleHooks
    517516 */
    518517void HOOK_FreeModuleHooks( HMODULE hModule )
    … …  
    528527       hook = HOOK_systemHooks[id - WH_MINHOOK];
    529528       while( hook )
    530           if( (hptr = (HOOKDATA *)hook) )
    531             {
    532               next = hptr->next;
    533               if( hptr->ownerModule == hModule )
     529       {
     530          hptr = (HOOKDATA *)hook;
     531          if (hptr)
     532            {
     533              next = hptr->next;
     534              if( hptr->ownerModule == hModule )
    534535                {
    535536                  hptr->flags &= HOOK_MAPTYPE;
    536537                  HOOK_RemoveHook(hptr);
    537538                }
    538               hook = next;
    539             }
    540           else hook = 0;
    541     }
    542 }
    543 
    544 /***********************************************************************
    545  *           HOOK_FreeQueueHooks
     539              hook = next;
     540            }
     541          else hook = 0;
     542       }
     543    }
     544}
     545
     546/***********************************************************************
     547 *           HOOK_FreeQueueHooks
    546548 */
    547549void HOOK_FreeQueueHooks( DWORD threadId )
    … …  
    549551  /* remove all hooks registered by this queue */
    550552
    551   HOOKDATA*     hptr = NULL;
    552   HHOOK         hook, next;
    553   int           id;
     553  HOOKDATA*     hptr = NULL;
     554  HHOOK         hook, next;
     555  int           id;
    554556
    555557  for( id = WH_MINHOOK; id <= WH_MAXHOOK; id++ )
    … …  
    557559       hook = HOOK_GetHook( id, threadId );
    558560       while( hook )
    559         {
    560           next = HOOK_GetNextHook(hook);
    561 
    562           hptr = (HOOKDATA *)hook;
    563           if( hptr && hptr->ownerThread == threadId )
    564             {
    565               hptr->flags &= HOOK_MAPTYPE;
    566               HOOK_RemoveHook(hptr);
    567             }
    568           hook = next;
    569         }
     561        {
     562          next = HOOK_GetNextHook(hook);
     563
     564          hptr = (HOOKDATA *)hook;
     565          if( hptr && hptr->ownerThread == threadId )
     566            {
     567              hptr->flags &= HOOK_MAPTYPE;
     568              HOOK_RemoveHook(hptr);
     569            }
     570          hook = next;
     571        }
    570572    }
    571573}
    … …  
    632634{
    633635    if (CHECK_MAGIC(hhook) == FALSE)
    634         return FALSE;
     636        return FALSE;
    635637
    636638    return HOOK_RemoveHook( (HOOKDATA *)hhook );
    … …  
    646648{
    647649    HANDLE next;
    648     INT fromtype;       /* figure out Ansi/Unicode */
     650    INT fromtype;       /* figure out Ansi/Unicode */
    649651    HOOKDATA *oldhook;
    650652
    651653    if (CHECK_MAGIC(hhook) == FALSE)
    652         return FALSE;
     654        return FALSE;
    653655
    654656    if (!(next = HOOK_GetNextHook( hhook ))) return 0;
    … …  
    670672BOOL WINAPI CallMsgFilterA( LPMSG msg, INT code )
    671673{
    672     if (GetSysModalWindow()) return FALSE;      /* ??? */
     674#if 0 //CB: not a Win32 API and unimplemented
     675    if (GetSysModalWindow()) return FALSE;      /* ??? */
     676#endif
    673677    if (HOOK_CallHooksA( WH_SYSMSGFILTER, code, 0, (LPARAM)msg ))
    674678      return TRUE;
    … …  
    682686BOOL WINAPI CallMsgFilterW( LPMSG msg, INT code )
    683687{
    684     if (GetSysModalWindow()) return FALSE;      /* ??? */
     688#if 0 //CB: not a Win32 API and unimplemented
     689    if (GetSysModalWindow()) return FALSE;      /* ??? */
     690#endif
    685691    if (HOOK_CallHooksW( WH_SYSMSGFILTER, code, 0, (LPARAM)msg ))
    686692      return TRUE;

  • trunk/src/user32/user32.cpp

    r2739 r2768  
    1 /* $Id: user32.cpp,v 1.71 2000-02-10 18:49:51 cbratschi Exp $ */
     1/* $Id: user32.cpp,v 1.72 2000-02-12 18:09:49 cbratschi Exp $ */
    22
    33/*
    … …  
    148148{
    149149    dprintf2(("USER32:  IntersectRect\n"));
    150     if (!lprcDst || !lprcSrc1 || !lprcSrc2)
     150    if (!lprcSrc1 || !lprcSrc2)
    151151    {
    152152      SetLastError(ERROR_INVALID_PARAMETER);
    … …  
    159159    {
    160160      SetLastError(ERROR_INVALID_PARAMETER);
    161       SetRectEmpty(lprcDst);
     161      if (lprcDst) SetRectEmpty(lprcDst);
    162162      return FALSE;
    163163    }
    164     lprcDst->left   = MAX(lprcSrc1->left,lprcSrc2->left);
    165     lprcDst->right  = MIN(lprcSrc1->right,lprcSrc2->right);
    166     lprcDst->top    = MAX(lprcSrc1->top,lprcSrc2->top);
    167     lprcDst->bottom = MIN(lprcSrc1->bottom,lprcSrc2->bottom);
     164    if (lprcDst)
     165    {
     166      lprcDst->left   = MAX(lprcSrc1->left,lprcSrc2->left);
     167      lprcDst->right  = MIN(lprcSrc1->right,lprcSrc2->right);
     168      lprcDst->top    = MAX(lprcSrc1->top,lprcSrc2->top);
     169      lprcDst->bottom = MIN(lprcSrc1->bottom,lprcSrc2->bottom);
     170    }
    168171
    169172    return TRUE;

  • trunk/src/user32/wndmsg.cpp

    r2552 r2768  
    1 /* $Id: wndmsg.cpp,v 1.12 2000-01-28 22:26:01 sandervl Exp $ */
     1/* $Id: wndmsg.cpp,v 1.13 2000-02-12 18:09:50 cbratschi Exp $ */
    22/*
    33 * Win32 window message text function for OS/2
    … …  
    145145    { "WM_COMPAREITEM", WM_COMPAREITEM,                     // 0x0039
    146146        0},
     147    { "WM_GETOBJECT", WM_GETOBJECT,                         // 0x003D
     148        0},
    147149    { "WM_COMPACTING", WM_COMPACTING,                       // 0x0041
     150        0},
     151    { "WM_COMMNOTIFY", WM_COMMNOTIFY,                       // 0x0044
    148152        0},
    149153    { "WM_WINDOWPOSCHANGING", WM_WINDOWPOSCHANGING,         // 0x0046
    … …  
    164168    { "WM_USERCHANGED", WM_USERCHANGED, 0},                 // 0x54
    165169    { "WM_NOTIFYFORMAT", WM_NOTIFYFORMAT, 0},               // 0x55
     170    { "WM_CONTEXTMENU" , WM_CONTEXTMENU, 0},                // 0x007B
    166171    { "WM_STYLECHANGING", WM_STYLECHANGING, 0},             // 0x7C
    167172    { "WM_STYLECHANGED", WM_STYLECHANGED, 0},               // 0x7D
    … …  
    182187        MTF_TYPE_NC},
    183188    { "WM_GETDLGCODE", WM_GETDLGCODE,                       // 0x0087
     189        0},
     190    { "WM_SYNCPAINT", WM_SYNCPAINT,                         // 0x0088
    184191        0},
    185192    { "WM_NCMOUSEMOVE", WM_NCMOUSEMOVE,                     // 0x00A0
    … …  
    346353    { "WM_ENTERIDLE", WM_ENTERIDLE,                         // 0x0121
    347354        0},
     355    { "WM_MENURBUTTONUP", WM_MENURBUTTONUP,                 // 0x0122
     356        0},
     357    { "WM_MENUDRAG", WM_MENUDRAG,                           // 0x0123
     358        0},
     359    { "WM_MENUGETOBJECT", WM_MENUGETOBJECT,                 // 0x0124
     360        0},
     361    { "WM_UNINITMENUPOPUP", WM_UNINITMENUPOPUP,             // 0x0125
     362        0},
     363    { "WM_MENUCOMMAND", WM_MENUCOMMAND,                     // 0x0126
     364        0},
     365    { "WM_KEYBOARDCUES", WM_KEYBOARDCUES,                   // 0x0127
     366        0},
    348367    { "WM_CTLCOLORMSGBOX", WM_CTLCOLORMSGBOX,               // 0x0132
    349368        0},
    … …  
    514533    { "WM_MBUTTONDBLCLK", WM_MBUTTONDBLCLK,                 // 0x0209
    515534        MTF_TYPE_MOUSE},
     535    { "WM_MOUSEWHEEL", WM_MOUSEWHEEL,                       // 0x020A
     536        MTF_TYPE_MOUSE},
    516537    { "WM_PARENTNOTIFY", WM_PARENTNOTIFY,                   // 0x0210
    517538        MTF_TYPE_MOUSE},
    … …  
    519540        0},
    520541    { "WM_EXITMENULOOP", WM_EXITMENULOOP,                   // 0x0212
     542        0},
     543    { "WM_NEXTMENU", WM_NEXTMENU,                           // 0x0213
     544        0},
     545    { "WM_SIZING", WM_SIZING,                               // 0x0214
     546        0},
     547    { "WM_CAPTURECHANGED", WM_CAPTURECHANGED,               // 0x0215
     548        0},
     549    { "WM_MOVING", WM_MOVING,                               // 0x0216
     550        0},
     551    { "WM_POWERBROADCAST", WM_POWERBROADCAST,               // 0x0218
     552        0},
     553    { "WM_DEVICECHANGE", WM_DEVICECHANGE,                   // 0x0219
    521554        0},
    522555    { "WM_MDICREATE", WM_MDICREATE,                         // 0x0220
    … …  
    565598        TMP_MTF_TYPE_IME},
    566599    { "WM_IME_CHAR",            WM_IME_CHAR,                // 0x0286
     600        TMP_MTF_TYPE_IME},
     601    { "WM_IME_REQUEST",         WM_IME_REQUEST,             // 0x0288
    567602        TMP_MTF_TYPE_IME},
    568603#ifdef  FE_IME
    … …  
    572607        MTF_TYPE_IME},
    573608#endif
     609    { "WM_MOUSEHOVER", WM_MOUSEHOVER,                       // 0x02A1
     610      MTF_TYPE_MOUSE},
     611    { "WM_MOUSELEAVE", WM_MOUSELEAVE,                       // 0x02A3
     612      MTF_TYPE_MOUSE},
     613    { "WM_NCMOUSEHOVER", WM_NCMOUSEHOVER,                   // 0x02A0
     614      MTF_TYPE_MOUSE},
     615    { "WM_NCMOUSELEAVE", WM_NCMOUSELEAVE,                   // 0x02A2
     616      MTF_TYPE_MOUSE},
    574617    { "WM_CUT", WM_CUT,                                     // 0x0300
    575618        MTF_TYPE_CLIP},
    … …  
    610653    { "WM_HOTKEY", WM_HOTKEY,                               // 0x0312
    611654        MTF_TYPE_KEYBD},
    612     { "WM_QUERYAFXWNDPROC(MFC)", WM_QUERYAFXWNDPROC,             // 0x0360
     655    { "WM_PRINT", WM_PRINT,                                 // 0x0317
     656        0},
     657    { "WM_PRINTCLIENT", WM_PRINTCLIENT,                     // 0x0318
     658        0},
     659    { "WM_QUERYAFXWNDPROC(MFC)", WM_QUERYAFXWNDPROC,        // 0x0360
    613660        0},
    614661    { "WM_SIZEPARENT(MFC)", WM_SIZEPARENT,                  // 0x0361
    615662        0},
    616     { "WM_SETMESSAGESTRING(MFC)", WM_SETMESSAGESTRING,              // 0x0362
    617         0},
    618     { "WM_IDLEUPDATECMDUI(MFC)", WM_IDLEUPDATECMDUI,                // 0x0363
    619         0},
    620     { "WM_INITIALUPDATE(MFC)", WM_INITIALUPDATE,                // 0x0364
    621         0},
    622     { "WM_COMMANDHELP(MFC)", WM_COMMANDHELP,                    // 0x0365
    623         0},
    624     { "WM_HELPHITTEST(MFC)", WM_HELPHITTEST,                    // 0x0366
    625         0},
    626     { "WM_EXITHELPMODE(MFC)", WM_EXITHELPMODE,                  // 0x0367
    627         0},
    628     { "WM_RECALCPARENT(MFC)", WM_RECALCPARENT,                  // 0x0368
     663    { "WM_SETMESSAGESTRING(MFC)", WM_SETMESSAGESTRING,      // 0x0362
     664        0},
     665    { "WM_IDLEUPDATECMDUI(MFC)", WM_IDLEUPDATECMDUI,        // 0x0363
     666        0},
     667    { "WM_INITIALUPDATE(MFC)", WM_INITIALUPDATE,            // 0x0364
     668        0},
     669    { "WM_COMMANDHELP(MFC)", WM_COMMANDHELP,                // 0x0365
     670        0},
     671    { "WM_HELPHITTEST(MFC)", WM_HELPHITTEST,                // 0x0366
     672        0},
     673    { "WM_EXITHELPMODE(MFC)", WM_EXITHELPMODE,              // 0x0367
     674        0},
     675    { "WM_RECALCPARENT(MFC)", WM_RECALCPARENT,              // 0x0368
    629676        0},
    630677    { "WM_SIZECHILD(MFC)", WM_SIZECHILD,                    // 0x0369
    … …  
    632679    { "WM_KICKIDLE(MFC)", WM_KICKIDLE,                      // 0x036A
    633680        0},
    634     { "WM_QUERYCENTERWND(MFC)", WM_QUERYCENTERWND,                  // 0x036B
    635         0},
    636     { "WM_DISABLEMODAL(MFC)", WM_DISABLEMODAL,                  // 0x036C
     681    { "WM_QUERYCENTERWND(MFC)", WM_QUERYCENTERWND,          // 0x036B
     682        0},
     683    { "WM_DISABLEMODAL(MFC)", WM_DISABLEMODAL,              // 0x036C
    637684        0},
    638685    { "WM_FLOATSTATUS(MFC)", WM_FLOATSTATUS,                // 0x036D
    639686        0},
    640     { "WM_ACTIVATETOPLEVEL(MFC)", WM_ACTIVATETOPLEVEL,              // 0x036E
    641         0},
    642     { "WM_QUERY3DCONTROLS(MFC)", WM_QUERY3DCONTROLS,                // 0x036F
    643         0},
    644     { "WM_SOCKET_NOTIFY(MFC)", WM_SOCKET_NOTIFY,                // 0x0373
     687    { "WM_ACTIVATETOPLEVEL(MFC)", WM_ACTIVATETOPLEVEL,      // 0x036E
     688        0},
     689    { "WM_QUERY3DCONTROLS(MFC)", WM_QUERY3DCONTROLS,        // 0x036F
     690        0},
     691    { "WM_SOCKET_NOTIFY(MFC)", WM_SOCKET_NOTIFY,            // 0x0373
    645692        0},
    646693    { "WM_SOCKET_DEAD(MFC)", WM_SOCKET_DEAD,                // 0x0374
    647694        0},
    648     { "WM_POPMESSAGESTRING(MFC)", WM_POPMESSAGESTRING,              // 0x0375
    649         0},
    650     { "WM_OCC_LOADFROMSTREAM(MFC)", WM_OCC_LOADFROMSTREAM,          // 0x0376
    651         0},
    652     { "WM_OCC_LOADFROMSTORAGE(MFC)", WM_OCC_LOADFROMSTORAGE,     // 0x0377
     695    { "WM_POPMESSAGESTRING(MFC)", WM_POPMESSAGESTRING,      // 0x0375
     696        0},
     697    { "WM_OCC_LOADFROMSTREAM(MFC)", WM_OCC_LOADFROMSTREAM,  // 0x0376
     698        0},
     699    { "WM_OCC_LOADFROMSTORAGE(MFC)", WM_OCC_LOADFROMSTORAGE, // 0x0377
    653700        0},
    654701    { "WM_OCC_INITNEW(MFC)", WM_OCC_INITNEW,                // 0x0378
    655702        0},
    656     { "WM_QUEUE_SENTINEL(MFC)", WM_QUEUE_SENTINEL,               // 0x0379
     703    { "WM_QUEUE_SENTINEL(MFC)", WM_QUEUE_SENTINEL,          // 0x0379
    657704        0},
    658705    { "WM_OCC_LOADFROMSTREAM_EX(MFC)", WM_OCC_LOADFROMSTREAM_EX, // 0x037A
    … …  
    660707    { "WM_OCC_LOADFROMSTORAGE_EX(MFC)", WM_OCC_LOADFROMSTORAGE_EX, // 0x037B
    661708        0},
     709    { "WM_FORWARDMSG", WM_FORWARDMSG,                       // 0x037F
     710        0},
    662711    { "WM_DDE_INITIATE", WM_DDE_INITIATE,                   // 0x03E0
    663712        MTF_TYPE_DDE},
    … …  
    677726        MTF_TYPE_DDE},
    678727    { "WM_DDE_EXECUTE", WM_DDE_EXECUTE,                     // 0x03E8
    679         MTF_TYPE_DDE}
     728        MTF_TYPE_DDE},
     729    //WM_USER                         0x0400
     730      //CB: some dialog message are WM_USER+x
     731      //    shlobj.h, aclui.h, shellapi.h, prsht.h, commdlg.h, commctrl.h, tapi.h, cpl.h, ras.h, richedit.h, winwlx.h, wfext.h, scrmsave.h, olectl.h, ftsiface.h, dispdib.h, proppage.h, vfw.h, mapiwz.h
     732    //WM_APP                          0x8000
    680733};
    681734
Note: See TracChangeset for help on using the changeset viewer.