rev 8829 - in trunk/packages/kdebase/debian: . patches

Fathi Boudra fabo at alioth.debian.org
Tue Jan 8 19:36:17 UTC 2008


Author: fabo
Date: 2008-01-08 19:36:17 +0000 (Tue, 08 Jan 2008)
New Revision: 8829

Added:
   trunk/packages/kdebase/debian/patches/02_kdm-kdmlib_branch_r752071.diff
   trunk/packages/kdebase/debian/patches/03_nsplugins_branch_r754402.diff
   trunk/packages/kdebase/debian/patches/04_nsplugins_regression_fix_branch_r757345.diff
   trunk/packages/kdebase/debian/patches/47_nsplugins_viewer_64bit_fix.diff
Removed:
   trunk/packages/kdebase/debian/patches/01_kdm-kdmlib_branch_r752071.diff
   trunk/packages/kdebase/debian/patches/01_nsplugins_branch_r754402.diff
Modified:
   trunk/packages/kdebase/debian/changelog
Log:
  * Add another nsplugins viewer 64bit fix from upstream revision 758319.
  * Add patch to fix regression in kcontrol administrator mode introduced by
    the changes done in the flash plugin patch:
    - Do not put kcontrol's own widgets inside of QXEmbed.


Modified: trunk/packages/kdebase/debian/changelog
===================================================================
--- trunk/packages/kdebase/debian/changelog	2008-01-08 19:07:04 UTC (rev 8828)
+++ trunk/packages/kdebase/debian/changelog	2008-01-08 19:36:17 UTC (rev 8829)
@@ -9,8 +9,15 @@
 
   * Remove obsolete dependency on xbase-clients.
 
- -- Armin Berres <trigger+debian at space-based.de>  Fri, 04 Jan 2008 14:51:01 +0100
+  +++ Changes by Fathi Boudra:
 
+  * Add another nsplugins viewer 64bit fix from upstream revision 758319.
+  * Add patch to fix regression in kcontrol administrator mode introduced by
+    the changes done in the flash plugin patch:
+    - Do not put kcontrol's own widgets inside of QXEmbed.
+
+ -- Debian Qt/KDE Maintainers <debian-qt-kde at lists.debian.org>  Tue, 08 Jan 2008 11:35:31 +0100
+
 kdebase (4:3.5.8.dfsg.1-5) unstable; urgency=low
 
   +++ Changes by Sune Vuorela:

Deleted: trunk/packages/kdebase/debian/patches/01_kdm-kdmlib_branch_r752071.diff

Deleted: trunk/packages/kdebase/debian/patches/01_nsplugins_branch_r754402.diff

