[LocalFiles Editor]

Update editarea to 0.8.2.
Remove CSS tab.
Fix jQuery path.

git-svn-id: http://piwigo.org/svn/trunk@5160 68402e56-0260-453c-a942-63ccdbb3a9ee

1 files changed, 407 insertions, 0 deletions

diff --git a/plugins/LocalFilesEditor/editarea/highlight.js b/plugins/LocalFilesEditor/editarea/highlight.js
new file mode 100644
index 000000000..d0ec749a3
--- /dev/null
+++ b/plugins/LocalFilesEditor/editarea/highlight.js
@@ -0,0 +1,407 @@
+	// change_to: "on" or "off"

+	EditArea.prototype.change_highlight= function(change_to){

+		if(this.settings["syntax"].length==0 && change_to==false){

+			this.switchClassSticky(_$("highlight"), 'editAreaButtonDisabled', true);

+			this.switchClassSticky(_$("reset_highlight"), 'editAreaButtonDisabled', true);

+			return false;

+		}

+		

+		if(this.do_highlight==change_to)

+			return false;

+	

+			

+		this.getIESelection();

+		var pos_start= this.textarea.selectionStart;

+		var pos_end= this.textarea.selectionEnd;

+		

+		if(this.do_highlight===true || change_to==false)

+			this.disable_highlight();

+		else

+			this.enable_highlight();

+		this.textarea.focus();

+		this.textarea.selectionStart = pos_start;

+		this.textarea.selectionEnd = pos_end;

+		this.setIESelection();

+				

+	};

+	

+	EditArea.prototype.disable_highlight= function(displayOnly){

+		var t= this, a=t.textarea, new_Obj, old_class, new_class;

+			

+		t.selection_field.innerHTML="";

+		t.selection_field_text.innerHTML="";

+		t.content_highlight.style.visibility="hidden";

+		// replacing the node is far more faster than deleting it's content in firefox

+		new_Obj= t.content_highlight.cloneNode(false);

+		new_Obj.innerHTML= "";			

+		t.content_highlight.parentNode.insertBefore(new_Obj, t.content_highlight);

+		t.content_highlight.parentNode.removeChild(t.content_highlight);	

+		t.content_highlight= new_Obj;

+		old_class= parent.getAttribute( a,"class" );

+		if(old_class){

+			new_class= old_class.replace( "hidden","" );

+			parent.setAttribute( a, "class", new_class );

+		}

+	

+		a.style.backgroundColor="transparent";	// needed in order to see the bracket finders

+		

+		//var icon= document.getElementById("highlight");

+		//setAttribute(icon, "class", getAttribute(icon, "class").replace(/ selected/g, "") );

+		//t.restoreClass(icon);

+		//t.switchClass(icon,'editAreaButtonNormal');

+		t.switchClassSticky(_$("highlight"), 'editAreaButtonNormal', true);

+		t.switchClassSticky(_$("reset_highlight"), 'editAreaButtonDisabled', true);

+	

+		t.do_highlight=false;

+	

+		t.switchClassSticky(_$("change_smooth_selection"), 'editAreaButtonSelected', true);

+		if(typeof(t.smooth_selection_before_highlight)!="undefined" && t.smooth_selection_before_highlight===false){

+			t.change_smooth_selection_mode(false);

+		}

+		

+	//	this.textarea.style.backgroundColor="#FFFFFF";

+	};

+

+	EditArea.prototype.enable_highlight= function(){

+		var t=this, a=t.textarea, new_class;

+		t.show_waiting_screen();

+			

+		t.content_highlight.style.visibility="visible";

+		new_class	=parent.getAttribute(a,"class")+" hidden";

+		parent.setAttribute( a, "class", new_class );

+		

+		// IE can't manage mouse click outside text range without this

+		if( t.isIE )

+			a.style.backgroundColor="#FFFFFF";	

+

+		t.switchClassSticky(_$("highlight"), 'editAreaButtonSelected', false);

+		t.switchClassSticky(_$("reset_highlight"), 'editAreaButtonNormal', false);

+		

+		t.smooth_selection_before_highlight=t.smooth_selection;

+		if(!t.smooth_selection)

+			t.change_smooth_selection_mode(true);

+		t.switchClassSticky(_$("change_smooth_selection"), 'editAreaButtonDisabled', true);

+		

+		

+		t.do_highlight=true;

+		t.resync_highlight();

+					

+		t.hide_waiting_screen();	

+	};

