Class Xinha

Object
   |
   +--Xinha

class Xinha

Defined in XinhaCore.js

Version: $Rev: 819 $ $LastChangedDate: 2007-04-20 01:20:22 +0200 (Fr, 20 Apr 2007) $

Field Detail

__htmlarea_id_num

integer __htmlarea_id_num

running number that identifies the current editor

_customUndo

<private> Boolean _customUndo

use our own undo implementation (true) or the browser's (false)

_doc

document _doc

The document object of the iframe.
Use this property to perform DOM operations on the edited document

_editMode

<private> string "wysiwyg"|"text" _editMode

the current editing mode

_framework

Object framework parts _framework

Holds the parts (table cells) of the UI (toolbar, panels, statusbar)

_htmlArea

<private> DomNode _htmlArea

Them whole thing (table)

_iframe

window _iframe

This is the actual editable area.
Technically it's an iframe that's made editable using window.designMode = 'on', respectively document.body.contentEditable = true (IE).
Use this property to get a grip on the iframe's window features

_initial_ta_size

<private> Object w,h _initial_ta_size

Before we modify anything, get the initial textarea size

_mdoc

<private> document _mdoc

the document object of the page Xinha is embedded in

_notifyListeners

<private> Object _notifyListeners

holds the events for use with the notifyOn/notifyOf system

_panels

<private> Array _panels

holds the panels

_statusBar

DomNode statusbar div _statusBar

The statusbar container

_statusBarItems

<private> Array tag names _statusBarItems

Holds the items of the DOM path that is shown in the statusbar in wysiwyg mode

_statusBarTextMode

<private> DomNode _statusBarTextMode

The message that is shown in the statusbar in text mode

_statusBarTree

<private> DomNode _statusBarTree

The DOM path that is shown in the statusbar in wysiwyg mode

_textArea

DomNode textarea _textArea

This property references the original textarea, which is at the same time the editor in text mode

_timerToolbar

<private> timeout _timerToolbar

periodically updates the toolbar

_timerUndo

<private> timeout _timerUndo

periodically takes a snapshot of the current editor content

_toolBar

<private> DomNode _toolBar

The toolbar

_toolbarObjects

<private> Object _toolbarObjects

Holds the botton objects

_undoPos

<private> integer _undoPos

the current position in the undo queue

_undoQueue

<private> Array _undoQueue

holds the undo snapshots

config

Xinha.Config config

The configuration used in the editor

doctype

<private> string doctype

doctype of the edited document (fullpage mode)

panels

<private> Object panels

plugins

<private> Object plugins

this object holds the plugins used in the editor

_addClasses

<static> Object _addClasses

Alias of Xinha.addClasses()

_blockTags

<private> <static> {String} _blockTags

List of tag names that are defined as block level elements in HTML

_closingTags

<static> Object _closingTags

_currentlyActiveEditor

<private> <static> {Xinha} _currentlyActiveEditor

Stores a reference to the currently active editor

_eventFlushers

<static> Array _eventFlushers

Holds the events to be flushed

_object

<private> <static> {Object} _object

Variable used to pass the object to the popup editor window.

_paraContainerTags

<private> <static> {String} _paraContainerTags

List of tag names that are allowed to contain a paragraph

_pluginLoadStatus

<private> <static> {Object} _pluginLoadStatus

Stores a status for each loading plugin that may be one of "loading","ready", or "failed"

_removeClasses

<static> Object _removeClasses

Alias of Xinha.removeClasses()

_someEditorHasBeenActivated

<private> <static> {Boolean} _someEditorHasBeenActivated

We need to know that at least one editor on the page has been activated this is because we will not focus any editor until an editor has been activated

addClass

<static> Object addClass

Alias of Xinha._addClass()

agt

<private> <static> Object agt

Cache the user agent for the following checks

ie_version

<static> string ie_version

Version Number, if browser is Microsoft Internet Explorer

is_designMode

<private> <static> string is_designMode

Editing is enabled by document.designMode (Gecko, Opera), as opposed to contenteditable (IE)

is_gecko

<static> string is_gecko

Browserengine is Gecko (Mozilla)

is_ie

<static> string is_ie

Browser is Microsoft Internet Explorer

is_khtml

<static> string is_khtml

Browserengine is KHTML (Konqueror, Safari)

is_mac

<static> string is_mac

OS is MacOS

is_mac_ie

<static> string is_mac_ie

Browser is Microsoft Internet Explorer Mac

is_opera

<static> string is_opera

Browser is Opera

is_safari

<static> string is_safari

Browser is Safari

is_win_ie

<static> string is_win_ie

Browser is Microsoft Internet Explorer Windows

isRunLocally

<private> <static> string isRunLocally

File is opened locally opened ("file://" protocol)

isSupportedBrowser