Copied: trunk/packages/kdebase/debian/patches/02_kdm-kdmlib_branch_r752071.diff (from rev 8828, trunk/packages/kdebase/debian/patches/01_kdm-kdmlib_branch_r752071.diff)
===================================================================
--- trunk/packages/kdebase/debian/patches/02_kdm-kdmlib_branch_r752071.diff	                        (rev 0)
+++ trunk/packages/kdebase/debian/patches/02_kdm-kdmlib_branch_r752071.diff	2008-01-08 19:36:17 UTC (rev 8829)
@@ -0,0 +1,289 @@
+#DPATCHLEVEL=0
+--- kcontrol/kdm/kdm-users.cpp	(.../tags/KDE/3.5.8/kdebase)	(revision 752071)
++++ kcontrol/kdm/kdm-users.cpp	(.../branches/KDE/3.5/kdebase)	(revision 752071)
+@@ -418,7 +418,8 @@
+ 	      setOn(selectedUsers.find(*name) != selectedUsers.end());
+       (new QCheckListItem(optoutlv, *name, QCheckListItem::CheckBox))->
+ 	      setOn(hiddenUsers.find(*name) != hiddenUsers.end());
+-      usercombo->insertItem(*name);
++      if ((*name)[0] != '@')
++        usercombo->insertItem(*name);
+     }
+     optinlv->sort();
+     optoutlv->sort();
+--- kcontrol/kdm/kdm-appear.cpp	(.../tags/KDE/3.5.8/kdebase)	(revision 752071)
++++ kcontrol/kdm/kdm-appear.cpp	(.../branches/KDE/3.5/kdebase)	(revision 752071)
+@@ -172,6 +172,7 @@
+   guicombo = new KBackedComboBox(group);
+   guicombo->insertItem( "", i18n("<default>") );
+   loadGuiStyles(guicombo);
++  guicombo->listBox()->sort();
+   label = new QLabel(guicombo, i18n("GUI s&tyle:"), group);
+   connect(guicombo, SIGNAL(activated(int)), SLOT(changed()));
+   hglay->addWidget(label, 0, 0);
+@@ -184,6 +185,7 @@
+   colcombo = new KBackedComboBox(group);
+   colcombo->insertItem( "", i18n("<default>") );
+   loadColorSchemes(colcombo);
++  colcombo->listBox()->sort();
+   label = new QLabel(colcombo, i18n("&Color scheme:"), group);
+   connect(colcombo, SIGNAL(activated(int)), SLOT(changed()));
+   hglay->addWidget(label, 1, 0);
+--- kdmlib/kgreet_classic.cpp	(.../tags/KDE/3.5.8/kdebase)	(revision 752071)
++++ kdmlib/kgreet_classic.cpp	(.../branches/KDE/3.5/kdebase)	(revision 752071)
+@@ -213,6 +213,7 @@
+ 	curUser = user;
+ 	loginEdit->setText( user );
+ 	passwdEdit->setFocus();
++	passwdEdit->selectAll();
+ }
+ 
+ void // virtual
+--- kdmlib/dmctl.cpp	(.../tags/KDE/3.5.8/kdebase)	(revision 752071)
++++ kdmlib/dmctl.cpp	(.../branches/KDE/3.5/kdebase)	(revision 752071)
+@@ -65,21 +65,28 @@
+ 		if ((fd = ::socket( PF_UNIX, SOCK_STREAM, 0 )) < 0)
+ 			return;
+ 		sa.sun_family = AF_UNIX;
+-		if (DMType == GDM)
+-			strcpy( sa.sun_path, "/tmp/.gdm_socket" );
+-		else {
++		if (DMType == GDM) {
++			strcpy( sa.sun_path, "/var/run/gdm_socket" );
++			if (::connect( fd, (struct sockaddr *)&sa, sizeof(sa) )) {
++				strcpy( sa.sun_path, "/tmp/.gdm_socket" );
++				if (::connect( fd, (struct sockaddr *)&sa, sizeof(sa) )) {
++					::close( fd );
++					fd = -1;
++					break;
++				}
++			}
++			GDMAuthenticate();
++		} else {
+ 			if ((ptr = strchr( dpy, ':' )))
+ 				ptr = strchr( ptr, '.' );
+ 			snprintf( sa.sun_path, sizeof(sa.sun_path),
+ 			          "%s/dmctl-%.*s/socket",
+-			          ctl, ptr ? ptr - dpy : 512, dpy );
++			          ctl, ptr ? int(ptr - dpy) : 512, dpy );
++			if (::connect( fd, (struct sockaddr *)&sa, sizeof(sa) )) {
++				::close( fd );
++				fd = -1;
++			}
+ 		}
+-		if (::connect( fd, (struct sockaddr *)&sa, sizeof(sa) )) {
+-			::close( fd );
+-			fd = -1;
+-		}
+-		if (DMType == GDM)
+-			GDMAuthenticate();
+ 		break;
+ 	case OldKDM:
+ 		{
+--- kdmlib/kgreet_winbind.cpp	(.../tags/KDE/3.5.8/kdebase)	(revision 752071)
++++ kdmlib/kgreet_winbind.cpp	(.../branches/KDE/3.5/kdebase)	(revision 752071)
+@@ -293,6 +293,7 @@
+ 	slotChangedDomain( dom );
+ 	loginEdit->setText( usr );
+ 	passwdEdit->setFocus();
++	passwdEdit->selectAll();
+ }
+ 
+ void // virtual
+--- kdm/backend/client.c	(.../tags/KDE/3.5.8/kdebase)	(revision 752071)
++++ kdm/backend/client.c	(.../branches/KDE/3.5/kdebase)	(revision 752071)
+@@ -1623,6 +1623,8 @@
+ 	int pretc;
+ #endif
+ 
++	Signal( SIGTERM, SIG_IGN );
++
+ 	if (removeAuth) {
+ 		if (source( systemEnviron, td->reset, td_setup ))
+ 			LogError( "Cannot execute reset script %\"s\n", td->reset );
+--- kdm/backend/inifile.c	(.../tags/KDE/3.5.8/kdebase)	(revision 752071)
++++ kdm/backend/inifile.c	(.../branches/KDE/3.5/kdebase)	(revision 752071)
+@@ -37,6 +37,7 @@
+ #include "dm_error.h"
+ 
+ #include <sys/types.h>
++#include <sys/stat.h>
+ #include <unistd.h>
+ #include <stdlib.h>
+ #include <string.h>
+@@ -47,17 +48,27 @@
+ {
+ 	char *data;
+ 	int fd, len;
++	struct stat st;
+ 
+ 	if ((fd = open( fname, O_RDONLY | O_NONBLOCK )) < 0) {
+ 		Debug( "cannot open ini-file %\"s: %m", fname );
+ 		return 0;
+ 	}
+-	len = lseek( fd, 0, SEEK_END );
++	if (fstat( fd, &st ) || !S_ISREG( st.st_mode )) {
++		LogWarn( "Ini-file %\"s is no regular file\n", fname );
++		close( fd );
++		return 0;
++	}
++	if (st.st_size >= 0x10000) {
++		LogWarn( "Ini-file %\"s is too big\n", fname );
++		close( fd );
++		return 0;
++	}
++	len = st.st_size;
+ 	if (!(data = Malloc( len + 2 ))) {
+ 		close( fd );
+ 		return 0;
+ 	}
+-	lseek( fd, 0, SEEK_SET );
+ 	if (read( fd, data, len ) != len) {
+ 		Debug( "cannot read ini-file %\"s: %m", fname );
+ 		free( data );
+--- kdm/backend/session.c	(.../tags/KDE/3.5.8/kdebase)	(revision 752071)
++++ kdm/backend/session.c	(.../branches/KDE/3.5/kdebase)	(revision 752071)
+@@ -145,7 +145,10 @@
+ 		ReStr( &curtype, "classic" );
+ 		cursource = (td->hstent->rLogin == 1) ? PWSRC_RELOGIN : PWSRC_MANUAL;
+ 		return 1;
+-	} else if (*td->autoUser && !td->autoDelay && (tdiff > 0 || td->autoAgain))
++	} else if (*td->autoUser && !td->autoDelay &&
++	           ((tdiff > 0 && ((td->displayType & d_lifetime) == dTransient ||
++	                           !td->hstent->lastExit)) ||
++	            td->autoAgain))
+ 	{
+ 		unsigned int lmask;
+ 		Window dummy1, dummy2;
+@@ -487,6 +490,7 @@
+ static void
+ catchTerm( int n ATTR_UNUSED )
+ {
++	Signal( SIGTERM, SIG_IGN );
+ 	Longjmp( abortSession, EX_AL_RESERVER_DPY );
+ }
+ 
+--- kdm/kfrontend/kdm_config.c	(.../tags/KDE/3.5.8/kdebase)	(revision 752071)
++++ kdm/kfrontend/kdm_config.c	(.../branches/KDE/3.5/kdebase)	(revision 752071)
+@@ -1072,6 +1072,9 @@
+ 		if (!((**hostPtr)->entry.displayAddress.hostAddress =
+ 		      Malloc( addr_len )))
+ 		{
++#if defined(IPv6) && defined(AF_INET6)
++			freeaddrinfo( ai );
++#endif
+ 			free( (char *)(**hostPtr) );
+ 			return 0;
+ 		}
+@@ -1165,7 +1168,7 @@
+ 					         h->entry.aliasPattern );
+ 			}
+ 		} else if (h->type == HOST_PATTERN && (flags & CHECK_NO_PAT))
+-			LogWarn( "XDMCP ACL: wildcarded pattern %'* in host-only context\n",
++			LogWarn( "XDMCP ACL: wildcarded pattern %'s in host-only context\n",
+ 			         h->entry.hostPattern );
+ 	return 0;
+ }
+@@ -1453,7 +1456,7 @@
+ 				break;
+ #endif
+ 			default:
+-				Debug( "Unsupported config cathegory %#x\n", what );
++				Debug( "Unsupported config category %#x\n", what );
+ 			}
+ 			free( cfgfile );
+ 			break;
+--- kdm/kfrontend/kgreeter.cpp	(.../tags/KDE/3.5.8/kdebase)	(revision 752071)
++++ kdm/kfrontend/kgreeter.cpp	(.../branches/KDE/3.5/kdebase)	(revision 752071)
+@@ -42,6 +42,8 @@
+ #undef Unsorted // x headers suck - make qdir.h work with --enable-final
+ #include <qdir.h>
+ #include <qfile.h>
++#include <qbuffer.h>
++#include <qmemarray.h>
+ #include <qimage.h>
+ #include <qmovie.h>
+ #include <qpopupmenu.h>
+@@ -59,6 +61,7 @@
+ #include <grp.h>
+ #include <stdlib.h>
+ #include <unistd.h>
++#include <fcntl.h>
+ #include <sys/types.h>
+ 
+ #include <X11/Xlib.h>
+@@ -163,6 +166,9 @@
+ 	QString login;
+ };
+ 
++#define FILE_LIMIT_ICON 20
++#define FILE_LIMIT_IMAGE 200
++
+ void
+ KGreeter::insertUser( const QImage &default_pix,
+                       const QString &username, struct passwd *ps )
+@@ -181,16 +187,44 @@
+ 		nd = 1;
+ 	QImage p;
+ 	do {
+-		QString fn = dp ?
+-		             QFile::decodeName( ps->pw_dir ) + "/.face" :
+-		             _faceDir + '/' + username + ".face";
+-		if (p.load( fn + ".icon" ) || p.load( fn )) {
+-			QSize ns( 48, 48 );
+-			if (p.size() != ns)
+-				p = p.convertDepth( 32 ).smoothScale( ns, QImage::ScaleMin );
+-			goto gotit;
++		dp ^= 1;
++		QCString fn = !dp ?
++		              QCString( ps->pw_dir ) + '/' :
++		              QFile::encodeName( _faceDir + '/' + username );
++		fn += ".face.icon";
++		int fd, ico;
++		if ((fd = open( fn.data(), O_RDONLY | O_NONBLOCK )) < 0) {
++			fn.truncate( fn.length() - 5 );
++			if ((fd = open( fn.data(), O_RDONLY | O_NONBLOCK )) < 0)
++				continue;
++			ico = 0;
++		} else
++			ico = 1;
++		QFile f;
++		f.open( IO_ReadOnly, fd );
++		int fs = f.size();
++		if (fs > (ico ? FILE_LIMIT_ICON : FILE_LIMIT_IMAGE) * 1000) {
++			LogWarn( "%s exceeds file size limit (%dkB)\n",
++			         fn.data(), ico ? FILE_LIMIT_ICON : FILE_LIMIT_IMAGE );
++			continue;
+ 		}
+-		dp = 1 - dp;
++		QByteArray fc( fs );
++		int rfs = f.readBlock( fc.data(), fs );
++		::close( fd );
++		fc.resize( rfs > 0 ? rfs : 0 );
++		QBuffer buf( fc );
++		buf.open( IO_ReadOnly );
++		QImageIO ir;
++		ir.setIODevice( &buf );
++		if (!ir.read()) {
++			LogInfo( "%s is no valid image\n", fn.data() );
++			continue;
++		}
++		p = ir.image();
++		QSize ns( 48, 48 );
++		if (p.size() != ns)
++			p = p.convertDepth( 32 ).smoothScale( ns, QImage::ScaleMin );
++		goto gotit;
+ 	} while (--nd >= 0);
+ 	p = default_pix;
+   gotit:
+--- kdm/kfrontend/genkdmconf.c	(.../tags/KDE/3.5.8/kdebase)	(revision 752071)
++++ kdm/kfrontend/genkdmconf.c	(.../branches/KDE/3.5/kdebase)	(revision 752071)
+@@ -673,7 +673,7 @@
+ "    xsess_tmp=";
+ static const char def_session2[] =
+ "\n"
+-"    $SHELL -c \"if (-f /etc/csh.login) source /etc/csh.login; if (-f ~/.login) source ~/.login; /bin/sh -c export >! $xsess_tmp\"\n"
++"    $SHELL -c \"if (-f /etc/csh.login) source /etc/csh.login; if (-f ~/.login) source ~/.login; /bin/sh -c export -p >! $xsess_tmp\"\n"
+ "    . $xsess_tmp\n"
+ "    rm -f $xsess_tmp\n"
+ "    ;;\n"

Copied: trunk/packages/kdebase/debian/patches/03_nsplugins_branch_r754402.diff (from rev 8828, trunk/packages/kdebase/debian/patches/01_nsplugins_branch_r754402.diff)
===================================================================
--- trunk/packages/kdebase/debian/patches/03_nsplugins_branch_r754402.diff	                        (rev 0)
+++ trunk/packages/kdebase/debian/patches/03_nsplugins_branch_r754402.diff	2008-01-08 19:36:17 UTC (rev 8829)
@@ -0,0 +1,1922 @@
+#DPATCHLEVEL=0
+--- nsplugins/sdk/prcpucfg.h	(.../tags/KDE/3.5.8/kdebase)	(revision 754402)
++++ nsplugins/sdk/prcpucfg.h	(.../branches/KDE/3.5/kdebase)	(revision 754402)
+@@ -276,7 +276,7 @@
+ #define PR_BYTES_PER_WORD_LOG2   2
+ #define PR_BYTES_PER_DWORD_LOG2  3
+ 
+-#elif defined(__sparc__)
++#elif defined(__sparc__) || (defined(__SUNPRO_CC) && defined(__sparc))
+ 
+ #undef	IS_LITTLE_ENDIAN
+ #define	IS_BIG_ENDIAN 1
+@@ -321,7 +321,7 @@
+ #define PR_BYTES_PER_WORD_LOG2   2
+ #define PR_BYTES_PER_DWORD_LOG2  3
+ 
+-#elif defined(__i386__)
++#elif defined(__i386__) || (defined(__SUNPRO_CC) && defined(__i386))
+ 
+ #define IS_LITTLE_ENDIAN 1
+ #undef  IS_BIG_ENDIAN
+--- nsplugins/sdk/jni_md.h	(.../tags/KDE/3.5.8/kdebase)	(revision 754402)
++++ nsplugins/sdk/jni_md.h	(.../branches/KDE/3.5/kdebase)	(revision 754402)
+@@ -1,25 +1,42 @@
+ /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+  *
+- * The contents of this file are subject to the Netscape Public
+- * License Version 1.1 (the "License"); you may not use this file
+- * except in compliance with the License. You may obtain a copy of
+- * the License at http://www.mozilla.org/NPL/
++ * ***** BEGIN LICENSE BLOCK *****
++ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+  *
+- * Software distributed under the License is distributed on an "AS
+- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+- * implied. See the License for the specific language governing
+- * rights and limitations under the License.
++ * The contents of this file are subject to the Mozilla Public License Version
++ * 1.1 (the "License"); you may not use this file except in compliance with
++ * the License. You may obtain a copy of the License at
++ * http://www.mozilla.org/MPL/
+  *
++ * Software distributed under the License is distributed on an "AS IS" basis,
++ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
++ * for the specific language governing rights and limitations under the
++ * License.
++ *
+  * The Original Code is mozilla.org code.
+  *
+- * The Initial Developer of the Original Code is Netscape
+- * Communications Corporation.  Portions created by Netscape are
+- * Copyright (C) 1998 Netscape Communications Corporation. All
+- * Rights Reserved.
++ * The Initial Developer of the Original Code is
++ * Netscape Communications Corporation.
++ * Portions created by the Initial Developer are Copyright (C) 1998
++ * the Initial Developer. All Rights Reserved.
+  *
+- * Contributor(s): 
++ * Contributor(s):
+  *
++ * Alternatively, the contents of this file may be used under the terms of
++ * either the GNU General Public License Version 2 or later (the "GPL"), or
++ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
++ * in which case the provisions of the GPL or the LGPL are applicable instead
++ * of those above. If you wish to allow use of your version of this file only
++ * under the terms of either the GPL or the LGPL, and not to allow others to
++ * use your version of this file under the terms of the MPL, indicate your
++ * decision by deleting the provisions above and replace them with the notice
++ * and other provisions required by the GPL or the LGPL. If you do not delete
++ * the provisions above, a recipient may use your version of this file under
++ * the terms of any one of the MPL, the GPL or the LGPL.
+  *
++ * ***** END LICENSE BLOCK *****
++ *
++ *
+  * This Original Code has been modified by IBM Corporation.
+  * Modifications made by IBM described herein are
+  * Copyright (c) International Business Machines
+--- nsplugins/sdk/npruntime.h	(.../tags/KDE/3.5.8/kdebase)	(revision 0)
++++ nsplugins/sdk/npruntime.h	(.../branches/KDE/3.5/kdebase)	(revision 754402)
+@@ -0,0 +1,399 @@
++/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
++/*
++ * Copyright � 2004, Apple Computer, Inc. and The Mozilla Foundation. 
++ * All rights reserved.
++ * 
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions are
++ * met:
++ * 
++ * 1. Redistributions of source code must retain the above copyright
++ * notice, this list of conditions and the following disclaimer.
++ * 2. Redistributions in binary form must reproduce the above copyright
++ * notice, this list of conditions and the following disclaimer in the
++ * documentation and/or other materials provided with the distribution.
++ * 3. Neither the names of Apple Computer, Inc. ("Apple") or The Mozilla
++ * Foundation ("Mozilla") nor the names of their contributors may be used
++ * to endorse or promote products derived from this software without
++ * specific prior written permission.
++ * 
++ * THIS SOFTWARE IS PROVIDED BY APPLE, MOZILLA AND THEIR CONTRIBUTORS "AS
++ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
++ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
++ * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE, MOZILLA OR
++ * THEIR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
++ * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
++ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
++ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
++ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
++ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
++ *
++ * Revision 1 (March 4, 2004):
++ * Initial proposal.
++ *
++ * Revision 2 (March 10, 2004):
++ * All calls into script were made asynchronous.  Results are
++ * provided via the NPScriptResultFunctionPtr callback.
++ *
++ * Revision 3 (March 10, 2004):
++ * Corrected comments to not refer to class retain/release FunctionPtrs.
++ *
++ * Revision 4 (March 11, 2004):
++ * Added additional convenience NPN_SetExceptionWithUTF8().
++ * Changed NPHasPropertyFunctionPtr and NPHasMethodFunctionPtr to take NPClass
++ * pointers instead of NPObject pointers.
++ * Added NPIsValidIdentifier().
++ *
++ * Revision 5 (March 17, 2004):
++ * Added context parameter to result callbacks from ScriptObject functions.
++ *
++ * Revision 6 (March 29, 2004):
++ * Renamed functions implemented by user agent to NPN_*.  Removed _ from
++ * type names.
++ * Renamed "JavaScript" types to "Script".
++ *
++ * Revision 7 (April 21, 2004):
++ * NPIdentifier becomes a void*, was int32_t
++ * Remove NP_IsValidIdentifier, renamed NP_IdentifierFromUTF8 to NP_GetIdentifier
++ * Added NPVariant and modified functions to use this new type.
++ *
++ * Revision 8 (July 9, 2004):
++ * Updated to joint Apple-Mozilla license.
++ *
++ */
++#ifndef _NP_RUNTIME_H_
++#define _NP_RUNTIME_H_
++
++#include <qglobal.h>
++typedef Q_UINT32 uint32_t;
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++
++/*
++    This API is used to facilitate binding code written in C to script
++    objects.  The API in this header does not assume the presence of a
++    user agent.  That is, it can be used to bind C code to scripting
++    environments outside of the context of a user agent.
++    
++    However, the normal use of the this API is in the context of a
++    scripting environment running in a browser or other user agent.
++    In particular it is used to support the extended Netscape
++    script-ability API for plugins (NP-SAP).  NP-SAP is an extension
++    of the Netscape plugin API.  As such we have adopted the use of
++    the "NP" prefix for this API.
++
++    The following NP{N|P}Variables were added to the Netscape plugin
++    API (in npapi.h):
++
++    NPNVWindowNPObject
++    NPNVPluginElementNPObject
++    NPPVpluginScriptableNPObject
++
++    These variables are exposed through NPN_GetValue() and
++    NPP_GetValue() (respectively) and are used to establish the
++    initial binding between the user agent and native code.  The DOM
++    objects in the user agent can be examined and manipulated using
++    the NPN_ functions that operate on NPObjects described in this
++    header.
++
++    To the extent possible the assumptions about the scripting
++    language used by the scripting environment have been minimized.
++*/
++
++#define NP_BEGIN_MACRO  do {
++#define NP_END_MACRO    } while (0)
++
++/*
++    Objects (non-primitive data) passed between 'C' and script is
++    always wrapped in an NPObject.  The 'interface' of an NPObject is
++    described by an NPClass.
++*/
++typedef struct NPObject NPObject;
++typedef struct NPClass NPClass;
++
++typedef char NPUTF8;
++typedef struct _NPString {
++    const NPUTF8 *utf8characters;
++    uint32_t utf8length;
++} NPString;
++
++typedef enum {
++    NPVariantType_Void,
++    NPVariantType_Null,
++    NPVariantType_Bool,
++    NPVariantType_Int32,
++    NPVariantType_Double,
++    NPVariantType_String,
++    NPVariantType_Object
++} NPVariantType;
++
++typedef struct _NPVariant {
++    NPVariantType type;
++    union {
++        bool boolValue;
++        uint32_t intValue;
++        double doubleValue;
++        NPString stringValue;
++        NPObject *objectValue;
++    } value;
++} NPVariant;
++
++/*
++    NPN_ReleaseVariantValue is called on all 'out' parameters
++    references.  Specifically it is to be called on variants that own
++    their value, as is the case with all non-const NPVariant*
++    arguments after a successful call to any methods (except this one)
++    in this API.
++
++    After calling NPN_ReleaseVariantValue, the type of the variant
++    will be NPVariantType_Void.
++*/
++void NPN_ReleaseVariantValue(NPVariant *variant);
++
++#define NPVARIANT_IS_VOID(_v)    ((_v).type == NPVariantType_Void)
++#define NPVARIANT_IS_NULL(_v)    ((_v).type == NPVariantType_Null)
++#define NPVARIANT_IS_BOOLEAN(_v) ((_v).type == NPVariantType_Bool)
++#define NPVARIANT_IS_INT32(_v)   ((_v).type == NPVariantType_Int32)
++#define NPVARIANT_IS_DOUBLE(_v)  ((_v).type == NPVariantType_Double)
++#define NPVARIANT_IS_STRING(_v)  ((_v).type == NPVariantType_String)
++#define NPVARIANT_IS_OBJECT(_v)  ((_v).type == NPVariantType_Object)
++
++#define NPVARIANT_TO_BOOLEAN(_v) ((_v).value.boolValue)
++#define NPVARIANT_TO_INT32(_v)   ((_v).value.intValue)
++#define NPVARIANT_TO_DOUBLE(_v)  ((_v).value.doubleValue)
++#define NPVARIANT_TO_STRING(_v)  ((_v).value.stringValue)
++#define NPVARIANT_TO_OBJECT(_v)  ((_v).value.objectValue)
++
++#define VOID_TO_NPVARIANT(_v)                                                 \
++NP_BEGIN_MACRO                                                                \
++    (_v).type = NPVariantType_Void;                                           \
++    (_v).value.objectValue = NULL;                                            \
++NP_END_MACRO
++
++#define NULL_TO_NPVARIANT(_v)                                                 \
++NP_BEGIN_MACRO                                                                \
++    (_v).type = NPVariantType_Null;                                           \
++    (_v).value.objectValue = NULL;                                            \
++NP_END_MACRO
++
++#define BOOLEAN_TO_NPVARIANT(_val, _v)                                        \
++NP_BEGIN_MACRO                                                                \
++    (_v).type = NPVariantType_Bool;                                           \
++    (_v).value.boolValue = !!(_val);                                          \
++NP_END_MACRO
++
++#define INT32_TO_NPVARIANT(_val, _v)                                          \
++NP_BEGIN_MACRO                                                                \
++    (_v).type = NPVariantType_Int32;                                          \
++    (_v).value.intValue = _val;                                               \
++NP_END_MACRO
++
++#define DOUBLE_TO_NPVARIANT(_val, _v)                                         \
++NP_BEGIN_MACRO                                                                \
++    (_v).type = NPVariantType_Double;                                         \
++    (_v).value.doubleValue = _val;                                            \
++NP_END_MACRO
++
++#define STRINGZ_TO_NPVARIANT(_val, _v)                                        \
++NP_BEGIN_MACRO                                                                \
++    (_v).type = NPVariantType_String;                                         \
++    NPString str = { _val, strlen(_val) };                                    \
++    (_v).value.stringValue = str;                                             \
++NP_END_MACRO
++
++#define STRINGN_TO_NPVARIANT(_val, _len, _v)                                  \
++NP_BEGIN_MACRO                                                                \
++    (_v).type = NPVariantType_String;                                         \
++    NPString str = { _val, _len };                                            \
++    (_v).value.stringValue = str;                                             \
++NP_END_MACRO
++
++#define OBJECT_TO_NPVARIANT(_val, _v)                                         \
++NP_BEGIN_MACRO                                                                \
++    (_v).type = NPVariantType_Object;                                         \
++    (_v).value.objectValue = _val;                                            \
++NP_END_MACRO
++
++
++/*
++	Type mappings (JavaScript types have been used for illustration
++    purposes):
++
++	JavaScript       to             C (NPVariant with type:)
++	undefined                       NPVariantType_Void
++	null                            NPVariantType_Null
++	Boolean                         NPVariantType_Bool
++	Number                          NPVariantType_Double or NPVariantType_Int32
++	String                          NPVariantType_String
++	Object                          NPVariantType_Object
++
++	C (NPVariant with type:)   to   JavaScript
++	NPVariantType_Void              undefined
++	NPVariantType_Null              null
++	NPVariantType_Bool              Boolean	
++	NPVariantType_Int32             Number
++	NPVariantType_Double            Number
++	NPVariantType_String            String
++	NPVariantType_Object            Object
++*/
++
++typedef void *NPIdentifier;
++
++/*
++    NPObjects have methods and properties.  Methods and properties are
++    identified with NPIdentifiers.  These identifiers may be reflected
++    in script.  NPIdentifiers can be either strings or integers, IOW,
++    methods and properties can be identified by either strings or
++    integers (i.e. foo["bar"] vs foo[1]). NPIdentifiers can be
++    compared using ==.  In case of any errors, the requested
++    NPIdentifier(s) will be NULL.
++*/
++NPIdentifier NPN_GetStringIdentifier(const NPUTF8 *name);
++void NPN_GetStringIdentifiers(const NPUTF8 **names, int32_t nameCount,
++                              NPIdentifier *identifiers);
++NPIdentifier NPN_GetIntIdentifier(int32_t intid);
++bool NPN_IdentifierIsString(NPIdentifier identifier);
++
++/*
++    The NPUTF8 returned from NPN_UTF8FromIdentifier SHOULD be freed.
++*/
++NPUTF8 *NPN_UTF8FromIdentifier(NPIdentifier identifier);
++
++/*
++    Get the integer represented by identifier. If identifier is not an
++    integer identifier, the behaviour is undefined.
++*/
++int32_t NPN_IntFromIdentifier(NPIdentifier identifier);
++
++/*
++    NPObject behavior is implemented using the following set of
++    callback functions.
++
++    The NPVariant *result argument of these functions (where
++    applicable) should be released using NPN_ReleaseVariantValue().
++*/
++typedef NPObject *(*NPAllocateFunctionPtr)(NPP npp, NPClass *aClass);
++typedef void (*NPDeallocateFunctionPtr)(NPObject *npobj);
++typedef void (*NPInvalidateFunctionPtr)(NPObject *npobj);
++typedef bool (*NPHasMethodFunctionPtr)(NPObject *npobj, NPIdentifier name);
++typedef bool (*NPInvokeFunctionPtr)(NPObject *npobj, NPIdentifier name,
++                                    const NPVariant *args, uint32_t argCount,
++                                    NPVariant *result);
++typedef bool (*NPInvokeDefaultFunctionPtr)(NPObject *npobj,
++                                           const NPVariant *args,
++                                           uint32_t argCount,
++                                           NPVariant *result);
++typedef bool (*NPHasPropertyFunctionPtr)(NPObject *npobj, NPIdentifier name);
++typedef bool (*NPGetPropertyFunctionPtr)(NPObject *npobj, NPIdentifier name,
++                                         NPVariant *result);
++typedef bool (*NPSetPropertyFunctionPtr)(NPObject *npobj, NPIdentifier name,
++                                         const NPVariant *value);
++typedef bool (*NPRemovePropertyFunctionPtr)(NPObject *npobj,
++                                            NPIdentifier name);
++
++/*
++    NPObjects returned by create, retain, invoke, and getProperty pass
++    a reference count to the caller.  That is, the callee adds a
++    reference count which passes to the caller.  It is the caller's
++    responsibility to release the returned object.
++
++    NPInvokeFunctionPtr function may return 0 to indicate a void
++    result.
++
++    NPInvalidateFunctionPtr is called by the scripting environment
++    when the native code is shutdown.  Any attempt to message a
++    NPObject instance after the invalidate callback has been
++    called will result in undefined behavior, even if the native code
++    is still retaining those NPObject instances.  (The runtime
++    will typically return immediately, with 0 or NULL, from an attempt
++    to dispatch to a NPObject, but this behavior should not be
++    depended upon.)
++*/
++struct NPClass
++{
++    uint32_t structVersion;
++    NPAllocateFunctionPtr allocate;
++    NPDeallocateFunctionPtr deallocate;
++    NPInvalidateFunctionPtr invalidate;
++    NPHasMethodFunctionPtr hasMethod;
++    NPInvokeFunctionPtr invoke;
++    NPInvokeDefaultFunctionPtr invokeDefault;
++    NPHasPropertyFunctionPtr hasProperty;
++    NPGetPropertyFunctionPtr getProperty;
++    NPSetPropertyFunctionPtr setProperty;
++    NPRemovePropertyFunctionPtr removeProperty;
++};
++
++#define NP_CLASS_STRUCT_VERSION 1
++
++struct NPObject {
++    NPClass *_class;
++    uint32_t referenceCount;
++    /*
++     * Additional space may be allocated here by types of NPObjects
++     */
++};
++
++/*
++    If the class has an allocate function, NPN_CreateObject invokes
++    that function, otherwise a NPObject is allocated and
++    returned. This method will initialize the referenceCount member of
++    the NPObject to 1.
++*/
++NPObject *NPN_CreateObject(NPP npp, NPClass *aClass);
++
++/*
++    Increment the NPObject's reference count.
++*/
++NPObject *NPN_RetainObject(NPObject *npobj);
++
++/*
++    Decremented the NPObject's reference count.  If the reference
++    count goes to zero, the class's destroy function is invoke if
++    specified, otherwise the object is freed directly.
++*/
++void NPN_ReleaseObject(NPObject *npobj);
++
++/*
++    Functions to access script objects represented by NPObject.
++
++    Calls to script objects are synchronous.  If a function returns a
++    value, it will be supplied via the result NPVariant
++    argument. Successful calls will return true, false will be
++    returned in case of an error.
++    
++    Calls made from plugin code to script must be made from the thread
++    on which the plugin was initialized.
++*/
++
++bool NPN_Invoke(NPP npp, NPObject *npobj, NPIdentifier methodName,
++                const NPVariant *args, uint32_t argCount, NPVariant *result);
++bool NPN_InvokeDefault(NPP npp, NPObject *npobj, const NPVariant *args,
++                       uint32_t argCount, NPVariant *result);
++bool NPN_Evaluate(NPP npp, NPObject *npobj, NPString *script,
++                  NPVariant *result);
++bool NPN_GetProperty(NPP npp, NPObject *npobj, NPIdentifier propertyName,
++                     NPVariant *result);
++bool NPN_SetProperty(NPP npp, NPObject *npobj, NPIdentifier propertyName,
++                     const NPVariant *value);
++bool NPN_RemoveProperty(NPP npp, NPObject *npobj, NPIdentifier propertyName);
++bool NPN_HasProperty(NPP npp, NPObject *npobj, NPIdentifier propertyName);
++bool NPN_HasMethod(NPP npp, NPObject *npobj, NPIdentifier methodName);
++
++/*
++    NPN_SetException may be called to trigger a script exception upon
++    return from entry points into NPObjects.  Typical usage:
++
++    NPN_SetException (npobj, message);
++*/
++void NPN_SetException(NPObject *npobj, const NPUTF8 *message);
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif
+--- nsplugins/sdk/npupp.h	(.../tags/KDE/3.5.8/kdebase)	(revision 754402)
++++ nsplugins/sdk/npupp.h	(.../branches/KDE/3.5/kdebase)	(revision 754402)
+@@ -1,11 +1,11 @@
+-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
++/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+ /* ***** BEGIN LICENSE BLOCK *****
+- * Version: NPL 1.1/GPL 2.0/LGPL 2.1
++ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+  *
+- * The contents of this file are subject to the Netscape Public License
+- * Version 1.1 (the "License"); you may not use this file except in
+- * compliance with the License. You may obtain a copy of the License at
+- * http://www.mozilla.org/NPL/
++ * The contents of this file are subject to the Mozilla Public License Version
++ * 1.1 (the "License"); you may not use this file except in compliance with
++ * the License. You may obtain a copy of the License at
++ * http://www.mozilla.org/MPL/
+  *
+  * Software distributed under the License is distributed on an "AS IS" basis,
+  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+@@ -14,31 +14,30 @@
+  *
+  * The Original Code is mozilla.org code.
+  *
+- * The Initial Developer of the Original Code is 
++ * The Initial Developer of the Original Code is
+  * Netscape Communications Corporation.
+  * Portions created by the Initial Developer are Copyright (C) 1998
+  * the Initial Developer. All Rights Reserved.
+  *
+  * Contributor(s):
+  *
+- *
+  * Alternatively, the contents of this file may be used under the terms of
+  * either the GNU General Public License Version 2 or later (the "GPL"), or
+  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+  * in which case the provisions of the GPL or the LGPL are applicable instead
+  * of those above. If you wish to allow use of your version of this file only
+  * under the terms of either the GPL or the LGPL, and not to allow others to
+- * use your version of this file under the terms of the NPL, indicate your
++ * use your version of this file under the terms of the MPL, indicate your
+  * decision by deleting the provisions above and replace them with the notice
+  * and other provisions required by the GPL or the LGPL. If you do not delete
+  * the provisions above, a recipient may use your version of this file under
+- * the terms of any one of the NPL, the GPL or the LGPL.
++ * the terms of any one of the MPL, the GPL or the LGPL.
+  *
+  * ***** END LICENSE BLOCK ***** */
+ 
+ 
+ /*
+- *  npupp.h $Revision: 665076 $
++ *  npupp.h
+  *  function call mecahnics needed by platform specific glue code.
+  */
+ 
+@@ -58,6 +57,8 @@
+ #include "npapi.h"
+ #endif
+ 
++#include "npruntime.h"
++
+ #include "jri.h"
+ 
+ /******************************************************************************************
+@@ -72,7 +73,6 @@
+ 
+ /* NPP_Initialize */
+ 
+-/*#define _NPUPP_USE_UPP_ (TARGET_RT_MAC_CFM && !TARGET_API_MAC_CARBON)*/
+ #define _NPUPP_USE_UPP_ 0
+ 
+ #if _NPUPP_USE_UPP_
+@@ -488,8 +488,6 @@
+ #endif
+ 
+ 
+-
+-
+ /*
+  *  Netscape entry points
+  */
+@@ -1063,6 +1061,584 @@
+ 
+ #endif
+ 
++/* NPN_GetStringIdentifier */
++
++#if _NPUPP_USE_UPP_
++
++typedef UniversalProcPtr NPN_GetStringIdentifierUPP;
++enum {
++	uppNPN_GetStringIdentifierProcInfo = kThinkCStackBased
++		| STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(const NPUTF8*)))
++		| RESULT_SIZE(SIZE_CODE(sizeof(NPIdentifier)))
++};
++
++#define NewNPN_GetStringIdentifierProc(FUNC)		\
++		(NPN_GetStringIdentifierUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetStringIdentifierProcInfo, GetCurrentArchitecture())
++#define CallNPN_GetStringIdentifierProc(FUNC, ARG1)		\
++		(jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetStringIdentifierProcInfo, (ARG1))	
++
++#else
++
++typedef NPIdentifier (* NP_LOADDS NPN_GetStringIdentifierUPP)(const NPUTF8* name);
++#define NewNPN_GetStringIdentifierProc(FUNC)		\
++		((NPN_GetStringIdentifierUPP) (FUNC))
++#define CallNPN_GetStringIdentifierProc(FUNC, ARG1)		\
++		(*(FUNC))((ARG1))
++
++#endif
++
++/* NPN_GetStringIdentifiers */
++
++#if _NPUPP_USE_UPP_
++
++typedef UniversalProcPtr NPN_GetStringIdentifiersUPP;
++enum {
++	uppNPN_GetStringIdentifiersProcInfo = kThinkCStackBased
++		| STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(const NPUTF8**)))
++		| STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(int32_t)))
++		| STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPIdentifier*)))
++        | RESULT_SIZE(SIZE_CODE(0))
++};
++
++#define NewNPN_GetStringIdentifiersProc(FUNC)		\
++		(NPN_GetStringIdentifiersUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetStringIdentifiersProcInfo, GetCurrentArchitecture())
++#define CallNPN_GetStringIdentifiersProc(FUNC, ARG1, ARG2, ARG3)		\
++		(jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetStringIdentifiersProcInfo, (ARG1), (ARG2), (ARG3))	
++
++#else
++
++typedef void (* NP_LOADDS NPN_GetStringIdentifiersUPP)(const NPUTF8** names,
++                                                 int32_t nameCount,
++                                                 NPIdentifier* identifiers);
++#define NewNPN_GetStringIdentifiersProc(FUNC)		\
++		((NPN_GetStringIdentifiersUPP) (FUNC))
++#define CallNPN_GetStringIdentifiersProc(FUNC, ARG1, ARG2, ARG3)		\
++		(*(FUNC))((ARG1), (ARG2), (ARG3))
++
++#endif
++
++/* NPN_GetIntIdentifier */
++
++#if _NPUPP_USE_UPP_
++
++typedef UniversalProcPtr NPN_GetIntIdentifierUPP;
++enum {
++	uppNPN_GetIntIdentifierProcInfo = kThinkCStackBased
++		| STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(int32_t)))
++		| RESULT_SIZE(SIZE_CODE(sizeof(NPIdentifier)))
++};
++
++#define NewNPN_GetIntIdentifierProc(FUNC)		\
++		(NPN_GetIntIdentifierUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetIntIdentifierProcInfo, GetCurrentArchitecture())
++#define CallNPN_GetIntIdentifierProc(FUNC, ARG1)		\
++		(jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetIntIdentifierProcInfo, (ARG1))	
++
++#else
++
++typedef NPIdentifier (* NP_LOADDS NPN_GetIntIdentifierUPP)(int32_t intid);
++#define NewNPN_GetIntIdentifierProc(FUNC)		\
++		((NPN_GetIntIdentifierUPP) (FUNC))
++#define CallNPN_GetIntIdentifierProc(FUNC, ARG1)		\
++		(*(FUNC))((ARG1))
++
++#endif
++
++/* NPN_IdentifierIsString */
++
++#if _NPUPP_USE_UPP_
++
++typedef UniversalProcPtr NPN_IdentifierIsStringUPP;
++enum {
++	uppNPN_IdentifierIsStringProcInfo = kThinkCStackBased
++		| STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPIdentifier identifier)))
++		| RESULT_SIZE(SIZE_CODE(sizeof(bool)))
++};
++
++#define NewNPN_IdentifierIsStringProc(FUNC)		\
++		(NPN_IdentifierIsStringUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_IdentifierIsStringProcInfo, GetCurrentArchitecture())
++#define CallNPN_IdentifierIsStringProc(FUNC, ARG1)		\
++		(jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_IdentifierIsStringProcInfo, (ARG1))	
++
++#else
++
++typedef bool (* NP_LOADDS NPN_IdentifierIsStringUPP)(NPIdentifier identifier);
++#define NewNPN_IdentifierIsStringProc(FUNC)		\
++		((NPN_IdentifierIsStringUPP) (FUNC))
++#define CallNPN_IdentifierIsStringProc(FUNC, ARG1)		\
++		(*(FUNC))((ARG1))
++
++#endif
++
++/* NPN_UTF8FromIdentifier */
++
++#if _NPUPP_USE_UPP_
++
++typedef UniversalProcPtr NPN_UTF8FromIdentifierUPP;
++enum {
++	uppNPN_UTF8FromIdentifierProcInfo = kThinkCStackBased
++		| STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPIdentifier)))
++		| RESULT_SIZE(SIZE_CODE(sizeof(NPUTF8*)))
++};
++
++#define NewNPN_UTF8FromIdentifierProc(FUNC)		\
++		(NPN_UTF8FromIdentifierUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_UTF8FromIdentifierProcInfo, GetCurrentArchitecture())
++#define CallNPN_UTF8FromIdentifierProc(FUNC, ARG1)		\
++		(jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_UTF8FromIdentifierProcInfo, (ARG1))	
++
++#else
++
++typedef NPUTF8* (* NP_LOADDS NPN_UTF8FromIdentifierUPP)(NPIdentifier identifier);
++#define NewNPN_UTF8FromIdentifierProc(FUNC)		\
++		((NPN_UTF8FromIdentifierUPP) (FUNC))
++#define CallNPN_UTF8FromIdentifierProc(FUNC, ARG1)		\
++		(*(FUNC))((ARG1))
++
++#endif
++
++/* NPN_IntFromIdentifier */
++
++#if _NPUPP_USE_UPP_
++
++typedef UniversalProcPtr NPN_IntFromIdentifierUPP;
++enum {
++	uppNPN_IntFromIdentifierProcInfo = kThinkCStackBased
++		| STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPIdentifier)))
++		| RESULT_SIZE(SIZE_CODE(sizeof(int32_t)))
++};
++
++#define NewNPN_IntFromIdentifierProc(FUNC)		\
++		(NPN_IntFromIdentifierUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_IntFromIdentifierProcInfo, GetCurrentArchitecture())
++#define CallNPN_IntFromIdentifierProc(FUNC, ARG1)		\
++		(jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_IntFromIdentifierProcInfo, (ARG1))	
++
++#else
++
++typedef int32_t (* NP_LOADDS NPN_IntFromIdentifierUPP)(NPIdentifier identifier);
++#define NewNPN_IntFromIdentifierProc(FUNC)		\
++		((NPN_IntFromIdentifierUPP) (FUNC))
++#define CallNPN_IntFromIdentifierProc(FUNC, ARG1)		\
++		(*(FUNC))((ARG1))
++
++#endif
++
++/* NPN_CreateObject */
++
++#if _NPUPP_USE_UPP_
++
++typedef UniversalProcPtr NPN_CreateObjectUPP;
++enum {
++	uppNPN_CreateObjectProcInfo = kThinkCStackBased
++		| STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
++		| STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPClass*)))
++		| RESULT_SIZE(SIZE_CODE(sizeof(NPObject*)))
++};
++
++#define NewNPN_CreateObjectProc(FUNC)		\
++		(NPN_CreateObjectUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_CreateObjectProcInfo, GetCurrentArchitecture())
++#define CallNPN_CreateObjectProc(FUNC, ARG1, ARG2)		\
++		(jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_CreateObjectProcInfo, (ARG1), (ARG2))	
++
++#else
++
++typedef NPObject* (* NP_LOADDS NPN_CreateObjectUPP)(NPP npp, NPClass *aClass);
++#define NewNPN_CreateObjectProc(FUNC)		\
++		((NPN_CreateObjectUPP) (FUNC))
++#define CallNPN_CreateObjectProc(FUNC, ARG1, ARG2)		\
++		(*(FUNC))((ARG1), (ARG2))
++
++#endif
++
++/* NPN_RetainObject */
++
++#if _NPUPP_USE_UPP_
++
++typedef UniversalProcPtr NPN_RetainObjectUPP;
++enum {
++	uppNPN_RetainObjectProcInfo = kThinkCStackBased
++		| STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPObject*)))
++		| RESULT_SIZE(SIZE_CODE(sizeof(NPObject*)))
++};
++
++#define NewNPN_RetainObjectProc(FUNC)		\
++		(NPN_RetainObjectUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_RetainObjectProcInfo, GetCurrentArchitecture())
++#define CallNPN_RetainObjectProc(FUNC, ARG1)		\
++		(jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_RetainObjectProcInfo, (ARG1))	
++
++#else
++
++typedef NPObject* (* NP_LOADDS NPN_RetainObjectUPP)(NPObject *obj);
++#define NewNPN_RetainObjectProc(FUNC)		\
++		((NPN_RetainObjectUPP) (FUNC))
++#define CallNPN_RetainObjectProc(FUNC, ARG1)		\
++		(*(FUNC))((ARG1))
++
++#endif
++
++/* NPN_ReleaseObject */
++
++#if _NPUPP_USE_UPP_
++
++typedef UniversalProcPtr NPN_ReleaseObjectUPP;
++enum {
++	uppNPN_ReleaseObjectProcInfo = kThinkCStackBased
++		| STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPObject*)))
++		| RESULT_SIZE(SIZE_CODE(0))
++};
++
++#define NewNPN_ReleaseObjectProc(FUNC)		\
++		(NPN_ReleaseObjectUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_ReleaseObjectProcInfo, GetCurrentArchitecture())
++#define CallNPN_ReleaseObjectProc(FUNC, ARG1)		\
++		(jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_ReleaseObjectProcInfo, (ARG1))
++
++#else
++
++typedef void (* NP_LOADDS NPN_ReleaseObjectUPP)(NPObject *obj);
++#define NewNPN_ReleaseObjectProc(FUNC)		\
++		((NPN_ReleaseObjectUPP) (FUNC))
++#define CallNPN_ReleaseObjectProc(FUNC, ARG1)		\
++		(*(FUNC))((ARG1))
++
++#endif
++
++/* NPN_Invoke */
++
++#if _NPUPP_USE_UPP_
++
++typedef UniversalProcPtr NPN_InvokeUPP;
++enum {
++	uppNPN_InvokeProcInfo = kThinkCStackBased
++		| STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
++		| STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPObject*)))
++		| STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPIdentifier)))
++		| STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(const NPVariant*)))
++		| STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(uint32_t)))
++		| STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(NPVariant*)))
++		| RESULT_SIZE(SIZE_CODE(sizeof(bool)))
++};
++
++#define NewNPN_InvokeProc(FUNC)		\
++		(NPN_InvokeUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_InvokeProcInfo, GetCurrentArchitecture())
++#define CallNPN_InvokeProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6)		\
++		(jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_InvokeProcInfo, (ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6))
++
++#else
++
++typedef bool (* NP_LOADDS NPN_InvokeUPP)(NPP npp, NPObject* obj, NPIdentifier methodName, const NPVariant *args, uint32_t argCount, NPVariant *result);
++#define NewNPN_InvokeProc(FUNC)		\
++		((NPN_InvokeUPP) (FUNC))
++#define CallNPN_InvokeProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6)		\
++		(*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6))
++
++#endif
++
++/* NPN_InvokeDefault */
++
++#if _NPUPP_USE_UPP_
++
++typedef UniversalProcPtr NPN_InvokeDefaultUPP;
++enum {
++	uppNPN_InvokeDefaultProcInfo = kThinkCStackBased
++		| STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
++		| STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPObject*)))
++		| STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(const NPVariant*)))
++		| STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(uint32_t)))
++		| STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(NPVariant*)))
++		| RESULT_SIZE(SIZE_CODE(sizeof(bool)))
++};
++
++#define NewNPN_InvokeDefaultProc(FUNC)		\
++		(NPN_InvokeDefaultUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_InvokeDefaultProcInfo, GetCurrentArchitecture())
++#define CallNPN_InvokeDefaultProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5)		\
++		(jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_InvokeDefaultProcInfo, (ARG1), (ARG2), (ARG3), (ARG4), (ARG5))
++
++#else
++
++typedef bool (* NP_LOADDS NPN_InvokeDefaultUPP)(NPP npp, NPObject* obj, const NPVariant *args, uint32_t argCount, NPVariant *result);
++#define NewNPN_InvokeDefaultProc(FUNC)		\
++		((NPN_InvokeDefaultUPP) (FUNC))
++#define CallNPN_InvokeDefaultProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5)		\
++		(*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4), (ARG5))
++
++#endif
++
++/* NPN_Evaluate */
++
++#if _NPUPP_USE_UPP_
++
++typedef UniversalProcPtr NPN_EvaluateUPP;
++enum {
++	uppNPN_EvaluateProcInfo = kThinkCStackBased
++		| STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
++		| STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPObject*)))
++		| STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPString*)))
++		| STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(NPVariant*)))
++		| RESULT_SIZE(SIZE_CODE(sizeof(bool)))
++};
++
++#define NewNPN_EvaluateProc(FUNC)		\
++		(NPN_EvaluateUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_EvaluateProcInfo, GetCurrentArchitecture())
++#define CallNPN_EvaluateProc(FUNC, ARG1, ARG2, ARG3, ARG4)		\
++		(jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_EvaluateProcInfo, (ARG1), (ARG2), (ARG3), (ARG4))
++
++#else
++
++typedef bool (* NP_LOADDS NPN_EvaluateUPP)(NPP npp, NPObject *obj, NPString *script, NPVariant *result);
++#define NewNPN_EvaluateProc(FUNC)		\
++		((NPN_EvaluateUPP) (FUNC))
++#define CallNPN_EvaluateProc(FUNC, ARG1, ARG2, ARG3, ARG4)		\
++		(*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4))
++
++#endif
++
++/* NPN_GetProperty */
++
++#if _NPUPP_USE_UPP_
++
++typedef UniversalProcPtr NPN_GetPropertyUPP;
++enum {
++	uppNPN_GetPropertyProcInfo = kThinkCStackBased
++		| STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
++		| STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPObject*)))
++		| STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPIdentifier)))
++		| STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(NPVariant*)))
++		| RESULT_SIZE(SIZE_CODE(sizeof(bool)))
++};
++
++#define NewNPN_GetPropertyProc(FUNC)		\
++		(NPN_GetPropertyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetPropertyProcInfo, GetCurrentArchitecture())
++#define CallNPN_GetPropertyProc(FUNC, ARG1, ARG2, ARG3, ARG4)		\
++		(jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetPropertyProcInfo, (ARG1), (ARG2), (ARG3), (ARG4))
++
++#else
++
++typedef bool (* NP_LOADDS NPN_GetPropertyUPP)(NPP npp, NPObject *obj, NPIdentifier propertyName, NPVariant *result);
++#define NewNPN_GetPropertyProc(FUNC)		\
++		((NPN_GetPropertyUPP) (FUNC))
++#define CallNPN_GetPropertyProc(FUNC, ARG1, ARG2, ARG3, ARG4)		\
++		(*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4))
++
++#endif
++
++/* NPN_SetProperty */
++
++#if _NPUPP_USE_UPP_
++
++typedef UniversalProcPtr NPN_SetPropertyUPP;
++enum {
++	uppNPN_SetPropertyProcInfo = kThinkCStackBased
++		| STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
++		| STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPObject*)))
++		| STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPIdentifier)))
++		| STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(const NPVariant*)))
++		| RESULT_SIZE(SIZE_CODE(sizeof(bool)))
++};
++
++#define NewNPN_SetPropertyProc(FUNC)		\
++		(NPN_SetPropertyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_SetPropertyProcInfo, GetCurrentArchitecture())
++#define CallNPN_SetPropertyProc(FUNC, ARG1, ARG2, ARG3, ARG4)		\
++		(jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_SetPropertyProcInfo, (ARG1), (ARG2), (ARG3), (ARG4))
++
++#else
++
++typedef bool (* NP_LOADDS NPN_SetPropertyUPP)(NPP npp, NPObject *obj, NPIdentifier propertyName, const NPVariant *value);
++#define NewNPN_SetPropertyProc(FUNC)		\
++		((NPN_SetPropertyUPP) (FUNC))
++#define CallNPN_SetPropertyProc(FUNC, ARG1, ARG2, ARG3, ARG4)		\
++		(*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4))
++
++#endif
++
++/* NPN_RemoveProperty */
++
++#if _NPUPP_USE_UPP_
++
++typedef UniversalProcPtr NPN_RemovePropertyUPP;
++enum {
++	uppNPN_RemovePropertyProcInfo = kThinkCStackBased
++		| STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
++		| STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPObject*)))
++		| STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPIdentifier)))
++		| RESULT_SIZE(SIZE_CODE(sizeof(bool)))
++};
++
++#define NewNPN_RemovePropertyProc(FUNC)		\
++		(NPN_RemovePropertyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_RemovePropertyProcInfo, GetCurrentArchitecture())
++#define CallNPN_RemovePropertyProc(FUNC, ARG1, ARG2, ARG3)		\
++		(jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_RemovePropertyProcInfo, (ARG1), (ARG2), (ARG3))
++
++#else
++
++typedef bool (* NP_LOADDS NPN_RemovePropertyUPP)(NPP npp, NPObject *obj, NPIdentifier propertyName);
++#define NewNPN_RemovePropertyProc(FUNC)		\
++		((NPN_RemovePropertyUPP) (FUNC))
++#define CallNPN_RemovePropertyProc(FUNC, ARG1, ARG2, ARG3)		\
++		(*(FUNC))((ARG1), (ARG2), (ARG3))
++
++#endif
++
++/* NPN_HasProperty */
++
++#if _NPUPP_USE_UPP_
++
++typedef UniversalProcPtr NPN_HasPropertyUPP;
++enum {
++	uppNPN_HasPropertyProcInfo = kThinkCStackBased
++		| STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
++		| STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPObject*)))
++		| STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPIdentifier)))
++		| RESULT_SIZE(SIZE_CODE(sizeof(bool)))
++};
++
++#define NewNPN_HasPropertyProc(FUNC)		\
++		(NPN_HasPropertyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_HasPropertyProcInfo, GetCurrentArchitecture())
++#define CallNPN_HasPropertyProc(FUNC, ARG1, ARG2, ARG3)		\
++		(jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_HasPropertyProcInfo, (ARG1), (ARG2), (ARG3))
++
++#else
++
++typedef bool (* NP_LOADDS NPN_HasPropertyUPP)(NPP npp, NPObject *obj, NPIdentifier propertyName);
++#define NewNPN_HasPropertyProc(FUNC)		\
++		((NPN_HasPropertyUPP) (FUNC))
++#define CallNPN_HasPropertyProc(FUNC, ARG1, ARG2, ARG3)		\
++		(*(FUNC))((ARG1), (ARG2), (ARG3))
++
++#endif
++
++/* NPN_HasMethod */
++
++#if _NPUPP_USE_UPP_
++
++typedef UniversalProcPtr NPN_HasMethodUPP;
++enum {
++	uppNPN_HasMethodProcInfo = kThinkCStackBased
++		| STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
++		| STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPObject*)))
++		| STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPIdentifier)))
++		| RESULT_SIZE(SIZE_CODE(sizeof(bool)))
++};
++
++#define NewNPN_HasMethodProc(FUNC)		\
++		(NPN_HasMethodUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_HasMethodProcInfo, GetCurrentArchitecture())
++#define CallNPN_HasMethodProc(FUNC, ARG1, ARG2, ARG3)		\
++		(jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_HasMethodProcInfo, (ARG1), (ARG2), (ARG3))
++
++#else
++
++typedef bool (* NP_LOADDS NPN_HasMethodUPP)(NPP npp, NPObject *obj, NPIdentifier propertyName);
++#define NewNPN_HasMethodProc(FUNC)		\
++		((NPN_HasMethodUPP) (FUNC))
++#define CallNPN_HasMethodProc(FUNC, ARG1, ARG2, ARG3)		\
++		(*(FUNC))((ARG1), (ARG2), (ARG3))
++
++#endif
++
++/* NPN_ReleaseVariantValue */
++
++#if _NPUPP_USE_UPP_
++
++typedef UniversalProcPtr NPN_ReleaseVariantValue;
++enum {
++	uppNPN_ReleaseVariantValueProcInfo = kThinkCStackBased
++		| STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPVariant*)))
++		| RESULT_SIZE(SIZE_CODE(0))
++};
++
++#define NewNPN_ReleaseVariantValueProc(FUNC)		\
++		(NPN_ReleaseVariantValueUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_ReleaseVariantValueProcInfo, GetCurrentArchitecture())
++#define CallNPN_ReleaseVariantValueProc(FUNC, ARG1)		\
++		(jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_ReleaseVariantValueProcInfo, (ARG1))	
++
++#else
++
++typedef void (* NP_LOADDS NPN_ReleaseVariantValueUPP)(NPVariant *variant);
++#define NewNPN_ReleaseVariantValueProc(FUNC)		\
++		((NPN_ReleaseVariantValueUPP) (FUNC))
++#define CallNPN_ReleaseVariantValueProc(FUNC, ARG1)		\
++		(*(FUNC))((ARG1))
++
++#endif
++
++/* NPN_SetException */
++
++#if _NPUPP_USE_UPP_
++
++typedef UniversalProcPtr NPN_SetExceptionUPP;
++enum {
++	uppNPN_SetExceptionProcInfo = kThinkCStackBased
++		| STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPObject*)))
++		| STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(const NPUTF8*)))
++		| RESULT_SIZE(SIZE_CODE(0))
++};
++
++#define NewNPN_SetExceptionProc(FUNC)		\
++		(NPN_SetExceptionUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_SetExceptionProcInfo, GetCurrentArchitecture())
++#define CallNPN_SetExceptionProc(FUNC, ARG1, ARG2)		\
++		(jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_SetExceptionProcInfo, (ARG1), (ARG2))	
++
++#else
++
++typedef void (* NP_LOADDS NPN_SetExceptionUPP)(NPObject *obj, const NPUTF8 *message);
++#define NewNPN_SetExceptionProc(FUNC)		\
++		((NPN_SetExceptionUPP) (FUNC))
++#define CallNPN_SetExceptionProc(FUNC, ARG1, ARG2)		\
++		(*(FUNC))((ARG1), (ARG2))	
++
++#endif
++
++/* NPN_PushPopupsEnabledStateUPP */
++
++#if _NPUPP_USE_UPP_
++
++typedef UniversalProcPtr NPN_PushPopupsEnabledStateUPP;
++enum {
++	uppNPN_PushPopupsEnabledStateProcInfo = kThinkCStackBased
++		| STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
++        | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPBool)))
++		| RESULT_SIZE(SIZE_CODE(0))
++};
++
++#define NewNPN_PushPopupsEnabledStateProc(FUNC)		\
++		(NPN_PushPopupsEnabledStateUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_PushPopupsEnabledStateProcInfo, GetCurrentArchitecture())
++#define CallNPN_PushPopupsEnabledStateProc(FUNC, ARG1, ARG2)		\
++		(jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_PushPopupsEnabledStateProcInfo, (ARG1), (ARG2))
++
++#else
++
++typedef bool (* NP_LOADDS NPN_PushPopupsEnabledStateUPP)(NPP npp, NPBool enabled);
++#define NewNPN_PushPopupsEnabledStateProc(FUNC)		\
++		((NPN_PushPopupsEnabledStateUPP) (FUNC))
++#define CallNPN_PushPopupsEnabledStateProc(FUNC, ARG1, ARG2)		\
++		(*(FUNC))((ARG1), (ARG2))
++
++#endif
++
++/* NPN_PopPopupsEnabledState */
++
++#if _NPUPP_USE_UPP_
++
++typedef UniversalProcPtr NPN_PopPopupsEnabledStateUPP;
++enum {
++	uppNPN_PopPopupsEnabledStateProcInfo = kThinkCStackBased
++		| STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
++		| RESULT_SIZE(SIZE_CODE(0))
++};
++
++#define NewNPN_PopPopupsEnabledStateProc(FUNC)		\
++		(NPN_PopPopupsEnabledStateUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_PopPopupsEnabledStateProcInfo, GetCurrentArchitecture())
++#define CallNPN_PopPopupsEnabledStateProc(FUNC, ARG1)		\
++		(jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_PopPopupsEnabledStateProcInfo, (ARG1))
++
++#else
++
++typedef bool (* NP_LOADDS NPN_PopPopupsEnabledStateUPP)(NPP npp);
++#define NewNPN_PopPopupsEnabledStateProc(FUNC)		\
++		((NPN_PopPopupsEnabledStateUPP) (FUNC))
++#define CallNPN_PopPopupsEnabledStateProc(FUNC, ARG1)		\
++		(*(FUNC))((ARG1))
++
++#endif
++
++
+ 
+ /******************************************************************************************
+  * The actual plugin function table definitions
+@@ -1117,6 +1693,27 @@
+     NPN_InvalidateRectUPP invalidaterect;
+     NPN_InvalidateRegionUPP invalidateregion;
+     NPN_ForceRedrawUPP forceredraw;
++    NPN_GetStringIdentifierUPP getstringidentifier;
++    NPN_GetStringIdentifiersUPP getstringidentifiers;
++    NPN_GetIntIdentifierUPP getintidentifier;
++    NPN_IdentifierIsStringUPP identifierisstring;
++    NPN_UTF8FromIdentifierUPP utf8fromidentifier;
++    NPN_IntFromIdentifierUPP intfromidentifier;
++    NPN_CreateObjectUPP createobject;
++    NPN_RetainObjectUPP retainobject;
++    NPN_ReleaseObjectUPP releaseobject;
++    NPN_InvokeUPP invoke;
++    NPN_InvokeDefaultUPP invokeDefault;
++    NPN_EvaluateUPP evaluate;
++    NPN_GetPropertyUPP getproperty;
++    NPN_SetPropertyUPP setproperty;
++    NPN_RemovePropertyUPP removeproperty;
++    NPN_HasPropertyUPP hasproperty;
++    NPN_HasMethodUPP hasmethod;
++    NPN_ReleaseVariantValueUPP releasevariantvalue;
++    NPN_SetExceptionUPP setexception;
++    NPN_PushPopupsEnabledStateUPP pushpopupsenabledstate;
++    NPN_PopPopupsEnabledStateUPP poppopupsenabledstate;
+ } NPNetscapeFuncs;
+ 
+ #ifdef XP_MAC
+--- nsplugins/sdk/npapi.h	(.../tags/KDE/3.5.8/kdebase)	(revision 754402)
++++ nsplugins/sdk/npapi.h	(.../branches/KDE/3.5/kdebase)	(revision 754402)
+@@ -38,7 +38,7 @@
+ 
+ 
+ /*
+- *  npapi.h $Revision: 719539 $
++ *  npapi.h
+  *  Netscape client plug-in API spec
+  */
+ 
+@@ -126,11 +126,11 @@
+ /*----------------------------------------------------------------------*/
+ 
+ #define NP_VERSION_MAJOR 0
+-#define NP_VERSION_MINOR 11
++#define NP_VERSION_MINOR 13
+ 
+ 
+ /* The OS/2 version of Netscape uses RC_DATA to define the
+-   mime types, file extentions, etc that are required.
++   mime types, file extensions, etc that are required.
+    Use a vertical bar to separate types, end types with \0.
+    FileVersion and ProductVersion are 32bit ints, all other
+    entries are strings the MUST be terminated wwith a \0.
+@@ -387,7 +387,8 @@
+ 
+   /* 12 and over are available on Mozilla builds starting with 0.9.9 */
+   NPPVjavascriptPushCallerBool = 12,
+-  NPPVpluginKeepLibraryInMemory = 13   /* available in Mozilla 1.0 */
++  NPPVpluginKeepLibraryInMemory = 13,   /* available in Mozilla 1.0 */
++  NPPVpluginNeedsXEmbed         = 14
+ } NPPVariable;
+ 
+ /*
+@@ -404,10 +405,20 @@
+   /* 10 and over are available on Mozilla builds starting with 0.9.4 */
+   NPNVserviceManager = (10 | NP_ABI_MASK),
+   NPNVDOMElement     = (11 | NP_ABI_MASK),   /* available in Mozilla 1.2 */
+-  NPNVDOMWindow      = (12 | NP_ABI_MASK)
++  NPNVDOMWindow      = (12 | NP_ABI_MASK),
++  NPNVToolkit        = (13 | NP_ABI_MASK),
++  NPNVSupportsXEmbedBool = 14
+ } NPNVariable;
+ 
+ /*
++ * The type of Tookkit the widgets use
++ */
++typedef enum {
++  NPNVGtk12 = 1,
++  NPNVGtk2
++} NPNToolkitType;
++
++/*
+  * The type of a NPWindow - it specifies the type of the data structure
+  * returned in the window field.
+  */
+@@ -428,7 +439,7 @@
+   NPRect clipRect; /* Clipping rectangle in port coordinates */
+                    /* Used by MAC only.			  */
+ #if defined(XP_UNIX) && !defined(XP_MACOSX)
+-  void * ws_info; /* Platform-dependent additonal data */
++  void * ws_info; /* Platform-dependent additional data */
+ #endif /* XP_UNIX */
+   NPWindowType type; /* Is this a window or a drawable? */
+ } NPWindow;
+--- nsplugins/viewer/nsplugin.cpp	(.../tags/KDE/3.5.8/kdebase)	(revision 754402)
++++ nsplugins/viewer/nsplugin.cpp	(.../branches/KDE/3.5/kdebase)	(revision 754402)
+@@ -180,6 +180,12 @@
+          // Offline browsing - no thanks
+          *(bool*)value = false;
+          return NPERR_NO_ERROR;
++      case NPNVToolkit:
++         *(NPNToolkitType*)value = NPNVGtk2;
++         return NPERR_NO_ERROR;
++      case NPNVSupportsXEmbedBool:
++         *(bool*)value = true;
++         return NPERR_NO_ERROR;
+       default:
+          return NPERR_INVALID_PARAM;
+    }
+@@ -484,6 +490,8 @@
+     KProtocolManager kpm;
+     QString agent = kpm.userAgentForHost("nspluginviewer");
+     kdDebug(1431) << "g_NPN_UserAgent() = " << agent << endl;
++    // flash crashes without Firefox UA
++    agent = "Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.8.1.10) Gecko/2007101500 Firefox/2.0.0.10";
+     return agent.latin1();
+ }
+ 
+@@ -583,7 +591,7 @@
+                                    KLibrary *handle, int width, int height,
+                                    QString src, QString /*mime*/,
+                                    QString appId, QString callbackId,
+-                                   bool embed,
++                                   bool embed, WId xembed,
+                                    QObject *parent, const char* name )
+    : DCOPObject(), QObject( parent, name ) 
+ {
+@@ -599,6 +607,8 @@
+    _streams.setAutoDelete( true );
+    _waitingRequests.setAutoDelete( true );
+    _callback = new NSPluginCallbackIface_stub( appId.latin1(), callbackId.latin1() );
++   _xembed_window = xembed;
++   _toplevel = _form = 0;
+ 
+    KURL base(src);
+    base.setFileName( QString::null );
+@@ -619,51 +629,53 @@
+    if (height == 0)
+       height = 1200;
+ 
+-   // create drawing area
+-   Arg args[7];
+-   Cardinal nargs = 0;
+-   XtSetArg(args[nargs], XtNwidth, width); nargs++;
+-   XtSetArg(args[nargs], XtNheight, height); nargs++;
+-   XtSetArg(args[nargs], XtNborderWidth, 0); nargs++;
++   if( _xembed_window == 0 ) {
++      // create drawing area
++      Arg args[7];
++      Cardinal nargs = 0;
++      XtSetArg(args[nargs], XtNwidth, width); nargs++;
++      XtSetArg(args[nargs], XtNheight, height); nargs++;
++      XtSetArg(args[nargs], XtNborderWidth, 0); nargs++;
+ 
+-   String n, c;
+-   XtGetApplicationNameAndClass(qt_xdisplay(), &n, &c);
++      String n, c;
++      XtGetApplicationNameAndClass(qt_xdisplay(), &n, &c);
+ 
+-   _toplevel = XtAppCreateShell("drawingArea", c, applicationShellWidgetClass,
+-                                qt_xdisplay(), args, nargs);
++      _toplevel = XtAppCreateShell("drawingArea", c, applicationShellWidgetClass,
++                                   qt_xdisplay(), args, nargs);
+ 
+-   // What exactly does widget mapping mean? Without this call the widget isn't
+-   // embedded correctly. With it the viewer doesn't show anything in standalone mode.
+-   //if (embed)
+-      XtSetMappedWhenManaged(_toplevel, False);
+-   XtRealizeWidget(_toplevel);
++      // What exactly does widget mapping mean? Without this call the widget isn't
++      // embedded correctly. With it the viewer doesn't show anything in standalone mode.
++      //if (embed)
++         XtSetMappedWhenManaged(_toplevel, False);
++      XtRealizeWidget(_toplevel);
+ 
+-   // Create form window that is searched for by flash plugin
+-   _form = XtVaCreateWidget("form", compositeWidgetClass, _toplevel, NULL);
+-   XtSetArg(args[nargs], XtNvisual, QPaintDevice::x11AppVisual()); nargs++;
+-   XtSetArg(args[nargs], XtNdepth, QPaintDevice::x11AppDepth()); nargs++;
+-   XtSetArg(args[nargs], XtNcolormap, QPaintDevice::x11AppColormap()); nargs++;
+-   XtSetValues(_form, args, nargs);
+-   XSync(qt_xdisplay(), false);
++      // Create form window that is searched for by flash plugin
++      _form = XtVaCreateWidget("form", compositeWidgetClass, _toplevel, NULL);
++      XtSetArg(args[nargs], XtNvisual, QPaintDevice::x11AppVisual()); nargs++;
++      XtSetArg(args[nargs], XtNdepth, QPaintDevice::x11AppDepth()); nargs++;
++      XtSetArg(args[nargs], XtNcolormap, QPaintDevice::x11AppColormap()); nargs++;
++      XtSetValues(_form, args, nargs);
++      XSync(qt_xdisplay(), false);
+ 
+-   // From mozilla - not sure if it's needed yet, nor what to use for embedder
++      // From mozilla - not sure if it's needed yet, nor what to use for embedder
+ #if 0
+-   /* this little trick seems to finish initializing the widget */
++      /* this little trick seems to finish initializing the widget */
+ #if XlibSpecificationRelease >= 6
+-   XtRegisterDrawable(qt_xdisplay(), embedderid, _toplevel);
++      XtRegisterDrawable(qt_xdisplay(), embedderid, _toplevel);
+ #else
+-   _XtRegisterWindow(embedderid, _toplevel);
++      _XtRegisterWindow(embedderid, _toplevel);
+ #endif
+ #endif
+-   XtRealizeWidget(_form);
+-   XtManageChild(_form);
++      XtRealizeWidget(_form);
++      XtManageChild(_form);
+ 
+-   // Register forwarder
+-   XtAddEventHandler(_toplevel, (KeyPressMask|KeyReleaseMask), 
+-                     False, forwarder, (XtPointer)this );
+-   XtAddEventHandler(_form, (KeyPressMask|KeyReleaseMask), 
+-                     False, forwarder, (XtPointer)this );
+-   XSync(qt_xdisplay(), false);
++      // Register forwarder
++      XtAddEventHandler(_toplevel, (KeyPressMask|KeyReleaseMask), 
++                        False, forwarder, (XtPointer)this );
++      XtAddEventHandler(_form, (KeyPressMask|KeyReleaseMask), 
++                        False, forwarder, (XtPointer)this );
++      XSync(qt_xdisplay(), false);
++   }
+ }
+ 
+ NSPluginInstance::~NSPluginInstance()
+@@ -714,14 +726,16 @@
+         if (saved)
+           g_NPN_MemFree(saved);
+ 
+-        XtRemoveEventHandler(_form, (KeyPressMask|KeyReleaseMask), 
+-                             False, forwarder, (XtPointer)this);
+-        XtRemoveEventHandler(_toplevel, (KeyPressMask|KeyReleaseMask), 
+-                             False, forwarder, (XtPointer)this);
+-        XtDestroyWidget(_form);
+-	_form = 0;
+-        XtDestroyWidget(_toplevel);
+-	_toplevel = 0;
++        if( _form != 0 ) {
++            XtRemoveEventHandler(_form, (KeyPressMask|KeyReleaseMask), 
++                                 False, forwarder, (XtPointer)this);
++            XtRemoveEventHandler(_toplevel, (KeyPressMask|KeyReleaseMask), 
++                                 False, forwarder, (XtPointer)this);
++            XtDestroyWidget(_form);
++    	    _form = 0;
++            XtDestroyWidget(_toplevel);
++	    _toplevel = 0;
++        }
+ 
+         if (_npp) {
+             ::free(_npp);   // matched with malloc() in newInstance
+@@ -902,7 +916,6 @@
+    _timer->start( 100, true );
+ }
+ 
+-
+ int NSPluginInstance::setWindow(int remove)
+ {
+    if (remove)
+@@ -926,15 +939,25 @@
+    _win.clipRect.bottom = _height;
+    _win.clipRect.right = _width;
+ 
+-   _win.window = (void*) XtWindow(_form);
++   if( _xembed_window ) {
++      _win.window = (void*) _xembed_window;
++      _win_info.type = NP_SETWINDOW;
++      _win_info.display = qt_xdisplay();
++      _win_info.visual = DefaultVisualOfScreen(DefaultScreenOfDisplay(qt_xdisplay()));
++      _win_info.colormap = DefaultColormapOfScreen(DefaultScreenOfDisplay(qt_xdisplay()));
++      _win_info.depth = DefaultDepthOfScreen(DefaultScreenOfDisplay(qt_xdisplay()));
++   } else {
++      _win.window = (void*) XtWindow(_form);
++
++      _win_info.type = NP_SETWINDOW;
++      _win_info.display = XtDisplay(_form);
++      _win_info.visual = DefaultVisualOfScreen(XtScreen(_form));
++      _win_info.colormap = DefaultColormapOfScreen(XtScreen(_form));
++      _win_info.depth = DefaultDepthOfScreen(XtScreen(_form));
++   }
++
+    kdDebug(1431) << "Window ID = " << _win.window << endl;
+ 
+-   _win_info.type = NP_SETWINDOW;
+-   _win_info.display = XtDisplay(_form);
+-   _win_info.visual = DefaultVisualOfScreen(XtScreen(_form));
+-   _win_info.colormap = DefaultColormapOfScreen(XtScreen(_form));
+-   _win_info.depth = DefaultDepthOfScreen(XtScreen(_form));
+-
+    _win.ws_info = &_win_info;
+ 
+    NPError error = NPSetWindow( &_win );
+@@ -959,9 +982,6 @@
+ 
+ void NSPluginInstance::resizePlugin(int w, int h)
+ {
+-   if (!_visible)
+-      return;
+-
+    if (w == _width && h == _height)
+       return;
+ 
+@@ -970,22 +990,30 @@
+    _width = w;
+    _height = h;
+ 
+-   XResizeWindow(qt_xdisplay(), XtWindow(_form), w, h);
+-   XResizeWindow(qt_xdisplay(), XtWindow(_toplevel), w, h);
++   if( _form != 0 ) {
++      XResizeWindow(qt_xdisplay(), XtWindow(_form), w, h);
++      XResizeWindow(qt_xdisplay(), XtWindow(_toplevel), w, h);
+ 
+-   Arg args[7];
+-   Cardinal nargs = 0;
+-   XtSetArg(args[nargs], XtNwidth, _width); nargs++;
+-   XtSetArg(args[nargs], XtNheight, _height); nargs++;
+-   XtSetArg(args[nargs], XtNvisual, QPaintDevice::x11AppVisual()); nargs++;
+-   XtSetArg(args[nargs], XtNdepth, QPaintDevice::x11AppDepth()); nargs++;
+-   XtSetArg(args[nargs], XtNcolormap, QPaintDevice::x11AppColormap()); nargs++;
+-   XtSetArg(args[nargs], XtNborderWidth, 0); nargs++;
++      Arg args[7];
++      Cardinal nargs = 0;
++      XtSetArg(args[nargs], XtNwidth, _width); nargs++;
++      XtSetArg(args[nargs], XtNheight, _height); nargs++;
++      XtSetArg(args[nargs], XtNvisual, QPaintDevice::x11AppVisual()); nargs++;
++      XtSetArg(args[nargs], XtNdepth, QPaintDevice::x11AppDepth()); nargs++;
++      XtSetArg(args[nargs], XtNcolormap, QPaintDevice::x11AppColormap()); nargs++;
++      XtSetArg(args[nargs], XtNborderWidth, 0); nargs++;
++ 
++      XtSetValues(_toplevel, args, nargs);
++      XtSetValues(_form, args, nargs);
+ 
+-   XtSetValues(_toplevel, args, nargs);
+-   XtSetValues(_form, args, nargs);
++      resizeWidgets(XtWindow(_form), _width, _height);
++   }
+ 
+-   resizeWidgets(XtWindow(_form), _width, _height);
++   // If not visible yet, displayWindow() will call setWindow() again anyway, so avoid this.
++   // This also handled plugins that are broken and cannot handle repeated setWindow() calls
++   // very well.
++   if (!_visible)
++      return;
+ 
+    setWindow();
+ 
+@@ -1405,7 +1433,7 @@
+ DCOPRef NSPluginClass::newInstance( QString url, QString mimeType, bool embed,
+                                     QStringList argn, QStringList argv,
+                                     QString appId, QString callbackId,
+-                                    bool reload, bool doPost, QByteArray postData )
++                                    bool reload, bool doPost, QByteArray postData, long xembed )
+ {
+    kdDebug(1431) << "-> NSPluginClass::NewInstance" << endl;
+ 
+@@ -1449,16 +1477,25 @@
+    memset(npp, 0, sizeof(NPP_t));
+    npp->ndata = NULL;
+ 
+-   // Create plugin instance object
+-   NSPluginInstance *inst = new NSPluginInstance( npp, &_pluginFuncs, _handle,
+-                                                  width, height, baseURL, mimeType,
+-                                                  appId, callbackId, embed, this );
+-
+    // create plugin instance
+    NPError error = _pluginFuncs.newp(mime, npp, embed ? NP_EMBED : NP_FULL,
+                                      argc, _argn, _argv, 0);
+    kdDebug(1431) << "NPP_New = " << (int)error << endl;
+ 
++   // don't use bool here, it can be 1 byte, but some plugins write it as int, and I can't find what the spec says
++   int wants_xembed = false;
++   if (_pluginFuncs.getvalue) {
++      NPError error = _pluginFuncs.getvalue(npp, (NPPVariable)14/*NPPVpluginNeedsXEmbed*/, &wants_xembed );
++      if( error != NPERR_NO_ERROR )
++         wants_xembed = false;
++   }
++   kdDebug(1431) << "Plugin requires XEmbed:" << (bool)wants_xembed << endl;
++
++   // Create plugin instance object
++   NSPluginInstance *inst = new NSPluginInstance( npp, &_pluginFuncs, _handle,
++                                                  width, height, baseURL, mimeType,
++                                                  appId, callbackId, embed, wants_xembed ? xembed : 0, this );
++
+    // free arrays with arguments
+    delete [] _argn;
+    delete [] _argv;
+@@ -1493,7 +1530,6 @@
+     timer(); //_timer->start( 0, TRUE );
+ }
+ 
+-
+ /****************************************************************************/
+ 
+ NSPluginStreamBase::NSPluginStreamBase( NSPluginInstance *instance )
+@@ -1516,8 +1552,6 @@
+ 
+    delete _tempFile;
+    _tempFile = 0;
+-   delete _queue;
+-   _queue = 0;
+ }
+ 
+ 
+--- nsplugins/viewer/viewer.cpp	(.../tags/KDE/3.5.8/kdebase)	(revision 754402)
++++ nsplugins/viewer/viewer.cpp	(.../branches/KDE/3.5/kdebase)	(revision 754402)
+@@ -52,6 +52,7 @@
+ #include <X11/Shell.h>
+ #else
+ #include "qxteventloop.h"
++#include "glibevents.h"
+ #endif
+ 
+ /**
+@@ -249,6 +250,7 @@
+ 
+    kdDebug(1430) << "4 - create KApplication" << endl;
+    KApplication app( argc,  argv, "nspluginviewer" );
++   GlibEvents glibevents;
+ #endif
+ 
+    {
+--- nsplugins/viewer/NSPluginClassIface.h	(.../tags/KDE/3.5.8/kdebase)	(revision 754402)
++++ nsplugins/viewer/NSPluginClassIface.h	(.../branches/KDE/3.5/kdebase)	(revision 754402)
+@@ -50,7 +50,7 @@
+   virtual DCOPRef newInstance(QString url, QString mimeType, bool embed,
+                               QStringList argn, QStringList argv,
+                               QString appId, QString callbackId, bool reload,
+-                              bool doPost, QByteArray postData) = 0;
++                              bool doPost, QByteArray postData, long xembed) = 0;
+   virtual QString getMIMEDescription() = 0;
+ 
+ };
+--- nsplugins/viewer/glibevents.cpp	(.../tags/KDE/3.5.8/kdebase)	(revision 0)
++++ nsplugins/viewer/glibevents.cpp	(.../branches/KDE/3.5/kdebase)	(revision 754402)
+@@ -0,0 +1,43 @@
++/*
++  Copyright (c) 2007 Lubos Lunak <l.lunak at suse.cz>
++ 
++  This program is free software; you can redistribute it and/or modify
++  it under the terms of the GNU General Public License as published by
++  the Free Software Foundation; either version 2 of the License, or
++  (at your option) any later version.
++ 
++  This program is distributed in the hope that it will be useful,
++  but WITHOUT ANY WARRANTY; without even the implied warranty of
++  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++  GNU General Public License for more details.
++ 
++  You should have received a copy of the GNU General Public License
++  along with this program; if not, write to the Free Software
++  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
++ 
++*/                                                                            
++
++#include "glibevents.h"
++
++#include <qapplication.h>
++
++GlibEvents::GlibEvents()
++    {
++    g_main_context_ref( g_main_context_default());
++    connect( &timer, SIGNAL( timeout()), SLOT( process()));
++    // TODO Poll for now
++    timer.start( 10 );
++    }
++
++GlibEvents::~GlibEvents()
++    {
++    g_main_context_unref( g_main_context_default());
++    }
++
++void GlibEvents::process()
++    {
++    while( g_main_context_pending( g_main_context_default()))
++        g_main_context_iteration( g_main_context_default(), false );
++    }
++
++#include "glibevents.moc"
+--- nsplugins/viewer/nsplugin.h	(.../tags/KDE/3.5.8/kdebase)	(revision 754402)
++++ nsplugins/viewer/nsplugin.h	(.../branches/KDE/3.5/kdebase)	(revision 754402)
+@@ -165,13 +165,13 @@
+   // constructor, destructor
+   NSPluginInstance( NPP privateData, NPPluginFuncs *pluginFuncs, KLibrary *handle,
+ 		    int width, int height, QString src, QString mime,
+-                    QString appId, QString callbackId, bool embed,
++                    QString appId, QString callbackId, bool embed, WId xembed,
+ 		    QObject *parent, const char* name=0 );
+   ~NSPluginInstance();
+ 
+   // DCOP functions
+   void shutdown();
+-  int winId() { return XtWindow(_form); }
++  int winId() { return _form != 0 ? XtWindow(_form) : 0; }
+   int setWindow(int remove=0);
+   void resizePlugin(int w, int h);
+   void javascriptResult(int id, QString result);
+@@ -232,6 +232,7 @@
+   NPPluginFuncs _pluginFuncs;
+ 
+   Widget _area, _form, _toplevel;
++  WId _xembed_window;
+   QString _baseURL;
+   int _width, _height;
+ 
+@@ -281,7 +282,7 @@
+   DCOPRef newInstance(QString url, QString mimeType, bool embed,
+                       QStringList argn, QStringList argv,
+                       QString appId, QString callbackId, bool reload, bool post,
+-                      QByteArray postData );
++                      QByteArray postData, long xembed );
+   void destroyInstance( NSPluginInstance* inst );
+   bool error() { return _error; }
+ 
+--- nsplugins/viewer/glibevents.h	(.../tags/KDE/3.5.8/kdebase)	(revision 0)
++++ nsplugins/viewer/glibevents.h	(.../branches/KDE/3.5/kdebase)	(revision 754402)
+@@ -0,0 +1,41 @@
++/*
++  Copyright (c) 2007 Lubos Lunak <l.lunak at suse.cz>
++ 
++  This program is free software; you can redistribute it and/or modify
++  it under the terms of the GNU General Public License as published by
++  the Free Software Foundation; either version 2 of the License, or
++  (at your option) any later version.
++ 
++  This program is distributed in the hope that it will be useful,
++  but WITHOUT ANY WARRANTY; without even the implied warranty of
++  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++  GNU General Public License for more details.
++ 
++  You should have received a copy of the GNU General Public License
++  along with this program; if not, write to the Free Software
++  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
++ 
++*/                                                                            
++
++#ifndef GLIBEVENTS_H
++#define GLIBEVENTS_H
++
++#include <qwidget.h>
++#include <qtimer.h>
++
++#include <glib.h>
++
++class GlibEvents
++    : public QWidget
++    {
++    Q_OBJECT
++    public:
++        GlibEvents();
++        virtual ~GlibEvents();
++    private slots:
++        void process();
++    private:
++        QTimer timer;
++    };
++
++#endif
+--- nsplugins/viewer/Makefile.am	(.../tags/KDE/3.5.8/kdebase)	(revision 754402)
++++ nsplugins/viewer/Makefile.am	(.../branches/KDE/3.5/kdebase)	(revision 754402)
+@@ -1,12 +1,11 @@
+-INCLUDES = -I$(top_srcdir)/nsplugins -I$(top_builddir)/nsplugins $(all_includes)
++INCLUDES = -I$(top_srcdir)/nsplugins -I$(top_builddir)/nsplugins $(all_includes) `pkg-config --cflags glib-2.0`
+ METASOURCES = AUTO
+ 
+ bin_PROGRAMS = nspluginviewer 
+ 
+ nspluginviewer_SOURCES = NSPluginCallbackIface.stub NSPluginClassIface.skel \
+-	nsplugin.cpp viewer.cpp kxt.cpp qxteventloop.cpp
+-nspluginviewer_LDFLAGS = $(all_libraries) $(KDE_RPATH) -export-dynamic
++	nsplugin.cpp viewer.cpp kxt.cpp qxteventloop.cpp glibevents.cpp
++nspluginviewer_LDFLAGS = $(all_libraries) $(KDE_RPATH) -export-dynamic `pkg-config --libs glib-2.0`
+ nspluginviewer_LDADD = $(LIB_KIO) $(LIB_KPARTS) -lXt
+ 
+ NSPluginCallbackIface_DIR = $(srcdir)/..
+-
+--- nsplugins/nspluginloader.cpp	(.../tags/KDE/3.5.8/kdebase)	(revision 754402)
++++ nsplugins/nspluginloader.cpp	(.../branches/KDE/3.5/kdebase)	(revision 754402)
+@@ -41,6 +41,7 @@
+ #include <qpushbutton.h>
+ #include <qxembed.h>
+ #include <qtextstream.h>
++#include <qtimer.h>
+ #include <qregexp.h>
+ 
+ #include "nspluginloader.h"
+@@ -54,11 +55,14 @@
+ int NSPluginLoader::s_refCount = 0;
+ 
+ 
+-NSPluginInstance::NSPluginInstance(QWidget *parent, const QCString& app, const QCString& id)
+-  : DCOPStub(app, id), NSPluginInstanceIface_stub(app, id), EMBEDCLASS(parent)
++NSPluginInstance::NSPluginInstance(QWidget *parent)
++  : EMBEDCLASS(parent), _loader( NULL ), shown( false ), inited( false ), resize_count( 0 ), stub( NULL )
+ {
+-    _loader = 0L;
+-    shown = false;
++}
++
++void NSPluginInstance::init(const QCString& app, const QCString& obj)
++{
++    stub = new NSPluginInstanceIface_stub( app, obj );
+     QGridLayout *_layout = new QGridLayout(this, 1, 1);
+     KConfig cfg("kcmnspluginrc", false);
+     cfg.setGroup("Misc");
+@@ -69,23 +73,37 @@
+         show();
+     } else {
+         _button = 0L;
+-        doLoadPlugin();
++        // Protection against repeated NPSetWindow() - Flash v9,0,115,0 doesn't handle
++        // repeated NPSetWindow() calls properly, which happens when NSPluginInstance is first
++        // shown and then resized. Which is what happens with KHTML. Therefore use 'shown'
++        // to detect whether the widget is shown and drop all resize events before that,
++        // and use 'resize_count' to wait for that one more resize to come (plus a timer
++        // for a possible timeout). Only then flash is actually initialized ('inited' is true).
++        resize_count = 1;
++        QTimer::singleShot( 1000, this, SLOT( doLoadPlugin()));
+     }
+ }
+ 
+ 
+ void NSPluginInstance::doLoadPlugin() {
+-    if (!_loader) {
++    if (!inited) {
+         delete _button;
+         _button = 0L;
+         _loader = NSPluginLoader::instance();
+         setBackgroundMode(QWidget::NoBackground);
+-        setProtocol(QXEmbed::XPLAIN);
+-        embed( NSPluginInstanceIface_stub::winId() );
++        WId winid = stub->winId();
++        if( winid != 0 ) {
++            setProtocol(QXEmbed::XPLAIN);
++            embed( winid );
++        } else {
++            setProtocol(QXEmbed::XEMBED);
++        }
++        // resize before showing, some plugins are stupid and can't handle repeated
++        // NPSetWindow() calls very well (viewer will avoid the call if not shown yet)
++        resizePlugin(width(), height());
+         displayPlugin();
+         show();
+-        shown = true;
+-        if (isVisible()) resizePlugin(width(), height());
++        inited = true;
+     }
+ }
+ 
+@@ -93,10 +111,13 @@
+ NSPluginInstance::~NSPluginInstance()
+ {
+    kdDebug() << "-> NSPluginInstance::~NSPluginInstance" << endl;
+-   shutdown();
++   if( inited )
++     shutdown();
+    kdDebug() << "release" << endl;
+-   _loader->release();
++   if(_loader)
++     _loader->release();
+    kdDebug() << "<- NSPluginInstance::~NSPluginInstance" << endl;
++   delete stub;
+ }
+ 
+ 
+@@ -112,8 +133,14 @@
+ 
+ void NSPluginInstance::resizeEvent(QResizeEvent *event)
+ {
+-  if (shown == false)
++  if (shown == false) // ignore all resizes before being shown
+      return;
++  if( !inited && resize_count > 0 ) {
++      if( --resize_count == 0 )
++        doLoadPlugin();
++      else
++        return;
++  }
+   EMBEDCLASS::resizeEvent(event);
+   if (isVisible()) {
+     resizePlugin(width(), height());
+@@ -124,9 +151,31 @@
+ void NSPluginInstance::showEvent(QShowEvent *event)
+ {
+   EMBEDCLASS::showEvent(event);
+-  resizePlugin(width(), height());
++  shown = true;
++  if(!inited && resize_count == 0 )
++      doLoadPlugin();
++  if(inited)
++    resizePlugin(width(), height());
+ }
+ 
++void NSPluginInstance::displayPlugin()
++{
++  qApp->syncX(); // process pending X commands
++  stub->displayPlugin();
++}
++
++void NSPluginInstance::resizePlugin( int w, int h )
++{
++  qApp->syncX();
++  stub->resizePlugin( w, h );
++}
++
++void NSPluginInstance::shutdown()
++{
++  if( stub )
++    stub->shutdown();
++}
++
+ /*******************************************************************************/
+ 
+ 
+@@ -445,20 +494,20 @@
+    if ( mime=="application/x-shockwave-flash" )
+        embed = true; // flash doesn't work in full mode :(
+ 
++   NSPluginInstance *plugin = new NSPluginInstance( parent );
++   kdDebug() << "<- NSPluginLoader::NewInstance = " << (void*)plugin << endl;
+ 
+    // get plugin instance
+-   DCOPRef inst_ref = cls->newInstance( url, mime, embed, argn, argv, appId, callbackId, reload, doPost, postData);
++   DCOPRef inst_ref = cls->newInstance( url, mime, embed, argn, argv, appId, callbackId, reload, doPost, postData, plugin->winId());
+    if ( inst_ref.isNull() )
+    {
+       kdDebug() << "Couldn't create plugin instance" << endl;
++      delete plugin;
+       return 0;
+    }
+ 
+-   NSPluginInstance *plugin = new NSPluginInstance( parent, inst_ref.app(),
+-                                                    inst_ref.object() );
++   plugin->init( inst_ref.app(), inst_ref.object() );
+ 
+-   kdDebug() << "<- NSPluginLoader::NewInstance = " << (void*)plugin << endl;
+-
+    return plugin;
+ }
+ 
+--- nsplugins/nspluginloader.h	(.../tags/KDE/3.5.8/kdebase)	(revision 754402)
++++ nsplugins/nspluginloader.h	(.../branches/KDE/3.5/kdebase)	(revision 754402)
+@@ -43,13 +43,16 @@
+ class QPushButton;
+ class QGridLayout;
+ 
+-class NSPluginInstance : public EMBEDCLASS, virtual public NSPluginInstanceIface_stub
++class NSPluginInstance : public EMBEDCLASS
+ {
+   Q_OBJECT
+ 
+ public:
+-    NSPluginInstance(QWidget *parent, const QCString& app, const QCString& id);
++    NSPluginInstance(QWidget *parent);
++    void init( const QCString& app, const QCString& obj );
+     ~NSPluginInstance();
++public: // wrappers
++    void javascriptResult( int id, QString result ) { stub->javascriptResult( id, result ); }
+ 
+ private slots:
+     void doLoadPlugin();
+@@ -60,8 +63,15 @@
+     void windowChanged(WId w);
+     class NSPluginLoader *_loader;
+     bool shown;
++    bool inited;
++    int resize_count;
+     QPushButton *_button;
+     QGridLayout *_layout;
++    NSPluginInstanceIface_stub* stub;
++private: // wrappers
++    void displayPlugin();
++    void resizePlugin( int w, int h );
++    void shutdown();
+ };
+ 
+ 
\ No newline at end of file

Added: trunk/packages/kdebase/debian/patches/04_nsplugins_regression_fix_branch_r757345.diff
===================================================================
--- trunk/packages/kdebase/debian/patches/04_nsplugins_regression_fix_branch_r757345.diff	                        (rev 0)
+++ trunk/packages/kdebase/debian/patches/04_nsplugins_regression_fix_branch_r757345.diff	2008-01-08 19:36:17 UTC (rev 8829)
@@ -0,0 +1,119 @@
+--- kdebase-3.5.8.dfsg.1/kcontrol/kcontrol/modules.cpp	2007-10-08 11:51:12.000000000 +0200
++++ kdebase-3.5.8.dfsg.1.new/kcontrol/kcontrol/modules.cpp	2008-01-08 16:43:19.000000000 +0100
+@@ -48,7 +48,7 @@
+ 
+ ConfigModule::ConfigModule(const KService::Ptr &s)
+   : KCModuleInfo(s), _changed(false), _module(0), _embedWidget(0),
+-    _rootProcess(0), _embedLayout(0), _embedFrame(0)
++    _rootProcess(0), _embedLayout(0), _embedFrame(0), _embedStack(0)
+ {
+ }
+ 
+@@ -97,6 +97,8 @@
+ 
+   delete _embedWidget;
+   _embedWidget = 0;
++  delete _embedStack;
++  _embedStack = 0;
+   delete _embedFrame;
+   _embedFrame = 0;
+   kapp->syncX();
+@@ -136,6 +138,7 @@
+   delete _rootProcess;
+   delete _embedWidget;
+   delete _embedLayout;
++  delete _embedStack;
+ 
+   // create an embed widget that will embed the
+   // kcmshell running as root
+@@ -149,14 +152,18 @@
+   _embedFrame->setLineWidth( 2 );
+   _embedFrame->setMidLineWidth( 2 );
+   _embedLayout->addWidget(_embedFrame,1);
+-  _embedWidget = new QXEmbed(_embedFrame );
++  // cannot reparent anything else inside QXEmbed, so put the busy label separately
++  _embedStack = new QWidgetStack(_embedFrame);
++  _embedWidget = new KControlEmbed(_embedStack);
+   _module->hide();
+   _embedFrame->show();
+-  QLabel *_busy = new QLabel(i18n("<big>Loading...</big>"), _embedWidget);
++  QLabel *_busy = new QLabel(i18n("<big>Loading...</big>"), _embedStack);
+   _busy->setAlignment(AlignCenter);
+   _busy->setTextFormat(RichText);
+   _busy->setGeometry(0,0, _module->width(), _module->height());
+   _busy->show();
++  _embedStack->raiseWidget(_busy);
++  connect(_embedWidget, SIGNAL( windowEmbedded(WId)), SLOT( embedded()));
+ 
+   // prepare the process to run the kcmshell
+   QString cmd = service()->exec().stripWhiteSpace();
+@@ -209,6 +216,8 @@
+     }
+ 
+   // clean up in case of failure
++  delete _embedStack;
++  _embedStack = 0;
+   delete _embedFrame;
+   _embedWidget = 0;
+   delete _embedLayout;
+@@ -239,6 +248,11 @@
+   emit childClosed();
+ }
+ 
++void ConfigModule::embedded()
++{
++  _embedStack->raiseWidget(_embedWidget); // put it above the busy label
++}
++
+ const KAboutData *ConfigModule::aboutData() const
+ {
+   if (!_module) return 0;
+--- kdebase-3.5.8.dfsg.1/kcontrol/kcontrol/modules.h	2005-10-10 17:03:43.000000000 +0200
++++ kdebase-3.5.8.dfsg.1.new/kcontrol/kcontrol/modules.h	2008-01-08 16:43:31.000000000 +0100
+@@ -23,6 +23,7 @@
+ #include <kcmoduleinfo.h>
+ #include <qobject.h>
+ #include <qdict.h>
++#include <qxembed.h>
+ 
+ template<class ConfigModule> class QPtrList;
+ class QStringList;
+@@ -33,6 +34,7 @@
+ class QXEmbed;
+ class QVBoxLayout;
+ class QVBox;
++class QWidgetStack;
+ 
+ class ConfigModule : public QObject, public KCModuleInfo
+ {
+@@ -62,6 +64,7 @@
+   void clientChanged(bool state);
+   void runAsRoot();
+   void rootExited(KProcess *proc);
++  void embedded();
+ 
+ 
+ signals:
+@@ -80,6 +83,7 @@
+   KProcess    *_rootProcess;
+   QVBoxLayout *_embedLayout;
+   QVBox       *_embedFrame;
++  QWidgetStack *_embedStack;
+ 
+ };
+ 
+@@ -119,4 +123,14 @@
+   QDict<Menu> subMenus;
+ };
+ 
++class KControlEmbed : public QXEmbed
++    {
++    Q_OBJECT
++    public:
++        KControlEmbed( QWidget* w ) : QXEmbed( w ) {}
++        virtual void windowChanged( WId w ) { if( w ) emit windowEmbedded( w ); }
++    signals:
++        void windowEmbedded( WId w );
++    };
++
+ #endif

