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

PlugIns编程

开发平台:

Unix_Linux

  1. /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
  2. /* ***** BEGIN LICENSE BLOCK *****
  3.  * Version: NPL 1.1/GPL 2.0/LGPL 2.1
  4.  *
  5.  * The contents of this file are subject to the Netscape Public License
  6.  * Version 1.1 (the "License"); you may not use this file except in
  7.  * compliance with the License. You may obtain a copy of the License at
  8.  * http://www.mozilla.org/NPL/
  9.  *
  10.  * Software distributed under the License is distributed on an "AS IS" basis,
  11.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12.  * for the specific language governing rights and limitations under the
  13.  * License.
  14.  *
  15.  * The Original Code is mozilla.org code.
  16.  *
  17.  * The Initial Developer of the Original Code is 
  18.  * Netscape Communications Corporation.
  19.  * Portions created by the Initial Developer are Copyright (C) 1998
  20.  * the Initial Developer. All Rights Reserved.
  21.  *
  22.  * Contributor(s):
  23.  *
  24.  * Alternatively, the contents of this file may be used under the terms of
  25.  * either the GNU General Public License Version 2 or later (the "GPL"), or 
  26.  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  27.  * in which case the provisions of the GPL or the LGPL are applicable instead
  28.  * of those above. If you wish to allow use of your version of this file only
  29.  * under the terms of either the GPL or the LGPL, and not to allow others to
  30.  * use your version of this file under the terms of the NPL, indicate your
  31.  * decision by deleting the provisions above and replace them with the notice
  32.  * and other provisions required by the GPL or the LGPL. If you do not delete
  33.  * the provisions above, a recipient may use your version of this file under
  34.  * the terms of any one of the NPL, the GPL or the LGPL.
  35.  *
  36.  * ***** END LICENSE BLOCK ***** */
  37. ////////////////////////////////////////////////////////////
  38. //
  39. // Implementation of plugin entry points (NPP_*)
  40. //
  41. #include "pluginbase.h"
  42. // here the plugin creates a plugin instance object which 
  43. // will be associated with this newly created NPP instance and 
  44. // will do all the neccessary job
  45. NPError NPP_New(NPMIMEType pluginType, NPP instance, uint16 mode, int16 argc, char* argn[], char* argv[], NPSavedData* saved)
  46. {   
  47.   if(instance == NULL)
  48.     return NPERR_INVALID_INSTANCE_ERROR;
  49.   NPError rv = NPERR_NO_ERROR;
  50.   // create a new plugin instance object
  51.   // initialization will be done when the associated window is ready
  52.   nsPluginCreateData ds;
  53.   
  54.   ds.instance = instance;
  55.   ds.type     = pluginType; 
  56.   ds.mode     = mode; 
  57.   ds.argc     = argc; 
  58.   ds.argn     = argn; 
  59.   ds.argv     = argv; 
  60.   ds.saved    = saved;
  61.   nsPluginInstanceBase * plugin = NS_NewPluginInstance(&ds);
  62.   if(plugin == NULL)
  63.     return NPERR_OUT_OF_MEMORY_ERROR;
  64.   // associate the plugin instance object with NPP instance
  65.   instance->pdata = (void *)plugin;
  66.   return rv;
  67. }
  68. // here is the place to clean up and destroy the nsPluginInstance object
  69. NPError NPP_Destroy (NPP instance, NPSavedData** save)
  70. {
  71.   if(instance == NULL)
  72.     return NPERR_INVALID_INSTANCE_ERROR;
  73.   NPError rv = NPERR_NO_ERROR;
  74.   nsPluginInstanceBase * plugin = (nsPluginInstanceBase *)instance->pdata;
  75.   if(plugin != NULL) {
  76.     plugin->shut();
  77.     NS_DestroyPluginInstance(plugin);
  78.   }
  79.   return rv;
  80. }
  81. // during this call we know when the plugin window is ready or
  82. // is about to be destroyed so we can do some gui specific
  83. // initialization and shutdown
  84. NPError NPP_SetWindow (NPP instance, NPWindow* pNPWindow)
  85. {    
  86.   if(instance == NULL)
  87.     return NPERR_INVALID_INSTANCE_ERROR;
  88.   NPError rv = NPERR_NO_ERROR;
  89.   if(pNPWindow == NULL)
  90.     return NPERR_GENERIC_ERROR;
  91.   nsPluginInstanceBase * plugin = (nsPluginInstanceBase *)instance->pdata;
  92.   if(plugin == NULL) 
  93.     return NPERR_GENERIC_ERROR;
  94.   // window just created
  95.   if(!plugin->isInitialized() && (pNPWindow->window != NULL)) { 
  96.     if(!plugin->init(pNPWindow)) {
  97.       NS_DestroyPluginInstance(plugin);
  98.       return NPERR_MODULE_LOAD_FAILED_ERROR;
  99.     }
  100.   }
  101.   // window goes away
  102.   if((pNPWindow->window == NULL) && plugin->isInitialized())
  103.     return plugin->SetWindow(pNPWindow);
  104.   // window resized?
  105.   if(plugin->isInitialized() && (pNPWindow->window != NULL))
  106.     return plugin->SetWindow(pNPWindow);
  107.   // this should not happen, nothing to do
  108.   if((pNPWindow->window == NULL) && !plugin->isInitialized())
  109.     return plugin->SetWindow(pNPWindow);
  110.   return rv;
  111. }
  112. NPError NPP_NewStream(NPP instance, NPMIMEType type, NPStream* stream, NPBool seekable, uint16* stype)
  113. {
  114.   if(instance == NULL)
  115.     return NPERR_INVALID_INSTANCE_ERROR;
  116.   nsPluginInstanceBase * plugin = (nsPluginInstanceBase *)instance->pdata;
  117.   if(plugin == NULL) 
  118.     return NPERR_GENERIC_ERROR;
  119.   NPError rv = plugin->NewStream(type, stream, seekable, stype);
  120.   return rv;
  121. }
  122. int32 NPP_WriteReady (NPP instance, NPStream *stream)
  123. {
  124.   if(instance == NULL)
  125.     return 0x0fffffff;
  126.   nsPluginInstanceBase * plugin = (nsPluginInstanceBase *)instance->pdata;
  127.   if(plugin == NULL) 
  128.     return 0x0fffffff;
  129.   int32 rv = plugin->WriteReady(stream);
  130.   return rv;
  131. }
  132. int32 NPP_Write (NPP instance, NPStream *stream, int32 offset, int32 len, void *buffer)
  133. {   
  134.   if(instance == NULL)
  135.     return len;
  136.   nsPluginInstanceBase * plugin = (nsPluginInstanceBase *)instance->pdata;
  137.   if(plugin == NULL) 
  138.     return len;
  139.   int32 rv = plugin->Write(stream, offset, len, buffer);
  140.   return rv;
  141. }
  142. NPError NPP_DestroyStream (NPP instance, NPStream *stream, NPError reason)
  143. {
  144.   if(instance == NULL)
  145.     return NPERR_INVALID_INSTANCE_ERROR;
  146.   nsPluginInstanceBase * plugin = (nsPluginInstanceBase *)instance->pdata;
  147.   if(plugin == NULL) 
  148.     return NPERR_GENERIC_ERROR;
  149.   NPError rv = plugin->DestroyStream(stream, reason);
  150.   return rv;
  151. }
  152. void NPP_StreamAsFile (NPP instance, NPStream* stream, const char* fname)
  153. {
  154.   if(instance == NULL)
  155.     return;
  156.   nsPluginInstanceBase * plugin = (nsPluginInstanceBase *)instance->pdata;
  157.   if(plugin == NULL) 
  158.     return;
  159.   plugin->StreamAsFile(stream, fname);
  160. }
  161. void NPP_Print (NPP instance, NPPrint* printInfo)
  162. {
  163.   if(instance == NULL)
  164.     return;
  165.   nsPluginInstanceBase * plugin = (nsPluginInstanceBase *)instance->pdata;
  166.   if(plugin == NULL) 
  167.     return;
  168.   plugin->Print(printInfo);
  169. }
  170. void NPP_URLNotify(NPP instance, const char* url, NPReason reason, void* notifyData)
  171. {
  172.   if(instance == NULL)
  173.     return;
  174.   nsPluginInstanceBase * plugin = (nsPluginInstanceBase *)instance->pdata;
  175.   if(plugin == NULL) 
  176.     return;
  177.   plugin->URLNotify(url, reason, notifyData);
  178. }
  179. NPError NPP_GetValue(NPP instance, NPPVariable variable, void *value)
  180. {
  181.   if(instance == NULL)
  182.     return NPERR_INVALID_INSTANCE_ERROR;
  183.   nsPluginInstanceBase * plugin = (nsPluginInstanceBase *)instance->pdata;
  184.   if(plugin == NULL) 
  185.     return NPERR_GENERIC_ERROR;
  186.   NPError rv = plugin->GetValue(variable, value);
  187.   return rv;
  188. }
  189. NPError NPP_SetValue(NPP instance, NPNVariable variable, void *value)
  190. {
  191.   if(instance == NULL)
  192.     return NPERR_INVALID_INSTANCE_ERROR;
  193.   nsPluginInstanceBase * plugin = (nsPluginInstanceBase *)instance->pdata;
  194.   if(plugin == NULL) 
  195.     return NPERR_GENERIC_ERROR;
  196.   NPError rv = plugin->SetValue(variable, value);
  197.   return rv;
  198. }
  199. int16 NPP_HandleEvent(NPP instance, void* event)
  200. {
  201.   if(instance == NULL)
  202.     return 0;
  203.   nsPluginInstanceBase * plugin = (nsPluginInstanceBase *)instance->pdata;
  204.   if(plugin == NULL) 
  205.     return 0;
  206.   uint16 rv = plugin->HandleEvent(event);
  207.   return rv;
  208. }
  209. #ifdef OJI
  210. jref NPP_GetJavaClass (void)
  211. {
  212.   return NULL;
  213. }
  214. #endif
  215. /**************************************************/
  216. /*                                                */
  217. /*                     Mac                        */
  218. /*                                                */
  219. /**************************************************/
  220. // Mac needs these wrappers, see npplat.h for more info
  221. #ifdef XP_MAC
  222. NPError Private_New(NPMIMEType pluginType, NPP instance, uint16 mode, int16 argc, char* argn[], char* argv[], NPSavedData* saved)
  223. {
  224.   NPError rv = NPP_New(pluginType, instance, mode, argc, argn, argv, saved);
  225.   return rv;
  226. }
  227. NPError Private_Destroy(NPP instance, NPSavedData** save)
  228. {
  229.   NPError rv = NPP_Destroy(instance, save);
  230.   return rv;
  231. }
  232. NPError Private_SetWindow(NPP instance, NPWindow* window)
  233. {
  234.   NPError rv = NPP_SetWindow(instance, window);
  235.   return rv;
  236. }
  237. NPError Private_NewStream(NPP instance, NPMIMEType type, NPStream* stream, NPBool seekable, uint16* stype)
  238. {
  239.   NPError rv = NPP_NewStream(instance, type, stream, seekable, stype);
  240.   return rv;
  241. }
  242. int32 Private_WriteReady(NPP instance, NPStream* stream)
  243. {
  244.   int32 rv = NPP_WriteReady(instance, stream);
  245.   return rv;
  246. }
  247. int32 Private_Write(NPP instance, NPStream* stream, int32 offset, int32 len, void* buffer)
  248. {
  249.   int32 rv = NPP_Write(instance, stream, offset, len, buffer);
  250.   return rv;
  251. }
  252. void Private_StreamAsFile(NPP instance, NPStream* stream, const char* fname)
  253. {
  254.   NPP_StreamAsFile(instance, stream, fname);
  255. }
  256. NPError Private_DestroyStream(NPP instance, NPStream* stream, NPError reason)
  257. {
  258.   NPError rv = NPP_DestroyStream(instance, stream, reason);
  259.   return rv;
  260. }
  261. int16 Private_HandleEvent(NPP instance, void* event)
  262. {
  263.   int16 rv = NPP_HandleEvent(instance, event);
  264.   return rv;
  265. }
  266. void Private_Print(NPP instance, NPPrint* platformPrint)
  267. {
  268.   NPP_Print(instance, platformPrint);
  269. }
  270. void Private_URLNotify(NPP instance, const char* url, NPReason reason, void* notifyData)
  271. {
  272.   NPP_URLNotify(instance, url, reason, notifyData);
  273. }
  274. jref Private_GetJavaClass(void)
  275. {
  276.   return NULL;
  277. }
  278. NPError Private_GetValue(NPP instance, NPPVariable variable, void *result)
  279. {
  280.   NPError rv = NPP_GetValue(instance, variable, result);
  281.   return rv;
  282. }
  283. NPError Private_SetValue(NPP instance, NPNVariable variable, void *value)
  284. {
  285.   NPError rv = NPP_SetValue(instance, variable, value);
  286.   return rv;
  287. }
  288. #endif //XP_MAC