Class mozile.edit

Object
   |
   +--mozile.Module
         |
         +--mozile.edit

class mozile.edit

extends mozile.Module

Field Detail

_isHigherThan

<static> Object _isHigherThan

Look-up table for comparing change types.

allCommands

<static> Object allCommands

An associative array of all the Command objects (including subclasses) in this document. Keys are command names, and values are the command objects.

clipboard

<static> DocumentFragment clipboard

The local clipboard. Contains document fragments created using the copy and cut commands.

commands

<static> mozile.edit.CommandGroup commands

A CommandGroup which will contain the global commands.

copy

<static> mozile.edit.Command copy

Copies the current selection to the clipboard.

currentState

<static> mozile.edit.State currentState

The current state.

cut

<static> mozile.edit.Command cut

Copies the current selection to the clipboard, then removes it.

debug

<static> mozile.edit.Command debug

Shows debugging information.

defaults

<static> mozile.edit.CommandGroup defaults

A CommandGroup which will contain default commands.

editable

<static> Boolean editable

Indicates whether Mozile is currently allowed to edit the document. A value of "true" means the document can be edited. A value of "false" means that editing is disabled.

executionGroup

<static> mozile.edit.Command executionGroup

Used to execute a set of commands, with no action of its own.

findText

<static> mozile.edit.Command findText

Searches for text in the editor.

indentList

<static> mozile.edit.Command indentList

Move the node before its next sibling.

insert

<static> Object insert

insertNode

<static> mozile.edit.Command insertNode

Removes a node from the document.

insertText

<static> mozile.edit.Command insertText

Inserts text into a text node.

keyCodes

<static> Object keyCodes

An associative array of keyCodes and their standard names. Used to convert keyCode to strings in accelerators. See: http://www.xulplanet.com/references/objref/KeyboardEvent.html TODO: Make sure this is not Mozilla-centric.

marked

<static> Array marked

An array of all elements marked with setMark().

mergeNodes

<static> mozile.edit.Command mergeNodes

Merges two nodes, appending the children of the second node to the first node.

moveNode

<static> mozile.edit.Command moveNode

Moves a node from one location in the document to another.

moveNodeNext

<static> mozile.edit.Command moveNodeNext

Move the node before its next sibling.

moveNodePrevious

<static> mozile.edit.Command moveNodePrevious

Move the node before its previous sibling.

navigateLeftRight

<static> mozile.edit.Command navigateLeftRight

Inserts text into a text node.

NEXT

<static> Integer NEXT

Flag for editing direction.

paste

<static> mozile.edit.Command paste

Copies the current selection to the clipboard.

PREVIOUS

<static> Integer PREVIOUS

Flag for editing direction.

redo

<static> mozile.edit.Command redo

Executes the current command in the global undo stack.

remove

<static> mozile.edit.Command remove

Removes text and nodes from a range.

removeFormatting

<static> Object removeFormatting

removeNode

<static> mozile.edit.Command removeNode

Removes a node from the document.

removeText

<static> mozile.edit.Command removeText

Removes text from a node.

replaceText

<static> mozile.edit.Command replaceText

Replaces all occurrences of the target text with a replacement.

rich

<static> Boolean rich

Indicates the rich editing commands have been defined.

save

<static> mozile.edit.Command save

Shows document source.

setAttribute

<static> Object setAttribute

showHidden

<static> mozile.edit.Command showHidden

Display

source

<static> mozile.edit.Command source

Shows document source.

splitNode

<static> mozile.edit.Command splitNode

Splits a node by cloning it, inserting the clone after the original, and moving all the original's children after the cursor into the clone.

splitNodes

<static> mozile.edit.Command splitNodes

Splits mutliple nodes.

status

<static> Boolean status

Indicates Mozile's current editing status. A value of "true" means the document is being edited. A value of "false" means that editing is currently disabled.

strings

<static> Object strings

Translations strings for the commands.

test

<static> mozile.edit.Command test

A command used for testing purposes only.

tweak

<static> mozile.edit.Command tweak

A tweaking command. For testing only

undo

<static> mozile.edit.Command undo

Reverses the action of the last command in the global undo stack.

unindentList

<static> Object unindentList

checkAccelerator

<static> Boolean checkAccelerator(<Event> event, <String> accelerator)