<private> <static> Boolean isSupportedBrowser

Cache result of checking for browser support

opera_version

<static> string opera_version

Version Number, if browser is Opera

RE_body

<static> RegExp RE_body

Finds body section in HTML

RE_doctype

<static> RegExp RE_doctype

Exracts DOCTYPE string from HTML

RE_email

<static> RegExp RE_email

Identifies email addresses

RE_head

<static> RegExp RE_head

Finds head section in HTML

RE_Specials

<private> <static> RegExp RE_Specials

Special characters that need to be escaped when dynamically creating a RegExp from an arbtrary string

RE_tagName

<static> RegExp RE_tagName

Identifies HTML tag names

RE_url

<static> RegExp RE_url

Identifies URLs

removeClass

<static> Object removeClass

Alias of Xinha.Xinha._removeClass()

toFree

<private> <static> Object toFree

List of objects that have to be trated on page unload in order to work around the broken Garbage Collector in IE

uniq_count

<private> <static> Object uniq_count

Index for Xinha.uniq function

version

<static> Object version

Xinha

Xinha(<String|DomNode> textarea, <Xinha.Config> config)

Creates a new Xinha object

Parameters:
textarea - the textarea to replace; can be either only the id or the DOM object as returned by document.getElementById()
config - optional if no Xinha.Config object is passed, the default config is used

Version: $Rev: 819 $ $LastChangedDate: 2007-04-20 01:20:22 +0200 (Fr, 20 Apr 2007) $

_activeElement

DomNode|null _activeElement(sel)

Alias of activeElement()

Deprecated

See:
- Xinha.activeElement()

_addToolbar

 <private> void _addToolbar()

FIXME: How can this be used??

_clearFonts

void _clearFonts()

Removes <font> tags; always cleans the whole editor content

_colorSelector

 <private> void _colorSelector(<String> cmdID)

Open a popup to select the hilitecolor or forecolor

Parameters:
cmdID - The commande ID (hilitecolor or forecolor)

_comboSelected

 <private> DomNode|null _comboSelected(<DomNode> el, <String> txt)

onChange handler for dropdowns in toolbar

Parameters:
el - Reference to the SELECT object
txt - The name of the select field, as in config.toolbar

_createImplicitBlock

void _createImplicitBlock(type)

What's this? does nothing, has to be removed

Deprecated

_createRange

Range _createRange(<Selection> sel)

Alias of createRange()

Parameters:
sel - Selection object

Deprecated

See:
- Xinha.createRange()

_createStatusBar

 <private> DomNode _createStatusBar()

creates the status bar

Returns:
status bar

_createToolbar

 <private> DomNode _createToolbar()

Creates the toolbar and appends it to the _htmlarea

Returns:
toolbar

_createToolbar1

 <private> DomNode _createToolbar1(editor, toolbar, tb_objects)

separate from previous createToolBar to allow dynamic change of toolbar

Returns:
toolbar

_editorEvent

Object _editorEvent(<Event> ev)

A generic event handler for things that happen in the IFRAME's document.
It provides two hooks for the "firePluginEvent" system:
"onKeyPress"
"onMouseDown"

Parameters:
ev -

See:
- Xinha.firePluginEvent()

_getAncestorBlock

DomNode|null _getAncestorBlock(<Selection> sel)

Traverses the DOM upwards and returns the first element that is a block level element

Parameters:
sel - Selection object as returned by getSelection

_getFirstAncestor

DomNode|null _getFirstAncestor(<Selection> sel, <Array> types)

Traverses the DOM upwards and returns the first element that is of one of the specified types

Parameters:
sel - Selection object as returned by getSelection
types - Array of HTML tag names (lower case)

_getSelection

Selection _getSelection()

Alias of getSelection()

Deprecated

See:
- Xinha.getSelection()

_popupDialog

void _popupDialog(<String> url, <Function> action, <Mixed> init)

Modal popup dialogs

Parameters:
url - URL to the popup dialog
action - A function that receives one value; this function will get called after the dialog is closed, with the return value of the dialog.
init - A variable that is passed to the popup window to pass arbitrary data

_selectionEmpty

Boolean _selectionEmpty(<Selection> sel)

Alias of selectionEmpty()

Parameters:
sel - Selection object as returned by getSelection

Deprecated

See:
- Xinha.selectionEmpty()

_setConfig

 <private> void _setConfig(config)

FIXME : function never used, can probably be removed from source

Deprecated

_shortCuts

 <private> void _shortCuts(<Event> ev)

Handles ctrl + key shortcuts

Parameters:
ev -

_splitBlock

void _splitBlock()

_toggleBorders

Boolean _toggleBorders()

Use some CSS trickery to toggle borders on tables

Returns:
always true

_undoTakeSnapshot

 <private> void _undoTakeSnapshot()

