utils/nplugin/src/npshell.cpp

   1 //::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
   2 //
   3 // npshell.cpp
   4 //
   5 // This file defines a "shell" plugin that plugin developers can use
   6 // as the basis for a real plugin.  This shell just provides empty
   7 // implementations of all functions that the plugin can implement
   8 // that will be called by Netscape (the NPP_xxx methods defined in
   9 // npapi.h).
  10 //
  11 //::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  12
  13 #ifndef _NPAPI_H_
  14 #include "npapi.h"
  15 #endif
  16
  17 #include <windows.h>
  18 #include <string.h>
  19 #include <stdio.h>
  20
  21 #include "NPApp.h"
  22
  23 //
  24 // Instance state information about the plugin.
  25 //
  26 // *Developers*: Use this struct to hold per-instance
  27 //               information that you'll need in the
  28 //               various functions in this file.
  29 //
  30 typedef struct _PluginInstance
  31 {
  32     NPWindow*       fWindow;
  33     uint16          fMode;
  34
  35 } PluginInstance;
  36
  37
  38
  39 //------------------------------------------------------------------------------------
  40 // NPP_Initialize:
  41 //------------------------------------------------------------------------------------
  42 NPError NPP_Initialize(void)
  43 {
  44 //    MessageBox(NULL, "NPP_Initialize", "NPTest", MB_OK);
  45
  46     wxPluginApp *app = wxGetPluginApp();
  47     if ( app )
  48         return app->NPP_Initialize();
  49     else
  50         return NPERR_NO_ERROR;
  51 }
  52
  53
  54 //------------------------------------------------------------------------------------
  55 // NPP_Shutdown:
  56 //------------------------------------------------------------------------------------
  57 void NPP_Shutdown(void)
  58 {
  59 //    MessageBox(NULL, "NPP_Shutdown", "wxPlugin", MB_OK);
  60
  61     wxPluginApp *app = wxGetPluginApp();
  62     if ( app )
  63         app->NPP_Shutdown();
  64 }
  65
  66
  67 //------------------------------------------------------------------------------------
  68 // NPP_New:
  69 //------------------------------------------------------------------------------------
  70 NPError NP_LOADDS
  71 NPP_New(NPMIMEType pluginType,
  72                 NPP instance,
  73                 uint16 mode,
  74                 int16 argc,
  75                 char* argn[],
  76                 char* argv[],
  77                 NPSavedData* saved)
  78 {
  79 //    MessageBox(NULL, "NPP_New", "NPTest", MB_OK);
  80
  81     if (instance == NULL)
  82         return NPERR_INVALID_INSTANCE_ERROR;
  83
  84     wxPluginApp *app = wxGetPluginApp();
  85     if ( app )
  86         return app->NPP_New(pluginType, instance, mode, argc, argn, argv, saved);
  87     else
  88         return NPERR_NO_ERROR;
  89 }
  90
  91 //------------------------------------------------------------------------------------
  92 // NPP_Destroy:
  93 //------------------------------------------------------------------------------------
  94 NPError NP_LOADDS
  95 NPP_Destroy(NPP instance, NPSavedData** save)
  96 {
  97 //    MessageBox(NULL, "NPP_Destroy", "NPTest", MB_OK);
  98
  99     if (instance == NULL)
 100         return NPERR_INVALID_INSTANCE_ERROR;
 101
 102     wxPluginApp *app = wxGetPluginApp();
 103     if ( app )
 104         return app->NPP_Destroy(instance, save);
 105     else
 106         return NPERR_NO_ERROR;
 107 }
 108
 109
 110 //------------------------------------------------------------------------------------
 111 // NPP_SetWindow:
 112 //------------------------------------------------------------------------------------
 113 NPError NP_LOADDS
 114 NPP_SetWindow(NPP instance, NPWindow* window)
 115 {
 116 //    MessageBox(NULL, "NPP_SetWindow", "NPTest", MB_OK);
 117
 118     if (instance == NULL)
 119         return NPERR_INVALID_INSTANCE_ERROR;
 120
 121     wxPluginApp *app = wxGetPluginApp();
 122     if ( app )
 123         return app->NPP_SetWindow(instance, window);
 124     else
 125         return NPERR_NO_ERROR;
 126 }
 127
 128
 129 //------------------------------------------------------------------------------------
 130 // NPP_NewStream:
 131 //------------------------------------------------------------------------------------
 132 NPError NP_LOADDS
 133 NPP_NewStream(NPP instance,
 134                             NPMIMEType type,
 135                             NPStream *stream,
 136                             NPBool seekable,
 137                             uint16 *stype)
 138 {
 139 //    MessageBox(NULL, "NPP_NewStream", "NPTest", MB_OK);
 140
 141     if (instance == NULL)
 142         return NPERR_INVALID_INSTANCE_ERROR;
 143
 144     wxPluginApp *app = wxGetPluginApp();
 145     if ( app )
 146         return app->NPP_NewStream(instance, type, stream, seekable, stype);
 147     else
 148         return NPERR_NO_ERROR;
 149 }
 150
 151
 152
 153 //
 154 // *Developers*:
 155 // These next 2 functions are directly relevant in a plug-in which handles the
 156 // data in a streaming manner.  If you want zero bytes because no buffer space
 157 // is YET available, return 0.  As long as the stream has not been written
 158 // to the plugin, Navigator will continue trying to send bytes.  If the plugin
 159 // doesn't want them, just return some large number from NPP_WriteReady(), and
 160 // ignore them in NPP_Write().  For a NP_ASFILE stream, they are still called
 161 // but can safely be ignored using this strategy.
 162 //
 163
 164 static int32 STREAMBUFSIZE = 0X0FFFFFFF;   // If we are reading from a file in NPAsFile
 165                                     // mode so we can take any size stream in our
 166                                     // write call (since we ignore it)
 167
 168 //------------------------------------------------------------------------------------
 169 // NPP_WriteReady:
 170 //------------------------------------------------------------------------------------
 171 int32 NP_LOADDS
 172 NPP_WriteReady(NPP instance, NPStream *stream)
 173 {
 174     wxPluginApp *app = wxGetPluginApp();
 175     if ( app )
 176         return app->NPP_WriteReady(instance, stream);
 177     else
 178         return STREAMBUFSIZE;
 179
 180     return STREAMBUFSIZE;   // Number of bytes ready to accept in NPP_Write()
 181 }
 182
 183
 184
 185 //------------------------------------------------------------------------------------
 186 // NPP_Write:
 187 //------------------------------------------------------------------------------------
 188 int32 NP_LOADDS
 189 NPP_Write(NPP instance, NPStream *stream, int32 offset, int32 len, void *buffer)
 190 {
 191     wxPluginApp *app = wxGetPluginApp();
 192     if ( app )
 193         return app->NPP_Write(instance, stream, offset, len, buffer);
 194     else
 195         return len;              // The number of bytes accepted
 196 }
 197
 198
 199
 200 //------------------------------------------------------------------------------------
 201 // NPP_DestroyStream:
 202 //------------------------------------------------------------------------------------
 203 NPError NP_LOADDS
 204 NPP_DestroyStream(NPP instance, NPStream *stream, NPError reason)
 205 {
 206     if (instance == NULL)
 207         return NPERR_INVALID_INSTANCE_ERROR;
 208
 209     wxPluginApp *app = wxGetPluginApp();
 210     if ( app )
 211         return app->NPP_DestroyStream(instance, stream, reason);
 212     else
 213         return NPERR_NO_ERROR;
 214 }
 215
 216
 217 //------------------------------------------------------------------------------------
 218 // NPP_StreamAsFile:
 219 //------------------------------------------------------------------------------------
 220 void NP_LOADDS
 221 NPP_StreamAsFile(NPP instance, NPStream *stream, const char* fname)
 222 {
 223     wxPluginApp *app = wxGetPluginApp();
 224     if ( app )
 225         app->NPP_StreamAsFile(instance, stream, fname);
 226 }
 227
 228
 229
 230 //------------------------------------------------------------------------------------
 231 // NPP_Print:
 232 //------------------------------------------------------------------------------------
 233 void NP_LOADDS
 234 NPP_Print(NPP instance, NPPrint* printInfo)
 235 {
 236     if (printInfo == NULL)   // trap invalid parm
 237         return;
 238     if ( instance == NULL )
 239         return;
 240
 241     wxPluginApp *app = wxGetPluginApp();
 242     if ( app )
 243         app->NPP_Print(instance, printInfo);
 244 }
 245
 246
 247 //------------------------------------------------------------------------------------
 248 // NPP_HandleEvent:
 249 // Mac-only.
 250 //------------------------------------------------------------------------------------
 251 int16 NPP_HandleEvent(NPP instance, void* event)
 252 {
 253     NPBool eventHandled = FALSE;
 254     if (instance == NULL)
 255         return eventHandled;
 256
 257     PluginInstance* This = (PluginInstance*) instance->pdata;
 258
 259     //
 260     // *Developers*: The "event" passed in is a Macintosh
 261     // EventRecord*.  The event.what field can be any of the
 262     // normal Mac event types, or one of the following additional
 263     // types defined in npapi.h: getFocusEvent, loseFocusEvent,
 264     // adjustCursorEvent.  The focus events inform your plugin
 265     // that it will become, or is no longer, the recepient of
 266     // key events.  If your plugin doesn't want to receive key
 267     // events, return false when passed at getFocusEvent.  The
 268     // adjustCursorEvent is passed repeatedly when the mouse is
 269     // over your plugin; if your plugin doesn't want to set the
 270     // cursor, return false.  Handle the standard Mac events as
 271     // normal.  The return value for all standard events is currently
 272     // ignored except for the key event: for key events, only return
 273     // true if your plugin has handled that particular key event.
 274     //
 275
 276     return eventHandled;
 277 }
 278