modules/plugin/sdk/samples/testevents/npevents.cpp

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
   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  *   Neil Hodgson <nhodgson@bigpond.net.au>
  25  *   Mark Hammond <MarkH@ActiveState.com>
  26  *
  27  * Alternatively, the contents of this file may be used under the terms of
  28  * either the GNU General Public License Version 2 or later (the "GPL"), or
  29  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  30  * in which case the provisions of the GPL or the LGPL are applicable instead
  31  * of those above. If you wish to allow use of your version of this file only
  32  * under the terms of either the GPL or the LGPL, and not to allow others to
  33  * use your version of this file under the terms of the MPL, indicate your
  34  * decision by deleting the provisions above and replace them with the notice
  35  * and other provisions required by the GPL or the LGPL. If you do not delete
  36  * the provisions above, a recipient may use your version of this file under
  37  * the terms of any one of the MPL, the GPL or the LGPL.
  38  *
  39  * ***** END LICENSE BLOCK ***** */
  40
  41 // npevents.cxx
  42 // Demonstration plugin for Mozilla that handles events, focus and keystrokes.
  43 // See README.txt for more details.
  44
  45 #include "nsplugin.h"
  46 #include "nsIServiceManager.h"
  47 #include "nsISupports.h"
  48 #include "nsIFactory.h"
  49 #include "nsIGenericFactory.h"
  50 #include "nsString.h"
  51 #include "nsIAllocator.h"
  52
  53 #include "nsIEventsPluginInstance.h"
  54
  55 #include <stdio.h>
  56 #include <string.h>
  57
  58 #if defined (XP_WIN)
  59
  60 #include <windows.h>
  61
  62 #elif defined (XP_UNIX)
  63
  64 #include <gdk/gdkprivate.h>
  65 #include <gtk/gtk.h>
  66 #include <gdk/gdkkeysyms.h>
  67 #include <gtkmozbox.h>
  68
  69 #endif
  70
  71 #define EVENTSPLUGIN_DEBUG
  72
  73 /**
  74  * {CB2EF72A-856A-4818-8E72-3439395E335F}
  75  */
  76 #define NS_EVENTSAMPLEPLUGIN_CID { 0xcb2ef72a, 0x856a, 0x4818, { 0x8e, 0x72, 0x34, 0x39, 0x39, 0x5e, 0x33, 0x5f } }
  77
  78 #if defined(XP_UNIX)
  79 typedef struct _PlatformInstance {
  80         GtkWidget *moz_box;
  81         Display * display;
  82         uint32 x, y;
  83         uint32 width, height;
  84 }
  85 PlatformInstance;
  86
  87 typedef GtkWidget* WinID;
  88
  89 #endif // XP_UNIX
  90
  91 #if defined(XP_WIN)
  92 typedef struct _PlatformInstance
  93 {
  94         WNDPROC fOldChildWindowProc; // The original WNDPROC of the edit control.
  95         WNDPROC fParentWindowProc; // The Mozilla WNDPROC for main (parent) window.
  96 } PlatformInstance;
  97
  98 // Unique string for associating a pointer with our WNDPROC
  99 static const char* gInstanceLookupString = "instance->pdata";
 100
 101 typedef HWND WinID;
 102
 103 #endif // XP_WIN
 104
 105 static NS_DEFINE_CID(kPluginManagerCID, NS_PLUGINMANAGER_CID);
 106 static NS_DEFINE_CID(kEventsPluginCID, NS_EVENTSAMPLEPLUGIN_CID);
 107
 108 const char *kPluginName = "Events Sample Plug-in";
 109 const char *kPluginDescription = "Sample plugin that demonstrates events, focus and keystrokes.";
 110 #define PLUGIN_MIME_TYPE "application/x-events-sample-plugin"
 111
 112 static const char* kMimeTypes[] = {
 113     PLUGIN_MIME_TYPE
 114 };
 115
 116 static const char* kMimeDescriptions[] = {
 117     "Event Sample Plug-in"
 118 };
 119
 120 static const char* kFileExtensions[] = {
 121     "smpev"
 122 };
 123
 124 static const PRInt32 kNumMimeTypes = sizeof(kMimeTypes) / sizeof(*kMimeTypes);
 125
 126 ////////////////////////////////////////////////////////////////////////////////
 127 // EventsPluginInstance represents an instance of the EventsPlugin class.
 128
 129 class EventsPluginInstance :
 130         public nsIPluginInstance,
 131         public nsIEventsSampleInstance {
 132 public:
 133     ////////////////////////////////////////////////////////////////////////////
 134     // for implementing a generic module
 135     static NS_METHOD
 136     Create(nsISupports* aOuter, REFNSIID aIID, void** aResult);
 137
 138     static NS_METHOD
 139     RegisterSelf(nsIComponentManager* aCompMgr,
 140                  nsIFile* aPath,
 141                  const char* aRegistryLocation,
 142                  const char* aComponentType,
 143                  const nsModuleComponentInfo *info);
 144
 145     static NS_METHOD
 146     UnregisterSelf(nsIComponentManager* aCompMgr,
 147                    nsIFile* aPath,
 148                    const char* aRegistryLocation,
 149                    const nsModuleComponentInfo *info);
 150
 151
 152         NS_DECL_ISUPPORTS
 153         NS_DECL_NSIEVENTSSAMPLEINSTANCE
 154
 155         ////////////////////////////////////////////////////////////////////////////
 156         // from nsIEventHandler:
 157
 158         NS_IMETHOD HandleEvent(nsPluginEvent* event, PRBool* handled);
 159
 160         ////////////////////////////////////////////////////////////////////////////
 161         // from nsIPluginInstance:
 162
 163         NS_IMETHOD Initialize(nsIPluginInstancePeer *peer);
 164
 165         // Required backpointer to the peer.
 166         NS_IMETHOD GetPeer(nsIPluginInstancePeer **result);
 167
 168         NS_IMETHOD Start(void);
 169
 170         NS_IMETHOD Stop(void);
 171
 172         NS_IMETHOD Destroy(void);
 173
 174         NS_IMETHOD SetWindow(nsPluginWindow* window);
 175
 176         NS_IMETHOD NewStream(nsIPluginStreamListener** listener);
 177
 178         NS_IMETHOD Print(nsPluginPrint* platformPrint);
 179
 180         NS_IMETHOD GetValue(nsPluginInstanceVariable variable, void *value);
 181
 182         ////////////////////////////////////////////////////////////////////////////
 183         // EventsPluginInstance specific methods:
 184
 185         EventsPluginInstance();
 186         virtual ~EventsPluginInstance();
 187
 188         void PlatformNew(void);
 189         nsresult PlatformDestroy(void);
 190         void PlatformResetWindow();
 191         PRInt16 PlatformHandleEvent(nsPluginEvent* event);
 192         void PlatformResizeWindow(nsPluginWindow* window);
 193         nsresult PlatformCreateWindow(nsPluginWindow* window);
 194
 195         void SetMode(nsPluginMode mode) { fMode = mode; }
 196
 197 protected:
 198         ////////////////////////////////////////////////////////////////////////////
 199         // Implementation methods
 200         nsresult DoSetWindow(nsPluginWindow* window);
 201
 202         // Data
 203         nsCOMPtr<nsIPluginInstancePeer> fPeer;
 204         nsPluginWindow *fWindow; // no nsCOMPtr as not an interface!
 205         nsPluginMode fMode;
 206         PlatformInstance fPlatform;
 207
 208         WinID wMain; // The window created by Mozilla for us.
 209         WinID wChild; // The window we create as a child of the nsWindow.
 210
 211         ////////////////////////////////////////////////////////////////////////////
 212         // Platform specific helpers
 213 #ifdef XP_WIN
 214         static LRESULT CALLBACK WndProcChild(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
 215 #endif
 216 };
 217
 218 ////////////////////////////////////////////////////////////////////////////////
 219 // EventsPluginStream represents the stream used by EvMozs
 220 // to receive data from the browser.
 221
 222 class EventsPluginStreamListener : public nsIPluginStreamListener {
 223 public:
 224
 225         NS_DECL_ISUPPORTS
 226
 227         ////////////////////////////////////////////////////////////////////////////
 228         // from nsIPluginStreamListener:
 229
 230         // Notify the observer that the URL has started to load.  This method is
 231         // called only once, at the beginning of a URL load.
 232         NS_IMETHOD OnStartBinding(nsIPluginStreamInfo* pluginInfo);
 233
 234         // Notify the client that data is available in the input stream.  This method is
 235         // called whenver data is written into the input stream by the networking library.
 236         NS_IMETHOD OnDataAvailable(nsIPluginStreamInfo* pluginInfo,
 237                                    nsIInputStream* input,
 238                                    PRUint32 length);
 239
 240         NS_IMETHOD OnFileAvailable(nsIPluginStreamInfo* pluginInfo, const char* fileName);
 241
 242         // Notify the observer that the URL has finished loading.  This method is
 243         // called once when the networking library has finished processing the
 244         // URL transaction initiatied via the nsINetService::Open(...) call.
 245         NS_IMETHOD OnStopBinding(nsIPluginStreamInfo* pluginInfo, nsresult status);
 246
 247         NS_IMETHOD OnNotify(const char* url, nsresult status);
 248
 249         NS_IMETHOD GetStreamType(nsPluginStreamType *result);
 250
 251         ////////////////////////////////////////////////////////////////////////////
 252         // EventsPluginStreamListener specific methods:
 253
 254         EventsPluginStreamListener(EventsPluginInstance *inst_, const char* url);
 255         virtual ~EventsPluginStreamListener(void);
 256
 257 protected:
 258         const char* fMessageName;
 259         EventsPluginInstance *inst;
 260 };
 261
 262 // The module loader information.
 263 static const nsModuleComponentInfo gComponentInfo[] = {
 264     { "Events Sample Plugin",
 265       NS_EVENTSAMPLEPLUGIN_CID,
 266       NS_INLINE_PLUGIN_CONTRACTID_PREFIX PLUGIN_MIME_TYPE,
 267       EventsPluginInstance::Create,
 268       EventsPluginInstance::RegisterSelf,
 269       EventsPluginInstance::UnregisterSelf },
 270 };
 271
 272 NS_IMPL_NSGETMODULE(EventsPlugin, gComponentInfo)
 273
 274
 275 ////////////////////////////////////////////////////////////////////////////////
 276 // EventsPluginInstance static Methods
 277 ////////////////////////////////////////////////////////////////////////////////
 278
 279 NS_METHOD
 280 EventsPluginInstance::Create(nsISupports* aOuter, REFNSIID aIID, void** aResult)
 281 {
 282     NS_PRECONDITION(aOuter == nsnull, "no aggregation");
 283     if (aOuter)
 284         return NS_ERROR_NO_AGGREGATION;
 285
 286     EventsPluginInstance* plugin = new EventsPluginInstance();
 287     if (! plugin)
 288         return NS_ERROR_OUT_OF_MEMORY;
 289
 290     nsresult rv;
 291     NS_ADDREF(plugin);
 292     rv = plugin->QueryInterface(aIID, aResult);
 293     NS_RELEASE(plugin);
 294     return rv;
 295 }
 296
 297 NS_METHOD
 298 EventsPluginInstance::RegisterSelf(nsIComponentManager* aCompMgr,
 299                                    nsIFile* aPath,
 300                                    const char* aRegistryLocation,
 301                                    const char* aComponentType,
 302                                    const nsModuleComponentInfo *info)
 303 {
 304     nsresult rv;
 305
 306     nsIServiceManager *svcMgr;
 307     rv = aCompMgr->QueryInterface(NS_GET_IID(nsIServiceManager),
 308                                   reinterpret_cast<void**>(&svcMgr));
 309     if (NS_FAILED(rv))
 310         return rv;
 311
 312     nsIPluginManager* pm;
 313     rv = svcMgr->GetService(kPluginManagerCID,
 314                             NS_GET_IID(nsIPluginManager),
 315                             reinterpret_cast<void**>(&pm));
 316     NS_RELEASE(svcMgr);
 317
 318     if (NS_SUCCEEDED(rv)) {
 319         rv = pm->RegisterPlugin(kEventsPluginCID,
 320                                 kPluginName,
 321                                 kPluginDescription,
 322                                 kMimeTypes,
 323                                 kMimeDescriptions,
 324                                 kFileExtensions,
 325                                 kNumMimeTypes);
 326
 327         NS_RELEASE(pm);
 328     }
 329
 330     return rv;
 331 }
 332
 333
 334 NS_METHOD
 335 EventsPluginInstance::UnregisterSelf(nsIComponentManager* aCompMgr,
 336                                      nsIFile* aPath,
 337                                      const char* aRegistryLocation,
 338                                      const nsModuleComponentInfo *info)
 339 {
 340     nsresult rv;
 341
 342     nsIServiceManager *svcMgr;
 343     rv = aCompMgr->QueryInterface(NS_GET_IID(nsIServiceManager),
 344                                   reinterpret_cast<void**>(&svcMgr));
 345     if (NS_FAILED(rv))
 346         return rv;
 347
 348     nsIPluginManager* pm;
 349     rv = svcMgr->GetService(kPluginManagerCID,
 350                             NS_GET_IID(nsIPluginManager),
 351                             reinterpret_cast<void**>(&pm));
 352     NS_RELEASE(svcMgr);
 353
 354     if (NS_SUCCEEDED(rv)) {
 355         rv = pm->UnregisterPlugin(kEventsPluginCID);
 356         NS_RELEASE(pm);
 357     }
 358
 359     return rv;
 360 }
 361
 362 ////////////////////////////////////////////////////////////////////////////////
 363 // EventsPluginInstance Methods
 364 ////////////////////////////////////////////////////////////////////////////////
 365
 366 // These macros produce simple version of QueryInterface and AddRef.
 367 // See the nsISupports.h header file for details.
 368
 369 NS_IMPL_ISUPPORTS2(EventsPluginInstance, nsIPluginInstance, nsIEventsSampleInstance)
 370
 371 EventsPluginInstance::EventsPluginInstance() :
 372                 fPeer(NULL), fWindow(NULL), fMode(nsPluginMode_Embedded)
 373 {
 374         wChild = 0;
 375 }
 376
 377 EventsPluginInstance::~EventsPluginInstance(void) {
 378 }
 379
 380
 381 NS_METHOD EventsPluginInstance::Initialize(nsIPluginInstancePeer *peer) {
 382 #ifdef EVENTSPLUGIN_DEBUG
 383         printf("EventsPluginInstance::Initialize\n");
 384 #endif
 385
 386         NS_ASSERTION(peer != NULL, "null peer");
 387
 388         fPeer = peer;
 389         nsCOMPtr<nsIPluginTagInfo> taginfo;
 390         const char* const* names = nsnull;
 391         const char* const* values = nsnull;
 392         PRUint16 count = 0;
 393         nsresult result;
 394
 395         peer->AddRef();
 396         result = peer->GetMode(&fMode);
 397         if (NS_FAILED(result)) return result;
 398
 399         taginfo = do_QueryInterface(peer, &result);
 400         if (NS_SUCCEEDED(result)) {
 401                 taginfo->GetAttributes(count, names, values);
 402         }
 403
 404         PlatformNew();  /* Call Platform-specific initializations */
 405         return NS_OK;
 406 }
 407
 408 NS_METHOD EventsPluginInstance::GetPeer(nsIPluginInstancePeer* *result) {
 409 #ifdef EVENTSPLUGIN_DEBUG
 410         printf("EventsPluginInstance::GetPeer\n");
 411 #endif
 412
 413         *result = fPeer;
 414         NS_IF_ADDREF(*result);
 415         return NS_OK;
 416 }
 417
 418 NS_METHOD EventsPluginInstance::Start(void) {
 419 #ifdef EVENTSPLUGIN_DEBUG
 420         printf("EventsPluginInstance::Start\n");
 421 #endif
 422
 423         return NS_OK;
 424 }
 425
 426 NS_METHOD EventsPluginInstance::Stop(void) {
 427 #ifdef EVENTSPLUGIN_DEBUG
 428         printf("EventsPluginInstance::Stop\n");
 429 #endif
 430
 431         return NS_OK;
 432 }
 433
 434 NS_METHOD EventsPluginInstance::Destroy(void) {
 435 #ifdef EVENTSPLUGIN_DEBUG
 436         printf("EventsPluginInstance::Destroy\n");
 437 #endif
 438
 439         PlatformDestroy(); // Perform platform specific cleanup
 440         return NS_OK;
 441 }
 442
 443 /*+++++++++++++++++++++++++++++++++++++++++++++++++
 444  * NPP_SetWindow:
 445  * Sets the window in which a plug-in draws, and returns an error value.
 446  *
 447  * NPP_SetWindow informs the plug-in instance specified by instance of the
 448  * the window denoted by window in which the instance draws. This nsPluginWindow
 449  * pointer is valid for the life of the instance, or until NPP_SetWindow is called
 450  * again with a different value. Subsequent calls to NPP_SetWindow for a given
 451  * instance typically indicate that the window has been resized. If either window
 452  * or window->window are NULL, the plug-in must not perform any additional
 453  * graphics operations on the window and should free any resources associated
 454  * with the window.
 455  +++++++++++++++++++++++++++++++++++++++++++++++++*/
 456 NS_METHOD EventsPluginInstance::SetWindow(nsPluginWindow* window) {
 457 #ifdef EVENTSPLUGIN_DEBUG
 458         printf("EventsPluginInstance::SetWindow\n");
 459 #endif
 460
 461         nsresult result;
 462         result = DoSetWindow(window);
 463         fWindow = window;
 464         return result;
 465 }
 466
 467 nsresult EventsPluginInstance::DoSetWindow(nsPluginWindow* window) {
 468         /*
 469          * PLUGIN DEVELOPERS:
 470          *      Before setting window to point to the
 471          *      new window, you may wish to compare the new window
 472          *      info to the previous window (if any) to note window
 473          *      size changes, etc.
 474          */
 475          nsresult result = NS_OK;
 476         if ( fWindow != NULL ) {
 477                 // If we already have a window, clean it up
 478                 // before working with the new window
 479                 if ( window && window->window && wMain == (WinID)window->window ) {
 480                         /* The new window is the same as the old one. Exit now. */
 481                         PlatformResizeWindow(window);
 482                         return NS_OK;
 483                 }
 484                 // Otherwise, just reset the window ready for the new one.
 485                 PlatformResetWindow();
 486         }
 487         else if ( (window == NULL) || ( window->window == NULL ) ) {
 488                 /* We can just get out of here if there is no current
 489                  * window and there is no new window to use. */
 490                 return NS_OK;
 491         }
 492         if (window && window->window) {
 493                 // Remember our main parent window.
 494                 wMain = (WinID)window->window;
 495                 // And create the child window.
 496                 result = PlatformCreateWindow(window);
 497         }
 498         return result;
 499 }
 500
 501 NS_METHOD EventsPluginInstance::NewStream(nsIPluginStreamListener** listener) {
 502 #ifdef EVENTSPLUGIN_DEBUG
 503         printf("EventsPluginInstance::NewStream\n");
 504 #endif
 505
 506         if (listener != NULL) {
 507                 EventsPluginStreamListener* sl =
 508                     new EventsPluginStreamListener(this, "http://www.mozilla.org");
 509                 if (!sl)
 510                         return NS_ERROR_UNEXPECTED;
 511                 sl->AddRef();
 512                 *listener = sl;
 513         }
 514
 515         return NS_OK;
 516 }
 517
 518 NS_METHOD EventsPluginInstance::Print(nsPluginPrint* printInfo) {
 519 #ifdef EVENTSPLUGIN_DEBUG
 520         printf("EventsPluginInstance::Print\n");
 521 #endif
 522
 523         if (printInfo == NULL)
 524                 return NS_ERROR_FAILURE;
 525
 526         if (printInfo->mode == nsPluginMode_Full) {
 527                 /*
 528                  * PLUGIN DEVELOPERS:
 529                  *      If your plugin would like to take over
 530                  *      printing completely when it is in full-screen mode,
 531                  *      set printInfo->pluginPrinted to TRUE and print your
 532                  *      plugin as you see fit.  If your plugin wants Netscape
 533                  *      to handle printing in this case, set
 534                  *      printInfo->pluginPrinted to FALSE (the default) and
 535                  *      do nothing.  If you do want to handle printing
 536                  *      yourself, printOne is true if the print button
 537                  *      (as opposed to the print menu) was clicked.
 538                  *      On the Macintosh, platformPrint is a THPrint; on
 539                  *      Windows, platformPrint is a structure
 540                  *      (defined in npapi.h) containing the printer name, port,
 541                  *      etc.
 542                  */
 543
 544                 /* Do the default*/
 545                 printInfo->print.fullPrint.pluginPrinted = PR_FALSE;
 546         } else {        /* If not fullscreen, we must be embedded */
 547                 /*
 548                  * PLUGIN DEVELOPERS:
 549                  *      If your plugin is embedded, or is full-screen
 550                  *      but you returned false in pluginPrinted above, NPP_Print
 551                  *      will be called with mode == nsPluginMode_Embedded.  The nsPluginWindow
 552                  *      in the printInfo gives the location and dimensions of
 553                  *      the embedded plugin on the printed page.  On the
 554                  *      Macintosh, platformPrint is the printer port; on
 555                  *      Windows, platformPrint is the handle to the printing
 556                  *      device context.
 557                  */
 558         }
 559         return NS_OK;
 560 }
 561
 562 /*+++++++++++++++++++++++++++++++++++++++++++++++++
 563  * NPP_HandleEvent:
 564  * Mac-only, but stub must be present for Windows
 565  * Delivers a platform-specific event to the instance.
 566  *
 567  * On the Macintosh, event is a pointer to a standard Macintosh EventRecord.
 568  * All standard event types are passed to the instance as appropriate. In general,
 569  * return TRUE if you handle the event and FALSE if you ignore the event.
 570  +++++++++++++++++++++++++++++++++++++++++++++++++*/
 571
 572 NS_METHOD EventsPluginInstance::HandleEvent(nsPluginEvent* event, PRBool* handled) {
 573 #ifdef EVENTSPLUGIN_DEBUG
 574         printf("EventsPluginInstance::HandleEvent\n");
 575 #endif
 576
 577         *handled = (PRBool)PlatformHandleEvent(event);
 578         return NS_OK;
 579 }
 580
 581 NS_METHOD EventsPluginInstance::GetValue(nsPluginInstanceVariable /*variable*/, void * /*value*/) {
 582 #ifdef EVENTSPLUGIN_DEBUG
 583         printf("EventsPluginInstance::GetValue\n");
 584 #endif
 585
 586         return NS_ERROR_FAILURE;
 587 }
 588
 589 ////////////////////////////////////////////////////////////////////////////////
 590 // EventsPluginStreamListener Methods
 591 ////////////////////////////////////////////////////////////////////////////////
 592
 593 EventsPluginStreamListener::EventsPluginStreamListener(EventsPluginInstance* inst_,
 594         const char* msgName)
 595                 : fMessageName(msgName), inst(inst_) {
 596 #ifdef EVENTSPLUGIN_DEBUG
 597         printf("EventsPluginStreamListener: EventsPluginStreamListener for %s\n", fMessageName);
 598 #endif
 599 }
 600
 601 EventsPluginStreamListener::~EventsPluginStreamListener(void) {
 602 }
 603
 604 // This macro produces a simple version of QueryInterface, AddRef and Release.
 605 // See the nsISupports.h header file for details.
 606
 607 NS_IMPL_ISUPPORTS1(EventsPluginStreamListener, nsIPluginStreamListener)
 608
 609 NS_METHOD EventsPluginStreamListener::OnStartBinding(nsIPluginStreamInfo * /*pluginInfo*/) {
 610 #ifdef EVENTSPLUGIN_DEBUG
 611         printf("EventsPluginStreamListener::OnStartBinding\n");
 612         printf("EventsPluginStreamListener: Opening plugin stream for %s\n", fMessageName);
 613 #endif
 614         return NS_OK;
 615 }
 616
 617 NS_METHOD EventsPluginStreamListener::OnDataAvailable(
 618     nsIPluginStreamInfo * /*pluginInfo*/,
 619     nsIInputStream* input,
 620     PRUint32 length) {
 621
 622 #ifdef EVENTSPLUGIN_DEBUG
 623         printf("EventsPluginStreamListener::OnDataAvailable\n");
 624 #endif
 625
 626         char* buffer = new char[length];
 627         if (buffer) {
 628                 PRUint32 amountRead = 0;
 629                 nsresult rslt = input->Read(buffer, length, &amountRead);
 630                 if (rslt == NS_OK) {
 631                         char msg[256];
 632                         sprintf(msg, "### Received %d bytes for %s\n", length, fMessageName);
 633                 }
 634                 delete buffer;
 635         }
 636         return NS_OK;
 637 }
 638
 639 NS_METHOD EventsPluginStreamListener::OnFileAvailable(
 640     nsIPluginStreamInfo * /*pluginInfo*/,
 641     const char* fileName) {
 642
 643 #ifdef EVENTSPLUGIN_DEBUG
 644         printf("EventsPluginStreamListener::OnFileAvailable\n");
 645 #endif
 646
 647         char msg[256];
 648         sprintf(msg, "### File available for %s: %s\n", fMessageName, fileName);
 649         return NS_OK;
 650 }
 651
 652 NS_METHOD EventsPluginStreamListener::OnStopBinding(
 653     nsIPluginStreamInfo * /*pluginInfo*/,
 654     nsresult /*status*/) {
 655
 656 #ifdef EVENTSPLUGIN_DEBUG
 657         printf("EventsPluginStreamListener::OnStopBinding\n");
 658 #endif
 659
 660         char msg[256];
 661         sprintf(msg, "### Closing plugin stream for %s\n", fMessageName);
 662         return NS_OK;
 663 }
 664
 665 NS_METHOD EventsPluginStreamListener::OnNotify(const char * /*url*/, nsresult /*status*/) {
 666 #ifdef EVENTSPLUGIN_DEBUG
 667         printf("EventsPluginStreamListener::OnNotify\n");
 668 #endif
 669
 670         return NS_OK;
 671 }
 672
 673 NS_METHOD EventsPluginStreamListener::GetStreamType(nsPluginStreamType *result) {
 674 #ifdef EVENTSPLUGIN_DEBUG
 675         printf("EventsPluginStreamListener::GetStreamType\n");
 676 #endif
 677
 678         *result = nsPluginStreamType_Normal;
 679         return NS_OK;
 680 }
 681
 682 ///////////////////////////////////////////////////////////////////////////////
 683 // Platform-Specific Implemenations
 684
 685 // UNIX Implementations
 686
 687 #ifdef XP_UNIX
 688
 689 void EventsPluginInstance::PlatformNew(void) {
 690         fPlatform.moz_box = 0;
 691 }
 692
 693 nsresult EventsPluginInstance::PlatformDestroy(void) {
 694         // the mozbox will be destroyed by the native destruction of the
 695         // widget's parent.
 696         return NS_OK;
 697 }
 698
 699 void EventsPluginInstance::PlatformResetWindow() {
 700 #ifdef EVENTSPLUGIN_DEBUG
 701         printf("EventsPluginInstance::PlatformResetWindow\n");
 702 #endif
 703         fPlatform.moz_box = 0;
 704 }
 705
 706 nsresult EventsPluginInstance::PlatformCreateWindow(nsPluginWindow* window) {
 707 #ifdef EVENTSPLUGIN_DEBUG
 708         printf("EventsPluginInstance::PlatformCreateWindow %lx\n", (long)window);
 709 #endif
 710
 711         Window x_window = (Window)window->window;
 712         GdkWindow *gdk_window = (GdkWindow *)gdk_xid_table_lookup(x_window);
 713         if (!gdk_window) {
 714                 fprintf(stderr, "NO WINDOW!!!\n");
 715                 return NS_ERROR_FAILURE;
 716         }
 717         fPlatform.moz_box = gtk_mozbox_new(gdk_window);
 718
 719         wChild = gtk_entry_new();
 720         gtk_container_add(GTK_CONTAINER(fPlatform.moz_box), wChild);
 721         gtk_widget_show_all(fPlatform.moz_box);
 722         return NS_OK;
 723 }
 724
 725 void EventsPluginInstance::PlatformResizeWindow(nsPluginWindow* window) {
 726         NS_PRECONDITION(wChild, "Have no wChild!");
 727 #ifdef EVENTSPLUGIN_DEBUG
 728         printf("EventsPluginInstance::PlatformResizeWindow to size (%d,%d)\n", window->width, window->height);
 729 #endif
 730         // Mozilla has already sized the mozbox - we just need to handle the child.
 731         gtk_widget_set_usize(wChild, window->width, window->height);
 732 }
 733
 734 int16 EventsPluginInstance::PlatformHandleEvent(nsPluginEvent * /*event*/) {
 735         /* UNIX Plugins do not use HandleEvent */
 736         return 0;
 737 }
 738
 739 /* attribute string text; */
 740 NS_IMETHODIMP EventsPluginInstance::GetVal(char * *aText) {
 741 #ifdef EVENTSPLUGIN_DEBUG
 742         printf("EventsPluginInstance::GetVal\n");
 743 #endif
 744         char *text = gtk_entry_get_text(GTK_ENTRY(wChild));
 745         *aText = reinterpret_cast<char*>(nsAllocator::Clone(text, strlen(text) + 1));
 746         return (*aText) ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
 747 }
 748
 749 NS_IMETHODIMP EventsPluginInstance::SetVal(const char * aText) {
 750 #ifdef EVENTSPLUGIN_DEBUG
 751         printf("EventsPluginInstance::SetVal\n");
 752 #endif
 753         gtk_entry_set_text(GTK_ENTRY(wChild), aText);
 754         return NS_OK;
 755 }
 756 #endif     /* XP_UNIX */
 757
 758 // Windows Implementations
 759
 760 #if defined(XP_WIN)
 761
 762 void EventsPluginInstance::PlatformNew(void) {
 763         // Nothing to do!
 764 }
 765
 766 nsresult EventsPluginInstance::PlatformDestroy(void) {
 767         wChild = 0;
 768         return NS_OK;
 769 }
 770
 771 nsresult EventsPluginInstance::PlatformCreateWindow(nsPluginWindow* window) {
 772         // Remember parent wndproc.
 773         fPlatform.fParentWindowProc = (WNDPROC)::GetWindowLong(wMain, GWL_WNDPROC);
 774         NS_ABORT_IF_FALSE(fPlatform.fParentWindowProc!=NULL, "Couldn't get the parent WNDPROC");
 775
 776         // Create the child window that fills our nsWindow
 777         RECT rc;
 778         ::GetWindowRect(wMain, &rc);
 779
 780         wChild = ::CreateWindow("Edit", // class - standard Windows edit control.
 781                                                         "", // title
 782                                                         WS_CHILD | WS_VISIBLE | ES_MULTILINE | ES_AUTOVSCROLL, // style
 783                                                         0, 0, rc.right-rc.left, rc.bottom-rc.top,
 784                                                         wMain, // parent
 785                                                         (HMENU)1111, // window ID
 786                                                         0, // instance
 787                                                         NULL); //creation data.
 788         NS_ABORT_IF_FALSE(wChild != NULL, "Failed to create the child window!");
 789         if (!wChild)
 790                 return NS_ERROR_FAILURE;
 791         // Stash away our "this" pointer so our WNDPROC can talk to us.
 792         ::SetProp(wChild, gInstanceLookupString, (HANDLE)this);
 793         fPlatform.fOldChildWindowProc =
 794                 (WNDPROC)::SetWindowLong( wChild,
 795                                                                 GWL_WNDPROC,
 796                                                                 (LONG)EventsPluginInstance::WndProcChild);
 797         return NS_OK;
 798 }
 799
 800 int16 EventsPluginInstance::PlatformHandleEvent(nsPluginEvent * /*event*/) {
 801         return NS_OK;
 802 }
 803
 804 void EventsPluginInstance::PlatformResetWindow() {
 805 #ifdef EVENTSPLUGIN_DEBUG
 806         printf("EventsPluginInstance::PlatformResetWindow\n");
 807 #endif
 808         fPlatform.fParentWindowProc = NULL;
 809         ::SetWindowLong(wChild, GWL_WNDPROC, (LONG)fPlatform.fOldChildWindowProc);
 810         fPlatform.fOldChildWindowProc = NULL;
 811         wChild = NULL;
 812         wMain = NULL;
 813 }
 814
 815 void EventsPluginInstance::PlatformResizeWindow(nsPluginWindow* window) {
 816 #ifdef EVENTSPLUGIN_DEBUG
 817         printf("EventsPluginInstance::PlatformResizeWindow with new size (%d,%d)\n", window->width, window->height);
 818 #endif
 819         RECT rc;
 820         NS_PRECONDITION(wMain != nsnull, "Must have a valid wMain to resize");
 821         ::GetClientRect(wMain, &rc);
 822         ::SetWindowPos(wChild, 0, rc.left, rc.top,
 823                        rc.right - rc.left, rc.bottom - rc.top, SWP_NOZORDER | SWP_NOACTIVATE);
 824 }
 825
 826 /* attribute string text; */
 827 NS_IMETHODIMP EventsPluginInstance::GetVal(char * *aText) {
 828 #ifdef EVENTSPLUGIN_DEBUG
 829         printf("EventsPluginInstance::GetVal\n");
 830 #endif
 831         static char *empty = "";
 832         char *value = empty;
 833         char buffer[256];
 834         if (wChild) {
 835                 GetWindowText(wChild, buffer, sizeof(buffer)/sizeof(buffer[0]));
 836                 value = buffer;
 837         }
 838         *aText = reinterpret_cast<char*>(nsAllocator::Clone(value, strlen(value) + 1));
 839         return (*aText) ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
 840 }
 841
 842 NS_IMETHODIMP EventsPluginInstance::SetVal(const char * aText) {
 843 #ifdef EVENTSPLUGIN_DEBUG
 844         printf("EventsPluginInstance::SetVal\n");
 845 #endif
 846         NS_ABORT_IF_FALSE(wChild != 0, "Don't have a window!");
 847         SetWindowText(wChild, aText);
 848         return NS_OK;
 849 }
 850
 851 // This is the WndProc for our child window (the edit control)
 852 LRESULT CALLBACK EventsPluginInstance::WndProcChild(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam) {
 853         EventsPluginInstance* inst = (EventsPluginInstance*) GetProp(hWnd, gInstanceLookupString);
 854         NS_ABORT_IF_FALSE(inst, "Could not get the inst from the Window!!");
 855         switch (Msg) {
 856         // NOTE: We DON'T pass on DBLCLK messages, as both Scintilla and
 857         // Mozilla have their own special logic, and they step on each other.
 858         // (causing our child to see a double-click as a triple-click)
 859                 case WM_KEYDOWN:
 860                 case WM_SYSKEYDOWN:
 861                 case WM_KEYUP:
 862                 case WM_SYSKEYUP:
 863                 case WM_CHAR:
 864                 case WM_SYSCHAR:
 865                 case WM_LBUTTONDOWN:
 866                 case WM_LBUTTONUP:
 867                 case WM_MBUTTONDOWN:
 868                 case WM_MBUTTONUP:
 869                 case WM_RBUTTONDOWN:
 870                 case WM_RBUTTONUP:
 871                 case WM_MOUSEMOVE:
 872                         // pretend the message happened in our parent.
 873                         return ::CallWindowProc(inst->fPlatform.fParentWindowProc, (HWND)inst->wMain, Msg, wParam, lParam);
 874                 default:
 875                         // let our child's default handle it.
 876                         return ::CallWindowProc(inst->fPlatform.fOldChildWindowProc, hWnd, Msg, wParam, lParam);
 877         }
 878         /* not reached */
 879         NS_ABORT_IF_FALSE(0, "not reached!");
 880 }
 881
 882
 883 #endif     /* XP_WIN */