Takes a snapshot of the current text (for undo)

_wordClean

void _wordClean()

Cleans dirty HTML from MS word; always cleans the whole editor content

activateEditor

 <private> Boolean activateEditor()

Enables one editor for editing, e.g. by a click in the editing area or after it has been deactivated programmatically before

activeElement

DomNode|null activeElement(sel)

Returns the selected element, if any. That is, the element that you have last selected in the "path" at the bottom of the editor, or a "control" (eg image)

addPanel

DomNode addPanel(<String> side)

Creates a panel in the panel container on the specified side

Parameters:
side - the panel container to which the new panel will be added
Possible values are: "right","left","top","bottom"

Returns:
Panel div

convertNode

DomNode convertNode(<DomNode> el, <String> newTagName)

Changes the type of a given node

Parameters:
el - The element to convert
newTagName - The type the element will be converted to

Returns:
A reference to the new element

createRange

Range createRange(<Selection> sel)

Create a Range object from the given selection. Note that range objects are browser specific.

Parameters:
sel - Selection object

See:
- Xinha.getSelection()

deactivateEditor

 <private> void deactivateEditor()

Disables the editor

debugTree

void debugTree()

Utility function: Outputs the structure of the edited document

disableToolbar

void disableToolbar(<Array> except)

Disables (greys out) the buttons of the toolbar

Parameters:
except - this array contains ids of toolbar objects that will not be disabled

editorIsActivated

 <private> Boolean editorIsActivated()

Checks if editor is active
EDITOR ACTIVATION NOTES:
when a page has multiple Xinha editors, ONLY ONE should be activated at any time (this is mostly to work around a bug in Mozilla, but also makes some sense). No editor should be activated or focused automatically until at least one editor has been activated through user action (by mouse-clicking in the editor).

enableToolbar

void enableToolbar()

Enables the toolbar again when disabled by disableToolbar()

execCommand

Boolean execCommand(<String> cmdID, <Boolean> UI, <Mixed> param)

This is a wrapper for the browser's execCommand function that handles things like formatting, inserting elements, etc.
It intercepts some commands and replaces them with our own implementation.
It provides a hook for the "firePluginEvent" system ("onExecCommand").

For reference see:
Mozilla implementation
MS implementation

Parameters:
cmdID - command to be executed as defined in the browsers implemantations or Xinha custom
UI - for compatibility with the execCommand syntax; false in most (all) cases
param - Some commands require parameters

Returns:
always false

See:
- Xinha.firePluginEvent()

firePluginEvent

Boolean firePluginEvent(<String> methodName)

Call a method of all plugins which define the method using the supplied arguments.

Example: editor.firePluginEvent('onExecCommand', 'paste')
The plugin would then define a method
PluginName.prototype.onExecCommand = function (cmdID, UI, param) {do something...}

The following methodNames are currently available:


methodName	Parameters
onExecCommand	cmdID, UI, param
onKeyPress	ev
onMouseDown	ev



The browser specific plugin (if any) is called last. The result of each call is treated as boolean. A true return means that the event will stop, no further plugins will get the event, a false return means the event will continue to fire.

Parameters:
methodName -
arguments - to pass to the method, optional [2..n]

fixRelativeLinks

 <private> String fixRelativeLinks(<String> html)

Transforms the paths in src & href attributes

Parameters:
html -

Returns:
transformed HTML

See:
- Xinha.Config.expandRelativeUrl
- Xinha.Config.stripSelfNamedAnchors
- Xinha.Config.stripBaseHref
- Xinha.Config.baseHref

focusEditor

document focusEditor()

Focuses the iframe window.

Returns:
a reference to the editor document

forceRedraw

void forceRedraw()

Sometimes the display has to be refreshed to make DOM changes visible (?) (Gecko bug?)

generate

Boolean generate()

Creates the Xinha object and replaces the textarea with it. Loads required files.

getAllAncestors

Array getAllAncestors()

Returns an array with all the ancestor nodes of the selection or current cursor position.

getEditorContent

String getEditorContent()

Get the edited HTML

Returns:
HTML content

getHTML

 <private> String getHTML()

Get the raw edited HTML, should not be used without Xinha.prototype.outwardHtml()

Returns:
HTML content

getInnerHTML

 <private> String getInnerHTML()

retrieve the HTML (fastest version, but uses innerHTML)

Returns:
HTML content

getKey

String getKey(<Event> keyEvent)

Return the character (as a string) of a keyEvent - ie, press the 'a' key and this method will return 'a', press SHIFT-a and it will return 'A'.

Parameters:
keyEvent -

getParentElement

DomNode getParentElement(<Selection> sel)

Get the parent element of the supplied or current selection.

Parameters:
sel - optional selection as returned by getSelection

getSelectedHTML

