1999-12-06 09:32:12 +03:00
|
|
|
/*
|
|
|
|
* The contents of this file are subject to the Mozilla Public
|
|
|
|
* License Version 1.1 (the "MPL"); you may not use this file
|
|
|
|
* except in compliance with the MPL. You may obtain a copy of
|
|
|
|
* the MPL at http://www.mozilla.org/MPL/
|
|
|
|
*
|
|
|
|
* Software distributed under the MPL is distributed on an "AS
|
|
|
|
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
|
|
|
* implied. See the MPL for the specific language governing
|
|
|
|
* rights and limitations under the MPL.
|
|
|
|
*
|
|
|
|
* The Original Code is XMLterm.
|
|
|
|
*
|
|
|
|
* The Initial Developer of the Original Code is Ramalingam Saravanan.
|
|
|
|
* Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
|
|
|
|
* Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
|
|
|
|
*
|
|
|
|
* Contributor(s):
|
2000-01-11 23:49:15 +03:00
|
|
|
* Pierre Phaneuf <pp@ludusdesign.com>
|
1999-12-06 09:32:12 +03:00
|
|
|
*/
|
|
|
|
|
|
|
|
// mozXMLTermListeners.cpp: implementation of classes in mozXMLTermListeners.h
|
|
|
|
|
|
|
|
#include "nsIServiceManager.h"
|
|
|
|
|
|
|
|
#include "mozXMLT.h"
|
2000-02-29 18:55:36 +03:00
|
|
|
#include "mozXMLTermUtils.h"
|
1999-12-06 09:32:12 +03:00
|
|
|
#include "mozXMLTermListeners.h"
|
|
|
|
|
|
|
|
#include "nsIDOMKeyEvent.h"
|
|
|
|
#include "nsIDOMMouseEvent.h"
|
|
|
|
#include "nsIDOMNSUIEvent.h"
|
|
|
|
#include "nsIPrivateTextEvent.h"
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
|
|
// mozXMLTermKeyListener factory
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
NS_NewXMLTermKeyListener(nsIDOMEventListener ** aInstancePtrResult,
|
|
|
|
mozIXMLTerminal *aXMLTerminal)
|
|
|
|
{
|
|
|
|
mozXMLTermKeyListener* listener = new mozXMLTermKeyListener();
|
|
|
|
if (listener == nsnull) {
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Save non-owning reference to embedding XMLTerminal object
|
|
|
|
listener->SetXMLTerminal(aXMLTerminal);
|
|
|
|
|
2000-01-11 23:49:15 +03:00
|
|
|
return listener->QueryInterface(NS_GET_IID(nsIDOMEventListener),
|
1999-12-06 09:32:12 +03:00
|
|
|
(void **) aInstancePtrResult);
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
NS_NewXMLTermTextListener(nsIDOMEventListener ** aInstancePtrResult,
|
|
|
|
mozIXMLTerminal *aXMLTerminal)
|
|
|
|
{
|
|
|
|
mozXMLTermTextListener* listener = new mozXMLTermTextListener();
|
|
|
|
if (listener == nsnull) {
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Save non-owning reference to embedding XMLTerminal object
|
|
|
|
listener->SetXMLTerminal(aXMLTerminal);
|
|
|
|
|
2000-01-11 23:49:15 +03:00
|
|
|
return listener->QueryInterface(NS_GET_IID(nsIDOMEventListener),
|
1999-12-06 09:32:12 +03:00
|
|
|
(void **) aInstancePtrResult);
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
NS_NewXMLTermMouseListener(nsIDOMEventListener ** aInstancePtrResult,
|
|
|
|
mozIXMLTerminal *aXMLTerminal)
|
|
|
|
{
|
|
|
|
mozXMLTermMouseListener* listener = new mozXMLTermMouseListener();
|
|
|
|
if (listener == nsnull) {
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Save non-owning reference to embedding XMLTerminal object
|
|
|
|
listener->SetXMLTerminal(aXMLTerminal);
|
|
|
|
|
2000-01-11 23:49:15 +03:00
|
|
|
return listener->QueryInterface(NS_GET_IID(nsIDOMEventListener),
|
1999-12-06 09:32:12 +03:00
|
|
|
(void **) aInstancePtrResult);
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
NS_NewXMLTermDragListener(nsIDOMEventListener ** aInstancePtrResult,
|
|
|
|
mozIXMLTerminal *aXMLTerminal)
|
|
|
|
{
|
|
|
|
mozXMLTermDragListener* listener = new mozXMLTermDragListener();
|
|
|
|
if (listener == nsnull) {
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Save non-owning reference to embedding XMLTerminal object
|
|
|
|
listener->SetXMLTerminal(aXMLTerminal);
|
|
|
|
|
2000-01-11 23:49:15 +03:00
|
|
|
return listener->QueryInterface(NS_GET_IID(nsIDOMEventListener),
|
1999-12-06 09:32:12 +03:00
|
|
|
(void **) aInstancePtrResult);
|
|
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
|
|
// mozXMLTermKeyListener implementation
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
|
|
|
2000-02-29 18:55:36 +03:00
|
|
|
mozXMLTermKeyListener::mozXMLTermKeyListener() :
|
|
|
|
mXMLTerminal(nsnull),
|
|
|
|
mSuspend(false)
|
1999-12-06 09:32:12 +03:00
|
|
|
{
|
|
|
|
NS_INIT_REFCNT();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
mozXMLTermKeyListener::~mozXMLTermKeyListener()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
NS_IMPL_ADDREF(mozXMLTermKeyListener)
|
|
|
|
|
|
|
|
NS_IMPL_RELEASE(mozXMLTermKeyListener)
|
|
|
|
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
mozXMLTermKeyListener::QueryInterface(REFNSIID aIID, void** aInstancePtr)
|
|
|
|
{
|
|
|
|
if (aInstancePtr == NULL) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Always NULL result, in case of failure
|
|
|
|
*aInstancePtr = NULL;
|
|
|
|
|
2000-01-11 23:49:15 +03:00
|
|
|
if (aIID.Equals(NS_GET_IID(nsISupports))) {
|
1999-12-06 09:32:12 +03:00
|
|
|
*aInstancePtr = NS_STATIC_CAST(nsISupports*,
|
|
|
|
NS_STATIC_CAST(nsIDOMKeyListener*,this));
|
|
|
|
|
2000-01-11 23:49:15 +03:00
|
|
|
} else if (aIID.Equals(NS_GET_IID(nsIDOMEventListener))) {
|
1999-12-06 09:32:12 +03:00
|
|
|
*aInstancePtr = NS_STATIC_CAST(nsIDOMEventListener*,this);
|
|
|
|
|
2000-01-11 23:49:15 +03:00
|
|
|
} else if (aIID.Equals(NS_GET_IID(nsIDOMKeyListener))) {
|
1999-12-06 09:32:12 +03:00
|
|
|
*aInstancePtr = NS_STATIC_CAST(nsIDOMKeyListener*,this);
|
|
|
|
|
2000-02-29 18:55:36 +03:00
|
|
|
} else if (aIID.Equals(NS_GET_IID(mozIXMLTermSuspend))) {
|
|
|
|
*aInstancePtr = NS_STATIC_CAST(mozIXMLTermSuspend*,this);
|
|
|
|
|
1999-12-06 09:32:12 +03:00
|
|
|
} else {
|
|
|
|
return NS_ERROR_NO_INTERFACE;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2000-02-29 18:55:36 +03:00
|
|
|
NS_IMETHODIMP mozXMLTermKeyListener::GetSuspend(PRBool* aSuspend)
|
|
|
|
{
|
|
|
|
if (!*aSuspend)
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
*aSuspend = mSuspend;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
NS_IMETHODIMP mozXMLTermKeyListener::SetSuspend(const PRBool aSuspend)
|
|
|
|
{
|
|
|
|
XMLT_LOG(mozXMLTermKeyListener::SetSuspend,50,("aSuspend=0x%x\n",
|
|
|
|
aSuspend));
|
|
|
|
mSuspend = aSuspend;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-12-06 09:32:12 +03:00
|
|
|
// Individual key handlers return NS_OK to indicate NOT consumed
|
|
|
|
// by default, an error is returned indicating event is consumed
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
mozXMLTermKeyListener::HandleEvent(nsIDOMEvent* aEvent)
|
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Process KeyDown events (handles control/alt modified key events)
|
|
|
|
NS_IMETHODIMP
|
|
|
|
mozXMLTermKeyListener::KeyDown(nsIDOMEvent* aKeyEvent)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMKeyEvent> keyEvent;
|
|
|
|
keyEvent = do_QueryInterface(aKeyEvent);
|
|
|
|
if (!keyEvent) {
|
|
|
|
// Non-key event passed to keydown, do not consume it
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2000-02-29 18:55:36 +03:00
|
|
|
PRBool shiftKey, ctrlKey, altKey;
|
1999-12-06 09:32:12 +03:00
|
|
|
PRUint32 keyCode;
|
|
|
|
|
2000-02-29 18:55:36 +03:00
|
|
|
XMLT_LOG(mozXMLTermKeyListener::KeyDown,50,("mSuspend=0x%x\n",
|
|
|
|
mSuspend));
|
1999-12-06 09:32:12 +03:00
|
|
|
|
|
|
|
if (NS_SUCCEEDED(keyEvent->GetKeyCode(&keyCode)) &&
|
2000-02-29 18:55:36 +03:00
|
|
|
NS_SUCCEEDED(keyEvent->GetShiftKey(&shiftKey)) &&
|
1999-12-06 09:32:12 +03:00
|
|
|
NS_SUCCEEDED(keyEvent->GetCtrlKey(&ctrlKey)) &&
|
|
|
|
NS_SUCCEEDED(keyEvent->GetAltKey(&altKey)) ) {
|
|
|
|
|
|
|
|
XMLT_LOG(mozXMLTermKeyListener::KeyDown,52,
|
2000-02-29 18:55:36 +03:00
|
|
|
("code=0x%x, shift=%d, ctrl=%d, alt=%d\n",
|
|
|
|
keyCode, shiftKey, ctrlKey, altKey));
|
1999-12-06 09:32:12 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// Consume key down event
|
|
|
|
return NS_ERROR_BASE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
mozXMLTermKeyListener::KeyUp(nsIDOMEvent* aKeyEvent)
|
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Handle KeyPress events (non control/alt modified key events)
|
|
|
|
NS_IMETHODIMP
|
|
|
|
mozXMLTermKeyListener::KeyPress(nsIDOMEvent* aKeyEvent)
|
|
|
|
{
|
|
|
|
nsresult result;
|
|
|
|
|
2000-02-29 18:55:36 +03:00
|
|
|
XMLT_LOG(mozXMLTermKeyListener::KeyPress,50,("mSuspend=0x%x\n",
|
|
|
|
mSuspend));
|
1999-12-06 09:32:12 +03:00
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMKeyEvent> keyEvent;
|
|
|
|
keyEvent = do_QueryInterface(aKeyEvent);
|
|
|
|
if (!keyEvent) {
|
|
|
|
// Non-key event passed to keydown, do not consume it
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2000-02-29 18:55:36 +03:00
|
|
|
#if 0 // Debugging
|
|
|
|
nsCOMPtr<nsIPresShell> presShell;
|
|
|
|
result = mXMLTerminal->GetPresShell(getter_AddRefs(presShell));
|
|
|
|
if (NS_SUCCEEDED(result) && presShell) {
|
|
|
|
nsCOMPtr<nsIDOMSelection> selection;
|
|
|
|
result = presShell->GetSelection(SELECTION_NORMAL,
|
|
|
|
getter_AddRefs(selection));
|
|
|
|
if (NS_SUCCEEDED(result) && selection) {
|
|
|
|
nsCOMPtr<nsIDOMNode> childNode, parentNode;
|
|
|
|
result = selection->GetFocusNode(getter_AddRefs(childNode));
|
|
|
|
if (NS_SUCCEEDED(result) && childNode) {
|
|
|
|
PRInt32 j;
|
|
|
|
nsAutoString nodeName;
|
|
|
|
for (j=0; (j<6) && childNode; j++) {
|
|
|
|
result = childNode->GetParentNode(getter_AddRefs(parentNode));
|
|
|
|
if (NS_SUCCEEDED(result) && parentNode) {
|
|
|
|
result = parentNode->GetNodeName(nodeName);
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
nsCAutoString CNodeName = nodeName;
|
|
|
|
XMLT_LOG(mozXMLTermKeyListener::KeyPress,58,("nodeName=%s\n",
|
|
|
|
CNodeName.GetBuffer()));
|
|
|
|
}
|
|
|
|
childNode = parentNode;
|
|
|
|
} else {
|
|
|
|
childNode = nsnull;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
1999-12-06 09:32:12 +03:00
|
|
|
PRUint32 keyCode;
|
2000-02-29 18:55:36 +03:00
|
|
|
PRBool shiftKey, ctrlKey, altKey;
|
1999-12-06 09:32:12 +03:00
|
|
|
if (NS_SUCCEEDED(keyEvent->GetKeyCode(&keyCode)) &&
|
2000-02-29 18:55:36 +03:00
|
|
|
NS_SUCCEEDED(keyEvent->GetShiftKey(&shiftKey)) &&
|
1999-12-06 09:32:12 +03:00
|
|
|
NS_SUCCEEDED(keyEvent->GetCtrlKey(&ctrlKey)) &&
|
|
|
|
NS_SUCCEEDED(keyEvent->GetAltKey(&altKey)) ) {
|
|
|
|
|
|
|
|
PRUint32 keyChar = 0;
|
2000-02-29 18:55:36 +03:00
|
|
|
nsAutoString JSCommand = "";
|
|
|
|
|
1999-12-06 09:32:12 +03:00
|
|
|
result = keyEvent->GetCharCode(&keyChar);
|
|
|
|
|
|
|
|
XMLT_LOG(mozXMLTermKeyListener::KeyPress,52,
|
2000-02-29 18:55:36 +03:00
|
|
|
("code=0x%x, char=0x%x, shift=%d, ctrl=%d, alt=%d\n",
|
|
|
|
keyCode, keyChar, shiftKey, ctrlKey, altKey));
|
1999-12-06 09:32:12 +03:00
|
|
|
|
2000-02-29 18:55:36 +03:00
|
|
|
if (keyChar == 0) {
|
|
|
|
// Key that hasn't been mapped to a character code
|
1999-12-06 09:32:12 +03:00
|
|
|
|
2000-02-29 18:55:36 +03:00
|
|
|
switch (keyCode) {
|
|
|
|
case nsIDOMKeyEvent::DOM_VK_SHIFT:
|
|
|
|
case nsIDOMKeyEvent::DOM_VK_CONTROL:
|
|
|
|
case nsIDOMKeyEvent::DOM_VK_ALT:
|
|
|
|
break; // ignore modifier key event
|
|
|
|
case nsIDOMKeyEvent::DOM_VK_BACK_SPACE:
|
|
|
|
keyChar = U_BACKSPACE;
|
|
|
|
break;
|
2000-03-07 18:45:16 +03:00
|
|
|
case nsIDOMKeyEvent::DOM_VK_DELETE:
|
|
|
|
keyChar = U_DEL;
|
|
|
|
break;
|
2000-02-29 18:55:36 +03:00
|
|
|
case nsIDOMKeyEvent::DOM_VK_TAB:
|
|
|
|
keyChar = U_TAB;
|
|
|
|
break;
|
|
|
|
case nsIDOMKeyEvent::DOM_VK_RETURN:
|
2000-03-07 18:45:16 +03:00
|
|
|
keyChar = U_CRETURN;
|
2000-02-29 18:55:36 +03:00
|
|
|
break;
|
|
|
|
case nsIDOMKeyEvent::DOM_VK_LEFT:
|
|
|
|
keyChar = U_CTL_B;
|
|
|
|
break;
|
|
|
|
case nsIDOMKeyEvent::DOM_VK_RIGHT:
|
|
|
|
keyChar = U_CTL_F;
|
|
|
|
break;
|
|
|
|
case nsIDOMKeyEvent::DOM_VK_UP:
|
|
|
|
keyChar = U_CTL_P;
|
|
|
|
break;
|
|
|
|
case nsIDOMKeyEvent::DOM_VK_DOWN:
|
|
|
|
keyChar = U_CTL_N;
|
|
|
|
break;
|
|
|
|
case nsIDOMKeyEvent::DOM_VK_ESCAPE:
|
|
|
|
keyChar = U_ESCAPE;
|
|
|
|
break;
|
|
|
|
case nsIDOMKeyEvent::DOM_VK_HOME:
|
|
|
|
JSCommand = "ScrollHome";
|
|
|
|
break;
|
|
|
|
case nsIDOMKeyEvent::DOM_VK_END:
|
|
|
|
JSCommand = "ScrollEnd";
|
|
|
|
break;
|
|
|
|
case nsIDOMKeyEvent::DOM_VK_PAGE_UP:
|
|
|
|
JSCommand = "ScrollPageUp";
|
|
|
|
break;
|
|
|
|
case nsIDOMKeyEvent::DOM_VK_PAGE_DOWN:
|
|
|
|
JSCommand = "ScrollPageDown";
|
|
|
|
break;
|
2000-03-06 18:16:48 +03:00
|
|
|
case nsIDOMKeyEvent::DOM_VK_F1:
|
|
|
|
JSCommand = "HideAll";
|
|
|
|
break;
|
|
|
|
case nsIDOMKeyEvent::DOM_VK_F2:
|
|
|
|
JSCommand = "ShowAll";
|
|
|
|
break;
|
2000-02-29 18:55:36 +03:00
|
|
|
default: // ignore event without consuming
|
|
|
|
return NS_OK;
|
1999-12-06 09:32:12 +03:00
|
|
|
}
|
|
|
|
|
2000-02-29 18:55:36 +03:00
|
|
|
} else if ((ctrlKey == PR_TRUE) && (altKey == PR_FALSE) &&
|
2000-03-07 18:45:16 +03:00
|
|
|
(keyChar >= 0x40U) && (keyChar < 0x80U)) {
|
2000-02-29 18:55:36 +03:00
|
|
|
// Control character, without Alt; adjust character code
|
2000-03-07 18:45:16 +03:00
|
|
|
// Is this portable?
|
|
|
|
keyChar = (keyChar >= 0x60U) ? keyChar-0x60U : keyChar-0x40U;
|
2000-02-29 18:55:36 +03:00
|
|
|
}
|
1999-12-06 09:32:12 +03:00
|
|
|
|
2000-02-29 18:55:36 +03:00
|
|
|
if (JSCommand.Length() > 0) {
|
|
|
|
// Execute JS command
|
|
|
|
nsCOMPtr<nsIDOMDocument> domDocument;
|
|
|
|
result = mXMLTerminal->GetDocument(getter_AddRefs(domDocument));
|
|
|
|
|
|
|
|
if (NS_SUCCEEDED(result) && domDocument) {
|
|
|
|
nsAutoString JSInput = JSCommand;
|
|
|
|
nsAutoString JSOutput = "";
|
|
|
|
JSInput.Append("(");
|
|
|
|
JSInput.Append(shiftKey,10);
|
|
|
|
JSInput.Append(",");
|
|
|
|
JSInput.Append(ctrlKey,10);
|
|
|
|
JSInput.Append(");");
|
|
|
|
result = mozXMLTermUtils::ExecuteScript(domDocument,
|
|
|
|
JSInput,
|
|
|
|
JSOutput);
|
1999-12-06 09:32:12 +03:00
|
|
|
}
|
|
|
|
}
|
2000-02-29 18:55:36 +03:00
|
|
|
|
|
|
|
if (!mSuspend && (keyChar > 0) && (keyChar <= 0xFFFDU)) {
|
|
|
|
// Transmit valid non-null Unicode character
|
|
|
|
const PRUnichar temUString[] = {keyChar,0};
|
|
|
|
nsAutoString keyString(temUString);
|
|
|
|
result = mXMLTerminal->SendTextAux(keyString);
|
|
|
|
}
|
1999-12-06 09:32:12 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// Consume key press event
|
|
|
|
return NS_ERROR_BASE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
|
|
// mozXMLTermTextListener implementation
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
mozXMLTermTextListener::mozXMLTermTextListener()
|
|
|
|
{
|
|
|
|
NS_INIT_REFCNT();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
mozXMLTermTextListener::~mozXMLTermTextListener()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
NS_IMPL_ADDREF(mozXMLTermTextListener)
|
|
|
|
|
|
|
|
NS_IMPL_RELEASE(mozXMLTermTextListener)
|
|
|
|
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
mozXMLTermTextListener::QueryInterface(REFNSIID aIID, void** aInstancePtr)
|
|
|
|
{
|
|
|
|
if (aInstancePtr == NULL) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Always NULL result, in case of failure
|
|
|
|
*aInstancePtr = NULL;
|
|
|
|
|
2000-01-11 23:49:15 +03:00
|
|
|
if (aIID.Equals(NS_GET_IID(nsISupports))) {
|
1999-12-06 09:32:12 +03:00
|
|
|
*aInstancePtr = NS_STATIC_CAST(nsISupports*,
|
|
|
|
NS_STATIC_CAST(nsIDOMTextListener*,this));
|
|
|
|
|
2000-01-11 23:49:15 +03:00
|
|
|
} else if (aIID.Equals(NS_GET_IID(nsIDOMEventListener))) {
|
1999-12-06 09:32:12 +03:00
|
|
|
*aInstancePtr = NS_STATIC_CAST(nsIDOMEventListener*,this);
|
|
|
|
|
2000-01-11 23:49:15 +03:00
|
|
|
} else if (aIID.Equals(NS_GET_IID(nsIDOMTextListener))) {
|
1999-12-06 09:32:12 +03:00
|
|
|
*aInstancePtr = NS_STATIC_CAST(nsIDOMTextListener*,this);
|
|
|
|
|
|
|
|
} else {
|
|
|
|
return NS_ERROR_NO_INTERFACE;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
mozXMLTermTextListener::HandleEvent(nsIDOMEvent* aEvent)
|
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
mozXMLTermTextListener::HandleText(nsIDOMEvent* aTextEvent)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIPrivateTextEvent> textEvent (do_QueryInterface(aTextEvent));
|
|
|
|
if (!textEvent) {
|
|
|
|
// Soft failure
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
XMLT_LOG(mozXMLTermTextListener::HandleText,50,("\n"));
|
|
|
|
|
|
|
|
nsAutoString textStr;
|
|
|
|
textEvent->GetText(textStr);
|
|
|
|
|
|
|
|
// Transmit text to terminal
|
|
|
|
mXMLTerminal->SendTextAux(textStr);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
|
|
// mozXMLTermMouseListener implementation
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
mozXMLTermMouseListener::mozXMLTermMouseListener()
|
|
|
|
{
|
|
|
|
NS_INIT_REFCNT();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
mozXMLTermMouseListener::~mozXMLTermMouseListener()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
NS_IMPL_ADDREF(mozXMLTermMouseListener)
|
|
|
|
|
|
|
|
NS_IMPL_RELEASE(mozXMLTermMouseListener)
|
|
|
|
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
mozXMLTermMouseListener::QueryInterface(REFNSIID aIID, void** aInstancePtr)
|
|
|
|
{
|
|
|
|
if (aInstancePtr == NULL) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Always NULL result, in case of failure
|
|
|
|
*aInstancePtr = NULL;
|
|
|
|
|
2000-01-11 23:49:15 +03:00
|
|
|
if (aIID.Equals(NS_GET_IID(nsISupports))) {
|
1999-12-06 09:32:12 +03:00
|
|
|
*aInstancePtr = NS_STATIC_CAST(nsISupports*,
|
|
|
|
NS_STATIC_CAST(nsIDOMMouseListener*,this));
|
|
|
|
|
2000-01-11 23:49:15 +03:00
|
|
|
} else if (aIID.Equals(NS_GET_IID(nsIDOMEventListener))) {
|
1999-12-06 09:32:12 +03:00
|
|
|
*aInstancePtr = NS_STATIC_CAST(nsIDOMEventListener*,this);
|
|
|
|
|
2000-01-11 23:49:15 +03:00
|
|
|
} else if (aIID.Equals(NS_GET_IID(nsIDOMMouseListener))) {
|
1999-12-06 09:32:12 +03:00
|
|
|
*aInstancePtr = NS_STATIC_CAST(nsIDOMMouseListener*,this);
|
|
|
|
|
|
|
|
} else {
|
|
|
|
return NS_ERROR_NO_INTERFACE;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
mozXMLTermMouseListener::HandleEvent(nsIDOMEvent* aEvent)
|
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
mozXMLTermMouseListener::MouseDown(nsIDOMEvent* aMouseEvent)
|
|
|
|
{
|
|
|
|
if (!aMouseEvent)
|
|
|
|
return NS_OK;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMMouseEvent> mouseEvent;
|
|
|
|
mouseEvent = do_QueryInterface(aMouseEvent);
|
|
|
|
if (!mouseEvent) {
|
|
|
|
// Non-mouse event passed; do not consume it
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
PRUint16 buttonCode = 0;
|
|
|
|
mouseEvent->GetButton(&buttonCode);
|
|
|
|
|
|
|
|
XMLT_LOG(mozXMLTermMouseListener::MouseDown,50,("buttonCode=%d\n",
|
|
|
|
buttonCode));
|
|
|
|
|
|
|
|
if (buttonCode == 2) {
|
|
|
|
// Middle-mouse button pressed; initiate paste
|
|
|
|
mXMLTerminal->Paste();
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
mozXMLTermMouseListener::MouseUp(nsIDOMEvent* aMouseEvent)
|
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
mozXMLTermMouseListener::MouseClick(nsIDOMEvent* aMouseEvent)
|
|
|
|
{
|
2000-03-01 18:50:23 +03:00
|
|
|
nsresult result;
|
|
|
|
|
|
|
|
if (!aMouseEvent)
|
|
|
|
return NS_OK;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMMouseEvent> mouseEvent;
|
|
|
|
mouseEvent = do_QueryInterface(aMouseEvent);
|
|
|
|
if (!mouseEvent) {
|
|
|
|
// Non-mouse event passed; do not consume it
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
PRUint16 buttonCode = 0;
|
|
|
|
mouseEvent->GetButton(&buttonCode);
|
|
|
|
|
|
|
|
PRInt32 screenX, screenY;
|
|
|
|
result = mouseEvent->GetScreenX(&screenX);
|
|
|
|
result = mouseEvent->GetScreenY(&screenY);
|
|
|
|
|
|
|
|
XMLT_LOG(mozXMLTermMouseListener::MouseClick,50, ("buttonCode=%d\n",
|
|
|
|
buttonCode));
|
|
|
|
|
|
|
|
#ifndef NO_WORKAROUND
|
|
|
|
// Without this workaround, clicking on the xmlterm window to give it
|
|
|
|
// focus fails position the cursor at the end of the last line
|
|
|
|
// (For some reason, the MouseDown event causes the cursor to be positioned
|
|
|
|
// in the line above the location of the mouse click
|
|
|
|
|
|
|
|
// Get selection
|
|
|
|
nsCOMPtr<nsIPresShell> presShell;
|
|
|
|
result = mXMLTerminal->GetPresShell(getter_AddRefs(presShell));
|
|
|
|
if (NS_FAILED(result) || !presShell)
|
|
|
|
return NS_OK; // Do not consume mouse event
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMSelection> selection;
|
|
|
|
result = presShell->GetSelection(SELECTION_NORMAL,
|
|
|
|
getter_AddRefs(selection));
|
|
|
|
|
|
|
|
if (NS_FAILED(result) || !selection)
|
|
|
|
return NS_OK; // Do not consume mouse event
|
|
|
|
|
|
|
|
// Locate selection range
|
|
|
|
nsCOMPtr<nsIDOMNSUIEvent> uiEvent (do_QueryInterface(mouseEvent));
|
|
|
|
if (!uiEvent)
|
|
|
|
return NS_OK; // Do not consume mouse event
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMNode> parentNode;
|
|
|
|
result = uiEvent->GetRangeParent(getter_AddRefs(parentNode));
|
|
|
|
if (NS_FAILED(result) || !parentNode)
|
|
|
|
return NS_OK; // Do not consume mouse event
|
|
|
|
|
|
|
|
PRInt32 offset = 0;
|
|
|
|
result = uiEvent->GetRangeOffset(&offset);
|
|
|
|
if (NS_FAILED(result))
|
|
|
|
return NS_OK; // Do not consume mouse event
|
|
|
|
|
|
|
|
(void)selection->Collapse(parentNode, offset);
|
|
|
|
#endif // !NO_WORKAROUND
|
|
|
|
|
|
|
|
return NS_OK; // Do not consume mouse event
|
1999-12-06 09:32:12 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
mozXMLTermMouseListener::MouseDblClick(nsIDOMEvent* aMouseEvent)
|
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
mozXMLTermMouseListener::MouseOver(nsIDOMEvent* aMouseEvent)
|
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
mozXMLTermMouseListener::MouseOut(nsIDOMEvent* aMouseEvent)
|
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
|
|
// mozXMLTermDragListener implementation
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
mozXMLTermDragListener::mozXMLTermDragListener()
|
|
|
|
{
|
|
|
|
NS_INIT_REFCNT();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
mozXMLTermDragListener::~mozXMLTermDragListener()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
NS_IMPL_ADDREF(mozXMLTermDragListener)
|
|
|
|
|
|
|
|
NS_IMPL_RELEASE(mozXMLTermDragListener)
|
|
|
|
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
mozXMLTermDragListener::QueryInterface(REFNSIID aIID, void** aInstancePtr)
|
|
|
|
{
|
|
|
|
if (aInstancePtr == NULL) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Always NULL result, in case of failure
|
|
|
|
*aInstancePtr = NULL;
|
|
|
|
|
2000-01-11 23:49:15 +03:00
|
|
|
if (aIID.Equals(NS_GET_IID(nsISupports))) {
|
1999-12-06 09:32:12 +03:00
|
|
|
*aInstancePtr = NS_STATIC_CAST(nsISupports*,
|
|
|
|
NS_STATIC_CAST(nsIDOMDragListener*,this));
|
|
|
|
|
2000-01-11 23:49:15 +03:00
|
|
|
} else if (aIID.Equals(NS_GET_IID(nsIDOMEventListener))) {
|
1999-12-06 09:32:12 +03:00
|
|
|
*aInstancePtr = NS_STATIC_CAST(nsIDOMEventListener*,this);
|
|
|
|
|
2000-01-11 23:49:15 +03:00
|
|
|
} else if (aIID.Equals(NS_GET_IID(nsIDOMDragListener))) {
|
1999-12-06 09:32:12 +03:00
|
|
|
*aInstancePtr = NS_STATIC_CAST(nsIDOMDragListener*,this);
|
|
|
|
|
|
|
|
} else {
|
|
|
|
return NS_ERROR_NO_INTERFACE;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
mozXMLTermDragListener::HandleEvent(nsIDOMEvent* aEvent)
|
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
mozXMLTermDragListener::DragEnter(nsIDOMEvent* aDragEvent)
|
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
mozXMLTermDragListener::DragOver(nsIDOMEvent* aDragEvent)
|
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
mozXMLTermDragListener::DragExit(nsIDOMEvent* aDragEvent)
|
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
mozXMLTermDragListener::DragDrop(nsIDOMEvent* aDragEvent)
|
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
mozXMLTermDragListener::DragGesture(nsIDOMEvent* aDragEvent)
|
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|