1999-02-12 20:18:58 +03:00
|
|
|
/* -*- Mode: C++; tab-width: 2; 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 "nsIDOMDocument.h"
|
|
|
|
#include "nsEditor.h"
|
1999-05-05 08:05:19 +04:00
|
|
|
#include "nsIEditProperty.h" // to be removed XXX
|
1999-02-12 20:18:58 +03:00
|
|
|
#include "nsIDOMText.h"
|
|
|
|
#include "nsIDOMElement.h"
|
|
|
|
#include "nsIDOMAttr.h"
|
|
|
|
#include "nsIDOMNode.h"
|
1999-04-21 22:53:55 +04:00
|
|
|
#include "nsIDOMNamedNodeMap.h"
|
1999-02-12 20:18:58 +03:00
|
|
|
#include "nsIDOMNodeList.h"
|
|
|
|
#include "nsIDOMRange.h"
|
|
|
|
#include "nsIDocument.h"
|
1999-04-21 22:53:55 +04:00
|
|
|
#include "nsVector.h"
|
1999-02-12 20:18:58 +03:00
|
|
|
#include "nsIServiceManager.h"
|
|
|
|
#include "nsEditFactory.h"
|
|
|
|
#include "nsTextEditFactory.h"
|
1999-03-02 08:30:53 +03:00
|
|
|
#include "nsHTMLEditFactory.h"
|
1999-02-12 20:18:58 +03:00
|
|
|
#include "nsEditorCID.h"
|
|
|
|
#include "nsTransactionManagerCID.h"
|
|
|
|
#include "nsITransactionManager.h"
|
|
|
|
#include "nsIPresShell.h"
|
|
|
|
#include "nsIViewManager.h"
|
|
|
|
#include "nsIDOMSelection.h"
|
|
|
|
#include "nsIEnumerator.h"
|
|
|
|
#include "nsIAtom.h"
|
|
|
|
#include "nsVoidArray.h"
|
1999-05-05 08:05:19 +04:00
|
|
|
#include "nsISupportsArray.h"
|
1999-02-13 07:48:09 +03:00
|
|
|
#include "nsICaret.h"
|
1999-02-12 20:18:58 +03:00
|
|
|
|
1999-04-27 21:14:28 +04:00
|
|
|
#include "nsIEditActionListener.h"
|
|
|
|
|
1999-03-10 22:48:13 +03:00
|
|
|
#include "nsIContent.h"
|
|
|
|
#include "nsIContentIterator.h"
|
|
|
|
#include "nsLayoutCID.h"
|
1999-02-12 20:18:58 +03:00
|
|
|
|
|
|
|
// transactions the editor knows how to build
|
|
|
|
#include "TransactionFactory.h"
|
|
|
|
#include "EditAggregateTxn.h"
|
|
|
|
#include "ChangeAttributeTxn.h"
|
|
|
|
#include "CreateElementTxn.h"
|
1999-02-24 20:24:37 +03:00
|
|
|
#include "InsertElementTxn.h"
|
1999-02-12 20:18:58 +03:00
|
|
|
#include "DeleteElementTxn.h"
|
|
|
|
#include "InsertTextTxn.h"
|
|
|
|
#include "DeleteTextTxn.h"
|
|
|
|
#include "DeleteRangeTxn.h"
|
|
|
|
#include "SplitElementTxn.h"
|
|
|
|
#include "JoinElementTxn.h"
|
1999-05-03 22:48:39 +04:00
|
|
|
#include "nsIStringStream.h"
|
1999-03-14 03:31:35 +03:00
|
|
|
|
|
|
|
#define HACK_FORCE_REDRAW 1
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef HACK_FORCE_REDRAW
|
|
|
|
// INCLUDES FOR EVIL HACK TO FOR REDRAW
|
|
|
|
// BEGIN
|
|
|
|
#include "nsIViewManager.h"
|
|
|
|
#include "nsIView.h"
|
|
|
|
// END
|
As a reminder, we decided to do this based strictly content. Some support for style-based text properties is written, but not used
anywhere any more.
* Cleaned up split and join undo/redo.
* Added TypeInState, a data struct that remembers things about text properties for collapsed selections, so you can type
* Ctrl-B with an insertion point and the next character will be bold.
* Added all the logic to handle inline vs. block elements when setting text properties.
* Added some support for italic and underline as well. Adding these things is pretty easy now. Ctrl-B, Ctrl-I, Ctrl-U for testing bold, italic, underline.
* Added all the logic to make sure we only add style tags where they're needed, so you should never get the same style tag nested within itself, except as needed for block elements.
* Added methods for testing a node to see if a particular style is set. This isn't 100% done yet, but with very little work we could have toolbar buttons that respond to selection changed notification that show the state of bold, italic, underline, etc. in real time. Supports tri-state: whole selection is bold, some of selection is bold, none of selection is bold, ...
* Fully undoable and redoable.
* Added some debug printfs to transactions and editors. all controlled by a gNoisy static in each module. helps me track down undo/redo problems. if the output bugs people enough, I'll shut it off and re-enable it in my local tree.
Noticably missing: make un-bold, make un-italic, etc. This is coming soon.
1999-04-01 21:58:07 +04:00
|
|
|
#endif
|
1999-03-23 18:45:58 +03:00
|
|
|
|
|
|
|
// Drag & Drop, Clipboard
|
|
|
|
#include "nsWidgetsCID.h"
|
|
|
|
#include "nsIClipboard.h"
|
|
|
|
#include "nsITransferable.h"
|
1999-04-17 17:51:42 +04:00
|
|
|
#include "nsIGenericTransferable.h"
|
1999-03-23 18:45:58 +03:00
|
|
|
#include "nsIDataFlavor.h"
|
1999-04-01 18:28:13 +04:00
|
|
|
#include "nsIFormatConverter.h"
|
1999-03-23 18:45:58 +03:00
|
|
|
|
|
|
|
// Drag & Drop, Clipboard Support
|
1999-04-01 18:28:13 +04:00
|
|
|
static NS_DEFINE_IID(kIClipboardIID, NS_ICLIPBOARD_IID);
|
|
|
|
static NS_DEFINE_CID(kCClipboardCID, NS_CLIPBOARD_CID);
|
1999-04-17 17:51:42 +04:00
|
|
|
static NS_DEFINE_CID(kIGenericTransferableIID, NS_IGENERICTRANSFERABLE_IID);
|
|
|
|
static NS_DEFINE_CID(kCGenericTransferableCID, NS_GENERICTRANSFERABLE_CID);
|
1999-04-01 18:28:13 +04:00
|
|
|
static NS_DEFINE_IID(kIDataFlavorIID, NS_IDATAFLAVOR_IID);
|
|
|
|
static NS_DEFINE_IID(kCDataFlavorCID, NS_DATAFLAVOR_CID);
|
|
|
|
static NS_DEFINE_IID(kCXIFFormatConverterCID, NS_XIFFORMATCONVERTER_CID);
|
|
|
|
static NS_DEFINE_IID(kIFormatConverterIID, NS_IFORMATCONVERTER_IID);
|
1999-03-23 18:45:58 +03:00
|
|
|
|
1999-02-21 00:29:27 +03:00
|
|
|
static NS_DEFINE_IID(kIContentIID, NS_ICONTENT_IID);
|
1999-02-12 20:18:58 +03:00
|
|
|
static NS_DEFINE_IID(kIDOMTextIID, NS_IDOMTEXT_IID);
|
|
|
|
static NS_DEFINE_IID(kIDOMElementIID, NS_IDOMELEMENT_IID);
|
|
|
|
static NS_DEFINE_IID(kIDOMNodeIID, NS_IDOMNODE_IID);
|
|
|
|
static NS_DEFINE_IID(kIDOMSelectionIID, NS_IDOMSELECTION_IID);
|
|
|
|
static NS_DEFINE_IID(kIDOMRangeIID, NS_IDOMRANGE_IID);
|
1999-05-05 08:05:19 +04:00
|
|
|
static NS_DEFINE_CID(kCRangeCID, NS_RANGE_CID);
|
1999-02-12 20:18:58 +03:00
|
|
|
static NS_DEFINE_IID(kIDOMDocumentIID, NS_IDOMDOCUMENT_IID);
|
|
|
|
static NS_DEFINE_IID(kIDocumentIID, NS_IDOCUMENT_IID);
|
1999-03-02 10:52:41 +03:00
|
|
|
static NS_DEFINE_IID(kIPresShellIID, NS_IPRESSHELL_IID);
|
1999-02-12 20:18:58 +03:00
|
|
|
static NS_DEFINE_IID(kIFactoryIID, NS_IFACTORY_IID);
|
|
|
|
static NS_DEFINE_IID(kIEditFactoryIID, NS_IEDITORFACTORY_IID);
|
1999-03-09 01:46:33 +03:00
|
|
|
static NS_DEFINE_IID(kITextEditFactoryIID, NS_ITEXTEDITORFACTORY_IID);
|
|
|
|
static NS_DEFINE_IID(kIHTMLEditFactoryIID, NS_IHTMLEDITORFACTORY_IID);
|
1999-02-12 20:18:58 +03:00
|
|
|
static NS_DEFINE_IID(kIEditorIID, NS_IEDITOR_IID);
|
|
|
|
static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);
|
|
|
|
static NS_DEFINE_IID(kEditorCID, NS_EDITOR_CID);
|
|
|
|
static NS_DEFINE_CID(kTextEditorCID, NS_TEXTEDITOR_CID);
|
1999-03-02 08:30:53 +03:00
|
|
|
static NS_DEFINE_CID(kHTMLEditorCID, NS_HTMLEDITOR_CID);
|
1999-03-10 22:48:13 +03:00
|
|
|
static NS_DEFINE_IID(kIContentIteratorIID, NS_ICONTENTITERTOR_IID);
|
|
|
|
static NS_DEFINE_CID(kCContentIteratorCID, NS_CONTENTITERATOR_CID);
|
1999-02-12 20:18:58 +03:00
|
|
|
// transaction manager
|
|
|
|
static NS_DEFINE_IID(kITransactionManagerIID, NS_ITRANSACTIONMANAGER_IID);
|
1999-03-11 00:27:02 +03:00
|
|
|
static NS_DEFINE_CID(kCTransactionManagerCID, NS_TRANSACTIONMANAGER_CID);
|
1999-02-12 20:18:58 +03:00
|
|
|
// transactions
|
|
|
|
static NS_DEFINE_IID(kEditAggregateTxnIID, EDIT_AGGREGATE_TXN_IID);
|
|
|
|
static NS_DEFINE_IID(kInsertTextTxnIID, INSERT_TEXT_TXN_IID);
|
|
|
|
static NS_DEFINE_IID(kDeleteTextTxnIID, DELETE_TEXT_TXN_IID);
|
|
|
|
static NS_DEFINE_IID(kCreateElementTxnIID, CREATE_ELEMENT_TXN_IID);
|
1999-02-24 20:24:37 +03:00
|
|
|
static NS_DEFINE_IID(kInsertElementTxnIID, INSERT_ELEMENT_TXN_IID);
|
1999-02-12 20:18:58 +03:00
|
|
|
static NS_DEFINE_IID(kDeleteElementTxnIID, DELETE_ELEMENT_TXN_IID);
|
|
|
|
static NS_DEFINE_IID(kDeleteRangeTxnIID, DELETE_RANGE_TXN_IID);
|
|
|
|
static NS_DEFINE_IID(kChangeAttributeTxnIID,CHANGE_ATTRIBUTE_TXN_IID);
|
|
|
|
static NS_DEFINE_IID(kSplitElementTxnIID, SPLIT_ELEMENT_TXN_IID);
|
|
|
|
static NS_DEFINE_IID(kJoinElementTxnIID, JOIN_ELEMENT_TXN_IID);
|
|
|
|
|
1999-03-09 12:44:27 +03:00
|
|
|
static NS_DEFINE_CID(kComponentManagerCID, NS_COMPONENTMANAGER_CID);
|
1999-05-04 02:57:48 +04:00
|
|
|
static NS_DEFINE_CID(kCDOMRangeCID, NS_RANGE_CID);
|
1999-03-09 12:44:27 +03:00
|
|
|
|
1999-02-12 20:18:58 +03:00
|
|
|
#ifdef XP_PC
|
|
|
|
#define TRANSACTION_MANAGER_DLL "txmgr.dll"
|
|
|
|
#else
|
|
|
|
#ifdef XP_MAC
|
|
|
|
#define TRANSACTION_MANAGER_DLL "TRANSACTION_MANAGER_DLL"
|
|
|
|
#else // XP_UNIX
|
|
|
|
#define TRANSACTION_MANAGER_DLL "libtxmgr.so"
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
1999-03-10 22:48:13 +03:00
|
|
|
#define NS_ERROR_EDITOR_NO_SELECTION NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_EDITOR,1)
|
1999-03-16 19:38:09 +03:00
|
|
|
#define NS_ERROR_EDITOR_NO_TEXTNODE NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_EDITOR,2)
|
|
|
|
|
1999-05-05 08:05:19 +04:00
|
|
|
const char* nsEditor::kMOZEditorBogusNodeAttr="MOZ_EDITOR_BOGUS_NODE";
|
|
|
|
const char* nsEditor::kMOZEditorBogusNodeValue="TRUE";
|
|
|
|
|
1999-04-13 02:37:20 +04:00
|
|
|
#ifdef NS_DEBUG_EDITOR
|
1999-05-05 08:05:19 +04:00
|
|
|
static PRBool gNoisy = PR_TRUE;
|
As a reminder, we decided to do this based strictly content. Some support for style-based text properties is written, but not used
anywhere any more.
* Cleaned up split and join undo/redo.
* Added TypeInState, a data struct that remembers things about text properties for collapsed selections, so you can type
* Ctrl-B with an insertion point and the next character will be bold.
* Added all the logic to handle inline vs. block elements when setting text properties.
* Added some support for italic and underline as well. Adding these things is pretty easy now. Ctrl-B, Ctrl-I, Ctrl-U for testing bold, italic, underline.
* Added all the logic to make sure we only add style tags where they're needed, so you should never get the same style tag nested within itself, except as needed for block elements.
* Added methods for testing a node to see if a particular style is set. This isn't 100% done yet, but with very little work we could have toolbar buttons that respond to selection changed notification that show the state of bold, italic, underline, etc. in real time. Supports tri-state: whole selection is bold, some of selection is bold, none of selection is bold, ...
* Fully undoable and redoable.
* Added some debug printfs to transactions and editors. all controlled by a gNoisy static in each module. helps me track down undo/redo problems. if the output bugs people enough, I'll shut it off and re-enable it in my local tree.
Noticably missing: make un-bold, make un-italic, etc. This is coming soon.
1999-04-01 21:58:07 +04:00
|
|
|
#else
|
|
|
|
static const PRBool gNoisy = PR_FALSE;
|
|
|
|
#endif
|
|
|
|
|
1999-02-12 20:18:58 +03:00
|
|
|
|
|
|
|
|
|
|
|
/* ----- TEST METHODS DECLARATIONS ----- */
|
|
|
|
// Methods defined here are TEMPORARY
|
1999-03-02 08:30:53 +03:00
|
|
|
//NS_IMETHODIMP GetColIndexForCell(nsIPresShell *aPresShell, nsIDOMNode *aCellNode, PRInt32 &aCellIndex);
|
1999-02-12 20:18:58 +03:00
|
|
|
/* ----- END TEST METHOD DECLARATIONS ----- */
|
|
|
|
|
|
|
|
|
|
|
|
PRInt32 nsEditor::gInstanceCount = 0;
|
|
|
|
|
|
|
|
//monitor for the editor
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
PRMonitor *getEditorMonitor() //if more than one person asks for the monitor at the same time for the FIRST time, we are screwed
|
|
|
|
{
|
|
|
|
static PRMonitor *ns_editlock = nsnull;
|
|
|
|
if (nsnull == ns_editlock)
|
|
|
|
{
|
|
|
|
ns_editlock = (PRMonitor *)1; //how long will the next line take? lets cut down on the chance of reentrancy
|
|
|
|
ns_editlock = PR_NewMonitor();
|
|
|
|
}
|
|
|
|
else if ((PRMonitor *)1 == ns_editlock)
|
|
|
|
return getEditorMonitor();
|
|
|
|
return ns_editlock;
|
|
|
|
}
|
|
|
|
|
1999-03-09 12:44:27 +03:00
|
|
|
nsIComponentManager* gCompMgr = NULL;
|
1999-02-12 20:18:58 +03:00
|
|
|
|
|
|
|
/*
|
1999-03-10 01:52:24 +03:00
|
|
|
we must be good providers of factories etc. this is where to put ALL editor exports
|
1999-02-12 20:18:58 +03:00
|
|
|
*/
|
|
|
|
//BEGIN EXPORTS
|
1999-03-09 12:44:27 +03:00
|
|
|
extern "C" NS_EXPORT nsresult NSGetFactory(nsISupports * aServMgr,
|
1999-02-26 13:17:14 +03:00
|
|
|
const nsCID & aClass,
|
|
|
|
const char *aClassName,
|
|
|
|
const char *aProgID,
|
1999-02-12 20:18:58 +03:00
|
|
|
nsIFactory ** aFactory)
|
|
|
|
{
|
|
|
|
if (nsnull == aFactory) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
|
|
|
|
|
|
|
*aFactory = nsnull;
|
|
|
|
|
1999-03-10 01:52:24 +03:00
|
|
|
nsresult rv;
|
|
|
|
nsCOMPtr<nsIServiceManager> servMgr(do_QueryInterface(aServMgr, &rv));
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
|
|
|
|
rv = servMgr->GetService(kComponentManagerCID, nsIComponentManager::GetIID(),
|
|
|
|
(nsISupports**)&gCompMgr);
|
1999-03-09 12:44:27 +03:00
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
|
1999-03-10 02:06:16 +03:00
|
|
|
rv = NS_NOINTERFACE;
|
1999-02-12 20:18:58 +03:00
|
|
|
if (aClass.Equals(kEditorCID)) {
|
1999-03-10 02:06:16 +03:00
|
|
|
rv = GetEditFactory(aFactory, aClass);
|
|
|
|
if (NS_FAILED(rv)) goto done;
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
|
|
|
else if (aClass.Equals(kTextEditorCID)) {
|
1999-03-10 02:06:16 +03:00
|
|
|
rv = GetTextEditFactory(aFactory, aClass);
|
|
|
|
if (NS_FAILED(rv)) goto done;
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
1999-03-02 08:30:53 +03:00
|
|
|
else if (aClass.Equals(kHTMLEditorCID)) {
|
1999-03-10 02:06:16 +03:00
|
|
|
rv = GetHTMLEditFactory(aFactory, aClass);
|
|
|
|
if (NS_FAILED(rv)) goto done;
|
1999-03-02 08:30:53 +03:00
|
|
|
}
|
1999-03-10 02:06:16 +03:00
|
|
|
|
|
|
|
done:
|
|
|
|
(void)servMgr->ReleaseService(kComponentManagerCID, gCompMgr);
|
|
|
|
|
|
|
|
return rv;
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern "C" NS_EXPORT PRBool
|
1999-03-09 12:44:27 +03:00
|
|
|
NSCanUnload(nsISupports* aServMgr)
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
|
|
|
return nsEditor::gInstanceCount; //I have no idea. I am copying code here
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern "C" NS_EXPORT nsresult
|
1999-03-09 12:44:27 +03:00
|
|
|
NSRegisterSelf(nsISupports* aServMgr, const char *path)
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
1999-03-09 12:44:27 +03:00
|
|
|
nsresult rv;
|
1999-03-09 14:49:41 +03:00
|
|
|
nsCOMPtr<nsIServiceManager> servMgr(do_QueryInterface(aServMgr, &rv));
|
1999-03-09 12:44:27 +03:00
|
|
|
if (NS_FAILED(rv)) return rv;
|
1999-03-09 14:49:41 +03:00
|
|
|
|
|
|
|
nsIComponentManager* compMgr;
|
|
|
|
rv = servMgr->GetService(kComponentManagerCID,
|
|
|
|
nsIComponentManager::GetIID(),
|
|
|
|
(nsISupports**)&compMgr);
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
|
1999-03-09 12:44:27 +03:00
|
|
|
rv = compMgr->RegisterComponent(kEditorCID, NULL, NULL, path,
|
|
|
|
PR_TRUE, PR_TRUE);
|
1999-03-09 14:49:41 +03:00
|
|
|
if (NS_FAILED(rv)) goto done;
|
1999-03-09 12:44:27 +03:00
|
|
|
rv = compMgr->RegisterComponent(kTextEditorCID, NULL, NULL, path,
|
|
|
|
PR_TRUE, PR_TRUE);
|
1999-03-09 14:49:41 +03:00
|
|
|
if (NS_FAILED(rv)) goto done;
|
1999-03-09 12:44:27 +03:00
|
|
|
rv = compMgr->RegisterComponent(kHTMLEditorCID, NULL, NULL, path,
|
|
|
|
PR_TRUE, PR_TRUE);
|
1999-03-09 14:49:41 +03:00
|
|
|
|
|
|
|
done:
|
|
|
|
(void)servMgr->ReleaseService(kComponentManagerCID, compMgr);
|
|
|
|
return rv;
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" NS_EXPORT nsresult
|
1999-03-09 12:44:27 +03:00
|
|
|
NSUnregisterSelf(nsISupports* aServMgr, const char *path)
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
1999-03-09 12:44:27 +03:00
|
|
|
nsresult rv;
|
1999-03-09 14:49:41 +03:00
|
|
|
|
|
|
|
nsCOMPtr<nsIServiceManager> servMgr(do_QueryInterface(aServMgr, &rv));
|
1999-03-09 12:44:27 +03:00
|
|
|
if (NS_FAILED(rv)) return rv;
|
1999-03-09 14:49:41 +03:00
|
|
|
|
|
|
|
nsIComponentManager* compMgr;
|
|
|
|
rv = servMgr->GetService(kComponentManagerCID,
|
|
|
|
nsIComponentManager::GetIID(),
|
|
|
|
(nsISupports**)&compMgr);
|
1999-03-09 12:44:27 +03:00
|
|
|
if (NS_FAILED(rv)) return rv;
|
1999-03-09 14:49:41 +03:00
|
|
|
|
|
|
|
rv = compMgr->UnregisterFactory(kIEditFactoryIID, path);
|
|
|
|
if (NS_FAILED(rv)) goto done;
|
1999-03-09 12:44:27 +03:00
|
|
|
rv = compMgr->UnregisterFactory(kITextEditFactoryIID, path);
|
1999-03-09 14:49:41 +03:00
|
|
|
if (NS_FAILED(rv)) goto done;
|
1999-03-09 12:44:27 +03:00
|
|
|
rv = compMgr->UnregisterFactory(kIHTMLEditFactoryIID, path);
|
1999-03-09 14:49:41 +03:00
|
|
|
|
|
|
|
done:
|
|
|
|
(void)servMgr->ReleaseService(kComponentManagerCID, compMgr);
|
|
|
|
return rv;
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
//END EXPORTS
|
|
|
|
|
|
|
|
|
|
|
|
//class implementations are in order they are declared in nsEditor.h
|
|
|
|
|
|
|
|
nsEditor::nsEditor()
|
|
|
|
{
|
|
|
|
//initialize member variables here
|
|
|
|
NS_INIT_REFCNT();
|
1999-05-04 02:57:48 +04:00
|
|
|
mIMEFirstTransaction=PR_FALSE;
|
1999-02-12 20:18:58 +03:00
|
|
|
PR_EnterMonitor(getEditorMonitor());
|
|
|
|
gInstanceCount++;
|
1999-04-27 21:14:28 +04:00
|
|
|
mActionListeners = 0;
|
1999-02-12 20:18:58 +03:00
|
|
|
PR_ExitMonitor(getEditorMonitor());
|
1999-05-04 02:57:48 +04:00
|
|
|
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
nsEditor::~nsEditor()
|
|
|
|
{
|
1999-04-27 21:14:28 +04:00
|
|
|
if (mActionListeners)
|
|
|
|
{
|
|
|
|
PRInt32 i;
|
|
|
|
nsIEditActionListener *listener;
|
|
|
|
|
|
|
|
for (i = 0; i < mActionListeners->Count(); i++)
|
|
|
|
{
|
|
|
|
listener = (nsIEditActionListener *)mActionListeners->ElementAt(i);
|
|
|
|
NS_IF_RELEASE(listener);
|
|
|
|
}
|
|
|
|
|
|
|
|
delete mActionListeners;
|
|
|
|
mActionListeners = 0;
|
|
|
|
}
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
1999-05-05 08:05:19 +04:00
|
|
|
// BEGIN nsEditor core implementation
|
1999-02-12 20:18:58 +03:00
|
|
|
|
|
|
|
|
|
|
|
NS_IMPL_ADDREF(nsEditor)
|
|
|
|
|
|
|
|
NS_IMPL_RELEASE(nsEditor)
|
|
|
|
|
|
|
|
|
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP
|
1999-02-12 20:18:58 +03:00
|
|
|
nsEditor::QueryInterface(REFNSIID aIID, void** aInstancePtr)
|
|
|
|
{
|
|
|
|
if (nsnull == aInstancePtr) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
|
|
|
if (aIID.Equals(kISupportsIID)) {
|
1999-02-17 22:42:29 +03:00
|
|
|
nsIEditor *tmp = this;
|
|
|
|
nsISupports *tmp2 = tmp;
|
|
|
|
*aInstancePtr = (void*)tmp2;
|
1999-02-12 20:18:58 +03:00
|
|
|
NS_ADDREF_THIS();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
if (aIID.Equals(kIEditorIID)) {
|
|
|
|
*aInstancePtr = (void*)(nsIEditor*)this;
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
return NS_NOINTERFACE;
|
|
|
|
}
|
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP
|
1999-02-12 20:18:58 +03:00
|
|
|
nsEditor::GetDocument(nsIDOMDocument **aDoc)
|
|
|
|
{
|
1999-03-02 10:52:41 +03:00
|
|
|
if (!aDoc)
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
1999-02-12 20:18:58 +03:00
|
|
|
*aDoc = nsnull; // init out param
|
|
|
|
NS_PRECONDITION(mDoc, "bad state, null mDoc");
|
|
|
|
if (!mDoc)
|
1999-03-02 10:52:41 +03:00
|
|
|
return NS_ERROR_NOT_INITIALIZED;
|
1999-02-12 20:18:58 +03:00
|
|
|
return mDoc->QueryInterface(kIDOMDocumentIID, (void **)aDoc);
|
|
|
|
}
|
|
|
|
|
1999-03-02 10:52:41 +03:00
|
|
|
nsresult
|
|
|
|
nsEditor::GetPresShell(nsIPresShell **aPS)
|
|
|
|
{
|
|
|
|
if (!aPS)
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
*aPS = nsnull; // init out param
|
|
|
|
NS_PRECONDITION(mPresShell, "bad state, null mPresShell");
|
|
|
|
if (!mPresShell)
|
|
|
|
return NS_ERROR_NOT_INITIALIZED;
|
|
|
|
return mPresShell->QueryInterface(kIPresShellIID, (void **)aPS);
|
|
|
|
}
|
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
1999-02-17 22:42:29 +03:00
|
|
|
nsEditor::GetSelection(nsIDOMSelection **aSelection)
|
|
|
|
{
|
|
|
|
if (!aSelection)
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
*aSelection = nsnull;
|
|
|
|
nsresult result = mPresShell->GetSelection(aSelection); // does an addref
|
|
|
|
return result;
|
|
|
|
}
|
1999-02-12 20:18:58 +03:00
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP
|
1999-02-12 20:18:58 +03:00
|
|
|
nsEditor::Init(nsIDOMDocument *aDoc, nsIPresShell* aPresShell)
|
|
|
|
{
|
|
|
|
NS_PRECONDITION(nsnull!=aDoc && nsnull!=aPresShell, "bad arg");
|
|
|
|
if ((nsnull==aDoc) || (nsnull==aPresShell))
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
|
1999-04-30 00:21:04 +04:00
|
|
|
mDoc = aDoc;
|
1999-05-04 02:26:07 +04:00
|
|
|
mPresShell = aPresShell; // we don't addref the pres shell
|
1999-02-12 20:45:58 +03:00
|
|
|
mPresShell->GetViewManager(&mViewManager);
|
1999-04-30 00:21:04 +04:00
|
|
|
if (mViewManager){
|
|
|
|
mViewManager->Release(); //we want a weak link
|
|
|
|
}
|
1999-02-12 20:18:58 +03:00
|
|
|
mUpdateCount=0;
|
1999-02-15 21:25:30 +03:00
|
|
|
InsertTextTxn::ClassInit();
|
1999-02-12 20:18:58 +03:00
|
|
|
|
1999-02-13 07:48:09 +03:00
|
|
|
/* Show the caret */
|
|
|
|
nsCOMPtr<nsICaret> caret;
|
|
|
|
if (NS_SUCCEEDED(mPresShell->GetCaret(getter_AddRefs(caret))))
|
|
|
|
{
|
|
|
|
caret->SetCaretVisible(PR_TRUE);
|
|
|
|
caret->SetCaretReadOnly(PR_FALSE);
|
|
|
|
}
|
|
|
|
|
1999-04-02 04:01:31 +04:00
|
|
|
mPresShell->SetCaretEnabled(PR_TRUE);
|
|
|
|
|
1999-02-12 20:18:58 +03:00
|
|
|
NS_POSTCONDITION(mDoc && mPresShell, "bad state");
|
1999-03-02 08:30:53 +03:00
|
|
|
|
1999-02-12 20:18:58 +03:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP
|
1999-02-12 20:18:58 +03:00
|
|
|
nsEditor::EnableUndo(PRBool aEnable)
|
|
|
|
{
|
|
|
|
nsITransactionManager *txnMgr = 0;
|
|
|
|
nsresult result=NS_OK;
|
|
|
|
|
|
|
|
if (PR_TRUE==aEnable)
|
|
|
|
{
|
|
|
|
if (!mTxnMgr)
|
|
|
|
{
|
1999-03-11 00:27:02 +03:00
|
|
|
result = gCompMgr->CreateInstance(kCTransactionManagerCID,
|
1999-03-09 12:44:27 +03:00
|
|
|
nsnull,
|
|
|
|
kITransactionManagerIID, (void **)&txnMgr);
|
1999-02-12 20:18:58 +03:00
|
|
|
if (NS_FAILED(result) || !txnMgr) {
|
|
|
|
printf("ERROR: Failed to get TransactionManager instance.\n");
|
|
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
|
|
}
|
1999-02-19 02:18:56 +03:00
|
|
|
mTxnMgr = do_QueryInterface(txnMgr); // CreateInstance refCounted the instance for us, remember it in an nsCOMPtr
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{ // disable the transaction manager if it is enabled
|
|
|
|
if (mTxnMgr)
|
|
|
|
{
|
1999-02-19 02:18:56 +03:00
|
|
|
mTxnMgr = do_QueryInterface(nsnull);
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP nsEditor::CanUndo(PRBool &aIsEnabled, PRBool &aCanUndo)
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
1999-02-17 09:18:11 +03:00
|
|
|
aIsEnabled = ((PRBool)((nsITransactionManager *)0!=mTxnMgr.get()));
|
1999-02-12 20:18:58 +03:00
|
|
|
if (aIsEnabled)
|
|
|
|
{
|
|
|
|
PRInt32 numTxns=0;
|
|
|
|
mTxnMgr->GetNumberOfUndoItems(&numTxns);
|
|
|
|
aCanUndo = ((PRBool)(0==numTxns));
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
aCanUndo = PR_FALSE;
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP nsEditor::CanRedo(PRBool &aIsEnabled, PRBool &aCanRedo)
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
1999-02-17 09:18:11 +03:00
|
|
|
aIsEnabled = ((PRBool)((nsITransactionManager *)0!=mTxnMgr.get()));
|
1999-02-12 20:18:58 +03:00
|
|
|
if (aIsEnabled)
|
|
|
|
{
|
|
|
|
PRInt32 numTxns=0;
|
|
|
|
mTxnMgr->GetNumberOfRedoItems(&numTxns);
|
|
|
|
aCanRedo = ((PRBool)(0==numTxns));
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
aCanRedo = PR_FALSE;
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP
|
1999-02-12 20:18:58 +03:00
|
|
|
nsEditor::SetProperties(nsVoidArray *aPropList)
|
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP
|
1999-02-12 20:18:58 +03:00
|
|
|
nsEditor::GetProperties(nsVoidArray *aPropList)
|
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP
|
1999-02-12 20:18:58 +03:00
|
|
|
nsEditor::SetAttribute(nsIDOMElement *aElement, const nsString& aAttribute, const nsString& aValue)
|
|
|
|
{
|
|
|
|
ChangeAttributeTxn *txn;
|
|
|
|
nsresult result = CreateTxnForSetAttribute(aElement, aAttribute, aValue, &txn);
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
result = Do(txn);
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP
|
1999-02-12 20:18:58 +03:00
|
|
|
nsEditor::CreateTxnForSetAttribute(nsIDOMElement *aElement,
|
|
|
|
const nsString& aAttribute,
|
|
|
|
const nsString& aValue,
|
|
|
|
ChangeAttributeTxn ** aTxn)
|
|
|
|
{
|
|
|
|
nsresult result = NS_ERROR_NULL_POINTER;
|
|
|
|
if (nsnull != aElement)
|
|
|
|
{
|
|
|
|
result = TransactionFactory::GetNewTransaction(kChangeAttributeTxnIID, (EditTxn **)aTxn);
|
1999-02-15 21:25:30 +03:00
|
|
|
if (NS_SUCCEEDED(result)) {
|
1999-02-12 20:18:58 +03:00
|
|
|
result = (*aTxn)->Init(this, aElement, aAttribute, aValue, PR_FALSE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP
|
1999-02-12 20:18:58 +03:00
|
|
|
nsEditor::GetAttributeValue(nsIDOMElement *aElement,
|
|
|
|
const nsString& aAttribute,
|
|
|
|
nsString& aResultValue,
|
|
|
|
PRBool& aResultIsSet)
|
|
|
|
{
|
|
|
|
aResultIsSet=PR_FALSE;
|
|
|
|
nsresult result=NS_OK;
|
|
|
|
if (nsnull!=aElement)
|
|
|
|
{
|
1999-02-17 22:42:29 +03:00
|
|
|
nsCOMPtr<nsIDOMAttr> attNode;
|
|
|
|
result = aElement->GetAttributeNode(aAttribute, getter_AddRefs(attNode));
|
|
|
|
if ((NS_SUCCEEDED(result)) && attNode)
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
|
|
|
attNode->GetSpecified(&aResultIsSet);
|
|
|
|
attNode->GetValue(aResultValue);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP
|
1999-02-12 20:18:58 +03:00
|
|
|
nsEditor::RemoveAttribute(nsIDOMElement *aElement, const nsString& aAttribute)
|
|
|
|
{
|
|
|
|
ChangeAttributeTxn *txn;
|
|
|
|
nsresult result = CreateTxnForRemoveAttribute(aElement, aAttribute, &txn);
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
result = Do(txn);
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP
|
1999-02-12 20:18:58 +03:00
|
|
|
nsEditor::CreateTxnForRemoveAttribute(nsIDOMElement *aElement,
|
|
|
|
const nsString& aAttribute,
|
|
|
|
ChangeAttributeTxn ** aTxn)
|
|
|
|
{
|
|
|
|
nsresult result = NS_ERROR_NULL_POINTER;
|
|
|
|
if (nsnull != aElement)
|
|
|
|
{
|
|
|
|
result = TransactionFactory::GetNewTransaction(kChangeAttributeTxnIID, (EditTxn **)aTxn);
|
1999-02-15 21:25:30 +03:00
|
|
|
if (NS_SUCCEEDED(result))
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
|
|
|
nsAutoString value;
|
|
|
|
result = (*aTxn)->Init(this, aElement, aAttribute, value, PR_TRUE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-04-21 22:53:55 +04:00
|
|
|
// Objects must be DOM elements
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsEditor::CopyAttributes(nsIDOMNode *aDestNode, nsIDOMNode *aSourceNode)
|
|
|
|
{
|
|
|
|
nsresult result=NS_OK;
|
|
|
|
|
|
|
|
if (!aDestNode || !aSourceNode)
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMElement> destElement = do_QueryInterface(aDestNode);
|
|
|
|
nsCOMPtr<nsIDOMElement> sourceElement = do_QueryInterface(aSourceNode);
|
|
|
|
if (!destElement || !sourceElement)
|
|
|
|
return NS_ERROR_NO_INTERFACE;
|
|
|
|
|
|
|
|
nsAutoString name;
|
|
|
|
nsAutoString value;
|
|
|
|
nsCOMPtr<nsIDOMNamedNodeMap> sourceAttributes;
|
|
|
|
sourceElement->GetAttributes(getter_AddRefs(sourceAttributes));
|
|
|
|
nsCOMPtr<nsIDOMNamedNodeMap> destAttributes;
|
|
|
|
destElement->GetAttributes(getter_AddRefs(destAttributes));
|
|
|
|
if (!sourceAttributes || !destAttributes)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
PRUint32 sourceCount;
|
|
|
|
sourceAttributes->GetLength(&sourceCount);
|
|
|
|
PRUint32 i, destCount;
|
|
|
|
destAttributes->GetLength(&destCount);
|
|
|
|
nsIDOMNode* attrNode;
|
|
|
|
|
|
|
|
// Clear existing attributes
|
|
|
|
for (i = 0; i < destCount; i++)
|
|
|
|
{
|
|
|
|
if( NS_SUCCEEDED(destAttributes->Item(i, &attrNode)) && attrNode)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMAttr> destAttribute = do_QueryInterface(attrNode);
|
|
|
|
if (destAttribute)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMAttr> resultAttribute;
|
|
|
|
destElement->RemoveAttributeNode(destAttribute, getter_AddRefs(resultAttribute));
|
|
|
|
// Is the resultAttribute deleted automagically?
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Set just the attributes that the source element has
|
|
|
|
for (i = 0; i < sourceCount; i++)
|
|
|
|
{
|
|
|
|
if( NS_SUCCEEDED(sourceAttributes->Item(i, &attrNode)) && attrNode)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMAttr> sourceAttribute = do_QueryInterface(attrNode);
|
|
|
|
if (sourceAttribute)
|
|
|
|
{
|
|
|
|
nsString sourceAttrName;
|
|
|
|
if (NS_SUCCEEDED(sourceAttribute->GetName(sourceAttrName)))
|
|
|
|
{
|
|
|
|
nsString sourceAttrValue;
|
|
|
|
if (NS_SUCCEEDED(sourceAttribute->GetValue(sourceAttrValue)) &&
|
|
|
|
sourceAttrValue != "")
|
|
|
|
{
|
|
|
|
destElement->SetAttribute(sourceAttrName, sourceAttrValue);
|
|
|
|
} else {
|
|
|
|
// Do we ever get here?
|
|
|
|
destElement->RemoveAttribute(sourceAttrName);
|
|
|
|
#if DEBUG_cmanske
|
|
|
|
printf("Attribute in NamedNodeMap has empty value in nsEditor::CopyAttributes()\n");
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP
|
1999-03-10 22:48:13 +03:00
|
|
|
nsEditor::InsertBreak()
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//END nsIEditorInterfaces
|
|
|
|
|
|
|
|
|
|
|
|
//BEGIN nsEditor Private methods
|
|
|
|
|
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP
|
1999-02-12 20:18:58 +03:00
|
|
|
nsEditor::Do(nsITransaction *aTxn)
|
|
|
|
{
|
As a reminder, we decided to do this based strictly content. Some support for style-based text properties is written, but not used
anywhere any more.
* Cleaned up split and join undo/redo.
* Added TypeInState, a data struct that remembers things about text properties for collapsed selections, so you can type
* Ctrl-B with an insertion point and the next character will be bold.
* Added all the logic to handle inline vs. block elements when setting text properties.
* Added some support for italic and underline as well. Adding these things is pretty easy now. Ctrl-B, Ctrl-I, Ctrl-U for testing bold, italic, underline.
* Added all the logic to make sure we only add style tags where they're needed, so you should never get the same style tag nested within itself, except as needed for block elements.
* Added methods for testing a node to see if a particular style is set. This isn't 100% done yet, but with very little work we could have toolbar buttons that respond to selection changed notification that show the state of bold, italic, underline, etc. in real time. Supports tri-state: whole selection is bold, some of selection is bold, none of selection is bold, ...
* Fully undoable and redoable.
* Added some debug printfs to transactions and editors. all controlled by a gNoisy static in each module. helps me track down undo/redo problems. if the output bugs people enough, I'll shut it off and re-enable it in my local tree.
Noticably missing: make un-bold, make un-italic, etc. This is coming soon.
1999-04-01 21:58:07 +04:00
|
|
|
if (gNoisy) { printf("Editor::Do ----------\n"); }
|
1999-02-12 20:18:58 +03:00
|
|
|
nsresult result = NS_OK;
|
1999-03-03 04:51:59 +03:00
|
|
|
nsCOMPtr<nsIDOMSelection>selection;
|
|
|
|
nsresult selectionResult = GetSelection(getter_AddRefs(selection));
|
|
|
|
if (NS_SUCCEEDED(selectionResult) && selection) {
|
|
|
|
selection->StartBatchChanges();
|
|
|
|
if (aTxn)
|
|
|
|
{
|
|
|
|
if (mTxnMgr) {
|
|
|
|
result = mTxnMgr->Do(aTxn);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
result = aTxn->Do();
|
|
|
|
}
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
1999-03-03 04:51:59 +03:00
|
|
|
selection->EndBatchChanges();
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP
|
1999-02-12 20:18:58 +03:00
|
|
|
nsEditor::Undo(PRUint32 aCount)
|
|
|
|
{
|
As a reminder, we decided to do this based strictly content. Some support for style-based text properties is written, but not used
anywhere any more.
* Cleaned up split and join undo/redo.
* Added TypeInState, a data struct that remembers things about text properties for collapsed selections, so you can type
* Ctrl-B with an insertion point and the next character will be bold.
* Added all the logic to handle inline vs. block elements when setting text properties.
* Added some support for italic and underline as well. Adding these things is pretty easy now. Ctrl-B, Ctrl-I, Ctrl-U for testing bold, italic, underline.
* Added all the logic to make sure we only add style tags where they're needed, so you should never get the same style tag nested within itself, except as needed for block elements.
* Added methods for testing a node to see if a particular style is set. This isn't 100% done yet, but with very little work we could have toolbar buttons that respond to selection changed notification that show the state of bold, italic, underline, etc. in real time. Supports tri-state: whole selection is bold, some of selection is bold, none of selection is bold, ...
* Fully undoable and redoable.
* Added some debug printfs to transactions and editors. all controlled by a gNoisy static in each module. helps me track down undo/redo problems. if the output bugs people enough, I'll shut it off and re-enable it in my local tree.
Noticably missing: make un-bold, make un-italic, etc. This is coming soon.
1999-04-01 21:58:07 +04:00
|
|
|
if (gNoisy) { printf("Editor::Undo ----------\n"); }
|
1999-02-12 20:18:58 +03:00
|
|
|
nsresult result = NS_OK;
|
1999-03-03 04:51:59 +03:00
|
|
|
nsCOMPtr<nsIDOMSelection>selection;
|
|
|
|
nsresult selectionResult = GetSelection(getter_AddRefs(selection));
|
|
|
|
if (NS_SUCCEEDED(selectionResult) && selection) {
|
|
|
|
selection->StartBatchChanges();
|
|
|
|
if ((nsITransactionManager *)nsnull!=mTxnMgr.get())
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
1999-03-03 04:51:59 +03:00
|
|
|
PRUint32 i=0;
|
|
|
|
for ( ; i<aCount; i++)
|
|
|
|
{
|
|
|
|
result = mTxnMgr->Undo();
|
|
|
|
if (NS_FAILED(result))
|
|
|
|
break;
|
|
|
|
}
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
1999-03-03 04:51:59 +03:00
|
|
|
selection->EndBatchChanges();
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP
|
1999-02-12 20:18:58 +03:00
|
|
|
nsEditor::Redo(PRUint32 aCount)
|
|
|
|
{
|
As a reminder, we decided to do this based strictly content. Some support for style-based text properties is written, but not used
anywhere any more.
* Cleaned up split and join undo/redo.
* Added TypeInState, a data struct that remembers things about text properties for collapsed selections, so you can type
* Ctrl-B with an insertion point and the next character will be bold.
* Added all the logic to handle inline vs. block elements when setting text properties.
* Added some support for italic and underline as well. Adding these things is pretty easy now. Ctrl-B, Ctrl-I, Ctrl-U for testing bold, italic, underline.
* Added all the logic to make sure we only add style tags where they're needed, so you should never get the same style tag nested within itself, except as needed for block elements.
* Added methods for testing a node to see if a particular style is set. This isn't 100% done yet, but with very little work we could have toolbar buttons that respond to selection changed notification that show the state of bold, italic, underline, etc. in real time. Supports tri-state: whole selection is bold, some of selection is bold, none of selection is bold, ...
* Fully undoable and redoable.
* Added some debug printfs to transactions and editors. all controlled by a gNoisy static in each module. helps me track down undo/redo problems. if the output bugs people enough, I'll shut it off and re-enable it in my local tree.
Noticably missing: make un-bold, make un-italic, etc. This is coming soon.
1999-04-01 21:58:07 +04:00
|
|
|
if (gNoisy) { printf("Editor::Redo ----------\n"); }
|
1999-02-12 20:18:58 +03:00
|
|
|
nsresult result = NS_OK;
|
1999-03-03 04:51:59 +03:00
|
|
|
nsCOMPtr<nsIDOMSelection>selection;
|
|
|
|
nsresult selectionResult = GetSelection(getter_AddRefs(selection));
|
|
|
|
if (NS_SUCCEEDED(selectionResult) && selection) {
|
|
|
|
selection->StartBatchChanges();
|
|
|
|
if ((nsITransactionManager *)nsnull!=mTxnMgr.get())
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
1999-03-03 04:51:59 +03:00
|
|
|
PRUint32 i=0;
|
|
|
|
for ( ; i<aCount; i++)
|
|
|
|
{
|
|
|
|
result = mTxnMgr->Redo();
|
|
|
|
if (NS_FAILED(result))
|
|
|
|
break;
|
|
|
|
}
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
1999-03-03 04:51:59 +03:00
|
|
|
selection->EndBatchChanges();
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP
|
1999-02-12 20:18:58 +03:00
|
|
|
nsEditor::BeginTransaction()
|
|
|
|
{
|
|
|
|
NS_PRECONDITION(mUpdateCount>=0, "bad state");
|
|
|
|
if (nsnull!=mViewManager)
|
|
|
|
{
|
|
|
|
if (0==mUpdateCount)
|
|
|
|
mViewManager->DisableRefresh();
|
|
|
|
mUpdateCount++;
|
|
|
|
}
|
1999-02-17 09:18:11 +03:00
|
|
|
if ((nsITransactionManager *)nsnull!=mTxnMgr.get())
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
|
|
|
mTxnMgr->BeginBatch();
|
|
|
|
}
|
1999-04-08 05:28:33 +04:00
|
|
|
nsCOMPtr<nsIDOMSelection>selection;
|
|
|
|
nsresult selectionResult = GetSelection(getter_AddRefs(selection));
|
|
|
|
if (NS_SUCCEEDED(selectionResult) && selection) {
|
|
|
|
selection->StartBatchChanges();
|
|
|
|
}
|
1999-02-12 20:18:58 +03:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP
|
1999-02-12 20:18:58 +03:00
|
|
|
nsEditor::EndTransaction()
|
|
|
|
{
|
|
|
|
NS_PRECONDITION(mUpdateCount>0, "bad state");
|
|
|
|
if (nsnull!=mViewManager)
|
|
|
|
{
|
|
|
|
mUpdateCount--;
|
|
|
|
if (0==mUpdateCount)
|
|
|
|
mViewManager->EnableRefresh();
|
|
|
|
}
|
1999-02-17 09:18:11 +03:00
|
|
|
if ((nsITransactionManager *)nsnull!=mTxnMgr.get())
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
|
|
|
mTxnMgr->EndBatch();
|
|
|
|
}
|
1999-04-08 05:28:33 +04:00
|
|
|
nsCOMPtr<nsIDOMSelection>selection;
|
|
|
|
nsresult selectionResult = GetSelection(getter_AddRefs(selection));
|
|
|
|
if (NS_SUCCEEDED(selectionResult) && selection) {
|
|
|
|
selection->EndBatchChanges();
|
|
|
|
}
|
1999-02-12 20:18:58 +03:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP nsEditor::ScrollIntoView(PRBool aScrollToBegin)
|
1999-02-19 02:01:06 +03:00
|
|
|
{
|
1999-03-10 22:48:13 +03:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
// XXX: the rule system should tell us which node to select all on (ie, the root, or the body)
|
|
|
|
NS_IMETHODIMP nsEditor::SelectAll()
|
|
|
|
{
|
|
|
|
if (!mDoc || !mPresShell) { return NS_ERROR_NOT_INITIALIZED; }
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMSelection> selection;
|
|
|
|
nsresult result = mPresShell->GetSelection(getter_AddRefs(selection));
|
|
|
|
if (NS_SUCCEEDED(result) && selection)
|
1999-02-19 02:01:06 +03:00
|
|
|
{
|
1999-03-10 22:48:13 +03:00
|
|
|
nsCOMPtr<nsIDOMNodeList>nodeList;
|
1999-03-12 05:28:24 +03:00
|
|
|
nsAutoString bodyTag = "body";
|
1999-03-10 22:48:13 +03:00
|
|
|
nsresult result = mDoc->GetElementsByTagName(bodyTag, getter_AddRefs(nodeList));
|
|
|
|
if ((NS_SUCCEEDED(result)) && nodeList)
|
1999-02-19 02:01:06 +03:00
|
|
|
{
|
1999-03-10 22:48:13 +03:00
|
|
|
PRUint32 count;
|
|
|
|
nodeList->GetLength(&count);
|
|
|
|
NS_ASSERTION(1==count, "there is not exactly 1 body in the document!");
|
|
|
|
nsCOMPtr<nsIDOMNode>bodyNode;
|
|
|
|
result = nodeList->Item(0, getter_AddRefs(bodyNode));
|
|
|
|
if ((NS_SUCCEEDED(result)) && bodyNode)
|
|
|
|
{
|
|
|
|
selection->Collapse(bodyNode, 0);
|
|
|
|
PRInt32 numBodyChildren=0;
|
|
|
|
nsCOMPtr<nsIDOMNode>lastChild;
|
|
|
|
result = bodyNode->GetLastChild(getter_AddRefs(lastChild));
|
|
|
|
if ((NS_SUCCEEDED(result)) && lastChild)
|
|
|
|
{
|
|
|
|
GetChildOffset(lastChild, bodyNode, numBodyChildren);
|
|
|
|
selection->Extend(bodyNode, numBodyChildren+1);
|
1999-02-21 00:29:27 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
1999-02-19 02:01:06 +03:00
|
|
|
return result;
|
1999-03-10 22:48:13 +03:00
|
|
|
}
|
|
|
|
|
1999-03-11 00:29:41 +03:00
|
|
|
NS_IMETHODIMP nsEditor::Cut()
|
|
|
|
{
|
1999-03-11 01:50:51 +03:00
|
|
|
//printf("nsEditor::Cut\n");
|
1999-03-11 01:46:15 +03:00
|
|
|
nsresult res = Copy();
|
|
|
|
if (NS_SUCCEEDED(res))
|
|
|
|
res = DeleteSelection(eLTR);
|
|
|
|
return res;
|
1999-03-11 00:29:41 +03:00
|
|
|
}
|
|
|
|
|
1999-03-11 03:08:10 +03:00
|
|
|
|
1999-03-11 00:29:41 +03:00
|
|
|
NS_IMETHODIMP nsEditor::Copy()
|
|
|
|
{
|
1999-03-11 01:50:51 +03:00
|
|
|
//printf("nsEditor::Copy\n");
|
1999-03-11 01:46:15 +03:00
|
|
|
|
1999-04-07 07:56:07 +04:00
|
|
|
return mPresShell->DoCopy();
|
1999-03-11 00:29:41 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP nsEditor::Paste()
|
|
|
|
{
|
1999-03-11 01:50:51 +03:00
|
|
|
//printf("nsEditor::Paste\n");
|
1999-03-23 18:45:58 +03:00
|
|
|
nsString stuffToPaste;
|
|
|
|
|
1999-04-19 23:35:55 +04:00
|
|
|
// Get Clipboard Service
|
1999-03-26 18:49:28 +03:00
|
|
|
nsIClipboard* clipboard;
|
1999-03-23 18:45:58 +03:00
|
|
|
nsresult rv = nsServiceManager::GetService(kCClipboardCID,
|
|
|
|
kIClipboardIID,
|
|
|
|
(nsISupports **)&clipboard);
|
1999-04-19 23:35:55 +04:00
|
|
|
|
|
|
|
// Create generic Transferable for getting the data
|
1999-04-23 18:41:32 +04:00
|
|
|
nsCOMPtr<nsIGenericTransferable> genericTrans;
|
1999-04-17 17:51:42 +04:00
|
|
|
rv = nsComponentManager::CreateInstance(kCGenericTransferableCID, nsnull,
|
1999-04-23 18:41:32 +04:00
|
|
|
kIGenericTransferableIID, (void**) getter_AddRefs(genericTrans));
|
1999-04-17 17:51:42 +04:00
|
|
|
if (NS_OK == rv) {
|
1999-04-19 23:35:55 +04:00
|
|
|
// Get the nsITransferable interface for getting the data from the clipboard
|
1999-04-23 18:41:32 +04:00
|
|
|
nsCOMPtr<nsITransferable> trans(do_QueryInterface(genericTrans));
|
1999-04-17 17:51:42 +04:00
|
|
|
if (trans) {
|
1999-04-23 18:41:32 +04:00
|
|
|
nsCOMPtr<nsIDataFlavor> flavor;
|
1999-04-19 23:35:55 +04:00
|
|
|
|
|
|
|
// Create the desired DataFlavor for the type of data we want to get out of the transferable
|
1999-04-23 18:41:32 +04:00
|
|
|
rv = nsComponentManager::CreateInstance(kCDataFlavorCID, nsnull, kIDataFlavorIID, (void**) getter_AddRefs(flavor));
|
1999-04-17 17:51:42 +04:00
|
|
|
if (NS_OK == rv) {
|
1999-04-19 23:35:55 +04:00
|
|
|
// Initialize the DataFlavor and set it into the GenericTransferable
|
1999-04-17 17:51:42 +04:00
|
|
|
flavor->Init(kTextMime, "Text");
|
|
|
|
genericTrans->AddDataFlavor(flavor);
|
|
|
|
|
1999-04-19 23:35:55 +04:00
|
|
|
// Get the Data from the clipboard
|
1999-04-17 17:51:42 +04:00
|
|
|
clipboard->GetData(trans);
|
|
|
|
|
1999-04-19 23:35:55 +04:00
|
|
|
// Now we ask the transferable for the data
|
|
|
|
// it still owns the data, we just have a pointer to it.
|
|
|
|
// If it can't support a "text" output of the data the call will fail
|
1999-04-17 17:51:42 +04:00
|
|
|
char *str = 0;
|
|
|
|
PRUint32 len;
|
1999-04-19 23:35:55 +04:00
|
|
|
if (NS_OK == trans->GetTransferData(flavor, (void **)&str, &len)) {
|
|
|
|
|
|
|
|
// Make adjustments for null terminated strings
|
1999-04-23 18:41:32 +04:00
|
|
|
if (str && len > 0) {
|
1999-04-19 23:35:55 +04:00
|
|
|
// stuffToPaste is ready for insertion into the content
|
|
|
|
stuffToPaste.SetString(str, len);
|
1999-04-17 17:51:42 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
1999-04-02 05:34:05 +04:00
|
|
|
}
|
1999-04-01 18:28:13 +04:00
|
|
|
}
|
1999-04-23 18:41:32 +04:00
|
|
|
nsServiceManager::ReleaseService(kCClipboardCID, clipboard);
|
1999-03-23 18:45:58 +03:00
|
|
|
|
1999-03-11 01:50:51 +03:00
|
|
|
//printf("Trying to insert '%s'\n", stuffToPaste.ToNewCString());
|
1999-03-11 01:46:15 +03:00
|
|
|
|
|
|
|
// Now let InsertText handle the hard stuff:
|
|
|
|
return InsertText(stuffToPaste);
|
1999-03-11 00:29:41 +03:00
|
|
|
}
|
|
|
|
|
1999-04-27 21:14:28 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsEditor::AddEditActionListener(nsIEditActionListener *aListener)
|
|
|
|
{
|
|
|
|
if (!aListener)
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
|
|
|
|
if (!mActionListeners)
|
|
|
|
{
|
|
|
|
mActionListeners = new nsVoidArray();
|
|
|
|
|
|
|
|
if (!mActionListeners)
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!mActionListeners->AppendElement((void *)aListener))
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
NS_ADDREF(aListener);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsEditor::RemoveEditActionListener(nsIEditActionListener *aListener)
|
|
|
|
{
|
|
|
|
if (!aListener || !mActionListeners)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
if (!mActionListeners->RemoveElement((void *)aListener))
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
NS_IF_RELEASE(aListener);
|
|
|
|
|
|
|
|
if (mActionListeners->Count() < 1)
|
|
|
|
{
|
|
|
|
delete mActionListeners;
|
|
|
|
mActionListeners = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1999-03-10 22:48:13 +03:00
|
|
|
nsString & nsIEditor::GetTextNodeTag()
|
|
|
|
{
|
|
|
|
static nsString gTextNodeTag("special text node tag");
|
|
|
|
return gTextNodeTag;
|
1999-02-19 02:01:06 +03:00
|
|
|
}
|
|
|
|
|
1999-02-12 20:18:58 +03:00
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP nsEditor::CreateNode(const nsString& aTag,
|
1999-03-12 05:28:24 +03:00
|
|
|
nsIDOMNode * aParent,
|
|
|
|
PRInt32 aPosition,
|
|
|
|
nsIDOMNode ** aNewNode)
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
|
|
|
CreateElementTxn *txn;
|
|
|
|
nsresult result = CreateTxnForCreateElement(aTag, aParent, aPosition, &txn);
|
1999-02-24 20:24:37 +03:00
|
|
|
if (NS_SUCCEEDED(result))
|
|
|
|
{
|
1999-02-12 20:18:58 +03:00
|
|
|
result = Do(txn);
|
1999-02-24 20:24:37 +03:00
|
|
|
if (NS_SUCCEEDED(result))
|
|
|
|
{
|
|
|
|
result = txn->GetNewNode(aNewNode);
|
|
|
|
NS_ASSERTION((NS_SUCCEEDED(result)), "GetNewNode can't fail if txn::Do succeeded.");
|
|
|
|
}
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP nsEditor::CreateTxnForCreateElement(const nsString& aTag,
|
1999-03-16 19:38:09 +03:00
|
|
|
nsIDOMNode *aParent,
|
|
|
|
PRInt32 aPosition,
|
|
|
|
CreateElementTxn ** aTxn)
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
|
|
|
nsresult result = NS_ERROR_NULL_POINTER;
|
|
|
|
if (nsnull != aParent)
|
|
|
|
{
|
|
|
|
result = TransactionFactory::GetNewTransaction(kCreateElementTxnIID, (EditTxn **)aTxn);
|
1999-02-15 21:25:30 +03:00
|
|
|
if (NS_SUCCEEDED(result)) {
|
1999-02-22 18:53:31 +03:00
|
|
|
result = (*aTxn)->Init(this, aTag, aParent, aPosition);
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP nsEditor::InsertNode(nsIDOMNode * aNode,
|
As a reminder, we decided to do this based strictly content. Some support for style-based text properties is written, but not used
anywhere any more.
* Cleaned up split and join undo/redo.
* Added TypeInState, a data struct that remembers things about text properties for collapsed selections, so you can type
* Ctrl-B with an insertion point and the next character will be bold.
* Added all the logic to handle inline vs. block elements when setting text properties.
* Added some support for italic and underline as well. Adding these things is pretty easy now. Ctrl-B, Ctrl-I, Ctrl-U for testing bold, italic, underline.
* Added all the logic to make sure we only add style tags where they're needed, so you should never get the same style tag nested within itself, except as needed for block elements.
* Added methods for testing a node to see if a particular style is set. This isn't 100% done yet, but with very little work we could have toolbar buttons that respond to selection changed notification that show the state of bold, italic, underline, etc. in real time. Supports tri-state: whole selection is bold, some of selection is bold, none of selection is bold, ...
* Fully undoable and redoable.
* Added some debug printfs to transactions and editors. all controlled by a gNoisy static in each module. helps me track down undo/redo problems. if the output bugs people enough, I'll shut it off and re-enable it in my local tree.
Noticably missing: make un-bold, make un-italic, etc. This is coming soon.
1999-04-01 21:58:07 +04:00
|
|
|
nsIDOMNode * aParent,
|
|
|
|
PRInt32 aPosition)
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
1999-04-27 21:14:28 +04:00
|
|
|
PRInt32 i;
|
|
|
|
nsIEditActionListener *listener;
|
|
|
|
|
|
|
|
if (mActionListeners)
|
|
|
|
{
|
|
|
|
for (i = 0; i < mActionListeners->Count(); i++)
|
|
|
|
{
|
|
|
|
listener = (nsIEditActionListener *)mActionListeners->ElementAt(i);
|
|
|
|
if (listener)
|
|
|
|
listener->WillInsertNode(aNode, aParent, aPosition);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-02-24 20:24:37 +03:00
|
|
|
InsertElementTxn *txn;
|
|
|
|
nsresult result = CreateTxnForInsertElement(aNode, aParent, aPosition, &txn);
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
result = Do(txn);
|
|
|
|
}
|
1999-04-27 21:14:28 +04:00
|
|
|
|
|
|
|
if (mActionListeners)
|
|
|
|
{
|
|
|
|
for (i = 0; i < mActionListeners->Count(); i++)
|
|
|
|
{
|
|
|
|
listener = (nsIEditActionListener *)mActionListeners->ElementAt(i);
|
|
|
|
if (listener)
|
|
|
|
listener->DidInsertNode(aNode, aParent, aPosition, result);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-02-24 20:24:37 +03:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP nsEditor::CreateTxnForInsertElement(nsIDOMNode * aNode,
|
1999-03-16 19:38:09 +03:00
|
|
|
nsIDOMNode * aParent,
|
|
|
|
PRInt32 aPosition,
|
|
|
|
InsertElementTxn ** aTxn)
|
1999-02-24 20:24:37 +03:00
|
|
|
{
|
|
|
|
nsresult result = NS_ERROR_NULL_POINTER;
|
|
|
|
if (aNode && aParent && aTxn)
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
1999-02-24 20:24:37 +03:00
|
|
|
result = TransactionFactory::GetNewTransaction(kInsertElementTxnIID, (EditTxn **)aTxn);
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
As a reminder, we decided to do this based strictly content. Some support for style-based text properties is written, but not used
anywhere any more.
* Cleaned up split and join undo/redo.
* Added TypeInState, a data struct that remembers things about text properties for collapsed selections, so you can type
* Ctrl-B with an insertion point and the next character will be bold.
* Added all the logic to handle inline vs. block elements when setting text properties.
* Added some support for italic and underline as well. Adding these things is pretty easy now. Ctrl-B, Ctrl-I, Ctrl-U for testing bold, italic, underline.
* Added all the logic to make sure we only add style tags where they're needed, so you should never get the same style tag nested within itself, except as needed for block elements.
* Added methods for testing a node to see if a particular style is set. This isn't 100% done yet, but with very little work we could have toolbar buttons that respond to selection changed notification that show the state of bold, italic, underline, etc. in real time. Supports tri-state: whole selection is bold, some of selection is bold, none of selection is bold, ...
* Fully undoable and redoable.
* Added some debug printfs to transactions and editors. all controlled by a gNoisy static in each module. helps me track down undo/redo problems. if the output bugs people enough, I'll shut it off and re-enable it in my local tree.
Noticably missing: make un-bold, make un-italic, etc. This is coming soon.
1999-04-01 21:58:07 +04:00
|
|
|
result = (*aTxn)->Init(aNode, aParent, aPosition, this);
|
1999-02-24 20:24:37 +03:00
|
|
|
}
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
1999-02-24 20:24:37 +03:00
|
|
|
return result;
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP nsEditor::DeleteNode(nsIDOMNode * aElement)
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
1999-04-27 21:14:28 +04:00
|
|
|
PRInt32 i;
|
|
|
|
nsIEditActionListener *listener;
|
|
|
|
|
|
|
|
if (mActionListeners)
|
|
|
|
{
|
|
|
|
for (i = 0; i < mActionListeners->Count(); i++)
|
|
|
|
{
|
|
|
|
listener = (nsIEditActionListener *)mActionListeners->ElementAt(i);
|
|
|
|
if (listener)
|
|
|
|
listener->WillDeleteNode(aElement);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-02-12 20:18:58 +03:00
|
|
|
DeleteElementTxn *txn;
|
1999-02-15 21:25:30 +03:00
|
|
|
nsresult result = CreateTxnForDeleteElement(aElement, &txn);
|
1999-02-12 20:18:58 +03:00
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
result = Do(txn);
|
|
|
|
}
|
1999-04-27 21:14:28 +04:00
|
|
|
|
|
|
|
if (mActionListeners)
|
|
|
|
{
|
|
|
|
for (i = 0; i < mActionListeners->Count(); i++)
|
|
|
|
{
|
|
|
|
listener = (nsIEditActionListener *)mActionListeners->ElementAt(i);
|
|
|
|
if (listener)
|
|
|
|
listener->DidDeleteNode(aElement, result);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-02-12 20:18:58 +03:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP nsEditor::CreateTxnForDeleteElement(nsIDOMNode * aElement,
|
1999-02-12 20:18:58 +03:00
|
|
|
DeleteElementTxn ** aTxn)
|
|
|
|
{
|
|
|
|
nsresult result = NS_ERROR_NULL_POINTER;
|
1999-02-15 21:25:30 +03:00
|
|
|
if (nsnull != aElement)
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
|
|
|
result = TransactionFactory::GetNewTransaction(kDeleteElementTxnIID, (EditTxn **)aTxn);
|
1999-02-15 21:25:30 +03:00
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
result = (*aTxn)->Init(aElement);
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-03-06 00:05:35 +03:00
|
|
|
NS_IMETHODIMP nsEditor::CreateAggregateTxnForDeleteSelection(nsIAtom *aTxnName, EditAggregateTxn **aAggTxn)
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
1999-03-02 08:30:53 +03:00
|
|
|
nsresult result = NS_ERROR_NULL_POINTER;
|
|
|
|
if (aAggTxn)
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
1999-03-02 08:30:53 +03:00
|
|
|
*aAggTxn = nsnull;
|
1999-03-06 00:05:35 +03:00
|
|
|
result = TransactionFactory::GetNewTransaction(kEditAggregateTxnIID, (EditTxn**)aAggTxn);
|
1999-03-02 08:30:53 +03:00
|
|
|
|
1999-03-06 00:05:35 +03:00
|
|
|
if (NS_FAILED(result) || !*aAggTxn) {
|
1999-03-02 08:30:53 +03:00
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Set the name for the aggregate transaction
|
1999-03-06 00:05:35 +03:00
|
|
|
(*aAggTxn)->SetName(aTxnName);
|
1999-03-02 08:30:53 +03:00
|
|
|
|
|
|
|
// Get current selection and setup txn to delete it,
|
|
|
|
// but only if selection exists (is not a collapsed "caret" state)
|
|
|
|
nsCOMPtr<nsIDOMSelection> selection;
|
|
|
|
result = mPresShell->GetSelection(getter_AddRefs(selection));
|
|
|
|
if (NS_SUCCEEDED(result) && selection)
|
|
|
|
{
|
|
|
|
PRBool collapsed;
|
1999-04-13 05:33:32 +04:00
|
|
|
result = selection->GetIsCollapsed(&collapsed);
|
1999-03-02 08:30:53 +03:00
|
|
|
if (NS_SUCCEEDED(result) && !collapsed) {
|
|
|
|
EditAggregateTxn *delSelTxn;
|
|
|
|
result = CreateTxnForDeleteSelection(nsIEditor::eLTR, &delSelTxn);
|
|
|
|
if (NS_SUCCEEDED(result) && delSelTxn) {
|
1999-03-06 00:05:35 +03:00
|
|
|
(*aAggTxn)->AppendChild(delSelTxn);
|
1999-03-02 08:30:53 +03:00
|
|
|
}
|
1999-02-15 21:25:30 +03:00
|
|
|
}
|
|
|
|
}
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
1999-03-02 08:30:53 +03:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-02-12 20:18:58 +03:00
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsEditor::InsertText(const nsString& aStringToInsert)
|
|
|
|
{
|
|
|
|
EditAggregateTxn *aggTxn = nsnull;
|
|
|
|
// Create the "delete current selection" txn
|
1999-03-06 00:05:35 +03:00
|
|
|
nsresult result = CreateAggregateTxnForDeleteSelection(InsertTextTxn::gInsertTextTxnName, &aggTxn);
|
1999-03-02 08:30:53 +03:00
|
|
|
if ((NS_FAILED(result)) || (nsnull==aggTxn)) {
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
1999-02-12 20:18:58 +03:00
|
|
|
InsertTextTxn *txn;
|
1999-03-10 22:48:13 +03:00
|
|
|
result = CreateTxnForInsertText(aStringToInsert, nsnull, &txn); // insert at the current selection
|
1999-02-15 21:25:30 +03:00
|
|
|
if ((NS_SUCCEEDED(result)) && txn) {
|
|
|
|
aggTxn->AppendChild(txn);
|
|
|
|
result = Do(aggTxn);
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
1999-03-10 22:48:13 +03:00
|
|
|
else if (NS_ERROR_EDITOR_NO_SELECTION==result) {
|
|
|
|
result = DoInitialInsert(aStringToInsert);
|
|
|
|
}
|
1999-03-16 19:38:09 +03:00
|
|
|
else if (NS_ERROR_EDITOR_NO_TEXTNODE==result)
|
|
|
|
{
|
|
|
|
BeginTransaction();
|
|
|
|
nsCOMPtr<nsIDOMSelection> selection;
|
|
|
|
result = GetSelection(getter_AddRefs(selection));
|
|
|
|
if ((NS_SUCCEEDED(result)) && selection)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMNode> selectedNode;
|
|
|
|
PRInt32 offset;
|
1999-04-16 00:20:12 +04:00
|
|
|
result = selection->GetAnchorNode(getter_AddRefs(selectedNode));
|
|
|
|
if (NS_SUCCEEDED(result) && NS_SUCCEEDED(selection->GetAnchorOffset(&offset)) && selectedNode)
|
1999-03-16 19:38:09 +03:00
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMNode> newNode;
|
|
|
|
result = CreateNode(GetTextNodeTag(), selectedNode, offset+1,
|
|
|
|
getter_AddRefs(newNode));
|
|
|
|
if (NS_SUCCEEDED(result) && newNode)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMCharacterData>newTextNode;
|
|
|
|
newTextNode = do_QueryInterface(newNode);
|
|
|
|
if (newTextNode)
|
|
|
|
{
|
|
|
|
nsAutoString placeholderText(" ");
|
|
|
|
newTextNode->SetData(placeholderText);
|
|
|
|
selection->Collapse(newNode, 0);
|
|
|
|
selection->Extend(newNode, 1);
|
|
|
|
result = InsertText(aStringToInsert);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
EndTransaction();
|
|
|
|
}
|
1999-02-12 20:18:58 +03:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP nsEditor::CreateTxnForInsertText(const nsString & aStringToInsert,
|
1999-03-10 22:48:13 +03:00
|
|
|
nsIDOMCharacterData *aTextNode,
|
1999-03-02 10:52:41 +03:00
|
|
|
InsertTextTxn ** aTxn)
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
|
|
|
nsresult result;
|
1999-03-10 22:48:13 +03:00
|
|
|
PRInt32 offset;
|
|
|
|
nsCOMPtr<nsIDOMCharacterData> nodeAsText;
|
|
|
|
|
|
|
|
if (aTextNode) {
|
|
|
|
nodeAsText = do_QueryInterface(aTextNode);
|
|
|
|
offset = 0;
|
|
|
|
}
|
|
|
|
else
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
1999-03-10 22:48:13 +03:00
|
|
|
nsCOMPtr<nsIDOMSelection> selection;
|
|
|
|
result = mPresShell->GetSelection(getter_AddRefs(selection));
|
|
|
|
if ((NS_SUCCEEDED(result)) && selection)
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
1999-03-10 22:48:13 +03:00
|
|
|
result = NS_ERROR_UNEXPECTED;
|
|
|
|
nsCOMPtr<nsIEnumerator> enumerator;
|
1999-04-04 22:01:35 +04:00
|
|
|
enumerator = do_QueryInterface(selection);
|
1999-03-10 22:48:13 +03:00
|
|
|
if (enumerator)
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
1999-03-10 22:48:13 +03:00
|
|
|
enumerator->First();
|
|
|
|
nsISupports *currentItem;
|
|
|
|
result = enumerator->CurrentItem(¤tItem);
|
|
|
|
if ((NS_SUCCEEDED(result)) && (nsnull!=currentItem))
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
1999-03-10 22:48:13 +03:00
|
|
|
result = NS_ERROR_UNEXPECTED;
|
|
|
|
nsCOMPtr<nsIDOMRange> range( do_QueryInterface(currentItem) );
|
|
|
|
if (range)
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
1999-03-10 22:48:13 +03:00
|
|
|
nsCOMPtr<nsIDOMNode> node;
|
|
|
|
result = range->GetStartParent(getter_AddRefs(node));
|
|
|
|
if ((NS_SUCCEEDED(result)) && (node))
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
1999-04-04 22:01:35 +04:00
|
|
|
nodeAsText = do_QueryInterface(node);
|
1999-02-12 20:18:58 +03:00
|
|
|
range->GetStartOffset(&offset);
|
1999-03-16 19:38:09 +03:00
|
|
|
if (!nodeAsText) {
|
|
|
|
result = NS_ERROR_EDITOR_NO_TEXTNODE;
|
|
|
|
}
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
1999-03-10 22:48:13 +03:00
|
|
|
else
|
|
|
|
{
|
|
|
|
result = NS_ERROR_EDITOR_NO_SELECTION;
|
|
|
|
}
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
1999-03-10 22:48:13 +03:00
|
|
|
if (NS_SUCCEEDED(result) && nodeAsText)
|
|
|
|
{
|
|
|
|
result = TransactionFactory::GetNewTransaction(kInsertTextTxnIID, (EditTxn **)aTxn);
|
|
|
|
if (nsnull!=*aTxn) {
|
|
|
|
result = (*aTxn)->Init(nodeAsText, offset, aStringToInsert, mPresShell);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
result = NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
// we're in the special situation where there is no selection. Insert the text
|
|
|
|
// at the beginning of the document.
|
|
|
|
// XXX: this is all logic that must be moved to the rule system
|
|
|
|
// for HTML, we create a text node on the body. That's what is done below
|
|
|
|
// for XML, we would create a text node on the root element.
|
|
|
|
// The rule system should be telling us which of these (or any other variant) to do.
|
|
|
|
/* this method should look something like
|
|
|
|
BeginTransaction()
|
|
|
|
mRule->GetNodeForInitialInsert(parentNode)
|
|
|
|
mRule->CreateInitialDocumentFragment(childNode)
|
|
|
|
InsertElement(childNode, parentNode)
|
|
|
|
find the first text node in childNode
|
|
|
|
insert the text there
|
|
|
|
*/
|
1999-02-12 20:18:58 +03:00
|
|
|
|
1999-03-10 22:48:13 +03:00
|
|
|
NS_IMETHODIMP nsEditor::DoInitialInsert(const nsString & aStringToInsert)
|
|
|
|
{
|
|
|
|
if (!mDoc) {
|
|
|
|
return NS_ERROR_NOT_INITIALIZED;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMNodeList>nodeList;
|
1999-03-12 05:28:24 +03:00
|
|
|
nsAutoString bodyTag = "body";
|
1999-03-10 22:48:13 +03:00
|
|
|
nsresult result = mDoc->GetElementsByTagName(bodyTag, getter_AddRefs(nodeList));
|
|
|
|
if ((NS_SUCCEEDED(result)) && nodeList)
|
|
|
|
{
|
|
|
|
PRUint32 count;
|
|
|
|
nodeList->GetLength(&count);
|
|
|
|
NS_ASSERTION(1==count, "there is not exactly 1 body in the document!");
|
|
|
|
nsCOMPtr<nsIDOMNode>node;
|
|
|
|
result = nodeList->Item(0, getter_AddRefs(node));
|
|
|
|
if ((NS_SUCCEEDED(result)) && node)
|
|
|
|
{ // now we've got the body tag.
|
|
|
|
// create transaction to insert the text node,
|
|
|
|
// and create a transaction to insert the text
|
|
|
|
CreateElementTxn *txn;
|
|
|
|
result = CreateTxnForCreateElement(GetTextNodeTag(), node, 0, &txn);
|
|
|
|
if ((NS_SUCCEEDED(result)) && txn)
|
|
|
|
{
|
|
|
|
result = Do(txn);
|
|
|
|
if (NS_SUCCEEDED(result))
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMNode>newNode;
|
|
|
|
txn->GetNewNode(getter_AddRefs(newNode));
|
|
|
|
if ((NS_SUCCEEDED(result)) && newNode)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMCharacterData>newTextNode;
|
|
|
|
newTextNode = do_QueryInterface(newNode);
|
|
|
|
if (newTextNode)
|
|
|
|
{
|
|
|
|
InsertTextTxn *insertTxn;
|
|
|
|
result = CreateTxnForInsertText(aStringToInsert, newTextNode, &insertTxn);
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
result = Do(insertTxn);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
result = NS_ERROR_UNEXPECTED;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
1999-02-12 20:18:58 +03:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP nsEditor::DeleteText(nsIDOMCharacterData *aElement,
|
1999-02-12 20:18:58 +03:00
|
|
|
PRUint32 aOffset,
|
|
|
|
PRUint32 aLength)
|
|
|
|
{
|
|
|
|
DeleteTextTxn *txn;
|
|
|
|
nsresult result = CreateTxnForDeleteText(aElement, aOffset, aLength, &txn);
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
result = Do(txn);
|
1999-03-14 03:31:35 +03:00
|
|
|
HACKForceRedraw();
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP nsEditor::CreateTxnForDeleteText(nsIDOMCharacterData *aElement,
|
1999-03-10 22:48:13 +03:00
|
|
|
PRUint32 aOffset,
|
|
|
|
PRUint32 aLength,
|
|
|
|
DeleteTextTxn **aTxn)
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
|
|
|
nsresult result=NS_ERROR_NULL_POINTER;
|
|
|
|
if (nsnull != aElement)
|
|
|
|
{
|
|
|
|
result = TransactionFactory::GetNewTransaction(kDeleteTextTxnIID, (EditTxn **)aTxn);
|
1999-02-15 21:25:30 +03:00
|
|
|
if (NS_SUCCEEDED(result)) {
|
1999-02-22 18:53:31 +03:00
|
|
|
result = (*aTxn)->Init(this, aElement, aOffset, aLength);
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1999-04-08 04:46:10 +04:00
|
|
|
NS_IMETHODIMP nsEditor::DeleteSelectionAndCreateNode(const nsString& aTag,
|
|
|
|
nsIDOMNode ** aNewNode)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMNode> parentSelectedNode;
|
|
|
|
PRInt32 offsetOfNewNode;
|
|
|
|
nsresult result = DeleteSelectionAndPrepareToCreateNode(parentSelectedNode,
|
|
|
|
offsetOfNewNode);
|
|
|
|
if (!NS_SUCCEEDED(result))
|
|
|
|
return result;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMNode> newNode;
|
|
|
|
result = CreateNode(aTag, parentSelectedNode, offsetOfNewNode,
|
|
|
|
getter_AddRefs(newNode));
|
|
|
|
|
|
|
|
*aNewNode = newNode;
|
|
|
|
|
|
|
|
// we want the selection to be just after the new node
|
|
|
|
nsCOMPtr<nsIDOMSelection> selection;
|
|
|
|
result = GetSelection(getter_AddRefs(selection));
|
|
|
|
if ((NS_SUCCEEDED(result)) && selection)
|
|
|
|
selection->Collapse(parentSelectedNode, offsetOfNewNode+1);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP nsEditor::DeleteSelectionAndPrepareToCreateNode(nsCOMPtr<nsIDOMNode> &parentSelectedNode, PRInt32& offsetOfNewNode)
|
1999-03-02 08:30:53 +03:00
|
|
|
{
|
|
|
|
nsresult result=NS_ERROR_NOT_INITIALIZED;
|
|
|
|
nsCOMPtr<nsIDOMSelection> selection;
|
|
|
|
result = GetSelection(getter_AddRefs(selection));
|
|
|
|
if ((NS_SUCCEEDED(result)) && selection)
|
|
|
|
{
|
|
|
|
PRBool collapsed;
|
1999-04-13 05:33:32 +04:00
|
|
|
result = selection->GetIsCollapsed(&collapsed);
|
1999-03-02 08:30:53 +03:00
|
|
|
if (NS_SUCCEEDED(result) && !collapsed)
|
|
|
|
{
|
|
|
|
result = DeleteSelection(nsIEditor::eLTR);
|
1999-03-10 22:48:13 +03:00
|
|
|
if (NS_FAILED(result)) {
|
|
|
|
return result;
|
|
|
|
}
|
1999-03-02 08:30:53 +03:00
|
|
|
// get the new selection
|
|
|
|
result = GetSelection(getter_AddRefs(selection));
|
1999-03-10 22:48:13 +03:00
|
|
|
if (NS_FAILED(result)) {
|
|
|
|
return result;
|
|
|
|
}
|
1999-03-02 08:30:53 +03:00
|
|
|
#ifdef NS_DEBUG
|
1999-03-15 03:57:32 +03:00
|
|
|
nsCOMPtr<nsIDOMNode>testSelectedNode;
|
1999-04-16 00:20:12 +04:00
|
|
|
nsresult debugResult = selection->GetAnchorNode(getter_AddRefs(testSelectedNode));
|
1999-03-15 03:57:32 +03:00
|
|
|
// no selection is ok.
|
|
|
|
// if there is a selection, it must be collapsed
|
|
|
|
if (testSelectedNode)
|
|
|
|
{
|
|
|
|
PRBool testCollapsed;
|
1999-04-13 05:33:32 +04:00
|
|
|
debugResult = selection->GetIsCollapsed(&testCollapsed);
|
1999-03-15 03:57:32 +03:00
|
|
|
NS_ASSERTION((NS_SUCCEEDED(result)), "couldn't get a selection after deletion");
|
|
|
|
NS_ASSERTION(PR_TRUE==testCollapsed, "selection not reset after deletion");
|
|
|
|
}
|
1999-03-02 08:30:53 +03:00
|
|
|
#endif
|
|
|
|
}
|
1999-03-17 09:13:46 +03:00
|
|
|
// split the selected node
|
1999-03-10 22:48:13 +03:00
|
|
|
PRInt32 offsetOfSelectedNode;
|
1999-04-16 00:20:12 +04:00
|
|
|
result = selection->GetAnchorNode(getter_AddRefs(parentSelectedNode));
|
|
|
|
if (NS_SUCCEEDED(result) && NS_SUCCEEDED(selection->GetAnchorOffset(&offsetOfSelectedNode)) && parentSelectedNode)
|
1999-03-02 08:30:53 +03:00
|
|
|
{
|
1999-03-10 22:48:13 +03:00
|
|
|
nsCOMPtr<nsIDOMNode> selectedNode;
|
|
|
|
PRUint32 selectedNodeContentCount=0;
|
|
|
|
nsCOMPtr<nsIDOMCharacterData>selectedParentNodeAsText;
|
|
|
|
selectedParentNodeAsText = do_QueryInterface(parentSelectedNode);
|
1999-03-17 09:13:46 +03:00
|
|
|
/* if the selection is a text node, split the text node if necesary
|
|
|
|
and compute where to put the new node
|
|
|
|
*/
|
|
|
|
if (selectedParentNodeAsText)
|
|
|
|
{
|
|
|
|
PRInt32 indexOfTextNodeInParent;
|
1999-03-10 22:48:13 +03:00
|
|
|
selectedNode = do_QueryInterface(parentSelectedNode);
|
|
|
|
selectedNode->GetParentNode(getter_AddRefs(parentSelectedNode));
|
|
|
|
selectedParentNodeAsText->GetLength(&selectedNodeContentCount);
|
1999-05-05 08:05:19 +04:00
|
|
|
GetChildOffset(selectedNode, parentSelectedNode, indexOfTextNodeInParent);
|
1999-03-17 09:13:46 +03:00
|
|
|
|
|
|
|
if ((offsetOfSelectedNode!=0) && (((PRUint32)offsetOfSelectedNode)!=selectedNodeContentCount))
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMNode> newSiblingNode;
|
|
|
|
result = SplitNode(selectedNode, offsetOfSelectedNode, getter_AddRefs(newSiblingNode));
|
|
|
|
// now get the node's offset in it's parent, and insert the new tag there
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
1999-05-05 08:05:19 +04:00
|
|
|
result = GetChildOffset(selectedNode, parentSelectedNode, offsetOfNewNode);
|
1999-03-17 09:13:46 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{ // determine where to insert the new node
|
|
|
|
if (0==offsetOfSelectedNode) {
|
|
|
|
offsetOfNewNode = indexOfTextNodeInParent; // insert new node as previous sibling to selection parent
|
|
|
|
}
|
|
|
|
else { // insert new node as last child
|
1999-05-05 08:05:19 +04:00
|
|
|
GetChildOffset(selectedNode, parentSelectedNode, offsetOfNewNode);
|
1999-03-17 09:13:46 +03:00
|
|
|
offsetOfNewNode++; // offsets are 0-based, and we need the index of the new node
|
|
|
|
}
|
|
|
|
}
|
1999-03-10 22:48:13 +03:00
|
|
|
}
|
1999-03-17 09:13:46 +03:00
|
|
|
/* if the selection is not a text node, split the parent node if necesary
|
|
|
|
and compute where to put the new node
|
|
|
|
*/
|
1999-03-10 22:48:13 +03:00
|
|
|
else
|
1999-03-17 09:13:46 +03:00
|
|
|
{ // it's an interior node
|
1999-03-10 22:48:13 +03:00
|
|
|
nsCOMPtr<nsIDOMNodeList>parentChildList;
|
|
|
|
parentSelectedNode->GetChildNodes(getter_AddRefs(parentChildList));
|
|
|
|
if ((NS_SUCCEEDED(result)) && parentChildList)
|
|
|
|
{
|
|
|
|
result = parentChildList->Item(offsetOfSelectedNode, getter_AddRefs(selectedNode));
|
|
|
|
if ((NS_SUCCEEDED(result)) && selectedNode)
|
1999-03-02 08:30:53 +03:00
|
|
|
{
|
1999-03-10 22:48:13 +03:00
|
|
|
nsCOMPtr<nsIDOMCharacterData>selectedNodeAsText;
|
|
|
|
selectedNodeAsText = do_QueryInterface(selectedNode);
|
1999-03-17 09:13:46 +03:00
|
|
|
nsCOMPtr<nsIDOMNodeList>childList;
|
|
|
|
selectedNode->GetChildNodes(getter_AddRefs(childList));
|
|
|
|
if ((NS_SUCCEEDED(result)) && childList) {
|
|
|
|
childList->GetLength(&selectedNodeContentCount);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
1999-03-10 22:48:13 +03:00
|
|
|
}
|
1999-03-17 09:13:46 +03:00
|
|
|
if ((offsetOfSelectedNode!=0) && (((PRUint32)offsetOfSelectedNode)!=selectedNodeContentCount))
|
1999-03-10 22:48:13 +03:00
|
|
|
{
|
1999-03-17 09:13:46 +03:00
|
|
|
nsCOMPtr<nsIDOMNode> newSiblingNode;
|
|
|
|
result = SplitNode(selectedNode, offsetOfSelectedNode, getter_AddRefs(newSiblingNode));
|
|
|
|
// now get the node's offset in it's parent, and insert the new tag there
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
1999-05-05 08:05:19 +04:00
|
|
|
result = GetChildOffset(selectedNode, parentSelectedNode, offsetOfNewNode);
|
1999-03-17 09:13:46 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{ // determine where to insert the new node
|
|
|
|
if (0==offsetOfSelectedNode) {
|
|
|
|
offsetOfNewNode = 0; // insert new node as first child
|
1999-03-10 22:48:13 +03:00
|
|
|
}
|
1999-03-17 09:13:46 +03:00
|
|
|
else { // insert new node as last child
|
1999-05-05 08:05:19 +04:00
|
|
|
GetChildOffset(selectedNode, parentSelectedNode, offsetOfNewNode);
|
1999-03-17 09:13:46 +03:00
|
|
|
offsetOfNewNode++; // offsets are 0-based, and we need the index of the new node
|
1999-03-10 22:48:13 +03:00
|
|
|
}
|
|
|
|
}
|
1999-03-02 08:30:53 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
1999-03-10 22:48:13 +03:00
|
|
|
|
1999-04-08 04:46:10 +04:00
|
|
|
// Here's where the new node was inserted
|
1999-03-02 08:30:53 +03:00
|
|
|
}
|
1999-03-17 09:13:46 +03:00
|
|
|
else {
|
|
|
|
printf("InsertBreak into an empty document is not yet supported\n");
|
|
|
|
}
|
1999-03-02 08:30:53 +03:00
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-02-12 22:36:18 +03:00
|
|
|
#define DELETE_SELECTION_DOESNT_GO_THROUGH_RANGE
|
1999-02-12 20:18:58 +03:00
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP
|
1999-02-12 20:18:58 +03:00
|
|
|
nsEditor::DeleteSelection(nsIEditor::Direction aDir)
|
|
|
|
{
|
|
|
|
nsresult result;
|
|
|
|
#ifdef DELETE_SELECTION_DOESNT_GO_THROUGH_RANGE
|
|
|
|
EditAggregateTxn *txn;
|
|
|
|
result = CreateTxnForDeleteSelection(aDir, &txn);
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
result = Do(txn);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
// XXX Warning, this should be moved to a transaction since
|
|
|
|
// calling it this way means undo won't work.
|
|
|
|
nsCOMPtr<nsIDOMSelection> selection;
|
|
|
|
result = mPresShell->GetSelection(getter_AddRefs(selection));
|
|
|
|
if (NS_SUCCEEDED(result) && selection)
|
|
|
|
result = selection->DeleteFromDocument();
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP nsEditor::CreateTxnForDeleteSelection(nsIEditor::Direction aDir,
|
1999-03-16 19:38:09 +03:00
|
|
|
EditAggregateTxn ** aTxn)
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
1999-02-15 21:25:30 +03:00
|
|
|
if (!aTxn)
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
*aTxn = nsnull;
|
|
|
|
|
1999-02-12 20:18:58 +03:00
|
|
|
nsresult result;
|
|
|
|
// allocate the out-param transaction
|
|
|
|
result = TransactionFactory::GetNewTransaction(kEditAggregateTxnIID, (EditTxn **)aTxn);
|
|
|
|
if (NS_FAILED(result)) {
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
nsCOMPtr<nsIDOMSelection> selection;
|
|
|
|
result = mPresShell->GetSelection(getter_AddRefs(selection));
|
|
|
|
if ((NS_SUCCEEDED(result)) && selection)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIEnumerator> enumerator;
|
1999-04-04 22:01:35 +04:00
|
|
|
enumerator = do_QueryInterface(selection);
|
1999-02-12 20:18:58 +03:00
|
|
|
if (enumerator)
|
|
|
|
{
|
|
|
|
for (enumerator->First(); NS_OK!=enumerator->IsDone(); enumerator->Next())
|
|
|
|
{
|
|
|
|
nsISupports *currentItem=nsnull;
|
|
|
|
result = enumerator->CurrentItem(¤tItem);
|
|
|
|
if ((NS_SUCCEEDED(result)) && (currentItem))
|
|
|
|
{
|
1999-03-03 01:27:46 +03:00
|
|
|
nsCOMPtr<nsIDOMRange> range( do_QueryInterface(currentItem) );
|
1999-02-12 20:18:58 +03:00
|
|
|
PRBool isCollapsed;
|
|
|
|
range->GetIsCollapsed(&isCollapsed);
|
|
|
|
if (PR_FALSE==isCollapsed)
|
|
|
|
{
|
|
|
|
DeleteRangeTxn *txn;
|
|
|
|
result = TransactionFactory::GetNewTransaction(kDeleteRangeTxnIID, (EditTxn **)&txn);
|
|
|
|
if ((NS_SUCCEEDED(result)) && (nsnull!=txn))
|
|
|
|
{
|
1999-02-17 22:42:29 +03:00
|
|
|
txn->Init(this, range);
|
1999-02-12 20:18:58 +03:00
|
|
|
(*aTxn)->AppendChild(txn);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
result = NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{ // we have an insertion point. delete the thing in front of it or behind it, depending on aDir
|
|
|
|
result = CreateTxnForDeleteInsertionPoint(range, aDir, *aTxn);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// if we didn't build the transaction correctly, destroy the out-param transaction so we don't leak it.
|
|
|
|
if (NS_FAILED(result))
|
|
|
|
{
|
|
|
|
NS_IF_RELEASE(*aTxn);
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//XXX: currently, this doesn't handle edge conditions because GetNext/GetPrior are not implemented
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP
|
1999-02-12 20:18:58 +03:00
|
|
|
nsEditor::CreateTxnForDeleteInsertionPoint(nsIDOMRange *aRange,
|
|
|
|
nsIEditor::Direction aDir,
|
|
|
|
EditAggregateTxn *aTxn)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMNode> node;
|
|
|
|
PRBool isFirst;
|
|
|
|
PRBool isLast;
|
|
|
|
PRInt32 offset;
|
|
|
|
PRInt32 length=1;
|
|
|
|
|
|
|
|
// get the node and offset of the insertion point
|
|
|
|
nsresult result = aRange->GetStartParent(getter_AddRefs(node));
|
1999-02-17 04:59:56 +03:00
|
|
|
if (NS_FAILED(result))
|
|
|
|
return result;
|
|
|
|
result = aRange->GetStartOffset(&offset);
|
|
|
|
if (NS_FAILED(result))
|
|
|
|
return result;
|
1999-02-12 20:18:58 +03:00
|
|
|
|
|
|
|
// determine if the insertion point is at the beginning, middle, or end of the node
|
1999-02-17 04:59:56 +03:00
|
|
|
nsCOMPtr<nsIDOMCharacterData> nodeAsText;
|
1999-03-16 19:38:09 +03:00
|
|
|
nsCOMPtr<nsIDOMNode> selectedNode;
|
|
|
|
nodeAsText = do_QueryInterface(node);
|
1999-02-17 04:59:56 +03:00
|
|
|
|
1999-02-12 20:18:58 +03:00
|
|
|
if (nodeAsText)
|
|
|
|
{
|
|
|
|
PRUint32 count;
|
|
|
|
nodeAsText->GetLength(&count);
|
|
|
|
isFirst = PRBool(0==offset);
|
1999-03-02 08:30:53 +03:00
|
|
|
isLast = PRBool(count==(PRUint32)offset);
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
|
|
|
else
|
1999-03-16 19:38:09 +03:00
|
|
|
{
|
|
|
|
// get the child list and count
|
|
|
|
nsCOMPtr<nsIDOMNodeList>childList;
|
|
|
|
PRUint32 count=0;
|
|
|
|
result = node->GetChildNodes(getter_AddRefs(childList));
|
|
|
|
if ((NS_SUCCEEDED(result)) && childList)
|
|
|
|
{
|
|
|
|
childList->GetLength(&count);
|
|
|
|
childList->Item(offset, getter_AddRefs(selectedNode));
|
|
|
|
}
|
|
|
|
isFirst = PRBool(0==offset);
|
|
|
|
isLast = PRBool((count-1)==(PRUint32)offset);
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
1999-03-10 22:48:13 +03:00
|
|
|
// XXX: if isFirst && isLast, then we'll need to delete the node
|
|
|
|
// as well as the 1 child
|
1999-02-12 20:18:58 +03:00
|
|
|
|
|
|
|
// build a transaction for deleting the appropriate data
|
1999-03-10 22:48:13 +03:00
|
|
|
// XXX: this has to come from rule section
|
1999-02-12 20:18:58 +03:00
|
|
|
if ((nsIEditor::eRTL==aDir) && (PR_TRUE==isFirst))
|
|
|
|
{ // we're backspacing from the beginning of the node. Delete the first thing to our left
|
|
|
|
nsCOMPtr<nsIDOMNode> priorNode;
|
|
|
|
result = GetPriorNode(node, getter_AddRefs(priorNode));
|
|
|
|
if ((NS_SUCCEEDED(result)) && priorNode)
|
|
|
|
{ // there is a priorNode, so delete it's last child (if text content, delete the last char.)
|
|
|
|
// if it has no children, delete it
|
1999-02-17 04:59:56 +03:00
|
|
|
nsCOMPtr<nsIDOMCharacterData> priorNodeAsText;
|
1999-04-04 22:01:35 +04:00
|
|
|
priorNodeAsText = do_QueryInterface(priorNode);
|
1999-02-12 20:18:58 +03:00
|
|
|
if (priorNodeAsText)
|
|
|
|
{
|
|
|
|
PRUint32 length=0;
|
|
|
|
priorNodeAsText->GetLength(&length);
|
|
|
|
if (0<length)
|
|
|
|
{
|
|
|
|
DeleteTextTxn *txn;
|
|
|
|
result = CreateTxnForDeleteText(priorNodeAsText, length-1, 1, &txn);
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
aTxn->AppendChild(txn);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{ // XXX: can you have an empty text node? If so, what do you do?
|
|
|
|
printf("ERROR: found a text node with 0 characters\n");
|
|
|
|
result = NS_ERROR_UNEXPECTED;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{ // priorNode is not text, so tell it's parent to delete it
|
1999-02-15 21:25:30 +03:00
|
|
|
DeleteElementTxn *txn;
|
|
|
|
result = CreateTxnForDeleteElement(priorNode, &txn);
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
aTxn->AppendChild(txn);
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if ((nsIEditor::eLTR==aDir) && (PR_TRUE==isLast))
|
|
|
|
{ // we're deleting from the end of the node. Delete the first thing to our right
|
|
|
|
nsCOMPtr<nsIDOMNode> nextNode;
|
|
|
|
result = GetNextNode(node, getter_AddRefs(nextNode));
|
|
|
|
if ((NS_SUCCEEDED(result)) && nextNode)
|
|
|
|
{ // there is a priorNode, so delete it's last child (if text content, delete the last char.)
|
|
|
|
// if it has no children, delete it
|
1999-02-17 04:59:56 +03:00
|
|
|
nsCOMPtr<nsIDOMCharacterData> nextNodeAsText;
|
1999-04-04 22:01:35 +04:00
|
|
|
nextNodeAsText = do_QueryInterface(nextNode);
|
1999-02-12 20:18:58 +03:00
|
|
|
if (nextNodeAsText)
|
|
|
|
{
|
|
|
|
PRUint32 length=0;
|
|
|
|
nextNodeAsText->GetLength(&length);
|
|
|
|
if (0<length)
|
|
|
|
{
|
|
|
|
DeleteTextTxn *txn;
|
|
|
|
result = CreateTxnForDeleteText(nextNodeAsText, 0, 1, &txn);
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
aTxn->AppendChild(txn);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{ // XXX: can you have an empty text node? If so, what do you do?
|
|
|
|
printf("ERROR: found a text node with 0 characters\n");
|
|
|
|
result = NS_ERROR_UNEXPECTED;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{ // nextNode is not text, so tell it's parent to delete it
|
1999-02-15 21:25:30 +03:00
|
|
|
DeleteElementTxn *txn;
|
|
|
|
result = CreateTxnForDeleteElement(nextNode, &txn);
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
aTxn->AppendChild(txn);
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (nodeAsText)
|
|
|
|
{ // we have text, so delete a char at the proper offset
|
|
|
|
if (nsIEditor::eRTL==aDir) {
|
|
|
|
offset --;
|
|
|
|
}
|
|
|
|
DeleteTextTxn *txn;
|
|
|
|
result = CreateTxnForDeleteText(nodeAsText, offset, length, &txn);
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
aTxn->AppendChild(txn);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{ // we're deleting a node
|
1999-03-16 19:38:09 +03:00
|
|
|
DeleteElementTxn *txn;
|
|
|
|
result = CreateTxnForDeleteElement(selectedNode, &txn);
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
aTxn->AppendChild(txn);
|
|
|
|
}
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP
|
1999-02-17 22:42:29 +03:00
|
|
|
nsEditor::SplitNode(nsIDOMNode * aNode,
|
1999-02-24 20:24:37 +03:00
|
|
|
PRInt32 aOffset,
|
|
|
|
nsIDOMNode **aNewLeftNode)
|
1999-02-17 22:42:29 +03:00
|
|
|
{
|
1999-04-27 21:14:28 +04:00
|
|
|
PRInt32 i;
|
|
|
|
nsIEditActionListener *listener;
|
|
|
|
|
|
|
|
if (mActionListeners)
|
|
|
|
{
|
|
|
|
for (i = 0; i < mActionListeners->Count(); i++)
|
|
|
|
{
|
|
|
|
listener = (nsIEditActionListener *)mActionListeners->ElementAt(i);
|
|
|
|
if (listener)
|
|
|
|
listener->WillSplitNode(aNode, aOffset);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-02-17 22:42:29 +03:00
|
|
|
SplitElementTxn *txn;
|
|
|
|
nsresult result = CreateTxnForSplitNode(aNode, aOffset, &txn);
|
1999-02-24 20:24:37 +03:00
|
|
|
if (NS_SUCCEEDED(result))
|
|
|
|
{
|
|
|
|
result = Do(txn);
|
|
|
|
if (NS_SUCCEEDED(result))
|
|
|
|
{
|
|
|
|
result = txn->GetNewNode(aNewLeftNode);
|
|
|
|
NS_ASSERTION((NS_SUCCEEDED(result)), "result must succeeded for GetNewNode");
|
|
|
|
}
|
1999-02-17 22:42:29 +03:00
|
|
|
}
|
1999-04-27 21:14:28 +04:00
|
|
|
|
|
|
|
if (mActionListeners)
|
|
|
|
{
|
|
|
|
for (i = 0; i < mActionListeners->Count(); i++)
|
|
|
|
{
|
|
|
|
listener = (nsIEditActionListener *)mActionListeners->ElementAt(i);
|
|
|
|
if (listener)
|
|
|
|
{
|
|
|
|
nsIDOMNode *ptr = (aNewLeftNode) ? *aNewLeftNode : 0;
|
|
|
|
listener->DidSplitNode(aNode, aOffset, ptr, result);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-02-17 22:42:29 +03:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP nsEditor::CreateTxnForSplitNode(nsIDOMNode *aNode,
|
1999-02-12 20:18:58 +03:00
|
|
|
PRUint32 aOffset,
|
|
|
|
SplitElementTxn **aTxn)
|
|
|
|
{
|
|
|
|
nsresult result=NS_ERROR_NULL_POINTER;
|
|
|
|
if (nsnull != aNode)
|
|
|
|
{
|
|
|
|
result = TransactionFactory::GetNewTransaction(kSplitElementTxnIID, (EditTxn **)aTxn);
|
1999-02-15 21:25:30 +03:00
|
|
|
if (NS_SUCCEEDED(result)) {
|
1999-02-12 20:18:58 +03:00
|
|
|
result = (*aTxn)->Init(this, aNode, aOffset);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP
|
1999-03-16 19:38:09 +03:00
|
|
|
nsEditor::JoinNodes(nsIDOMNode * aLeftNode,
|
|
|
|
nsIDOMNode * aRightNode,
|
|
|
|
nsIDOMNode * aParent)
|
1999-02-17 22:42:29 +03:00
|
|
|
{
|
1999-04-27 21:14:28 +04:00
|
|
|
PRInt32 i;
|
|
|
|
nsIEditActionListener *listener;
|
|
|
|
|
|
|
|
if (mActionListeners)
|
|
|
|
{
|
|
|
|
for (i = 0; i < mActionListeners->Count(); i++)
|
|
|
|
{
|
|
|
|
listener = (nsIEditActionListener *)mActionListeners->ElementAt(i);
|
|
|
|
if (listener)
|
|
|
|
listener->WillJoinNodes(aLeftNode, aRightNode, aParent);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-02-17 22:42:29 +03:00
|
|
|
JoinElementTxn *txn;
|
1999-03-16 19:38:09 +03:00
|
|
|
nsresult result = CreateTxnForJoinNode(aLeftNode, aRightNode, &txn);
|
1999-02-17 22:42:29 +03:00
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
result = Do(txn);
|
|
|
|
}
|
1999-04-27 21:14:28 +04:00
|
|
|
|
|
|
|
if (mActionListeners)
|
|
|
|
{
|
|
|
|
for (i = 0; i < mActionListeners->Count(); i++)
|
|
|
|
{
|
|
|
|
listener = (nsIEditActionListener *)mActionListeners->ElementAt(i);
|
|
|
|
if (listener)
|
|
|
|
listener->DidJoinNodes(aLeftNode, aRightNode, aParent, result);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-02-17 22:42:29 +03:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP nsEditor::CreateTxnForJoinNode(nsIDOMNode *aLeftNode,
|
1999-03-16 19:38:09 +03:00
|
|
|
nsIDOMNode *aRightNode,
|
|
|
|
JoinElementTxn **aTxn)
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
|
|
|
nsresult result=NS_ERROR_NULL_POINTER;
|
|
|
|
if ((nsnull != aLeftNode) && (nsnull != aRightNode))
|
|
|
|
{
|
|
|
|
result = TransactionFactory::GetNewTransaction(kJoinElementTxnIID, (EditTxn **)aTxn);
|
1999-02-15 21:25:30 +03:00
|
|
|
if (NS_SUCCEEDED(result)) {
|
1999-02-12 20:18:58 +03:00
|
|
|
result = (*aTxn)->Init(this, aLeftNode, aRightNode);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-05-05 08:05:19 +04:00
|
|
|
|
|
|
|
// END nsEditor core implementation
|
|
|
|
|
|
|
|
// BEGIN nsEditor public static helper methods
|
|
|
|
|
|
|
|
nsresult
|
1999-02-17 22:42:29 +03:00
|
|
|
nsEditor::SplitNodeImpl(nsIDOMNode * aExistingRightNode,
|
|
|
|
PRInt32 aOffset,
|
|
|
|
nsIDOMNode* aNewLeftNode,
|
|
|
|
nsIDOMNode* aParent)
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
1999-04-04 22:01:35 +04:00
|
|
|
|
1999-04-15 10:06:33 +04:00
|
|
|
if (gNoisy) { printf("SplitNodeImpl: left=%p, right=%p, offset=%d\n", aNewLeftNode, aExistingRightNode, aOffset); }
|
1999-04-04 22:01:35 +04:00
|
|
|
|
1999-02-12 20:18:58 +03:00
|
|
|
nsresult result;
|
|
|
|
NS_ASSERTION(((nsnull!=aExistingRightNode) &&
|
|
|
|
(nsnull!=aNewLeftNode) &&
|
|
|
|
(nsnull!=aParent)),
|
|
|
|
"null arg");
|
|
|
|
if ((nsnull!=aExistingRightNode) &&
|
|
|
|
(nsnull!=aNewLeftNode) &&
|
|
|
|
(nsnull!=aParent))
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMNode> resultNode;
|
|
|
|
result = aParent->InsertBefore(aNewLeftNode, aExistingRightNode, getter_AddRefs(resultNode));
|
1999-04-04 22:01:35 +04:00
|
|
|
//printf(" after insert\n"); content->List(); // DEBUG
|
1999-02-12 20:18:58 +03:00
|
|
|
if (NS_SUCCEEDED(result))
|
|
|
|
{
|
|
|
|
// split the children between the 2 nodes
|
|
|
|
// at this point, aExistingRightNode has all the children
|
|
|
|
// move all the children whose index is < aOffset to aNewLeftNode
|
|
|
|
if (0<=aOffset) // don't bother unless we're going to move at least one child
|
|
|
|
{
|
1999-02-17 22:42:29 +03:00
|
|
|
// if it's a text node, just shuffle around some text
|
1999-03-03 01:27:46 +03:00
|
|
|
nsCOMPtr<nsIDOMCharacterData> rightNodeAsText( do_QueryInterface(aExistingRightNode) );
|
|
|
|
nsCOMPtr<nsIDOMCharacterData> leftNodeAsText( do_QueryInterface(aNewLeftNode) );
|
1999-02-17 22:42:29 +03:00
|
|
|
if (leftNodeAsText && rightNodeAsText)
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
1999-02-17 22:42:29 +03:00
|
|
|
// fix right node
|
|
|
|
nsString leftText;
|
|
|
|
rightNodeAsText->SubstringData(0, aOffset, leftText);
|
|
|
|
rightNodeAsText->DeleteData(0, aOffset);
|
|
|
|
// fix left node
|
|
|
|
leftNodeAsText->SetData(leftText);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{ // otherwise it's an interior node, so shuffle around the children
|
1999-04-04 22:01:35 +04:00
|
|
|
// go through list backwards so deletes don't interfere with the iteration
|
1999-02-17 22:42:29 +03:00
|
|
|
nsCOMPtr<nsIDOMNodeList> childNodes;
|
|
|
|
result = aExistingRightNode->GetChildNodes(getter_AddRefs(childNodes));
|
|
|
|
if ((NS_SUCCEEDED(result)) && (childNodes))
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
1999-04-04 22:01:35 +04:00
|
|
|
PRInt32 i=aOffset-1;
|
|
|
|
for ( ; ((NS_SUCCEEDED(result)) && (0<=i)); i--)
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
1999-02-17 22:42:29 +03:00
|
|
|
nsCOMPtr<nsIDOMNode> childNode;
|
|
|
|
result = childNodes->Item(i, getter_AddRefs(childNode));
|
|
|
|
if ((NS_SUCCEEDED(result)) && (childNode))
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
1999-02-17 22:42:29 +03:00
|
|
|
result = aExistingRightNode->RemoveChild(childNode, getter_AddRefs(resultNode));
|
1999-04-04 22:01:35 +04:00
|
|
|
//printf(" after remove\n"); content->List(); // DEBUG
|
1999-02-17 22:42:29 +03:00
|
|
|
if (NS_SUCCEEDED(result))
|
|
|
|
{
|
1999-04-04 22:01:35 +04:00
|
|
|
nsCOMPtr<nsIDOMNode> firstChild;
|
|
|
|
aNewLeftNode->GetFirstChild(getter_AddRefs(firstChild));
|
|
|
|
result = aNewLeftNode->InsertBefore(childNode, firstChild, getter_AddRefs(resultNode));
|
|
|
|
//printf(" after append\n"); content->List(); // DEBUG
|
1999-02-17 22:42:29 +03:00
|
|
|
}
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
|
|
|
}
|
1999-02-17 22:42:29 +03:00
|
|
|
}
|
|
|
|
}
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
result = NS_ERROR_INVALID_ARG;
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-05-05 08:05:19 +04:00
|
|
|
nsresult
|
1999-02-17 22:42:29 +03:00
|
|
|
nsEditor::JoinNodesImpl(nsIDOMNode * aNodeToKeep,
|
|
|
|
nsIDOMNode * aNodeToJoin,
|
|
|
|
nsIDOMNode * aParent,
|
|
|
|
PRBool aNodeToKeepIsFirst)
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
|
|
|
nsresult result;
|
|
|
|
NS_ASSERTION(((nsnull!=aNodeToKeep) &&
|
|
|
|
(nsnull!=aNodeToJoin) &&
|
|
|
|
(nsnull!=aParent)),
|
|
|
|
"null arg");
|
|
|
|
if ((nsnull!=aNodeToKeep) &&
|
|
|
|
(nsnull!=aNodeToJoin) &&
|
|
|
|
(nsnull!=aParent))
|
|
|
|
{
|
1999-02-17 22:42:29 +03:00
|
|
|
// if it's a text node, just shuffle around some text
|
1999-03-03 01:27:46 +03:00
|
|
|
nsCOMPtr<nsIDOMCharacterData> keepNodeAsText( do_QueryInterface(aNodeToKeep) );
|
|
|
|
nsCOMPtr<nsIDOMCharacterData> joinNodeAsText( do_QueryInterface(aNodeToJoin) );
|
1999-02-17 22:42:29 +03:00
|
|
|
if (keepNodeAsText && joinNodeAsText)
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
1999-02-17 22:42:29 +03:00
|
|
|
nsString rightText;
|
|
|
|
nsString leftText;
|
|
|
|
if (aNodeToKeepIsFirst)
|
|
|
|
{
|
|
|
|
keepNodeAsText->GetData(leftText);
|
|
|
|
joinNodeAsText->GetData(rightText);
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
1999-02-17 22:42:29 +03:00
|
|
|
else
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
1999-02-17 22:42:29 +03:00
|
|
|
keepNodeAsText->GetData(rightText);
|
|
|
|
joinNodeAsText->GetData(leftText);
|
|
|
|
}
|
|
|
|
leftText += rightText;
|
|
|
|
keepNodeAsText->SetData(leftText);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{ // otherwise it's an interior node, so shuffle around the children
|
|
|
|
nsCOMPtr<nsIDOMNodeList> childNodes;
|
|
|
|
result = aNodeToJoin->GetChildNodes(getter_AddRefs(childNodes));
|
|
|
|
if ((NS_SUCCEEDED(result)) && (childNodes))
|
|
|
|
{
|
1999-04-04 22:01:35 +04:00
|
|
|
PRInt32 i; // must be signed int!
|
1999-02-17 22:42:29 +03:00
|
|
|
PRUint32 childCount=0;
|
|
|
|
childNodes->GetLength(&childCount);
|
|
|
|
nsCOMPtr<nsIDOMNode> firstNode; //only used if aNodeToKeepIsFirst is false
|
|
|
|
if (PR_FALSE==aNodeToKeepIsFirst)
|
|
|
|
{ // remember the first child in aNodeToKeep, we'll insert all the children of aNodeToJoin in front of it
|
|
|
|
result = aNodeToKeep->GetFirstChild(getter_AddRefs(firstNode));
|
|
|
|
// GetFirstChild returns nsnull firstNode if aNodeToKeep has no children, that's ok.
|
|
|
|
}
|
|
|
|
nsCOMPtr<nsIDOMNode> resultNode;
|
1999-04-04 22:01:35 +04:00
|
|
|
// have to go through the list backwards to keep deletes from interfering with iteration
|
|
|
|
nsCOMPtr<nsIDOMNode> previousChild;
|
|
|
|
for (i=childCount-1; ((NS_SUCCEEDED(result)) && (0<=i)); i--)
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
1999-02-17 22:42:29 +03:00
|
|
|
nsCOMPtr<nsIDOMNode> childNode;
|
|
|
|
result = childNodes->Item(i, getter_AddRefs(childNode));
|
|
|
|
if ((NS_SUCCEEDED(result)) && (childNode))
|
|
|
|
{
|
|
|
|
if (PR_TRUE==aNodeToKeepIsFirst)
|
|
|
|
{ // append children of aNodeToJoin
|
1999-04-04 22:01:35 +04:00
|
|
|
//was result = aNodeToKeep->AppendChild(childNode, getter_AddRefs(resultNode));
|
|
|
|
result = aNodeToKeep->InsertBefore(childNode, previousChild, getter_AddRefs(resultNode));
|
|
|
|
previousChild = do_QueryInterface(childNode);
|
1999-02-17 22:42:29 +03:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{ // prepend children of aNodeToJoin
|
1999-04-04 22:01:35 +04:00
|
|
|
//was result = aNodeToKeep->InsertBefore(childNode, firstNode, getter_AddRefs(resultNode));
|
1999-02-17 22:42:29 +03:00
|
|
|
result = aNodeToKeep->InsertBefore(childNode, firstNode, getter_AddRefs(resultNode));
|
1999-04-04 22:01:35 +04:00
|
|
|
firstNode = do_QueryInterface(childNode);
|
1999-02-17 22:42:29 +03:00
|
|
|
}
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
1999-02-17 22:42:29 +03:00
|
|
|
else if (!childNodes) {
|
|
|
|
result = NS_ERROR_NULL_POINTER;
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
|
|
|
}
|
1999-02-17 22:42:29 +03:00
|
|
|
if (NS_SUCCEEDED(result))
|
|
|
|
{ // delete the extra node
|
|
|
|
nsCOMPtr<nsIDOMNode> resultNode;
|
|
|
|
result = aParent->RemoveChild(aNodeToJoin, getter_AddRefs(resultNode));
|
|
|
|
}
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
|
|
|
else
|
|
|
|
result = NS_ERROR_INVALID_ARG;
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-05-05 08:05:19 +04:00
|
|
|
nsresult
|
|
|
|
nsEditor::GetChildOffset(nsIDOMNode *aChild, nsIDOMNode *aParent, PRInt32 &aOffset)
|
1999-02-22 18:53:31 +03:00
|
|
|
{
|
|
|
|
NS_ASSERTION((aChild && aParent), "bad args");
|
|
|
|
nsresult result = NS_ERROR_NULL_POINTER;
|
|
|
|
if (aChild && aParent)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMNodeList> childNodes;
|
|
|
|
result = aParent->GetChildNodes(getter_AddRefs(childNodes));
|
|
|
|
if ((NS_SUCCEEDED(result)) && (childNodes))
|
|
|
|
{
|
|
|
|
PRInt32 i=0;
|
|
|
|
for ( ; NS_SUCCEEDED(result); i++)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMNode> childNode;
|
|
|
|
result = childNodes->Item(i, getter_AddRefs(childNode));
|
|
|
|
if ((NS_SUCCEEDED(result)) && (childNode))
|
|
|
|
{
|
|
|
|
if (childNode.get()==aChild)
|
|
|
|
{
|
|
|
|
aOffset = i;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (!childNode)
|
|
|
|
result = NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (!childNodes)
|
|
|
|
result = NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-05-05 08:05:19 +04:00
|
|
|
// returns the number of things inside aNode.
|
|
|
|
// If aNode is text, returns number of characters. If not, returns number of children nodes.
|
|
|
|
nsresult
|
|
|
|
nsEditor::GetLengthOfDOMNode(nsIDOMNode *aNode, PRUint32 &aCount)
|
1999-03-14 03:31:35 +03:00
|
|
|
{
|
1999-05-05 08:05:19 +04:00
|
|
|
aCount = 0;
|
|
|
|
if (!aNode) { return NS_ERROR_NULL_POINTER; }
|
|
|
|
nsresult result=NS_OK;
|
|
|
|
nsCOMPtr<nsIDOMCharacterData>nodeAsChar;
|
|
|
|
nodeAsChar = do_QueryInterface(aNode);
|
|
|
|
if (nodeAsChar) {
|
|
|
|
nodeAsChar->GetLength(&aCount);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
PRBool hasChildNodes;
|
|
|
|
aNode->HasChildNodes(&hasChildNodes);
|
|
|
|
if (PR_TRUE==hasChildNodes)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMNodeList>nodeList;
|
|
|
|
result = aNode->GetChildNodes(getter_AddRefs(nodeList));
|
|
|
|
if (NS_SUCCEEDED(result) && nodeList) {
|
|
|
|
nodeList->GetLength(&aCount);
|
1999-03-14 03:31:35 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
1999-05-05 08:05:19 +04:00
|
|
|
return result;
|
1999-03-14 03:31:35 +03:00
|
|
|
}
|
|
|
|
|
1999-05-05 08:05:19 +04:00
|
|
|
// content-based inline vs. block query
|
|
|
|
nsresult
|
|
|
|
nsEditor::IsNodeInline(nsIDOMNode *aNode, PRBool &aIsInline)
|
1999-03-02 08:30:53 +03:00
|
|
|
{
|
1999-05-05 08:05:19 +04:00
|
|
|
// this is a content-based implementation
|
|
|
|
if (!aNode) { return NS_ERROR_NULL_POINTER; }
|
|
|
|
|
|
|
|
nsresult result;
|
|
|
|
aIsInline = PR_FALSE;
|
|
|
|
nsCOMPtr<nsIDOMElement>element;
|
|
|
|
element = do_QueryInterface(aNode);
|
|
|
|
if (element)
|
1999-03-02 08:30:53 +03:00
|
|
|
{
|
1999-05-05 08:05:19 +04:00
|
|
|
nsAutoString tag;
|
|
|
|
result = element->GetTagName(tag);
|
|
|
|
if (NS_SUCCEEDED(result))
|
|
|
|
{
|
|
|
|
nsIAtom *tagAtom = NS_NewAtom(tag);
|
|
|
|
if (!tagAtom) { return NS_ERROR_NULL_POINTER; }
|
|
|
|
if (tagAtom==nsIEditProperty::a ||
|
|
|
|
tagAtom==nsIEditProperty::b ||
|
|
|
|
tagAtom==nsIEditProperty::big ||
|
|
|
|
tagAtom==nsIEditProperty::font ||
|
|
|
|
tagAtom==nsIEditProperty::i ||
|
|
|
|
tagAtom==nsIEditProperty::span ||
|
|
|
|
tagAtom==nsIEditProperty::small ||
|
|
|
|
tagAtom==nsIEditProperty::strike ||
|
|
|
|
tagAtom==nsIEditProperty::sub ||
|
|
|
|
tagAtom==nsIEditProperty::sup ||
|
|
|
|
tagAtom==nsIEditProperty::tt ||
|
|
|
|
tagAtom==nsIEditProperty::u )
|
|
|
|
{
|
|
|
|
aIsInline = PR_TRUE;
|
1999-03-02 08:30:53 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
1999-05-05 08:05:19 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsEditor::GetBlockParent(nsIDOMNode *aNode, nsIDOMElement **aBlockParent)
|
|
|
|
{
|
|
|
|
nsresult result = NS_OK;
|
|
|
|
if (!aBlockParent) {return NS_ERROR_NULL_POINTER;}
|
|
|
|
*aBlockParent = nsnull;
|
|
|
|
nsCOMPtr<nsIDOMNode>parent;
|
|
|
|
nsCOMPtr<nsIDOMNode>temp;
|
|
|
|
result = aNode->GetParentNode(getter_AddRefs(parent));
|
|
|
|
while (NS_SUCCEEDED(result) && parent)
|
|
|
|
{
|
|
|
|
PRBool isInline;
|
|
|
|
result = IsNodeInline(parent, isInline);
|
|
|
|
if (PR_FALSE==isInline)
|
|
|
|
{
|
|
|
|
parent->QueryInterface(nsIDOMElement::GetIID(), (void**)aBlockParent);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
result = parent->GetParentNode(getter_AddRefs(temp));
|
|
|
|
parent = do_QueryInterface(temp);
|
|
|
|
}
|
|
|
|
if (gNoisy) { printf("GetBlockParent for %p returning parent %p\n", aNode, *aBlockParent); }
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsEditor::GetBlockSection(nsIDOMNode *aChild,
|
|
|
|
nsIDOMNode **aLeftNode,
|
|
|
|
nsIDOMNode **aRightNode)
|
|
|
|
{
|
|
|
|
nsresult result = NS_OK;
|
|
|
|
if (!aChild || !aLeftNode || !aRightNode) {return NS_ERROR_NULL_POINTER;}
|
|
|
|
*aLeftNode = aChild;
|
|
|
|
*aRightNode = aChild;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMNode>sibling;
|
|
|
|
result = aChild->GetPreviousSibling(getter_AddRefs(sibling));
|
|
|
|
while ((NS_SUCCEEDED(result)) && sibling)
|
|
|
|
{
|
|
|
|
PRBool isInline;
|
|
|
|
IsNodeInline(sibling, isInline);
|
|
|
|
if (PR_FALSE==isInline)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMCharacterData>nodeAsText = do_QueryInterface(sibling);
|
|
|
|
if (!nodeAsText) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
// XXX: needs some logic to work for other leaf nodes besides text!
|
|
|
|
}
|
|
|
|
*aLeftNode = sibling;
|
|
|
|
result = (*aLeftNode)->GetPreviousSibling(getter_AddRefs(sibling));
|
|
|
|
}
|
|
|
|
NS_ADDREF((*aLeftNode));
|
|
|
|
// now do the right side
|
|
|
|
result = aChild->GetNextSibling(getter_AddRefs(sibling));
|
|
|
|
while ((NS_SUCCEEDED(result)) && sibling)
|
|
|
|
{
|
|
|
|
PRBool isInline;
|
|
|
|
IsNodeInline(sibling, isInline);
|
|
|
|
if (PR_FALSE==isInline)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMCharacterData>nodeAsText = do_QueryInterface(sibling);
|
|
|
|
if (!nodeAsText) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
*aRightNode = sibling;
|
|
|
|
result = (*aRightNode)->GetNextSibling(getter_AddRefs(sibling));
|
|
|
|
}
|
|
|
|
NS_ADDREF((*aRightNode));
|
|
|
|
if (gNoisy) { printf("GetBlockSection returning %p %p\n",
|
|
|
|
(*aLeftNode), (*aRightNode)); }
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsEditor::GetBlockSectionsForRange(nsIDOMRange *aRange, nsISupportsArray *aSections)
|
|
|
|
{
|
|
|
|
if (!aRange || !aSections) {return NS_ERROR_NULL_POINTER;}
|
|
|
|
|
|
|
|
nsresult result;
|
|
|
|
nsCOMPtr<nsIContentIterator>iter;
|
|
|
|
result = nsComponentManager::CreateInstance(kCContentIteratorCID, nsnull,
|
|
|
|
kIContentIteratorIID, getter_AddRefs(iter));
|
|
|
|
if ((NS_SUCCEEDED(result)) && iter)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMRange> lastRange;
|
|
|
|
iter->Init(aRange);
|
|
|
|
nsCOMPtr<nsIContent> currentContent;
|
|
|
|
iter->CurrentNode(getter_AddRefs(currentContent));
|
|
|
|
while (NS_COMFALSE == iter->IsDone())
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMNode>currentNode = do_QueryInterface(currentContent);
|
|
|
|
if (currentNode)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIAtom> currentContentTag;
|
|
|
|
currentContent->GetTag(*getter_AddRefs(currentContentTag));
|
|
|
|
// <BR> divides block content ranges. We can achieve this by nulling out lastRange
|
|
|
|
if (nsIEditProperty::br==currentContentTag)
|
|
|
|
{
|
|
|
|
lastRange = do_QueryInterface(nsnull);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
PRBool isInlineOrText;
|
|
|
|
result = IsNodeInline(currentNode, isInlineOrText);
|
|
|
|
if (PR_FALSE==isInlineOrText)
|
|
|
|
{
|
|
|
|
PRUint16 nodeType;
|
|
|
|
currentNode->GetNodeType(&nodeType);
|
|
|
|
if (nsIDOMNode::TEXT_NODE == nodeType) {
|
|
|
|
isInlineOrText = PR_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (PR_TRUE==isInlineOrText)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMNode>leftNode;
|
|
|
|
nsCOMPtr<nsIDOMNode>rightNode;
|
|
|
|
result = GetBlockSection(currentNode,
|
|
|
|
getter_AddRefs(leftNode),
|
|
|
|
getter_AddRefs(rightNode));
|
|
|
|
if (gNoisy) {printf("currentNode %p has block content (%p,%p)\n", currentNode.get(), leftNode.get(), rightNode.get());}
|
|
|
|
if ((NS_SUCCEEDED(result)) && leftNode && rightNode)
|
|
|
|
{
|
|
|
|
// add range to the list if it doesn't overlap with the previous range
|
|
|
|
PRBool addRange=PR_TRUE;
|
|
|
|
if (lastRange)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMNode> lastStartNode;
|
|
|
|
nsCOMPtr<nsIDOMElement> blockParentOfLastStartNode;
|
|
|
|
lastRange->GetStartParent(getter_AddRefs(lastStartNode));
|
|
|
|
result = GetBlockParent(lastStartNode, getter_AddRefs(blockParentOfLastStartNode));
|
|
|
|
if ((NS_SUCCEEDED(result)) && blockParentOfLastStartNode)
|
|
|
|
{
|
|
|
|
if (gNoisy) {printf("lastStartNode %p has block parent %p\n", lastStartNode.get(), blockParentOfLastStartNode.get());}
|
|
|
|
nsCOMPtr<nsIDOMElement> blockParentOfLeftNode;
|
|
|
|
result = GetBlockParent(leftNode, getter_AddRefs(blockParentOfLeftNode));
|
|
|
|
if ((NS_SUCCEEDED(result)) && blockParentOfLeftNode)
|
|
|
|
{
|
|
|
|
if (gNoisy) {printf("leftNode %p has block parent %p\n", leftNode.get(), blockParentOfLeftNode.get());}
|
|
|
|
if (blockParentOfLastStartNode==blockParentOfLeftNode) {
|
|
|
|
addRange = PR_FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (PR_TRUE==addRange)
|
|
|
|
{
|
|
|
|
if (gNoisy) {printf("adding range, setting lastRange with start node %p\n", leftNode.get());}
|
|
|
|
nsCOMPtr<nsIDOMRange> range;
|
|
|
|
result = nsComponentManager::CreateInstance(kCRangeCID, nsnull,
|
|
|
|
kIDOMRangeIID, getter_AddRefs(range));
|
|
|
|
if ((NS_SUCCEEDED(result)) && range)
|
|
|
|
{ // initialize the range
|
|
|
|
range->SetStart(leftNode, 0);
|
|
|
|
range->SetEnd(rightNode, 0);
|
|
|
|
aSections->AppendElement(range);
|
|
|
|
lastRange = do_QueryInterface(range);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* 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 result;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsEditor::IntermediateNodesAreInline(nsIDOMRange *aRange,
|
|
|
|
nsIDOMNode *aStartNode,
|
|
|
|
PRInt32 aStartOffset,
|
|
|
|
nsIDOMNode *aEndNode,
|
|
|
|
PRInt32 aEndOffset,
|
|
|
|
PRBool &aResult)
|
|
|
|
{
|
|
|
|
aResult = PR_TRUE; // init out param. we assume the condition is true unless we find a node that violates it
|
|
|
|
if (!aStartNode || !aEndNode || !aRange) { return NS_ERROR_NULL_POINTER; }
|
|
|
|
|
|
|
|
nsCOMPtr<nsIContentIterator>iter;
|
|
|
|
nsresult result;
|
|
|
|
result = nsComponentManager::CreateInstance(kCContentIteratorCID, nsnull,
|
|
|
|
kIContentIteratorIID, getter_AddRefs(iter));
|
|
|
|
//XXX: maybe CreateInstance is expensive, and I should keep around a static iter?
|
|
|
|
// as long as this method can't be called recursively or re-entrantly!
|
|
|
|
|
|
|
|
if ((NS_SUCCEEDED(result)) && iter)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIContent>startContent;
|
|
|
|
startContent = do_QueryInterface(aStartNode);
|
|
|
|
nsCOMPtr<nsIContent>endContent;
|
|
|
|
endContent = do_QueryInterface(aEndNode);
|
|
|
|
if (startContent && endContent)
|
|
|
|
{
|
|
|
|
iter->Init(aRange);
|
|
|
|
nsCOMPtr<nsIContent> content;
|
|
|
|
iter->CurrentNode(getter_AddRefs(content));
|
|
|
|
while (NS_COMFALSE == iter->IsDone())
|
|
|
|
{
|
|
|
|
if ((content.get() != startContent.get()) &&
|
|
|
|
(content.get() != endContent.get()))
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMNode>currentNode;
|
|
|
|
currentNode = do_QueryInterface(content);
|
|
|
|
PRBool isInline=PR_FALSE;
|
|
|
|
IsNodeInline(currentNode, isInline);
|
|
|
|
if (PR_FALSE==isInline)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMCharacterData>nodeAsText;
|
|
|
|
nodeAsText = do_QueryInterface(currentNode);
|
|
|
|
if (!nodeAsText) // text nodes don't count in this check, so ignore them
|
|
|
|
{
|
|
|
|
aResult = PR_FALSE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* 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(content));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsEditor::GetPriorNode(nsIDOMNode *aCurrentNode, nsIDOMNode **aResultNode)
|
|
|
|
{
|
|
|
|
nsresult result;
|
|
|
|
*aResultNode = nsnull;
|
|
|
|
// if aCurrentNode has a left sibling, return that sibling's rightmost child (or itself if it has no children)
|
|
|
|
result = aCurrentNode->GetPreviousSibling(aResultNode);
|
|
|
|
if ((NS_SUCCEEDED(result)) && *aResultNode)
|
|
|
|
return GetRightmostChild(*aResultNode, aResultNode);
|
|
|
|
|
|
|
|
// otherwise, walk up the parent change until there is a child that comes before
|
|
|
|
// the ancestor of aCurrentNode. Then return that node's rightmost child
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMNode> parent(do_QueryInterface(aCurrentNode));
|
|
|
|
do {
|
|
|
|
nsCOMPtr<nsIDOMNode> node(parent);
|
|
|
|
result = node->GetParentNode(getter_AddRefs(parent));
|
|
|
|
if ((NS_SUCCEEDED(result)) && parent)
|
|
|
|
{
|
|
|
|
result = parent->GetPreviousSibling(getter_AddRefs(node));
|
|
|
|
if ((NS_SUCCEEDED(result)) && node)
|
|
|
|
{
|
|
|
|
|
|
|
|
return GetRightmostChild(node, aResultNode);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} while ((NS_SUCCEEDED(result)) && parent);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsEditor::GetNextNode(nsIDOMNode *aCurrentNode, nsIDOMNode **aResultNode)
|
|
|
|
{
|
|
|
|
nsresult result;
|
|
|
|
*aResultNode = nsnull;
|
|
|
|
// if aCurrentNode has a right sibling, return that sibling's leftmost child (or itself if it has no children)
|
|
|
|
result = aCurrentNode->GetNextSibling(aResultNode);
|
|
|
|
if ((NS_SUCCEEDED(result)) && *aResultNode)
|
|
|
|
return GetLeftmostChild(*aResultNode, aResultNode);
|
|
|
|
|
|
|
|
// otherwise, walk up the parent change until there is a child that comes before
|
|
|
|
// the ancestor of aCurrentNode. Then return that node's rightmost child
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMNode> parent(do_QueryInterface(aCurrentNode));
|
|
|
|
do {
|
|
|
|
nsCOMPtr<nsIDOMNode> node(parent);
|
|
|
|
result = node->GetParentNode(getter_AddRefs(parent));
|
|
|
|
if ((NS_SUCCEEDED(result)) && parent)
|
|
|
|
{
|
|
|
|
result = parent->GetNextSibling(getter_AddRefs(node));
|
|
|
|
if ((NS_SUCCEEDED(result)) && node)
|
|
|
|
{
|
|
|
|
return GetLeftmostChild(node, aResultNode);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} while ((NS_SUCCEEDED(result)) && parent);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsEditor::GetRightmostChild(nsIDOMNode *aCurrentNode, nsIDOMNode **aResultNode)
|
|
|
|
{
|
|
|
|
nsresult result = NS_OK;
|
|
|
|
nsCOMPtr<nsIDOMNode> resultNode(do_QueryInterface(aCurrentNode));
|
|
|
|
PRBool hasChildren;
|
|
|
|
resultNode->HasChildNodes(&hasChildren);
|
|
|
|
while ((NS_SUCCEEDED(result)) && (PR_TRUE==hasChildren))
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMNode> temp(resultNode);
|
|
|
|
temp->GetLastChild(getter_AddRefs(resultNode));
|
|
|
|
resultNode->HasChildNodes(&hasChildren);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
*aResultNode = resultNode;
|
|
|
|
NS_ADDREF(*aResultNode);
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsEditor::GetLeftmostChild(nsIDOMNode *aCurrentNode, nsIDOMNode **aResultNode)
|
|
|
|
{
|
|
|
|
nsresult result = NS_OK;
|
|
|
|
nsCOMPtr<nsIDOMNode> resultNode(do_QueryInterface(aCurrentNode));
|
|
|
|
PRBool hasChildren;
|
|
|
|
resultNode->HasChildNodes(&hasChildren);
|
|
|
|
while ((NS_SUCCEEDED(result)) && (PR_TRUE==hasChildren))
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMNode> temp(resultNode);
|
|
|
|
temp->GetFirstChild(getter_AddRefs(resultNode));
|
|
|
|
resultNode->HasChildNodes(&hasChildren);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
*aResultNode = resultNode;
|
|
|
|
NS_ADDREF(*aResultNode);
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
PRBool
|
|
|
|
nsEditor::NodeIsType(nsIDOMNode *aNode, nsIAtom *aTag)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMElement>element;
|
|
|
|
element = do_QueryInterface(aNode);
|
|
|
|
if (element)
|
|
|
|
{
|
|
|
|
nsAutoString tag;
|
|
|
|
element->GetTagName(tag);
|
|
|
|
if (tag.Equals(aTag->GetUnicode()))
|
|
|
|
{
|
|
|
|
return PR_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return PR_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
PRBool
|
|
|
|
nsEditor::IsEditable(nsIDOMNode *aNode)
|
|
|
|
{
|
|
|
|
if (!aNode) return PR_FALSE;
|
|
|
|
nsCOMPtr<nsIDOMElement>element;
|
|
|
|
element = do_QueryInterface(aNode);
|
|
|
|
if (element)
|
|
|
|
{
|
|
|
|
nsAutoString att(kMOZEditorBogusNodeAttr);
|
|
|
|
nsAutoString val;
|
|
|
|
(void)element->GetAttribute(att, val);
|
|
|
|
if (val.Equals(kMOZEditorBogusNodeValue)) {
|
|
|
|
return PR_FALSE;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
return PR_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMCharacterData>text;
|
|
|
|
text = do_QueryInterface(aNode);
|
|
|
|
if (text)
|
|
|
|
{
|
|
|
|
nsAutoString data;
|
|
|
|
text->GetData(data);
|
|
|
|
PRUint32 length = data.Length();
|
|
|
|
if (0==length) {
|
|
|
|
return PR_FALSE;
|
|
|
|
}
|
|
|
|
// if the node contains only newlines, it's not editable
|
|
|
|
PRUint32 i;
|
|
|
|
for (i=0; i<length; i++)
|
|
|
|
{
|
|
|
|
if ('\n'!=data.CharAt(0)) {
|
|
|
|
return PR_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return PR_FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return PR_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
//END nsEditor static utility methods
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void nsEditor::HACKForceRedraw()
|
|
|
|
{
|
|
|
|
#ifdef HACK_FORCE_REDRAW
|
|
|
|
// XXXX: Horrible hack! We are doing this because
|
|
|
|
// of an error in Gecko which is not rendering the
|
|
|
|
// document after a change via the DOM - gpk 2/11/99
|
|
|
|
// BEGIN HACK!!!
|
|
|
|
nsCOMPtr<nsIPresShell> shell;
|
|
|
|
|
|
|
|
GetPresShell(getter_AddRefs(shell));
|
|
|
|
if (shell) {
|
|
|
|
nsCOMPtr<nsIViewManager> viewmgr;
|
|
|
|
|
|
|
|
shell->GetViewManager(getter_AddRefs(viewmgr));
|
|
|
|
if (viewmgr) {
|
|
|
|
nsIView* view;
|
|
|
|
viewmgr->GetRootView(view); // views are not refCounted
|
|
|
|
if (view) {
|
|
|
|
viewmgr->UpdateView(view,nsnull,NS_VMREFRESH_IMMEDIATE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// END HACK
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
NS_IMETHODIMP nsEditor::GetLayoutObject(nsIDOMNode *aNode, nsISupports **aLayoutObject)
|
|
|
|
{
|
|
|
|
nsresult result = NS_ERROR_FAILURE; // we return an error unless we get the index
|
|
|
|
if( mPresShell != nsnull )
|
|
|
|
{
|
|
|
|
if ((nsnull!=aNode))
|
|
|
|
{ // get the content interface
|
|
|
|
nsCOMPtr<nsIContent> nodeAsContent( do_QueryInterface(aNode) );
|
|
|
|
if (nodeAsContent)
|
|
|
|
{ // get the frame from the content interface
|
|
|
|
nsISupports *layoutObject=nsnull; // frames are not ref counted, so don't use an nsCOMPtr
|
|
|
|
*aLayoutObject = nsnull;
|
|
|
|
return (NS_SUCCEEDED(mPresShell->GetLayoutObjectFor(nodeAsContent, &layoutObject)));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
result = NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
1999-03-02 08:30:53 +03:00
|
|
|
}
|
1999-02-12 20:18:58 +03:00
|
|
|
|
1999-05-04 02:57:48 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsEditor::BeginComposition(void)
|
|
|
|
{
|
|
|
|
|
|
|
|
if ((nsITransactionManager *)nsnull!=mTxnMgr.get())
|
|
|
|
{
|
|
|
|
#ifdef DEBUG_tague
|
|
|
|
printf("nsEditor::StartComposition -- begin batch.\n");
|
|
|
|
#endif
|
|
|
|
mTxnMgr->BeginBatch();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!mIMESelectionRange)
|
|
|
|
{
|
|
|
|
nsresult result = nsComponentManager::CreateInstance(kCDOMRangeCID, nsnull,
|
|
|
|
nsIDOMRange::GetIID(),
|
|
|
|
getter_AddRefs(mIMESelectionRange));
|
|
|
|
if (NS_FAILED(result))
|
|
|
|
{
|
|
|
|
mTxnMgr->EndBatch();
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
mIMEFirstTransaction=PR_TRUE;
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsEditor::EndComposition(void)
|
|
|
|
{
|
|
|
|
if ((nsITransactionManager *)nsnull!=mTxnMgr.get())
|
|
|
|
{
|
|
|
|
#ifdef DEBUG_tague
|
|
|
|
printf("nsEditor::EndComposition -- end batch.\n");
|
|
|
|
#endif
|
|
|
|
mTxnMgr->EndBatch();
|
|
|
|
mIMEFirstTransaction=PR_TRUE;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
// mIMESelectionRange = nsCOMPtr<nsIDOMRange>();
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsEditor::SetCompositionString(const nsString& aCompositionString)
|
|
|
|
{
|
|
|
|
|
|
|
|
if (mIMEFirstTransaction==PR_TRUE) {
|
|
|
|
mIMEFirstTransaction = PR_FALSE;
|
|
|
|
} else {
|
|
|
|
// printf("Undo!\n");
|
|
|
|
// mTxnMgr->Undo();
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMSelection> selection;
|
|
|
|
nsresult result;
|
|
|
|
|
|
|
|
result = mPresShell->GetSelection(getter_AddRefs(selection));
|
|
|
|
|
|
|
|
if (NS_FAILED(result))
|
|
|
|
{
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMNode> node;
|
|
|
|
PRInt32 offset;
|
|
|
|
|
|
|
|
result = mIMESelectionRange->GetStartParent(getter_AddRefs(node));
|
|
|
|
result = mIMESelectionRange->GetStartOffset(&offset);
|
|
|
|
|
|
|
|
result = selection->Collapse(node, offset);
|
|
|
|
|
|
|
|
|
|
|
|
result = mIMESelectionRange->GetEndParent(getter_AddRefs(node));
|
|
|
|
result = mIMESelectionRange->GetEndOffset(&offset);
|
|
|
|
|
|
|
|
result = selection->Extend(node, offset);
|
|
|
|
}
|
|
|
|
#ifdef DEBUG_tague
|
|
|
|
printf("nsEditor::SetCompositionString: string=%s\n",aCompositionString);
|
|
|
|
#endif
|
|
|
|
return SetPreeditText(aCompositionString);
|
|
|
|
}
|
|
|
|
|
1999-04-04 22:01:35 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsEditor::DebugDumpContent() const
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIContent>content;
|
|
|
|
nsCOMPtr<nsIDOMNodeList>nodeList;
|
|
|
|
nsAutoString bodyTag = "body";
|
|
|
|
mDoc->GetElementsByTagName(bodyTag, getter_AddRefs(nodeList));
|
|
|
|
if (nodeList)
|
|
|
|
{
|
|
|
|
PRUint32 count;
|
|
|
|
nodeList->GetLength(&count);
|
|
|
|
NS_ASSERTION(1==count, "there is not exactly 1 body in the document!");
|
|
|
|
nsCOMPtr<nsIDOMNode>bodyNode;
|
|
|
|
nodeList->Item(0, getter_AddRefs(bodyNode));
|
|
|
|
if (bodyNode) {
|
|
|
|
content = do_QueryInterface(bodyNode);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
content->List();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-05-05 08:05:19 +04:00
|
|
|
nsresult
|
|
|
|
nsEditor::GetFirstNodeOfType(nsIDOMNode *aStartNode,
|
|
|
|
const nsString &aTag,
|
|
|
|
nsIDOMNode **aResult)
|
|
|
|
{
|
|
|
|
nsresult result=NS_OK;
|
1999-02-12 20:18:58 +03:00
|
|
|
|
1999-05-05 08:05:19 +04:00
|
|
|
if (!aStartNode)
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
if (!aResult)
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMElement> element;
|
|
|
|
*aResult = nsnull;
|
|
|
|
nsCOMPtr<nsIDOMNode> childNode;
|
|
|
|
result = aStartNode->GetFirstChild(getter_AddRefs(childNode));
|
|
|
|
while (childNode)
|
|
|
|
{
|
|
|
|
result = childNode->QueryInterface(kIDOMNodeIID,getter_AddRefs(element));
|
|
|
|
nsAutoString tag;
|
|
|
|
if (NS_SUCCEEDED(result) && (element))
|
|
|
|
{
|
|
|
|
element->GetTagName(tag);
|
|
|
|
if (PR_TRUE==aTag.Equals(tag))
|
|
|
|
{
|
|
|
|
return (childNode->QueryInterface(kIDOMNodeIID,(void **) aResult)); // does the addref
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
nsresult result = GetFirstNodeOfType(childNode, aTag, aResult);
|
|
|
|
if (nsnull!=*aResult)
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
nsCOMPtr<nsIDOMNode> temp = childNode;
|
|
|
|
temp->GetNextSibling(getter_AddRefs(childNode));
|
|
|
|
}
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
1999-03-02 08:30:53 +03:00
|
|
|
|
1999-05-05 08:05:19 +04:00
|
|
|
nsresult
|
|
|
|
nsEditor::GetFirstTextNode(nsIDOMNode *aNode, nsIDOMNode **aRetNode)
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
1999-05-05 08:05:19 +04:00
|
|
|
if (!aNode || !aRetNode)
|
|
|
|
{
|
|
|
|
NS_NOTREACHED("GetFirstTextNode Failed");
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
|
|
|
|
|
|
|
PRUint16 mType;
|
|
|
|
PRBool mCNodes;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMNode> answer;
|
|
|
|
|
|
|
|
aNode->GetNodeType(&mType);
|
|
|
|
|
|
|
|
if (nsIDOMNode::ELEMENT_NODE == mType) {
|
|
|
|
if (NS_SUCCEEDED(aNode->HasChildNodes(&mCNodes)) && PR_TRUE == mCNodes)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMNode> node1;
|
|
|
|
nsCOMPtr<nsIDOMNode> node2;
|
|
|
|
|
|
|
|
if (!NS_SUCCEEDED(aNode->GetFirstChild(getter_AddRefs(node1))))
|
|
|
|
{
|
|
|
|
NS_NOTREACHED("GetFirstTextNode Failed");
|
|
|
|
}
|
|
|
|
while(!answer && node1)
|
|
|
|
{
|
|
|
|
GetFirstTextNode(node1, getter_AddRefs(answer));
|
|
|
|
node1->GetNextSibling(getter_AddRefs(node2));
|
|
|
|
node1 = node2;
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
1999-05-05 08:05:19 +04:00
|
|
|
else if (nsIDOMNode::TEXT_NODE == mType) {
|
|
|
|
answer = do_QueryInterface(aNode);
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
1999-05-05 08:05:19 +04:00
|
|
|
|
|
|
|
// OK, now return the answer, if any
|
|
|
|
*aRetNode = answer;
|
|
|
|
if (*aRetNode)
|
|
|
|
NS_IF_ADDREF(*aRetNode);
|
|
|
|
else
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
return NS_OK;
|
1999-02-12 20:18:58 +03:00
|
|
|
}
|
|
|
|
|
1999-05-05 08:05:19 +04:00
|
|
|
|
|
|
|
//END nsEditor Private methods
|
1999-02-12 20:18:58 +03:00
|
|
|
|
1999-05-04 02:57:48 +04:00
|
|
|
NS_IMETHODIMP nsEditor::DoInitialPreeeditInsert(const nsString& aStringToInsert)
|
|
|
|
{
|
|
|
|
if (!mDoc) {
|
|
|
|
return NS_ERROR_NOT_INITIALIZED;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMNodeList>nodeList;
|
|
|
|
nsAutoString bodyTag = "body";
|
|
|
|
nsresult result = mDoc->GetElementsByTagName(bodyTag, getter_AddRefs(nodeList));
|
|
|
|
if ((NS_SUCCEEDED(result)) && nodeList)
|
|
|
|
{
|
|
|
|
PRUint32 count;
|
|
|
|
nodeList->GetLength(&count);
|
|
|
|
NS_ASSERTION(1==count, "there is not exactly 1 body in the document!");
|
|
|
|
nsCOMPtr<nsIDOMNode>node;
|
|
|
|
result = nodeList->Item(0, getter_AddRefs(node));
|
|
|
|
if ((NS_SUCCEEDED(result)) && node)
|
|
|
|
{ // now we've got the body tag.
|
|
|
|
// create transaction to insert the text node,
|
|
|
|
// and create a transaction to insert the text
|
|
|
|
CreateElementTxn *txn;
|
|
|
|
result = CreateTxnForCreateElement(GetTextNodeTag(), node, 0, &txn);
|
|
|
|
if ((NS_SUCCEEDED(result)) && txn)
|
|
|
|
{
|
|
|
|
result = Do(txn);
|
|
|
|
if (NS_SUCCEEDED(result))
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMNode>newNode;
|
|
|
|
txn->GetNewNode(getter_AddRefs(newNode));
|
|
|
|
if ((NS_SUCCEEDED(result)) && newNode)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMCharacterData>newTextNode;
|
|
|
|
newTextNode = do_QueryInterface(newNode);
|
|
|
|
if (newTextNode)
|
|
|
|
{
|
|
|
|
InsertTextTxn *insertTxn;
|
|
|
|
result = CreateTxnForInsertText(aStringToInsert, newTextNode, &insertTxn);
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
result = Do(insertTxn);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
result = NS_ERROR_UNEXPECTED;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsEditor::SetPreeditText(const nsString& aStringToInsert)
|
|
|
|
{
|
|
|
|
nsresult result;
|
|
|
|
|
|
|
|
EditAggregateTxn *aggTxn = nsnull;
|
|
|
|
// Create the "delete current selection" txn
|
|
|
|
nsCOMPtr<nsIDOMSelection> selection;
|
|
|
|
|
|
|
|
BeginTransaction();
|
|
|
|
|
|
|
|
result = mPresShell->GetSelection(getter_AddRefs(selection));
|
|
|
|
|
|
|
|
if (NS_SUCCEEDED(result) && selection)
|
|
|
|
{
|
|
|
|
PRBool collapsed;
|
|
|
|
result = selection->GetIsCollapsed(&collapsed);
|
|
|
|
if (NS_SUCCEEDED(result) && !collapsed) {
|
|
|
|
EditAggregateTxn *delSelTxn;
|
|
|
|
result = CreateTxnForDeleteSelection(nsIEditor::eLTR, &delSelTxn);
|
|
|
|
if (NS_SUCCEEDED(result) && delSelTxn) {
|
|
|
|
result = Do(delSelTxn);
|
|
|
|
|
|
|
|
if (NS_FAILED(result)) {
|
|
|
|
EndTransaction();
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
1999-02-12 20:18:58 +03:00
|
|
|
|
1999-05-04 02:57:48 +04:00
|
|
|
result = mPresShell->GetSelection(getter_AddRefs(selection));
|
1999-02-12 20:18:58 +03:00
|
|
|
|
1999-05-04 02:57:48 +04:00
|
|
|
if (NS_FAILED(result))
|
|
|
|
{
|
|
|
|
EndTransaction();
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMRange> startRange;
|
|
|
|
nsCOMPtr<nsIDOMRange> endRange;
|
|
|
|
|
|
|
|
result = selection->GetRangeAt(0, getter_AddRefs(startRange));
|
1999-02-12 20:18:58 +03:00
|
|
|
|
1999-05-04 02:57:48 +04:00
|
|
|
if (NS_FAILED(result))
|
|
|
|
{
|
|
|
|
EndTransaction();
|
|
|
|
return result;
|
|
|
|
}
|
1999-02-12 20:18:58 +03:00
|
|
|
|
1999-05-04 02:57:48 +04:00
|
|
|
InsertTextTxn *txn;
|
|
|
|
result = CreateTxnForInsertText(aStringToInsert, nsnull, &txn); // insert at the current selection
|
|
|
|
if ((NS_SUCCEEDED(result)) && txn) {
|
|
|
|
result = Do(txn);
|
|
|
|
}
|
|
|
|
else if (NS_ERROR_EDITOR_NO_SELECTION==result) {
|
|
|
|
result = DoInitialInsert(aStringToInsert);
|
|
|
|
}
|
|
|
|
else if (NS_ERROR_EDITOR_NO_TEXTNODE==result)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMSelection> selection;
|
|
|
|
result = GetSelection(getter_AddRefs(selection));
|
|
|
|
if ((NS_SUCCEEDED(result)) && selection)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMNode> selectedNode;
|
|
|
|
PRInt32 offset;
|
|
|
|
result = selection->GetAnchorNode(getter_AddRefs(selectedNode));
|
|
|
|
if (NS_SUCCEEDED(result) && NS_SUCCEEDED(selection->GetAnchorOffset(&offset)) && selectedNode)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMNode> newNode;
|
|
|
|
result = CreateNode(GetTextNodeTag(), selectedNode, offset+1,
|
|
|
|
getter_AddRefs(newNode));
|
|
|
|
if (NS_SUCCEEDED(result) && newNode)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMCharacterData>newTextNode;
|
|
|
|
newTextNode = do_QueryInterface(newNode);
|
|
|
|
if (newTextNode)
|
|
|
|
{
|
|
|
|
nsAutoString placeholderText(" ");
|
|
|
|
newTextNode->SetData(placeholderText);
|
|
|
|
selection->Collapse(newNode, 0);
|
|
|
|
selection->Extend(newNode, 1);
|
|
|
|
result = SetPreeditText(aStringToInsert);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
result = mPresShell->GetSelection(getter_AddRefs(selection));
|
|
|
|
|
|
|
|
if (NS_FAILED(result))
|
|
|
|
{
|
|
|
|
EndTransaction();
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
result = selection->GetRangeAt(0, getter_AddRefs(endRange));
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMNode> node;
|
|
|
|
PRInt32 offset;
|
|
|
|
|
|
|
|
startRange->GetStartParent(getter_AddRefs(node));
|
|
|
|
startRange->GetStartOffset(&offset);
|
|
|
|
mIMESelectionRange->SetStart(node, offset);
|
|
|
|
|
|
|
|
endRange->GetStartParent(getter_AddRefs(node));
|
|
|
|
endRange->GetStartOffset(&offset);
|
|
|
|
mIMESelectionRange->SetEnd(node, offset);
|
|
|
|
|
|
|
|
EndTransaction();
|
|
|
|
return result;
|
|
|
|
}
|
1999-05-05 08:05:19 +04:00
|
|
|
|