misc/callback.c

   1 /*
   2  * Function callbacks for the library
   3  *
   4  * Copyright 1997 Alexandre Julliard
   5  */
   6
   7 #include <assert.h>
   8 #include "winuser.h"
   9 #include "callback.h"
  10 #include "task.h"
  11 #include "syslevel.h"
  12 #include "cursoricon.h"
  13 #include "user.h"
  14 #include "queue.h"
  15 #include "debug.h"
  16 #include "win.h"
  17
  18
  19 /**********************************************************************
  20  *           CALLBACK_CallWndProc
  21  */
  22 static LRESULT WINAPI CALLBACK_CallWndProc( WNDPROC16 proc, HWND16 hwnd,
  23                                             UINT16 msg, WPARAM16 wParam,
  24                                             LPARAM lParam )
  25 {
  26     LRESULT retvalue;
  27     int iWndsLocks;
  28
  29     /* To avoid any deadlocks, all the locks on the windows structures
  30        must be suspended before the control is passed to the application */
  31     iWndsLocks = WIN_SuspendWndsLock();
  32     retvalue = proc( hwnd, msg, wParam, lParam );
  33     WIN_RestoreWndsLock(iWndsLocks);
  34     return retvalue;
  35 }
  36
  37
  38 /**********************************************************************
  39  *           CALLBACK_CallRegisterProc
  40  */
  41 static LONG WINAPI CALLBACK_CallRegisterProc( CONTEXT *context, INT offset)
  42 {
  43     ERR(relay, "Cannot call a register proc in Winelib\n" );
  44     assert( FALSE );
  45     return 0;
  46 }
  47
  48
  49 /**********************************************************************
  50  *           CALLBACK_CallDriverProc
  51  */
  52 static LRESULT WINAPI CALLBACK_CallDriverProc( DRIVERPROC16 proc, DWORD dwId,
  53                                                HDRVR16 hdrvr, UINT16 msg,
  54                                                LPARAM lp1, LPARAM lp2 )
  55 {
  56     return proc( dwId, hdrvr, msg, lp1, lp2 );
  57 }
  58
  59
  60 /**********************************************************************
  61  *           CALLBACK_CallDriverCallback
  62  */
  63 static LRESULT WINAPI CALLBACK_CallDriverCallback( FARPROC16 proc,
  64                                                    HANDLE16 hDev, UINT16 msg,
  65                                                    DWORD dwUser, LPARAM lp1,
  66                                                    LPARAM lp2 )
  67 {
  68     return proc( hDev, msg, dwUser, lp1, lp2 );
  69 }
  70
  71
  72 /**********************************************************************
  73  *           CALLBACK_CallTimeFuncProc
  74  */
  75 static LRESULT WINAPI CALLBACK_CallTimeFuncProc( FARPROC16 proc, WORD id,
  76                                                  UINT16 msg, DWORD dwUser,
  77                                                  LPARAM lp1, LPARAM lp2 )
  78 {
  79     return proc( id, msg, dwUser, lp1, lp2 );
  80 }
  81
  82
  83 /**********************************************************************
  84  *           CALLBACK_CallWindowsExitProc
  85  */
  86 static INT16 WINAPI CALLBACK_CallWindowsExitProc( FARPROC16 proc, INT16 type)
  87 {
  88     return proc( type );
  89 }
  90
  91
  92 /**********************************************************************
  93  *           CALLBACK_CallWordBreakProc
  94  */
  95 static INT16 WINAPI CALLBACK_CallWordBreakProc( EDITWORDBREAKPROC16 proc,
  96                                                 SEGPTR text, INT16 word,
  97                                                 INT16 len, INT16 action )
  98 {
  99     return proc( (LPSTR)text, word, len, action );
 100 }
 101
 102
 103 /**********************************************************************
 104  *           CALLBACK_CallBootAppProc
 105  */
 106 static void WINAPI CALLBACK_CallBootAppProc( FARPROC16 proc, HANDLE16 module,
 107                                              HFILE16 file )
 108 {
 109     proc( module, file );
 110 }
 111
 112
 113 /**********************************************************************
 114  *           CALLBACK_CallLoadAppSegProc
 115  */
 116 static WORD WINAPI CALLBACK_CallLoadAppSegProc( FARPROC16 proc,
 117                                                 HANDLE16 module, HFILE16 file,
 118                                                 WORD seg )
 119 {
 120     return proc( module, file, seg );
 121 }
 122
 123
 124 /**********************************************************************
 125  *           CALLBACK_CallLocalNotifyFunc
 126  */
 127 static WORD WINAPI CALLBACK_CallLocalNotifyFunc( FARPROC16 proc,
 128                                                  WORD wMsg, HLOCAL16 hMem,
 129                                                  WORD wArg )
 130 {
 131     return proc( wMsg, hMem, wArg );
 132 }
 133
 134
 135 /**********************************************************************
 136  *           CALLBACK_CallResourceHandlerProc
 137  */
 138 static HGLOBAL16 WINAPI CALLBACK_CallResourceHandlerProc( FARPROC16 proc,
 139                                                           HGLOBAL16 hMemObj,
 140                                                           HMODULE16 hModule,
 141                                                           HRSRC16 hRsrc )
 142 {
 143     ERR( relay, "Cannot call a 16-bit resource handler in Winelib\n" );
 144     assert( FALSE );
 145     return 0;
 146 }
 147
 148
 149 /**********************************************************************
 150  *           CALLBACK_CallASPIPostProc
 151  */
 152 static LRESULT WINAPI CALLBACK_CallASPIPostProc( FARPROC16 proc, SEGPTR ptr )
 153 {
 154     return proc( ptr );
 155 }
 156
 157
 158 /**********************************************************************
 159  *           CALLBACK_CallWOWCallbackProc
 160  */
 161 static DWORD WINAPI CALLBACK_CallWOWCallbackProc( FARPROC16 proc, DWORD dw )
 162 {
 163     return proc( dw );
 164 }
 165
 166 /**********************************************************************
 167  *           CALLBACK_CallWOWCallback16Ex
 168  *
 169  * WCB16_MAX_CBARGS (16) is the maximum number of args.
 170  *
 171  * Can call functions using CDECL or PASCAL calling conventions. The CDECL
 172  * ones are reversed (not 100% sure about that).
 173  */
 174 static BOOL WINAPI CALLBACK_CallWOWCallback16Ex(
 175         FARPROC16 proc, DWORD dwFlags, DWORD cbArgs, LPVOID xargs,LPDWORD pdwret
 176 ) {
 177     LPDWORD     args = (LPDWORD)xargs;
 178     DWORD       ret,i;
 179
 180     if (dwFlags == WCB16_CDECL) {
 181         /* swap the arguments */
 182         args = HeapAlloc(GetProcessHeap(),0,cbArgs*sizeof(DWORD));
 183         for (i=0;i<cbArgs;i++)
 184                 args[i] = ((DWORD*)xargs)[cbArgs-i-1];
 185     }
 186     switch (cbArgs) {
 187     case 0: ret = proc();break;
 188     case 1: ret = proc(args[0]);break;
 189     case 2: ret = proc(args[0],args[1]);break;
 190     case 3: ret = proc(args[0],args[1],args[2]);break;
 191     case 4: ret = proc(args[0],args[1],args[2],args[3]);break;
 192     case 5: ret = proc(args[0],args[1],args[2],args[3],args[4]);break;
 193     case 6: ret = proc(args[0],args[1],args[2],args[3],args[4],args[5]);
 194             break;
 195     case 7: ret = proc(args[0],args[1],args[2],args[3],args[4],args[5],
 196                     args[6]
 197             );
 198             break;
 199     case 8: ret = proc(args[0],args[1],args[2],args[3],args[4],args[5],
 200                     args[6],args[7]
 201             );
 202             break;
 203     case 9: ret = proc(args[0],args[1],args[2],args[3],args[4],args[5],
 204                     args[6],args[7],args[8]
 205             );
 206             break;
 207     case 10:ret = proc(args[0],args[1],args[2],args[3],args[4],args[5],
 208                     args[6],args[7],args[8],args[9]
 209             );
 210             break;
 211     case 11:ret = proc(args[0],args[1],args[2],args[3],args[4],args[5],
 212                     args[6],args[7],args[8],args[9],args[10]
 213             );
 214             break;
 215     case 12:ret = proc(args[0],args[1],args[2],args[3],args[4],args[5],
 216                     args[6],args[7],args[8],args[9],args[10],args[11]
 217             );
 218             break;
 219     case 13:ret = proc(args[0],args[1],args[2],args[3],args[4],args[5],
 220                     args[6],args[7],args[8],args[9],args[10],args[11],
 221                     args[12]
 222             );
 223             break;
 224     case 14:ret = proc(args[0],args[1],args[2],args[3],args[4],args[5],
 225                     args[6],args[7],args[8],args[9],args[10],args[11],
 226                     args[12],args[13]
 227             );
 228             break;
 229     case 15:ret = proc(args[0],args[1],args[2],args[3],args[4],args[5],
 230                     args[6],args[7],args[8],args[9],args[10],args[11],
 231                     args[12],args[13],args[14]
 232             );
 233             break;
 234     case 16:ret = proc(args[0],args[1],args[2],args[3],args[4],args[5],
 235                     args[6],args[7],args[8],args[9],args[10],args[11],
 236                     args[12],args[13],args[14],args[15]
 237             );
 238             break;
 239     default:
 240             WARN(relay,"(%ld) arguments not supported.\n",cbArgs);
 241             if (dwFlags == WCB16_CDECL)
 242                 HeapFree(GetProcessHeap(),0,args);
 243             return FALSE;
 244     }
 245     if (dwFlags == WCB16_CDECL)
 246         HeapFree(GetProcessHeap(),0,args);
 247     if (pdwret)
 248         *pdwret = ret;
 249     return TRUE;
 250 }
 251
 252 /**********************************************************************
 253  *           CALLBACK_CallUTProc
 254  */
 255 static DWORD WINAPI CALLBACK_CallUTProc( FARPROC16 proc, DWORD w1, DWORD w2 )
 256 {
 257     ERR( relay, "Cannot call a UT thunk proc in Winelib\n" );
 258     assert( FALSE );
 259     return 0;
 260 }
 261
 262 /**********************************************************************
 263  *           CALLBACK_CallTaskRescheduleProc
 264  */
 265 static BOOL WINAPI CALLBACK_CallTaskRescheduleProc( void )
 266 {
 267     BOOL pending;
 268
 269     SYSLEVEL_EnterWin16Lock();
 270     pending = TASK_Reschedule();
 271     SYSLEVEL_LeaveWin16Lock();
 272
 273     return pending;
 274 }
 275
 276
 277 /**********************************************************************
 278  *           CALLBACK_WinelibTable
 279  *
 280  * The callbacks function table for Winelib
 281  */
 282 static const CALLBACKS_TABLE CALLBACK_WinelibTable =
 283 {
 284     CALLBACK_CallRegisterProc,        /* CallRegisterShortProc */
 285     CALLBACK_CallRegisterProc,        /* CallRegisterLongProc */
 286     CALLBACK_CallTaskRescheduleProc,  /* CallTaskRescheduleProc */
 287     NULL,                             /* CallFrom16WndProc */
 288     CALLBACK_CallWndProc,             /* CallWndProc */
 289     CALLBACK_CallDriverProc,          /* CallDriverProc */
 290     CALLBACK_CallDriverCallback,      /* CallDriverCallback */
 291     CALLBACK_CallTimeFuncProc,        /* CallTimeFuncProc */
 292     CALLBACK_CallWindowsExitProc,     /* CallWindowsExitProc */
 293     CALLBACK_CallWordBreakProc,       /* CallWordBreakProc */
 294     CALLBACK_CallBootAppProc,         /* CallBootAppProc */
 295     CALLBACK_CallLoadAppSegProc,      /* CallLoadAppSegProc */
 296     CALLBACK_CallLocalNotifyFunc,     /* CallLocalNotifyFunc */
 297     CALLBACK_CallResourceHandlerProc, /* CallResourceHandlerProc */
 298     CALLBACK_CallWOWCallbackProc,     /* CallWOWCallbackProc */
 299     CALLBACK_CallWOWCallback16Ex,     /* CallWOWCallback16Ex */
 300     CALLBACK_CallUTProc,              /* CallUTProc */
 301     CALLBACK_CallASPIPostProc,        /* CallASPIPostProc */
 302     /* The graphics driver callbacks are never used in Winelib */
 303     NULL,                             /* CallDrvControlProc */
 304     NULL,                             /* CallDrvEnableProc */
 305     NULL,                             /* CallDrvEnumDFontsProc */
 306     NULL,                             /* CallDrvEnumObjProc */
 307     NULL,                             /* CallDrvOutputProc */
 308     NULL,                             /* CallDrvRealizeProc */
 309     NULL,                             /* CallDrvStretchBltProc */
 310     NULL,                             /* CallDrvExtTextOutProc */
 311     NULL,                             /* CallDrvGetCharWidth */
 312     NULL                              /* CallDrvAbortProc */
 313 };
 314
 315 const CALLBACKS_TABLE *Callbacks = &CALLBACK_WinelibTable;
 316
 317
 318 /**********************************************************************
 319  *           CALLOUT_Table
 320  *
 321  * The callout function table for Winelib
 322  */
 323
 324 CALLOUT_TABLE Callout =
 325 {
 326     PeekMessage16, PeekMessageA, PeekMessageW,
 327     GetMessage16, GetMessageA, GetMessageW,
 328     SendMessage16, SendMessageA, SendMessageW,
 329     PostMessage16, PostMessageA, PostMessageW,
 330     PostAppMessage16, PostThreadMessageA, PostThreadMessageW,
 331     TranslateMessage16, TranslateMessage,
 332     DispatchMessage16, DispatchMessageA, DispatchMessageW,
 333     RedrawWindow16, RedrawWindow,
 334     UserSignalProc,
 335     InitApp16, InitThreadInput16,
 336     UserYield16,
 337     CURSORICON_Destroy
 338 };
 339