aboutsummaryrefslogtreecommitdiffstats
path: root/plugins/LocalFilesEditor/editarea/highlight.js
diff options
context:
space:
mode:
authorpatdenice <patdenice@piwigo.org>2010-03-17 15:27:14 +0000
committerpatdenice <patdenice@piwigo.org>2010-03-17 15:27:14 +0000
commit3c10b3da9feaf945c68f4c698bf0e341b0e8e557 (patch)
tree83d304a4d703875e67a26a3598594efcad3bd488 /plugins/LocalFilesEditor/editarea/highlight.js
parent595a87ac7e5aa7fad3260849be0a9f11edd665fe (diff)
[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
Diffstat (limited to 'plugins/LocalFilesEditor/editarea/highlight.js')
-rw-r--r--plugins/LocalFilesEditor/editarea/highlight.js407
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);
+ };