String getSelectedHTML()

Get the HTML of the current selection. HTML returned has not been passed through outwardHTML.

getSelection

Selection getSelection()

Get a Selection object of the current selection. Note that selection objects are browser specific.

hasSelectedText

Boolean hasSelectedText()

Return true if we have some selection

hidePanel

void hidePanel(<DomNode> panel)

Hides a panel

Parameters:
panel - object as returned by Xinha.prototype.addPanel()

hidePanels

void hidePanels(<Array> sides)

Hides the panel(s) on one or more sides

Parameters:
sides - the sides on which the panels shall be hidden

imgURL

String imgURL(<String> file, <String> plugin)

Creates a path in the form _editor_url + "plugins/" + plugin + "/img/" + file

Parameters:
file - Name of the image
plugin - optional If omitted, simply _editor_url + file is returned

Deprecated

initIframe

 <private> Object initIframe()

Creates the iframe (editable area)

initSize

 <private> void initSize()

Size the editor according to the INITIAL sizing information. config.width The width may be set via three ways auto = the width is inherited from the original textarea toolbar = the width is set to be the same size as the toolbar = the width is an explicit size (any CSS measurement, eg 100em should be fine) config.height auto = the height is inherited from the original textarea = an explicit size measurement (again, CSS measurements) config.sizeIncludesBars true = the tool & status bars will appear inside the width & height confines false = the tool & status bars will appear outside the width & height confines

insertHTML

void insertHTML(<String> html)

Insert HTML at the current position, deleting the selection if any.

Parameters:
html -

insertNodeAtSelection

void insertNodeAtSelection(<DomNode> toBeInserted)

Insert a node at the current selection point.

Parameters:
toBeInserted -

inwardHtml

 <private> String inwardHtml(<String> html)

Performs various transformations of the HTML to be edited Plugins can provide their own, additional transformations by defining a plugin.prototype.inwardHtml() implematation, which is called by this function

Parameters:
html -

Returns:
transformed HTML

See:
- Xinha.outwardHtml()

inwardSpecialReplacements

 <private> String inwardSpecialReplacements(<String> html)

Apply the replacements defined in Xinha.Config.specialReplacements

Parameters:
html -

Returns:
transformed HTML

See:
- Xinha.outwardSpecialReplacements()

isKeyEvent

Boolean isKeyEvent(<Event> event)

Determine if the given event object is a keydown/press event.

Parameters:
event -

isShortCut

Boolean isShortCut(<Event> keyEvent)

Determines if the given key event object represents a combination of CTRL-, which for Xinha is a shortcut. Note that CTRL-ALT- is not a shortcut.

Parameters:
keyEvent -

notifyOf

void notifyOf(ev, args)

notifyOn

void notifyOn(ev, fn)

outwardHtml

 <private> String outwardHtml(<String> html)

Performs various transformations of the HTML used internally, complement to Xinha.prototype.inwardHtml() Plugins can provide their own, additional transformations by defining a plugin.prototype.outwardHtml() implematation, which is called by this function

Parameters:
html -

Returns:
HTML content

See:
- Xinha.inwardHtml()

outwardSpecialReplacements

 <private> String outwardSpecialReplacements(<String> html)

Apply the replacements defined in Xinha.Config.specialReplacements

Parameters:
html -

Returns:
transformed HTML

See:
- Xinha.inwardSpecialReplacements()

popupURL

String popupURL(<String> file)

Creates a path

Parameters:
file - Name of the popup

Deprecated

redo

 <private> void redo()

Custom implementation of redo functionality

registerPanel

void registerPanel(<string> side, object)

FIXME: Never used, what is this for?

Parameters:
side -
Object - }

registerPlugin

Object registerPlugin()

Create the specified plugin and register it with this Xinha return the plugin created to allow refresh when necessary.
This is only useful if Xinha is generated without using Xinha.makeEditors()

registerPlugin2

 <private> Object registerPlugin2(plugin, args)

This is the variant of the function above where the plugin arguments are already packed in an array. Externally, it should be only used in the full-screen editor code, in order to initialize plugins with the same parameters as in the opener window.

registerPlugins

 <private> void registerPlugins(<Array> plugin_names)

Registers the loaded plugins with the editor

Parameters:
plugin_names -

removeLoadingMessage

void removeLoadingMessage()

removePanel

void removePanel(<DomNode> panel)

Removes a panel

Parameters:
panel - object as returned by Xinha.prototype.addPanel()

restoreSelection

void restoreSelection(<Range> savedSelection)

Restores a selection previously stored

Parameters:
savedSelection - Range object as returned by Xinha.prototype.restoreSelection()

saveSelection

Range saveSelection()

Returns a range object to be stored and later restored with Xinha.prototype.restoreSelection()

scrollPos