+	

+	/**

+	 * Ask to update highlighted text

+	 * @param Array infos - Array of datas returned by EditArea.get_selection_infos()

+	 */

+	EditArea.prototype.maj_highlight= function(infos){

+		// for speed mesure

+		var debug_opti="",tps_start= new Date().getTime(), tps_middle_opti=new Date().getTime();

+		var t=this, hightlighted_text, updated_highlight;	

+		var textToHighlight=infos["full_text"], doSyntaxOpti = false, doHtmlOpti = false, stay_begin="", stay_end="", trace_new , trace_last;

+		

+		if(t.last_text_to_highlight==infos["full_text"] && t.resync_highlight!==true)

+			return;

+					

+		//  OPTIMISATION: will search to update only changed lines

+		if(t.reload_highlight===true){

+			t.reload_highlight=false;

+		}else if(textToHighlight.length==0){

+			textToHighlight="\n ";

+		}else{

+			// get text change datas

+			changes = t.checkTextEvolution(t.last_text_to_highlight,textToHighlight);

+			

+			// check if it can only reparse the changed text

+			trace_new		= t.get_syntax_trace(changes.newTextLine).replace(/\r/g, '');

+			trace_last		= t.get_syntax_trace(changes.lastTextLine).replace(/\r/g, '');

+			doSyntaxOpti	= ( trace_new == trace_last );

+			

+			// check if the difference comes only from a new line created 

+			// => we have to remember that the editor can automaticaly add tabulation or space after the new line) 

+			if( !doSyntaxOpti && trace_new == "\n"+trace_last && /^[ \t\s]*\n[ \t\s]*$/.test( changes.newText.replace(/\r/g, '') ) && changes.lastText =="" )

+			{

+				doSyntaxOpti	= true;

+			}

+			

+			// we do the syntax optimisation

+			if( doSyntaxOpti ){

+						

+				tps_middle_opti=new Date().getTime();	

+			

+				stay_begin= t.last_hightlighted_text.split("\n").slice(0, changes.lineStart).join("\n");

+				if(changes.lineStart>0)

+					stay_begin+= "\n";

+				stay_end= t.last_hightlighted_text.split("\n").slice(changes.lineLastEnd+1).join("\n");

+				if(stay_end.length>0)

+					stay_end= "\n"+stay_end;

+					

+				// Final check to see that we're not in the middle of span tags

+				if( stay_begin.split('<span').length != stay_begin.split('</span').length 

+					|| stay_end.split('<span').length != stay_end.split('</span').length )

+				{

+					doSyntaxOpti	= false;

+					stay_end		= '';

+					stay_begin		= '';

+				}

+				else

+				{

+					if(stay_begin.length==0 && changes.posLastEnd==-1)

+						changes.newTextLine+="\n";

+					textToHighlight=changes.newTextLine;

+				}

+			}

+			if(t.settings["debug"]){

+				var ch =changes;

+				debug_opti= ( doSyntaxOpti?"Optimisation": "No optimisation" )

+					+" start: "+ch.posStart +"("+ch.lineStart+")"

+					+" end_new: "+ ch.posNewEnd+"("+ch.lineNewEnd+")"

+					+" end_last: "+ ch.posLastEnd+"("+ch.lineLastEnd+")"

+					+"\nchanged_text: "+ch.newText+" => trace: "+trace_new

+					+"\nchanged_last_text: "+ch.lastText+" => trace: "+trace_last

+					//debug_opti+= "\nchanged: "+ infos["full_text"].substring(ch.posStart, ch.posNewEnd);

+					+ "\nchanged_line: "+ch.newTextLine

+					+ "\nlast_changed_line: "+ch.lastTextLine

+					+"\nstay_begin: "+ stay_begin.slice(-100)

+					+"\nstay_end: "+ stay_end.substr( 0, 100 );

+					//debug_opti="start: "+stay_begin_len+ "("+nb_line_start_unchanged+") end: "+ (stay_end_len)+ "("+(splited.length-nb_line_end_unchanged)+") ";

+					//debug_opti+="changed: "+ textToHighlight.substring(stay_begin_len, textToHighlight.length-stay_end_len)+" \n";

+					

+					//debug_opti+="changed: "+ stay_begin.substr(stay_begin.length-200)+ "----------"+ textToHighlight+"------------------"+ stay_end.substr(0,200) +"\n";

+					+"\n";

+			}

+	

+			

+			// END OPTIMISATION

+		}

+

+		tps_end_opti	= new Date().getTime();	

+				

+		// apply highlight

+		updated_highlight	= t.colorize_text(textToHighlight);

+		tpsAfterReg			= new Date().getTime();

+		

+		/***

+		 * see if we can optimize for updating only the required part of the HTML code

+		 * 

+		 * The goal here will be to find the text node concerned by the modification and to update it

+		 */

+		//-------------------------------------------

+		

+		// disable latest optimization tricks (introduced in 0.8.1 and removed in 0.8.2), TODO: check for another try later

+		doSyntaxOpti	= doHtmlOpti = false;

+		if( doSyntaxOpti )

+		{

+			try

+			{

+				var replacedBloc, i, nbStart = '', nbEnd = '', newHtml, lengthOld, lengthNew;

+				replacedBloc		= t.last_hightlighted_text.substring( stay_begin.length, t.last_hightlighted_text.length - stay_end.length );

+				

+				lengthOld	= replacedBloc.length;

+				lengthNew	= updated_highlight.length;

+				

+				// find the identical caracters at the beginning

+				for( i=0; i < lengthOld && i < lengthNew && replacedBloc.charAt(i) == updated_highlight.charAt(i) ; i++ )

+				{

+				}

+				nbStart = i;

+				// find the identical caracters at the end

+				for( i=0; i + nbStart < lengthOld && i + nbStart < lengthNew && replacedBloc.charAt(lengthOld-i-1) == updated_highlight.charAt(lengthNew-i-1) ; i++ )

+				{

+				}

+				nbEnd	= i;

+				//console.log( nbStart, nbEnd, replacedBloc, updated_highlight );

+				// get the changes

+				lastHtml	= replacedBloc.substring( nbStart, lengthOld - nbEnd );

+				newHtml		= updated_highlight.substring( nbStart, lengthNew - nbEnd );

+				

+				// We can do the optimisation only if we havn't touch to span elements

+				if( newHtml.indexOf('<span') == -1 && newHtml.indexOf('</span') == -1 

+					&& lastHtml.indexOf('<span') == -1 && lastHtml.indexOf('</span') == -1 )

+				{

+					var beginStr, nbOpendedSpan, nbClosedSpan, nbUnchangedChars, span, textNode;

+					doHtmlOpti		= true;

+					beginStr		= t.last_hightlighted_text.substr( 0, stay_begin.length + nbStart );

+					// fix special chars

+					newHtml			= newHtml.replace( /&lt;/g, '<').replace( /&gt;/g, '>').replace( /&amp;/g, '&');

+		

+					nbOpendedSpan	= beginStr.split('<span').length - 1;

+					nbClosedSpan	= beginStr.split('</span').length - 1;

+					// retrieve the previously opened span (Add 1 for the first level span?)

+					span 			= t.content_highlight.getElementsByTagName('span')[ nbOpendedSpan ];

+					

+					//--------[

+					// get the textNode to update

+					

+					// if we're inside a span, we'll take the one that is opened (can be a parent of the current span)

+					parentSpan		= span;

+					maxStartOffset	= maxEndOffset = 0;

+					

+					// it will be in the child of the root node 

+					if( nbOpendedSpan == nbClosedSpan )

+					{

+						while( parentSpan.parentNode != t.content_highlight && parentSpan.parentNode.tagName != 'PRE' )

+						{

+							parentSpan	= parentSpan.parentNode;

+						}

+					}

+					// get the last opened span

+					else

+					{

+						maxStartOffset	= maxEndOffset = beginStr.length + 1;

+						// move to parent node for each closed span found after the lastest open span

+						nbClosed = beginStr.substr( Math.max( 0, beginStr.lastIndexOf( '<span', maxStartOffset - 1 ) ) ).split('</span').length - 1;

+						while( nbClosed > 0 )

+						{

+							nbClosed--;

+							parentSpan = parentSpan.parentNode;

+						}

+						

+						// find the position of the last opended tag

+						while( parentSpan.parentNode != t.content_highlight && parentSpan.parentNode.tagName != 'PRE' && ( tmpMaxStartOffset = Math.max( 0, beginStr.lastIndexOf( '<span', maxStartOffset - 1 ) ) ) < ( tmpMaxEndOffset = Math.max( 0, beginStr.lastIndexOf( '</span', maxEndOffset - 1 ) ) ) )

+						{

+							maxStartOffset	= tmpMaxStartOffset;

+							maxEndOffset	= tmpMaxEndOffset;

+						}

+					}

+					// Note: maxEndOffset is no more used but maxStartOffset will be used

+					

+					if( parentSpan.parentNode == t.content_highlight || parentSpan.parentNode.tagName == 'PRE' )

+					{

+						maxStartOffset	= Math.max( 0, beginStr.indexOf( '<span' ) );

+					}

+					

+					// find the matching text node (this will be one that will be at the end of the beginStr

+					if( maxStartOffset == beginStr.length )

+					{

+						nbSubSpanBefore	= 0;

+					}

+					else

+					{

+						lastEndPos 				= Math.max( 0, beginStr.lastIndexOf( '>', maxStartOffset ) );

+		

+						// count the number of sub spans

+						nbSubSpanBefore			= beginStr.substr( lastEndPos ).split('<span').length-1;

+					}

+					

+					// there is no sub-span before

+					if( nbSubSpanBefore == 0 )

+					{

+						textNode	= parentSpan.firstChild;

+					}

+					// we need to find where is the text node modified

+					else

+					{

+						// take the last direct child (no sub-child)

+						lastSubSpan	= parentSpan.getElementsByTagName('span')[ nbSubSpanBefore - 1 ];

+						while( lastSubSpan.parentNode != parentSpan )

+						{

+							lastSubSpan	= lastSubSpan.parentNode;

+						}

+

+						// associate to next text node following the last sub span

+						if( lastSubSpan.nextSibling == null || lastSubSpan.nextSibling.nodeType != 3 )

+						{

+							textNode	= document.createTextNode('');

+							lastSubSpan.parentNode.insertBefore( textNode, lastSubSpan.nextSibling );

+						}

+						else

+						{

+							textNode	= lastSubSpan.nextSibling;

+						}

+					}

+					//--------]

+					

+					

+					//--------[

+					// update the textNode content

+					

+					// number of caracters after the last opened of closed span

+					//nbUnchangedChars = ( lastIndex = beginStr.lastIndexOf( '>' ) ) == -1 ? beginStr.length : beginStr.length - ( lastIndex + 1 );

+					//nbUnchangedChars =  ? beginStr.length : beginStr.substr( lastIndex + 1 ).replace( /&lt;/g, '<').replace( /&gt;/g, '>').replace( /&amp;/g, '&').length;

+					

+					if( ( lastIndex = beginStr.lastIndexOf( '>' ) ) == -1 )

+					{

+						nbUnchangedChars	= beginStr.length;

+					}

+					else

+					{

+						nbUnchangedChars	= beginStr.substr( lastIndex + 1 ).replace( /&lt;/g, '<').replace( /&gt;/g, '>').replace( /&amp;/g, '&').length; 	

+						//nbUnchangedChars	+= beginStr.substr( ).replace( /&/g, '&amp;').replace( /</g, '&lt;').replace( />/g, '&gt;').length - beginStr.length;

+					}

+					//alert( nbUnchangedChars );

+					//	console.log( span, textNode, nbOpendedSpan,nbClosedSpan,  span.nextSibling, textNode.length, nbUnchangedChars, lastHtml, lastHtml.length, newHtml, newHtml.length );

+					//	alert( textNode.parentNode.className +'-'+ textNode.parentNode.tagName+"\n"+ textNode.data +"\n"+ nbUnchangedChars +"\n"+ lastHtml.length +"\n"+ newHtml +"\n"+ newHtml.length  );

+				//	console.log( nbUnchangedChars, lastIndex, beginStr.length, beginStr.replace(/&/g, '&amp;'), lastHtml.length, '|', newHtml.replace( /\t/g, 't').replace( /\n/g, 'n').replace( /\r/g, 'r'), lastHtml.replace( /\t/g, 't').replace( /\n/g, 'n').replace( /\r/, 'r') );

+				//	console.log( textNode.data.replace(/&/g, '&amp;') );

+					// IE only manage \r for cariage return in textNode and not \n or \r\n

+					if( t.isIE )

+					{

+						nbUnchangedChars	-= ( beginStr.substr( beginStr.length - nbUnchangedChars ).split("\n").length - 1 );

+						//alert( textNode.data.replace(/\r/g, '_r').replace(/\n/g, '_n')); 

+						textNode.replaceData( nbUnchangedChars, lastHtml.replace(/\n/g, '').length, newHtml.replace(/\n/g, '') );

+					}

+					else

+					{

+						textNode.replaceData( nbUnchangedChars, lastHtml.length, newHtml );

+					}

+					//--------]

+				}

+			}

+			// an exception shouldn't occured but if replaceData failed at least it won't break everything

+			catch( e )

+			{

+		//		throw e;

+			//	console.log( e );

+				doHtmlOpti	= false;

+			}

+			

+		}

+	

+		/*** END HTML update's optimisation ***/

+		// end test

+		

+	//			console.log(  (TPS6-TPS5), (TPS5-TPS4), (TPS4-TPS3), (TPS3-TPS2), (TPS2-TPS1), _CPT );

+		// get the new highlight content

+		tpsAfterOpti2		= new Date().getTime();

+		hightlighted_text	= stay_begin + updated_highlight + stay_end;

+		if( !doHtmlOpti )

+		{

+			// update the content of the highlight div by first updating a clone node (as there is no display in the same time for t node it's quite faster (5*))

+			var new_Obj= t.content_highlight.cloneNode(false);

+			if( ( t.isIE && t.isIE < 8 ) || ( t.isOpera && t.isOpera < 9.6 ) )

+				new_Obj.innerHTML= "<pre><span class='"+ t.settings["syntax"] +"'>" + hightlighted_text + "</span></pre>";	

+			else

+				new_Obj.innerHTML= "<span class='"+ t.settings["syntax"] +"'>"+ hightlighted_text +"</span>";

+	

+			t.content_highlight.parentNode.replaceChild(new_Obj, t.content_highlight);

+		

+			t.content_highlight= new_Obj;

+		}

+		

+		t.last_text_to_highlight= infos["full_text"];

+		t.last_hightlighted_text= hightlighted_text;

+		

+		tps3=new Date().getTime();

+	

+		if(t.settings["debug"]){

+			//lineNumber=tab_text.length;

+			//t.debug.value+=" \nNB char: "+_$("src").value.length+" Nb line: "+ lineNumber;

+		

+			t.debug.value= "Tps optimisation "+(tps_end_opti-tps_start)

+				+" | tps reg exp: "+ (tpsAfterReg-tps_end_opti)

+				+" | tps opti HTML : "+ (tpsAfterOpti2-tpsAfterReg) + ' '+ ( doHtmlOpti ? 'yes' : 'no' )

+				+" | tps update highlight content: "+ (tps3-tpsAfterOpti2)

+				+" | tpsTotal: "+ (tps3-tps_start)

+				+ "("+tps3+")\n"+ debug_opti;

+		//	t.debug.value+= "highlight\n"+hightlighted_text;*/

+		}

+		

+	};

+	

+	EditArea.prototype.resync_highlight= function(reload_now){

+		this.reload_highlight=true;

+		this.last_text_to_highlight="";

+		this.focus();		

+		if(reload_now)

+			this.check_line_selection(false); 

+	};