Wiki2GoEditor 1.0.0

data/fckeditor/editor/_source/classes/fckevents.js

@@ -0,0 +1,53 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ *  - GNU General Public License Version 2 or later (the "GPL")
+ *    http://www.gnu.org/licenses/gpl.html
+ *
+ *  - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ *    http://www.gnu.org/licenses/lgpl.html
+ *
+ *  - Mozilla Public License Version 1.1 or later (the "MPL")
+ *    http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * FCKEvents Class: used to handle events is a advanced way.
+ */
+
+var FCKEvents = function( eventsOwner )
+{
+	this.Owner = eventsOwner ;
+	this._RegisteredEvents = new Object() ;
+}
+
+FCKEvents.prototype.AttachEvent = function( eventName, functionPointer )
+{
+	var aTargets ;
+
+	if ( !( aTargets = this._RegisteredEvents[ eventName ] ) )
+		this._RegisteredEvents[ eventName ] = [ functionPointer ] ;
+	else
+		aTargets.push( functionPointer ) ;
+}
+
+FCKEvents.prototype.FireEvent = function( eventName, params )
+{
+	var bReturnValue = true ;
+
+	var oCalls = this._RegisteredEvents[ eventName ] ;
+
+	if ( oCalls )
+	{
+		for ( var i = 0 ; i < oCalls.length ; i++ )
+			bReturnValue = ( oCalls[ i ]( this.Owner, params ) && bReturnValue ) ;
+	}
+
+	return bReturnValue ;
+}

data/fckeditor/editor/_source/classes/fckicon.js

@@ -0,0 +1,98 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ *  - GNU General Public License Version 2 or later (the "GPL")
+ *    http://www.gnu.org/licenses/gpl.html
+ *
+ *  - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ *    http://www.gnu.org/licenses/lgpl.html
+ *
+ *  - Mozilla Public License Version 1.1 or later (the "MPL")
+ *    http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * FCKIcon Class: renders an icon from a single image, a strip or even a
+ * spacer.
+ */
+
+var FCKIcon = function( iconPathOrStripInfoArray )
+{
+	var sTypeOf = iconPathOrStripInfoArray ? typeof( iconPathOrStripInfoArray ) : 'undefined' ;
+	switch ( sTypeOf )
+	{
+		case 'number' :
+			this.Path = FCKConfig.SkinPath + 'fck_strip.gif' ;
+			this.Size = 16 ;
+			this.Position = iconPathOrStripInfoArray ;
+			break ;
+
+		case 'undefined' :
+			this.Path = FCK_SPACER_PATH ;
+			break ;
+
+		case 'string' :
+			this.Path = iconPathOrStripInfoArray ;
+			break ;
+
+		default :
+			// It is an array in the format [ StripFilePath, IconSize, IconPosition ]
+			this.Path		= iconPathOrStripInfoArray[0] ;
+			this.Size		= iconPathOrStripInfoArray[1] ;
+			this.Position	= iconPathOrStripInfoArray[2] ;
+	}
+}
+
+FCKIcon.prototype.CreateIconElement = function( document )
+{
+	var eIcon, eIconImage ;
+
+	if ( this.Position )		// It is using an icons strip image.
+	{
+		var sPos = '-' + ( ( this.Position - 1 ) * this.Size ) + 'px' ;
+
+		if ( FCKBrowserInfo.IsIE )
+		{
+			// <div class="TB_Button_Image"><img src="strip.gif" style="top:-16px"></div>
+
+			eIcon = document.createElement( 'DIV' ) ;
+
+			eIconImage = eIcon.appendChild( document.createElement( 'IMG' ) ) ;
+			eIconImage.src = this.Path ;
+			eIconImage.style.top = sPos ;
+		}
+		else
+		{
+			// <img class="TB_Button_Image" src="spacer.gif" style="background-position: 0px -16px;background-image: url(strip.gif);">
+
+			eIcon = document.createElement( 'IMG' ) ;
+			eIcon.src = FCK_SPACER_PATH ;
+			eIcon.style.backgroundPosition	= '0px ' + sPos ;
+			eIcon.style.backgroundImage		= 'url(' + this.Path + ')' ;
+		}
+	}
+	else					// It is using a single icon image.
+	{
+		// This is not working well with IE. See notes bellow.
+		// <img class="TB_Button_Image" src="smiley.gif">
+//		eIcon = document.createElement( 'IMG' ) ;
+//		eIcon.src = this.Path ? this.Path : FCK_SPACER_PATH ;
+
+		// IE makes the button 1px higher if using the <img> directly, so we
+		// are changing to the <div> system to clip the image correctly.
+		eIcon = document.createElement( 'DIV' ) ;
+
+		eIconImage = eIcon.appendChild( document.createElement( 'IMG' ) ) ;
+		eIconImage.src = this.Path ? this.Path : FCK_SPACER_PATH ;
+	}
+
+	eIcon.className = 'TB_Button_Image' ;
+
+	return eIcon ;
+}