Object scrollPos(<Window> scope)

Detect the current scroll position

Parameters:
scope - optional When calling from a popup window, pass its window object to get the values of the popup

Returns:
Object with Integer properties x and y

scrollToElement

void scrollToElement(<DomNode> e)

Scrolls the editor iframe to a given element or to the cursor

Parameters:
e - optional The element to scroll to; if ommitted, element the element the cursor is in

selectionEmpty

Boolean selectionEmpty(<Selection> sel)

Determines if the given selection is empty (collapsed).

Parameters:
sel - Selection object as returned by getSelection

selectNodeContents

void selectNodeContents(<DomNode> node,<Integer> pos)

Selects the contents of the given node. If the node is a "control" type element, (image, form input, table) the node itself is selected for manipulation.

Parameters:
node -
pos - Set to a numeric position inside the node to collapse the cursor here if possible.

setDoctype

 <private> void setDoctype(<String> doctype)

sets the given doctype (useful only when config.fullPage is true)

Parameters:
doctype -

setEditorContent

void setEditorContent(<String> html)

Completely change the HTML inside the editor

Parameters:
html - new content

setEditorEvents

 <private> void setEditorEvents()

Initialize some event handlers

setFullHTML

 <private> Object setFullHTML(<String> html)

Sets the HTML in fullpage mode. Actually the whole iframe document is rewritten.

Parameters:
html -

setHTML

 <private> void setHTML(<String> html)

Completely change the HTML inside

Parameters:
html - new content, should have been run through inwardHtml() first

setLoadingMessage

void setLoadingMessage(string)

setMode

Object setMode(<String> mode)

Switches editor mode between wysiwyg and text (HTML)

Parameters:
mode - optional "textmode" or "wysiwyg", if omitted, toggles between modes.

showPanel

void showPanel(<DomNode> panel)

Shows a panel

Parameters:
panel - object as returned by Xinha.prototype.addPanel()

showPanels

void showPanels(<Array> sides)

Shows the panel(s) on one or more sides

Parameters:
sides - the sides on which the panels shall be hidden

sizeEditor

void sizeEditor(<string> width, <string> height, <Boolean> includingBars, <Boolean> includingPanels)

Size the editor to a specific size, or just refresh the size (when window resizes for example)

Parameters:
width - optional width (CSS specification)
height - optional height (CSS specification)
includingBars - optional to indicate if the size should include or exclude tool & status bars
includingPanels - optional to indicate if the size should include or exclude panels

stripBaseURL

String stripBaseURL(<String> string)

Strips host-part of URL which is added by browsers to links relative to server root

Parameters:
string -

surroundHTML

 <private> void surroundHTML(startTag, endTag)

Call this function to surround the existing HTML code in the selection with your tags. FIXME: buggy! Don't use this

Deprecated

undo

 <private> void undo()

Custom implementation of undo functionality

updateToolbar

void updateToolbar(<Boolean> noStatus)

Updates enabled/disable/active state of the toolbar elements, the statusbar and other things This function is called on every key stroke as well as by a timer on a regular basis.
Plugins have the opportunity to implement a prototype.onUpdateToolbar() method, which will also be called by this function.

Parameters:
noStatus - private use Exempt updating of statusbar

whenDocReady

void whenDocReady(<Function> f)

Delay a function until the document is ready for operations. See ticket:547

Parameters:
f - The function to call once the document is ready

_addClass

<static> void _addClass(<DomNode> el, <String> className)

Adds one CSS class to a given element (that is, it expands its className property by the given string, separated by a space)

Parameters:
el - The DOM element the class will be added to
className - The class to be added

See:
- Xinha.addClasses()

_addEvent

<static> void _addEvent(<DomNode> el, <String> evname, <function> func)

adds an event listener for the specified element and event type

Parameters:
el - the DOM element the event should be attached to
evname - the name of the event to listen for (without leading "on")
func - the function to be called when the event is fired

See:
- Xinha._addEvents()
- Xinha.addDom0Event()
- Xinha.prependDom0Event()

_addEvents

<static> void _addEvents(<DomNode> el, <Array> evs, <function> func)

add several events at once to one element

Parameters:
el - the DOM element the event should be attached to
evs - the names of the event to listen for (without leading "on")
func - the function to be called when the event is fired

See:
- Xinha._addEvent()

_colorToRgb

<static> String _colorToRgb(<String|Integer> v)

Returns hexadecimal color representation from a number or a rgb-style color.

Parameters:
v - rgb(r,g,b) or 24bit color definition

Returns:
#RRGGBB color definition

_createToolbarBreakingElement

<static>  <private> DomNode _createToolbarBreakingElement()

Create a break element to add in the toolbar

Returns:
HTML element to add

_getback

<static> void _getback(<String> url, <Function> handler)

