2005-01-30 02:53:32 +03:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
|
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
|
|
|
*
|
|
|
|
* 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 XForms support.
|
|
|
|
*
|
|
|
|
* The Initial Developer of the Original Code is
|
|
|
|
* Olli Pettay.
|
|
|
|
* Portions created by the Initial Developer are Copyright (C) 2004
|
|
|
|
* the Initial Developer. All Rights Reserved.
|
|
|
|
*
|
|
|
|
* Contributor(s):
|
|
|
|
* Olli Pettay <Olli.Pettay@helsinki.fi> (original author)
|
|
|
|
*
|
|
|
|
* 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 ***** */
|
|
|
|
|
|
|
|
#include "nsXFormsAtoms.h"
|
|
|
|
#include "nsXFormsStubElement.h"
|
|
|
|
#include "nsXFormsActionElement.h"
|
|
|
|
#include "nsIXFormsActionModuleElement.h"
|
|
|
|
|
|
|
|
#include "nsIXTFXMLVisual.h"
|
|
|
|
#include "nsIXTFXMLVisualWrapper.h"
|
|
|
|
|
2005-06-26 22:30:17 +04:00
|
|
|
#include "nsIDOMText.h"
|
2005-01-30 02:53:32 +03:00
|
|
|
#include "nsIDOM3Node.h"
|
|
|
|
#include "nsIDOMElement.h"
|
|
|
|
#include "nsIDOMNodeList.h"
|
|
|
|
#include "nsIDOMDocument.h"
|
|
|
|
#include "nsIDOMNSDocument.h"
|
|
|
|
#include "nsIDOMDocumentView.h"
|
|
|
|
#include "nsIDOMAbstractView.h"
|
|
|
|
#include "nsIDOMHTMLDocument.h"
|
|
|
|
#include "nsIDOMWindowInternal.h"
|
|
|
|
#include "nsIDOMDOMImplementation.h"
|
|
|
|
|
|
|
|
#include "nsIDOMEvent.h"
|
|
|
|
#include "nsIDOMMouseEvent.h"
|
|
|
|
#include "nsIDOMEventTarget.h"
|
|
|
|
#include "nsIDOMEventListener.h"
|
|
|
|
|
|
|
|
#include "nsIDOMViewCSS.h"
|
|
|
|
#include "nsIDOMCSSValue.h"
|
|
|
|
#include "nsIDOMCSSPrimitiveValue.h"
|
|
|
|
#include "nsIDOMCSSStyleDeclaration.h"
|
|
|
|
|
|
|
|
#include "nsITimer.h"
|
|
|
|
#include "nsIDocument.h"
|
|
|
|
#include "nsIBoxObject.h"
|
|
|
|
#include "nsIServiceManager.h"
|
|
|
|
|
|
|
|
#include "prmem.h"
|
|
|
|
#include "plbase64.h"
|
|
|
|
#include "nsAutoPtr.h"
|
|
|
|
#include "nsIStringBundle.h"
|
|
|
|
#include "nsIDOMSerializer.h"
|
|
|
|
#include "nsIServiceManager.h"
|
2005-11-05 19:11:42 +03:00
|
|
|
#include "nsIDelegateInternal.h"
|
2005-01-30 02:53:32 +03:00
|
|
|
|
|
|
|
#define EPHEMERAL_STYLE \
|
|
|
|
"position:absolute;z-index:2147483647; \
|
|
|
|
background:inherit;color:inherit; \
|
|
|
|
border:inherit;visibility:visible;"
|
|
|
|
|
|
|
|
#define EPHEMERAL_STYLE_HIDDEN \
|
|
|
|
"position:absolute;z-index:2147483647;visibility:hidden;"
|
|
|
|
|
|
|
|
#define MESSAGE_WINDOW_PROPERTIES \
|
2005-02-23 23:35:04 +03:00
|
|
|
"location=false,scrollbars=yes,centerscreen"
|
2005-01-30 02:53:32 +03:00
|
|
|
|
|
|
|
|
|
|
|
// Defining a simple dialog for modeless and modal messages.
|
|
|
|
|
|
|
|
#define MESSAGE_WINDOW_UI_PART1 \
|
|
|
|
"<?xml version='1.0'?> \
|
|
|
|
<?xml-stylesheet href='chrome://global/skin/' type='text/css'?> \
|
|
|
|
<window title='[XForms]'\
|
|
|
|
xmlns='http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul' \
|
2005-11-15 20:22:15 +03:00
|
|
|
onkeypress='if (event.keyCode == event.DOM_VK_ESCAPE) window.close();' \
|
2005-01-30 02:53:32 +03:00
|
|
|
onload='document.documentElement.lastChild.previousSibling \
|
|
|
|
.firstChild.nextSibling.focus();'>"
|
|
|
|
|
|
|
|
#define MESSAGE_WINDOW_UI_PART2 \
|
|
|
|
"<separator class='thin'/><hbox><spacer flex='1'/><button label='"
|
|
|
|
|
|
|
|
#define MESSAGE_WINDOW_UI_PART3 \
|
|
|
|
"' oncommand='window.close();'/><spacer flex='1'/> \
|
|
|
|
</hbox><separator class='thin'/></window>"
|
|
|
|
|
|
|
|
#define SHOW_EPHEMERAL_TIMEOUT 750
|
|
|
|
#define HIDE_EPHEMERAL_TIMEOUT 5000
|
|
|
|
#define EPHEMERAL_POSITION_RESET_TIMEOUT 100
|
|
|
|
|
|
|
|
class nsXFormsEventListener;
|
|
|
|
/**
|
|
|
|
* Implementation of the XForms \<message\> element.
|
|
|
|
*
|
|
|
|
* @see http://www.w3.org/TR/xforms/slice10.html#action-info
|
|
|
|
*/
|
|
|
|
class nsXFormsMessageElement : public nsXFormsXMLVisualStub,
|
|
|
|
public nsIDOMEventListener,
|
|
|
|
public nsIXFormsActionModuleElement
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
NS_DECL_ISUPPORTS_INHERITED
|
|
|
|
|
|
|
|
// nsIXTFElement overrides
|
|
|
|
NS_IMETHOD WillChangeDocument(nsIDOMDocument *aNewDocument);
|
|
|
|
NS_IMETHOD OnDestroyed();
|
|
|
|
|
|
|
|
// nsIXTFXMLVisual overrides
|
|
|
|
NS_IMETHOD OnCreated(nsIXTFXMLVisualWrapper *aWrapper);
|
|
|
|
|
|
|
|
// nsIXTFVisual overrides
|
|
|
|
NS_IMETHOD GetVisualContent(nsIDOMElement **aElement);
|
|
|
|
NS_IMETHOD GetInsertionPoint(nsIDOMElement **aElement);
|
|
|
|
NS_IMETHOD ParentChanged(nsIDOMElement *aNewParent);
|
|
|
|
NS_IMETHOD WillChangeParent(nsIDOMElement *aNewParent);
|
|
|
|
|
|
|
|
NS_DECL_NSIDOMEVENTLISTENER
|
|
|
|
NS_DECL_NSIXFORMSACTIONMODULEELEMENT
|
|
|
|
|
|
|
|
// Start the timer, which is used to set the message visible
|
|
|
|
void StartEphemeral();
|
|
|
|
// Set the message visible and start timer to hide it later.
|
|
|
|
void ShowEphemeral();
|
|
|
|
// Hide the ephemeral message.
|
|
|
|
void HideEphemeral();
|
|
|
|
// Reset the position of the ephemeral message.
|
|
|
|
void ResetEphemeralPosition()
|
|
|
|
{
|
|
|
|
mPosX = mPosY = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
enum MessageType {
|
|
|
|
eType_Normal,
|
|
|
|
eType_Hint,
|
|
|
|
eType_Help,
|
|
|
|
eType_Alert
|
|
|
|
};
|
|
|
|
|
|
|
|
nsXFormsMessageElement(MessageType aType) :
|
|
|
|
mType(aType), mElement(nsnull), mPosX(-1), mPosY(-1) {}
|
|
|
|
private:
|
|
|
|
nsresult HandleEphemeralMessage(nsIDOMDocument* aDoc, nsIDOMEvent* aEvent);
|
|
|
|
nsresult HandleModalAndModelessMessage(nsIDOMDocument* aDoc, nsAString& aLevel);
|
|
|
|
void CloneNode(nsIDOMNode* aSrc, nsIDOMNode** aTarget);
|
|
|
|
void AppendCSSOptions(nsIDOMViewCSS* aViewCSS, nsAString& aOptions);
|
2005-05-18 00:04:08 +04:00
|
|
|
PRBool HandleInlineAlert(nsIDOMEvent* aEvent);
|
2005-01-30 02:53:32 +03:00
|
|
|
nsresult ConstructMessageWindowURL(nsAString& aData,
|
|
|
|
PRBool aIsLink,
|
|
|
|
/*out*/ nsAString& aURL);
|
|
|
|
|
|
|
|
MessageType mType;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMElement> mVisualElement;
|
|
|
|
nsIDOMElement *mElement;
|
|
|
|
|
|
|
|
// The position of the ephemeral message
|
|
|
|
PRInt32 mPosX;
|
|
|
|
PRInt32 mPosY;
|
|
|
|
|
|
|
|
nsCOMPtr<nsITimer> mEphemeralTimer;
|
|
|
|
nsCOMPtr<nsIDOMDocument> mDocument;
|
|
|
|
};
|
|
|
|
|
|
|
|
NS_IMPL_ADDREF_INHERITED(nsXFormsMessageElement, nsXFormsXMLVisualStub)
|
|
|
|
NS_IMPL_RELEASE_INHERITED(nsXFormsMessageElement, nsXFormsXMLVisualStub)
|
|
|
|
|
|
|
|
NS_INTERFACE_MAP_BEGIN(nsXFormsMessageElement)
|
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIXFormsActionModuleElement)
|
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIDOMEventListener)
|
|
|
|
NS_INTERFACE_MAP_END_INHERITING(nsXFormsXMLVisualStub)
|
|
|
|
|
|
|
|
// nsIXTFXMLVisual
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsXFormsMessageElement::OnCreated(nsIXTFXMLVisualWrapper *aWrapper)
|
|
|
|
{
|
2005-08-10 11:58:29 +04:00
|
|
|
nsresult rv = nsXFormsXMLVisualStub::OnCreated(aWrapper);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
2005-01-30 02:53:32 +03:00
|
|
|
aWrapper->SetNotificationMask(nsIXTFElement::NOTIFY_WILL_CHANGE_DOCUMENT |
|
|
|
|
nsIXTFElement::NOTIFY_PARENT_CHANGED);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMElement> node;
|
|
|
|
rv = aWrapper->GetElementNode(getter_AddRefs(node));
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
mElement = node;
|
|
|
|
NS_ASSERTION(mElement, "Wrapper is not an nsIDOMElement, we'll crash soon");
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMDocument> domDoc;
|
|
|
|
mElement->GetOwnerDocument(getter_AddRefs(domDoc));
|
|
|
|
domDoc->CreateElementNS(NS_LITERAL_STRING(NS_NAMESPACE_XHTML),
|
2005-05-18 00:04:08 +04:00
|
|
|
mType == eType_Alert
|
|
|
|
? NS_LITERAL_STRING("span")
|
|
|
|
: NS_LITERAL_STRING("div"),
|
2005-01-30 02:53:32 +03:00
|
|
|
getter_AddRefs(mVisualElement));
|
2005-05-18 00:04:08 +04:00
|
|
|
if (mVisualElement && mType != eType_Alert)
|
|
|
|
mVisualElement->SetAttribute(NS_LITERAL_STRING("style"),
|
|
|
|
NS_LITERAL_STRING(EPHEMERAL_STYLE_HIDDEN));
|
2005-01-30 02:53:32 +03:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
// nsIXTFVisual
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsXFormsMessageElement::GetVisualContent(nsIDOMElement **aElement)
|
|
|
|
{
|
|
|
|
NS_IF_ADDREF(*aElement = mVisualElement);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsXFormsMessageElement::GetInsertionPoint(nsIDOMElement **aElement)
|
|
|
|
{
|
|
|
|
NS_IF_ADDREF(*aElement = mVisualElement);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
// nsIXTFElement
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsXFormsMessageElement::WillChangeDocument(nsIDOMDocument *aNewDocument)
|
|
|
|
{
|
|
|
|
if (mDocument) {
|
|
|
|
if (mEphemeralTimer) {
|
|
|
|
mEphemeralTimer->Cancel();
|
|
|
|
mEphemeralTimer = nsnull;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDocument> doc(do_QueryInterface(mDocument));
|
|
|
|
if (doc) {
|
|
|
|
nsXFormsMessageElement *msg =
|
|
|
|
NS_STATIC_CAST(nsXFormsMessageElement*,
|
|
|
|
doc->GetProperty(nsXFormsAtoms::messageProperty));
|
|
|
|
if (msg == this)
|
|
|
|
doc->UnsetProperty(nsXFormsAtoms::messageProperty);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
mDocument = aNewDocument;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsXFormsMessageElement::OnDestroyed()
|
|
|
|
{
|
|
|
|
mElement = nsnull;
|
|
|
|
mVisualElement = nsnull;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsXFormsMessageElement::HandleEvent(nsIDOMEvent* aEvent)
|
|
|
|
{
|
2005-05-03 23:39:38 +04:00
|
|
|
return nsXFormsUtils::EventHandlingAllowed(aEvent, mElement) ?
|
|
|
|
HandleAction(aEvent, nsnull) : NS_OK;
|
2005-01-30 02:53:32 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nsXFormsMessageElement::CloneNode(nsIDOMNode* aSrc, nsIDOMNode** aTarget)
|
|
|
|
{
|
|
|
|
nsAutoString ns;
|
|
|
|
nsAutoString localName;
|
|
|
|
aSrc->GetNamespaceURI(ns);
|
|
|
|
aSrc->GetLocalName(localName);
|
|
|
|
// Clone the visual content of the <output>.
|
|
|
|
// According to the XForms Schema it is enough
|
|
|
|
// to support <output> here.
|
|
|
|
if (ns.EqualsLiteral(NS_NAMESPACE_XFORMS) &&
|
|
|
|
localName.EqualsLiteral("output")) {
|
2005-11-05 19:11:42 +03:00
|
|
|
nsCOMPtr<nsIDelegateInternal> outEl(do_QueryInterface(aSrc));
|
2005-06-26 22:30:17 +04:00
|
|
|
if (outEl) {
|
|
|
|
nsCOMPtr<nsIDOMDocument> doc;
|
|
|
|
aSrc->GetOwnerDocument(getter_AddRefs(doc));
|
|
|
|
if (doc) {
|
|
|
|
nsCOMPtr<nsIDOMText> text;
|
|
|
|
nsAutoString value;
|
|
|
|
outEl->GetValue(value);
|
|
|
|
doc->CreateTextNode(value, getter_AddRefs(text));
|
|
|
|
NS_IF_ADDREF(*aTarget = text);
|
|
|
|
}
|
2005-01-30 02:53:32 +03:00
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Clone other elements
|
|
|
|
aSrc->CloneNode(PR_FALSE, aTarget);
|
|
|
|
|
|
|
|
if (!*aTarget)
|
|
|
|
return;
|
|
|
|
|
|
|
|
// Add the new children
|
|
|
|
nsCOMPtr<nsIDOMNode> tmp;
|
|
|
|
nsCOMPtr<nsIDOMNodeList> childNodes;
|
|
|
|
aSrc->GetChildNodes(getter_AddRefs(childNodes));
|
|
|
|
|
|
|
|
PRUint32 count = 0;
|
|
|
|
if (childNodes)
|
|
|
|
childNodes->GetLength(&count);
|
|
|
|
|
|
|
|
for (PRUint32 i = 0; i < count; ++i) {
|
|
|
|
nsCOMPtr<nsIDOMNode> child;
|
|
|
|
childNodes->Item(i, getter_AddRefs(child));
|
|
|
|
|
|
|
|
if (child) {
|
|
|
|
nsCOMPtr<nsIDOMNode> clone;
|
|
|
|
CloneNode(child, getter_AddRefs(clone));
|
|
|
|
if (clone)
|
|
|
|
(*aTarget)->AppendChild(clone, getter_AddRefs(tmp));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsXFormsMessageElement::WillChangeParent(nsIDOMElement *aNewParent)
|
|
|
|
{
|
|
|
|
if (mType == eType_Normal)
|
|
|
|
return NS_OK;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMNode> parent;
|
|
|
|
mElement->GetParentNode(getter_AddRefs(parent));
|
|
|
|
if (!parent)
|
|
|
|
return NS_OK;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMEventTarget> targ(do_QueryInterface(parent));
|
|
|
|
NS_ENSURE_STATE(targ);
|
|
|
|
|
|
|
|
if (mType == eType_Hint) {
|
|
|
|
targ->RemoveEventListener(NS_LITERAL_STRING("xforms-hint"), this, PR_FALSE);
|
2005-06-08 19:33:18 +04:00
|
|
|
targ->RemoveEventListener(NS_LITERAL_STRING("xforms-moz-hint-off"),
|
|
|
|
this, PR_FALSE);
|
2005-01-30 02:53:32 +03:00
|
|
|
} else if (mType == eType_Help) {
|
|
|
|
targ->RemoveEventListener(NS_LITERAL_STRING("xforms-help"), this, PR_FALSE);
|
|
|
|
} else if (mType == eType_Alert) {
|
|
|
|
targ->RemoveEventListener(NS_LITERAL_STRING("xforms-invalid"), this, PR_TRUE);
|
|
|
|
targ->RemoveEventListener(NS_LITERAL_STRING("xforms-out-of-range"), this, PR_TRUE);
|
2005-06-08 19:33:18 +04:00
|
|
|
targ->RemoveEventListener(NS_LITERAL_STRING("xforms-binding-exception"),this, PR_TRUE);
|
2005-01-30 02:53:32 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsXFormsMessageElement::ParentChanged(nsIDOMElement *aNewParent)
|
|
|
|
{
|
|
|
|
if (mType == eType_Normal || !aNewParent)
|
|
|
|
return NS_OK;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMEventTarget> targ(do_QueryInterface(aNewParent));
|
|
|
|
NS_ENSURE_STATE(targ);
|
|
|
|
|
|
|
|
if (mType == eType_Hint) {
|
|
|
|
targ->AddEventListener(NS_LITERAL_STRING("xforms-hint"), this, PR_FALSE);
|
2005-06-08 19:33:18 +04:00
|
|
|
targ->AddEventListener(NS_LITERAL_STRING("xforms-moz-hint-off"),
|
|
|
|
this, PR_FALSE);
|
2005-01-30 02:53:32 +03:00
|
|
|
} else if (mType == eType_Help) {
|
|
|
|
targ->AddEventListener(NS_LITERAL_STRING("xforms-help"), this, PR_FALSE);
|
|
|
|
} else if (mType == eType_Alert) {
|
|
|
|
// Adding listeners for error events, which have a form control as a target.
|
|
|
|
targ->AddEventListener(NS_LITERAL_STRING("xforms-invalid"), this, PR_TRUE);
|
|
|
|
targ->AddEventListener(NS_LITERAL_STRING("xforms-out-of-range"), this, PR_TRUE);
|
|
|
|
targ->AddEventListener(NS_LITERAL_STRING("xforms-binding-exception"), this, PR_TRUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsXFormsMessageElement::HandleAction(nsIDOMEvent* aEvent,
|
|
|
|
nsIXFormsActionElement *aParentAction)
|
|
|
|
{
|
|
|
|
if (!mElement)
|
|
|
|
return NS_OK;
|
|
|
|
|
2005-05-19 18:39:33 +04:00
|
|
|
if (mType != eType_Normal) {
|
|
|
|
nsCOMPtr<nsIDOMEventTarget> target;
|
|
|
|
|
|
|
|
if (mType == eType_Alert) {
|
|
|
|
// Alert should fire only if target is the parent element.
|
|
|
|
aEvent->GetTarget(getter_AddRefs(target));
|
|
|
|
} else {
|
|
|
|
// If <help> or <hint> is inside <action>, we don't want to fire them,
|
|
|
|
// unless xforms-help/xforms-hint is dispatched to the <action>.
|
|
|
|
aEvent->GetCurrentTarget(getter_AddRefs(target));
|
|
|
|
}
|
|
|
|
nsCOMPtr<nsIDOMNode> targetNode(do_QueryInterface(target));
|
|
|
|
nsCOMPtr<nsIDOMNode> parent;
|
|
|
|
mElement->GetParentNode(getter_AddRefs(parent));
|
|
|
|
if (!parent || targetNode != parent)
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2005-01-30 02:53:32 +03:00
|
|
|
nsAutoString level;
|
|
|
|
|
|
|
|
switch (mType) {
|
|
|
|
case eType_Normal:
|
|
|
|
mElement->GetAttribute(NS_LITERAL_STRING("level"), level);
|
|
|
|
break;
|
|
|
|
case eType_Hint:
|
|
|
|
level.AssignLiteral("ephemeral");
|
2005-05-19 18:39:33 +04:00
|
|
|
// Using the innermost <hint>.
|
|
|
|
aEvent->StopPropagation();
|
2005-01-30 02:53:32 +03:00
|
|
|
break;
|
|
|
|
case eType_Help:
|
|
|
|
level.AssignLiteral("modeless");
|
2005-05-19 18:39:33 +04:00
|
|
|
// <help> is equivalent to a
|
|
|
|
// <message level="modeless" ev:event="xforms-help" ev:propagate="stop>.
|
|
|
|
aEvent->StopPropagation();
|
2005-07-13 18:36:43 +04:00
|
|
|
aEvent->PreventDefault();
|
2005-01-30 02:53:32 +03:00
|
|
|
break;
|
|
|
|
case eType_Alert:
|
2005-05-18 00:04:08 +04:00
|
|
|
if (HandleInlineAlert(aEvent))
|
|
|
|
return NS_OK;
|
|
|
|
|
2005-01-30 02:53:32 +03:00
|
|
|
level.AssignLiteral("modal");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (level.IsEmpty())
|
|
|
|
return NS_OK;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMDocument> doc;
|
|
|
|
mElement->GetOwnerDocument(getter_AddRefs(doc));
|
|
|
|
|
|
|
|
return level.EqualsLiteral("ephemeral")
|
|
|
|
? HandleEphemeralMessage(doc, aEvent)
|
|
|
|
: HandleModalAndModelessMessage(doc, level);
|
|
|
|
}
|
|
|
|
|
2005-05-18 00:04:08 +04:00
|
|
|
PRBool
|
|
|
|
nsXFormsMessageElement::HandleInlineAlert(nsIDOMEvent* aEvent)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMDocument> doc;
|
2005-12-14 00:19:58 +03:00
|
|
|
nsCOMPtr<nsIDOMWindowInternal> internal;
|
2005-05-18 00:04:08 +04:00
|
|
|
mElement->GetOwnerDocument(getter_AddRefs(doc));
|
2005-12-14 00:19:58 +03:00
|
|
|
nsXFormsUtils::GetWindowFromDocument(doc, getter_AddRefs(internal));
|
|
|
|
if (!internal) {
|
2005-05-18 00:04:08 +04:00
|
|
|
return PR_FALSE;
|
2005-12-14 00:19:58 +03:00
|
|
|
}
|
2005-05-18 00:04:08 +04:00
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMViewCSS> cssView(do_QueryInterface(internal));
|
|
|
|
if (!cssView)
|
|
|
|
return PR_FALSE;
|
|
|
|
|
|
|
|
nsAutoString tmp;
|
|
|
|
nsCOMPtr<nsIDOMCSSStyleDeclaration> styles;
|
|
|
|
cssView->GetComputedStyle(mElement, tmp, getter_AddRefs(styles));
|
|
|
|
nsCOMPtr<nsIDOMCSSValue> display;
|
|
|
|
styles->GetPropertyCSSValue(NS_LITERAL_STRING("display"),
|
|
|
|
getter_AddRefs(display));
|
|
|
|
if (display) {
|
|
|
|
nsCOMPtr<nsIDOMCSSPrimitiveValue> displayValue(do_QueryInterface(display));
|
|
|
|
if (displayValue) {
|
|
|
|
nsAutoString type;
|
|
|
|
displayValue->GetStringValue(type);
|
|
|
|
if (type.EqualsLiteral("none"))
|
|
|
|
return PR_FALSE;
|
|
|
|
|
|
|
|
nsAutoString instanceData;
|
|
|
|
PRBool hasBinding = nsXFormsUtils::GetSingleNodeBindingValue(mElement,
|
|
|
|
instanceData);
|
|
|
|
if (hasBinding) {
|
|
|
|
nsCOMPtr<nsIDOM3Node> visualElement3(do_QueryInterface(mVisualElement));
|
|
|
|
if (visualElement3) {
|
|
|
|
visualElement3->SetTextContent(instanceData);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return PR_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
return PR_FALSE;
|
|
|
|
}
|
|
|
|
|
2005-01-30 02:53:32 +03:00
|
|
|
nsresult
|
|
|
|
nsXFormsMessageElement::HandleEphemeralMessage(nsIDOMDocument* aDoc,
|
|
|
|
nsIDOMEvent* aEvent)
|
|
|
|
{
|
|
|
|
if (!aEvent)
|
|
|
|
return NS_OK;
|
|
|
|
|
2005-06-08 19:33:18 +04:00
|
|
|
nsAutoString eventType;
|
|
|
|
aEvent->GetType(eventType);
|
|
|
|
|
|
|
|
if (mType == eType_Hint) {
|
|
|
|
// If this is a <hint> element, try to make it work more like a tooltip:
|
|
|
|
// - if we get an xforms-moz-hint-off event, hide the element.
|
|
|
|
// - if the <hint> is active and we get a new xforms-hint, then do nothing.
|
|
|
|
nsCOMPtr<nsIDocument> doc(do_QueryInterface(aDoc));
|
|
|
|
if (!doc)
|
|
|
|
return NS_OK;
|
|
|
|
|
|
|
|
nsXFormsMessageElement *msg =
|
|
|
|
NS_STATIC_CAST(nsXFormsMessageElement*,
|
|
|
|
doc->GetProperty(nsXFormsAtoms::messageProperty));
|
|
|
|
if (msg == this) {
|
|
|
|
if (eventType.EqualsLiteral("xforms-moz-hint-off")) {
|
|
|
|
if (mEphemeralTimer) {
|
|
|
|
mEphemeralTimer->Cancel();
|
|
|
|
mEphemeralTimer = nsnull;
|
|
|
|
}
|
|
|
|
doc->UnsetProperty(nsXFormsAtoms::messageProperty);
|
|
|
|
|
|
|
|
if (mVisualElement) {
|
|
|
|
mVisualElement->SetAttribute(NS_LITERAL_STRING("style"),
|
|
|
|
NS_LITERAL_STRING(EPHEMERAL_STYLE_HIDDEN));
|
|
|
|
}
|
|
|
|
ResetEphemeralPosition();
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-01-30 02:53:32 +03:00
|
|
|
/// @bug How to handle the following:
|
|
|
|
/// <message level="ephemeral" src="http://mozilla.org"/>
|
|
|
|
nsCOMPtr<nsIDOMEventTarget> target;
|
|
|
|
aEvent->GetTarget(getter_AddRefs(target));
|
|
|
|
nsCOMPtr<nsIDOMElement> targetEl(do_QueryInterface(target));
|
|
|
|
if (targetEl) {
|
|
|
|
nsCOMPtr<nsIDOMNSDocument> nsDoc(do_QueryInterface(aDoc));
|
|
|
|
if (nsDoc) {
|
|
|
|
PRInt32 oldX = mPosX;
|
|
|
|
PRInt32 oldY = mPosY;
|
|
|
|
nsCOMPtr<nsIBoxObject> box;
|
|
|
|
nsDoc->GetBoxObjectFor(targetEl, getter_AddRefs(box));
|
|
|
|
if (box) {
|
|
|
|
box->GetX(&mPosX);
|
|
|
|
box->GetY(&mPosY);
|
|
|
|
PRInt32 height;
|
|
|
|
box->GetHeight(&height);
|
|
|
|
|
|
|
|
mPosX += 10;
|
|
|
|
mPosY = mPosY + height;
|
|
|
|
|
|
|
|
// Move the ephemeral message a bit upwards if the
|
|
|
|
// box object of the event target is large enough.
|
|
|
|
// This makes it more clear to which element the
|
|
|
|
// message is related to.
|
|
|
|
if (height > 20)
|
|
|
|
mPosY -= height > 30 ? 10 : 10 - (30 - height);
|
|
|
|
}
|
|
|
|
|
|
|
|
// A special case for hints to make them work more like
|
|
|
|
// normal tooltips.
|
|
|
|
if (eventType.EqualsLiteral("xforms-hint") &&
|
|
|
|
mPosX == oldX && mPosY == oldY) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsAutoString instanceData;
|
|
|
|
PRBool hasBinding = nsXFormsUtils::GetSingleNodeBindingValue(mElement,
|
|
|
|
instanceData);
|
|
|
|
if (hasBinding) {
|
|
|
|
nsCOMPtr<nsIDOM3Node> visualElement3(do_QueryInterface(mVisualElement));
|
|
|
|
if (visualElement3) {
|
|
|
|
visualElement3->SetTextContent(instanceData);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
StartEphemeral();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsXFormsMessageElement::HandleModalAndModelessMessage(nsIDOMDocument* aDoc,
|
|
|
|
nsAString& aLevel)
|
|
|
|
{
|
2005-12-14 00:19:58 +03:00
|
|
|
nsCOMPtr<nsIDOMWindowInternal> internal;
|
|
|
|
nsXFormsUtils::GetWindowFromDocument(aDoc, getter_AddRefs(internal));
|
|
|
|
if (!internal) {
|
2005-01-30 02:53:32 +03:00
|
|
|
return NS_OK;
|
2005-12-14 00:19:58 +03:00
|
|
|
}
|
2005-01-30 02:53:32 +03:00
|
|
|
|
|
|
|
nsAutoString instanceData;
|
|
|
|
PRBool hasBinding = nsXFormsUtils::GetSingleNodeBindingValue(mElement,
|
|
|
|
instanceData);
|
|
|
|
|
|
|
|
nsAutoString options;
|
|
|
|
options.AppendLiteral(MESSAGE_WINDOW_PROPERTIES);
|
|
|
|
|
|
|
|
nsAutoString src;
|
2005-07-26 20:39:25 +04:00
|
|
|
if (!hasBinding) {
|
|
|
|
mElement->GetAttribute(NS_LITERAL_STRING("src"), src);
|
|
|
|
}
|
2005-01-30 02:53:32 +03:00
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMViewCSS> cssView(do_QueryInterface(internal));
|
|
|
|
AppendCSSOptions(cssView, options);
|
|
|
|
|
2005-07-26 20:39:25 +04:00
|
|
|
// order of precedence is single-node binding, linking attribute then
|
|
|
|
// inline text
|
2005-01-30 02:53:32 +03:00
|
|
|
nsresult rv;
|
2005-07-26 20:39:25 +04:00
|
|
|
if (!hasBinding && !src.IsEmpty()) {
|
2005-01-30 02:53:32 +03:00
|
|
|
// Creating a normal window for messages with src attribute.
|
|
|
|
options.AppendLiteral(",chrome=no");
|
|
|
|
rv = ConstructMessageWindowURL(src, PR_TRUE, src);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
} else {
|
|
|
|
// Cloning the content of the xf:message and creating a
|
|
|
|
// dialog for it.
|
|
|
|
options.AppendLiteral(",dialog,chrome,dependent");
|
|
|
|
nsCOMPtr<nsIDOMDocument> ddoc;
|
|
|
|
nsCOMPtr<nsIDOMDOMImplementation> domImpl;
|
|
|
|
rv = aDoc->GetImplementation(getter_AddRefs(domImpl));
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
rv = domImpl->CreateDocument(EmptyString(), EmptyString(), nsnull,
|
|
|
|
getter_AddRefs(ddoc));
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
if (!ddoc)
|
|
|
|
return NS_OK;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMNode> tmp;
|
|
|
|
nsCOMPtr<nsIDOMElement> htmlEl;
|
|
|
|
rv = ddoc->CreateElementNS(NS_LITERAL_STRING(NS_NAMESPACE_XHTML),
|
|
|
|
NS_LITERAL_STRING("html"),
|
|
|
|
getter_AddRefs(htmlEl));
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
ddoc->AppendChild(htmlEl, getter_AddRefs(tmp));
|
2005-11-15 20:22:15 +03:00
|
|
|
|
2005-01-30 02:53:32 +03:00
|
|
|
nsCOMPtr<nsIDOMElement> bodyEl;
|
|
|
|
rv = ddoc->CreateElementNS(NS_LITERAL_STRING(NS_NAMESPACE_XHTML),
|
|
|
|
NS_LITERAL_STRING("body"),
|
|
|
|
getter_AddRefs(bodyEl));
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
htmlEl->AppendChild(bodyEl, getter_AddRefs(tmp));
|
2005-11-15 20:22:15 +03:00
|
|
|
|
2005-01-30 02:53:32 +03:00
|
|
|
// If we have a binding, it is enough to show a simple message
|
|
|
|
if (hasBinding) {
|
|
|
|
nsCOMPtr<nsIDOM3Node> body3(do_QueryInterface(bodyEl));
|
|
|
|
if (body3)
|
|
|
|
body3->SetTextContent(instanceData);
|
|
|
|
} else {
|
|
|
|
// Otherwise copying content from the original document to
|
|
|
|
// the modeless/modal message document.
|
|
|
|
nsCOMPtr<nsIDOMNode> tmp;
|
|
|
|
nsCOMPtr<nsIDOMNodeList> childNodes;
|
|
|
|
mElement->GetChildNodes(getter_AddRefs(childNodes));
|
|
|
|
|
|
|
|
PRUint32 count = 0;
|
|
|
|
if (childNodes)
|
|
|
|
childNodes->GetLength(&count);
|
|
|
|
|
|
|
|
for (PRUint32 i = 0; i < count; ++i) {
|
|
|
|
nsCOMPtr<nsIDOMNode> child;
|
|
|
|
childNodes->Item(i, getter_AddRefs(child));
|
|
|
|
|
|
|
|
if (child) {
|
|
|
|
nsCOMPtr<nsIDOMNode> clone;
|
|
|
|
CloneNode(child, getter_AddRefs(clone));
|
|
|
|
if (clone)
|
|
|
|
bodyEl->AppendChild(clone, getter_AddRefs(tmp));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2005-11-15 20:22:15 +03:00
|
|
|
|
2005-01-30 02:53:32 +03:00
|
|
|
nsCOMPtr<nsIDOMSerializer> serializer =
|
|
|
|
do_CreateInstance(NS_XMLSERIALIZER_CONTRACTID, &rv);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
nsAutoString docString;
|
|
|
|
rv = serializer->SerializeToString(ddoc, docString);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2005-11-15 20:22:15 +03:00
|
|
|
|
2005-01-30 02:53:32 +03:00
|
|
|
rv = ConstructMessageWindowURL(docString, PR_FALSE, src);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
}
|
2005-11-15 20:22:15 +03:00
|
|
|
|
2005-01-30 02:53:32 +03:00
|
|
|
nsCOMPtr<nsISupports> arg;
|
|
|
|
PRBool isModal = aLevel.EqualsLiteral("modal");
|
|
|
|
if (isModal) {
|
|
|
|
options.AppendLiteral(",modal");
|
|
|
|
// We need to have an argument to set the window modal.
|
|
|
|
// Using nsXFormsAtoms::messageProperty so that we don't create new
|
|
|
|
// cycles between the windows.
|
|
|
|
arg = nsXFormsAtoms::messageProperty;
|
|
|
|
}
|
2005-11-15 20:22:15 +03:00
|
|
|
|
2005-01-30 02:53:32 +03:00
|
|
|
//XXX Add support for xforms-link-error.
|
|
|
|
nsCOMPtr<nsIDOMWindow> messageWindow;
|
2006-03-20 22:17:14 +03:00
|
|
|
// The 2nd argument is the window name, and if a window with the name exists,
|
|
|
|
// it gets reused. Using "_blank" makes sure we get a new window each time.
|
|
|
|
internal->OpenDialog(src, NS_LITERAL_STRING("_blank"), options, arg,
|
|
|
|
getter_AddRefs(messageWindow));
|
2005-01-30 02:53:32 +03:00
|
|
|
if (!isModal) {
|
|
|
|
nsCOMPtr<nsIDOMWindowInternal> msgWinInternal =
|
|
|
|
do_QueryInterface(messageWindow);
|
|
|
|
if (msgWinInternal)
|
|
|
|
msgWinInternal->Focus();
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nsXFormsMessageElement::AppendCSSOptions(nsIDOMViewCSS* aViewCSS, nsAString& aOptions)
|
|
|
|
{
|
|
|
|
if (!aViewCSS)
|
|
|
|
return;
|
|
|
|
// Try to get the calculated size of the message element. It will
|
|
|
|
// be used for the new window.
|
|
|
|
//XXX This could be extended also for 'top', 'left' etc. properties.
|
|
|
|
PRInt32 computedWidth = 0;
|
|
|
|
PRInt32 computedHeight = 0;
|
|
|
|
|
|
|
|
nsAutoString tmp;
|
|
|
|
nsCOMPtr<nsIDOMCSSStyleDeclaration> styles;
|
|
|
|
aViewCSS->GetComputedStyle(mElement, tmp, getter_AddRefs(styles));
|
|
|
|
if (styles) {
|
|
|
|
nsCOMPtr<nsIDOMCSSValue> cssWidth;
|
|
|
|
styles->GetPropertyCSSValue(NS_LITERAL_STRING("width"),
|
|
|
|
getter_AddRefs(cssWidth));
|
|
|
|
nsCOMPtr<nsIDOMCSSPrimitiveValue> pvalueWidth(do_QueryInterface(cssWidth));
|
|
|
|
float width = 0;
|
|
|
|
if (pvalueWidth) {
|
|
|
|
PRUint16 type;
|
|
|
|
pvalueWidth->GetPrimitiveType(&type);
|
|
|
|
if (type == nsIDOMCSSPrimitiveValue::CSS_PX)
|
|
|
|
pvalueWidth->GetFloatValue(type, &width);
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMCSSValue> cssHeight;
|
|
|
|
styles->GetPropertyCSSValue(NS_LITERAL_STRING("height"),
|
|
|
|
getter_AddRefs(cssHeight));
|
|
|
|
nsCOMPtr<nsIDOMCSSPrimitiveValue> pvalueHeight(do_QueryInterface(cssHeight));
|
|
|
|
float height = 0;
|
|
|
|
if (pvalueHeight) {
|
|
|
|
PRUint16 type;
|
|
|
|
pvalueHeight->GetPrimitiveType(&type);
|
|
|
|
if (type == nsIDOMCSSPrimitiveValue::CSS_PX)
|
|
|
|
pvalueHeight->GetFloatValue(type, &height);
|
|
|
|
}
|
|
|
|
computedWidth = NS_STATIC_CAST(PRInt32, width);
|
|
|
|
computedHeight = NS_STATIC_CAST(PRInt32, height);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (computedWidth > 0 && computedHeight > 0) {
|
|
|
|
nsAutoString options;
|
|
|
|
options.AppendLiteral(",innerWidth=");
|
|
|
|
options.AppendInt(computedWidth);
|
|
|
|
options.AppendLiteral(",innerHeight=");
|
|
|
|
options.AppendInt(computedHeight);
|
|
|
|
aOptions.Append(options);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsXFormsMessageElement::ConstructMessageWindowURL(nsAString& aData,
|
|
|
|
PRBool aIsLink,
|
|
|
|
nsAString& aURL)
|
|
|
|
{
|
|
|
|
nsXPIDLString messageOK;
|
|
|
|
nsCOMPtr<nsIStringBundleService> bundleService =
|
|
|
|
do_GetService(NS_STRINGBUNDLE_CONTRACTID);
|
|
|
|
if (bundleService) {
|
|
|
|
nsCOMPtr<nsIStringBundle> bundle;
|
|
|
|
bundleService->CreateBundle("chrome://global/locale/dialog.properties",
|
|
|
|
getter_AddRefs(bundle));
|
|
|
|
if (bundle) {
|
|
|
|
bundle->GetStringFromName(NS_LITERAL_STRING("button-accept").get(),
|
|
|
|
getter_Copies(messageOK));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (messageOK.IsEmpty())
|
|
|
|
messageOK.AssignLiteral("OK");
|
|
|
|
|
|
|
|
nsAutoString xul;
|
|
|
|
xul.AssignLiteral(MESSAGE_WINDOW_UI_PART1);
|
|
|
|
if (aIsLink)
|
|
|
|
xul.AppendLiteral("<browser flex='1' src='");
|
|
|
|
|
|
|
|
xul.Append(aData);
|
|
|
|
|
|
|
|
if (aIsLink)
|
|
|
|
xul.AppendLiteral("'/>");
|
|
|
|
else
|
|
|
|
xul.AppendLiteral("<spacer flex='1'/>");
|
|
|
|
|
|
|
|
xul.AppendLiteral(MESSAGE_WINDOW_UI_PART2);
|
|
|
|
xul.Append(messageOK);
|
|
|
|
xul.AppendLiteral(MESSAGE_WINDOW_UI_PART3);
|
|
|
|
|
|
|
|
char* b64 = PL_Base64Encode(NS_ConvertUTF16toUTF8(xul).get(), 0, nsnull);
|
|
|
|
if (!b64)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
nsCAutoString b64String;
|
|
|
|
b64String.AppendLiteral("data:application/vnd.mozilla.xul+xml;base64,");
|
|
|
|
b64String.Append(b64);
|
|
|
|
PR_Free(b64);
|
|
|
|
|
|
|
|
CopyUTF8toUTF16(b64String, aURL);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
sEphemeralCallbackShow(nsITimer *aTimer, void *aListener)
|
|
|
|
{
|
|
|
|
nsXFormsMessageElement* self =
|
|
|
|
NS_STATIC_CAST(nsXFormsMessageElement*, aListener);
|
|
|
|
if (self)
|
|
|
|
self->ShowEphemeral();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
sEphemeralCallbackHide(nsITimer *aTimer, void *aListener)
|
|
|
|
{
|
|
|
|
nsXFormsMessageElement* self =
|
|
|
|
NS_STATIC_CAST(nsXFormsMessageElement*, aListener);
|
|
|
|
if (self)
|
|
|
|
self->HideEphemeral();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
sEphemeralCallbackResetPosition(nsITimer *aTimer, void *aListener)
|
|
|
|
{
|
|
|
|
nsXFormsMessageElement* self =
|
|
|
|
NS_STATIC_CAST(nsXFormsMessageElement*, aListener);
|
|
|
|
if (self)
|
|
|
|
self->ResetEphemeralPosition();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nsXFormsMessageElement::StartEphemeral()
|
|
|
|
{
|
|
|
|
HideEphemeral();
|
|
|
|
if (!mElement)
|
|
|
|
return;
|
|
|
|
nsCOMPtr<nsIDOMDocument> domdoc;
|
|
|
|
mElement->GetOwnerDocument(getter_AddRefs(domdoc));
|
|
|
|
nsCOMPtr<nsIDocument> doc(do_QueryInterface(domdoc));
|
|
|
|
if (!doc)
|
|
|
|
return;
|
|
|
|
doc->SetProperty(nsXFormsAtoms::messageProperty, this);
|
|
|
|
mEphemeralTimer = do_CreateInstance(NS_TIMER_CONTRACTID);
|
|
|
|
if (mEphemeralTimer)
|
|
|
|
mEphemeralTimer->InitWithFuncCallback(sEphemeralCallbackShow, this,
|
|
|
|
SHOW_EPHEMERAL_TIMEOUT,
|
|
|
|
nsITimer::TYPE_ONE_SHOT);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nsXFormsMessageElement::ShowEphemeral()
|
|
|
|
{
|
|
|
|
if (mEphemeralTimer) {
|
|
|
|
mEphemeralTimer->Cancel();
|
|
|
|
mEphemeralTimer = nsnull;
|
|
|
|
}
|
|
|
|
if (!mElement)
|
|
|
|
return;
|
|
|
|
|
|
|
|
nsAutoString style;
|
|
|
|
style.AppendLiteral(EPHEMERAL_STYLE);
|
|
|
|
style.AppendLiteral("left:");
|
|
|
|
style.AppendInt(mPosX);
|
|
|
|
style.AppendLiteral("px;top:");
|
|
|
|
style.AppendInt(mPosY);
|
|
|
|
style.AppendLiteral("px;");
|
|
|
|
mVisualElement->SetAttribute(NS_LITERAL_STRING("style"), style);
|
|
|
|
mEphemeralTimer = do_CreateInstance(NS_TIMER_CONTRACTID);
|
|
|
|
if (mEphemeralTimer)
|
|
|
|
mEphemeralTimer->InitWithFuncCallback(sEphemeralCallbackHide, this,
|
|
|
|
HIDE_EPHEMERAL_TIMEOUT,
|
|
|
|
nsITimer::TYPE_ONE_SHOT);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nsXFormsMessageElement::HideEphemeral()
|
|
|
|
{
|
|
|
|
if (mEphemeralTimer) {
|
|
|
|
mEphemeralTimer->Cancel();
|
|
|
|
mEphemeralTimer = nsnull;
|
|
|
|
}
|
|
|
|
if (!mElement)
|
|
|
|
return;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMDocument> domdoc;
|
|
|
|
mElement->GetOwnerDocument(getter_AddRefs(domdoc));
|
|
|
|
nsCOMPtr<nsIDocument> doc(do_QueryInterface(domdoc));
|
|
|
|
if (!doc)
|
|
|
|
return;
|
|
|
|
nsXFormsMessageElement *msg =
|
|
|
|
NS_STATIC_CAST(nsXFormsMessageElement*,
|
|
|
|
doc->GetProperty(nsXFormsAtoms::messageProperty));
|
|
|
|
if (msg && msg != this) {
|
|
|
|
msg->HideEphemeral();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
doc->UnsetProperty(nsXFormsAtoms::messageProperty);
|
|
|
|
|
|
|
|
if (mVisualElement)
|
|
|
|
mVisualElement->SetAttribute(NS_LITERAL_STRING("style"),
|
|
|
|
NS_LITERAL_STRING(EPHEMERAL_STYLE_HIDDEN));
|
|
|
|
|
|
|
|
mEphemeralTimer = do_CreateInstance(NS_TIMER_CONTRACTID);
|
|
|
|
if (mEphemeralTimer)
|
|
|
|
mEphemeralTimer->InitWithFuncCallback(sEphemeralCallbackResetPosition,
|
|
|
|
this,
|
|
|
|
EPHEMERAL_POSITION_RESET_TIMEOUT,
|
|
|
|
nsITimer::TYPE_ONE_SHOT);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_HIDDEN_(nsresult)
|
|
|
|
NS_NewXFormsMessageElement(nsIXTFElement **aResult)
|
|
|
|
{
|
|
|
|
*aResult = new nsXFormsMessageElement(nsXFormsMessageElement::eType_Normal);
|
|
|
|
if (!*aResult)
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
|
|
|
|
NS_ADDREF(*aResult);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_HIDDEN_(nsresult)
|
|
|
|
NS_NewXFormsHintElement(nsIXTFElement **aResult)
|
|
|
|
{
|
|
|
|
*aResult = new nsXFormsMessageElement(nsXFormsMessageElement::eType_Hint);
|
|
|
|
if (!*aResult)
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
|
|
|
|
NS_ADDREF(*aResult);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_HIDDEN_(nsresult)
|
|
|
|
NS_NewXFormsHelpElement(nsIXTFElement **aResult)
|
|
|
|
{
|
|
|
|
*aResult = new nsXFormsMessageElement(nsXFormsMessageElement::eType_Help);
|
|
|
|
if (!*aResult)
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
|
|
|
|
NS_ADDREF(*aResult);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_HIDDEN_(nsresult)
|
|
|
|
NS_NewXFormsAlertElement(nsIXTFElement **aResult)
|
|
|
|
{
|
|
|
|
*aResult = new nsXFormsMessageElement(nsXFormsMessageElement::eType_Alert);
|
|
|
|
if (!*aResult)
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
|
|
|
|
NS_ADDREF(*aResult);
|
|
|
|
return NS_OK;
|
|
|
|
}
|