Check an event against an "accelerator" string (i.e. a specified key combination) or array of strings. Examples of accelerators: "Command-D", "Command-Shift-D". "Command" is translated as "Control" under Windows and Linux, and "Meta" under Mac OS.

Note: The sequence is important. The order must be "Command-Meta-Control-Alt-Shift-UpperCaseCharacter". (Comparison is done using lower case. Not all combinations will work on all platforms.)

Parameters:
event - The event to check.
accelerator - A string denoting the key combination(s).

checkAccelerators

<static> Boolean checkAccelerators(<Event> event, accelerators)

Check an event against an array of "accelerator" strings (i.e. a specified key combination) or array of strings.

Parameters:
event - The event to check.
accelerator - An array of strings denoting the key combination(s).

containsEmptyToken

<static> Boolean containsEmptyToken(<Node> node, <Integer> offset)

Determines whether a text node ends with an empty token instance.

Parameters:
node - The text node to check.
offset - Optional. An offset within the text node. The method will look for an empty token immediately after this offset. If none is given, the method searches for any empty token.

convertKeyCode

<static> String convertKeyCode(<Integer> keyCode)

Converts a key code to a key name. E.g. 14 becomes "Enter".

Parameters:
keyCode - The key code to convert.

createEmptyToken

<static> Text createEmptyToken()

Creates an empty token node.

done

<static> Void done(<mozile.edit.State> state)

Records the result of a command in such a way that it can be undone.

Parameters:
state - The state to record. Expected to be the result of a Command's execute method.

dumpUndoStack

<static> Void dumpUndoStack()

Displays the contents of the undo stack.

extendRNG

<static> Void extendRNG()

Add command functionality to the RNG system.

followMESRef

<static> Element followMESRef(<Element> element)

Follow an MES reference and return an MES define element. Currently only works for define elements immediately under the root of the document that the ref element belongs to.

Parameters:
element - The "ref" element to follow.

generateAccelerator

<static> String generateAccelerator(<Event> event)

Takes an event and returns a representation of the event as an accelerator string.

Parameters:
event - The event to generate the accelerator from.

generateCommand

<static> mozile.rng.Command generateCommand(node, <Object> localization)

Generate a Mozile command from an RNG Element.

Parameters:
localization - Optional. The localization to use.
rng - The RNG element to generate commands for.

generateCommands

<static> Void generateCommands(<mozile.rng.Schema> schema, <Object> localization)

For each RNG Element in the given schema, add all of the appropriate commands.

Parameters:
schema - The schema to generate commands for.
localization - Optional. The localization to use.

getCommand

<static> mozile.edit.Command getCommand(<String> name)

Gets a command from the list of all commands.

Parameters:
name - The name of the command.

getContainer

<static> Element getContainer(<Element> element)

Searches for an ancestor which mas been marked by Mozile as editable. Containers themselves should not be edited, but the nodes they contain can be. Elements with the "contentEditable" attribute set to true are marked as editable when found.

Parameters:
element - The element to check.

getCurrentState

<static> State getCurrentState(<Document> doc)

Sets the current state. Uses the undoIndex to find the state in the undoStack.

Parameters:
doc - Optional. The target document.

getInsertionPoint

<static> mozile.edit.InsertionPoint getInsertionPoint(<Node> node, <Integer> direction, <Boolean> force)

Get the first insertion point in the given node and the given direction. If the direction is "next" then the first point is returned. If the direction is "previous" then the last point us returned.

Parameters:
node - The node to search for an insertion point.
direction - A coded integer. Can be NEXT (1) or PREVIOUS (-1).
force - Optional. When true the fact that the given node is not editable is ignored.

getMark

<static> Object getMark(<Element> element, <String> key)

Gets a property of a special "mozile" object belonging to an element.

Parameters:
element - The element to get check.
key - The name of the property to set. Must be a valid JavaScript property name.

Returns:
The value, if set. Otherwise undefined.

getMarked

<static> Array getMarked(<String> key, <String> value)

Gets an array of all elements marked with matching key and value.

Parameters:
key - The name of the property to set. Must be a valid JavaScript property name.
value - Optional. The value to check for. If non is given, any value is accepted.

getParentBlock

<static> Element getParentBlock(<Node> node)