Use XMLHTTPRequest to receive some data from the server and do something with the it (asyncronously!)

Parameters:
url - The address for the HTTPRequest
handler - A function that is called when an answer is received from the server with the responseText as argument

_geturlcontent

<static> Object _geturlcontent(<String> url)

Use XMLHTTPRequest to receive some data from the server syncronously

Parameters:
url - The address for the HTTPRequest

_hasClass

<static> Boolean _hasClass(<DomNode> el, <String> className)

Checks if one element has set the given className

Parameters:
el - The DOM element to check
className - The class to be looked for

_lc

<static> Object _lc(<String> string, <String> context, <Object> replace)

Return a localised string.

Parameters:
string - English language string. It can also contain variables in the form "Some text with $variable=replaced text$". This replaces $variable in "Some text with $variable" with "replaced text"
context - Case sensitive context name, eg 'Xinha' (default), 'TableOperations'...
replace - Replace $variables in String, eg {foo: 'replaceText'} ($foo in string will be replaced by replaceText)

_loadback

<static> Object _loadback(<String> url, <Object> callback, <Object> scope, <Object> bonus)

Load a javascript file by inserting it in the HEAD tag and eventually call a function when loaded Note that this method cannot be abstracted into browser specific files because this method LOADS the browser specific files. Hopefully it should work for most browsers as it is.

Parameters:
url - Source url of the file to load
callback - optional Callback function to launch once ready
scope - optional Application scope for the callback function
bonus - optional Arbitrary object send as a param to the callback function

_loadlang

<static>  <private> Object _loadlang(<String> context,url)

Load a language file. This function should not be used directly, Xinha._lc will use it when necessary.

Parameters:
context - Case sensitive context name, eg 'Xinha', 'TableOperations', ...

_makeColor

<static> String _makeColor(v)

Creates a rgb-style rgb(r,g,b) color from a (24bit) number

Parameters:
Integer - }

Returns:
rgb(r,g,b) color definition

_postback

<static> void _postback(<String> url, <Object> data, <Function> handler)

Use XMLHTTPRequest to post some data back to the server and do something with the response (asyncronously!), this is used by such things as the tidy functions

Parameters:
url - The address for the HTTPRequest
data - The data to be passed to the server like {name:"value"}
handler - A function that is called when an answer is received from the server with the responseText as argument

_prepareForDom0Events

<static>  <private> void _prepareForDom0Events(el, ev)

Prepares an element to receive more than one DOM-0 event handler when handlers are added via addDom0Event and prependDom0Event.

_removeClass

<static> void _removeClass(<DomNode> el, <String> className)

Removes one CSS class (that is one of possible more parts separated by spaces) from a given element

Parameters:
el - The DOM element the class will be removed from
className - The class to be removed

See:
- Xinha._removeClasses

_removeEvent

<static> void _removeEvent(<DomNode> el, <String> evname, <function> func)

removes an event listener previously added

Parameters:
el - the DOM element the event should be removed from
evname - the name of the event the listener should be removed from (without leading "on")
func - the function to be removed

See:
- Xinha._removeEvents()

_removeEvents

<static> void _removeEvents(<DomNode> el, <Array> evs, <function> func)

remove several events at once to from element

Parameters:
el - the DOM element the events should be remove from
evs - the names of the events the listener should be removed from (without leading "on")
func - the function to be removed

See:
- Xinha._removeEvent()

_resolveRelativeUrl

<static> Object _resolveRelativeUrl( base, url )

_stopEvent

<static> void _stopEvent(<event> ev)

stops bubbling of the event, if no further listeners should be triggered

Parameters:
ev - the event to be stopped

addClasses

<static> void addClasses(<DomNode> el, <String> classes)

Adds CSS classes to a given element (that is, it expands its className property by the given string, separated by a space, thereby checking that no class is doubly added)

Parameters:
el - The DOM element the classes will be added to
classes - The classes to be added

See:
- Xinha.addClass

addCoreCSS

<static>  <private> String addCoreCSS(<String> html)

Adds styles for internal use to the edited document

Parameters:
html - optional

Returns:
html HTML with added styles or only styles if html omitted

See:
- Xinha.stripCoreCSS()

addDom0Event

<static> void addDom0Event(<DomNode> el, <String> ev, <function> fn)

Adds a standard "DOM-0" event listener to an element. The DOM-0 events are those applied directly as attributes to an element - eg element.onclick = stuff; By using this function instead of simply overwriting any existing DOM-0 event by the same name on the element it will trigger as well as the existing ones. Handlers are triggered one after the other in the order they are added. Remember to return true/false from your handler, this will determine whether subsequent handlers will be triggered (ie that the event will continue or be canceled).

Parameters:
el - the DOM element the event should be attached to
ev - the name of the event to listen for (without leading "on")
fn - the function to be called when the event is fired

