nagai/fune
3
0
Fork 0
forked from mirrors/gecko-dev
Code Pull requests Activity
fune/embedding/browser/webBrowser/nsContextMenuInfo.cpp

563 lines
18 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 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 the Mozilla browser.
*
* The Initial Developer of the Original Code is Netscape
* Communications, Inc. Portions created by Netscape are
* Copyright (C) 1999, Mozilla. All Rights Reserved.
*
* Contributor(s):
* Chris Saari <saari@netscape.com>
* Conrad Carlen <ccarlen@netscape.com>
*/
#include "nsContextMenuInfo.h"
#include "nsIDocument.h"
#include "nsIFrame.h"
#include "nsIImageFrame.h"
#include "imgIRequest.h"
#include "nsIStyleContext.h"
#include "nsICanvasFrame.h"
#include "nsIDOMHTMLDocument.h"
#include "nsIDOMHTMLElement.h"
#include "nsIDOMHTMLAnchorElement.h"
#include "nsIDOMHTMLImageElement.h"
#include "nsIDOMHTMLAreaElement.h"
#include "nsIDOMHTMLLinkElement.h"
#include "nsNetUtil.h"
//*****************************************************************************
// class nsContextMenuInfo
//*****************************************************************************
NS_IMPL_ISUPPORTS1(nsContextMenuInfo, nsIContextMenuInfo)
nsContextMenuInfo::nsContextMenuInfo() :
mCachedBGImageRequestNode(nsnull)
{
}
nsContextMenuInfo::~nsContextMenuInfo()
{
}
/* readonly attribute nsIDOMEvent mouseEvent; */
NS_IMETHODIMP nsContextMenuInfo::GetMouseEvent(nsIDOMEvent **aEvent)
{
NS_ENSURE_ARG_POINTER(aEvent);
NS_IF_ADDREF(*aEvent = mMouseEvent);
return NS_OK;
}
/* readonly attribute nsIDOMNode targetNode; */
NS_IMETHODIMP nsContextMenuInfo::GetTargetNode(nsIDOMNode **aNode)
{
NS_ENSURE_ARG_POINTER(aNode);
NS_IF_ADDREF(*aNode = mDOMNode);
return NS_OK;
}
/* readonly attribute AString associatedLink; */
NS_IMETHODIMP
nsContextMenuInfo::GetAssociatedLink(nsAString& aHRef)
{
NS_ENSURE_STATE(mAssociatedLink);
aHRef.Truncate(0);
nsCOMPtr<nsIDOMElement> content(do_QueryInterface(mAssociatedLink));
nsAutoString localName;
if (content)
content->GetLocalName(localName);
nsCOMPtr<nsIDOMElement> linkContent;
ToLowerCase(localName);
if (localName.Equals(NS_LITERAL_STRING("a")) ||
localName.Equals(NS_LITERAL_STRING("area")) ||
localName.Equals(NS_LITERAL_STRING("link"))) {
PRBool hasAttr;
content->HasAttribute(NS_LITERAL_STRING("href"), &hasAttr);
if (hasAttr) {
linkContent = content;
nsCOMPtr<nsIDOMHTMLAnchorElement> anchor(do_QueryInterface(linkContent));
if (anchor)
anchor->GetHref(aHRef);
else {
nsCOMPtr<nsIDOMHTMLAreaElement> area(do_QueryInterface(linkContent));
if (area)
area->GetHref(aHRef);
else {
nsCOMPtr<nsIDOMHTMLLinkElement> link(do_QueryInterface(linkContent));
if (link)
link->GetHref(aHRef);
}
}
}
}
else {
nsCOMPtr<nsIDOMNode> curr;
mAssociatedLink->GetParentNode(getter_AddRefs(curr));
while (curr) {
content = do_QueryInterface(curr);
if (!content)
break;
content->GetLocalName(localName);
ToLowerCase(localName);
if (localName.Equals(NS_LITERAL_STRING("a"))) {
PRBool hasAttr;
content->HasAttribute(NS_LITERAL_STRING("href"), &hasAttr);
if (hasAttr) {
linkContent = content;
nsCOMPtr<nsIDOMHTMLAnchorElement> anchor(do_QueryInterface(linkContent));
if (anchor)
anchor->GetHref(aHRef);
}
else
linkContent = nsnull; // Links can't be nested.
break;
}
nsCOMPtr<nsIDOMNode> temp = curr;
temp->GetParentNode(getter_AddRefs(curr));
}
}
return NS_OK;
}
/* readonly attribute imgIContainer imageContainer; */
NS_IMETHODIMP nsContextMenuInfo::GetImageContainer(imgIContainer **aImageContainer)
{
NS_ENSURE_ARG_POINTER(aImageContainer);
NS_ENSURE_STATE(mDOMNode);
nsCOMPtr<imgIRequest> request;
GetImageRequest(mDOMNode, getter_AddRefs(request));
if (request)
return request->GetImage(aImageContainer);
return NS_ERROR_FAILURE;
}
/* readonly attribute nsIURI imageSrc; */
NS_IMETHODIMP nsContextMenuInfo::GetImageSrc(nsIURI **aURI)
{
NS_ENSURE_ARG_POINTER(aURI);
NS_ENSURE_STATE(mDOMNode);
// First try the easy case of our node being a nsIDOMHTMLImageElement
nsCOMPtr<nsIDOMHTMLImageElement> imgElement(do_QueryInterface(mDOMNode));
if (imgElement) {
nsAutoString imgSrcSpec;
nsresult rv = imgElement->GetSrc(imgSrcSpec);
if (NS_SUCCEEDED(rv))
return NS_NewURI(aURI, NS_ConvertUCS2toUTF8(imgSrcSpec));
}
// If not, dig deeper.
nsCOMPtr<imgIRequest> request;
GetImageRequest(mDOMNode, getter_AddRefs(request));
if (request)
return request->GetURI(aURI);
return NS_ERROR_FAILURE;
}
/* readonly attribute imgIContainer backgroundImageContainer; */
NS_IMETHODIMP
nsContextMenuInfo::GetBackgroundImageContainer(imgIContainer **aImageContainer)
{
NS_ENSURE_ARG_POINTER(aImageContainer);
NS_ENSURE_STATE(mDOMNode);
nsCOMPtr<imgIRequest> request;
GetBackgroundImageRequest(mDOMNode, getter_AddRefs(request));
if (request)
return request->GetImage(aImageContainer);
return NS_ERROR_FAILURE;
}
/* readonly attribute nsIURI backgroundImageSrc; */
NS_IMETHODIMP
nsContextMenuInfo::GetBackgroundImageSrc(nsIURI **aURI)
{
NS_ENSURE_ARG_POINTER(aURI);
NS_ENSURE_STATE(mDOMNode);
nsCOMPtr<imgIRequest> request;
GetBackgroundImageRequest(mDOMNode, getter_AddRefs(request));
if (request)
return request->GetURI(aURI);
return NS_ERROR_FAILURE;
}
//*****************************************************************************
nsresult
nsContextMenuInfo::GetImageRequest(nsIDOMNode * aDOMNode, imgIRequest ** aRequest)
{
NS_ENSURE_ARG(aDOMNode);
NS_ENSURE_ARG_POINTER(aRequest);
// Get content
nsCOMPtr<nsIContent> content = do_QueryInterface(aDOMNode);
NS_ENSURE_TRUE(content, NS_ERROR_FAILURE);
// Get Document
nsCOMPtr<nsIDocument> document;
content->GetDocument(*getter_AddRefs(document));
NS_ENSURE_TRUE(document, NS_ERROR_FAILURE);
// Get shell
nsCOMPtr<nsIPresShell> presShell;
document->GetShellAt(0, getter_AddRefs(presShell));
NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);
// Get PresContext
nsCOMPtr<nsIPresContext> presContext;
presShell->GetPresContext(getter_AddRefs(presContext));
NS_ENSURE_TRUE(presContext, NS_ERROR_FAILURE);
nsIFrame *frame = nsnull;
presShell->GetPrimaryFrameFor(content, &frame); // does not AddRef
NS_ENSURE_TRUE(frame, NS_ERROR_FAILURE);
nsIImageFrame *imgFrame = nsnull;
frame->QueryInterface(NS_GET_IID(nsIImageFrame), (void **)&imgFrame); // does not AddRef
NS_ENSURE_TRUE(imgFrame, NS_ERROR_FAILURE);
return imgFrame->GetImageRequest(aRequest);
}
PRBool
nsContextMenuInfo::HasBackgroundImage(nsIDOMNode * aDOMNode)
{
NS_ENSURE_ARG(aDOMNode);
nsCOMPtr<imgIRequest> request;
GetBackgroundImageRequest(aDOMNode, getter_AddRefs(request));
return (request != nsnull);
}
nsresult
nsContextMenuInfo::GetBackgroundImageRequest(nsIDOMNode * aDOMNode, imgIRequest ** aRequest)
{
nsresult rv = NS_ERROR_FAILURE;
NS_ENSURE_ARG(aDOMNode);
NS_ENSURE_ARG_POINTER(aRequest);
if (mCachedBGImageRequest && (aDOMNode == mCachedBGImageRequestNode)) {
*aRequest = mCachedBGImageRequest;
NS_ADDREF(*aRequest);
return NS_OK;
}
// Get content
nsCOMPtr<nsIContent> content = do_QueryInterface(aDOMNode);
NS_ENSURE_TRUE(content, NS_ERROR_FAILURE);
// Get Document
nsCOMPtr<nsIDocument> document;
content->GetDocument(*getter_AddRefs(document));
NS_ENSURE_TRUE(document, NS_ERROR_FAILURE);
// Get shell
nsCOMPtr<nsIPresShell> presShell;
document->GetShellAt(0, getter_AddRefs(presShell));
NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);
// Get PresContext
nsCOMPtr<nsIPresContext> presContext;
presShell->GetPresContext(getter_AddRefs(presContext));
NS_ENSURE_TRUE(presContext, NS_ERROR_FAILURE);
const nsStyleBackground* bg;
nsIFrame* frame = nsnull;
rv = presShell->GetPrimaryFrameFor(content, &frame);
if (NS_SUCCEEDED(rv) && frame)
{
// look for a background image on the element
nsCOMPtr<nsIStyleContext> styleContext;
rv = presShell->GetStyleContextFor(frame, getter_AddRefs(styleContext));
if (NS_FAILED(rv) || !styleContext) return rv;
do {
bg = (const nsStyleBackground*)
styleContext->GetStyleData(eStyleStruct_Background);
styleContext = dont_AddRef(styleContext->GetParent());
} while (bg && bg->mBackgroundImage.IsEmpty() && styleContext.get());
if (bg && !bg->mBackgroundImage.IsEmpty())
{
nsIFrame *pBGFrame = nsnull;
rv = GetFrameForBackgroundUpdate(presContext, frame, &pBGFrame);
if (NS_SUCCEEDED(rv) && pBGFrame)
{
// Lookup the background image
mCachedBGImageRequestNode = aDOMNode;
rv = presContext->LoadImage(bg->mBackgroundImage, pBGFrame, getter_AddRefs(mCachedBGImageRequest));
*aRequest = mCachedBGImageRequest;
NS_IF_ADDREF(*aRequest);
return rv;
}
}
} // if (NS_SUCCEEDED(rv) && frame)
// nothing on the element or its parent style contexts, fall back to canvas frame for the whole page
rv = NS_ERROR_FAILURE;
nsCOMPtr<nsIContent> rootContent;
document->GetRootContent(getter_AddRefs(rootContent));
NS_ENSURE_TRUE(rootContent, NS_ERROR_FAILURE);
presShell->GetPrimaryFrameFor(rootContent, &frame);
NS_ENSURE_TRUE(frame, NS_ERROR_FAILURE);
frame->GetParent(&frame);
NS_ENSURE_TRUE(frame, NS_ERROR_FAILURE);
nsICanvasFrame* canvasFrame;
if (NS_SUCCEEDED(frame->QueryInterface(NS_GET_IID(nsICanvasFrame), (void**)&canvasFrame))) {
PRBool isCanvas;
FindBackground(presContext, frame, &bg, &isCanvas);
if (bg && !bg->mBackgroundImage.IsEmpty())
{
nsIFrame *pBGFrame = nsnull;
rv = GetFrameForBackgroundUpdate(presContext, frame, &pBGFrame);
if (NS_SUCCEEDED(rv) && pBGFrame)
{
// Lookup the background image
mCachedBGImageRequestNode = aDOMNode;
rv = presContext->LoadImage(bg->mBackgroundImage, pBGFrame, getter_AddRefs(mCachedBGImageRequest));
*aRequest = mCachedBGImageRequest;
NS_IF_ADDREF(*aRequest);
return rv;
}
}
}
return rv;
}
////////
// Everything following this is copied from nsCSSRendering.cpp. The methods were not publically available,
// Perhaps there is a better, pubically supported way to get the same thing done?
////////
// nethod GetFrameForBackgroundUpdate
//
// If the frame (aFrame) is the HTML or BODY frame then find the canvas frame and set the
// aBGFrame param to that. This is used when we need a frame to invalidate after an asynch
// image load for the background.
//
// The check is a bit expensive, however until the canvas frame is somehow cached on the
// body frame, or the root element, we need to walk the frames up until we find the canvas
//
nsresult nsContextMenuInfo::GetFrameForBackgroundUpdate(nsIPresContext *aPresContext,nsIFrame *aFrame, nsIFrame **aBGFrame)
{
NS_ASSERTION(aFrame && aBGFrame, "illegal null parameter");
nsresult rv = NS_OK;
if (aFrame && aBGFrame) {
*aBGFrame = aFrame; // default to the frame passed in
nsCOMPtr<nsIContent> pContent;
aFrame->GetContent(getter_AddRefs(pContent));
if (pContent) {
// make sure that this is the HTML or BODY element
nsCOMPtr<nsIAtom> tag;
pContent->GetTag(*(getter_AddRefs(tag)));
nsCOMPtr<nsIAtom> mTag_html = getter_AddRefs(NS_NewAtom("html"));
nsCOMPtr<nsIAtom> mTag_body = getter_AddRefs(NS_NewAtom("body"));
if (tag &&
tag.get() == mTag_html ||
tag.get() == mTag_body) {
// the frame is the body frame, so we provide the canvas frame
nsIFrame *pCanvasFrame = nsnull;
aFrame->GetParent(&pCanvasFrame);
while (pCanvasFrame) {
nsCOMPtr<nsIAtom> parentType;
pCanvasFrame->GetFrameType(getter_AddRefs(parentType));
nsCOMPtr<nsIAtom> mTag_canvasFrame = getter_AddRefs(NS_NewAtom("CanvasFrame"));
if (parentType.get() == mTag_canvasFrame) {
*aBGFrame = pCanvasFrame;
break;
}
pCanvasFrame->GetParent(&pCanvasFrame);
}
}// if tag == html or body
}
} else {
rv = NS_ERROR_NULL_POINTER;
}
return rv;
}
inline PRBool
nsContextMenuInfo::FindCanvasBackground(nsIPresContext* aPresContext,
nsIFrame* aForFrame,
const nsStyleBackground** aBackground)
{
// XXXldb What if the root element is positioned, etc.? (We don't
// allow that yet, do we?)
nsIFrame *firstChild;
aForFrame->FirstChild(aPresContext, nsnull, &firstChild);
if (firstChild) {
const nsStyleBackground *result;
GetStyleData(firstChild, &result);
// for printing and print preview.. this should be a pageContentFrame
nsCOMPtr<nsIAtom> frameType;
nsCOMPtr<nsIStyleContext> parentContext;
firstChild->GetFrameType(getter_AddRefs(frameType));
nsCOMPtr<nsIAtom> mTag_pageContentFrame = getter_AddRefs(NS_NewAtom("PageContentFrame"));
if ( (frameType == mTag_pageContentFrame) ){
// we have to find the background style ourselves.. since the
// pageContentframe does not have content
while(firstChild){
for (nsIFrame* kidFrame = firstChild; nsnull != kidFrame; ) {
kidFrame->GetStyleContext(getter_AddRefs(parentContext));
result = (nsStyleBackground*)parentContext->GetStyleData(eStyleStruct_Background);
if (!result->BackgroundIsTransparent()){
GetStyleData(kidFrame, aBackground);
return PR_TRUE;
} else {
kidFrame->GetNextSibling(&kidFrame);
}
}
firstChild->FirstChild(aPresContext, nsnull, &firstChild);
}
return PR_FALSE; // nothing found for this
}
// Check if we need to do propagation from BODY rather than HTML.
if (result->BackgroundIsTransparent()) {
nsCOMPtr<nsIContent> content;
aForFrame->GetContent(getter_AddRefs(content));
if (content) {
nsCOMPtr<nsIDOMNode> node( do_QueryInterface(content) );
// Use |GetOwnerDocument| so it works during destruction.
nsCOMPtr<nsIDOMDocument> doc;
node->GetOwnerDocument(getter_AddRefs(doc));
nsCOMPtr<nsIDOMHTMLDocument> htmlDoc = do_QueryInterface(doc);
if (htmlDoc) {
nsCOMPtr<nsIDOMHTMLElement> body;
htmlDoc->GetBody(getter_AddRefs(body));
nsCOMPtr<nsIContent> bodyContent = do_QueryInterface(body);
// We need to null check the body node (bug 118829) since
// there are cases, thanks to the fix for bug 5569, where we
// will reflow a document with no body. In particular, if a
// SCRIPT element in the head blocks the parser and then has a
// SCRIPT that does "document.location.href = 'foo'", then
// nsParser::Terminate will call |DidBuildModel| methods
// through to the content sink, which will call |StartLayout|
// and thus |InitialReflow| on the pres shell. See bug 119351
// for the ugly details.
if (bodyContent) {
nsCOMPtr<nsIPresShell> shell;
aPresContext->GetShell(getter_AddRefs(shell));
nsIFrame *bodyFrame;
nsresult rv = shell->GetPrimaryFrameFor(bodyContent, &bodyFrame);
if (NS_SUCCEEDED(rv) && bodyFrame)
::GetStyleData(bodyFrame, &result);
}
}
}
}
*aBackground = result;
} else {
// This should always give transparent, so we'll fill it in with the
// default color if needed. This seems to happen a bit while a page is
// being loaded.
GetStyleData(aForFrame, aBackground);
}
return PR_TRUE;
}
inline PRBool
nsContextMenuInfo::FindElementBackground(nsIPresContext* aPresContext,
nsIFrame* aForFrame,
const nsStyleBackground** aBackground)
{
nsIFrame *parentFrame;
aForFrame->GetParent(&parentFrame);
// XXXldb We shouldn't have to null-check |parentFrame| here.
if (parentFrame && IsCanvasFrame(parentFrame)) {
// Check that we're really the root (rather than in another child list).
nsIFrame *childFrame;
parentFrame->FirstChild(aPresContext, nsnull, &childFrame);
if (childFrame == aForFrame)
return PR_FALSE; // Background was already drawn for the canvas.
}
::GetStyleData(aForFrame, aBackground);
nsCOMPtr<nsIContent> content;
aForFrame->GetContent(getter_AddRefs(content));
if (!content || !content->IsContentOfType(nsIContent::eHTML))
return PR_TRUE; // not frame for an HTML element
if (!parentFrame)
return PR_TRUE; // no parent to look at
nsCOMPtr<nsIAtom> tag;
content->GetTag(*getter_AddRefs(tag));
nsCOMPtr<nsIAtom> mTag_body = getter_AddRefs(NS_NewAtom("body"));
if (tag != mTag_body)
return PR_TRUE; // not frame for <BODY> element
// We should only look at the <html> background if we're in an HTML document
nsCOMPtr<nsIDOMNode> node(do_QueryInterface(content));
nsCOMPtr<nsIDOMDocument> doc;
node->GetOwnerDocument(getter_AddRefs(doc));
nsCOMPtr<nsIDOMHTMLDocument> htmlDoc(do_QueryInterface(doc));
if (!htmlDoc)
return PR_TRUE;
const nsStyleBackground *htmlBG;
::GetStyleData(parentFrame, &htmlBG);
return !htmlBG->BackgroundIsTransparent();
}
PRBool
nsContextMenuInfo::IsCanvasFrame(nsIFrame *aFrame)
{
nsCOMPtr<nsIAtom> mTag_canvasFrame = getter_AddRefs(NS_NewAtom("CanvasFrame"));
nsCOMPtr<nsIAtom> mTag_rootFrame = getter_AddRefs(NS_NewAtom("RootFrame"));
nsCOMPtr<nsIAtom> mTag_pageFrame = getter_AddRefs(NS_NewAtom("PageFrame"));
nsCOMPtr<nsIAtom> frameType;
aFrame->GetFrameType(getter_AddRefs(frameType));
return (frameType == mTag_canvasFrame ||
frameType == mTag_rootFrame ||
frameType == mTag_pageFrame);
}
PRBool
nsContextMenuInfo::FindBackground(nsIPresContext* aPresContext,
nsIFrame* aForFrame,
const nsStyleBackground** aBackground,
PRBool* aIsCanvas)
{
*aIsCanvas = PR_TRUE;
return FindCanvasBackground(aPresContext, aForFrame, aBackground);
}
View git blame Copy permalink