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"
|
|
|
|
#include "nsIDOMText.h"
|
|
|
|
#include "nsIDOMElement.h"
|
|
|
|
#include "nsIDOMAttr.h"
|
|
|
|
#include "nsIDOMNode.h"
|
|
|
|
#include "nsIDOMNodeList.h"
|
|
|
|
#include "nsIDOMRange.h"
|
|
|
|
#include "nsIDocument.h"
|
|
|
|
#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-02-13 07:48:09 +03:00
|
|
|
#include "nsICaret.h"
|
1999-04-07 07:56:07 +04:00
|
|
|
#ifndef NEW_CLIPBOARD_SUPPORT
|
1999-03-11 01:46:15 +03:00
|
|
|
#include "nsISelectionMgr.h"
|
1999-04-07 07:56:07 +04:00
|
|
|
#endif
|
1999-02-12 20:18:58 +03:00
|
|
|
|
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-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
|
|
|
|
|
|
|
#ifdef NEW_CLIPBOARD_SUPPORT
|
1999-03-24 04:43:46 +03:00
|
|
|
|
1999-03-23 18:45:58 +03:00
|
|
|
// Drag & Drop, Clipboard
|
|
|
|
#include "nsWidgetsCID.h"
|
|
|
|
#include "nsIClipboard.h"
|
|
|
|
#include "nsITransferable.h"
|
|
|
|
#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-03-23 18:45:58 +03:00
|
|
|
|
1999-04-01 18:28:13 +04:00
|
|
|
static NS_DEFINE_IID(kITransferableIID, NS_ITRANSFERABLE_IID);
|
|
|
|
static NS_DEFINE_CID(kCTransferableCID, NS_TRANSFERABLE_CID);
|
|
|
|
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
|
|
|
#endif
|
|
|
|
|
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);
|
|
|
|
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);
|
1999-02-17 22:42:29 +03:00
|
|
|
static NS_DEFINE_IID(kIEditorSupportIID, NS_IEDITORSUPPORT_IID);
|
1999-02-12 20:18:58 +03:00
|
|
|
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-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)
|
|
|
|
|
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
|
|
|
#ifdef NS_DEBUG
|
|
|
|
static PRBool gNoisy = PR_TRUE;
|
|
|
|
#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();
|
|
|
|
PR_EnterMonitor(getEditorMonitor());
|
|
|
|
gInstanceCount++;
|
|
|
|
PR_ExitMonitor(getEditorMonitor());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
nsEditor::~nsEditor()
|
|
|
|
{
|
|
|
|
NS_IF_RELEASE(mPresShell);
|
|
|
|
NS_IF_RELEASE(mViewManager);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//BEGIN nsIEditor interface implementations
|
|
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
1999-02-17 22:42:29 +03:00
|
|
|
if (aIID.Equals(kIEditorSupportIID)) {
|
|
|
|
*aInstancePtr = (void*)(nsIEditorSupport*)this;
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
1999-02-12 20:18:58 +03:00
|
|
|
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-02-19 02:18:56 +03:00
|
|
|
mDoc = do_QueryInterface(aDoc);
|
1999-02-12 20:18:58 +03:00
|
|
|
mPresShell = aPresShell;
|
|
|
|
NS_ADDREF(mPresShell);
|
1999-02-12 20:45:58 +03:00
|
|
|
mPresShell->GetViewManager(&mViewManager);
|
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-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::GetFirstNodeOfType(nsIDOMNode *aStartNode, const nsString &aTag, nsIDOMNode **aResult)
|
|
|
|
{
|
|
|
|
nsresult result=NS_OK;
|
|
|
|
|
|
|
|
if (!mDoc)
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
if (!aResult)
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
|
|
|
|
/* If no node set, get root node */
|
|
|
|
nsCOMPtr<nsIDOMNode> node;
|
|
|
|
nsCOMPtr<nsIDOMElement> element;
|
|
|
|
|
|
|
|
if (nsnull==aStartNode)
|
|
|
|
{
|
|
|
|
mDoc->GetDocumentElement(getter_AddRefs(element));
|
|
|
|
result = element->QueryInterface(kIDOMNodeIID,getter_AddRefs(node));
|
|
|
|
if (NS_FAILED(result))
|
|
|
|
return result;
|
|
|
|
if (!node)
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
|
|
|
else
|
1999-02-19 02:18:56 +03:00
|
|
|
node = do_QueryInterface(aStartNode);
|
1999-02-12 20:18:58 +03:00
|
|
|
|
|
|
|
*aResult = nsnull;
|
|
|
|
nsCOMPtr<nsIDOMNode> childNode;
|
|
|
|
result = node->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
|
|
|
NS_IMETHODIMP
|
1999-02-12 20:18:58 +03:00
|
|
|
nsEditor::GetFirstTextNode(nsIDOMNode *aNode, nsIDOMNode **aRetNode)
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (nsIDOMNode::TEXT_NODE == mType) {
|
1999-02-19 02:18:56 +03:00
|
|
|
answer = do_QueryInterface(aNode);
|
1999-02-12 20:18:58 +03: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-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-04-07 07:56:07 +04:00
|
|
|
#ifndef NEW_CLIPBOARD_SUPPORT
|
1999-03-11 03:08:10 +03:00
|
|
|
extern "C" NS_EXPORT nsISelectionMgr* GetSelectionMgr();
|
1999-04-07 07:56:07 +04:00
|
|
|
#endif
|
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
|
|
|
#ifndef NEW_CLIPBOARD_SUPPORT
|
1999-03-11 01:46:15 +03:00
|
|
|
// Get the nsSelectionMgr:
|
|
|
|
// XXX BWEEP BWEEP TEMPORARY!
|
|
|
|
// The selection mgr needs to be a service.
|
|
|
|
// See http://bugzilla.mozilla.org/show_bug.cgi?id=3509.
|
|
|
|
// In the meantime, so I'm not blocked on writing the rest of the code,
|
|
|
|
// nsSelectionMgr uses the egregious hack of a global variable:
|
1999-03-11 03:08:10 +03:00
|
|
|
nsISelectionMgr* selectionMgr = GetSelectionMgr();
|
1999-03-11 01:46:15 +03:00
|
|
|
if (!selectionMgr)
|
|
|
|
{
|
|
|
|
printf("Can't get selection mgr!\n");
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
//NS_ADD_REF(theSelectionMgr);
|
|
|
|
return mPresShell->DoCopy(selectionMgr);
|
1999-04-07 07:56:07 +04:00
|
|
|
#else
|
|
|
|
return mPresShell->DoCopy();
|
|
|
|
#endif
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
#ifdef NEW_CLIPBOARD_SUPPORT
|
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-02 05:34:05 +04:00
|
|
|
nsITransferable *trans = 0;
|
1999-03-23 18:45:58 +03:00
|
|
|
rv = nsComponentManager::CreateInstance(kCTransferableCID, nsnull, kITransferableIID, (void**) &trans);
|
1999-04-01 18:28:13 +04:00
|
|
|
|
|
|
|
//nsIFormatConverter * xifConverter;
|
|
|
|
//rv = nsComponentManager::CreateInstance(kCXIFFormatConverterCID, nsnull, kIFormatConverterIID, (void**) &xifConverter);
|
|
|
|
|
|
|
|
//trans->SetConverter(xifConverter);
|
|
|
|
|
1999-04-02 05:34:05 +04:00
|
|
|
nsIDataFlavor *flavor = 0;
|
1999-04-01 18:28:13 +04:00
|
|
|
rv = nsComponentManager::CreateInstance(kCDataFlavorCID, nsnull, kIDataFlavorIID, (void**) &flavor);
|
|
|
|
flavor->Init(kTextMime, "Text");
|
|
|
|
trans->AddDataFlavor(flavor);
|
1999-03-23 18:45:58 +03:00
|
|
|
|
1999-03-26 18:49:28 +03:00
|
|
|
clipboard->GetData(trans);
|
1999-03-23 18:45:58 +03:00
|
|
|
|
1999-04-02 05:34:05 +04:00
|
|
|
char *str = 0;
|
1999-04-01 18:28:13 +04:00
|
|
|
PRUint32 len;
|
|
|
|
trans->GetTransferData(flavor, (void **)&str, &len);
|
|
|
|
|
1999-04-02 05:34:05 +04:00
|
|
|
if (str) {
|
|
|
|
if (str[len-1] == 0) {
|
|
|
|
len--;
|
|
|
|
}
|
|
|
|
stuffToPaste.SetString(str, len);
|
1999-04-01 18:28:13 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IF_RELEASE(flavor);
|
1999-03-23 18:45:58 +03:00
|
|
|
NS_IF_RELEASE(trans);
|
1999-04-01 18:28:13 +04:00
|
|
|
NS_IF_RELEASE(clipboard);
|
1999-03-23 18:45:58 +03:00
|
|
|
|
|
|
|
|
|
|
|
#else
|
1999-03-11 01:46:15 +03:00
|
|
|
|
|
|
|
// Get the nsSelectionMgr:
|
|
|
|
// XXX BWEEP BWEEP TEMPORARY!
|
|
|
|
// The selection mgr needs to be a service.
|
|
|
|
// See http://bugzilla.mozilla.org/show_bug.cgi?id=3509.
|
|
|
|
// In the meantime, so I'm not blocked on writing the rest of the code,
|
|
|
|
// nsSelectionMgr uses the egregious hack of a global variable:
|
1999-03-11 03:08:10 +03:00
|
|
|
nsISelectionMgr* selectionMgr = GetSelectionMgr();
|
1999-03-11 01:46:15 +03:00
|
|
|
if (!selectionMgr)
|
|
|
|
{
|
|
|
|
printf("Can't get selection mgr!\n");
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
//NS_ADD_REF(theSelectionMgr);
|
|
|
|
|
|
|
|
// Now we have the selection mgr. Get its contents as text (for now):
|
|
|
|
selectionMgr->PasteTextBlocking(&stuffToPaste);
|
1999-03-23 18:45:58 +03:00
|
|
|
#endif
|
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-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-02-24 20:24:37 +03:00
|
|
|
InsertElementTxn *txn;
|
|
|
|
nsresult result = CreateTxnForInsertElement(aNode, aParent, aPosition, &txn);
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
result = Do(txn);
|
|
|
|
}
|
|
|
|
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
|
|
|
{
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
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;
|
|
|
|
result = selection->IsCollapsed(&collapsed);
|
|
|
|
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;
|
|
|
|
result = selection->GetAnchorNodeAndOffset(getter_AddRefs(selectedNode), &offset);
|
|
|
|
if ((NS_SUCCEEDED(result)) && 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 = 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;
|
|
|
|
result = selection->IsCollapsed(&collapsed);
|
|
|
|
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;
|
|
|
|
PRInt32 testOffset;
|
|
|
|
nsresult debugResult = selection->GetAnchorNodeAndOffset(getter_AddRefs(testSelectedNode), &testOffset);
|
|
|
|
// no selection is ok.
|
|
|
|
// if there is a selection, it must be collapsed
|
|
|
|
if (testSelectedNode)
|
|
|
|
{
|
|
|
|
PRBool testCollapsed;
|
|
|
|
debugResult = selection->IsCollapsed(&testCollapsed);
|
|
|
|
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;
|
|
|
|
result = selection->GetAnchorNodeAndOffset(getter_AddRefs(parentSelectedNode), &offsetOfSelectedNode);
|
|
|
|
if ((NS_SUCCEEDED(result)) && 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-03-17 09:13:46 +03:00
|
|
|
nsIEditorSupport::GetChildOffset(selectedNode, parentSelectedNode, indexOfTextNodeInParent);
|
|
|
|
|
|
|
|
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)) {
|
|
|
|
result = nsIEditorSupport::GetChildOffset(selectedNode, parentSelectedNode, offsetOfNewNode);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
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
|
|
|
|
nsIEditorSupport::GetChildOffset(selectedNode, parentSelectedNode, offsetOfNewNode);
|
|
|
|
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)) {
|
|
|
|
result = nsIEditorSupport::GetChildOffset(selectedNode, parentSelectedNode, offsetOfNewNode);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
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
|
|
|
|
nsIEditorSupport::GetChildOffset(selectedNode, parentSelectedNode, offsetOfNewNode);
|
|
|
|
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-12 20:18:58 +03:00
|
|
|
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
|
|
|
|
|
1999-02-19 14:30:31 +03:00
|
|
|
nsCOMPtr<nsIDOMNode> parent(do_QueryInterface(aCurrentNode));
|
1999-02-12 20:18:58 +03:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP
|
1999-02-12 20:18:58 +03:00
|
|
|
nsEditor::GetNextNode(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->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
|
|
|
|
|
1999-02-19 14:30:31 +03:00
|
|
|
nsCOMPtr<nsIDOMNode> parent(do_QueryInterface(aCurrentNode));
|
1999-02-12 20:18:58 +03:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP
|
1999-02-12 20:18:58 +03:00
|
|
|
nsEditor::GetRightmostChild(nsIDOMNode *aCurrentNode, nsIDOMNode **aResultNode)
|
|
|
|
{
|
|
|
|
nsresult result = NS_OK;
|
1999-02-19 14:30:31 +03:00
|
|
|
nsCOMPtr<nsIDOMNode> resultNode(do_QueryInterface(aCurrentNode));
|
1999-02-12 20:18:58 +03:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP
|
1999-02-12 20:18:58 +03:00
|
|
|
nsEditor::GetLeftmostChild(nsIDOMNode *aCurrentNode, nsIDOMNode **aResultNode)
|
|
|
|
{
|
|
|
|
nsresult result = NS_OK;
|
1999-02-19 14:30:31 +03:00
|
|
|
nsCOMPtr<nsIDOMNode> resultNode(do_QueryInterface(aCurrentNode));
|
1999-02-12 20:18:58 +03:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
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
|
|
|
{
|
|
|
|
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
|
|
|
}
|
|
|
|
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
|
|
|
{
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
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-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP
|
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
|
|
|
|
|
|
|
printf("SplitNodeImpl: left=%p, right=%p, offset=%d\n", aNewLeftNode, aExistingRightNode, aOffset);
|
|
|
|
|
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-03-02 08:30:53 +03:00
|
|
|
NS_IMETHODIMP
|
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-02-22 18:53:31 +03:00
|
|
|
nsresult nsIEditorSupport::GetChildOffset(nsIDOMNode *aChild, nsIDOMNode *aParent, PRInt32 &aOffset)
|
|
|
|
{
|
|
|
|
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-03-02 10:52:41 +03:00
|
|
|
|
|
|
|
//END nsEditor Private methods
|
|
|
|
|
1999-03-14 03:31:35 +03:00
|
|
|
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!!!
|
|
|
|
nsIPresShell* shell = nsnull;
|
|
|
|
|
|
|
|
GetPresShell(&shell);
|
|
|
|
if (nsnull != shell) {
|
|
|
|
nsIViewManager* viewmgr = nsnull;;
|
|
|
|
nsIView* view = nsnull;
|
|
|
|
|
|
|
|
shell->GetViewManager(&viewmgr);
|
|
|
|
if (nsnull != viewmgr) {
|
|
|
|
viewmgr->GetRootView(view);
|
|
|
|
if (nsnull != view) {
|
|
|
|
viewmgr->UpdateView(view,nsnull,NS_VMREFRESH_IMMEDIATE);
|
|
|
|
}
|
|
|
|
NS_RELEASE(viewmgr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// END HACK
|
|
|
|
#endif
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
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
|
1999-03-03 01:27:46 +03:00
|
|
|
nsCOMPtr<nsIContent> nodeAsContent( do_QueryInterface(aNode) );
|
1999-03-02 08:30:53 +03:00
|
|
|
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-02-12 20:18:58 +03:00
|
|
|
|
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-02-12 20:18:58 +03:00
|
|
|
|
1999-03-02 08:30:53 +03:00
|
|
|
//END nsEditor Private methods
|
1999-02-12 20:18:58 +03:00
|
|
|
|
|
|
|
/* ----- TEST METHODS ----- */
|
|
|
|
// Methods defined here are TEMPORARY
|
1999-03-02 08:30:53 +03:00
|
|
|
|
|
|
|
/* ORIGINAL version by Steve - KEEP FOR REFERENCE
|
|
|
|
NS_IMETHODIMP GetColIndexForCell(nsIPresShell *aPresShell, nsIDOMNode *aCellNode, PRInt32 &aCellIndex)
|
1999-02-12 20:18:58 +03:00
|
|
|
{
|
|
|
|
aCellIndex=0; // initialize out param
|
|
|
|
nsresult result = NS_ERROR_FAILURE; // we return an error unless we get the index
|
|
|
|
if ((nsnull!=aCellNode) && (nsnull!=aPresShell))
|
|
|
|
{ // get the content interface
|
|
|
|
nsCOMPtr<nsIContent> nodeAsContent(aCellNode);
|
|
|
|
if (nodeAsContent)
|
|
|
|
{ // get the frame from the content interface
|
|
|
|
nsISupports *layoutObject=nsnull; // frames are not ref counted, so don't use an nsCOMPtr
|
|
|
|
result = aPresShell->GetLayoutObjectFor(nodeAsContent, &layoutObject);
|
|
|
|
if ((NS_SUCCEEDED(result)) && (nsnull!=layoutObject))
|
|
|
|
{ // get the table cell interface from the frame
|
|
|
|
nsITableCellLayout *cellLayoutObject=nsnull; // again, frames are not ref-counted
|
1999-03-03 22:48:57 +03:00
|
|
|
result = layoutObject->QueryInterface(nsITableCellLayout::GetIID(), (void**)(&cellLayoutObject));
|
1999-02-12 20:18:58 +03:00
|
|
|
if ((NS_SUCCEEDED(result)) && (nsnull!=cellLayoutObject))
|
|
|
|
{ // get the index
|
|
|
|
result = cellLayoutObject->GetColIndex(aCellIndex);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
result = NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
1999-03-02 08:30:53 +03:00
|
|
|
*/
|
1999-02-12 20:18:58 +03:00
|
|
|
|
|
|
|
/* ----- END TEST METHODS ----- */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|