See:
- Xinha._addEvent()
- Xinha.prependDom0Event()

arrayContainsArray

<static> Boolean arrayContainsArray(<Array> a1, <Array> a2)

Returns true if all elements of a2 are also contained in a1 (at least I think this is what it does)

Parameters:
a1 -
a2 -

arrayFilter

<static> Array arrayFilter(<Array> a1, <Function> filterfn)

Walks through an array and applies a filter function to each item

Parameters:
a1 - The array to filter
filterfn - If this function returns true, the item is added to the new array

Returns:
Filtered array

base64_decode

<static> String base64_decode(<String> input)

Utility function to base64_decode some arbitrary data, uses the builtin atob() if it exists (Moz)

Parameters:
input -

base64_encode

<static> String base64_encode(<String> input)

Utility function to base64_encode some arbitrary data, uses the builtin btoa() if it exists (Moz)

Parameters:
input -

checkSupportedBrowser

<static>  <private> Boolean checkSupportedBrowser()

Check if Xinha can run in the used browser, otherwise the textarea will be remain unchanged

cloneObject

<static>  <private> Object cloneObject(<Object> obj)

function that returns a clone of the given object

Parameters:
obj -

Returns:
cloned object

collectGarbageForIE

<static>  <private> void collectGarbageForIE()

IE's Garbage Collector is broken very badly. We will do our best to do it's job for it, but we can't be perfect. Takes all objects from Xinha.free and releases sets the null

See:
- Xinha.toFree
- Xinha.free()

collectionToArray

<static> Array collectionToArray(<Collection> collection)

Converts a Collection object to an array

Parameters:
collection - The array to filter

Returns:
Array containing the item of collection

createLoadingMessage

<static> Object createLoadingMessage(textarea,text)

createLoadingMessages

<static> void createLoadingMessages(xinha_editors)

escapeStringForRegExp

<static> Object escapeStringForRegExp(<string> string)

When dynamically creating a RegExp from an arbtrary string, some charactes that have special meanings in regular expressions have to be escaped. Run any string through this function to escape reserved characters.

Parameters:
string - the string to be escaped

Returns:
string

findPosX

<static> Integer findPosX(obj)

Find left pixel position of an element in the DOM.

Parameters:
element - HTML Element

findPosY

<static> Integer findPosY(obj)

Find top pixel position of an element in the DOM.

Parameters:
element - HTML Element

flushEvents

<static>  <private> void flushEvents()

Event Flushing To try and work around memory leaks in the rather broken garbage collector in IE, Xinha.flushEvents can be called onunload, it will remove any event listeners (that were added through _addEvent(s)) and clear any DOM-0 events.

free

<static>  <private> void free(obj, prop)

Release memory properties from object

Parameters:
object - The object to free memory
String - } prop optional The property to release

See:
- Xinha.collectGarbageForIE()
- Xinha.free()

freeLater

<static>  <private> void freeLater(obj,prop)

Adds objects to Xinha.toFree

Parameters:
object - The object to free memory
String - } prop optional The property to release

See:
- Xinha.toFree
- Xinha.free()
- Xinha.collectGarbageForIE()

getElementById

<static> DomNode getElementById(<String> tag, <String> id)

FIX: Internet Explorer returns an item having the _name_ equal to the given id, even if it's not having any id. This way it can return a different form field, even if it's not a textarea. This workarounds the problem by specifically looking to search only elements having a certain tag name.

Parameters:
tag - The tag name to limit the return to
id -

getElementTopLeft

<static> Object getElementTopLeft(<DomNode> element)

Calculate the top and left pixel position of an element in the DOM.

Parameters:
element - HTML Element

Returns:
Object with Integer properties top and left

getInnerText

<static> Object getInnerText(<DomNode> el)

Extracts the textual content of a given node

Parameters:
el -

getOuterHTML

<static> String getOuterHTML(<DomNode> element)

Return the HTML string of the given Element, including the Element.

Parameters:
element - HTML Element

getPluginDir

<static>  <private> String getPluginDir(<String> pluginName)

Dynamically returns the directory from which the plugins are loaded
This could be overridden to change the dir

Parameters:
pluginName -

Returns:
path to plugin

getXMLHTTPRequestObject

<static> XMLHTTPRequest getXMLHTTPRequestObject()

Get a new XMLHTTPRequest Object ready to be used.

hasDisplayedChildren

<static> Boolean hasDisplayedChildren(<DomNode> el)

Walks through the children of a given element and checks if any of the are visible (= not display:none)

Parameters:
el -

hasParentNode

<static> Boolean hasParentNode(<DomNode> el)

Checks if some element has a parent node

Parameters:
el -

htmlEncode

<static> String htmlEncode(<String> str)

