Bommels05/Mozilla
Bommels05/Mozilla
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Mozilla/mozilla/layout/html/content/src/nsHTMLAppletElement.cpp
drapeau%eng.sun.com 1cd55fd548 Fix for bug 18899 ('Make "--enable-oji" as part of the default Mozilla 
Build').  Modified files that conditionally compiled in support for
OJI, replacing with code that looks for OJI as an XPCOM service, and
failing gracefully if the OJI XPCOM service is not found.  The four
files modified by this fix are the only active ones; other modules
that conditionally compile in support for OJI appear to be dead code.

r=drapeau@eng.sun.com.  Fix contributed by Jayashri Visvanathan
(visvan@eng.sun.com).


git-svn-id: svn://10.0.0.236/trunk@55129 18797224-902f-48f8-a5cc-f745e15eee43
1999-12-03 00:26:09 +00:00

355 lines
12 KiB
C++
Raw Blame History

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
*
* 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/
*
* 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 Communicator client 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.
*
* Contributor(s):
*/
#include "nsIDOMHTMLAppletElement.h"
#include "nsIScriptObjectOwner.h"
#include "nsIDOMEventReceiver.h"
#include "nsIHTMLContent.h"
#include "nsGenericHTMLElement.h"
#include "nsHTMLAtoms.h"
#include "nsHTMLIIDs.h"
#include "nsIStyleContext.h"
#include "nsIMutableStyleContext.h"
#include "nsStyleConsts.h"
#include "nsIPresContext.h"
#include "nsIDocument.h"
#include "nsIPresShell.h"
#include "nsIFrame.h"
#include "nsIServiceManager.h"
#include "nsIJVMManager.h"
#include "nsILiveConnectManager.h"
#include "nsIPluginInstance.h"
#include "nsIJVMPluginInstance.h"
// XXX this is to get around conflicts with windows.h defines
// introduced through jni.h
#ifdef XP_PC
#undef GetClassName
#undef GetObject
#endif
static NS_DEFINE_IID(kIDOMHTMLAppletElementIID, NS_IDOMHTMLAPPLETELEMENT_IID);
class nsHTMLAppletElement : public nsIDOMHTMLAppletElement,
public nsIScriptObjectOwner,
public nsIDOMEventReceiver,
public nsIHTMLContent
{
public:
nsHTMLAppletElement(nsIAtom* aTag);
virtual ~nsHTMLAppletElement();
// nsISupports
NS_DECL_ISUPPORTS
// nsIDOMNode
NS_IMPL_IDOMNODE_USING_GENERIC(mInner)
// nsIDOMElement
NS_IMPL_IDOMELEMENT_USING_GENERIC(mInner)
// nsIDOMHTMLElement
NS_IMPL_IDOMHTMLELEMENT_USING_GENERIC(mInner)
// nsIDOMHTMLAppletElement
NS_IMETHOD GetAlign(nsString& aAlign);
NS_IMETHOD SetAlign(const nsString& aAlign);
NS_IMETHOD GetAlt(nsString& aAlt);
NS_IMETHOD SetAlt(const nsString& aAlt);
NS_IMETHOD GetArchive(nsString& aArchive);
NS_IMETHOD SetArchive(const nsString& aArchive);
NS_IMETHOD GetCode(nsString& aCode);
NS_IMETHOD SetCode(const nsString& aCode);
NS_IMETHOD GetCodeBase(nsString& aCodeBase);
NS_IMETHOD SetCodeBase(const nsString& aCodeBase);
NS_IMETHOD GetHeight(nsString& aHeight);
NS_IMETHOD SetHeight(const nsString& aHeight);
NS_IMETHOD GetHspace(nsString& aHspace);
NS_IMETHOD SetHspace(const nsString& aHspace);
NS_IMETHOD GetName(nsString& aName);
NS_IMETHOD SetName(const nsString& aName);
NS_IMETHOD GetObject(nsString& aObject);
NS_IMETHOD SetObject(const nsString& aObject);
NS_IMETHOD GetVspace(nsString& aVspace);
NS_IMETHOD SetVspace(const nsString& aVspace);
NS_IMETHOD GetWidth(nsString& aWidth);
NS_IMETHOD SetWidth(const nsString& aWidth);
// nsIScriptObjectOwner
NS_IMETHOD GetScriptObject(nsIScriptContext* aContext,
void** aScriptObject);
NS_IMETHOD SetScriptObject(void *aScriptObject);
// nsIDOMEventReceiver
NS_IMPL_IDOMEVENTRECEIVER_USING_GENERIC(mInner)
// nsIContent
NS_IMPL_ICONTENT_USING_GENERIC(mInner)
// nsIHTMLContent
NS_IMPL_IHTMLCONTENT_USING_GENERIC(mInner)
protected:
nsGenericHTMLContainerElement mInner;
PRBool mReflectedApplet;
};
nsresult
NS_NewHTMLAppletElement(nsIHTMLContent** aInstancePtrResult, nsIAtom* aTag)
{
NS_PRECONDITION(nsnull != aInstancePtrResult, "null ptr");
if (nsnull == aInstancePtrResult) {
return NS_ERROR_NULL_POINTER;
}
nsIHTMLContent* it = new nsHTMLAppletElement(aTag);
if (nsnull == it) {
return NS_ERROR_OUT_OF_MEMORY;
}
return it->QueryInterface(kIHTMLContentIID, (void**) aInstancePtrResult);
}
nsHTMLAppletElement::nsHTMLAppletElement(nsIAtom* aTag)
{
NS_INIT_REFCNT();
mInner.Init(this, aTag);
mReflectedApplet = PR_FALSE;
}
nsHTMLAppletElement::~nsHTMLAppletElement()
{
}
NS_IMPL_ADDREF(nsHTMLAppletElement)
NS_IMPL_RELEASE(nsHTMLAppletElement)
nsresult
nsHTMLAppletElement::QueryInterface(REFNSIID aIID, void** aInstancePtr)
{
NS_IMPL_HTML_CONTENT_QUERY_INTERFACE(aIID, aInstancePtr, this)
if (aIID.Equals(kIDOMHTMLAppletElementIID)) {
nsIDOMHTMLAppletElement* tmp = this;
*aInstancePtr = (void*) tmp;
NS_ADDREF_THIS();
return NS_OK;
}
return NS_NOINTERFACE;
}
nsresult
nsHTMLAppletElement::CloneNode(PRBool aDeep, nsIDOMNode** aReturn)
{
nsHTMLAppletElement* it = new nsHTMLAppletElement(mInner.mTag);
if (nsnull == it) {
return NS_ERROR_OUT_OF_MEMORY;
}
mInner.CopyInnerTo(this, &it->mInner, aDeep);
return it->QueryInterface(kIDOMNodeIID, (void**) aReturn);
}
NS_IMPL_STRING_ATTR(nsHTMLAppletElement, Align, align)
NS_IMPL_STRING_ATTR(nsHTMLAppletElement, Alt, alt)
NS_IMPL_STRING_ATTR(nsHTMLAppletElement, Archive, archive)
NS_IMPL_STRING_ATTR(nsHTMLAppletElement, Code, code)
NS_IMPL_STRING_ATTR(nsHTMLAppletElement, CodeBase, codebase)
NS_IMPL_STRING_ATTR(nsHTMLAppletElement, Height, height)
NS_IMPL_STRING_ATTR(nsHTMLAppletElement, Hspace, hspace)
NS_IMPL_STRING_ATTR(nsHTMLAppletElement, Name, name)
NS_IMPL_STRING_ATTR(nsHTMLAppletElement, Object, object)
NS_IMPL_STRING_ATTR(nsHTMLAppletElement, Vspace, vspace)
NS_IMPL_STRING_ATTR(nsHTMLAppletElement, Width, width)
NS_IMETHODIMP
nsHTMLAppletElement::StringToAttribute(nsIAtom* aAttribute,
const nsString& aValue,
nsHTMLValue& aResult)
{
if (aAttribute == nsHTMLAtoms::align) {
if (nsGenericHTMLElement::ParseAlignValue(aValue, aResult)) {
return NS_CONTENT_ATTR_HAS_VALUE;
}
}
else if (nsGenericHTMLElement::ParseImageAttribute(aAttribute,
aValue, aResult)) {
return NS_CONTENT_ATTR_HAS_VALUE;
}
return NS_CONTENT_ATTR_NOT_THERE;
}
NS_IMETHODIMP
nsHTMLAppletElement::AttributeToString(nsIAtom* aAttribute,
const nsHTMLValue& aValue,
nsString& aResult) const
{
if (aAttribute == nsHTMLAtoms::align) {
if (eHTMLUnit_Enumerated == aValue.GetUnit()) {
nsGenericHTMLElement::AlignValueToString(aValue, aResult);
return NS_CONTENT_ATTR_HAS_VALUE;
}
}
else if (nsGenericHTMLElement::ImageAttributeToString(aAttribute,
aValue, aResult)) {
return NS_CONTENT_ATTR_HAS_VALUE;
}
return mInner.AttributeToString(aAttribute, aValue, aResult);
}
static void
MapAttributesInto(const nsIHTMLMappedAttributes* aAttributes,
nsIMutableStyleContext* aContext,
nsIPresContext* aPresContext)
{
nsGenericHTMLElement::MapCommonAttributesInto(aAttributes, aContext, aPresContext);
nsGenericHTMLElement::MapImageAttributesInto(aAttributes, aContext, aPresContext);
nsGenericHTMLElement::MapImageAlignAttributeInto(aAttributes, aContext, aPresContext);
nsGenericHTMLElement::MapImageBorderAttributeInto(aAttributes, aContext, aPresContext, nsnull);
}
NS_IMETHODIMP
nsHTMLAppletElement::GetMappedAttributeImpact(const nsIAtom* aAttribute,
PRInt32& aHint) const
{
if (! nsGenericHTMLElement::GetCommonMappedAttributesImpact(aAttribute, aHint)) {
if (! nsGenericHTMLElement::GetImageMappedAttributesImpact(aAttribute, aHint)) {
if (! nsGenericHTMLElement::GetImageAlignAttributeImpact(aAttribute, aHint)) {
if (! nsGenericHTMLElement::GetImageBorderAttributeImpact(aAttribute, aHint)) {
aHint = NS_STYLE_HINT_CONTENT;
}
}
}
}
return NS_OK;
}
NS_IMETHODIMP
nsHTMLAppletElement::GetAttributeMappingFunctions(nsMapAttributesFunc& aFontMapFunc,
nsMapAttributesFunc& aMapFunc) const
{
aFontMapFunc = nsnull;
aMapFunc = &MapAttributesInto;
return NS_OK;
}
NS_IMETHODIMP
nsHTMLAppletElement::HandleDOMEvent(nsIPresContext* aPresContext,
nsEvent* aEvent,
nsIDOMEvent** aDOMEvent,
PRUint32 aFlags,
nsEventStatus* aEventStatus)
{
return mInner.HandleDOMEvent(aPresContext, aEvent, aDOMEvent,
aFlags, aEventStatus);
}
extern nsresult NS_GetObjectFramePluginInstance(nsIFrame* aFrame, nsIPluginInstance*& aPluginInstance);
/**
* For backwards compatibility an applet element's JavaScript object should expose both the public
* fields of the applet, and the attributes of the applet tag. The call to nsGenericElement::GetScriptObject
* takes case of the tag attributes. Here we generate a JavaScript reference to the applet object itself,
* and set its __proto__ property to the tag object. That way, if the Java applet has public fields that
* shadow the tag attributes, the applet's fields take precedence.
*/
NS_IMETHODIMP
nsHTMLAppletElement::GetScriptObject(nsIScriptContext* aContext,
void** aScriptObject)
{
nsresult rv = NS_OK;
NS_WITH_SERVICE(nsIJVMManager, jvm, nsIJVMManager::GetCID(), &rv);
if (NS_SUCCEEDED(rv)) {
// nsresult rv = NS_OK;
if (!mReflectedApplet) {
// 1. get the script object corresponding to the <APPLET> element itself.
JSObject* elementObject = nsnull;
rv = mInner.GetScriptObject(aContext, (void**)&elementObject);
if (NS_OK != rv)
return rv;
// 2. get the plugin instance corresponding to this element.
nsIPresShell* shell = mInner.mDocument->GetShellAt(0);
if (nsnull == shell)
return NS_ERROR_FAILURE;
nsIFrame* frame = nsnull;
shell->GetPrimaryFrameFor(mInner.mContent, &frame);
NS_RELEASE(shell);
// 3. get the Java object corresponding to this applet, and reflect it into
// JavaScript using the LiveConnect manager.
JSContext* context = (JSContext*)aContext->GetNativeContext();
JSObject* wrappedAppletObject = nsnull;
nsIPluginInstance* pluginInstance = nsnull;
rv = NS_GetObjectFramePluginInstance(frame, pluginInstance);
if ((rv == NS_OK) && (nsnull != pluginInstance)) {
nsIJVMPluginInstance* javaPluginInstance = nsnull;
if (pluginInstance->QueryInterface(nsIJVMPluginInstance::GetIID(), (void**)&javaPluginInstance) == NS_OK) {
jobject appletObject = nsnull;
rv = javaPluginInstance->GetJavaObject(&appletObject);
if (NS_OK == rv) {
nsILiveConnectManager* manager = NULL;
rv = nsServiceManager::GetService(nsIJVMManager::GetCID(),
nsILiveConnectManager::GetIID(),
(nsISupports **)&manager);
if (rv == NS_OK) {
rv = manager->WrapJavaObject(context, appletObject, &wrappedAppletObject);
nsServiceManager::ReleaseService(nsIJVMManager::GetCID(), manager);
}
}
NS_RELEASE(javaPluginInstance);
}
NS_RELEASE(pluginInstance);
}
// 4. set the __proto__ field of the applet object to be the element script object.
if (nsnull != wrappedAppletObject) {
JS_SetPrototype(context, wrappedAppletObject, elementObject);
mInner.SetScriptObject(wrappedAppletObject);
mReflectedApplet = PR_TRUE;
}
*aScriptObject = wrappedAppletObject;
} else {
rv = mInner.GetScriptObject(aContext, aScriptObject);
}
return rv;
}
else
return mInner.GetScriptObject(aContext, aScriptObject);
}
// TODO: if this method ever gets called, it will destroy the prototype type chain.
NS_IMETHODIMP
nsHTMLAppletElement::SetScriptObject(void *aScriptObject)
{
return mInner.SetScriptObject(aScriptObject);
}
NS_IMETHODIMP
nsHTMLAppletElement::SizeOf(nsISizeOfHandler* aSizer, PRUint32* aResult) const
{
return mInner.SizeOf(aSizer, aResult, sizeof(*this));
}
Reference in New Issue View Git Blame Copy Permalink