np_sdk/npsdk/npwin.cxx

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   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 Communicator client 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 #include "npapi.h"
  39 #include "npupp.h"
  40 #include "plugin.h"
  41
  42 //\\// DEFINE
  43 #define NP_EXPORT
  44
  45 //\\// GLOBAL DATA
  46 NPNetscapeFuncs* g_pNavigatorFuncs = 0;
  47
  48 extern "C"
  49 {
  50 #ifdef OJI
  51 JRIGlobalRef Private_GetJavaClass(void);
  52
  53 //\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\.
  54 ////\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//.
  55 // Private_GetJavaClass (global function)
  56 //
  57 //  Given a Java class reference (thru NPP_GetJavaClass) inform JRT
  58 //  of this class existence
  59 //
  60 JRIGlobalRef
  61 Private_GetJavaClass(void)
  62 {
  63     jref clazz = NPP_GetJavaClass();
  64     if (clazz) {
  65         JRIEnv* env = NPN_GetJavaEnv();
  66         return JRI_NewGlobalRef(env, clazz);
  67     }
  68     return NULL;
  69 }
  70 #endif /* OJI */
  71
  72 //\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\.
  73 ////\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//.
  74 //                      PLUGIN DLL entry points
  75 //
  76 // These are the Windows specific DLL entry points. They must be exoprted
  77 //
  78
  79 // we need these to be global since we have to fill one of its field
  80 // with a data (class) which requires knowlwdge of the navigator
  81 // jump-table. This jump table is known at Initialize time (NP_Initialize)
  82 // which is called after NP_GetEntryPoint
  83 static NPPluginFuncs* g_pluginFuncs;
  84
  85 //\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\.
  86 ////\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//.
  87 // NP_GetEntryPoints
  88 //
  89 //  fills in the func table used by Navigator to call entry points in
  90 //  plugin DLL.  Note that these entry points ensure that DS is loaded
  91 //  by using the NP_LOADDS macro, when compiling for Win16
  92 //
  93 NPError WINAPI NP_EXPORT
  94 NP_GetEntryPoints(NPPluginFuncs* pFuncs)
  95 {
  96     // trap a NULL ptr
  97     if(pFuncs == NULL)
  98         return NPERR_INVALID_FUNCTABLE_ERROR;
  99
 100     // if the plugin's function table is smaller than the plugin expects,
 101     // then they are incompatible, and should return an error
 102
 103     pFuncs->version       = (NP_VERSION_MAJOR << 8) | NP_VERSION_MINOR;
 104     pFuncs->newp          = NPP_New;
 105     pFuncs->destroy       = NPP_Destroy;
 106     pFuncs->setwindow     = NPP_SetWindow;
 107     pFuncs->newstream     = NPP_NewStream;
 108     pFuncs->destroystream = NPP_DestroyStream;
 109     pFuncs->asfile        = NPP_StreamAsFile;
 110     pFuncs->writeready    = NPP_WriteReady;
 111     pFuncs->write         = NPP_Write;
 112     pFuncs->print         = NPP_Print;
 113     pFuncs->event         = 0;       /// reserved
 114
 115     g_pluginFuncs         = pFuncs;
 116
 117     return NPERR_NO_ERROR;
 118 }
 119
 120 //\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\.
 121 ////\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//.
 122 // NP_Initialize
 123 //
 124 //  called immediately after the plugin DLL is loaded
 125 //
 126 NPError WINAPI NP_EXPORT
 127 NP_Initialize(NPNetscapeFuncs* pFuncs)
 128 {
 129     // trap a NULL ptr
 130     if(pFuncs == NULL)
 131         return NPERR_INVALID_FUNCTABLE_ERROR;
 132
 133     g_pNavigatorFuncs = pFuncs; // save it for future reference
 134
 135     // if the plugin's major ver level is lower than the Navigator's,
 136     // then they are incompatible, and should return an error
 137     if(HIBYTE(pFuncs->version) > NP_VERSION_MAJOR)
 138         return NPERR_INCOMPATIBLE_VERSION_ERROR;
 139
 140     // We have to defer these assignments until g_pNavigatorFuncs is set
 141     int navMinorVers = g_pNavigatorFuncs->version & 0xFF;
 142
 143     if( navMinorVers >= NPVERS_HAS_NOTIFICATION ) {
 144         g_pluginFuncs->urlnotify = NPP_URLNotify;
 145     }
 146
 147 #ifdef OJI
 148     if( navMinorVers >= NPVERS_HAS_LIVECONNECT ) {
 149         g_pluginFuncs->javaClass = Private_GetJavaClass();
 150     }
 151 #endif
 152
 153     return NPP_Initialize();
 154 }
 155
 156 //\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\.
 157 ////\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//.
 158 // NP_Shutdown
 159 //
 160 //  called immediately before the plugin DLL is unloaded.
 161 //  This functio shuold check for some ref count on the dll to see if it is
 162 //  unloadable or it needs to stay in memory.
 163 //
 164 void WINAPI NP_EXPORT
 165 NP_Shutdown()
 166 {
 167     NPP_Shutdown();
 168     g_pNavigatorFuncs = NULL;
 169 }
 170
 171 char * NP_GetMIMEDescription()
 172 {
 173   return (char *)NPP_GetMIMEDescription();
 174 }
 175
 176 //                      END - PLUGIN DLL entry points
 177 ////\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//.
 178 //\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\.
 179
 180 /*    NAVIGATOR Entry points    */
 181
 182 /* These entry points expect to be called from within the plugin.  The
 183    noteworthy assumption is that DS has already been set to point to the
 184    plugin's DLL data segment.  Don't call these functions from outside
 185    the plugin without ensuring DS is set to the DLLs data segment first,
 186    typically using the NP_LOADDS macro
 187 */
 188
 189 /* returns the major/minor version numbers of the Plugin API for the plugin
 190    and the Navigator
 191 */
 192 void NPN_Version(int* plugin_major, int* plugin_minor, int* netscape_major, int* netscape_minor)
 193 {
 194     *plugin_major   = NP_VERSION_MAJOR;
 195     *plugin_minor   = NP_VERSION_MINOR;
 196     *netscape_major = HIBYTE(g_pNavigatorFuncs->version);
 197     *netscape_minor = LOBYTE(g_pNavigatorFuncs->version);
 198 }
 199
 200 NPError NPN_GetValue(NPP instance, NPNVariable variable, void *result)
 201 {
 202     return g_pNavigatorFuncs->getvalue(instance, variable, result);
 203 }
 204
 205
 206 /* causes the specified URL to be fetched and streamed in
 207 */
 208 NPError NPN_GetURLNotify(NPP instance, const char *url, const char *target, void* notifyData)
 209
 210 {
 211     int navMinorVers = g_pNavigatorFuncs->version & 0xFF;
 212     NPError err;
 213     if( navMinorVers >= NPVERS_HAS_NOTIFICATION ) {
 214         err = g_pNavigatorFuncs->geturlnotify(instance, url, target, notifyData);
 215     }
 216     else {
 217         err = NPERR_INCOMPATIBLE_VERSION_ERROR;
 218     }
 219     return err;
 220 }
 221
 222
 223 NPError NPN_GetURL(NPP instance, const char *url, const char *target)
 224 {
 225     return g_pNavigatorFuncs->geturl(instance, url, target);
 226 }
 227
 228 NPError NPN_PostURLNotify(NPP instance, const char* url, const char* window, uint32_t len, const char* buf, NPBool file, void* notifyData)
 229 {
 230     int navMinorVers = g_pNavigatorFuncs->version & 0xFF;
 231     NPError err;
 232     if( navMinorVers >= NPVERS_HAS_NOTIFICATION ) {
 233         err = g_pNavigatorFuncs->posturlnotify(instance, url, window, len, buf, file, notifyData);
 234     }
 235     else {
 236         err = NPERR_INCOMPATIBLE_VERSION_ERROR;
 237     }
 238     return err;
 239 }
 240
 241
 242 NPError NPN_PostURL(NPP instance, const char* url, const char* window, uint32_t len, const char* buf, NPBool file)
 243 {
 244     return g_pNavigatorFuncs->posturl(instance, url, window, len, buf, file);
 245 }
 246
 247 /* Requests that a number of bytes be provided on a stream.  Typically
 248    this would be used if a stream was in "pull" mode.  An optional
 249    position can be provided for streams which are seekable.
 250 */
 251 NPError NPN_RequestRead(NPStream* stream, NPByteRange* rangeList)
 252 {
 253     return g_pNavigatorFuncs->requestread(stream, rangeList);
 254 }
 255
 256 /* Creates a new stream of data from the plug-in to be interpreted
 257    by Netscape in the current window.
 258 */
 259 NPError NPN_NewStream(NPP instance, NPMIMEType type,
 260                                 const char* target, NPStream** stream)
 261 {
 262     int navMinorVersion = g_pNavigatorFuncs->version & 0xFF;
 263     NPError err;
 264
 265     if( navMinorVersion >= NPVERS_HAS_STREAMOUTPUT ) {
 266         err = g_pNavigatorFuncs->newstream(instance, type, target, stream);
 267     }
 268     else {
 269         err = NPERR_INCOMPATIBLE_VERSION_ERROR;
 270     }
 271     return err;
 272 }
 273
 274 /* Provides len bytes of data.
 275 */
 276 int32_t NPN_Write(NPP instance, NPStream *stream,
 277                 int32_t len, void *buffer)
 278 {
 279     int navMinorVersion = g_pNavigatorFuncs->version & 0xFF;
 280     int32_t result;
 281
 282     if( navMinorVersion >= NPVERS_HAS_STREAMOUTPUT ) {
 283         result = g_pNavigatorFuncs->write(instance, stream, len, buffer);
 284     }
 285     else {
 286         result = -1;
 287     }
 288     return result;
 289 }
 290
 291 /* Closes a stream object.
 292 reason indicates why the stream was closed.
 293 */
 294 NPError NPN_DestroyStream(NPP instance, NPStream* stream, NPError reason)
 295 {
 296     int navMinorVersion = g_pNavigatorFuncs->version & 0xFF;
 297     NPError err;
 298
 299     if( navMinorVersion >= NPVERS_HAS_STREAMOUTPUT ) {
 300         err = g_pNavigatorFuncs->destroystream(instance, stream, reason);
 301     }
 302     else {
 303         err = NPERR_INCOMPATIBLE_VERSION_ERROR;
 304     }
 305     return err;
 306 }
 307
 308 /* Provides a text status message in the Netscape client user interface
 309 */
 310 void NPN_Status(NPP instance, const char *message)
 311 {
 312     g_pNavigatorFuncs->status(instance, message);
 313 }
 314
 315 /* returns the user agent string of Navigator, which contains version info
 316 */
 317 const char* NPN_UserAgent(NPP instance)
 318 {
 319     return g_pNavigatorFuncs->uagent(instance);
 320 }
 321
 322 /* allocates memory from the Navigator's memory space.  Necessary so that
 323    saved instance data may be freed by Navigator when exiting.
 324 */
 325
 326
 327 void* NPN_MemAlloc(uint32_t size)
 328 {
 329     return g_pNavigatorFuncs->memalloc(size);
 330 }
 331
 332 /* reciprocal of MemAlloc() above
 333 */
 334 void NPN_MemFree(void* ptr)
 335 {
 336     g_pNavigatorFuncs->memfree(ptr);
 337 }
 338
 339 #ifdef OJI
 340 /* private function to Netscape.  do not use!
 341 */
 342 void NPN_ReloadPlugins(NPBool reloadPages)
 343 {
 344     g_pNavigatorFuncs->reloadplugins(reloadPages);
 345 }
 346
 347 JRIEnv* NPN_GetJavaEnv(void)
 348 {
 349     return g_pNavigatorFuncs->getJavaEnv();
 350 }
 351
 352 jref NPN_GetJavaPeer(NPP instance)
 353 {
 354     return g_pNavigatorFuncs->getJavaPeer(instance);
 355 }
 356 #endif
 357 } //end of extern "C"
 358