Performs HTML encoding of some given string (converts HTML special characters to entities)

Parameters:
str - The unencoded input

Returns:
The encoded output

init

<static> void init()

isBlockElement

<static> Boolean isBlockElement(<DomNode> el)

Checks if one element is in the list of elements that are defined as block level elements in HTML

Parameters:
el - The DOM element to check

isParaContainer

<static> Boolean isParaContainer(<DomNode> el)

Checks if one element is in the list of elements that are allowed to contain a paragraph in HTML

Parameters:
el - The DOM element to check

loadPlugin

<static> Boolean loadPlugin(<String> pluginName, <Function> callback, <String> plugin_file)

Static function that loads the given plugin

Parameters:
pluginName -
callback - function to be called when file is loaded
plugin_file - URL of the file to load

Returns:
true if plugin loaded, false otherwise

loadPlugins

<static> Boolean loadPlugins(<Array> plugins, <Function> callbackIfNotReady)

Static function that loads the plugins (see xinha_plugins in NewbieGuide)

Parameters:
plugins -
callbackIfNotReady - function that is called repeatedly until all files are

Returns:
true if all plugins are loaded, false otherwise

loadStyle

<static> void loadStyle(<String> style, <String> plugin, <String> id)

Adds a stylesheet to the document

Parameters:
style - name of the stylesheet file
plugin - optional name of a plugin; if passed this function looks for the stylesheet file in the plugin directory
id - optional a unique id for identifiing the created link element, e.g. for avoiding double loading or later removing it again

makeBtnImg

<static>  <private> DomNode makeBtnImg(imgDef, doc)

creates a button (i.e. container element + image)

Returns:
conteainer element

makeEditors

<static> Object makeEditors(<Array> editor_names, <Xinha.Config> default_config, <Array> plugin_names)

Xinha's main loading function (see NewbieGuide)

Parameters:
editor_names -
default_config -
plugin_names -

Returns:
An object that contains references to all created editors indexed by the IDs of the textareas

needsClosingTag

<static> Boolean needsClosingTag(<DomNode> el)

Checks if one element is in the list of elements for which the end tag is not optional or forbidden in HTML

Parameters:
el - The DOM element to check

notImplemented

<static> void notImplemented(methodName)

objectProperties

<static> Array objectProperties(<Object> obj)

Returns an array containig all properties that are set in an object

Parameters:
obj -

onload

<static> void onload()

pageSize

<static> Object pageSize(<Window> scope)

Detect the size of the whole document

Parameters:
scope - optional When calling from a popup window, pass its window object to get the values of the popup

Returns:
Object with Integer properties x and y

prependDom0Event

<static> void prependDom0Event(el, ev, fn)

See addDom0Event, the difference is that handlers registered using prependDom0Event will be triggered before existing DOM-0 events of the same name on the same element.

Parameters:
the - DOM element the event should be attached to
the - name of the event to listen for (without leading "on")
the - function to be called when the event is fired

See:
- Xinha._addEvent()
- Xinha.addDom0Event()

refreshPlugin

<static>  <private> void refreshPlugin(<PluginInstance> plugin)

Refresh plugin by calling onGenerate or onGenerateOnce method.

Parameters:
plugin -

removeClasses

<static> Object removeClasses(<DomNode> el, classes)

Removes CSS classes (that is one or more of possibly several parts separated by spaces) from a given element

Parameters:
el - The DOM element the class will be removed from
className - The class to be removed

See:
- Xinha._removeClasses

removeFromParent

<static> DomNode removeFromParent(<DomNode> el)

Removes a node from the DOM

Parameters:
el - The element to be removed

Returns:
The removed element

removeLoadingMessages

<static> void removeLoadingMessages(xinha_editors)

replace

<static> Object replace(<string> id, config)

Helper function: replaces the TEXTAREA with the given ID with Xinha.

Parameters:
id - id of the textarea to replace
optional - config

replaceAll

<static> void replaceAll(config)

Helper function: replace all TEXTAREA-s in the document with Xinha-s.

Parameters:
optional - config

setLoadingMessage

<static> void setLoadingMessage(string)

startEditors

<static> void startEditors(<Object> editors)

Another main loading function (see NewbieGuide)

Parameters:
editors - As returned by Xinha.makeEditors()

stripCoreCSS

<static>  <private> String stripCoreCSS(<String> html)

Remove internal styles

Parameters:
html -

See:
- Xinha.addCoreCSS()

uniq

<static> String uniq(<String> prefix)

Returns a string that is unique on the page

Parameters:
prefix - This string is prefixed to a running number

viewportSize

<static> Object viewportSize(<Window> scope)

Detect the size of visible area

Parameters:
scope - optional When calling from a popup window, pass its window object to get the values of the popup

Returns:
Object with Integer properties x and y