NS_IMETHODIMP
nsFormFillController::OnTextEntered(bool* aPrevent)
{
NS_ENSURE_ARG(aPrevent);
NS_ENSURE_TRUE(mFocusedInput, NS_OK);
// Fire off a DOMAutoComplete event
nsCOMPtr<nsIDOMDocument> domDoc;
mFocusedInput->GetOwnerDocument(getter_AddRefs(domDoc));
NS_ENSURE_STATE(domDoc);
nsCOMPtr<nsIDOMEvent> event;
domDoc->CreateEvent(NS_LITERAL_STRING("Events"), getter_AddRefs(event));
nsCOMPtr<nsIPrivateDOMEvent> privateEvent(do_QueryInterface(event));
NS_ENSURE_STATE(privateEvent);
event->InitEvent(NS_LITERAL_STRING("DOMAutoComplete"), true, true);
// XXXjst: We mark this event as a trusted event, it's up to the
// callers of this to ensure that it's only called from trusted
// code.
privateEvent->SetTrusted(true);
nsCOMPtr<nsIDOMEventTarget> targ = do_QueryInterface(mFocusedInput);
bool defaultActionEnabled;
targ->DispatchEvent(event, &defaultActionEnabled);
*aPrevent = !defaultActionEnabled;
return NS_OK;
}
NS_IMETHOD Run()
{
nsAutoString domEventToFire;
if (mIsActivate) {
// Highlight the menu.
mMenu->SetAttr(kNameSpaceID_None, nsGkAtoms::menuactive,
NS_LITERAL_STRING("true"), PR_TRUE);
// The menuactivated event is used by accessibility to track the user's
// movements through menus
domEventToFire.AssignLiteral("DOMMenuItemActive");
}
else {
// Unhighlight the menu.
mMenu->UnsetAttr(kNameSpaceID_None, nsGkAtoms::menuactive, PR_TRUE);
domEventToFire.AssignLiteral("DOMMenuItemInactive");
}
nsCOMPtr<nsIDOMEvent> event;
if (NS_SUCCEEDED(nsEventDispatcher::CreateEvent(mPresContext, nsnull,
NS_LITERAL_STRING("Events"),
getter_AddRefs(event)))) {
event->InitEvent(domEventToFire, PR_TRUE, PR_TRUE);
nsCOMPtr<nsIPrivateDOMEvent> privateEvent(do_QueryInterface(event));
privateEvent->SetTrusted(PR_TRUE);
nsEventDispatcher::DispatchDOMEvent(mMenu, nsnull, event,
mPresContext, nsnull);
}
return NS_OK;
}
NS_IMETHODIMP nsPLDOMEvent::Run()
{
if (!mEventNode) {
return NS_OK;
}
nsCOMPtr<nsIDOMEvent> domEvent(mEvent);
if (!domEvent) {
nsCOMPtr<nsIDOMDocument> domDoc;
mEventNode->GetOwnerDocument(getter_AddRefs(domDoc));
nsCOMPtr<nsIDOMDocumentEvent> domEventDoc = do_QueryInterface(domDoc);
if (domEventDoc) {
domEventDoc->CreateEvent(NS_LITERAL_STRING("Events"),
getter_AddRefs(domEvent));
nsCOMPtr<nsIPrivateDOMEvent> privateEvent(do_QueryInterface(domEvent));
if (privateEvent &&
NS_SUCCEEDED(domEvent->InitEvent(mEventType, PR_TRUE, PR_TRUE))) {
privateEvent->SetTrusted(PR_TRUE);
}
}
}
nsCOMPtr<nsIDOMEventTarget> target = do_QueryInterface(mEventNode);
PRBool defaultActionEnabled; // This is not used because the caller is async
target->DispatchEvent(domEvent, &defaultActionEnabled);
return NS_OK;
}
void
nsInProcessTabChildGlobal::DelayedDisconnect()
{
// Don't let the event escape
mOwner = nsnull;
// Fire the "unload" event
nsCOMPtr<nsIDOMEvent> event;
NS_NewDOMEvent(getter_AddRefs(event), nsnull, nsnull);
if (event) {
event->InitEvent(NS_LITERAL_STRING("unload"), PR_FALSE, PR_FALSE);
nsCOMPtr<nsIPrivateDOMEvent> privateEvent(do_QueryInterface(event));
privateEvent->SetTrusted(PR_TRUE);
PRBool dummy;
nsDOMEventTargetHelper::DispatchEvent(event, &dummy);
}
// Continue with the Disconnect cleanup
nsCOMPtr<nsIDOMWindow> win = do_GetInterface(mDocShell);
nsCOMPtr<nsPIDOMWindow> pwin = do_QueryInterface(win);
if (pwin) {
pwin->SetChromeEventHandler(pwin->GetChromeEventHandler());
}
mDocShell = nsnull;
mChromeMessageManager = nsnull;
if (mMessageManager) {
static_cast<nsFrameMessageManager*>(mMessageManager.get())->Disconnect();
mMessageManager = nsnull;
}
if (mListenerManager) {
mListenerManager->Disconnect();
}
if (!mLoadingScript) {
if (mCx) {
DestroyCx();
}
} else {
mDelayedDisconnect = PR_TRUE;
}
}
PRBool
nsAutoWindowStateHelper::DispatchCustomEvent(const char *aEventName)
{
if (!mWindow) {
return PR_TRUE;
}
#ifdef DEBUG
{
nsCOMPtr<nsPIDOMWindow> window(do_QueryInterface(mWindow));
NS_ASSERTION(window->GetExtantDocument() != nsnull,
"nsPrompt used too early on window object!");
}
#endif
nsCOMPtr<nsIDOMDocument> domdoc;
mWindow->GetDocument(getter_AddRefs(domdoc));
nsCOMPtr<nsIDOMDocumentEvent> docevent(do_QueryInterface(domdoc));
nsCOMPtr<nsIDOMEvent> event;
PRBool defaultActionEnabled = PR_TRUE;
if (docevent) {
docevent->CreateEvent(NS_LITERAL_STRING("Events"), getter_AddRefs(event));
nsCOMPtr<nsIPrivateDOMEvent> privateEvent(do_QueryInterface(event));
if (privateEvent) {
event->InitEvent(NS_ConvertASCIItoUTF16(aEventName), PR_TRUE, PR_TRUE);
privateEvent->SetTrusted(PR_TRUE);
nsCOMPtr<nsIDOMEventTarget> target(do_QueryInterface(mWindow));
target->DispatchEvent(event, &defaultActionEnabled);
}
}
return defaultActionEnabled;
}
PRBool
nsXBLWindowKeyHandler::WalkHandlersAndExecute(nsIDOMKeyEvent* aKeyEvent,
nsIAtom* aEventType,
nsXBLPrototypeHandler* aHandler,
PRUint32 aCharCode,
PRBool aIgnoreShiftKey)
{
nsresult rv;
nsCOMPtr<nsIPrivateDOMEvent> privateEvent(do_QueryInterface(aKeyEvent));
// Try all of the handlers until we find one that matches the event.
for (nsXBLPrototypeHandler *currHandler = aHandler; currHandler;
currHandler = currHandler->GetNextHandler()) {
PRBool stopped;
privateEvent->IsDispatchStopped(&stopped);
if (stopped) {
// The event is finished, don't execute any more handlers
return NS_OK;
}
if (!EventMatched(currHandler, aEventType, aKeyEvent,
aCharCode, aIgnoreShiftKey))
continue; // try the next one
// Before executing this handler, check that it's not disabled,
// and that it has something to do (oncommand of the <key> or its
// <command> is non-empty).
nsCOMPtr<nsIContent> elt = currHandler->GetHandlerElement();
nsCOMPtr<nsIDOMElement> commandElt;
// See if we're in a XUL doc.
nsCOMPtr<nsIDOMElement> el = GetElement();
if (el && elt) {
// We are. Obtain our command attribute.
nsAutoString command;
elt->GetAttr(kNameSpaceID_None, nsGkAtoms::command, command);
if (!command.IsEmpty()) {
// Locate the command element in question. Note that we
// know "elt" is in a doc if we're dealing with it here.
NS_ASSERTION(elt->IsInDoc(), "elt must be in document");
nsCOMPtr<nsIDOMDocument> domDoc(
do_QueryInterface(elt->GetCurrentDoc()));
if (domDoc)
domDoc->GetElementById(command, getter_AddRefs(commandElt));
if (!commandElt) {
NS_ERROR("A XUL <key> is observing a command that doesn't exist. Unable to execute key binding!\n");
continue;
}
}
}
if (!commandElt) {
commandElt = do_QueryInterface(elt);
}
if (commandElt) {
nsAutoString value;
commandElt->GetAttribute(NS_LITERAL_STRING("disabled"), value);
if (value.EqualsLiteral("true")) {
continue; // this handler is disabled, try the next one
}
// Check that there is an oncommand handler
commandElt->GetAttribute(NS_LITERAL_STRING("oncommand"), value);
if (value.IsEmpty()) {
continue; // nothing to do
}
}
nsCOMPtr<nsPIDOMEventTarget> piTarget;
nsCOMPtr<nsIDOMElement> element = GetElement();
if (element) {
piTarget = do_QueryInterface(commandElt);
} else {
piTarget = mTarget;
}
rv = currHandler->ExecuteHandler(piTarget, aKeyEvent);
if (NS_SUCCEEDED(rv)) {
return PR_TRUE;
}
}
return PR_FALSE;
}
