npwin.cpp
上传用户:hongyu5696
上传日期:2018-01-22
资源大小:391k
文件大小:9k
源码类别:

PlugIns编程

开发平台:

Unix_Linux

  1. /* npwin.cpp */
  2. //\// INCLUDE
  3. //#include "StdAfx.h"
  4. // netscape
  5. #ifndef _NPAPI_H_
  6. #include "npapi.h"
  7. #endif
  8. #ifndef _NPUPP_H_
  9. #include "npupp.h"
  10. #endif
  11. //\// DEFINE
  12. #ifdef WIN32
  13.     #define NP_EXPORT //__declspec( dllexport )
  14. #else
  15.     #define NP_EXPORT _export
  16. #endif
  17. //\// GLOBAL DATA
  18. NPNetscapeFuncs* g_pNavigatorFuncs = NULL;
  19. //\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\.
  20. ////\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//.
  21. // Private_GetJavaClass (global function)
  22. //
  23. // Given a Java class reference (thru NPP_GetJavaClass) inform JRT
  24. // of this class existence
  25. //
  26. JRIGlobalRef
  27. Private_GetJavaClass(void)
  28. {
  29.     jref clazz = NPP_GetJavaClass();
  30.     if (clazz) {
  31. JRIEnv* env = NPN_GetJavaEnv();
  32. return JRI_NewGlobalRef(env, clazz);
  33.     }
  34.     return NULL;
  35. }
  36. //\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\.
  37. ////\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//.
  38. // PLUGIN DLL entry points   
  39. //
  40. // These are the Windows specific DLL entry points. They must be exoprted
  41. //
  42. // we need these to be global since we have to fill one of its field
  43. // with a data (class) which requires knowlwdge of the navigator
  44. // jump-table. This jump table is known at Initialize time (NP_Initialize)
  45. // which is called after NP_GetEntryPoint
  46. static NPPluginFuncs* g_pluginFuncs;
  47. //\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\.
  48. ////\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//.
  49. // NP_GetEntryPoints
  50. //
  51. // fills in the func table used by Navigator to call entry points in
  52. //  plugin DLL.  Note that these entry points ensure that DS is loaded
  53. //  by using the NP_LOADDS macro, when compiling for Win16
  54. //
  55. NPError WINAPI NP_EXPORT
  56. NP_GetEntryPoints(NPPluginFuncs* pFuncs)
  57. {
  58.     // trap a NULL ptr 
  59.     if(pFuncs == NULL)
  60.         return NPERR_INVALID_FUNCTABLE_ERROR;
  61.     // if the plugin's function table is smaller than the plugin expects,
  62.     // then they are incompatible, and should return an error 
  63.     pFuncs->version       = (NP_VERSION_MAJOR << 8) | NP_VERSION_MINOR;
  64.     pFuncs->newp          = NPP_New;
  65.     pFuncs->destroy       = NPP_Destroy;
  66.     pFuncs->setwindow     = NPP_SetWindow;
  67.     pFuncs->newstream     = NPP_NewStream;
  68.     pFuncs->destroystream = NPP_DestroyStream;
  69.     pFuncs->asfile        = NPP_StreamAsFile;
  70.     pFuncs->writeready    = NPP_WriteReady;
  71.     pFuncs->write         = NPP_Write;
  72.     pFuncs->print         = NPP_Print;
  73.     pFuncs->event         = NULL;       /// reserved 
  74. g_pluginFuncs   = pFuncs;
  75.     return NPERR_NO_ERROR;
  76. }
  77. //\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\.
  78. ////\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//.
  79. // NP_Initialize
  80. //
  81. // called immediately after the plugin DLL is loaded
  82. //
  83. NPError WINAPI NP_EXPORT 
  84. NP_Initialize(NPNetscapeFuncs* pFuncs)
  85. {
  86.     // trap a NULL ptr 
  87.     if(pFuncs == NULL)
  88.         return NPERR_INVALID_FUNCTABLE_ERROR;
  89.     g_pNavigatorFuncs = pFuncs; // save it for future reference 
  90.     // if the plugin's major ver level is lower than the Navigator's,
  91.     // then they are incompatible, and should return an error 
  92.     if(HIBYTE(pFuncs->version) > NP_VERSION_MAJOR)
  93.         return NPERR_INCOMPATIBLE_VERSION_ERROR;
  94. // We have to defer these assignments until g_pNavigatorFuncs is set
  95.     int navMinorVers = g_pNavigatorFuncs->version & 0xFF;
  96. if( navMinorVers >= NPVERS_HAS_NOTIFICATION ) {
  97. g_pluginFuncs->urlnotify = NPP_URLNotify;
  98. }
  99. if( navMinorVers >= NPVERS_HAS_LIVECONNECT ) {
  100. g_pluginFuncs->javaClass = Private_GetJavaClass();
  101. }
  102. // NPP_Initialize is a standard (cross-platform) initialize function.
  103.     return NPP_Initialize();
  104. }
  105. //\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\.
  106. ////\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//.
  107. // NP_Shutdown
  108. //
  109. // called immediately before the plugin DLL is unloaded.
  110. // This functio shuold check for some ref count on the dll to see if it is
  111. // unloadable or it needs to stay in memory. 
  112. //
  113. NPError WINAPI NP_EXPORT 
  114. NP_Shutdown()
  115. {
  116.     NPP_Shutdown();
  117.     g_pNavigatorFuncs = NULL;
  118.     return NPERR_NO_ERROR;
  119. }
  120. // END - PLUGIN DLL entry points   
  121. ////\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//.
  122. //\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\.
  123. /*    NAVIGATOR Entry points    */
  124. /* These entry points expect to be called from within the plugin.  The
  125.    noteworthy assumption is that DS has already been set to point to the
  126.    plugin's DLL data segment.  Don't call these functions from outside
  127.    the plugin without ensuring DS is set to the DLLs data segment first,
  128.    typically using the NP_LOADDS macro
  129. */
  130. /* returns the major/minor version numbers of the Plugin API for the plugin
  131.    and the Navigator
  132. */
  133. void NPN_Version(int* plugin_major, int* plugin_minor, int* netscape_major, int* netscape_minor)
  134. {
  135.     *plugin_major   = NP_VERSION_MAJOR;
  136.     *plugin_minor   = NP_VERSION_MINOR;
  137.     *netscape_major = HIBYTE(g_pNavigatorFuncs->version);
  138.     *netscape_minor = LOBYTE(g_pNavigatorFuncs->version);
  139. }
  140. /* causes the specified URL to be fetched and streamed in
  141. */
  142. NPError NPN_GetURLNotify(NPP instance, const char *url, const char *target, void* notifyData)
  143. {
  144. int navMinorVers = g_pNavigatorFuncs->version & 0xFF;
  145. NPError err;
  146. if( navMinorVers >= NPVERS_HAS_NOTIFICATION ) {
  147. err = g_pNavigatorFuncs->geturlnotify(instance, url, target, notifyData);
  148. }
  149. else {
  150. err = NPERR_INCOMPATIBLE_VERSION_ERROR;
  151. }
  152. return err;
  153. }
  154. NPError NPN_GetURL(NPP instance, const char *url, const char *target)
  155. {
  156.     return g_pNavigatorFuncs->geturl(instance, url, target);
  157. }
  158. NPError NPN_PostURLNotify(NPP instance, const char* url, const char* window, uint32 len, const char* buf, NPBool file, void* notifyData)
  159. {
  160. int navMinorVers = g_pNavigatorFuncs->version & 0xFF;
  161. NPError err;
  162. if( navMinorVers >= NPVERS_HAS_NOTIFICATION ) {
  163. err = g_pNavigatorFuncs->posturlnotify(instance, url, window, len, buf, file, notifyData);
  164. }
  165. else {
  166. err = NPERR_INCOMPATIBLE_VERSION_ERROR;
  167. }
  168. return err;
  169. }
  170. NPError NPN_PostURL(NPP instance, const char* url, const char* window, uint32 len, const char* buf, NPBool file)
  171. {
  172.     return g_pNavigatorFuncs->posturl(instance, url, window, len, buf, file);
  173. }
  174. /* Requests that a number of bytes be provided on a stream.  Typically
  175.    this would be used if a stream was in "pull" mode.  An optional
  176.    position can be provided for streams which are seekable.
  177. */
  178. NPError NPN_RequestRead(NPStream* stream, NPByteRange* rangeList)
  179. {
  180.     return g_pNavigatorFuncs->requestread(stream, rangeList);
  181. }
  182. /* Creates a new stream of data from the plug-in to be interpreted
  183.    by Netscape in the current window.
  184. */
  185. NPError NPN_NewStream(NPP instance, NPMIMEType type, 
  186. const char* target, NPStream** stream)
  187. {
  188. int navMinorVersion = g_pNavigatorFuncs->version & 0xFF;
  189. NPError err;
  190. if( navMinorVersion >= NPVERS_HAS_STREAMOUTPUT ) {
  191. err = g_pNavigatorFuncs->newstream(instance, type, target, stream);
  192. }
  193. else {
  194. err = NPERR_INCOMPATIBLE_VERSION_ERROR;
  195. }
  196. return err;
  197. }
  198. /* Provides len bytes of data.
  199. */
  200. int32 NPN_Write(NPP instance, NPStream *stream,
  201.                 int32 len, void *buffer)
  202. {
  203. int navMinorVersion = g_pNavigatorFuncs->version & 0xFF;
  204. int32 result;
  205. if( navMinorVersion >= NPVERS_HAS_STREAMOUTPUT ) {
  206. result = g_pNavigatorFuncs->write(instance, stream, len, buffer);
  207. }
  208. else {
  209. result = -1;
  210. }
  211. return result;
  212. }
  213. /* Closes a stream object.  
  214. reason indicates why the stream was closed.
  215. */
  216. NPError NPN_DestroyStream(NPP instance, NPStream* stream, NPError reason)
  217. {
  218. int navMinorVersion = g_pNavigatorFuncs->version & 0xFF;
  219. NPError err;
  220. if( navMinorVersion >= NPVERS_HAS_STREAMOUTPUT ) {
  221. err = g_pNavigatorFuncs->destroystream(instance, stream, reason);
  222. }
  223. else {
  224. err = NPERR_INCOMPATIBLE_VERSION_ERROR;
  225. }
  226. return err;
  227. }
  228. /* Provides a text status message in the Netscape client user interface
  229. */
  230. void NPN_Status(NPP instance, const char *message)
  231. {
  232.     g_pNavigatorFuncs->status(instance, message);
  233. }
  234. /* returns the user agent string of Navigator, which contains version info
  235. */
  236. const char* NPN_UserAgent(NPP instance)
  237. {
  238.     return g_pNavigatorFuncs->uagent(instance);
  239. }
  240. /* allocates memory from the Navigator's memory space.  Necessary so that
  241.    saved instance data may be freed by Navigator when exiting.
  242. */
  243. void* NPN_MemAlloc(uint32 size)
  244. {
  245.     return g_pNavigatorFuncs->memalloc(size);
  246. }
  247. /* reciprocal of MemAlloc() above
  248. */
  249. void NPN_MemFree(void* ptr)
  250. {
  251.     g_pNavigatorFuncs->memfree(ptr);
  252. }
  253. /* private function to Netscape.  do not use!
  254. */
  255. void NPN_ReloadPlugins(NPBool reloadPages)
  256. {
  257.     g_pNavigatorFuncs->reloadplugins(reloadPages);
  258. }
  259. JRIEnv* NPN_GetJavaEnv(void)
  260. {
  261. return g_pNavigatorFuncs->getJavaEnv();
  262. }
  263. jref NPN_GetJavaPeer(NPP instance)
  264. {
  265. return g_pNavigatorFuncs->getJavaPeer(instance);
  266. }