npupp_8h-source.html

npupp.h

00001 /* -*- Mode: C; tab-width: 4; -*- */
00002 /*
00003  *  npupp.h $Revision: 1.1 $
00004  *  function call mecahnics needed by platform specific glue code.
00005  */
00006 
00007 
00008 #ifndef _NPUPP_H_
00009 #define _NPUPP_H_
00010 
00011 #ifndef GENERATINGCFM
00012 #define GENERATINGCFM 0
00013 #endif
00014 
00015 #ifndef _NPAPI_H_
00016 #include "npapi.h"
00017 #endif
00018 
00019 #include "jri.h"
00020 
00021 /******************************************************************************************
00022    plug-in function table macros
00023                 for each function in and out of the plugin API we define
00024                     typedef NPP_FooUPP
00025                                         #define NewNPP_FooProc
00026                                         #define CallNPP_FooProc
00027                         for mac, define the UPP magic for PPC/68K calling
00028  *******************************************************************************************/
00029 
00030 
00031 /* NPP_Initialize */
00032 
00033 #if GENERATINGCFM
00034 typedef UniversalProcPtr NPP_InitializeUPP;
00035 
00036 enum {
00037         uppNPP_InitializeProcInfo = kThinkCStackBased
00038                 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(0))              
00039                 | RESULT_SIZE(SIZE_CODE(0))
00040 };
00041 
00042 #define NewNPP_InitializeProc(FUNC)             \
00043                 (NPP_InitializeUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_InitializeProcInfo, GetCurrentArchitecture())
00044 #define CallNPP_InitializeProc(FUNC)            \
00045                 (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_InitializeProcInfo)
00046                 
00047 #else
00048 
00049 typedef void (*NPP_InitializeUPP)(void);
00050 #define NewNPP_InitializeProc(FUNC)             \
00051                 ((NPP_InitializeUPP) (FUNC))
00052 #define CallNPP_InitializeProc(FUNC)            \
00053                 (*(FUNC))()
00054 
00055 #endif
00056 
00057 
00058 /* NPP_Shutdown */
00059 
00060 #if GENERATINGCFM
00061 typedef UniversalProcPtr NPP_ShutdownUPP;
00062 
00063 enum {
00064         uppNPP_ShutdownProcInfo = kThinkCStackBased
00065                 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(0))              
00066                 | RESULT_SIZE(SIZE_CODE(0))
00067 };
00068 
00069 #define NewNPP_ShutdownProc(FUNC)               \
00070                 (NPP_ShutdownUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_ShutdownProcInfo, GetCurrentArchitecture())
00071 #define CallNPP_ShutdownProc(FUNC)              \
00072                 (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_ShutdownProcInfo)
00073                 
00074 #else
00075 
00076 typedef void (*NPP_ShutdownUPP)(void);
00077 #define NewNPP_ShutdownProc(FUNC)               \
00078                 ((NPP_ShutdownUPP) (FUNC))
00079 #define CallNPP_ShutdownProc(FUNC)              \
00080                 (*(FUNC))()
00081 
00082 #endif
00083 
00084 
00085 /* NPP_New */
00086 
00087 #if GENERATINGCFM
00088 typedef UniversalProcPtr NPP_NewUPP;
00089 
00090 enum {
00091         uppNPP_NewProcInfo = kThinkCStackBased
00092                 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPMIMEType)))
00093                 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPP)))
00094                 | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(uint16)))
00095                 | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(int16)))
00096                 | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(char **)))
00097                 | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(char **)))
00098                 | STACK_ROUTINE_PARAMETER(7, SIZE_CODE(sizeof(NPSavedData *)))
00099                 | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
00100 };
00101 
00102 #define NewNPP_NewProc(FUNC)            \
00103                 (NPP_NewUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_NewProcInfo, GetCurrentArchitecture())
00104 #define CallNPP_NewProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) \
00105                 (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_NewProcInfo, \
00106                                                                    (ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6), (ARG7))
00107 #else
00108 
00109 typedef NPError (*NPP_NewUPP)(NPMIMEType pluginType, NPP instance, uint16 mode, int16 argc, char* argn[], char* argv[], NPSavedData* saved);
00110 #define NewNPP_NewProc(FUNC)            \
00111                 ((NPP_NewUPP) (FUNC))
00112 #define CallNPP_NewProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7)         \
00113                 (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6), (ARG7))
00114 
00115 #endif
00116 
00117 
00118 /* NPP_Destroy */
00119 
00120 #if GENERATINGCFM
00121 
00122 typedef UniversalProcPtr NPP_DestroyUPP;
00123 enum {
00124         uppNPP_DestroyProcInfo = kThinkCStackBased
00125                 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
00126                 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPSavedData **)))
00127                 | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
00128 };
00129 #define NewNPP_DestroyProc(FUNC)                \
00130                 (NPP_DestroyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_DestroyProcInfo, GetCurrentArchitecture())
00131 #define CallNPP_DestroyProc(FUNC, ARG1, ARG2)           \
00132                 (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_DestroyProcInfo, (ARG1), (ARG2))
00133 #else
00134 
00135 typedef NPError (*NPP_DestroyUPP)(NPP instance, NPSavedData** save);
00136 #define NewNPP_DestroyProc(FUNC)                \
00137                 ((NPP_DestroyUPP) (FUNC))
00138 #define CallNPP_DestroyProc(FUNC, ARG1, ARG2)           \
00139                 (*(FUNC))((ARG1), (ARG2))
00140 
00141 #endif
00142 
00143 
00144 /* NPP_SetWindow */
00145 
00146 #if GENERATINGCFM
00147 
00148 typedef UniversalProcPtr NPP_SetWindowUPP;
00149 enum {
00150         uppNPP_SetWindowProcInfo = kThinkCStackBased
00151                 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
00152                 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPWindow *)))
00153                 | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
00154 };
00155 #define NewNPP_SetWindowProc(FUNC)              \
00156                 (NPP_SetWindowUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_SetWindowProcInfo, GetCurrentArchitecture())
00157 #define CallNPP_SetWindowProc(FUNC, ARG1, ARG2)         \
00158                 (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_SetWindowProcInfo, (ARG1), (ARG2))
00159 
00160 #else
00161 
00162 typedef NPError (*NPP_SetWindowUPP)(NPP instance, NPWindow* window);
00163 #define NewNPP_SetWindowProc(FUNC)              \
00164                 ((NPP_SetWindowUPP) (FUNC))
00165 #define CallNPP_SetWindowProc(FUNC, ARG1, ARG2)         \
00166                 (*(FUNC))((ARG1), (ARG2))
00167 
00168 #endif
00169 
00170 
00171 /* NPP_NewStream */
00172 
00173 #if GENERATINGCFM
00174 
00175 typedef UniversalProcPtr NPP_NewStreamUPP;
00176 enum {
00177         uppNPP_NewStreamProcInfo = kThinkCStackBased
00178                 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
00179                 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPMIMEType)))
00180                 | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPStream *)))
00181                 | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(NPBool)))
00182                 | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(uint16 *)))
00183                 | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
00184 };
00185 #define NewNPP_NewStreamProc(FUNC)              \
00186                 (NPP_NewStreamUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_NewStreamProcInfo, GetCurrentArchitecture())
00187 #define CallNPP_NewStreamProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5)               \
00188                 (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_NewStreamProcInfo, (ARG1), (ARG2), (ARG3), (ARG4), (ARG5))
00189 #else
00190 
00191 typedef NPError (*NPP_NewStreamUPP)(NPP instance, NPMIMEType type, NPStream* stream, NPBool seekable, uint16* stype);
00192 #define NewNPP_NewStreamProc(FUNC)              \
00193                 ((NPP_NewStreamUPP) (FUNC))
00194 #define CallNPP_NewStreamProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5) \
00195                 (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4), (ARG5))
00196 #endif
00197 
00198 
00199 /* NPP_DestroyStream */
00200 
00201 #if GENERATINGCFM
00202 
00203 typedef UniversalProcPtr NPP_DestroyStreamUPP;
00204 enum {
00205         uppNPP_DestroyStreamProcInfo = kThinkCStackBased
00206                 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
00207                 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPStream *)))
00208                 | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPReason)))
00209                 | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
00210 };
00211 #define NewNPP_DestroyStreamProc(FUNC)          \
00212                 (NPP_DestroyStreamUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_DestroyStreamProcInfo, GetCurrentArchitecture())
00213 #define CallNPP_DestroyStreamProc(FUNC,  NPParg, NPStreamPtr, NPReasonArg)              \
00214                 (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_DestroyStreamProcInfo, (NPParg), (NPStreamPtr), (NPReasonArg))
00215 
00216 #else
00217 
00218 typedef NPError (*NPP_DestroyStreamUPP)(NPP instance, NPStream* stream, NPReason reason);
00219 #define NewNPP_DestroyStreamProc(FUNC)          \
00220                 ((NPP_DestroyStreamUPP) (FUNC))
00221 #define CallNPP_DestroyStreamProc(FUNC,  NPParg, NPStreamPtr, NPReasonArg)              \
00222                 (*(FUNC))((NPParg), (NPStreamPtr), (NPReasonArg))
00223 
00224 #endif
00225 
00226 
00227 /* NPP_WriteReady */
00228 
00229 #if GENERATINGCFM
00230 
00231 typedef UniversalProcPtr NPP_WriteReadyUPP;
00232 enum {
00233         uppNPP_WriteReadyProcInfo = kThinkCStackBased
00234                 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
00235                 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPStream *)))
00236                 | RESULT_SIZE(SIZE_CODE(sizeof(int32)))
00237 };
00238 #define NewNPP_WriteReadyProc(FUNC)             \
00239                 (NPP_WriteReadyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_WriteReadyProcInfo, GetCurrentArchitecture())
00240 #define CallNPP_WriteReadyProc(FUNC,  NPParg, NPStreamPtr)              \
00241                 (int32)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_WriteReadyProcInfo, (NPParg), (NPStreamPtr))
00242 
00243 #else
00244 
00245 typedef int32 (*NPP_WriteReadyUPP)(NPP instance, NPStream* stream);
00246 #define NewNPP_WriteReadyProc(FUNC)             \
00247                 ((NPP_WriteReadyUPP) (FUNC))
00248 #define CallNPP_WriteReadyProc(FUNC,  NPParg, NPStreamPtr)              \
00249                 (*(FUNC))((NPParg), (NPStreamPtr))
00250 
00251 #endif
00252 
00253 
00254 /* NPP_Write */
00255 
00256 #if GENERATINGCFM
00257 
00258 typedef UniversalProcPtr NPP_WriteUPP;
00259 enum {
00260         uppNPP_WriteProcInfo = kThinkCStackBased
00261                 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
00262                 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPStream *)))
00263                 | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(int32)))
00264                 | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(int32)))
00265                 | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(void*)))
00266                 | RESULT_SIZE(SIZE_CODE(sizeof(int32)))
00267 };
00268 #define NewNPP_WriteProc(FUNC)          \
00269                 (NPP_WriteUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_WriteProcInfo, GetCurrentArchitecture())
00270 #define CallNPP_WriteProc(FUNC,  NPParg, NPStreamPtr, offsetArg, lenArg, bufferPtr)             \
00271                 (int32)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_WriteProcInfo, (NPParg), (NPStreamPtr), (offsetArg), (lenArg), (bufferPtr))
00272 
00273 #else
00274 
00275 typedef int32 (*NPP_WriteUPP)(NPP instance, NPStream* stream, int32 offset, int32 len, void* buffer);
00276 #define NewNPP_WriteProc(FUNC)          \
00277                 ((NPP_WriteUPP) (FUNC))
00278 #define CallNPP_WriteProc(FUNC,  NPParg, NPStreamPtr, offsetArg, lenArg, bufferPtr)             \
00279                 (*(FUNC))((NPParg), (NPStreamPtr), (offsetArg), (lenArg), (bufferPtr))
00280 
00281 #endif
00282 
00283 
00284 /* NPP_StreamAsFile */
00285 
00286 #if GENERATINGCFM
00287 
00288 typedef UniversalProcPtr NPP_StreamAsFileUPP;
00289 enum {
00290         uppNPP_StreamAsFileProcInfo = kThinkCStackBased
00291                 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
00292                 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPStream *)))
00293                 | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(const char *)))
00294                 | RESULT_SIZE(SIZE_CODE(0))
00295 };
00296 #define NewNPP_StreamAsFileProc(FUNC)           \
00297                 (NPP_StreamAsFileUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_StreamAsFileProcInfo, GetCurrentArchitecture())
00298 #define CallNPP_StreamAsFileProc(FUNC, ARG1, ARG2, ARG3)                \
00299                 (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_StreamAsFileProcInfo, (ARG1), (ARG2), (ARG3))
00300 
00301 #else
00302 
00303 typedef void (*NPP_StreamAsFileUPP)(NPP instance, NPStream* stream, const char* fname);
00304 #define NewNPP_StreamAsFileProc(FUNC)           \
00305                 ((NPP_StreamAsFileUPP) (FUNC))
00306 #define CallNPP_StreamAsFileProc(FUNC,  ARG1, ARG2, ARG3)               \
00307                 (*(FUNC))((ARG1), (ARG2), (ARG3))
00308 #endif
00309 
00310 
00311 /* NPP_Print */
00312 
00313 #if GENERATINGCFM
00314 
00315 typedef UniversalProcPtr NPP_PrintUPP;
00316 enum {
00317         uppNPP_PrintProcInfo = kThinkCStackBased
00318                 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
00319                 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPPrint *)))
00320                 | RESULT_SIZE(SIZE_CODE(0))
00321 };
00322 #define NewNPP_PrintProc(FUNC)          \
00323                 (NPP_PrintUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_PrintProcInfo, GetCurrentArchitecture())
00324 #define CallNPP_PrintProc(FUNC,  NPParg, voidPtr)               \
00325                 (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_PrintProcInfo, (NPParg), (voidPtr))
00326 
00327 #else
00328 
00329 typedef void (*NPP_PrintUPP)(NPP instance, NPPrint* platformPrint);
00330 #define NewNPP_PrintProc(FUNC)          \
00331                 ((NPP_PrintUPP) (FUNC))
00332 #define CallNPP_PrintProc(FUNC,  NPParg, NPPrintArg)            \
00333                 (*(FUNC))((NPParg), (NPPrintArg))
00334 
00335 #endif
00336 
00337 
00338 /* NPP_HandleEvent */
00339 
00340 #if GENERATINGCFM
00341 
00342 typedef UniversalProcPtr NPP_HandleEventUPP;
00343 enum {
00344         uppNPP_HandleEventProcInfo = kThinkCStackBased
00345                 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
00346                 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(void *)))
00347                 | RESULT_SIZE(SIZE_CODE(sizeof(int16)))
00348 };
00349 #define NewNPP_HandleEventProc(FUNC)            \
00350                 (NPP_HandleEventUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_HandleEventProcInfo, GetCurrentArchitecture())
00351 #define CallNPP_HandleEventProc(FUNC,  NPParg, voidPtr)         \
00352                 (int16)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_HandleEventProcInfo, (NPParg), (voidPtr))
00353 
00354 #else
00355 
00356 typedef int16 (*NPP_HandleEventUPP)(NPP instance, void* event);
00357 #define NewNPP_HandleEventProc(FUNC)            \
00358                 ((NPP_HandleEventUPP) (FUNC))
00359 #define CallNPP_HandleEventProc(FUNC,  NPParg, voidPtr)         \
00360                 (*(FUNC))((NPParg), (voidPtr))
00361 
00362 #endif
00363 
00364 
00365 /* NPP_URLNotify */
00366 
00367 #if GENERATINGCFM
00368 
00369 typedef UniversalProcPtr NPP_URLNotifyUPP;
00370 enum {
00371         uppNPP_URLNotifyProcInfo = kThinkCStackBased
00372                 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
00373                 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(const char*)))
00374                 | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPReason)))
00375                 | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(void*)))
00376                 | RESULT_SIZE(SIZE_CODE(SIZE_CODE(0)))
00377 };
00378 #define NewNPP_URLNotifyProc(FUNC)              \
00379                 (NPP_URLNotifyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_URLNotifyProcInfo, GetCurrentArchitecture())
00380 #define CallNPP_URLNotifyProc(FUNC,  ARG1, ARG2, ARG3, ARG4)            \
00381                 (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_URLNotifyProcInfo, (ARG1), (ARG2), (ARG3), (ARG4))
00382 
00383 #else
00384 
00385 typedef void (*NPP_URLNotifyUPP)(NPP instance, const char* url, NPReason reason, void* notifyData);
00386 #define NewNPP_URLNotifyProc(FUNC)              \
00387                 ((NPP_URLNotifyUPP) (FUNC))
00388 #define CallNPP_URLNotifyProc(FUNC,  ARG1, ARG2, ARG3, ARG4)            \
00389                 (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4))
00390 
00391 #endif
00392 
00393 
00394 
00395 
00396 /*
00397  *  Netscape entry points
00398  */
00399 
00400 #ifdef XP_UNIX
00401 
00402 /* NPN_GetValue */
00403 
00404 #if GENERATINGCFM
00405 
00406 typedef UniversalProcPtr NPN_GetValueUPP;
00407 enum {
00408         uppNPN_GetValueProcInfo = kThinkCStackBased
00409                 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
00410                 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPNVariable)))
00411                 | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void *)))
00412                 | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
00413 };
00414 #define NewNPN_GetValueProc(FUNC)               \
00415                 (NPN_GetValueUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetValueProcInfo, GetCurrentArchitecture())
00416 #define CallNPN_GetURNotifyLProc(FUNC, ARG1, ARG2, ARG3) \
00417                 (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetValueProcInfo, (ARG1), (ARG2), (ARG3))
00418 #else
00419 
00420 typedef NPError (*NPN_GetValueUPP)(NPP instance, NPNVariable variable, void *ret_alue);
00421 #define NewNPN_GetValueProc(FUNC)               \
00422                 ((NPN_GetValueUPP) (FUNC))
00423 #define CallNPN_GetValueProc(FUNC, ARG1, ARG2, ARG3)            \
00424                 (*(FUNC))((ARG1), (ARG2), (ARG3))
00425 #endif
00426 
00427 #endif /* XP_UNIX */
00428 
00429 
00430 
00431 /* NPN_GetUrlNotify */
00432 
00433 #if GENERATINGCFM
00434 
00435 typedef UniversalProcPtr NPN_GetURLNotifyUPP;
00436 enum {
00437         uppNPN_GetURLNotifyProcInfo = kThinkCStackBased
00438                 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
00439                 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(const char*)))
00440                 | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(const char*)))
00441                 | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(void*)))
00442                 | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
00443 };
00444 #define NewNPN_GetURLNotifyProc(FUNC)           \
00445                 (NPN_GetURLNotifyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetURLNotifyProcInfo, GetCurrentArchitecture())
00446 #define CallNPN_GetURLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4) \
00447                 (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetURLNotifyProcInfo, (ARG1), (ARG2), (ARG3), (ARG4))
00448 #else
00449 
00450 typedef NPError (*NPN_GetURLNotifyUPP)(NPP instance, const char* url, const char* window, void* notifyData);
00451 #define NewNPN_GetURLNotifyProc(FUNC)           \
00452                 ((NPN_GetURLNotifyUPP) (FUNC))
00453 #define CallNPN_GetURLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4)          \
00454                 (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4))
00455 #endif
00456 
00457 
00458 /* NPN_PostUrlNotify */
00459 
00460 #if GENERATINGCFM
00461 
00462 typedef UniversalProcPtr NPN_PostURLNotifyUPP;
00463 enum {
00464         uppNPN_PostURLNotifyProcInfo = kThinkCStackBased
00465                 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
00466                 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(const char*)))
00467                 | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(const char*)))
00468                 | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(uint32)))
00469                 | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(const char*)))
00470                 | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(NPBool)))
00471                 | STACK_ROUTINE_PARAMETER(7, SIZE_CODE(sizeof(void*)))
00472                 | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
00473 };
00474 #define NewNPN_PostURLNotifyProc(FUNC)          \
00475                 (NPN_PostURLNotifyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_PostURLNotifyProcInfo, GetCurrentArchitecture())
00476 #define CallNPN_PostURLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) \
00477                 (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_PostURLNotifyProcInfo, (ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6), (ARG7))
00478 #else
00479 
00480 typedef NPError (*NPN_PostURLNotifyUPP)(NPP instance, const char* url, const char* window, uint32 len, const char* buf, NPBool file, void* notifyData);
00481 #define NewNPN_PostURLNotifyProc(FUNC)          \
00482                 ((NPN_PostURLNotifyUPP) (FUNC))
00483 #define CallNPN_PostURLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) \
00484                 (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6), (ARG7))
00485 #endif
00486 
00487 
00488 /* NPN_GetUrl */
00489 
00490 #if GENERATINGCFM
00491 
00492 typedef UniversalProcPtr NPN_GetURLUPP;
00493 enum {
00494         uppNPN_GetURLProcInfo = kThinkCStackBased
00495                 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
00496                 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(const char*)))
00497                 | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(const char*)))
00498                 | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
00499 };
00500 #define NewNPN_GetURLProc(FUNC)         \
00501                 (NPN_GetURLUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetURLProcInfo, GetCurrentArchitecture())
00502 #define CallNPN_GetURLProc(FUNC, ARG1, ARG2, ARG3) \
00503                 (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetURLProcInfo, (ARG1), (ARG2), (ARG3))
00504 #else
00505 
00506 typedef NPError (*NPN_GetURLUPP)(NPP instance, const char* url, const char* window);
00507 #define NewNPN_GetURLProc(FUNC)         \
00508                 ((NPN_GetURLUPP) (FUNC))
00509 #define CallNPN_GetURLProc(FUNC, ARG1, ARG2, ARG3)              \
00510                 (*(FUNC))((ARG1), (ARG2), (ARG3))
00511 #endif
00512 
00513 
00514 /* NPN_PostUrl */
00515 
00516 #if GENERATINGCFM
00517 
00518 typedef UniversalProcPtr NPN_PostURLUPP;
00519 enum {
00520         uppNPN_PostURLProcInfo = kThinkCStackBased
00521                 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
00522                 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(const char*)))
00523                 | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(const char*)))
00524                 | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(uint32)))
00525                 | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(const char*)))
00526                 | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(NPBool)))
00527                 | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
00528 };
00529 #define NewNPN_PostURLProc(FUNC)                \
00530                 (NPN_PostURLUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_PostURLProcInfo, GetCurrentArchitecture())
00531 #define CallNPN_PostURLProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) \
00532                 (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_PostURLProcInfo, (ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6))
00533 #else
00534 
00535 typedef NPError (*NPN_PostURLUPP)(NPP instance, const char* url, const char* window, uint32 len, const char* buf, NPBool file);
00536 #define NewNPN_PostURLProc(FUNC)                \
00537                 ((NPN_PostURLUPP) (FUNC))
00538 #define CallNPN_PostURLProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) \
00539                 (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6))
00540 #endif
00541 
00542 
00543 /* NPN_RequestRead */
00544 
00545 #if GENERATINGCFM
00546 
00547 typedef UniversalProcPtr NPN_RequestReadUPP;
00548 enum {
00549         uppNPN_RequestReadProcInfo = kThinkCStackBased
00550                 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPStream *)))
00551                 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPByteRange *)))
00552                 | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
00553 };
00554 #define NewNPN_RequestReadProc(FUNC)            \
00555                 (NPN_RequestReadUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_RequestReadProcInfo, GetCurrentArchitecture())
00556 #define CallNPN_RequestReadProc(FUNC,  stream, range)           \
00557                 (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_RequestReadProcInfo, (stream), (range))
00558 
00559 #else
00560 
00561 typedef NPError (*NPN_RequestReadUPP)(NPStream* stream, NPByteRange* rangeList);
00562 #define NewNPN_RequestReadProc(FUNC)            \
00563                 ((NPN_RequestReadUPP) (FUNC))
00564 #define CallNPN_RequestReadProc(FUNC, stream, range)            \
00565                 (*(FUNC))((stream), (range))
00566 
00567 #endif
00568 
00569 
00570 /* NPN_NewStream */
00571 
00572 #if GENERATINGCFM
00573 
00574 typedef UniversalProcPtr NPN_NewStreamUPP;
00575 enum {
00576         uppNPN_NewStreamProcInfo = kThinkCStackBased
00577                 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
00578                 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPMIMEType)))
00579                 | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(const char *)))
00580                 | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(NPStream **)))
00581                 | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
00582 };
00583 #define NewNPN_NewStreamProc(FUNC)              \
00584                 (NPN_NewStreamUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_NewStreamProcInfo, GetCurrentArchitecture())
00585 #define CallNPN_NewStreamProc(FUNC, npp, type, window, stream)          \
00586                 (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_NewStreamProcInfo, (npp), (type), (window), (stream))       
00587 
00588 #else
00589 
00590 typedef NPError (*NPN_NewStreamUPP)(NPP instance, NPMIMEType type, const char* window, NPStream** stream);
00591 #define NewNPN_NewStreamProc(FUNC)              \
00592                 ((NPN_NewStreamUPP) (FUNC))
00593 #define CallNPN_NewStreamProc(FUNC, npp, type, window, stream)          \
00594                 (*(FUNC))((npp), (type), (window), (stream))
00595 
00596 #endif
00597 
00598 
00599 /* NPN_Write */
00600 
00601 #if GENERATINGCFM
00602 
00603 typedef UniversalProcPtr NPN_WriteUPP;
00604 enum {
00605         uppNPN_WriteProcInfo = kThinkCStackBased
00606                 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
00607                 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPStream *)))
00608                 | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(int32)))
00609                 | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(void*)))
00610                 | RESULT_SIZE(SIZE_CODE(sizeof(int32)))
00611 };
00612 #define NewNPN_WriteProc(FUNC)          \
00613                 (NPN_WriteUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_WriteProcInfo, GetCurrentArchitecture())
00614 #define CallNPN_WriteProc(FUNC, npp, stream, len, buffer)               \
00615                 (int32)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_WriteProcInfo, (npp), (stream), (len), (buffer))      
00616 
00617 #else
00618 
00619 typedef int32 (*NPN_WriteUPP)(NPP instance, NPStream* stream, int32 len, void* buffer);
00620 #define NewNPN_WriteProc(FUNC)          \
00621                 ((NPN_WriteUPP) (FUNC))
00622 #define CallNPN_WriteProc(FUNC, npp, stream, len, buffer)               \
00623                 (*(FUNC))((npp), (stream), (len), (buffer))
00624 
00625 #endif
00626 
00627 
00628 /* NPN_DestroyStream */
00629 
00630 #if GENERATINGCFM
00631 
00632 typedef UniversalProcPtr NPN_DestroyStreamUPP;
00633 enum {
00634         uppNPN_DestroyStreamProcInfo = kThinkCStackBased
00635                 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP )))
00636                 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPStream *)))
00637                 | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPReason)))
00638                 | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
00639 };
00640 #define NewNPN_DestroyStreamProc(FUNC)          \
00641                 (NPN_DestroyStreamUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_DestroyStreamProcInfo, GetCurrentArchitecture())
00642 #define CallNPN_DestroyStreamProc(FUNC, npp, stream, reason)            \
00643                 (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_DestroyStreamProcInfo, (npp), (stream), (reason))   
00644 
00645 #else
00646 
00647 typedef NPError (*NPN_DestroyStreamUPP)(NPP instance, NPStream* stream, NPReason reason);
00648 #define NewNPN_DestroyStreamProc(FUNC)          \
00649                 ((NPN_DestroyStreamUPP) (FUNC))
00650 #define CallNPN_DestroyStreamProc(FUNC, npp, stream, reason)            \
00651                 (*(FUNC))((npp), (stream), (reason))
00652 
00653 #endif
00654 
00655 
00656 /* NPN_Status */
00657 
00658 #if GENERATINGCFM
00659 
00660 typedef UniversalProcPtr NPN_StatusUPP;
00661 enum {
00662         uppNPN_StatusProcInfo = kThinkCStackBased
00663                 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
00664                 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(char *)))
00665 };
00666 
00667 #define NewNPN_StatusProc(FUNC)         \
00668                 (NPN_StatusUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_StatusProcInfo, GetCurrentArchitecture())
00669 #define CallNPN_StatusProc(FUNC, npp, msg)              \
00670                 (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_StatusProcInfo, (npp), (msg))  
00671 
00672 #else
00673 
00674 typedef void (*NPN_StatusUPP)(NPP instance, const char* message);
00675 #define NewNPN_StatusProc(FUNC)         \
00676                 ((NPN_StatusUPP) (FUNC))
00677 #define CallNPN_StatusProc(FUNC, npp, msg)              \
00678                 (*(FUNC))((npp), (msg)) 
00679 
00680 #endif
00681 
00682 
00683 /* NPN_UserAgent */
00684 #if GENERATINGCFM
00685 
00686 typedef UniversalProcPtr NPN_UserAgentUPP;
00687 enum {
00688         uppNPN_UserAgentProcInfo = kThinkCStackBased
00689                 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
00690                 | RESULT_SIZE(SIZE_CODE(sizeof(const char *)))
00691 };
00692 
00693 #define NewNPN_UserAgentProc(FUNC)              \
00694                 (NPN_UserAgentUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_UserAgentProcInfo, GetCurrentArchitecture())
00695 #define CallNPN_UserAgentProc(FUNC, ARG1)               \
00696                 (const char*)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_UserAgentProcInfo, (ARG1))
00697 
00698 #else
00699 
00700 typedef const char*     (*NPN_UserAgentUPP)(NPP instance);
00701 #define NewNPN_UserAgentProc(FUNC)              \
00702                 ((NPN_UserAgentUPP) (FUNC))
00703 #define CallNPN_UserAgentProc(FUNC, ARG1)               \
00704                 (*(FUNC))((ARG1))
00705 
00706 #endif
00707 
00708 
00709 /* NPN_MemAlloc */
00710 #if GENERATINGCFM
00711 
00712 typedef UniversalProcPtr NPN_MemAllocUPP;
00713 enum {
00714         uppNPN_MemAllocProcInfo = kThinkCStackBased
00715                 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(uint32)))
00716                 | RESULT_SIZE(SIZE_CODE(sizeof(void *)))
00717 };
00718 
00719 #define NewNPN_MemAllocProc(FUNC)               \
00720                 (NPN_MemAllocUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_MemAllocProcInfo, GetCurrentArchitecture())
00721 #define CallNPN_MemAllocProc(FUNC, ARG1)                \
00722                 (void*)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_MemAllocProcInfo, (ARG1))     
00723 
00724 #else
00725 
00726 typedef void* (*NPN_MemAllocUPP)(uint32 size);
00727 #define NewNPN_MemAllocProc(FUNC)               \
00728                 ((NPN_MemAllocUPP) (FUNC))
00729 #define CallNPN_MemAllocProc(FUNC, ARG1)                \
00730                 (*(FUNC))((ARG1))       
00731 
00732 #endif
00733 
00734 
00735 /* NPN__MemFree */
00736 
00737 #if GENERATINGCFM
00738 
00739 typedef UniversalProcPtr NPN_MemFreeUPP;
00740 enum {
00741         uppNPN_MemFreeProcInfo = kThinkCStackBased
00742                 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(void *)))
00743 };
00744 
00745 #define NewNPN_MemFreeProc(FUNC)                \
00746                 (NPN_MemFreeUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_MemFreeProcInfo, GetCurrentArchitecture())
00747 #define CallNPN_MemFreeProc(FUNC, ARG1)         \
00748                 (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_MemFreeProcInfo, (ARG1))
00749 
00750 #else
00751 
00752 typedef void (*NPN_MemFreeUPP)(void* ptr);
00753 #define NewNPN_MemFreeProc(FUNC)                \
00754                 ((NPN_MemFreeUPP) (FUNC))
00755 #define CallNPN_MemFreeProc(FUNC, ARG1)         \
00756                 (*(FUNC))((ARG1))       
00757 
00758 #endif
00759 
00760 
00761 /* NPN_MemFlush */
00762 
00763 #if GENERATINGCFM
00764 
00765 typedef UniversalProcPtr NPN_MemFlushUPP;
00766 enum {
00767         uppNPN_MemFlushProcInfo = kThinkCStackBased
00768                 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(uint32)))
00769                 | RESULT_SIZE(SIZE_CODE(sizeof(uint32)))
00770 };
00771 
00772 #define NewNPN_MemFlushProc(FUNC)               \
00773                 (NPN_MemFlushUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_MemFlushProcInfo, GetCurrentArchitecture())
00774 #define CallNPN_MemFlushProc(FUNC, ARG1)                \
00775                 (uint32)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_MemFlushProcInfo, (ARG1))    
00776 
00777 #else
00778 
00779 typedef uint32 (*NPN_MemFlushUPP)(uint32 size);
00780 #define NewNPN_MemFlushProc(FUNC)               \
00781                 ((NPN_MemFlushUPP) (FUNC))
00782 #define CallNPN_MemFlushProc(FUNC, ARG1)                \
00783                 (*(FUNC))((ARG1))       
00784 
00785 #endif
00786 
00787 
00788 
00789 /* NPN_ReloadPlugins */
00790 
00791 #if GENERATINGCFM
00792 
00793 typedef UniversalProcPtr NPN_ReloadPluginsUPP;
00794 enum {
00795         uppNPN_ReloadPluginsProcInfo = kThinkCStackBased
00796                 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPBool)))
00797                 | RESULT_SIZE(SIZE_CODE(0))
00798 };
00799 
00800 #define NewNPN_ReloadPluginsProc(FUNC)          \
00801                 (NPN_ReloadPluginsUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_ReloadPluginsProcInfo, GetCurrentArchitecture())
00802 #define CallNPN_ReloadPluginsProc(FUNC, ARG1)           \
00803                 (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_ReloadPluginsProcInfo, (ARG1)) 
00804 
00805 #else
00806 
00807 typedef void (*NPN_ReloadPluginsUPP)(NPBool reloadPages);
00808 #define NewNPN_ReloadPluginsProc(FUNC)          \
00809                 ((NPN_ReloadPluginsUPP) (FUNC))
00810 #define CallNPN_ReloadPluginsProc(FUNC, ARG1)           \
00811                 (*(FUNC))((ARG1))       
00812 
00813 #endif
00814 
00815 
00816 /* NPN_GetJavaEnv */
00817 
00818 #if GENERATINGCFM
00819 
00820 typedef UniversalProcPtr NPN_GetJavaEnvUPP;
00821 enum {
00822         uppNPN_GetJavaEnvProcInfo = kThinkCStackBased
00823                 | RESULT_SIZE(SIZE_CODE(sizeof(JRIEnv*)))
00824 };
00825 
00826 #define NewNPN_GetJavaEnvProc(FUNC)             \
00827                 (NPN_GetJavaEnvUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetJavaEnvProcInfo, GetCurrentArchitecture())
00828 #define CallNPN_GetJavaEnvProc(FUNC)            \
00829                 (JRIEnv*)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetJavaEnvProcInfo) 
00830 
00831 #else
00832 
00833 typedef JRIEnv* (*NPN_GetJavaEnvUPP)(void);
00834 #define NewNPN_GetJavaEnvProc(FUNC)             \
00835                 ((NPN_GetJavaEnvUPP) (FUNC))
00836 #define CallNPN_GetJavaEnvProc(FUNC)            \
00837                 (*(FUNC))()     
00838 
00839 #endif
00840 
00841 
00842 /* NPN_GetJavaPeer */
00843 
00844 #if GENERATINGCFM
00845 
00846 typedef UniversalProcPtr NPN_GetJavaPeerUPP;
00847 enum {
00848         uppNPN_GetJavaPeerProcInfo = kThinkCStackBased
00849                 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
00850                 | RESULT_SIZE(SIZE_CODE(sizeof(jref)))
00851 };
00852 
00853 #define NewNPN_GetJavaPeerProc(FUNC)            \
00854                 (NPN_GetJavaPeerUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetJavaPeerProcInfo, GetCurrentArchitecture())
00855 #define CallNPN_GetJavaPeerProc(FUNC, ARG1)             \
00856                 (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetJavaPeerProcInfo, (ARG1))   
00857 
00858 #else
00859 
00860 typedef jref (*NPN_GetJavaPeerUPP)(NPP instance);
00861 #define NewNPN_GetJavaPeerProc(FUNC)            \
00862                 ((NPN_GetJavaPeerUPP) (FUNC))
00863 #define CallNPN_GetJavaPeerProc(FUNC, ARG1)             \
00864                 (*(FUNC))((ARG1))       
00865 
00866 #endif
00867 
00868 
00869 
00870 
00871 /******************************************************************************************
00872  * The actual plugin function table definitions
00873  *******************************************************************************************/
00874 
00875 typedef struct _NPPluginFuncs {
00876     uint16 size;
00877     uint16 version;
00878     NPP_NewUPP newp;
00879     NPP_DestroyUPP destroy;
00880     NPP_SetWindowUPP setwindow;
00881     NPP_NewStreamUPP newstream;
00882     NPP_DestroyStreamUPP destroystream;
00883     NPP_StreamAsFileUPP asfile;
00884     NPP_WriteReadyUPP writeready;
00885     NPP_WriteUPP write;
00886     NPP_PrintUPP print;
00887     NPP_HandleEventUPP event;
00888     NPP_URLNotifyUPP urlnotify;
00889     JRIGlobalRef javaClass;
00890 } NPPluginFuncs;
00891 
00892 typedef struct _NPNetscapeFuncs {
00893     uint16 size;
00894     uint16 version;
00895     NPN_GetURLUPP geturl;
00896     NPN_PostURLUPP posturl;
00897     NPN_RequestReadUPP requestread;
00898     NPN_NewStreamUPP newstream;
00899     NPN_WriteUPP write;
00900     NPN_DestroyStreamUPP destroystream;
00901     NPN_StatusUPP status;
00902     NPN_UserAgentUPP uagent;
00903     NPN_MemAllocUPP memalloc;
00904     NPN_MemFreeUPP memfree;
00905     NPN_MemFlushUPP memflush;
00906     NPN_ReloadPluginsUPP reloadplugins;
00907     NPN_GetJavaEnvUPP getJavaEnv;
00908     NPN_GetJavaPeerUPP getJavaPeer;
00909     NPN_GetURLNotifyUPP geturlnotify;
00910     NPN_PostURLNotifyUPP posturlnotify;
00911 #ifdef XP_UNIX
00912     NPN_GetValueUPP getvalue;
00913 #endif /* XP_UNIX */
00914 } NPNetscapeFuncs;
00915 
00916 
00917 
00918 #ifdef XP_MAC
00919 /******************************************************************************************
00920  * Mac platform-specific plugin glue stuff
00921  *******************************************************************************************/
00922 
00923 /*
00924  * Main entry point of the plugin.
00925  * This routine will be called when the plugin is loaded. The function
00926  * tables are passed in and the plugin fills in the NPPluginFuncs table
00927  * and NPPShutdownUPP for Netscape's use.
00928  */
00929 
00930 #if GENERATINGCFM
00931 
00932 typedef UniversalProcPtr NPP_MainEntryUPP;
00933 enum {
00934         uppNPP_MainEntryProcInfo = kThinkCStackBased
00935                 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPNetscapeFuncs*)))
00936                 | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPPluginFuncs*)))
00937                 | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPP_ShutdownUPP*)))
00938                 | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
00939 };
00940 #define NewNPP_MainEntryProc(FUNC)              \
00941                 (NPP_MainEntryUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_MainEntryProcInfo, GetCurrentArchitecture())
00942 #define CallNPP_MainEntryProc(FUNC,  netscapeFunc, pluginFunc, shutdownUPP)             \
00943                 CallUniversalProc((UniversalProcPtr)(FUNC), (ProcInfoType)uppNPP_MainEntryProcInfo, (netscapeFunc), (pluginFunc), (shutdownUPP))
00944 
00945 #else
00946 
00947 typedef NPError (*NPP_MainEntryUPP)(NPNetscapeFuncs*, NPPluginFuncs*, NPP_ShutdownUPP*);
00948 #define NewNPP_MainEntryProc(FUNC)              \
00949                 ((NPP_MainEntryUPP) (FUNC))
00950 #define CallNPP_MainEntryProc(FUNC,  netscapeFunc, pluginFunc, shutdownUPP)             \
00951                 (*(FUNC))((netscapeFunc), (pluginFunc), (shutdownUPP))
00952 
00953 #endif
00954 #endif /* MAC */
00955 
00956 
00957 #ifdef _WINDOWS
00958 
00959 #ifdef __cplusplus
00960 extern "C" {
00961 #endif
00962 
00963 /* plugin meta member functions */
00964 
00965 NPError WINAPI NP_GetEntryPoints(NPPluginFuncs* pFuncs);
00966 
00967 NPError WINAPI NP_Initialize(NPNetscapeFuncs* pFuncs);
00968 
00969 NPError WINAPI NP_Shutdown();
00970 
00971 #ifdef __cplusplus
00972 }
00973 #endif
00974 
00975 #endif /* _WINDOWS */
00976 
00977 #ifdef XP_UNIX
00978 
00979 #ifdef __cplusplus
00980 extern "C" {
00981 #endif
00982 
00983 /* plugin meta member functions */
00984 
00985 char*   NP_GetMIMEDescription(void);
00986 NPError NP_Initialize(NPNetscapeFuncs*, NPPluginFuncs*);
00987 NPError NP_Shutdown(void);
00988 
00989 #ifdef __cplusplus
00990 }
00991 #endif
00992 
00993 #endif /* XP_UNIX */
00994 
00995 #endif /* _NPUPP_H_ */

Generated on Thu Nov 25 15:42:53 2004 for iARS(internetAudioRenderingSystem) by  doxygen 1.3.9.1