Returns the node if it is a block, or the first ancestor which is a block.

Parameters:
node -

isBlock

<static> Boolean isBlock(<Node> node)

A temporary hack to check whether a node is a block level element or not. TODO: Replace with an RNG based method.

Parameters:
node -

isChildless

<static> Boolean isChildless(<Node> node)

A temporary hack to check whether a node can have child nodes. TODO: Replace with an RNG based method.

Parameters:
node -

isEditable

<static> Boolean isEditable(<Node> node)

Detect whether this node is inside an editable container element.

Parameters:
node - The node to check.

isEditableElement

<static> Boolean isEditableElement(<Element> element)

Determines whether this element has been marked as editable by Mozile.

Parameters:
element - The element to check.

isEmpty

<static> Boolean isEmpty(<Node> node)

Determines whether a node is empty: it contains no non-white-space text and no empty tokens inside any of its children.

Parameters:
node - The node to check.

isEmptyToken

<static> Boolean isEmptyToken(<Node> node)

Determines whether a node is an "empty token" instance. That is, is it a text node which contains only the mozile.emptyToken character(s)?

Parameters:
node - The text node to check.

isHigherPriority

<static> Boolean isHigherPriority(<String> higher, <String> lower)

Compares two change types to determine if one is higher priority than the other.

Parameters:
higher - The first change type to test.
lower - The second change type to test.

isTextEditable

<static> Boolean isTextEditable(<Node> node)

Checks a text node to see if it is editable. Only non-white-space and empty token nodes are editable.

Parameters:
node - The node to check.

lookupRNG

<static> mozile.rng.Element lookupRNG(<Node> node)

Gets the mozile.rng.Element object which corresponds to the given element. Currently returns the first RNG object of type "element" with a name matching the given element's nodeName (changed to lower case). TODO: Should be smarter.

Parameters:
node - The node to find the RNG rule for.

mayContainText

<static> Boolean mayContainText(<Node> node)

Checks a node to see if it may contain non-whitespace text. If an element is given, it is checked. If a text node is given, the parent element is checked. For all other nodes the method retuns false. If there is an RNG rule which allows the element to contain text, then the method returns true. If there is no RNG rule, but the element contains non-white-space text node children, then the method returns true. Otherwise it return false.

Parameters:
node - The node to check.

parseAccelerator

<static> Object parseAccelerator(<String> accelerator)

Takes an accelerator string and returns an object with easy-to-use properties.

Parameters:
accelerator - The accelerator string to check. See

Returns:
The returned object has Boolean properties for: command, meta, ctrl, alt, and shift, and integer "charCode", and a string "character" and a string "abbr".

See:
- mozile.edit.checkAccelerator

parseMES

<static> Void parseMES(<mozile.edit.Command> container, node, <Object> localization)

Search through the children of the given node (following any references) for MES definitions.

Parameters:
container - The Command object to attach new commands to.
localization - Optional. The localization to use.

setMark

<static> Object setMark(<Element> element, <String> key, value)

Sets a property of a special "mozile" object for an element, which stores data for Mozile to use. Note: this is restricted to elements because of limitations with IE6. Warning: Won't work for XML element in IE6.

Parameters:
element - The element to mark.
key - The name of the property to set. Must be a valid JavaScript property name.
value - The value for the new property.

Returns:
The value, if set. Otherwise null.

setStatus

<static> Boolean setStatus(<Boolean> status)

Sets the editing status for the document. In browsers that do not support contentEditable, the document.designMode is turned on or off. If the status is already set to the desired value, nothing is changed.

Parameters:
status - The desired editing status.

splitAccelerators

<static> Array splitAccelerators(<String> accelerators)

Splits a space-separated list of accelerator strings, and cleans them.

Parameters:
accelerators - A space-separated list of accelerators.

start

<static> Boolean start()

Enables editing of the current document. All elements marked as "editingDisabled" will have their contentEditable attributes set to "true".

stop

<static> Boolean stop()

Disables editing of the current document. All elements in the document that have their contentEditable attribute set to "true" will be marked as "editingDisabled" and contentEditable will be set to "false. This prevents further editing in IE.

updateClipboard

<static> Void updateClipboard()

Updates the local clipboard with data from the system clipboard, when possible.