1999-02-12 20:18:58 +03:00
|
|
|
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
|
|
*
|
1999-11-06 06:43:54 +03:00
|
|
|
* The contents of this file are subject to the Netscape Public
|
|
|
|
* License Version 1.1 (the "License"); you may not use this file
|
|
|
|
* except in compliance with the License. You may obtain a copy of
|
|
|
|
* the License at http://www.mozilla.org/NPL/
|
1999-02-12 20:18:58 +03:00
|
|
|
*
|
1999-11-06 06:43:54 +03:00
|
|
|
* Software distributed under the License is distributed on an "AS
|
|
|
|
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
|
|
|
* implied. See the License for the specific language governing
|
|
|
|
* rights and limitations under the License.
|
1999-02-12 20:18:58 +03:00
|
|
|
*
|
1999-11-06 06:43:54 +03:00
|
|
|
* The Original Code is mozilla.org code.
|
|
|
|
*
|
|
|
|
* The Initial Developer of the Original Code is Netscape
|
1999-02-12 20:18:58 +03:00
|
|
|
* Communications Corporation. Portions created by Netscape are
|
1999-11-06 06:43:54 +03:00
|
|
|
* Copyright (C) 1998 Netscape Communications Corporation. All
|
|
|
|
* Rights Reserved.
|
|
|
|
*
|
|
|
|
* Contributor(s):
|
2000-01-11 23:49:15 +03:00
|
|
|
* Pierre Phaneuf <pp@ludusdesign.com>
|
1999-02-12 20:18:58 +03:00
|
|
|
*/
|
|
|
|
#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-11-03 10:11:45 +03:00
|
|
|
#include "nsIDOMKeyEvent.h"
|
|
|
|
#include "nsIDOMMouseEvent.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-12-16 01:04:43 +03:00
|
|
|
#include "nsIPrivateDOMEvent.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"
|
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_IID(kCDataFlavorCID, NS_DATAFLAVOR_CID);
|
1999-08-19 17:30:48 +04:00
|
|
|
static NS_DEFINE_IID(kContentIteratorCID, NS_CONTENTITERATOR_CID);
|
|
|
|
static NS_DEFINE_IID(kCXIFConverterCID, NS_XIFFORMATCONVERTER_CID);
|
|
|
|
|
1999-12-01 03:35:31 +03:00
|
|
|
//#define DEBUG_IME
|
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;
|
|
|
|
}
|
2000-01-11 23:49:15 +03:00
|
|
|
if (aIID.Equals(NS_GET_IID(nsISupports))) {
|
1999-02-12 20:18:58 +03:00
|
|
|
*aInstancePtr = (void*)(nsISupports*)this;
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2000-01-11 23:49:15 +03:00
|
|
|
if (aIID.Equals(NS_GET_IID(nsIDOMEventListener))) {
|
1999-02-12 20:18:58 +03:00
|
|
|
*aInstancePtr = (void*)(nsIDOMEventListener*)this;
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2000-01-11 23:49:15 +03:00
|
|
|
if (aIID.Equals(NS_GET_IID(nsIDOMKeyListener))) {
|
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-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-11-03 10:11:45 +03:00
|
|
|
nsCOMPtr<nsIDOMKeyEvent>keyEvent;
|
|
|
|
keyEvent = do_QueryInterface(aKeyEvent);
|
|
|
|
if (!keyEvent)
|
1999-08-25 14:51:55 +04:00
|
|
|
{
|
|
|
|
//non-key event passed to keydown. bad things.
|
|
|
|
return NS_OK;
|
|
|
|
}
|
1999-12-16 01:04:43 +03:00
|
|
|
|
|
|
|
nsCOMPtr<nsIPrivateDOMEvent> privateEvent = do_QueryInterface(aKeyEvent);
|
|
|
|
if(privateEvent)
|
|
|
|
{
|
|
|
|
PRBool dispatchStopped;
|
|
|
|
privateEvent->IsDispatchStopped(&dispatchStopped);
|
|
|
|
if(dispatchStopped)
|
|
|
|
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-11-03 10:11:45 +03:00
|
|
|
keyEvent->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-11-03 10:11:45 +03:00
|
|
|
if (nsIDOMKeyEvent::DOM_VK_SHIFT==keyCode
|
|
|
|
|| nsIDOMKeyEvent::DOM_VK_CONTROL==keyCode
|
|
|
|
|| nsIDOMKeyEvent::DOM_VK_ALT==keyCode)
|
1999-10-21 00:02:44 +04:00
|
|
|
return NS_ERROR_BASE; // consumed
|
1999-11-03 10:11:45 +03:00
|
|
|
if (nsIDOMKeyEvent::DOM_VK_BACK_SPACE==keyCode)
|
1999-08-25 14:51:55 +04:00
|
|
|
{
|
1999-12-07 11:30:19 +03:00
|
|
|
mEditor->DeleteSelection(nsIEditor::ePrevious);
|
1999-08-31 05:14:40 +04:00
|
|
|
ScrollSelectionIntoView();
|
|
|
|
return NS_ERROR_BASE; // consumed
|
1999-08-25 14:51:55 +04:00
|
|
|
}
|
1999-11-03 10:11:45 +03:00
|
|
|
if (nsIDOMKeyEvent::DOM_VK_DELETE==keyCode)
|
1999-09-18 00:11:13 +04:00
|
|
|
{
|
1999-12-07 11:30:19 +03:00
|
|
|
mEditor->DeleteSelection(nsIEditor::eNext);
|
1999-09-18 00:11:13 +04:00
|
|
|
ScrollSelectionIntoView();
|
|
|
|
return NS_ERROR_BASE; // consumed
|
|
|
|
}
|
1999-11-03 10:11:45 +03:00
|
|
|
if (nsIDOMKeyEvent::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
|
1999-11-03 10:11:45 +03:00
|
|
|
htmlEditor->EditorKeyPress(keyEvent);
|
1999-09-18 00:11:13 +04:00
|
|
|
ScrollSelectionIntoView();
|
|
|
|
return NS_ERROR_BASE; // "I handled the event, don't do default processing"
|
|
|
|
}
|
1999-11-04 01:05:45 +03:00
|
|
|
if (nsIDOMKeyEvent::DOM_VK_RETURN==keyCode
|
|
|
|
|| nsIDOMKeyEvent::DOM_VK_ENTER==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();
|
1999-11-03 10:11:45 +03:00
|
|
|
htmlEditor->EditorKeyPress(keyEvent);
|
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
|
|
|
|
1999-11-03 10:11:45 +03:00
|
|
|
htmlEditor->EditorKeyPress(keyEvent);
|
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
|
|
|
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;
|
2000-02-19 00:32:26 +03:00
|
|
|
|
|
|
|
#ifdef USE_OLD_OBSOLETE_HARDWIRED_SHORTCUT_KEYS
|
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-05-19 03:51:04 +04:00
|
|
|
|
1999-11-03 10:11:45 +03:00
|
|
|
nsCOMPtr<nsIDOMKeyEvent>keyEvent;
|
|
|
|
keyEvent = do_QueryInterface(aKeyEvent);
|
|
|
|
if (!keyEvent) {
|
1999-05-19 03:51:04 +04:00
|
|
|
//non-key event passed in. bad things.
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-12-01 00:58:00 +03:00
|
|
|
if (NS_SUCCEEDED(keyEvent->GetCharCode(&charCode)))
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
1999-12-01 00:58:00 +03:00
|
|
|
// Figure out the modifier key, different on every platform
|
|
|
|
PRBool isOnlyPlatformModifierKey = PR_FALSE;;
|
|
|
|
PRBool isCtrlKey, isAltKey, isMetaKey, isShiftKey;
|
|
|
|
if (NS_SUCCEEDED(keyEvent->GetAltKey(&isAltKey)) &&
|
|
|
|
NS_SUCCEEDED(keyEvent->GetMetaKey(&isMetaKey)) &&
|
|
|
|
NS_SUCCEEDED(keyEvent->GetShiftKey(&isShiftKey)) &&
|
|
|
|
NS_SUCCEEDED(keyEvent->GetCtrlKey(&isCtrlKey)) )
|
|
|
|
{
|
|
|
|
#if defined(XP_MAC)
|
|
|
|
isOnlyPlatformModifierKey = (isMetaKey &&
|
|
|
|
!isShiftKey && !isCtrlKey && !isAltKey);
|
|
|
|
#elif defined(XP_UNIX)
|
|
|
|
isOnlyPlatformModifierKey = (isAltKey &&
|
|
|
|
!isShiftKey && !isCtrlKey && !isMetaKey);
|
|
|
|
#else /* Windows and default */
|
|
|
|
isOnlyPlatformModifierKey = (isCtrlKey &&
|
|
|
|
!isShiftKey && !isAltKey && !isMetaKey);
|
1999-09-10 18:42:20 +04:00
|
|
|
#endif
|
1999-12-01 00:58:00 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
if (PR_TRUE == isOnlyPlatformModifierKey)
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
1999-12-01 00:58:00 +03:00
|
|
|
// swallow all keys with only the platform modifier
|
|
|
|
// even if we don't process them
|
|
|
|
aProcessed = PR_TRUE;
|
|
|
|
|
|
|
|
// A minimal set of fallback mappings in case
|
|
|
|
// XUL keybindings are unavailable:
|
|
|
|
switch (charCode)
|
|
|
|
{
|
|
|
|
// XXX: hard-coded select all
|
|
|
|
case (PRUint32)('a'):
|
1999-03-10 22:49:43 +03:00
|
|
|
if (mEditor)
|
|
|
|
mEditor->SelectAll();
|
1999-12-01 00:58:00 +03:00
|
|
|
break;
|
1999-03-10 22:49:43 +03:00
|
|
|
|
1999-12-01 00:58:00 +03:00
|
|
|
// XXX: hard-coded cut
|
|
|
|
case (PRUint32)('x'):
|
1999-03-11 01:46:15 +03:00
|
|
|
if (mEditor)
|
|
|
|
mEditor->Cut();
|
1999-12-01 00:58:00 +03:00
|
|
|
break;
|
1999-03-11 01:46:15 +03:00
|
|
|
|
1999-12-01 00:58:00 +03:00
|
|
|
// XXX: hard-coded copy
|
|
|
|
case (PRUint32)('c'):
|
1999-03-11 01:46:15 +03:00
|
|
|
if (mEditor)
|
|
|
|
mEditor->Copy();
|
1999-12-01 00:58:00 +03:00
|
|
|
break;
|
1999-05-14 02:11:05 +04:00
|
|
|
|
1999-12-01 00:58:00 +03:00
|
|
|
// XXX: hard-coded paste
|
|
|
|
case (PRUint32)('v'):
|
1999-03-11 01:46:15 +03:00
|
|
|
if (mEditor)
|
1999-12-01 00:58:00 +03:00
|
|
|
mEditor->Paste();
|
|
|
|
break;
|
1999-03-11 01:46:15 +03:00
|
|
|
|
1999-12-01 00:58:00 +03:00
|
|
|
// XXX: hard-coded undo
|
|
|
|
case (PRUint32)('z'):
|
1999-03-02 10:52:41 +03:00
|
|
|
if (mEditor)
|
1999-02-12 20:18:58 +03:00
|
|
|
mEditor->Undo(1);
|
1999-12-01 00:58:00 +03:00
|
|
|
break;
|
1999-02-12 20:18:58 +03:00
|
|
|
|
1999-12-01 00:58:00 +03:00
|
|
|
// XXX: hard-coded redo
|
|
|
|
case (PRUint32)('y'):
|
1999-03-02 10:52:41 +03:00
|
|
|
if (mEditor)
|
1999-02-12 20:18:58 +03:00
|
|
|
mEditor->Redo(1);
|
1999-12-01 00:58:00 +03:00
|
|
|
break;
|
|
|
|
}
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
|
|
|
}
|
2000-02-19 00:32:26 +03:00
|
|
|
#endif
|
1999-02-12 20:18:58 +03:00
|
|
|
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
|
|
|
|
2000-01-11 23:49:15 +03:00
|
|
|
if (aIID.Equals(NS_GET_IID(nsISupports))) {
|
1999-02-12 20:18:58 +03:00
|
|
|
*aInstancePtr = (void*)(nsISupports*)this;
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2000-01-11 23:49:15 +03:00
|
|
|
if (aIID.Equals(NS_GET_IID(nsIDOMEventListener))) {
|
1999-02-12 20:18:58 +03:00
|
|
|
*aInstancePtr = (void*)(nsIDOMEventListener*)this;
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2000-01-11 23:49:15 +03:00
|
|
|
if (aIID.Equals(NS_GET_IID(nsIDOMMouseListener))) {
|
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,
|
2000-01-11 23:49:15 +03:00
|
|
|
NS_GET_IID(nsIContentIterator),
|
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 07:16:48 +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-11-30 03:10:55 +03:00
|
|
|
nsCOMPtr<nsIDOMMouseEvent> mouseEvent ( do_QueryInterface(aMouseEvent) );
|
1999-11-03 10:11:45 +03:00
|
|
|
if (!mouseEvent) {
|
1999-05-19 03:51:04 +04:00
|
|
|
//non-ui event passed in. bad things.
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-12-08 06:39:36 +03:00
|
|
|
// If we got a mouse down inside the editing area, we should force the
|
|
|
|
// IME to commit before we change the cursor position
|
|
|
|
nsCOMPtr<nsIEditorIMESupport> imeEditor = do_QueryInterface(mEditor);
|
|
|
|
if(imeEditor)
|
|
|
|
imeEditor->ForceCompositionEnd();
|
|
|
|
|
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;
|
1999-11-03 10:11:45 +03:00
|
|
|
mouseEvent->GetButton(&button);
|
1999-08-19 17:30:48 +04:00
|
|
|
// middle-mouse click (paste);
|
1999-11-30 03:10:55 +03:00
|
|
|
if (button == 2)
|
|
|
|
{
|
1999-08-19 17:30:48 +04:00
|
|
|
|
|
|
|
// Set the selection to the point under the mouse cursor:
|
1999-11-03 10:11:45 +03:00
|
|
|
nsCOMPtr<nsIDOMNSUIEvent> nsuiEvent (do_QueryInterface(aMouseEvent));
|
1999-08-25 14:51:55 +04:00
|
|
|
|
1999-11-03 10:11:45 +03:00
|
|
|
if (!nsuiEvent)
|
1999-08-25 14:51:55 +04:00
|
|
|
return NS_ERROR_BASE; // NS_ERROR_BASE means "We did process the event".
|
|
|
|
nsCOMPtr<nsIDOMNode> parent;
|
1999-11-03 10:11:45 +03:00
|
|
|
if (!NS_SUCCEEDED(nsuiEvent->GetRangeParent(getter_AddRefs(parent))))
|
1999-08-25 14:51:55 +04:00
|
|
|
return NS_ERROR_BASE; // NS_ERROR_BASE means "We did process the event".
|
|
|
|
PRInt32 offset = 0;
|
1999-11-03 10:11:45 +03:00
|
|
|
if (!NS_SUCCEEDED(nsuiEvent->GetRangeOffset(&offset)))
|
1999-08-25 14:51:55 +04:00
|
|
|
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.
|
1999-11-30 03:10:55 +03:00
|
|
|
mouseEvent = do_QueryInterface(aMouseEvent);
|
1999-08-25 14:51:55 +04:00
|
|
|
PRBool ctrlKey = PR_FALSE;
|
1999-11-03 10:11:45 +03:00
|
|
|
mouseEvent->GetCtrlKey(&ctrlKey);
|
1999-08-25 14:51:55 +04:00
|
|
|
|
|
|
|
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
|
|
|
|
2000-01-11 23:49:15 +03:00
|
|
|
if (aIID.Equals(NS_GET_IID(nsISupports))) {
|
1999-03-20 02:36:20 +03:00
|
|
|
*aInstancePtr = (void*)(nsISupports*)this;
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2000-01-11 23:49:15 +03:00
|
|
|
if (aIID.Equals(NS_GET_IID(nsIDOMEventListener))) {
|
1999-03-20 02:36:20 +03:00
|
|
|
*aInstancePtr = (void*)(nsIDOMEventListener*)this;
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2000-01-11 23:49:15 +03:00
|
|
|
if (aIID.Equals(NS_GET_IID(nsIDOMTextListener))) {
|
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
|
|
|
{
|
1999-12-01 03:35:31 +03:00
|
|
|
#ifdef DEBUG_IME
|
1999-10-28 02:56:36 +04:00
|
|
|
printf("nsTextEditorTextListener::HandleEvent\n");
|
|
|
|
#endif
|
1999-03-20 02:36:20 +03:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsTextEditorTextListener::HandleText(nsIDOMEvent* aTextEvent)
|
|
|
|
{
|
1999-12-01 03:35:31 +03:00
|
|
|
#ifdef DEBUG_IME
|
1999-10-28 02:56:36 +04:00
|
|
|
printf("nsTextEditorTextListener::HandleText\n");
|
|
|
|
#endif
|
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
|
|
|
|
2000-01-11 23:49:15 +03:00
|
|
|
if (aIID.Equals(NS_GET_IID(nsISupports))) {
|
1999-03-14 07:45:00 +03:00
|
|
|
*aInstancePtr = (void*)(nsISupports*)this;
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2000-01-11 23:49:15 +03:00
|
|
|
if (aIID.Equals(NS_GET_IID(nsIDOMEventListener))) {
|
1999-03-14 07:45:00 +03:00
|
|
|
*aInstancePtr = (void*)(nsIDOMEventListener*)this;
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2000-01-11 23:49:15 +03:00
|
|
|
if (aIID.Equals(NS_GET_IID(nsIDOMDragListener))) {
|
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...
|
|
|
|
|
1999-11-30 01:35:35 +03:00
|
|
|
// ...until we have this implemented, just eat the drag event so it
|
|
|
|
// ...doesn't leak out into the rest of the app/handlers.
|
|
|
|
aDragEvent->PreventBubble();
|
|
|
|
|
1999-08-19 23:48:33 +04:00
|
|
|
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;
|
1999-11-30 03:10:55 +03:00
|
|
|
NS_WITH_SERVICE ( nsIDragService, dragService, "component://netscape/widget/dragservice", &rv );
|
1999-08-25 12:35:06 +04:00
|
|
|
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;
|
2000-02-02 01:26:21 +03:00
|
|
|
dragSession->IsDataFlavorSupported(kUnicodeMime, &flavorSupported);
|
1999-08-25 12:35:06 +04:00
|
|
|
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;
|
1999-11-30 03:10:55 +03:00
|
|
|
NS_WITH_SERVICE ( nsIDragService, dragService, "component://netscape/widget/dragservice", &rv );
|
1999-08-25 12:35:06 +04:00
|
|
|
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;
|
2000-02-02 01:26:21 +03:00
|
|
|
dragSession->IsDataFlavorSupported(kUnicodeMime, &flavorSupported);
|
1999-08-25 12:35:06 +04:00
|
|
|
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;
|
1999-11-30 03:10:55 +03:00
|
|
|
NS_WITH_SERVICE(nsIDragService, dragService, "component://netscape/widget/dragservice", &rv);
|
1999-10-08 18:39:20 +04:00
|
|
|
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;
|
1999-11-30 03:10:55 +03:00
|
|
|
rv = nsComponentManager::CreateInstance("component://netscape/widget/transferable", nsnull,
|
2000-01-11 23:49:15 +03:00
|
|
|
NS_GET_IID(nsITransferable),
|
1999-10-08 18:39:20 +04:00
|
|
|
(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.
|
2000-02-02 01:26:21 +03:00
|
|
|
trans->AddDataFlavor(kUnicodeMime);
|
1999-10-08 18:39:20 +04:00
|
|
|
//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);
|
2000-02-02 01:26:21 +03:00
|
|
|
nsCOMPtr<nsISupportsWString> textDataObj( do_QueryInterface(genericDataObj) );
|
1999-10-08 18:39:20 +04:00
|
|
|
// If the string was not empty then paste it in
|
|
|
|
if ( textDataObj )
|
|
|
|
{
|
2000-02-02 01:26:21 +03:00
|
|
|
PRUnichar* text = nsnull;
|
1999-10-08 18:39:20 +04:00
|
|
|
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;
|
|
|
|
}
|
2000-01-11 23:49:15 +03:00
|
|
|
if (aIID.Equals(NS_GET_IID(nsISupports))) {
|
1999-05-04 02:57:48 +04:00
|
|
|
*aInstancePtr = (void*)(nsISupports*)this;
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2000-01-11 23:49:15 +03:00
|
|
|
if (aIID.Equals(NS_GET_IID(nsIDOMEventListener))) {
|
1999-05-04 02:57:48 +04:00
|
|
|
*aInstancePtr = (void*)(nsIDOMEventListener*)this;
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2000-01-11 23:49:15 +03:00
|
|
|
if (aIID.Equals(NS_GET_IID(nsIDOMCompositionListener))) {
|
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)
|
|
|
|
{
|
1999-12-01 03:35:31 +03:00
|
|
|
#ifdef DEBUG_IME
|
1999-10-28 02:56:36 +04:00
|
|
|
printf("nsTextEditorCompositionListener::HandleEvent\n");
|
|
|
|
#endif
|
1999-05-04 02:57:48 +04:00
|
|
|
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-12-01 03:35:31 +03:00
|
|
|
#ifdef DEBUG_IME
|
1999-10-28 02:56:36 +04:00
|
|
|
printf("nsTextEditorCompositionListener::HandleStartComposition\n");
|
|
|
|
#endif
|
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
|
|
|
}
|
1999-12-07 04:29:00 +03:00
|
|
|
nsresult
|
|
|
|
nsTextEditorCompositionListener::HandleQueryComposition(nsIDOMEvent* aCompositionEvent)
|
|
|
|
{
|
|
|
|
#ifdef DEBUG_IME
|
|
|
|
printf("nsTextEditorCompositionListener::HandleQueryComposition\n");
|
|
|
|
#endif
|
|
|
|
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->QueryComposition(eventReply);
|
|
|
|
}
|
1999-05-04 02:57:48 +04:00
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsTextEditorCompositionListener::HandleEndComposition(nsIDOMEvent* aCompositionEvent)
|
|
|
|
{
|
1999-12-01 03:35:31 +03:00
|
|
|
#ifdef DEBUG_IME
|
1999-10-28 02:56:36 +04:00
|
|
|
printf("nsTextEditorCompositionListener::HandleEndComposition\n");
|
|
|
|
#endif
|
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);
|
|
|
|
|
2000-01-11 23:49:15 +03:00
|
|
|
return it->QueryInterface(NS_GET_IID(nsIDOMEventListener), (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);
|
|
|
|
|
2000-01-11 23:49:15 +03:00
|
|
|
return it->QueryInterface(NS_GET_IID(nsIDOMEventListener), (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
|
|
|
|
2000-01-11 23:49:15 +03:00
|
|
|
return it->QueryInterface(NS_GET_IID(nsIDOMEventListener), (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);
|
|
|
|
|
2000-01-11 23:49:15 +03:00
|
|
|
return it->QueryInterface(NS_GET_IID(nsIDOMEventListener), (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);
|
2000-01-11 23:49:15 +03:00
|
|
|
return it->QueryInterface(NS_GET_IID(nsIDOMEventListener), (void **) aInstancePtrResult);
|
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-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);
|
2000-01-11 23:49:15 +03:00
|
|
|
return it->QueryInterface(NS_GET_IID(nsIDOMEventListener), (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) {
|
1999-11-14 05:51:25 +03:00
|
|
|
viewmgr->UpdateView(view,NS_VMREFRESH_IMMEDIATE);
|
1999-08-07 09:28:57 +04:00
|
|
|
}
|
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) {
|
1999-11-14 05:51:25 +03:00
|
|
|
viewmgr->UpdateView(view,NS_VMREFRESH_IMMEDIATE);
|
1999-08-03 10:07:29 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
// 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;
|
|
|
|
}
|
|
|
|
|