1999-02-12 20:18:58 +03:00
|
|
|
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
|
|
*
|
|
|
|
* The contents of this file are subject to the Netscape Public License
|
|
|
|
* Version 1.0 (the "NPL"); you may not use this file except in
|
|
|
|
* compliance with the NPL. You may obtain a copy of the NPL at
|
|
|
|
* http://www.mozilla.org/NPL/
|
|
|
|
*
|
|
|
|
* Software distributed under the NPL is distributed on an "AS IS" basis,
|
|
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
|
|
|
|
* for the specific language governing rights and limitations under the
|
|
|
|
* NPL.
|
|
|
|
*
|
|
|
|
* The Initial Developer of this code under the NPL is Netscape
|
|
|
|
* Communications Corporation. Portions created by Netscape are
|
|
|
|
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
|
|
|
|
* Reserved.
|
|
|
|
*/
|
|
|
|
#include "nsEditorEventListeners.h"
|
|
|
|
#include "nsEditor.h"
|
1999-08-09 05:37:50 +04:00
|
|
|
#include "nsVoidArray.h"
|
|
|
|
#include "nsString.h"
|
|
|
|
|
1999-02-12 20:18:58 +03:00
|
|
|
#include "nsIDOMDocument.h"
|
Preparation for ender-based text control
* added focus listener. Doesn't do much yet, but when focus notifications start appearing, we'll be ready for them. The code is in
place to hide selection when we lose focus and paint selection when we get focus. That's probably not quite right, but it's a start.
We will need to be able to determine the distinction between losing focus to another control within our app, and losing focus to
another app.
* added support for disabled and readonly states in the editor. This is accomplished by having flags set by the client, and letting the
rules system deal with those flags. The flags I added are:
TEXT_EDITOR_FLAG_PLAINTEXT 0x01 // only plain text editing is allowed
TEXT_EDITOR_FLAG_SINGLELINE 0x02 // enter key and CR-LF handled specially
TEXT_EDITOR_FLAG_PASSWORD 0x04 // text is not entered into content, only a representative character
TEXT_EDITOR_FLAG_READONLY 0x08 // editing events are disabled. Editor may still accept focus.
TEXT_EDITOR_FLAG_DISALBED 0x10 // all events are disabled (like scrolling). Editor will not accept focus.
* added WillInsertBreak/DidInsertBreak into text rules, so flags could be checked. This gets us readonly, disabled, and single line
behavior.
* cleaned up the code that allocates, registers, and destroys event listeners. Thanks to Kin and Simon for cleaning up the
ownership model on the listeners, it was a big help.
* added support for a max text length. You can now tell the text editor, be no bigger than n characters.
1999-05-29 01:24:18 +04:00
|
|
|
#include "nsIDocument.h"
|
|
|
|
#include "nsIPresShell.h"
|
1999-02-12 20:18:58 +03:00
|
|
|
#include "nsIDOMElement.h"
|
1999-05-07 23:22:38 +04:00
|
|
|
#include "nsIDOMSelection.h"
|
1999-02-12 20:18:58 +03:00
|
|
|
#include "nsIDOMCharacterData.h"
|
1999-02-24 20:24:37 +03:00
|
|
|
#include "nsIEditProperty.h"
|
|
|
|
#include "nsISupportsArray.h"
|
1999-03-23 01:10:29 +03:00
|
|
|
#include "nsIStringStream.h"
|
1999-05-19 03:51:04 +04:00
|
|
|
#include "nsIDOMUIEvent.h"
|
1999-06-09 01:51:40 +04:00
|
|
|
#include "nsIDOMNSUIEvent.h"
|
1999-08-06 06:32:13 +04:00
|
|
|
#include "nsIPrivateTextEvent.h"
|
1999-08-31 05:20:32 +04:00
|
|
|
#include "nsIPrivateCompositionEvent.h"
|
1999-08-09 05:37:50 +04:00
|
|
|
#include "nsIEditorMailSupport.h"
|
1999-08-24 22:30:19 +04:00
|
|
|
#include "nsIDocumentEncoder.h"
|
1999-04-20 21:43:26 +04:00
|
|
|
|
1999-08-02 17:53:23 +04:00
|
|
|
// for repainting hack only
|
|
|
|
#include "nsIView.h"
|
|
|
|
#include "nsIViewManager.h"
|
|
|
|
// end repainting hack only
|
|
|
|
|
1999-04-07 00:24:09 +04:00
|
|
|
// Drag & Drop, Clipboard
|
|
|
|
#include "nsIServiceManager.h"
|
|
|
|
#include "nsWidgetsCID.h"
|
|
|
|
#include "nsIClipboard.h"
|
1999-04-17 17:52:28 +04:00
|
|
|
#include "nsIDragService.h"
|
1999-05-07 23:42:27 +04:00
|
|
|
#include "nsIDragSession.h"
|
1999-04-07 00:24:09 +04:00
|
|
|
#include "nsITransferable.h"
|
|
|
|
#include "nsIFormatConverter.h"
|
1999-08-19 17:30:48 +04:00
|
|
|
#include "nsIContentIterator.h"
|
|
|
|
#include "nsIContent.h"
|
1999-08-25 12:35:06 +04:00
|
|
|
#include "nsISupportsPrimitives.h"
|
1999-08-19 17:30:48 +04:00
|
|
|
#include "nsLayoutCID.h"
|
1999-04-07 00:24:09 +04:00
|
|
|
|
|
|
|
// Drag & Drop, Clipboard Support
|
1999-05-07 23:42:27 +04:00
|
|
|
static NS_DEFINE_CID(kCDragServiceCID, NS_DRAGSERVICE_CID);
|
1999-05-14 01:53:57 +04:00
|
|
|
static NS_DEFINE_CID(kCTransferableCID, NS_TRANSFERABLE_CID);
|
1999-05-07 23:42:27 +04:00
|
|
|
static NS_DEFINE_IID(kCDataFlavorCID, NS_DATAFLAVOR_CID);
|
1999-08-19 17:30:48 +04:00
|
|
|
static NS_DEFINE_IID(kContentIteratorCID, NS_CONTENTITERATOR_CID);
|
|
|
|
static NS_DEFINE_CID(kCClipboardCID, NS_CLIPBOARD_CID);
|
|
|
|
static NS_DEFINE_IID(kCXIFConverterCID, NS_XIFFORMATCONVERTER_CID);
|
|
|
|
|
1999-04-07 00:24:09 +04:00
|
|
|
|
|
|
|
|
1999-02-12 20:18:58 +03:00
|
|
|
/*
|
|
|
|
* nsTextEditorKeyListener implementation
|
|
|
|
*/
|
|
|
|
|
|
|
|
NS_IMPL_ADDREF(nsTextEditorKeyListener)
|
|
|
|
|
|
|
|
NS_IMPL_RELEASE(nsTextEditorKeyListener)
|
|
|
|
|
|
|
|
|
1999-03-20 02:36:20 +03:00
|
|
|
nsTextEditorKeyListener::nsTextEditorKeyListener()
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
|
|
|
NS_INIT_REFCNT();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
nsTextEditorKeyListener::~nsTextEditorKeyListener()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsTextEditorKeyListener::QueryInterface(REFNSIID aIID, void** aInstancePtr)
|
|
|
|
{
|
|
|
|
if (nsnull == aInstancePtr) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
1999-06-30 01:01:31 +04:00
|
|
|
if (aIID.Equals(nsCOMTypeInfo<nsISupports>::GetIID())) {
|
1999-02-12 20:18:58 +03:00
|
|
|
*aInstancePtr = (void*)(nsISupports*)this;
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
1999-05-28 04:19:51 +04:00
|
|
|
if (aIID.Equals(nsIDOMEventListener::GetIID())) {
|
1999-02-12 20:18:58 +03:00
|
|
|
*aInstancePtr = (void*)(nsIDOMEventListener*)this;
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
1999-05-28 04:19:51 +04:00
|
|
|
if (aIID.Equals(nsIDOMKeyListener::GetIID())) {
|
1999-02-12 20:18:58 +03:00
|
|
|
*aInstancePtr = (void*)(nsIDOMKeyListener*)this;
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
return NS_NOINTERFACE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
nsresult
|
1999-03-29 02:27:38 +04:00
|
|
|
nsTextEditorKeyListener::HandleEvent(nsIDOMEvent* aEvent)
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-07-07 03:31:08 +04:00
|
|
|
// individual key handlers return NS_OK to indicate NOT consumed
|
|
|
|
// by default, an error is returned indicating event is consumed
|
|
|
|
// joki is fixing this interface.
|
1999-06-04 09:14:01 +04:00
|
|
|
nsresult
|
|
|
|
nsTextEditorKeyListener::KeyDown(nsIDOMEvent* aKeyEvent)
|
|
|
|
{
|
1999-09-19 14:30:30 +04:00
|
|
|
PRUint32 keyCode;
|
|
|
|
nsCOMPtr<nsIDOMUIEvent>uiEvent;
|
|
|
|
uiEvent = do_QueryInterface(aKeyEvent);
|
|
|
|
if (uiEvent)
|
|
|
|
{
|
|
|
|
if (NS_SUCCEEDED(uiEvent->GetKeyCode(&keyCode)))
|
|
|
|
{
|
1999-09-21 18:19:17 +04:00
|
|
|
if (nsIDOMUIEvent::DOM_VK_TAB==keyCode)
|
1999-09-19 14:30:30 +04:00
|
|
|
{
|
|
|
|
nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(mEditor);
|
|
|
|
PRUint32 flags=0;
|
|
|
|
mEditor->GetFlags(&flags);
|
|
|
|
if ((flags & nsIHTMLEditor::eEditorSingleLineMask))
|
|
|
|
return NS_OK; // let it be used for focus switching
|
|
|
|
|
|
|
|
// else we insert the tab straight through
|
|
|
|
htmlEditor->EditorKeyPress(uiEvent);
|
|
|
|
ScrollSelectionIntoView();
|
|
|
|
return NS_ERROR_BASE; // "I handled the event, don't do default processing"
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
1999-09-18 00:11:13 +04:00
|
|
|
return NS_OK;
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsTextEditorKeyListener::KeyUp(nsIDOMEvent* aKeyEvent)
|
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1999-06-04 09:14:01 +04:00
|
|
|
nsresult
|
|
|
|
nsTextEditorKeyListener::KeyPress(nsIDOMEvent* aKeyEvent)
|
|
|
|
{
|
1999-08-25 14:51:55 +04:00
|
|
|
nsCOMPtr<nsIDOMUIEvent>uiEvent;
|
|
|
|
uiEvent = do_QueryInterface(aKeyEvent);
|
|
|
|
if (!uiEvent)
|
|
|
|
{
|
|
|
|
//non-key event passed to keydown. bad things.
|
|
|
|
return NS_OK;
|
|
|
|
}
|
1999-07-08 23:52:44 +04:00
|
|
|
|
1999-08-20 17:14:03 +04:00
|
|
|
PRBool keyProcessed;
|
1999-09-20 08:16:34 +04:00
|
|
|
// we should check a flag here to see if we should be using built-in key bindings
|
|
|
|
// mEditor->GetFlags(&flags);
|
|
|
|
// if (flags & ...)
|
1999-08-20 17:14:03 +04:00
|
|
|
ProcessShortCutKeys(aKeyEvent, keyProcessed);
|
|
|
|
if (PR_FALSE==keyProcessed)
|
|
|
|
{
|
landing keyEvent_19991004_BRANCH
bugs # see the log of the check in into branch
author/reviewer:
mozilla/layout/base/src/nsRangeList.cpp brade/mjudge
mozilla/layout/html/forms/src/nsGfxTextControlFrame.cpp brade/ftang
mozilla/layout/events/src/nsDOMEvent.cpp brade/joki
mozilla/layout/events/src/nsEventStateManager.cpp brade/joki
mozilla/widget/public/nsGUIEvent.h akkana/ftang
mozilla/widget/src/windows/nsWindow.cpp ftang/mjudge
mozilla/widget/src/windows/nsWindow.h ftang/mjudge
mozilla/widget/src/mac/nsTextAreaWidget.cpp brade/ftang
mozilla/widget/src/mac/nsMacEventHandler.cpp brade/simon
mozilla/widget/src/xpwidgets/nsKeyBindMgr.cpp brade/ftang
mozilla/widget/src/gtk/nsGtkEventHandler.cpp akkana/?
mozilla/widget/src/gtk/nsWidget.cpp erik/ftang
mozilla/layout/xul/base/src/nsTreeCellFrame.cpp brade/ftang
mozilla/editor/base/nsEditorEventListeners.cpp brade/akkana
mozilla/editor/base/nsHTMLEditor.cpp brade/akkana
mozilla/rdf/content/src/nsXULKeyListener.cpp ftang/saari
fix the master bug- 15693
fix at least, but not limited to, the following bugs
10158,11956,6053,9333,10901,14348,6449,11845,13016,14410,15657,15307,15842,13856
1999-10-14 22:27:01 +04:00
|
|
|
PRUint32 keyCode;
|
1999-09-20 08:16:34 +04:00
|
|
|
uiEvent->GetKeyCode(&keyCode);
|
1999-08-25 14:51:55 +04:00
|
|
|
|
|
|
|
nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(mEditor);
|
|
|
|
if (!htmlEditor) return NS_ERROR_NO_INTERFACE;
|
|
|
|
|
1999-09-20 08:16:34 +04:00
|
|
|
// if there is no charCode, then it's a key that doesn't map to a character,
|
|
|
|
// so look for special keys using keyCode
|
landing keyEvent_19991004_BRANCH
bugs # see the log of the check in into branch
author/reviewer:
mozilla/layout/base/src/nsRangeList.cpp brade/mjudge
mozilla/layout/html/forms/src/nsGfxTextControlFrame.cpp brade/ftang
mozilla/layout/events/src/nsDOMEvent.cpp brade/joki
mozilla/layout/events/src/nsEventStateManager.cpp brade/joki
mozilla/widget/public/nsGUIEvent.h akkana/ftang
mozilla/widget/src/windows/nsWindow.cpp ftang/mjudge
mozilla/widget/src/windows/nsWindow.h ftang/mjudge
mozilla/widget/src/mac/nsTextAreaWidget.cpp brade/ftang
mozilla/widget/src/mac/nsMacEventHandler.cpp brade/simon
mozilla/widget/src/xpwidgets/nsKeyBindMgr.cpp brade/ftang
mozilla/widget/src/gtk/nsGtkEventHandler.cpp akkana/?
mozilla/widget/src/gtk/nsWidget.cpp erik/ftang
mozilla/layout/xul/base/src/nsTreeCellFrame.cpp brade/ftang
mozilla/editor/base/nsEditorEventListeners.cpp brade/akkana
mozilla/editor/base/nsHTMLEditor.cpp brade/akkana
mozilla/rdf/content/src/nsXULKeyListener.cpp ftang/saari
fix the master bug- 15693
fix at least, but not limited to, the following bugs
10158,11956,6053,9333,10901,14348,6449,11845,13016,14410,15657,15307,15842,13856
1999-10-14 22:27:01 +04:00
|
|
|
if (0 != keyCode)
|
1999-08-25 14:51:55 +04:00
|
|
|
{
|
1999-10-21 00:02:44 +04:00
|
|
|
if (nsIDOMUIEvent::DOM_VK_SHIFT==keyCode
|
|
|
|
|| nsIDOMUIEvent::DOM_VK_CONTROL==keyCode
|
|
|
|
|| nsIDOMUIEvent::DOM_VK_ALT==keyCode)
|
|
|
|
return NS_ERROR_BASE; // consumed
|
1999-09-21 18:19:17 +04:00
|
|
|
if (nsIDOMUIEvent::DOM_VK_BACK==keyCode)
|
1999-08-25 14:51:55 +04:00
|
|
|
{
|
|
|
|
mEditor->DeleteSelection(nsIEditor::eDeletePrevious);
|
1999-08-31 05:14:40 +04:00
|
|
|
ScrollSelectionIntoView();
|
|
|
|
return NS_ERROR_BASE; // consumed
|
1999-08-25 14:51:55 +04:00
|
|
|
}
|
1999-09-21 18:19:17 +04:00
|
|
|
if (nsIDOMUIEvent::DOM_VK_DELETE==keyCode)
|
1999-09-18 00:11:13 +04:00
|
|
|
{
|
|
|
|
mEditor->DeleteSelection(nsIEditor::eDeleteNext);
|
|
|
|
ScrollSelectionIntoView();
|
|
|
|
return NS_ERROR_BASE; // consumed
|
|
|
|
}
|
1999-09-21 18:19:17 +04:00
|
|
|
if (nsIDOMUIEvent::DOM_VK_TAB==keyCode)
|
1999-09-18 00:11:13 +04:00
|
|
|
{
|
|
|
|
PRUint32 flags=0;
|
|
|
|
mEditor->GetFlags(&flags);
|
|
|
|
if ((flags & nsIHTMLEditor::eEditorSingleLineMask))
|
|
|
|
return NS_OK; // let it be used for focus switching
|
|
|
|
|
|
|
|
// else we insert the tab straight through
|
|
|
|
htmlEditor->EditorKeyPress(uiEvent);
|
|
|
|
ScrollSelectionIntoView();
|
|
|
|
return NS_ERROR_BASE; // "I handled the event, don't do default processing"
|
|
|
|
}
|
1999-09-21 18:19:17 +04:00
|
|
|
if (nsIDOMUIEvent::DOM_VK_RETURN==keyCode)
|
1999-08-23 10:42:04 +04:00
|
|
|
{
|
1999-09-18 00:11:13 +04:00
|
|
|
PRUint32 flags=0;
|
1999-08-23 10:42:04 +04:00
|
|
|
mEditor->GetFlags(&flags);
|
|
|
|
if (!(flags & nsIHTMLEditor::eEditorSingleLineMask))
|
|
|
|
{
|
1999-09-13 13:37:51 +04:00
|
|
|
//htmlEditor->InsertBreak();
|
|
|
|
htmlEditor->EditorKeyPress(uiEvent);
|
1999-08-31 05:14:40 +04:00
|
|
|
ScrollSelectionIntoView();
|
1999-08-25 14:51:55 +04:00
|
|
|
return NS_ERROR_BASE; // consumed
|
1999-08-23 10:42:04 +04:00
|
|
|
}
|
1999-08-25 14:51:55 +04:00
|
|
|
else
|
|
|
|
{
|
1999-08-23 10:42:04 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
1999-08-25 14:51:55 +04:00
|
|
|
}
|
|
|
|
}
|
1999-09-13 13:37:51 +04:00
|
|
|
|
landing keyEvent_19991004_BRANCH
bugs # see the log of the check in into branch
author/reviewer:
mozilla/layout/base/src/nsRangeList.cpp brade/mjudge
mozilla/layout/html/forms/src/nsGfxTextControlFrame.cpp brade/ftang
mozilla/layout/events/src/nsDOMEvent.cpp brade/joki
mozilla/layout/events/src/nsEventStateManager.cpp brade/joki
mozilla/widget/public/nsGUIEvent.h akkana/ftang
mozilla/widget/src/windows/nsWindow.cpp ftang/mjudge
mozilla/widget/src/windows/nsWindow.h ftang/mjudge
mozilla/widget/src/mac/nsTextAreaWidget.cpp brade/ftang
mozilla/widget/src/mac/nsMacEventHandler.cpp brade/simon
mozilla/widget/src/xpwidgets/nsKeyBindMgr.cpp brade/ftang
mozilla/widget/src/gtk/nsGtkEventHandler.cpp akkana/?
mozilla/widget/src/gtk/nsWidget.cpp erik/ftang
mozilla/layout/xul/base/src/nsTreeCellFrame.cpp brade/ftang
mozilla/editor/base/nsEditorEventListeners.cpp brade/akkana
mozilla/editor/base/nsHTMLEditor.cpp brade/akkana
mozilla/rdf/content/src/nsXULKeyListener.cpp ftang/saari
fix the master bug- 15693
fix at least, but not limited to, the following bugs
10158,11956,6053,9333,10901,14348,6449,11845,13016,14410,15657,15307,15842,13856
1999-10-14 22:27:01 +04:00
|
|
|
#if 0
|
1999-09-21 18:19:17 +04:00
|
|
|
// XXX: this must change. DOM_VK_tab must be handled here, not in keyDown
|
|
|
|
if (nsIDOMUIEvent::DOM_VK_TAB==keyCode)
|
1999-08-25 14:51:55 +04:00
|
|
|
{
|
|
|
|
return NS_OK; // ignore tabs here, they're handled in keyDown if at all
|
|
|
|
}
|
landing keyEvent_19991004_BRANCH
bugs # see the log of the check in into branch
author/reviewer:
mozilla/layout/base/src/nsRangeList.cpp brade/mjudge
mozilla/layout/html/forms/src/nsGfxTextControlFrame.cpp brade/ftang
mozilla/layout/events/src/nsDOMEvent.cpp brade/joki
mozilla/layout/events/src/nsEventStateManager.cpp brade/joki
mozilla/widget/public/nsGUIEvent.h akkana/ftang
mozilla/widget/src/windows/nsWindow.cpp ftang/mjudge
mozilla/widget/src/windows/nsWindow.h ftang/mjudge
mozilla/widget/src/mac/nsTextAreaWidget.cpp brade/ftang
mozilla/widget/src/mac/nsMacEventHandler.cpp brade/simon
mozilla/widget/src/xpwidgets/nsKeyBindMgr.cpp brade/ftang
mozilla/widget/src/gtk/nsGtkEventHandler.cpp akkana/?
mozilla/widget/src/gtk/nsWidget.cpp erik/ftang
mozilla/layout/xul/base/src/nsTreeCellFrame.cpp brade/ftang
mozilla/editor/base/nsEditorEventListeners.cpp brade/akkana
mozilla/editor/base/nsHTMLEditor.cpp brade/akkana
mozilla/rdf/content/src/nsXULKeyListener.cpp ftang/saari
fix the master bug- 15693
fix at least, but not limited to, the following bugs
10158,11956,6053,9333,10901,14348,6449,11845,13016,14410,15657,15307,15842,13856
1999-10-14 22:27:01 +04:00
|
|
|
#endif
|
|
|
|
|
|
|
|
htmlEditor->EditorKeyPress(uiEvent);
|
|
|
|
ScrollSelectionIntoView();
|
1999-08-25 14:51:55 +04:00
|
|
|
}
|
1999-08-31 05:14:40 +04:00
|
|
|
else
|
|
|
|
ScrollSelectionIntoView();
|
1999-08-25 14:51:55 +04:00
|
|
|
|
|
|
|
return NS_ERROR_BASE; // consumed
|
1999-06-04 09:14:01 +04:00
|
|
|
|
|
|
|
}
|
|
|
|
|
1999-02-12 20:18:58 +03:00
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsTextEditorKeyListener::ProcessShortCutKeys(nsIDOMEvent* aKeyEvent, PRBool& aProcessed)
|
|
|
|
{
|
|
|
|
aProcessed=PR_FALSE;
|
landing keyEvent_19991004_BRANCH
bugs # see the log of the check in into branch
author/reviewer:
mozilla/layout/base/src/nsRangeList.cpp brade/mjudge
mozilla/layout/html/forms/src/nsGfxTextControlFrame.cpp brade/ftang
mozilla/layout/events/src/nsDOMEvent.cpp brade/joki
mozilla/layout/events/src/nsEventStateManager.cpp brade/joki
mozilla/widget/public/nsGUIEvent.h akkana/ftang
mozilla/widget/src/windows/nsWindow.cpp ftang/mjudge
mozilla/widget/src/windows/nsWindow.h ftang/mjudge
mozilla/widget/src/mac/nsTextAreaWidget.cpp brade/ftang
mozilla/widget/src/mac/nsMacEventHandler.cpp brade/simon
mozilla/widget/src/xpwidgets/nsKeyBindMgr.cpp brade/ftang
mozilla/widget/src/gtk/nsGtkEventHandler.cpp akkana/?
mozilla/widget/src/gtk/nsWidget.cpp erik/ftang
mozilla/layout/xul/base/src/nsTreeCellFrame.cpp brade/ftang
mozilla/editor/base/nsEditorEventListeners.cpp brade/akkana
mozilla/editor/base/nsHTMLEditor.cpp brade/akkana
mozilla/rdf/content/src/nsXULKeyListener.cpp ftang/saari
fix the master bug- 15693
fix at least, but not limited to, the following bugs
10158,11956,6053,9333,10901,14348,6449,11845,13016,14410,15657,15307,15842,13856
1999-10-14 22:27:01 +04:00
|
|
|
PRUint32 charCode;
|
1999-02-12 20:18:58 +03:00
|
|
|
PRBool ctrlKey;
|
1999-10-15 18:52:45 +04:00
|
|
|
PRBool isAltKey, isMetaKey, isShiftKey;
|
1999-05-19 03:51:04 +04:00
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMUIEvent>uiEvent;
|
|
|
|
uiEvent = do_QueryInterface(aKeyEvent);
|
|
|
|
if (!uiEvent) {
|
|
|
|
//non-key event passed in. bad things.
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
landing keyEvent_19991004_BRANCH
bugs # see the log of the check in into branch
author/reviewer:
mozilla/layout/base/src/nsRangeList.cpp brade/mjudge
mozilla/layout/html/forms/src/nsGfxTextControlFrame.cpp brade/ftang
mozilla/layout/events/src/nsDOMEvent.cpp brade/joki
mozilla/layout/events/src/nsEventStateManager.cpp brade/joki
mozilla/widget/public/nsGUIEvent.h akkana/ftang
mozilla/widget/src/windows/nsWindow.cpp ftang/mjudge
mozilla/widget/src/windows/nsWindow.h ftang/mjudge
mozilla/widget/src/mac/nsTextAreaWidget.cpp brade/ftang
mozilla/widget/src/mac/nsMacEventHandler.cpp brade/simon
mozilla/widget/src/xpwidgets/nsKeyBindMgr.cpp brade/ftang
mozilla/widget/src/gtk/nsGtkEventHandler.cpp akkana/?
mozilla/widget/src/gtk/nsWidget.cpp erik/ftang
mozilla/layout/xul/base/src/nsTreeCellFrame.cpp brade/ftang
mozilla/editor/base/nsEditorEventListeners.cpp brade/akkana
mozilla/editor/base/nsHTMLEditor.cpp brade/akkana
mozilla/rdf/content/src/nsXULKeyListener.cpp ftang/saari
fix the master bug- 15693
fix at least, but not limited to, the following bugs
10158,11956,6053,9333,10901,14348,6449,11845,13016,14410,15657,15307,15842,13856
1999-10-14 22:27:01 +04:00
|
|
|
if (NS_SUCCEEDED(uiEvent->GetCharCode(&charCode)) &&
|
1999-10-16 01:20:57 +04:00
|
|
|
NS_SUCCEEDED(uiEvent->GetAltKey(&isAltKey)) &&
|
|
|
|
NS_SUCCEEDED(uiEvent->GetMetaKey(&isMetaKey)) &&
|
|
|
|
NS_SUCCEEDED(uiEvent->GetShiftKey(&isShiftKey)) &&
|
landing keyEvent_19991004_BRANCH
bugs # see the log of the check in into branch
author/reviewer:
mozilla/layout/base/src/nsRangeList.cpp brade/mjudge
mozilla/layout/html/forms/src/nsGfxTextControlFrame.cpp brade/ftang
mozilla/layout/events/src/nsDOMEvent.cpp brade/joki
mozilla/layout/events/src/nsEventStateManager.cpp brade/joki
mozilla/widget/public/nsGUIEvent.h akkana/ftang
mozilla/widget/src/windows/nsWindow.cpp ftang/mjudge
mozilla/widget/src/windows/nsWindow.h ftang/mjudge
mozilla/widget/src/mac/nsTextAreaWidget.cpp brade/ftang
mozilla/widget/src/mac/nsMacEventHandler.cpp brade/simon
mozilla/widget/src/xpwidgets/nsKeyBindMgr.cpp brade/ftang
mozilla/widget/src/gtk/nsGtkEventHandler.cpp akkana/?
mozilla/widget/src/gtk/nsWidget.cpp erik/ftang
mozilla/layout/xul/base/src/nsTreeCellFrame.cpp brade/ftang
mozilla/editor/base/nsEditorEventListeners.cpp brade/akkana
mozilla/editor/base/nsHTMLEditor.cpp brade/akkana
mozilla/rdf/content/src/nsXULKeyListener.cpp ftang/saari
fix the master bug- 15693
fix at least, but not limited to, the following bugs
10158,11956,6053,9333,10901,14348,6449,11845,13016,14410,15657,15307,15842,13856
1999-10-14 22:27:01 +04:00
|
|
|
NS_SUCCEEDED(uiEvent->GetCtrlKey(&ctrlKey)) )
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
1999-09-10 18:42:20 +04:00
|
|
|
#ifdef XP_MAC
|
|
|
|
// hack to make Mac work for hard-coded keybindings
|
|
|
|
// metaKey query is only way to query for command key on Mac
|
|
|
|
// if that's pressed, we'll set the ctrlKey boolean
|
|
|
|
// (even though the control key might also be pressed)
|
1999-10-15 18:52:45 +04:00
|
|
|
if (PR_TRUE==isMetaKey) {
|
landing keyEvent_19991004_BRANCH
bugs # see the log of the check in into branch
author/reviewer:
mozilla/layout/base/src/nsRangeList.cpp brade/mjudge
mozilla/layout/html/forms/src/nsGfxTextControlFrame.cpp brade/ftang
mozilla/layout/events/src/nsDOMEvent.cpp brade/joki
mozilla/layout/events/src/nsEventStateManager.cpp brade/joki
mozilla/widget/public/nsGUIEvent.h akkana/ftang
mozilla/widget/src/windows/nsWindow.cpp ftang/mjudge
mozilla/widget/src/windows/nsWindow.h ftang/mjudge
mozilla/widget/src/mac/nsTextAreaWidget.cpp brade/ftang
mozilla/widget/src/mac/nsMacEventHandler.cpp brade/simon
mozilla/widget/src/xpwidgets/nsKeyBindMgr.cpp brade/ftang
mozilla/widget/src/gtk/nsGtkEventHandler.cpp akkana/?
mozilla/widget/src/gtk/nsWidget.cpp erik/ftang
mozilla/layout/xul/base/src/nsTreeCellFrame.cpp brade/ftang
mozilla/editor/base/nsEditorEventListeners.cpp brade/akkana
mozilla/editor/base/nsHTMLEditor.cpp brade/akkana
mozilla/rdf/content/src/nsXULKeyListener.cpp ftang/saari
fix the master bug- 15693
fix at least, but not limited to, the following bugs
10158,11956,6053,9333,10901,14348,6449,11845,13016,14410,15657,15307,15842,13856
1999-10-14 22:27:01 +04:00
|
|
|
ctrlKey = !ctrlKey; /* if controlKey is pressed, we shouldn't execute code below */
|
|
|
|
/* if it's not set and cmdKey is, then we should proceed to code below */
|
1999-10-15 18:52:45 +04:00
|
|
|
isMetaKey = PR_FALSE; /* reset so there aren't extra modifiers to prevent binding from working */
|
1999-09-10 18:42:20 +04:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
1999-07-07 03:31:08 +04:00
|
|
|
if (PR_TRUE==ctrlKey) {
|
|
|
|
aProcessed = PR_TRUE;
|
|
|
|
}
|
|
|
|
// swallow all control keys
|
1999-02-12 20:18:58 +03:00
|
|
|
// XXX: please please please get these mappings from an external source!
|
landing keyEvent_19991004_BRANCH
bugs # see the log of the check in into branch
author/reviewer:
mozilla/layout/base/src/nsRangeList.cpp brade/mjudge
mozilla/layout/html/forms/src/nsGfxTextControlFrame.cpp brade/ftang
mozilla/layout/events/src/nsDOMEvent.cpp brade/joki
mozilla/layout/events/src/nsEventStateManager.cpp brade/joki
mozilla/widget/public/nsGUIEvent.h akkana/ftang
mozilla/widget/src/windows/nsWindow.cpp ftang/mjudge
mozilla/widget/src/windows/nsWindow.h ftang/mjudge
mozilla/widget/src/mac/nsTextAreaWidget.cpp brade/ftang
mozilla/widget/src/mac/nsMacEventHandler.cpp brade/simon
mozilla/widget/src/xpwidgets/nsKeyBindMgr.cpp brade/ftang
mozilla/widget/src/gtk/nsGtkEventHandler.cpp akkana/?
mozilla/widget/src/gtk/nsWidget.cpp erik/ftang
mozilla/layout/xul/base/src/nsTreeCellFrame.cpp brade/ftang
mozilla/editor/base/nsEditorEventListeners.cpp brade/akkana
mozilla/editor/base/nsHTMLEditor.cpp brade/akkana
mozilla/rdf/content/src/nsXULKeyListener.cpp ftang/saari
fix the master bug- 15693
fix at least, but not limited to, the following bugs
10158,11956,6053,9333,10901,14348,6449,11845,13016,14410,15657,15307,15842,13856
1999-10-14 22:27:01 +04:00
|
|
|
switch (charCode)
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
1999-03-10 22:49:43 +03:00
|
|
|
// XXX: hard-coded select all
|
1999-09-10 18:42:20 +04:00
|
|
|
case (PRUint32)('a'):
|
1999-10-15 18:52:45 +04:00
|
|
|
if (PR_TRUE==ctrlKey && PR_FALSE==isShiftKey && PR_FALSE==isAltKey && PR_FALSE==isMetaKey)
|
1999-03-10 22:49:43 +03:00
|
|
|
{
|
|
|
|
if (mEditor)
|
|
|
|
mEditor->SelectAll();
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
1999-03-11 01:46:15 +03:00
|
|
|
// XXX: hard-coded cut
|
1999-08-28 04:31:06 +04:00
|
|
|
case (PRUint32)('x'):
|
1999-10-15 18:52:45 +04:00
|
|
|
if (PR_TRUE==ctrlKey && PR_FALSE==isShiftKey && PR_FALSE==isAltKey && PR_FALSE==isMetaKey)
|
1999-03-11 01:46:15 +03:00
|
|
|
{
|
|
|
|
if (mEditor)
|
|
|
|
mEditor->Cut();
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
// XXX: hard-coded copy
|
1999-09-10 18:42:20 +04:00
|
|
|
case (PRUint32)('c'):
|
1999-10-15 18:52:45 +04:00
|
|
|
if (PR_TRUE==ctrlKey && PR_FALSE==isShiftKey && PR_FALSE==isAltKey && PR_FALSE==isMetaKey)
|
1999-03-11 01:46:15 +03:00
|
|
|
{
|
|
|
|
if (mEditor)
|
|
|
|
mEditor->Copy();
|
|
|
|
}
|
1999-05-14 02:11:05 +04:00
|
|
|
break;
|
|
|
|
|
1999-03-11 01:46:15 +03:00
|
|
|
// XXX: hard-coded paste
|
1999-09-10 18:42:20 +04:00
|
|
|
case (PRUint32)('v'):
|
1999-10-15 18:52:45 +04:00
|
|
|
if (PR_TRUE==ctrlKey && PR_FALSE==isShiftKey && PR_FALSE==isAltKey && PR_FALSE==isMetaKey)
|
1999-03-11 01:46:15 +03:00
|
|
|
{
|
|
|
|
printf("control-v\n");
|
|
|
|
if (mEditor)
|
1999-05-27 04:08:15 +04:00
|
|
|
mEditor->Paste();
|
1999-03-11 01:46:15 +03:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
1999-02-12 20:18:58 +03:00
|
|
|
// XXX: hard-coded undo
|
1999-09-10 18:42:20 +04:00
|
|
|
case (PRUint32)('z'):
|
1999-10-15 18:52:45 +04:00
|
|
|
if (PR_TRUE==ctrlKey && PR_FALSE==isShiftKey && PR_FALSE==isAltKey && PR_FALSE==isMetaKey)
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
1999-03-02 10:52:41 +03:00
|
|
|
if (mEditor)
|
1999-02-12 20:18:58 +03:00
|
|
|
mEditor->Undo(1);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
// XXX: hard-coded redo
|
1999-09-10 18:42:20 +04:00
|
|
|
case (PRUint32)('y'):
|
1999-10-15 18:52:45 +04:00
|
|
|
if (PR_TRUE==ctrlKey && PR_FALSE==isShiftKey && PR_FALSE==isAltKey && PR_FALSE==isMetaKey)
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
1999-03-02 10:52:41 +03:00
|
|
|
if (mEditor)
|
1999-02-12 20:18:58 +03:00
|
|
|
mEditor->Redo(1);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-08-31 05:14:40 +04:00
|
|
|
nsresult
|
|
|
|
nsTextEditorKeyListener::ScrollSelectionIntoView()
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIPresShell> presShell;
|
|
|
|
|
|
|
|
nsresult result = mEditor->GetPresShell(getter_AddRefs(presShell));
|
|
|
|
|
|
|
|
if (NS_FAILED(result))
|
|
|
|
return result;
|
|
|
|
|
|
|
|
if (!presShell)
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
1999-02-12 20:18:58 +03:00
|
|
|
|
1999-08-31 05:14:40 +04:00
|
|
|
return presShell->ScrollSelectionIntoView(SELECTION_NORMAL, SELECTION_FOCUS_REGION);
|
|
|
|
}
|
1999-02-12 20:18:58 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* nsTextEditorMouseListener implementation
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
NS_IMPL_ADDREF(nsTextEditorMouseListener)
|
|
|
|
|
|
|
|
NS_IMPL_RELEASE(nsTextEditorMouseListener)
|
|
|
|
|
|
|
|
|
|
|
|
nsTextEditorMouseListener::nsTextEditorMouseListener()
|
|
|
|
{
|
|
|
|
NS_INIT_REFCNT();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
nsTextEditorMouseListener::~nsTextEditorMouseListener()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsTextEditorMouseListener::QueryInterface(REFNSIID aIID, void** aInstancePtr)
|
|
|
|
{
|
|
|
|
if (nsnull == aInstancePtr) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
1999-05-28 04:19:51 +04:00
|
|
|
|
1999-06-30 01:01:31 +04:00
|
|
|
if (aIID.Equals(nsCOMTypeInfo<nsISupports>::GetIID())) {
|
1999-02-12 20:18:58 +03:00
|
|
|
*aInstancePtr = (void*)(nsISupports*)this;
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
1999-05-28 04:19:51 +04:00
|
|
|
if (aIID.Equals(nsIDOMEventListener::GetIID())) {
|
1999-02-12 20:18:58 +03:00
|
|
|
*aInstancePtr = (void*)(nsIDOMEventListener*)this;
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
1999-05-28 04:19:51 +04:00
|
|
|
if (aIID.Equals(nsIDOMMouseListener::GetIID())) {
|
1999-02-12 20:18:58 +03:00
|
|
|
*aInstancePtr = (void*)(nsIDOMMouseListener*)this;
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
return NS_NOINTERFACE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
nsresult
|
1999-03-29 02:27:38 +04:00
|
|
|
nsTextEditorMouseListener::HandleEvent(nsIDOMEvent* aEvent)
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
1999-08-19 17:30:48 +04:00
|
|
|
// XXX: evil global functions, move them to proper support module
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
IsNodeInSelection(nsIDOMNode *aInNode, nsIDOMSelection *aInSelection, PRBool &aOutIsInSel)
|
|
|
|
{
|
1999-08-25 14:51:55 +04:00
|
|
|
aOutIsInSel = PR_FALSE; // init out-param
|
|
|
|
if (!aInNode || !aInSelection) { return NS_ERROR_NULL_POINTER; }
|
1999-08-19 17:30:48 +04:00
|
|
|
|
|
|
|
nsCOMPtr<nsIContentIterator>iter;
|
|
|
|
nsresult result = nsComponentManager::CreateInstance(kContentIteratorCID, nsnull,
|
|
|
|
nsIContentIterator::GetIID(),
|
1999-09-13 13:37:51 +04:00
|
|
|
getter_AddRefs(iter));
|
1999-08-25 14:51:55 +04:00
|
|
|
if (NS_FAILED(result)) { return result; }
|
|
|
|
if (!iter) { return NS_ERROR_OUT_OF_MEMORY; }
|
1999-08-19 17:30:48 +04:00
|
|
|
|
1999-08-25 14:51:55 +04:00
|
|
|
nsCOMPtr<nsIEnumerator> enumerator;
|
1999-08-19 17:30:48 +04:00
|
|
|
result = aInSelection->GetEnumerator(getter_AddRefs(enumerator));
|
|
|
|
if (NS_FAILED(result)) { return result; }
|
1999-08-25 14:51:55 +04:00
|
|
|
if (!enumerator) { return NS_ERROR_OUT_OF_MEMORY; }
|
1999-08-19 17:30:48 +04:00
|
|
|
|
|
|
|
for (enumerator->First(); NS_OK!=enumerator->IsDone(); enumerator->Next())
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsISupports> currentItem;
|
|
|
|
result = enumerator->CurrentItem(getter_AddRefs(currentItem));
|
|
|
|
if ((NS_SUCCEEDED(result)) && (currentItem))
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMRange> range( do_QueryInterface(currentItem) );
|
|
|
|
|
1999-08-25 14:51:55 +04:00
|
|
|
iter->Init(range);
|
|
|
|
nsCOMPtr<nsIContent> currentContent;
|
|
|
|
iter->CurrentNode(getter_AddRefs(currentContent));
|
1999-10-28 00:24:21 +04:00
|
|
|
while (NS_ENUMERATOR_FALSE == iter->IsDone())
|
1999-08-25 14:51:55 +04:00
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMNode>currentNode = do_QueryInterface(currentContent);
|
|
|
|
if (currentNode.get()==aInNode)
|
|
|
|
{
|
|
|
|
// if it's a start or end node, need to test whether the (x,y)
|
|
|
|
// of the event falls within the selection
|
|
|
|
|
|
|
|
// talk to Mike
|
|
|
|
|
|
|
|
aOutIsInSel = PR_TRUE;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
/* do not check result here, and especially do not return the result code.
|
|
|
|
* we rely on iter->IsDone to tell us when the iteration is complete
|
|
|
|
*/
|
|
|
|
iter->Next();
|
|
|
|
iter->CurrentNode(getter_AddRefs(currentContent));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NS_OK;
|
1999-08-19 17:30:48 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
1999-02-12 20:18:58 +03:00
|
|
|
nsresult
|
|
|
|
nsTextEditorMouseListener::MouseDown(nsIDOMEvent* aMouseEvent)
|
|
|
|
{
|
1999-05-07 23:22:38 +04:00
|
|
|
if (!aMouseEvent)
|
|
|
|
return NS_OK; // NS_OK means "we didn't process the event". Go figure.
|
|
|
|
|
1999-05-19 03:51:04 +04:00
|
|
|
nsCOMPtr<nsIDOMUIEvent>uiEvent;
|
|
|
|
uiEvent = do_QueryInterface(aMouseEvent);
|
|
|
|
if (!uiEvent) {
|
|
|
|
//non-ui event passed in. bad things.
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-08-25 14:51:55 +04:00
|
|
|
nsCOMPtr<nsIEditor> editor (do_QueryInterface(mEditor));
|
1999-08-19 17:30:48 +04:00
|
|
|
if (!editor) { return NS_OK; }
|
1999-06-09 01:51:40 +04:00
|
|
|
|
1999-08-19 17:30:48 +04:00
|
|
|
|
1999-08-25 14:51:55 +04:00
|
|
|
// get the document
|
|
|
|
nsCOMPtr<nsIDOMDocument>domDoc;
|
1999-08-19 17:30:48 +04:00
|
|
|
editor->GetDocument(getter_AddRefs(domDoc));
|
1999-08-25 14:51:55 +04:00
|
|
|
if (!domDoc) { return NS_OK; }
|
|
|
|
nsCOMPtr<nsIDocument>doc = do_QueryInterface(domDoc);
|
|
|
|
if (!doc) { return NS_OK; }
|
1999-05-27 04:08:15 +04:00
|
|
|
|
1999-08-19 17:30:48 +04:00
|
|
|
PRUint16 button = 0;
|
|
|
|
uiEvent->GetButton(&button);
|
1999-08-25 14:51:55 +04:00
|
|
|
// left button click might be a drag-start
|
|
|
|
if (1==button)
|
|
|
|
{
|
1999-08-19 17:30:48 +04:00
|
|
|
#ifndef EXPERIMENTAL_DRAG_CODE
|
1999-08-25 14:51:55 +04:00
|
|
|
return NS_OK;
|
1999-08-19 17:30:48 +04:00
|
|
|
#else
|
1999-08-25 14:51:55 +04:00
|
|
|
nsString XIFBuffer;
|
|
|
|
// get the DOM select here
|
|
|
|
nsCOMPtr<nsIDOMSelection> sel;
|
|
|
|
editor->GetSelection(getter_AddRefs(sel));
|
1999-08-19 17:30:48 +04:00
|
|
|
|
1999-08-25 14:51:55 +04:00
|
|
|
// convert the DOMselection to XIF
|
|
|
|
if (sel)
|
|
|
|
{
|
|
|
|
// if we are within the selection, start the drag
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMNode> target;
|
|
|
|
nsresult rv = aMouseEvent->GetTarget(getter_AddRefs(target));
|
|
|
|
if (NS_FAILED(rv) || !target) { return NS_OK; }
|
|
|
|
PRBool isInSel;
|
|
|
|
rv = IsNodeInSelection(target, sel, isInSel);
|
|
|
|
if (NS_FAILED(rv) || PR_FALSE==isInSel) { return NS_OK; }
|
|
|
|
doc->CreateXIF(XIFBuffer, sel);
|
|
|
|
|
|
|
|
// Get the Clipboard
|
1999-10-08 18:39:20 +04:00
|
|
|
NS_WITH_SERVICE(nsIClipboard, clipboard, kCClipboardCID, &rv);
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
|
|
|
|
// Create a data flavor to tell the transferable
|
|
|
|
// that it is about to receive XIF
|
|
|
|
nsAutoString flavor(kXIFMime);
|
|
|
|
|
|
|
|
// Create a transferable for putting data on the Clipboard
|
|
|
|
nsCOMPtr<nsITransferable> trans;
|
|
|
|
rv = nsComponentManager::CreateInstance(kCTransferableCID, nsnull,
|
|
|
|
nsITransferable::GetIID(),
|
|
|
|
(void**) getter_AddRefs(trans));
|
|
|
|
if (NS_OK == rv) {
|
|
|
|
// The data on the clipboard will be in "XIF" format
|
|
|
|
// so give the clipboard transferable a "XIFConverter" for
|
|
|
|
// converting from XIF to other formats
|
|
|
|
nsCOMPtr<nsIFormatConverter> xifConverter;
|
|
|
|
rv = nsComponentManager::CreateInstance(kCXIFConverterCID, nsnull,
|
|
|
|
nsIFormatConverter::GetIID(),
|
|
|
|
(void**) getter_AddRefs(xifConverter));
|
|
|
|
if (NS_OK == rv) {
|
|
|
|
// Add the XIF DataFlavor to the transferable
|
|
|
|
// this tells the transferable that it can handle receiving the XIF format
|
|
|
|
trans->AddDataFlavor(&flavor);
|
|
|
|
|
|
|
|
// Add the converter for going from XIF to other formats
|
|
|
|
trans->SetConverter(xifConverter);
|
|
|
|
|
|
|
|
// Now add the XIF data to the transferable
|
|
|
|
// the transferable wants the number bytes for the data and since it is double byte
|
|
|
|
// we multiply by 2
|
|
|
|
trans->SetTransferData(&flavor, XIFBuffer.ToNewUnicode(), XIFBuffer.Length()*2);
|
|
|
|
|
|
|
|
// Now invoke the drag session
|
|
|
|
NS_WITH_SERVICE(nsIDragService, dragService, kCDragServiceCID, &rv);
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
nsCOMPtr<nsISupportsArray> items;
|
|
|
|
NS_NewISupportsArray(getter_AddRefs(items));
|
|
|
|
if ( items ) {
|
|
|
|
items->AppendElement(trans);
|
|
|
|
dragService->InvokeDragSession(items, nsnull,
|
|
|
|
nsIDragService::DRAGDROP_ACTION_COPY |
|
|
|
|
nsIDragService::DRAGDROP_ACTION_MOVE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NS_ERROR_BASE; // return that we've handled the event
|
1999-08-19 17:30:48 +04:00
|
|
|
#endif
|
1999-08-09 05:37:50 +04:00
|
|
|
}
|
1999-08-19 17:30:48 +04:00
|
|
|
// middle-mouse click (paste);
|
|
|
|
else if (button == 2)
|
1999-08-25 14:51:55 +04:00
|
|
|
{
|
1999-08-19 17:30:48 +04:00
|
|
|
|
|
|
|
// Set the selection to the point under the mouse cursor:
|
1999-08-25 14:51:55 +04:00
|
|
|
nsCOMPtr<nsIDOMNSUIEvent> mouseEvent (do_QueryInterface(aMouseEvent));
|
|
|
|
|
|
|
|
if (!mouseEvent)
|
|
|
|
return NS_ERROR_BASE; // NS_ERROR_BASE means "We did process the event".
|
|
|
|
nsCOMPtr<nsIDOMNode> parent;
|
|
|
|
if (!NS_SUCCEEDED(mouseEvent->GetRangeParent(getter_AddRefs(parent))))
|
|
|
|
return NS_ERROR_BASE; // NS_ERROR_BASE means "We did process the event".
|
|
|
|
PRInt32 offset = 0;
|
|
|
|
if (!NS_SUCCEEDED(mouseEvent->GetRangeOffset(&offset)))
|
|
|
|
return NS_ERROR_BASE; // NS_ERROR_BASE means "We did process the event".
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMSelection> selection;
|
|
|
|
if (NS_SUCCEEDED(editor->GetSelection(getter_AddRefs(selection))))
|
|
|
|
(void)selection->Collapse(parent, offset);
|
|
|
|
|
|
|
|
// If the ctrl key is pressed, we'll do paste as quotation.
|
|
|
|
// Would've used the alt key, but the kde wmgr treats alt-middle specially.
|
|
|
|
PRBool ctrlKey = PR_FALSE;
|
|
|
|
uiEvent->GetCtrlKey(&ctrlKey);
|
|
|
|
|
|
|
|
if (ctrlKey)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIEditorMailSupport> mailEditor = do_QueryInterface(mEditor);
|
|
|
|
if (mailEditor)
|
|
|
|
mailEditor->PasteAsQuotation();
|
|
|
|
}
|
|
|
|
editor->Paste();
|
|
|
|
return NS_ERROR_BASE; // NS_ERROR_BASE means "We did process the event".
|
|
|
|
}
|
|
|
|
return NS_OK; // did not process the event
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
1999-08-19 17:30:48 +04:00
|
|
|
|
1999-02-12 20:18:58 +03:00
|
|
|
nsresult
|
|
|
|
nsTextEditorMouseListener::MouseUp(nsIDOMEvent* aMouseEvent)
|
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsTextEditorMouseListener::MouseClick(nsIDOMEvent* aMouseEvent)
|
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsTextEditorMouseListener::MouseDblClick(nsIDOMEvent* aMouseEvent)
|
|
|
|
{
|
1999-08-25 14:51:55 +04:00
|
|
|
nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(mEditor);
|
1999-08-09 05:37:50 +04:00
|
|
|
if (htmlEditor)
|
1999-06-25 00:59:45 +04:00
|
|
|
{
|
1999-08-09 05:37:50 +04:00
|
|
|
nsCOMPtr<nsIDOMElement> selectedElement;
|
1999-09-13 13:37:51 +04:00
|
|
|
if (NS_SUCCEEDED(htmlEditor->GetSelectedElement("", getter_AddRefs(selectedElement)))
|
|
|
|
&& selectedElement)
|
1999-06-25 00:59:45 +04:00
|
|
|
{
|
1999-08-09 05:37:50 +04:00
|
|
|
nsAutoString TagName;
|
|
|
|
selectedElement->GetTagName(TagName);
|
|
|
|
TagName.ToLowerCase();
|
1999-06-25 00:59:45 +04:00
|
|
|
|
|
|
|
#if DEBUG_cmanske
|
1999-08-09 05:37:50 +04:00
|
|
|
char szTagName[64];
|
|
|
|
TagName.ToCString(szTagName, 64);
|
|
|
|
printf("Single Selected element found: %s\n", szTagName);
|
1999-06-25 00:59:45 +04:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
1999-02-12 20:18:58 +03:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsTextEditorMouseListener::MouseOver(nsIDOMEvent* aMouseEvent)
|
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsTextEditorMouseListener::MouseOut(nsIDOMEvent* aMouseEvent)
|
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-03-20 02:36:20 +03:00
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* nsTextEditorMouseListener implementation
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
NS_IMPL_ADDREF(nsTextEditorTextListener)
|
|
|
|
|
|
|
|
NS_IMPL_RELEASE(nsTextEditorTextListener)
|
|
|
|
|
|
|
|
|
|
|
|
nsTextEditorTextListener::nsTextEditorTextListener()
|
1999-08-25 14:51:55 +04:00
|
|
|
: mCommitText(PR_FALSE),
|
|
|
|
mInTransaction(PR_FALSE)
|
1999-03-20 02:36:20 +03:00
|
|
|
{
|
|
|
|
NS_INIT_REFCNT();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
nsTextEditorTextListener::~nsTextEditorTextListener()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsTextEditorTextListener::QueryInterface(REFNSIID aIID, void** aInstancePtr)
|
|
|
|
{
|
|
|
|
if (nsnull == aInstancePtr) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
1999-05-28 04:19:51 +04:00
|
|
|
|
1999-06-30 01:01:31 +04:00
|
|
|
if (aIID.Equals(nsCOMTypeInfo<nsISupports>::GetIID())) {
|
1999-03-20 02:36:20 +03:00
|
|
|
*aInstancePtr = (void*)(nsISupports*)this;
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
1999-05-28 04:19:51 +04:00
|
|
|
if (aIID.Equals(nsIDOMEventListener::GetIID())) {
|
1999-03-20 02:36:20 +03:00
|
|
|
*aInstancePtr = (void*)(nsIDOMEventListener*)this;
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
1999-05-28 04:19:51 +04:00
|
|
|
if (aIID.Equals(nsIDOMTextListener::GetIID())) {
|
1999-03-20 02:36:20 +03:00
|
|
|
*aInstancePtr = (void*)(nsIDOMTextListener*)this;
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
return NS_NOINTERFACE;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
1999-03-29 02:27:38 +04:00
|
|
|
nsTextEditorTextListener::HandleEvent(nsIDOMEvent* aEvent)
|
1999-03-20 02:36:20 +03:00
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsTextEditorTextListener::HandleText(nsIDOMEvent* aTextEvent)
|
|
|
|
{
|
1999-09-15 03:40:16 +04:00
|
|
|
nsAutoString composedText;
|
1999-08-25 14:51:55 +04:00
|
|
|
nsresult result = NS_OK;
|
|
|
|
nsCOMPtr<nsIPrivateTextEvent> textEvent;
|
|
|
|
nsIPrivateTextRangeList *textRangeList;
|
|
|
|
nsTextEventReply *textEventReply;
|
|
|
|
|
|
|
|
textEvent = do_QueryInterface(aTextEvent);
|
|
|
|
if (!textEvent) {
|
|
|
|
//non-ui event passed in. bad things.
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
textEvent->GetText(composedText);
|
|
|
|
textEvent->GetInputRange(&textRangeList);
|
|
|
|
textEvent->GetEventReply(&textEventReply);
|
|
|
|
textRangeList->AddRef();
|
|
|
|
nsCOMPtr<nsIEditorIMESupport> imeEditor = do_QueryInterface(mEditor, &result);
|
|
|
|
if (imeEditor)
|
1999-08-09 05:37:50 +04:00
|
|
|
result = imeEditor->SetCompositionString(composedText,textRangeList,textEventReply);
|
1999-08-25 14:51:55 +04:00
|
|
|
return result;
|
1999-03-20 02:36:20 +03:00
|
|
|
}
|
|
|
|
|
1999-05-07 23:42:27 +04:00
|
|
|
/*
|
|
|
|
* nsTextEditorDragListener implementation
|
|
|
|
*/
|
|
|
|
|
|
|
|
NS_IMPL_ADDREF(nsTextEditorDragListener)
|
|
|
|
|
|
|
|
NS_IMPL_RELEASE(nsTextEditorDragListener)
|
|
|
|
|
|
|
|
|
|
|
|
nsTextEditorDragListener::nsTextEditorDragListener()
|
|
|
|
{
|
|
|
|
NS_INIT_REFCNT();
|
|
|
|
}
|
|
|
|
|
|
|
|
nsTextEditorDragListener::~nsTextEditorDragListener()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
1999-03-14 07:45:00 +03:00
|
|
|
nsresult
|
|
|
|
nsTextEditorDragListener::QueryInterface(REFNSIID aIID, void** aInstancePtr)
|
|
|
|
{
|
|
|
|
if (nsnull == aInstancePtr) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
1999-05-28 04:19:51 +04:00
|
|
|
|
1999-06-30 01:01:31 +04:00
|
|
|
if (aIID.Equals(nsCOMTypeInfo<nsISupports>::GetIID())) {
|
1999-03-14 07:45:00 +03:00
|
|
|
*aInstancePtr = (void*)(nsISupports*)this;
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
1999-05-28 04:19:51 +04:00
|
|
|
if (aIID.Equals(nsIDOMEventListener::GetIID())) {
|
1999-03-14 07:45:00 +03:00
|
|
|
*aInstancePtr = (void*)(nsIDOMEventListener*)this;
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
1999-05-28 04:19:51 +04:00
|
|
|
if (aIID.Equals(nsIDOMDragListener::GetIID())) {
|
1999-03-14 07:45:00 +03:00
|
|
|
*aInstancePtr = (void*)(nsIDOMDragListener*)this;
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
return NS_NOINTERFACE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
nsresult
|
1999-03-29 02:27:38 +04:00
|
|
|
nsTextEditorDragListener::HandleEvent(nsIDOMEvent* aEvent)
|
1999-03-14 07:45:00 +03:00
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1999-08-19 23:48:33 +04:00
|
|
|
nsresult
|
|
|
|
nsTextEditorDragListener::DragGesture(nsIDOMEvent* aDragEvent)
|
|
|
|
{
|
|
|
|
// ...figure out if a drag should be started...
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-03-14 07:45:00 +03:00
|
|
|
|
|
|
|
nsresult
|
1999-04-07 00:24:09 +04:00
|
|
|
nsTextEditorDragListener::DragEnter(nsIDOMEvent* aDragEvent)
|
|
|
|
{
|
1999-08-25 12:35:06 +04:00
|
|
|
nsresult rv;
|
|
|
|
NS_WITH_SERVICE ( nsIDragService, dragService, kCDragServiceCID, &rv );
|
|
|
|
if ( NS_SUCCEEDED(rv) ) {
|
1999-05-07 23:42:27 +04:00
|
|
|
nsCOMPtr<nsIDragSession> dragSession(do_QueryInterface(dragService));
|
1999-08-25 12:35:06 +04:00
|
|
|
if ( dragSession ) {
|
|
|
|
PRBool flavorSupported = PR_FALSE;
|
|
|
|
dragSession->IsDataFlavorSupported(kTextMime, &flavorSupported);
|
|
|
|
if ( flavorSupported )
|
|
|
|
dragSession->SetCanDrop(PR_TRUE);
|
1999-05-07 23:42:27 +04:00
|
|
|
}
|
1999-04-17 17:52:28 +04:00
|
|
|
}
|
1999-06-16 08:52:05 +04:00
|
|
|
|
1999-04-07 00:24:09 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsTextEditorDragListener::DragOver(nsIDOMEvent* aDragEvent)
|
|
|
|
{
|
1999-08-25 12:35:06 +04:00
|
|
|
nsresult rv;
|
|
|
|
NS_WITH_SERVICE ( nsIDragService, dragService, kCDragServiceCID, &rv );
|
|
|
|
if ( NS_SUCCEEDED(rv) ) {
|
1999-05-07 23:42:27 +04:00
|
|
|
nsCOMPtr<nsIDragSession> dragSession(do_QueryInterface(dragService));
|
1999-08-25 12:35:06 +04:00
|
|
|
if ( dragSession ) {
|
|
|
|
PRBool flavorSupported = PR_FALSE;
|
|
|
|
dragSession->IsDataFlavorSupported(kTextMime, &flavorSupported);
|
|
|
|
if ( flavorSupported )
|
|
|
|
dragSession->SetCanDrop(PR_TRUE);
|
1999-05-07 23:42:27 +04:00
|
|
|
}
|
1999-04-17 17:52:28 +04:00
|
|
|
}
|
1999-06-16 08:52:05 +04:00
|
|
|
|
1999-04-07 00:24:09 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsTextEditorDragListener::DragExit(nsIDOMEvent* aDragEvent)
|
1999-03-14 07:45:00 +03:00
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsTextEditorDragListener::DragDrop(nsIDOMEvent* aMouseEvent)
|
|
|
|
{
|
1999-05-07 23:42:27 +04:00
|
|
|
// Create drag service for getting state of drag
|
1999-10-08 18:39:20 +04:00
|
|
|
nsresult rv;
|
|
|
|
NS_WITH_SERVICE(nsIDragService, dragService, kCDragServiceCID, &rv);
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
1999-05-07 23:42:27 +04:00
|
|
|
|
1999-10-08 18:39:20 +04:00
|
|
|
nsCOMPtr<nsIDragSession> dragSession(do_QueryInterface(dragService));
|
|
|
|
|
|
|
|
if (dragSession) {
|
|
|
|
|
|
|
|
// Create transferable for getting the drag data
|
|
|
|
nsCOMPtr<nsITransferable> trans;
|
|
|
|
rv = nsComponentManager::CreateInstance(kCTransferableCID, nsnull,
|
|
|
|
nsITransferable::GetIID(),
|
|
|
|
(void**) getter_AddRefs(trans));
|
|
|
|
if ( NS_SUCCEEDED(rv) && trans ) {
|
|
|
|
// Add the text Flavor to the transferable,
|
|
|
|
// because that is the only type of data we are
|
|
|
|
// looking for at the moment.
|
|
|
|
trans->AddDataFlavor(kTextMime);
|
|
|
|
//trans->AddDataFlavor(mImageDataFlavor);
|
|
|
|
|
|
|
|
// Fill the transferable with data for each drag item in succession
|
|
|
|
PRUint32 numItems = 0;
|
|
|
|
if (NS_SUCCEEDED(dragSession->GetNumDropItems(&numItems))) {
|
|
|
|
|
|
|
|
printf("Num Drop Items %d\n", numItems);
|
|
|
|
|
|
|
|
PRUint32 i;
|
|
|
|
for (i=0;i<numItems;++i) {
|
|
|
|
if (NS_SUCCEEDED(dragSession->GetData(trans, i))) {
|
|
|
|
|
|
|
|
// Get the string data out of the transferable
|
|
|
|
// Note: the transferable owns the pointer to the data
|
|
|
|
nsCOMPtr<nsISupports> genericDataObj;
|
|
|
|
PRUint32 len;
|
|
|
|
char* whichFlavor = nsnull;
|
|
|
|
trans->GetAnyTransferData(&whichFlavor, getter_AddRefs(genericDataObj), &len);
|
|
|
|
nsCOMPtr<nsISupportsString> textDataObj( do_QueryInterface(genericDataObj) );
|
|
|
|
// If the string was not empty then paste it in
|
|
|
|
if ( textDataObj )
|
|
|
|
{
|
|
|
|
char* text = nsnull;
|
|
|
|
textDataObj->ToString(&text);
|
|
|
|
nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(mEditor);
|
|
|
|
if ( htmlEditor && text )
|
|
|
|
htmlEditor->InsertText(text);
|
|
|
|
dragSession->SetCanDrop(PR_TRUE);
|
1999-05-27 01:08:14 +04:00
|
|
|
}
|
1999-10-08 18:39:20 +04:00
|
|
|
|
|
|
|
nsCRT::free(whichFlavor);
|
|
|
|
// XXX This is where image support might go
|
|
|
|
//void * data;
|
|
|
|
//trans->GetTransferData(mImageDataFlavor, (void **)&data, &len);
|
|
|
|
}
|
|
|
|
} // foreach drag item
|
|
|
|
}
|
|
|
|
} // if valid transferable
|
|
|
|
} // if valid drag session
|
1999-04-07 00:24:09 +04:00
|
|
|
|
1999-03-14 07:45:00 +03:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-05-07 23:42:27 +04:00
|
|
|
|
1999-05-04 02:57:48 +04:00
|
|
|
nsTextEditorCompositionListener::nsTextEditorCompositionListener()
|
|
|
|
{
|
|
|
|
NS_INIT_REFCNT();
|
|
|
|
}
|
|
|
|
|
|
|
|
nsTextEditorCompositionListener::~nsTextEditorCompositionListener()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsTextEditorCompositionListener::QueryInterface(REFNSIID aIID, void** aInstancePtr)
|
|
|
|
{
|
|
|
|
if (nsnull == aInstancePtr) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
1999-06-30 01:01:31 +04:00
|
|
|
if (aIID.Equals(nsCOMTypeInfo<nsISupports>::GetIID())) {
|
1999-05-04 02:57:48 +04:00
|
|
|
*aInstancePtr = (void*)(nsISupports*)this;
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
1999-05-28 04:19:51 +04:00
|
|
|
if (aIID.Equals(nsIDOMEventListener::GetIID())) {
|
1999-05-04 02:57:48 +04:00
|
|
|
*aInstancePtr = (void*)(nsIDOMEventListener*)this;
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
1999-05-28 04:19:51 +04:00
|
|
|
if (aIID.Equals(nsIDOMCompositionListener::GetIID())) {
|
1999-05-04 02:57:48 +04:00
|
|
|
*aInstancePtr = (void*)(nsIDOMCompositionListener*)this;
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
return NS_NOINTERFACE;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMPL_ADDREF(nsTextEditorCompositionListener)
|
|
|
|
|
|
|
|
NS_IMPL_RELEASE(nsTextEditorCompositionListener)
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsTextEditorCompositionListener::HandleEvent(nsIDOMEvent* aEvent)
|
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
1999-08-09 05:37:50 +04:00
|
|
|
|
|
|
|
void nsTextEditorCompositionListener::SetEditor(nsIEditor *aEditor)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIEditorIMESupport> imeEditor = do_QueryInterface(aEditor);
|
1999-08-25 14:51:55 +04:00
|
|
|
if (!imeEditor) return; // should return an error here!
|
1999-08-09 05:37:50 +04:00
|
|
|
|
|
|
|
// note that we don't hold an extra reference here.
|
|
|
|
mEditor = imeEditor;
|
|
|
|
}
|
|
|
|
|
1999-05-04 02:57:48 +04:00
|
|
|
nsresult
|
|
|
|
nsTextEditorCompositionListener::HandleStartComposition(nsIDOMEvent* aCompositionEvent)
|
|
|
|
{
|
1999-08-31 05:20:32 +04:00
|
|
|
nsCOMPtr<nsIPrivateCompositionEvent> pCompositionEvent = do_QueryInterface(aCompositionEvent);
|
|
|
|
nsTextEventReply* eventReply;
|
|
|
|
|
|
|
|
if (!pCompositionEvent) return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
nsresult rv = pCompositionEvent->GetCompositionReply(&eventReply);
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
|
|
|
|
return mEditor->BeginComposition(eventReply);
|
1999-05-04 02:57:48 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsTextEditorCompositionListener::HandleEndComposition(nsIDOMEvent* aCompositionEvent)
|
|
|
|
{
|
1999-08-25 14:51:55 +04:00
|
|
|
return mEditor->EndComposition();
|
1999-05-04 02:57:48 +04:00
|
|
|
}
|
|
|
|
|
1999-02-12 20:18:58 +03:00
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Factory functions
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
NS_NewEditorKeyListener(nsIDOMEventListener ** aInstancePtrResult,
|
1999-08-09 05:37:50 +04:00
|
|
|
nsIEditor *aEditor)
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
|
|
|
nsTextEditorKeyListener* it = new nsTextEditorKeyListener();
|
|
|
|
if (nsnull == it) {
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
|
|
|
|
it->SetEditor(aEditor);
|
|
|
|
|
1999-05-28 04:19:51 +04:00
|
|
|
return it->QueryInterface(nsIDOMEventListener::GetIID(), (void **) aInstancePtrResult);
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
NS_NewEditorMouseListener(nsIDOMEventListener ** aInstancePtrResult,
|
1999-08-09 05:37:50 +04:00
|
|
|
nsIEditor *aEditor)
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
|
|
|
nsTextEditorMouseListener* it = new nsTextEditorMouseListener();
|
|
|
|
if (nsnull == it) {
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
|
|
|
|
it->SetEditor(aEditor);
|
|
|
|
|
1999-05-28 04:19:51 +04:00
|
|
|
return it->QueryInterface(nsIDOMEventListener::GetIID(), (void **) aInstancePtrResult);
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
1999-03-20 02:36:20 +03:00
|
|
|
nsresult
|
1999-08-09 05:37:50 +04:00
|
|
|
NS_NewEditorTextListener(nsIDOMEventListener** aInstancePtrResult, nsIEditor* aEditor)
|
1999-03-20 02:36:20 +03:00
|
|
|
{
|
1999-08-25 14:51:55 +04:00
|
|
|
nsTextEditorTextListener* it = new nsTextEditorTextListener();
|
|
|
|
if (nsnull==it) {
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
1999-03-20 02:36:20 +03:00
|
|
|
|
1999-08-25 14:51:55 +04:00
|
|
|
it->SetEditor(aEditor);
|
1999-03-20 02:36:20 +03:00
|
|
|
|
1999-08-25 14:51:55 +04:00
|
|
|
return it->QueryInterface(nsIDOMEventListener::GetIID(), (void **) aInstancePtrResult);
|
1999-03-20 02:36:20 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
1999-02-12 20:18:58 +03:00
|
|
|
|
1999-03-14 07:45:00 +03:00
|
|
|
nsresult
|
|
|
|
NS_NewEditorDragListener(nsIDOMEventListener ** aInstancePtrResult,
|
1999-08-09 05:37:50 +04:00
|
|
|
nsIEditor *aEditor)
|
1999-03-14 07:45:00 +03:00
|
|
|
{
|
|
|
|
nsTextEditorDragListener* it = new nsTextEditorDragListener();
|
|
|
|
if (nsnull == it) {
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
|
|
|
|
it->SetEditor(aEditor);
|
|
|
|
|
1999-05-28 04:19:51 +04:00
|
|
|
return it->QueryInterface(nsIDOMEventListener::GetIID(), (void **) aInstancePtrResult);
|
1999-03-14 07:45:00 +03:00
|
|
|
}
|
|
|
|
|
1999-05-04 02:57:48 +04:00
|
|
|
nsresult
|
1999-08-09 05:37:50 +04:00
|
|
|
NS_NewEditorCompositionListener(nsIDOMEventListener** aInstancePtrResult, nsIEditor* aEditor)
|
1999-05-04 02:57:48 +04:00
|
|
|
{
|
1999-08-25 14:51:55 +04:00
|
|
|
nsTextEditorCompositionListener* it = new nsTextEditorCompositionListener();
|
|
|
|
if (nsnull==it) {
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
it->SetEditor(aEditor);
|
Preparation for ender-based text control
* added focus listener. Doesn't do much yet, but when focus notifications start appearing, we'll be ready for them. The code is in
place to hide selection when we lose focus and paint selection when we get focus. That's probably not quite right, but it's a start.
We will need to be able to determine the distinction between losing focus to another control within our app, and losing focus to
another app.
* added support for disabled and readonly states in the editor. This is accomplished by having flags set by the client, and letting the
rules system deal with those flags. The flags I added are:
TEXT_EDITOR_FLAG_PLAINTEXT 0x01 // only plain text editing is allowed
TEXT_EDITOR_FLAG_SINGLELINE 0x02 // enter key and CR-LF handled specially
TEXT_EDITOR_FLAG_PASSWORD 0x04 // text is not entered into content, only a representative character
TEXT_EDITOR_FLAG_READONLY 0x08 // editing events are disabled. Editor may still accept focus.
TEXT_EDITOR_FLAG_DISALBED 0x10 // all events are disabled (like scrolling). Editor will not accept focus.
* added WillInsertBreak/DidInsertBreak into text rules, so flags could be checked. This gets us readonly, disabled, and single line
behavior.
* cleaned up the code that allocates, registers, and destroys event listeners. Thanks to Kin and Simon for cleaning up the
ownership model on the listeners, it was a big help.
* added support for a max text length. You can now tell the text editor, be no bigger than n characters.
1999-05-29 01:24:18 +04:00
|
|
|
return it->QueryInterface(nsIDOMEventListener::GetIID(), (void **) aInstancePtrResult);
|
|
|
|
}
|
1999-05-04 02:57:48 +04:00
|
|
|
|
Preparation for ender-based text control
* added focus listener. Doesn't do much yet, but when focus notifications start appearing, we'll be ready for them. The code is in
place to hide selection when we lose focus and paint selection when we get focus. That's probably not quite right, but it's a start.
We will need to be able to determine the distinction between losing focus to another control within our app, and losing focus to
another app.
* added support for disabled and readonly states in the editor. This is accomplished by having flags set by the client, and letting the
rules system deal with those flags. The flags I added are:
TEXT_EDITOR_FLAG_PLAINTEXT 0x01 // only plain text editing is allowed
TEXT_EDITOR_FLAG_SINGLELINE 0x02 // enter key and CR-LF handled specially
TEXT_EDITOR_FLAG_PASSWORD 0x04 // text is not entered into content, only a representative character
TEXT_EDITOR_FLAG_READONLY 0x08 // editing events are disabled. Editor may still accept focus.
TEXT_EDITOR_FLAG_DISALBED 0x10 // all events are disabled (like scrolling). Editor will not accept focus.
* added WillInsertBreak/DidInsertBreak into text rules, so flags could be checked. This gets us readonly, disabled, and single line
behavior.
* cleaned up the code that allocates, registers, and destroys event listeners. Thanks to Kin and Simon for cleaning up the
ownership model on the listeners, it was a big help.
* added support for a max text length. You can now tell the text editor, be no bigger than n characters.
1999-05-29 01:24:18 +04:00
|
|
|
nsresult
|
|
|
|
NS_NewEditorFocusListener(nsIDOMEventListener ** aInstancePtrResult,
|
1999-08-09 05:37:50 +04:00
|
|
|
nsIEditor *aEditor)
|
Preparation for ender-based text control
* added focus listener. Doesn't do much yet, but when focus notifications start appearing, we'll be ready for them. The code is in
place to hide selection when we lose focus and paint selection when we get focus. That's probably not quite right, but it's a start.
We will need to be able to determine the distinction between losing focus to another control within our app, and losing focus to
another app.
* added support for disabled and readonly states in the editor. This is accomplished by having flags set by the client, and letting the
rules system deal with those flags. The flags I added are:
TEXT_EDITOR_FLAG_PLAINTEXT 0x01 // only plain text editing is allowed
TEXT_EDITOR_FLAG_SINGLELINE 0x02 // enter key and CR-LF handled specially
TEXT_EDITOR_FLAG_PASSWORD 0x04 // text is not entered into content, only a representative character
TEXT_EDITOR_FLAG_READONLY 0x08 // editing events are disabled. Editor may still accept focus.
TEXT_EDITOR_FLAG_DISALBED 0x10 // all events are disabled (like scrolling). Editor will not accept focus.
* added WillInsertBreak/DidInsertBreak into text rules, so flags could be checked. This gets us readonly, disabled, and single line
behavior.
* cleaned up the code that allocates, registers, and destroys event listeners. Thanks to Kin and Simon for cleaning up the
ownership model on the listeners, it was a big help.
* added support for a max text length. You can now tell the text editor, be no bigger than n characters.
1999-05-29 01:24:18 +04:00
|
|
|
{
|
|
|
|
nsTextEditorFocusListener* it = new nsTextEditorFocusListener();
|
|
|
|
if (nsnull == it) {
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
it->SetEditor(aEditor);
|
1999-08-25 14:51:55 +04:00
|
|
|
return it->QueryInterface(nsIDOMEventListener::GetIID(), (void **) aInstancePtrResult);
|
1999-05-04 02:57:48 +04:00
|
|
|
}
|
1999-02-12 20:18:58 +03:00
|
|
|
|
1999-03-20 02:36:20 +03:00
|
|
|
|
Preparation for ender-based text control
* added focus listener. Doesn't do much yet, but when focus notifications start appearing, we'll be ready for them. The code is in
place to hide selection when we lose focus and paint selection when we get focus. That's probably not quite right, but it's a start.
We will need to be able to determine the distinction between losing focus to another control within our app, and losing focus to
another app.
* added support for disabled and readonly states in the editor. This is accomplished by having flags set by the client, and letting the
rules system deal with those flags. The flags I added are:
TEXT_EDITOR_FLAG_PLAINTEXT 0x01 // only plain text editing is allowed
TEXT_EDITOR_FLAG_SINGLELINE 0x02 // enter key and CR-LF handled specially
TEXT_EDITOR_FLAG_PASSWORD 0x04 // text is not entered into content, only a representative character
TEXT_EDITOR_FLAG_READONLY 0x08 // editing events are disabled. Editor may still accept focus.
TEXT_EDITOR_FLAG_DISALBED 0x10 // all events are disabled (like scrolling). Editor will not accept focus.
* added WillInsertBreak/DidInsertBreak into text rules, so flags could be checked. This gets us readonly, disabled, and single line
behavior.
* cleaned up the code that allocates, registers, and destroys event listeners. Thanks to Kin and Simon for cleaning up the
ownership model on the listeners, it was a big help.
* added support for a max text length. You can now tell the text editor, be no bigger than n characters.
1999-05-29 01:24:18 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* nsTextEditorFocusListener implementation
|
|
|
|
*/
|
|
|
|
|
|
|
|
NS_IMPL_ADDREF(nsTextEditorFocusListener)
|
|
|
|
|
|
|
|
NS_IMPL_RELEASE(nsTextEditorFocusListener)
|
|
|
|
|
|
|
|
|
|
|
|
nsTextEditorFocusListener::nsTextEditorFocusListener()
|
|
|
|
{
|
|
|
|
NS_INIT_REFCNT();
|
|
|
|
}
|
|
|
|
|
|
|
|
nsTextEditorFocusListener::~nsTextEditorFocusListener()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsTextEditorFocusListener::QueryInterface(REFNSIID aIID, void** aInstancePtr)
|
|
|
|
{
|
|
|
|
if (nsnull == aInstancePtr) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
|
|
|
static NS_DEFINE_IID(kIDOMFocusListenerIID, NS_IDOMFOCUSLISTENER_IID);
|
|
|
|
static NS_DEFINE_IID(kIDOMEventListenerIID, NS_IDOMEVENTLISTENER_IID);
|
|
|
|
static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);
|
|
|
|
if (aIID.Equals(kISupportsIID)) {
|
|
|
|
*aInstancePtr = (void*)(nsISupports*)this;
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
if (aIID.Equals(kIDOMEventListenerIID)) {
|
|
|
|
*aInstancePtr = (void*)(nsIDOMEventListener*)this;
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
if (aIID.Equals(kIDOMFocusListenerIID)) {
|
|
|
|
*aInstancePtr = (void*)(nsIDOMFocusListener*)this;
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
return NS_NOINTERFACE;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsTextEditorFocusListener::HandleEvent(nsIDOMEvent* aEvent)
|
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
1999-08-02 17:53:23 +04:00
|
|
|
nsTextEditorFocusListener::Focus(nsIDOMEvent* aEvent)
|
Preparation for ender-based text control
* added focus listener. Doesn't do much yet, but when focus notifications start appearing, we'll be ready for them. The code is in
place to hide selection when we lose focus and paint selection when we get focus. That's probably not quite right, but it's a start.
We will need to be able to determine the distinction between losing focus to another control within our app, and losing focus to
another app.
* added support for disabled and readonly states in the editor. This is accomplished by having flags set by the client, and letting the
rules system deal with those flags. The flags I added are:
TEXT_EDITOR_FLAG_PLAINTEXT 0x01 // only plain text editing is allowed
TEXT_EDITOR_FLAG_SINGLELINE 0x02 // enter key and CR-LF handled specially
TEXT_EDITOR_FLAG_PASSWORD 0x04 // text is not entered into content, only a representative character
TEXT_EDITOR_FLAG_READONLY 0x08 // editing events are disabled. Editor may still accept focus.
TEXT_EDITOR_FLAG_DISALBED 0x10 // all events are disabled (like scrolling). Editor will not accept focus.
* added WillInsertBreak/DidInsertBreak into text rules, so flags could be checked. This gets us readonly, disabled, and single line
behavior.
* cleaned up the code that allocates, registers, and destroys event listeners. Thanks to Kin and Simon for cleaning up the
ownership model on the listeners, it was a big help.
* added support for a max text length. You can now tell the text editor, be no bigger than n characters.
1999-05-29 01:24:18 +04:00
|
|
|
{
|
|
|
|
// turn on selection and caret
|
|
|
|
if (mEditor)
|
|
|
|
{
|
1999-08-07 09:28:57 +04:00
|
|
|
PRUint32 flags;
|
|
|
|
mEditor->GetFlags(&flags);
|
1999-08-09 05:37:50 +04:00
|
|
|
if (! (flags & nsIHTMLEditor::eEditorDisabledMask))
|
1999-08-07 09:28:57 +04:00
|
|
|
{ // only enable caret and selection if the editor is not disabled
|
|
|
|
nsCOMPtr<nsIEditor>editor = do_QueryInterface(mEditor);
|
|
|
|
if (editor)
|
Preparation for ender-based text control
* added focus listener. Doesn't do much yet, but when focus notifications start appearing, we'll be ready for them. The code is in
place to hide selection when we lose focus and paint selection when we get focus. That's probably not quite right, but it's a start.
We will need to be able to determine the distinction between losing focus to another control within our app, and losing focus to
another app.
* added support for disabled and readonly states in the editor. This is accomplished by having flags set by the client, and letting the
rules system deal with those flags. The flags I added are:
TEXT_EDITOR_FLAG_PLAINTEXT 0x01 // only plain text editing is allowed
TEXT_EDITOR_FLAG_SINGLELINE 0x02 // enter key and CR-LF handled specially
TEXT_EDITOR_FLAG_PASSWORD 0x04 // text is not entered into content, only a representative character
TEXT_EDITOR_FLAG_READONLY 0x08 // editing events are disabled. Editor may still accept focus.
TEXT_EDITOR_FLAG_DISALBED 0x10 // all events are disabled (like scrolling). Editor will not accept focus.
* added WillInsertBreak/DidInsertBreak into text rules, so flags could be checked. This gets us readonly, disabled, and single line
behavior.
* cleaned up the code that allocates, registers, and destroys event listeners. Thanks to Kin and Simon for cleaning up the
ownership model on the listeners, it was a big help.
* added support for a max text length. You can now tell the text editor, be no bigger than n characters.
1999-05-29 01:24:18 +04:00
|
|
|
{
|
1999-08-07 09:28:57 +04:00
|
|
|
nsCOMPtr<nsIPresShell>ps;
|
|
|
|
editor->GetPresShell(getter_AddRefs(ps));
|
|
|
|
if (ps)
|
Preparation for ender-based text control
* added focus listener. Doesn't do much yet, but when focus notifications start appearing, we'll be ready for them. The code is in
place to hide selection when we lose focus and paint selection when we get focus. That's probably not quite right, but it's a start.
We will need to be able to determine the distinction between losing focus to another control within our app, and losing focus to
another app.
* added support for disabled and readonly states in the editor. This is accomplished by having flags set by the client, and letting the
rules system deal with those flags. The flags I added are:
TEXT_EDITOR_FLAG_PLAINTEXT 0x01 // only plain text editing is allowed
TEXT_EDITOR_FLAG_SINGLELINE 0x02 // enter key and CR-LF handled specially
TEXT_EDITOR_FLAG_PASSWORD 0x04 // text is not entered into content, only a representative character
TEXT_EDITOR_FLAG_READONLY 0x08 // editing events are disabled. Editor may still accept focus.
TEXT_EDITOR_FLAG_DISALBED 0x10 // all events are disabled (like scrolling). Editor will not accept focus.
* added WillInsertBreak/DidInsertBreak into text rules, so flags could be checked. This gets us readonly, disabled, and single line
behavior.
* cleaned up the code that allocates, registers, and destroys event listeners. Thanks to Kin and Simon for cleaning up the
ownership model on the listeners, it was a big help.
* added support for a max text length. You can now tell the text editor, be no bigger than n characters.
1999-05-29 01:24:18 +04:00
|
|
|
{
|
1999-08-09 05:37:50 +04:00
|
|
|
if (! (flags & nsIHTMLEditor::eEditorReadonlyMask))
|
1999-08-07 09:28:57 +04:00
|
|
|
{ // only enable caret if the editor is not readonly
|
|
|
|
ps->SetCaretEnabled(PR_TRUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMDocument>domDoc;
|
|
|
|
editor->GetDocument(getter_AddRefs(domDoc));
|
|
|
|
if (domDoc)
|
1999-08-02 17:53:23 +04:00
|
|
|
{
|
1999-08-07 09:28:57 +04:00
|
|
|
nsCOMPtr<nsIDocument>doc = do_QueryInterface(domDoc);
|
|
|
|
if (doc)
|
|
|
|
{
|
|
|
|
doc->SetDisplaySelection(PR_TRUE);
|
|
|
|
}
|
1999-08-02 17:53:23 +04:00
|
|
|
}
|
1999-08-31 05:14:40 +04:00
|
|
|
#ifdef USE_HACK_REPAINT
|
1999-08-07 09:28:57 +04:00
|
|
|
// begin hack repaint
|
|
|
|
nsCOMPtr<nsIViewManager> viewmgr;
|
|
|
|
ps->GetViewManager(getter_AddRefs(viewmgr));
|
|
|
|
if (viewmgr) {
|
|
|
|
nsIView* view;
|
1999-08-25 14:51:55 +04:00
|
|
|
viewmgr->GetRootView(view); // views are not refCounted
|
1999-08-07 09:28:57 +04:00
|
|
|
if (view) {
|
|
|
|
viewmgr->UpdateView(view,nsnull,NS_VMREFRESH_IMMEDIATE);
|
|
|
|
}
|
1999-08-31 04:51:23 +04:00
|
|
|
}
|
1999-08-31 05:14:40 +04:00
|
|
|
// end hack repaint
|
|
|
|
#else
|
|
|
|
ps->RepaintSelection(SELECTION_NORMAL);
|
|
|
|
#endif
|
Preparation for ender-based text control
* added focus listener. Doesn't do much yet, but when focus notifications start appearing, we'll be ready for them. The code is in
place to hide selection when we lose focus and paint selection when we get focus. That's probably not quite right, but it's a start.
We will need to be able to determine the distinction between losing focus to another control within our app, and losing focus to
another app.
* added support for disabled and readonly states in the editor. This is accomplished by having flags set by the client, and letting the
rules system deal with those flags. The flags I added are:
TEXT_EDITOR_FLAG_PLAINTEXT 0x01 // only plain text editing is allowed
TEXT_EDITOR_FLAG_SINGLELINE 0x02 // enter key and CR-LF handled specially
TEXT_EDITOR_FLAG_PASSWORD 0x04 // text is not entered into content, only a representative character
TEXT_EDITOR_FLAG_READONLY 0x08 // editing events are disabled. Editor may still accept focus.
TEXT_EDITOR_FLAG_DISALBED 0x10 // all events are disabled (like scrolling). Editor will not accept focus.
* added WillInsertBreak/DidInsertBreak into text rules, so flags could be checked. This gets us readonly, disabled, and single line
behavior.
* cleaned up the code that allocates, registers, and destroys event listeners. Thanks to Kin and Simon for cleaning up the
ownership model on the listeners, it was a big help.
* added support for a max text length. You can now tell the text editor, be no bigger than n characters.
1999-05-29 01:24:18 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
1999-08-02 17:53:23 +04:00
|
|
|
nsTextEditorFocusListener::Blur(nsIDOMEvent* aEvent)
|
Preparation for ender-based text control
* added focus listener. Doesn't do much yet, but when focus notifications start appearing, we'll be ready for them. The code is in
place to hide selection when we lose focus and paint selection when we get focus. That's probably not quite right, but it's a start.
We will need to be able to determine the distinction between losing focus to another control within our app, and losing focus to
another app.
* added support for disabled and readonly states in the editor. This is accomplished by having flags set by the client, and letting the
rules system deal with those flags. The flags I added are:
TEXT_EDITOR_FLAG_PLAINTEXT 0x01 // only plain text editing is allowed
TEXT_EDITOR_FLAG_SINGLELINE 0x02 // enter key and CR-LF handled specially
TEXT_EDITOR_FLAG_PASSWORD 0x04 // text is not entered into content, only a representative character
TEXT_EDITOR_FLAG_READONLY 0x08 // editing events are disabled. Editor may still accept focus.
TEXT_EDITOR_FLAG_DISALBED 0x10 // all events are disabled (like scrolling). Editor will not accept focus.
* added WillInsertBreak/DidInsertBreak into text rules, so flags could be checked. This gets us readonly, disabled, and single line
behavior.
* cleaned up the code that allocates, registers, and destroys event listeners. Thanks to Kin and Simon for cleaning up the
ownership model on the listeners, it was a big help.
* added support for a max text length. You can now tell the text editor, be no bigger than n characters.
1999-05-29 01:24:18 +04:00
|
|
|
{
|
|
|
|
// turn off selection and caret
|
|
|
|
if (mEditor)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIEditor>editor = do_QueryInterface(mEditor);
|
|
|
|
if (editor)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIPresShell>ps;
|
|
|
|
editor->GetPresShell(getter_AddRefs(ps));
|
|
|
|
if (ps)
|
|
|
|
{
|
|
|
|
ps->SetCaretEnabled(PR_FALSE);
|
1999-08-03 10:07:29 +04:00
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMDocument>domDoc;
|
|
|
|
editor->GetDocument(getter_AddRefs(domDoc));
|
|
|
|
if (domDoc)
|
Preparation for ender-based text control
* added focus listener. Doesn't do much yet, but when focus notifications start appearing, we'll be ready for them. The code is in
place to hide selection when we lose focus and paint selection when we get focus. That's probably not quite right, but it's a start.
We will need to be able to determine the distinction between losing focus to another control within our app, and losing focus to
another app.
* added support for disabled and readonly states in the editor. This is accomplished by having flags set by the client, and letting the
rules system deal with those flags. The flags I added are:
TEXT_EDITOR_FLAG_PLAINTEXT 0x01 // only plain text editing is allowed
TEXT_EDITOR_FLAG_SINGLELINE 0x02 // enter key and CR-LF handled specially
TEXT_EDITOR_FLAG_PASSWORD 0x04 // text is not entered into content, only a representative character
TEXT_EDITOR_FLAG_READONLY 0x08 // editing events are disabled. Editor may still accept focus.
TEXT_EDITOR_FLAG_DISALBED 0x10 // all events are disabled (like scrolling). Editor will not accept focus.
* added WillInsertBreak/DidInsertBreak into text rules, so flags could be checked. This gets us readonly, disabled, and single line
behavior.
* cleaned up the code that allocates, registers, and destroys event listeners. Thanks to Kin and Simon for cleaning up the
ownership model on the listeners, it was a big help.
* added support for a max text length. You can now tell the text editor, be no bigger than n characters.
1999-05-29 01:24:18 +04:00
|
|
|
{
|
1999-08-03 10:07:29 +04:00
|
|
|
nsCOMPtr<nsIDocument>doc = do_QueryInterface(domDoc);
|
|
|
|
if (doc)
|
|
|
|
{
|
|
|
|
doc->SetDisplaySelection(PR_FALSE);
|
|
|
|
}
|
Preparation for ender-based text control
* added focus listener. Doesn't do much yet, but when focus notifications start appearing, we'll be ready for them. The code is in
place to hide selection when we lose focus and paint selection when we get focus. That's probably not quite right, but it's a start.
We will need to be able to determine the distinction between losing focus to another control within our app, and losing focus to
another app.
* added support for disabled and readonly states in the editor. This is accomplished by having flags set by the client, and letting the
rules system deal with those flags. The flags I added are:
TEXT_EDITOR_FLAG_PLAINTEXT 0x01 // only plain text editing is allowed
TEXT_EDITOR_FLAG_SINGLELINE 0x02 // enter key and CR-LF handled specially
TEXT_EDITOR_FLAG_PASSWORD 0x04 // text is not entered into content, only a representative character
TEXT_EDITOR_FLAG_READONLY 0x08 // editing events are disabled. Editor may still accept focus.
TEXT_EDITOR_FLAG_DISALBED 0x10 // all events are disabled (like scrolling). Editor will not accept focus.
* added WillInsertBreak/DidInsertBreak into text rules, so flags could be checked. This gets us readonly, disabled, and single line
behavior.
* cleaned up the code that allocates, registers, and destroys event listeners. Thanks to Kin and Simon for cleaning up the
ownership model on the listeners, it was a big help.
* added support for a max text length. You can now tell the text editor, be no bigger than n characters.
1999-05-29 01:24:18 +04:00
|
|
|
}
|
1999-08-31 05:14:40 +04:00
|
|
|
#ifdef USE_HACK_REPAINT
|
1999-08-03 10:07:29 +04:00
|
|
|
// begin hack repaint
|
|
|
|
nsCOMPtr<nsIViewManager> viewmgr;
|
|
|
|
ps->GetViewManager(getter_AddRefs(viewmgr));
|
|
|
|
if (viewmgr)
|
|
|
|
{
|
|
|
|
nsIView* view;
|
1999-08-25 14:51:55 +04:00
|
|
|
viewmgr->GetRootView(view); // views are not refCounted
|
1999-08-03 10:07:29 +04:00
|
|
|
if (view) {
|
|
|
|
viewmgr->UpdateView(view,nsnull,NS_VMREFRESH_IMMEDIATE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// end hack repaint
|
1999-08-31 05:14:40 +04:00
|
|
|
#else
|
|
|
|
ps->RepaintSelection(SELECTION_NORMAL);
|
|
|
|
#endif
|
Preparation for ender-based text control
* added focus listener. Doesn't do much yet, but when focus notifications start appearing, we'll be ready for them. The code is in
place to hide selection when we lose focus and paint selection when we get focus. That's probably not quite right, but it's a start.
We will need to be able to determine the distinction between losing focus to another control within our app, and losing focus to
another app.
* added support for disabled and readonly states in the editor. This is accomplished by having flags set by the client, and letting the
rules system deal with those flags. The flags I added are:
TEXT_EDITOR_FLAG_PLAINTEXT 0x01 // only plain text editing is allowed
TEXT_EDITOR_FLAG_SINGLELINE 0x02 // enter key and CR-LF handled specially
TEXT_EDITOR_FLAG_PASSWORD 0x04 // text is not entered into content, only a representative character
TEXT_EDITOR_FLAG_READONLY 0x08 // editing events are disabled. Editor may still accept focus.
TEXT_EDITOR_FLAG_DISALBED 0x10 // all events are disabled (like scrolling). Editor will not accept focus.
* added WillInsertBreak/DidInsertBreak into text rules, so flags could be checked. This gets us readonly, disabled, and single line
behavior.
* cleaned up the code that allocates, registers, and destroys event listeners. Thanks to Kin and Simon for cleaning up the
ownership model on the listeners, it was a big help.
* added support for a max text length. You can now tell the text editor, be no bigger than n characters.
1999-05-29 01:24:18 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|