data/fckeditor/editor/_source/classes/fckiecleanup.js

@@ -0,0 +1,68 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ *  - GNU General Public License Version 2 or later (the "GPL")
+ *    http://www.gnu.org/licenses/gpl.html
+ *
+ *  - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ *    http://www.gnu.org/licenses/lgpl.html
+ *
+ *  - Mozilla Public License Version 1.1 or later (the "MPL")
+ *    http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * FCKIECleanup Class: a generic class used as a tool to remove IE leaks.
+ */
+
+var	FCKIECleanup = function( attachWindow )
+{
+	// If the attachWindow already have a cleanup object, jusgt use that one.
+	if ( attachWindow._FCKCleanupObj )
+		this.Items = attachWindow._FCKCleanupObj.Items ;
+	else
+	{
+		this.Items = new Array() ;
+
+		attachWindow._FCKCleanupObj = this ;
+		FCKTools.AddEventListenerEx( attachWindow, 'unload', FCKIECleanup_Cleanup ) ;
+//		attachWindow.attachEvent( 'onunload', FCKIECleanup_Cleanup ) ;
+	}
+}
+
+FCKIECleanup.prototype.AddItem = function( dirtyItem, cleanupFunction )
+{
+	this.Items.push( [ dirtyItem, cleanupFunction ] ) ;
+}
+
+function FCKIECleanup_Cleanup()
+{
+	if ( !this._FCKCleanupObj )
+		return ;
+
+	var aItems = this._FCKCleanupObj.Items ;
+
+	while ( aItems.length > 0 )
+	{
+
+		// It is important to remove from the end to the beginning (pop()),
+		// because of the order things get created in the editor. In the code,
+		// elements in deeper position in the DOM are placed at the end of the
+		// cleanup function, so we must cleanup then first, otherwise IE could
+		// throw some crazy memory errors (IE bug).
+		var oItem = aItems.pop() ;
+		if ( oItem )
+			oItem[1].call( oItem[0] ) ;
+	}
+
+	this._FCKCleanupObj = null ;
+
+	if ( CollectGarbage )
+		CollectGarbage() ;
+}

data/fckeditor/editor/_source/classes/fckimagepreloader.js

@@ -0,0 +1,68 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ *  - GNU General Public License Version 2 or later (the "GPL")
+ *    http://www.gnu.org/licenses/gpl.html
+ *
+ *  - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ *    http://www.gnu.org/licenses/lgpl.html
+ *
+ *  - Mozilla Public License Version 1.1 or later (the "MPL")
+ *    http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * Preload a list of images, firing an event when complete.
+ */
+
+var FCKImagePreloader = function()
+{
+	this._Images = new Array() ;
+}
+
+FCKImagePreloader.prototype =
+{
+	AddImages : function( images )
+	{
+		if ( typeof( images ) == 'string' )
+			images = images.split( ';' ) ;
+
+		this._Images = this._Images.concat( images ) ;
+	},
+
+	Start : function()
+	{
+		var aImages = this._Images ;
+		this._PreloadCount = aImages.length ;
+
+		for ( var i = 0 ; i < aImages.length ; i++ )
+		{
+			var eImg = document.createElement( 'img' ) ;
+			eImg.onload = eImg.onerror = _FCKImagePreloader_OnImage ;
+			eImg._FCKImagePreloader = this ;
+			eImg.src = aImages[i] ;
+
+			_FCKImagePreloader_ImageCache.push( eImg ) ;
+		}
+	}
+};
+
+// All preloaded images must be placed in a global array, otherwise the preload
+// magic will not happen.
+var _FCKImagePreloader_ImageCache = new Array() ;
+
+function _FCKImagePreloader_OnImage()
+{
+	var oImagePreloader = this._FCKImagePreloader ;
+
+	if ( (--oImagePreloader._PreloadCount) == 0 && oImagePreloader.OnComplete )
+		oImagePreloader.OnComplete() ;
+
+	this._FCKImagePreloader = null ;
+}

data/fckeditor/editor/_source/classes/fckkeystrokehandler.js

