modules/plugin/default/unix/npshell.c

   1 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  *
   3  * ***** BEGIN LICENSE BLOCK *****
   4  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   5  *
   6  * The contents of this file are subject to the Mozilla Public License Version
   7  * 1.1 (the "License"); you may not use this file except in compliance with
   8  * the License. You may obtain a copy of the License at
   9  * http://www.mozilla.org/MPL/
  10  *
  11  * Software distributed under the License is distributed on an "AS IS" basis,
  12  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  13  * for the specific language governing rights and limitations under the
  14  * License.
  15  *
  16  * The Original Code is mozilla.org code.
  17  *
  18  * The Initial Developer of the Original Code is
  19  * Netscape Communications Corporation.
  20  * Portions created by the Initial Developer are Copyright (C) 1998
  21  * the Initial Developer. All Rights Reserved.
  22  *
  23  * Contributor(s):
  24  *   Stephen Mak <smak@sun.com>
  25  *
  26  * Alternatively, the contents of this file may be used under the terms of
  27  * either the GNU General Public License Version 2 or later (the "GPL"), or
  28  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  29  * in which case the provisions of the GPL or the LGPL are applicable instead
  30  * of those above. If you wish to allow use of your version of this file only
  31  * under the terms of either the GPL or the LGPL, and not to allow others to
  32  * use your version of this file under the terms of the MPL, indicate your
  33  * decision by deleting the provisions above and replace them with the notice
  34  * and other provisions required by the GPL or the LGPL. If you do not delete
  35  * the provisions above, a recipient may use your version of this file under
  36  * the terms of any one of the MPL, the GPL or the LGPL.
  37  *
  38  * ***** END LICENSE BLOCK ***** */
  39
  40 /*
  41  * npshell.c
  42  *
  43  * Netscape Client Plugin API
  44  * - Function that need to be implemented by plugin developers
  45  *
  46  * This file defines a "shell" plugin that plugin developers can use
  47  * as the basis for a real plugin.  This shell just provides empty
  48  * implementations of all functions that the plugin can implement
  49  * that will be called by Netscape (the NPP_xxx methods defined in
  50  * npapi.h).
  51  *
  52  * dp Suresh <dp@netscape.com>
  53  * updated 5/1998 <pollmann@netscape.com>
  54  * updated 9/2000 <smak@sun.com>
  55  *
  56  */
  57
  58 #include <stdio.h>
  59 #include <string.h>
  60 #include "npapi.h"
  61 #include "nullplugin.h"
  62 #include "strings.h"
  63 #include "plstr.h"
  64
  65 /***********************************************************************
  66  *
  67  * Implementations of plugin API functions
  68  *
  69  ***********************************************************************/
  70
  71 char*
  72 NPP_GetMIMEDescription(void)
  73 {
  74     return(MIME_TYPES_HANDLED);
  75 }
  76
  77 NPError
  78 NPP_GetValue(NPP instance, NPPVariable variable, void *value)
  79 {
  80     NPError err = NPERR_NO_ERROR;
  81
  82     switch (variable) {
  83         case NPPVpluginNameString:
  84             *((char **)value) = PLUGIN_NAME;
  85             break;
  86         case NPPVpluginDescriptionString:
  87             *((char **)value) = PLUGIN_DESCRIPTION;
  88             break;
  89         default:
  90             err = NPERR_GENERIC_ERROR;
  91     }
  92     return err;
  93 }
  94
  95 NPError
  96 NPP_Initialize(void)
  97 {
  98
  99     return NPERR_NO_ERROR;
 100 }
 101
 102 void
 103 NPP_Shutdown(void)
 104 {
 105 }
 106
 107 NPError
 108 NPP_New(NPMIMEType pluginType,
 109     NPP instance,
 110     uint16_t mode,
 111     int16_t argc,
 112     char* argn[],
 113     char* argv[],
 114     NPSavedData* saved)
 115 {
 116
 117     PluginInstance* This;
 118
 119     if (instance == NULL)
 120         return NPERR_INVALID_INSTANCE_ERROR;
 121
 122     instance->pdata = NPN_MemAlloc(sizeof(PluginInstance));
 123
 124     This = (PluginInstance*) instance->pdata;
 125
 126     if (This == NULL)
 127     {
 128         return NPERR_OUT_OF_MEMORY_ERROR;
 129     }
 130
 131     memset(This, 0, sizeof(PluginInstance));
 132
 133     /* mode is NP_EMBED, NP_FULL, or NP_BACKGROUND (see npapi.h) */
 134     This->mode = mode;
 135     This->type = dupMimeType(pluginType);
 136     This->instance = instance;
 137     This->pluginsPageUrl = NULL;
 138     This->exists = FALSE;
 139
 140     /* Parse argument list passed to plugin instance */
 141     /* We are interested in these arguments
 142      *  PLUGINSPAGE = <url>
 143      */
 144     while (argc > 0)
 145     {
 146         argc --;
 147         if (argv[argc] != NULL)
 148         {
 149         if (!PL_strcasecmp(argn[argc], "PLUGINSPAGE"))
 150             This->pluginsPageUrl = strdup(argv[argc]);
 151         else if (!PL_strcasecmp(argn[argc], "PLUGINURL"))
 152             This->pluginsFileUrl = strdup(argv[argc]);
 153         else if (!PL_strcasecmp(argn[argc], "CODEBASE"))
 154             This->pluginsPageUrl = strdup(argv[argc]);
 155         else if (!PL_strcasecmp(argn[argc], "CLASSID"))
 156             This->pluginsFileUrl = strdup(argv[argc]);
 157         else if (!PL_strcasecmp(argn[argc], "HIDDEN"))
 158             This->pluginsHidden = (!PL_strcasecmp(argv[argc],
 159             "TRUE"));
 160         }
 161     }
 162
 163     return NPERR_NO_ERROR;
 164 }
 165
 166 NPError
 167 NPP_Destroy(NPP instance, NPSavedData** save)
 168 {
 169
 170     PluginInstance* This;
 171
 172     if (instance == NULL)
 173         return NPERR_INVALID_INSTANCE_ERROR;
 174
 175     This = (PluginInstance*) instance->pdata;
 176
 177     if (This != NULL) {
 178         if (This->dialogBox)
 179            destroyWidget(This);
 180         if (This->type)
 181             NPN_MemFree(This->type);
 182         if (This->pluginsPageUrl)
 183             NPN_MemFree(This->pluginsPageUrl);
 184         if (This->pluginsFileUrl)
 185                 NPN_MemFree(This->pluginsFileUrl);
 186         NPN_MemFree(instance->pdata);
 187         instance->pdata = NULL;
 188     }
 189
 190     return NPERR_NO_ERROR;
 191 }
 192
 193
 194 NPError
 195 NPP_SetWindow(NPP instance, NPWindow* window)
 196 {
 197     PluginInstance* This;
 198     NPSetWindowCallbackStruct *ws_info;
 199
 200     if (instance == NULL)
 201         return NPERR_INVALID_INSTANCE_ERROR;
 202
 203     This = (PluginInstance*) instance->pdata;
 204
 205     if (This == NULL)
 206         return NPERR_INVALID_INSTANCE_ERROR;
 207
 208     ws_info = (NPSetWindowCallbackStruct *)window->ws_info;
 209
 210 #ifdef MOZ_X11
 211     if (This->window == (Window) window->window) {
 212         /* The page with the plugin is being resized.
 213            Save any UI information because the next time
 214            around expect a SetWindow with a new window
 215            id.
 216         */
 217 #ifdef DEBUG
 218         fprintf(stderr, "Nullplugin: plugin received window resize.\n");
 219         fprintf(stderr, "Window=(%i)\n", (int)window);
 220         fprintf(stderr, "W=(%i) H=(%i)\n",
 221             (int)window->width, (int)window->height);
 222 #endif
 223         return NPERR_NO_ERROR;
 224     } else {
 225
 226       This->window = (Window) window->window;
 227       This->x = window->x;
 228       This->y = window->y;
 229       This->width = window->width;
 230       This->height = window->height;
 231       This->display = ws_info->display;
 232       This->visual = ws_info->visual;
 233       This->depth = ws_info->depth;
 234       This->colormap = ws_info->colormap;
 235       makePixmap(This);
 236       makeWidget(This);
 237     }
 238 #endif  /* #ifdef MOZ_X11 */
 239
 240     return NPERR_NO_ERROR;
 241 }
 242
 243
 244 NPError
 245 NPP_NewStream(NPP instance,
 246           NPMIMEType type,
 247           NPStream *stream,
 248           NPBool seekable,
 249           uint16_t *stype)
 250 {
 251     if (instance == NULL)
 252         return NPERR_INVALID_INSTANCE_ERROR;
 253
 254     return NPERR_NO_ERROR;
 255 }
 256
 257
 258 int32_t
 259 NPP_WriteReady(NPP instance, NPStream *stream)
 260 {
 261     if (instance == NULL)
 262         return NPERR_INVALID_INSTANCE_ERROR;
 263
 264     /* We don't want any data, kill the stream */
 265     NPN_DestroyStream(instance, stream, NPRES_DONE);
 266
 267     /* Number of bytes ready to accept in NPP_Write() */
 268     return -1L;   /* don't accept any bytes in NPP_Write() */
 269 }
 270
 271
 272 int32_t
 273 NPP_Write(NPP instance, NPStream *stream, int32_t offset, int32_t len, void *buffer)
 274 {
 275     if (instance == NULL)
 276         return NPERR_INVALID_INSTANCE_ERROR;
 277
 278     /* We don't want any data, kill the stream */
 279     NPN_DestroyStream(instance, stream, NPRES_DONE);
 280
 281     return -1L;   /* don't accept any bytes in NPP_Write() */
 282 }
 283
 284
 285 NPError
 286 NPP_DestroyStream(NPP instance, NPStream *stream, NPError reason)
 287 {
 288     if (instance == NULL)
 289         return NPERR_INVALID_INSTANCE_ERROR;
 290
 291     /***** Insert NPP_DestroyStream code here *****\
 292     PluginInstance* This;
 293     This = (PluginInstance*) instance->pdata;
 294     \**********************************************/
 295
 296     return NPERR_NO_ERROR;
 297 }
 298
 299
 300 void
 301 NPP_StreamAsFile(NPP instance, NPStream *stream, const char* fname)
 302 {
 303     /***** Insert NPP_StreamAsFile code here *****\
 304     PluginInstance* This;
 305     if (instance != NULL)
 306         This = (PluginInstance*) instance->pdata;
 307     \*********************************************/
 308 }
 309
 310
 311 void
 312 NPP_URLNotify(NPP instance, const char* url,
 313                 NPReason reason, void* notifyData)
 314 {
 315     /***** Insert NPP_URLNotify code here *****\
 316     PluginInstance* This;
 317     if (instance != NULL)
 318         This = (PluginInstance*) instance->pdata;
 319     \*********************************************/
 320 }
 321
 322
 323 void
 324 NPP_Print(NPP instance, NPPrint* printInfo)
 325 {
 326     if(printInfo == NULL)
 327         return;
 328
 329     if (instance != NULL) {
 330     /***** Insert NPP_Print code here *****\
 331         PluginInstance* This = (PluginInstance*) instance->pdata;
 332     \**************************************/
 333
 334         if (printInfo->mode == NP_FULL) {
 335             /*
 336              * PLUGIN DEVELOPERS:
 337              *  If your plugin would like to take over
 338              *  printing completely when it is in full-screen mode,
 339              *  set printInfo->pluginPrinted to TRUE and print your
 340              *  plugin as you see fit.  If your plugin wants Netscape
 341              *  to handle printing in this case, set
 342              *  printInfo->pluginPrinted to FALSE (the default) and
 343              *  do nothing.  If you do want to handle printing
 344              *  yourself, printOne is true if the print button
 345              *  (as opposed to the print menu) was clicked.
 346              *  On the Macintosh, platformPrint is a THPrint; on
 347              *  Windows, platformPrint is a structure
 348              *  (defined in npapi.h) containing the printer name, port,
 349              *  etc.
 350              */
 351
 352     /***** Insert NPP_Print code here *****\
 353             void* platformPrint =
 354                 printInfo->print.fullPrint.platformPrint;
 355             NPBool printOne =
 356                 printInfo->print.fullPrint.printOne;
 357     \**************************************/
 358
 359             /* Do the default*/
 360             printInfo->print.fullPrint.pluginPrinted = FALSE;
 361         }
 362         else {  /* If not fullscreen, we must be embedded */
 363             /*
 364              * PLUGIN DEVELOPERS:
 365              *  If your plugin is embedded, or is full-screen
 366              *  but you returned false in pluginPrinted above, NPP_Print
 367              *  will be called with mode == NP_EMBED.  The NPWindow
 368              *  in the printInfo gives the location and dimensions of
 369              *  the embedded plugin on the printed page.  On the
 370              *  Macintosh, platformPrint is the printer port; on
 371              *  Windows, platformPrint is the handle to the printing
 372              *  device context.
 373              */
 374
 375     /***** Insert NPP_Print code here *****\
 376             NPWindow* printWindow =
 377                 &(printInfo->print.embedPrint.window);
 378             void* platformPrint =
 379                 printInfo->print.embedPrint.platformPrint;
 380     \**************************************/
 381         }
 382     }
 383 }