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