@@ -0,0 +1,136 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ *  - GNU General Public License Version 2 or later (the "GPL")
+ *    http://www.gnu.org/licenses/gpl.html
+ *
+ *  - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ *    http://www.gnu.org/licenses/lgpl.html
+ *
+ *  - Mozilla Public License Version 1.1 or later (the "MPL")
+ *    http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * Control keyboard keystroke combinations.
+ */
+
+var FCKKeystrokeHandler = function( cancelCtrlDefaults )
+{
+	this.Keystrokes = new Object() ;
+	this.CancelCtrlDefaults = ( cancelCtrlDefaults !== false ) ;
+}
+
+/*
+ * Listen to keystroke events in an element or DOM document object.
+ *		@target: The element or document to listen to keystroke events.
+ */
+FCKKeystrokeHandler.prototype.AttachToElement = function( target )
+{
+	// For newer browsers, it is enough to listen to the keydown event only.
+	// Some browsers instead, don't cancel key events in the keydown, but in the
+	// keypress. So we must do a longer trip in those cases.
+	FCKTools.AddEventListenerEx( target, 'keydown', _FCKKeystrokeHandler_OnKeyDown, this ) ;
+	if ( FCKBrowserInfo.IsGecko10 || FCKBrowserInfo.IsOpera || ( FCKBrowserInfo.IsGecko && FCKBrowserInfo.IsMac ) )
+		FCKTools.AddEventListenerEx( target, 'keypress', _FCKKeystrokeHandler_OnKeyPress, this ) ;
+}
+
+/*
+ * Sets a list of keystrokes. It can receive either a single array or "n"
+ * arguments, each one being an array of 1 or 2 elemenst. The first element
+ * is the keystroke combination, and the second is the value to assign to it.
+ * If the second element is missing, the keystroke definition is removed.
+ */
+FCKKeystrokeHandler.prototype.SetKeystrokes = function()
+{
+	// Look through the arguments.
+	for ( var i = 0 ; i < arguments.length ; i++ )
+	{
+		var keyDef = arguments[i] ;
+
+		if ( typeof( keyDef[0] ) == 'object' )		// It is an array with arrays defining the keystrokes.
+			this.SetKeystrokes.apply( this, keyDef ) ;
+		else
+		{
+			if ( keyDef.length == 1 )		// If it has only one element, removed the keystroke.
+				delete this.Keystrokes[ keyDef[0] ] ;
+			else							// Otherwise add it.
+				this.Keystrokes[ keyDef[0] ] = keyDef[1] === true ? true : keyDef ;
+		}
+	}
+}
+
+function _FCKKeystrokeHandler_OnKeyDown( ev, keystrokeHandler )
+{
+	// Get the key code.
+	var keystroke = ev.keyCode || ev.which ;
+
+	// Combine it with the CTRL, SHIFT and ALT states.
+	var keyModifiers = 0 ;
+
+	if ( ev.ctrlKey || ev.metaKey )
+		keyModifiers += CTRL ;
+
+	if ( ev.shiftKey )
+		keyModifiers += SHIFT ;
+
+	if ( ev.altKey )
+		keyModifiers += ALT ;
+
+	var keyCombination = keystroke + keyModifiers ;
+
+	var cancelIt = keystrokeHandler._CancelIt = false ;
+
+	// Look for its definition availability.
+	var keystrokeValue = keystrokeHandler.Keystrokes[ keyCombination ] ;
+
+//	FCKDebug.Output( 'KeyDown: ' + keyCombination + ' - Value: ' + keystrokeValue ) ;
+
+	// If the keystroke is defined
+	if ( keystrokeValue )
+	{
+		// If the keystroke has been explicetly set to "true" OR calling the
+		// "OnKeystroke" event, it doesn't return "true", the default behavior
+		// must be preserved.
+		if ( keystrokeValue === true || !( keystrokeHandler.OnKeystroke && keystrokeHandler.OnKeystroke.apply( keystrokeHandler, keystrokeValue ) ) )
+			return true ;
+
+		cancelIt = true ;
+	}
+
+	// By default, it will cancel all combinations with the CTRL key only (except positioning keys).
+	if ( cancelIt || ( keystrokeHandler.CancelCtrlDefaults && keyModifiers == CTRL && ( keystroke < 33 || keystroke > 40 ) ) )
+	{
+		keystrokeHandler._CancelIt = true ;
+
+		if ( ev.preventDefault )
+			return ev.preventDefault() ;
+
+		ev.returnValue = false ;
+		ev.cancelBubble = true ;
+		return false ;
+	}
+
+	return true ;
+}
+
+function _FCKKeystrokeHandler_OnKeyPress( ev, keystrokeHandler )
+{
+	if ( keystrokeHandler._CancelIt )
+	{
+//		FCKDebug.Output( 'KeyPress Cancel', 'Red') ;
+
+		if ( ev.preventDefault )
+			return ev.preventDefault() ;
+
+		return false ;
+	}
+
+	return true ;
+}

data/fckeditor/editor/_source/classes/fckmenublock.js