Added: trunk/packages/kdebase/debian/patches/47_nsplugins_viewer_64bit_fix.diff
===================================================================
--- trunk/packages/kdebase/debian/patches/47_nsplugins_viewer_64bit_fix.diff	                        (rev 0)
+++ trunk/packages/kdebase/debian/patches/47_nsplugins_viewer_64bit_fix.diff	2008-01-08 19:36:17 UTC (rev 8829)
@@ -0,0 +1,42 @@
+--- kdebase-3.5.8.dfsg.1/nsplugins/viewer/qxteventloop.cpp	2007-05-14 09:55:42.000000000 +0200
++++ kdebase-3.5.8.dfsg.1.new/nsplugins/viewer/qxteventloop.cpp	2008-01-08 11:52:28.000000000 +0100
+@@ -72,7 +72,7 @@
+ 
+     QIntDict<QSocketNotifier> socknotDict;
+     bool activate_timers;
+-    int timerid;
++    XtIntervalId timerid;
+ 
+     // arguments for Xt display initialization
+     const char* applicationClass;
+@@ -110,7 +110,7 @@
+ 
+ QXtEventLoopPrivate::QXtEventLoopPrivate()
+     : appContext(NULL), ownContext(NULL),
+-      activate_timers(FALSE), timerid(-1)
++      activate_timers(FALSE), timerid(0)
+ {
+ }
+ 
+@@ -416,7 +416,7 @@
+ void qmotif_timeout_handler( XtPointer, XtIntervalId * )
+ {
+     static_d->activate_timers = TRUE;
+-    static_d->timerid = -1;
++    static_d->timerid = 0;
+ }
+ 
+ /*! \reimp
+@@ -429,10 +429,10 @@
+ 
+     // make sure we fire off Qt's timers
+     int ttw = timeToWait();
+-    if ( d->timerid != -1 ) {
++    if ( d->timerid != 0 ) {
+ 	XtRemoveTimeOut( d->timerid );
+     }
+-    d->timerid = -1;
++    d->timerid = 0;
+     if ( ttw != -1 ) {
+ 	d->timerid =
+ 	    XtAppAddTimeOut( d->appContext, ttw,




More information about the pkg-kde-commits mailing list