mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-12-12 00:50:40 +00:00
7436f01057
Doing QI from nsIEditor to nsIEditorIMESupport doesn't make sense because editor should always support all methods and attributes of nsIEditorIMESupport (it does NOT mean that all nsIEditor implementation need to support IME). This patch moves all of them to nsIEditor for avoiding redundant QIs. MozReview-Commit-ID: DzIKuGHG4iy --HG-- extra : rebase_source : cc5e9a6ae4572ebe461d9770ffa5c23d33dc8526
593 lines
22 KiB
Plaintext
593 lines
22 KiB
Plaintext
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "nsISupports.idl"
|
|
#include "domstubs.idl"
|
|
|
|
interface nsIURI;
|
|
interface nsIAtom;
|
|
interface nsIContent;
|
|
interface nsISelection;
|
|
interface nsISelectionController;
|
|
interface nsIDocumentStateListener;
|
|
interface nsIOutputStream;
|
|
interface nsITransactionManager;
|
|
interface nsITransaction;
|
|
interface nsIEditorObserver;
|
|
interface nsIEditActionListener;
|
|
interface nsIInlineSpellChecker;
|
|
interface nsITransferable;
|
|
|
|
%{C++
|
|
namespace mozilla {
|
|
namespace widget {
|
|
struct IMEState;
|
|
} // namespace widget
|
|
} // namespace mozilla
|
|
%}
|
|
|
|
native IMEState(mozilla::widget::IMEState);
|
|
|
|
[scriptable, uuid(094be624-f0bf-400f-89e2-6a84baab9474)]
|
|
interface nsIEditor : nsISupports
|
|
{
|
|
%{C++
|
|
typedef short EDirection;
|
|
typedef short EStripWrappers;
|
|
%}
|
|
const short eNone = 0;
|
|
const short eNext = 1;
|
|
const short ePrevious = 2;
|
|
const short eNextWord = 3;
|
|
const short ePreviousWord = 4;
|
|
const short eToBeginningOfLine = 5;
|
|
const short eToEndOfLine = 6;
|
|
|
|
const short eStrip = 0;
|
|
const short eNoStrip = 1;
|
|
|
|
readonly attribute nsISelection selection;
|
|
|
|
/**
|
|
* Finalizes selection and caret for the editor.
|
|
*/
|
|
[noscript] void finalizeSelection();
|
|
|
|
/**
|
|
* Init is to tell the implementation of nsIEditor to begin its services
|
|
* @param aDoc The dom document interface being observed
|
|
* @param aRoot This is the root of the editable section of this
|
|
* document. If it is null then we get root
|
|
* from document body.
|
|
* @param aSelCon this should be used to get the selection location
|
|
* (will be null for HTML editors)
|
|
* @param aFlags A bitmask of flags for specifying the behavior
|
|
* of the editor.
|
|
*/
|
|
[noscript] void init(in nsIDOMDocument doc,
|
|
in nsIContent aRoot,
|
|
in nsISelectionController aSelCon,
|
|
in unsigned long aFlags,
|
|
in AString initialValue);
|
|
|
|
void setAttributeOrEquivalent(in nsIDOMElement element,
|
|
in AString sourceAttrName,
|
|
in AString sourceAttrValue,
|
|
in boolean aSuppressTransaction);
|
|
void removeAttributeOrEquivalent(in nsIDOMElement element,
|
|
in DOMString sourceAttrName,
|
|
in boolean aSuppressTransaction);
|
|
|
|
/**
|
|
* postCreate should be called after Init, and is the time that the editor
|
|
* tells its documentStateObservers that the document has been created.
|
|
*/
|
|
void postCreate();
|
|
|
|
/**
|
|
* preDestroy is called before the editor goes away, and gives the editor a
|
|
* chance to tell its documentStateObservers that the document is going away.
|
|
* @param aDestroyingFrames set to true when the frames being edited
|
|
* are being destroyed (so there is no need to modify any nsISelections,
|
|
* nor is it safe to do so)
|
|
*/
|
|
void preDestroy(in boolean aDestroyingFrames);
|
|
|
|
/** edit flags for this editor. May be set at any time. */
|
|
attribute unsigned long flags;
|
|
|
|
/**
|
|
* the MimeType of the document
|
|
*/
|
|
attribute string contentsMIMEType;
|
|
|
|
/** Returns true if we have a document that is not marked read-only */
|
|
readonly attribute boolean isDocumentEditable;
|
|
|
|
/** Returns true if the current selection anchor is editable */
|
|
readonly attribute boolean isSelectionEditable;
|
|
|
|
/**
|
|
* the DOM Document this editor is associated with, refcounted.
|
|
*/
|
|
readonly attribute nsIDOMDocument document;
|
|
|
|
/** the body element, i.e. the root of the editable document.
|
|
*/
|
|
readonly attribute nsIDOMElement rootElement;
|
|
|
|
/**
|
|
* the selection controller for the current presentation, refcounted.
|
|
*/
|
|
readonly attribute nsISelectionController selectionController;
|
|
|
|
|
|
/* ------------ Selected content removal -------------- */
|
|
|
|
/**
|
|
* DeleteSelection removes all nodes in the current selection.
|
|
* @param aDir if eNext, delete to the right (for example, the DEL key)
|
|
* if ePrevious, delete to the left (for example, the BACKSPACE key)
|
|
* @param stripWrappers If eStrip, strip any empty inline elements left
|
|
* behind after the deletion; if eNoStrip, don't. If in
|
|
* doubt, pass eStrip -- eNoStrip is only for if you're
|
|
* about to insert text or similar right after.
|
|
*/
|
|
void deleteSelection(in short action, in short stripWrappers);
|
|
|
|
|
|
/* ------------ Document info and file methods -------------- */
|
|
|
|
/** Returns true if the document has no *meaningful* content */
|
|
readonly attribute boolean documentIsEmpty;
|
|
|
|
/** Returns true if the document is modifed and needs saving */
|
|
readonly attribute boolean documentModified;
|
|
|
|
/** Sets the current 'Save' document character set */
|
|
attribute ACString documentCharacterSet;
|
|
|
|
/** to be used ONLY when we need to override the doc's modification
|
|
* state (such as when it's saved).
|
|
*/
|
|
void resetModificationCount();
|
|
|
|
/** Gets the modification count of the document we are editing.
|
|
* @return the modification count of the document being edited.
|
|
* Zero means unchanged.
|
|
*/
|
|
long getModificationCount();
|
|
|
|
/** called each time we modify the document.
|
|
* Increments the modification count of the document.
|
|
* @param aModCount the number of modifications by which
|
|
* to increase or decrease the count
|
|
*/
|
|
void incrementModificationCount(in long aModCount);
|
|
|
|
/* ------------ Transaction methods -------------- */
|
|
|
|
/** transactionManager Get the transaction manager the editor is using.
|
|
*/
|
|
attribute nsITransactionManager transactionManager;
|
|
|
|
/** doTransaction() fires a transaction.
|
|
* It is provided here so clients can create their own transactions.
|
|
* If a transaction manager is present, it is used.
|
|
* Otherwise, the transaction is just executed directly.
|
|
*
|
|
* @param aTxn the transaction to execute
|
|
*/
|
|
void doTransaction(in nsITransaction txn);
|
|
|
|
|
|
/** turn the undo system on or off
|
|
* @param aEnable if PR_TRUE, the undo system is turned on if available
|
|
* if PR_FALSE the undo system is turned off if it
|
|
* was previously on
|
|
* @return if aEnable is PR_TRUE, returns NS_OK if
|
|
* the undo system could be initialized properly
|
|
* if aEnable is PR_FALSE, returns NS_OK.
|
|
*/
|
|
void enableUndo(in boolean enable);
|
|
|
|
/**
|
|
* The number of items on the undo stack.
|
|
*/
|
|
readonly attribute long numberOfUndoItems;
|
|
|
|
/**
|
|
* The number of items on the redo stack.
|
|
*/
|
|
readonly attribute long numberOfRedoItems;
|
|
|
|
/** undo reverses the effects of the last Do operation,
|
|
* if Undo is enabled in the editor.
|
|
* It is provided here so clients need no knowledge of whether
|
|
* the editor has a transaction manager or not.
|
|
* If a transaction manager is present, it is told to undo,
|
|
* and the result of that undo is returned.
|
|
* Otherwise, the Undo request is ignored and an
|
|
* error NS_ERROR_NOT_AVAILABLE is returned.
|
|
*
|
|
*/
|
|
void undo(in unsigned long count);
|
|
|
|
/** returns state information about the undo system.
|
|
* @param aIsEnabled [OUT] PR_TRUE if undo is enabled
|
|
* @param aCanUndo [OUT] PR_TRUE if at least one transaction is
|
|
* currently ready to be undone.
|
|
*/
|
|
void canUndo(out boolean isEnabled, out boolean canUndo);
|
|
|
|
/** redo reverses the effects of the last Undo operation
|
|
* It is provided here so clients need no knowledge of whether
|
|
* the editor has a transaction manager or not.
|
|
* If a transaction manager is present, it is told to redo and the
|
|
* result of the previously undone transaction is reapplied to the document.
|
|
* If no transaction is available for Redo, or if the document
|
|
* has no transaction manager, the Redo request is ignored and an
|
|
* error NS_ERROR_NOT_AVAILABLE is returned.
|
|
*
|
|
*/
|
|
void redo(in unsigned long count);
|
|
|
|
/** returns state information about the redo system.
|
|
* @param aIsEnabled [OUT] PR_TRUE if redo is enabled
|
|
* @param aCanRedo [OUT] PR_TRUE if at least one transaction is
|
|
currently ready to be redone.
|
|
*/
|
|
void canRedo(out boolean isEnabled, out boolean canRedo);
|
|
|
|
/** beginTransaction is a signal from the caller to the editor that
|
|
* the caller will execute multiple updates to the content tree
|
|
* that should be treated as a single logical operation,
|
|
* in the most efficient way possible.<br>
|
|
* All transactions executed between a call to beginTransaction and
|
|
* endTransaction will be undoable as an atomic action.<br>
|
|
* endTransaction must be called after beginTransaction.<br>
|
|
* Calls to beginTransaction can be nested, as long as endTransaction
|
|
* is called once per beginUpdate.
|
|
*/
|
|
void beginTransaction();
|
|
|
|
/** endTransaction is a signal to the editor that the caller is
|
|
* finished updating the content model.<br>
|
|
* beginUpdate must be called before endTransaction is called.<br>
|
|
* Calls to beginTransaction can be nested, as long as endTransaction
|
|
* is called once per beginTransaction.
|
|
*/
|
|
void endTransaction();
|
|
|
|
void beginPlaceHolderTransaction(in nsIAtom name);
|
|
void endPlaceHolderTransaction();
|
|
boolean shouldTxnSetSelection();
|
|
|
|
/** Set the flag that prevents insertElementTxn from changing the selection
|
|
* @param should Set false to suppress changing the selection;
|
|
* i.e., before using InsertElement() to insert
|
|
* under <head> element
|
|
* WARNING: You must be very careful to reset back to PR_TRUE after
|
|
* setting PR_FALSE, else selection/caret is trashed
|
|
* for further editing.
|
|
*/
|
|
void setShouldTxnSetSelection(in boolean should);
|
|
|
|
/* ------------ Inline Spell Checking methods -------------- */
|
|
|
|
/** Returns the inline spell checker associated with this object. The spell
|
|
* checker is lazily created, so this function may create the object for
|
|
* you during this call.
|
|
* @param autoCreate If true, this will create a spell checker object
|
|
* if one does not exist yet for this editor. If false
|
|
* and the object has not been created, this function
|
|
* WILL RETURN NULL.
|
|
*/
|
|
nsIInlineSpellChecker getInlineSpellChecker(in boolean autoCreate);
|
|
|
|
/** Resyncs spellchecking state (enabled/disabled). This should be called
|
|
* when anything that affects spellchecking state changes, such as the
|
|
* spellcheck attribute value.
|
|
*/
|
|
void syncRealTimeSpell();
|
|
|
|
/** Called when the user manually overrides the spellchecking state for this
|
|
* editor.
|
|
* @param enable The new state of spellchecking in this editor, as
|
|
* requested by the user.
|
|
*/
|
|
void setSpellcheckUserOverride(in boolean enable);
|
|
|
|
/* ------------ Clipboard methods -------------- */
|
|
|
|
/** cut the currently selected text, putting it into the OS clipboard
|
|
* What if no text is selected?
|
|
* What about mixed selections?
|
|
* What are the clipboard formats?
|
|
*/
|
|
void cut();
|
|
|
|
/** Can we cut? True if the doc is modifiable, and we have a non-
|
|
* collapsed selection.
|
|
*/
|
|
boolean canCut();
|
|
|
|
/** copy the currently selected text, putting it into the OS clipboard
|
|
* What if no text is selected?
|
|
* What about mixed selections?
|
|
* What are the clipboard formats?
|
|
*/
|
|
void copy();
|
|
|
|
/** Can we copy? True if we have a non-collapsed selection.
|
|
*/
|
|
boolean canCopy();
|
|
|
|
/** Can we delete? True if we have a non-collapsed selection.
|
|
*/
|
|
boolean canDelete();
|
|
|
|
/** paste the text in the OS clipboard at the cursor position, replacing
|
|
* the selected text (if any)
|
|
*/
|
|
void paste(in long aSelectionType);
|
|
|
|
/** Paste the text in |aTransferable| at the cursor position, replacing the
|
|
* selected text (if any).
|
|
*/
|
|
void pasteTransferable(in nsITransferable aTransferable);
|
|
|
|
/** Can we paste? True if the doc is modifiable, and we have
|
|
* pasteable data in the clipboard.
|
|
*/
|
|
boolean canPaste(in long aSelectionType);
|
|
|
|
/** Can we paste |aTransferable| or, if |aTransferable| is null, will a call
|
|
* to pasteTransferable later possibly succeed if given an instance of
|
|
* nsITransferable then? True if the doc is modifiable, and, if
|
|
* |aTransfeable| is non-null, we have pasteable data in |aTransfeable|.
|
|
*/
|
|
boolean canPasteTransferable([optional] in nsITransferable aTransferable);
|
|
|
|
/* ------------ Selection methods -------------- */
|
|
|
|
/** sets the document selection to the entire contents of the document */
|
|
void selectAll();
|
|
|
|
/** sets the document selection to the beginning of the document */
|
|
void beginningOfDocument();
|
|
|
|
/** sets the document selection to the end of the document */
|
|
void endOfDocument();
|
|
|
|
/* ------------ Node manipulation methods -------------- */
|
|
|
|
/**
|
|
* setAttribute() sets the attribute of aElement.
|
|
* No checking is done to see if aAttribute is a legal attribute of the node,
|
|
* or if aValue is a legal value of aAttribute.
|
|
*
|
|
* @param aElement the content element to operate on
|
|
* @param aAttribute the string representation of the attribute to set
|
|
* @param aValue the value to set aAttribute to
|
|
*/
|
|
void setAttribute(in nsIDOMElement aElement, in AString attributestr,
|
|
in AString attvalue);
|
|
|
|
/**
|
|
* getAttributeValue() retrieves the attribute's value for aElement.
|
|
*
|
|
* @param aElement the content element to operate on
|
|
* @param aAttribute the string representation of the attribute to get
|
|
* @param aResultValue [OUT] the value of aAttribute.
|
|
* Only valid if aResultIsSet is PR_TRUE
|
|
* @return PR_TRUE if aAttribute is set on the current node,
|
|
* PR_FALSE if it is not.
|
|
*/
|
|
boolean getAttributeValue(in nsIDOMElement aElement,
|
|
in AString attributestr,
|
|
out AString resultValue);
|
|
|
|
/**
|
|
* removeAttribute() deletes aAttribute from the attribute list of aElement.
|
|
* If aAttribute is not an attribute of aElement, nothing is done.
|
|
*
|
|
* @param aElement the content element to operate on
|
|
* @param aAttribute the string representation of the attribute to get
|
|
*/
|
|
void removeAttribute(in nsIDOMElement aElement,
|
|
in AString aAttribute);
|
|
|
|
/**
|
|
* cloneAttribute() copies the attribute from the source node to
|
|
* the destination node and delete those not in the source.
|
|
*
|
|
* The supplied nodes MUST BE ELEMENTS (most callers are working with nodes)
|
|
* @param aAttribute the name of the attribute to copy
|
|
* @param aDestNode the destination element to operate on
|
|
* @param aSourceNode the source element to copy attributes from
|
|
* @exception NS_ERROR_NULL_POINTER at least one of the nodes is null
|
|
* @exception NS_ERROR_NO_INTERFACE at least one of the nodes is not an
|
|
* element
|
|
*/
|
|
void cloneAttribute(in AString aAttribute,
|
|
in nsIDOMNode aDestNode, in nsIDOMNode aSourceNode);
|
|
|
|
/**
|
|
* cloneAttributes() is similar to nsIDOMNode::cloneNode(),
|
|
* it assures the attribute nodes of the destination are identical
|
|
* with the source node by copying all existing attributes from the
|
|
* source and deleting those not in the source.
|
|
* This is used when the destination node (element) already exists
|
|
*
|
|
* The supplied nodes MUST BE ELEMENTS (most callers are working with nodes)
|
|
* @param aDestNode the destination element to operate on
|
|
* @param aSourceNode the source element to copy attributes from
|
|
*/
|
|
void cloneAttributes(in nsIDOMNode destNode, in nsIDOMNode sourceNode);
|
|
|
|
/**
|
|
* createNode instantiates a new element of type aTag and inserts it
|
|
* into aParent at aPosition.
|
|
* @param aTag The type of object to create
|
|
* @param aParent The node to insert the new object into
|
|
* @param aPosition The place in aParent to insert the new node
|
|
* @return The node created. Caller must release aNewNode.
|
|
*/
|
|
nsIDOMNode createNode(in AString tag,
|
|
in nsIDOMNode parent,
|
|
in long position);
|
|
|
|
/**
|
|
* insertNode inserts aNode into aParent at aPosition.
|
|
* No checking is done to verify the legality of the insertion.
|
|
* That is the responsibility of the caller.
|
|
* @param aNode The DOM Node to insert.
|
|
* @param aParent The node to insert the new object into
|
|
* @param aPosition The place in aParent to insert the new node
|
|
* 0=first child, 1=second child, etc.
|
|
* any number > number of current children = last child
|
|
*/
|
|
void insertNode(in nsIDOMNode node,
|
|
in nsIDOMNode parent,
|
|
in long aPosition);
|
|
|
|
|
|
/**
|
|
* splitNode() creates a new node identical to an existing node,
|
|
* and split the contents between the two nodes
|
|
* @param aExistingRightNode the node to split.
|
|
* It will become the new node's next sibling.
|
|
* @param aOffset the offset of aExistingRightNode's
|
|
* content|children to do the split at
|
|
* @param aNewLeftNode [OUT] the new node resulting from the split,
|
|
* becomes aExistingRightNode's previous sibling.
|
|
*/
|
|
void splitNode(in nsIDOMNode existingRightNode,
|
|
in long offset,
|
|
out nsIDOMNode newLeftNode);
|
|
|
|
/**
|
|
* joinNodes() takes 2 nodes and merge their content|children.
|
|
* @param aLeftNode The left node. It will be deleted.
|
|
* @param aRightNode The right node. It will remain after the join.
|
|
* @param aParent The parent of aExistingRightNode
|
|
*
|
|
* There is no requirement that the two nodes be
|
|
* of the same type. However, a text node can be
|
|
* merged only with another text node.
|
|
*/
|
|
void joinNodes(in nsIDOMNode leftNode,
|
|
in nsIDOMNode rightNode,
|
|
in nsIDOMNode parent);
|
|
|
|
/**
|
|
* deleteNode removes aChild from aParent.
|
|
* @param aChild The node to delete
|
|
*/
|
|
void deleteNode(in nsIDOMNode child);
|
|
|
|
/**
|
|
* Returns true if markNodeDirty() has any effect. Returns false if
|
|
* markNodeDirty() is a no-op.
|
|
*/
|
|
[notxpcom] boolean outputsMozDirty();
|
|
|
|
/**
|
|
* markNodeDirty() sets a special dirty attribute on the node.
|
|
* Usually this will be called immediately after creating a new node.
|
|
* @param aNode The node for which to insert formatting.
|
|
*/
|
|
void markNodeDirty(in nsIDOMNode node);
|
|
|
|
/* ---------- direction controller ---------- */
|
|
|
|
/**
|
|
* Switches the editor element direction; from "Left-to-Right" to
|
|
* "Right-to-Left", and vice versa.
|
|
*/
|
|
void switchTextDirection();
|
|
|
|
/* ------------ Output methods -------------- */
|
|
|
|
/**
|
|
* Output methods:
|
|
* aFormatType is a mime type, like text/plain.
|
|
*/
|
|
AString outputToString(in AString formatType,
|
|
in unsigned long flags);
|
|
void outputToStream(in nsIOutputStream aStream,
|
|
in AString formatType,
|
|
in ACString charsetOverride,
|
|
in unsigned long flags);
|
|
|
|
|
|
/* ------------ Various listeners methods --------------
|
|
* nsIEditor holds strong references to the editor observers, action listeners
|
|
* and document state listeners.
|
|
*/
|
|
|
|
/** add an EditorObserver to the editors list of observers. */
|
|
void addEditorObserver(in nsIEditorObserver observer);
|
|
|
|
/** Remove an EditorObserver from the editor's list of observers. */
|
|
void removeEditorObserver(in nsIEditorObserver observer);
|
|
|
|
/** add an EditActionListener to the editors list of listeners. */
|
|
void addEditActionListener(in nsIEditActionListener listener);
|
|
|
|
/** Remove an EditActionListener from the editor's list of listeners. */
|
|
void removeEditActionListener(in nsIEditActionListener listener);
|
|
|
|
/** Add a DocumentStateListener to the editors list of doc state listeners. */
|
|
void addDocumentStateListener(in nsIDocumentStateListener listener);
|
|
|
|
/** Remove a DocumentStateListener to the editors list of doc state listeners. */
|
|
void removeDocumentStateListener(in nsIDocumentStateListener listener);
|
|
|
|
|
|
/* ------------ Debug methods -------------- */
|
|
|
|
/**
|
|
* And a debug method -- show us what the tree looks like right now
|
|
*/
|
|
void dumpContentTree();
|
|
|
|
/** Dumps a text representation of the content tree to standard out */
|
|
void debugDumpContent() ;
|
|
|
|
/* Run unit tests. Noop in optimized builds */
|
|
void debugUnitTests(out long outNumTests, out long outNumTestsFailed);
|
|
|
|
/* checks if a node is read-only or not */
|
|
[notxpcom] boolean isModifiableNode(in nsIDOMNode aNode);
|
|
|
|
/* Set true if you want to suppress dispatching input event. */
|
|
attribute boolean suppressDispatchingInputEvent;
|
|
|
|
/**
|
|
* True if an edit action is being handled (in other words, between calls of
|
|
* nsIEditorObserver::BeforeEditAction() and nsIEditorObserver::EditAction()
|
|
* or nsIEditorObserver::CancelEditAction(). Otherwise, false.
|
|
*/
|
|
[noscript] readonly attribute boolean isInEditAction;
|
|
|
|
/**
|
|
* forceCompositionEnd() force the composition end
|
|
*/
|
|
void forceCompositionEnd();
|
|
|
|
/**
|
|
* Get preferred IME status of current widget.
|
|
*/
|
|
[noscript] IMEState getPreferredIMEState();
|
|
|
|
/**
|
|
* whether this editor has active IME transaction
|
|
*/
|
|
readonly attribute boolean composing;
|
|
};
|