@@ -0,0 +1,143 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ *  - GNU General Public License Version 2 or later (the "GPL")
+ *    http://www.gnu.org/licenses/gpl.html
+ *
+ *  - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ *    http://www.gnu.org/licenses/lgpl.html
+ *
+ *  - Mozilla Public License Version 1.1 or later (the "MPL")
+ *    http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * Renders a list of menu items.
+ */
+
+var FCKMenuBlock = function()
+{
+	this._Items	= new Array() ;
+}
+
+
+FCKMenuBlock.prototype.Count = function()
+{
+	return this._Items.length ;
+}
+
+FCKMenuBlock.prototype.AddItem = function( name, label, iconPathOrStripInfoArrayOrIndex, isDisabled )
+{
+	var oItem = new FCKMenuItem( this, name, label, iconPathOrStripInfoArrayOrIndex, isDisabled ) ;
+
+	oItem.OnClick		= FCKTools.CreateEventListener( FCKMenuBlock_Item_OnClick, this ) ;
+	oItem.OnActivate	= FCKTools.CreateEventListener( FCKMenuBlock_Item_OnActivate, this ) ;
+
+	this._Items.push( oItem ) ;
+
+	return oItem ;
+}
+
+FCKMenuBlock.prototype.AddSeparator = function()
+{
+	this._Items.push( new FCKMenuSeparator() ) ;
+}
+
+FCKMenuBlock.prototype.RemoveAllItems = function()
+{
+	this._Items = new Array() ;
+
+	var eItemsTable = this._ItemsTable ;
+	if ( eItemsTable )
+	{
+		while ( eItemsTable.rows.length > 0 )
+			eItemsTable.deleteRow( 0 ) ;
+	}
+}
+
+FCKMenuBlock.prototype.Create = function( parentElement )
+{
+	if ( !this._ItemsTable )
+	{
+		if ( FCK.IECleanup )
+			FCK.IECleanup.AddItem( this, FCKMenuBlock_Cleanup ) ;
+
+		this._Window = FCKTools.GetElementWindow( parentElement ) ;
+
+		var oDoc = FCKTools.GetElementDocument( parentElement ) ;
+
+		var eTable = parentElement.appendChild( oDoc.createElement( 'table' ) ) ;
+		eTable.cellPadding = 0 ;
+		eTable.cellSpacing = 0 ;
+
+		FCKTools.DisableSelection( eTable ) ;
+
+		var oMainElement = eTable.insertRow(-1).insertCell(-1) ;
+		oMainElement.className = 'MN_Menu' ;
+
+		var eItemsTable = this._ItemsTable = oMainElement.appendChild( oDoc.createElement( 'table' ) ) ;
+		eItemsTable.cellPadding = 0 ;
+		eItemsTable.cellSpacing = 0 ;
+	}
+
+	for ( var i = 0 ; i < this._Items.length ; i++ )
+		this._Items[i].Create( this._ItemsTable ) ;
+}
+
+/* Events */
+
+function FCKMenuBlock_Item_OnClick( clickedItem, menuBlock )
+{
+	FCKTools.RunFunction( menuBlock.OnClick, menuBlock, [ clickedItem ] ) ;
+}
+
+function FCKMenuBlock_Item_OnActivate( menuBlock )
+{
+	var oActiveItem = menuBlock._ActiveItem ;
+
+	if ( oActiveItem && oActiveItem != this )
+	{
+		// Set the focus to this menu block window (to fire OnBlur on opened panels).
+		if ( !FCKBrowserInfo.IsIE && oActiveItem.HasSubMenu && !this.HasSubMenu )
+			menuBlock._Window.focus() ;
+
+		oActiveItem.Deactivate() ;
+	}
+
+	menuBlock._ActiveItem = this ;
+}
+
+function FCKMenuBlock_Cleanup()
+{
+	this._Window = null ;
+	this._ItemsTable = null ;
+}
+
+// ################# //
+
+var FCKMenuSeparator = function()
+{}
+
+FCKMenuSeparator.prototype.Create = function( parentTable )
+{
+	var oDoc = FCKTools.GetElementDocument( parentTable ) ;
+
+	var r = parentTable.insertRow(-1) ;
+
+	var eCell = r.insertCell(-1) ;
+	eCell.className = 'MN_Separator MN_Icon' ;
+
+	eCell = r.insertCell(-1) ;
+	eCell.className = 'MN_Separator' ;
+	eCell.appendChild( oDoc.createElement( 'DIV' ) ).className = 'MN_Separator_Line' ;
+
+	eCell = r.insertCell(-1) ;
+	eCell.className = 'MN_Separator' ;
+	eCell.appendChild( oDoc.createElement( 'DIV' ) ).className = 'MN_Separator_Line' ;
+}