[dgoette] 38631: * readd & update diff function * fix css * fix problem, while requesting translations

Author: dgoette
Date: Wed Jan  7 08:43:03 2009
New Revision: 38631

URL: http://svn.reactos.org/svn/reactos?rev=38631&view=rev
Log:
* readd & update diff function
* fix css
* fix problem, while requesting translations

Added:
    branches/danny-web/reactos.org/htdocs/roscms/js/diff.js
Modified:
    branches/danny-web/reactos.org/htdocs/roscms/css/cms_website.css
    branches/danny-web/reactos.org/htdocs/roscms/js/cms_website.js
    branches/danny-web/reactos.org/htdocs/roscms/lib/Export_XML.class.php

Modified: branches/danny-web/reactos.org/htdocs/roscms/css/cms_website.css
URL:
http://svn.reactos.org/svn/reactos/branches/danny-web/reactos.org/htdocs/ro…
==============================================================================
--- branches/danny-web/reactos.org/htdocs/roscms/css/cms_website.css [iso-8859-1]
(original)
+++ branches/danny-web/reactos.org/htdocs/roscms/css/cms_website.css [iso-8859-1] Wed Jan 
7 08:43:03 2009
@@ -115,3 +115,8 @@
 .detailmenu { color: #006090; text-decoration: underline; cursor: pointer; }
 
 .frmeditbutton { cursor:pointer; color:#006090; }
+
+#legend { display: block; width: 500px; border: solid 1px black; }
+
+#legend .lbox { border: solid 1px black; width: 17px;}
+

Modified: branches/danny-web/reactos.org/htdocs/roscms/js/cms_website.js
URL:
http://svn.reactos.org/svn/reactos/branches/danny-web/reactos.org/htdocs/ro…
==============================================================================
--- branches/danny-web/reactos.org/htdocs/roscms/js/cms_website.js [iso-8859-1]
(original)
+++ branches/danny-web/reactos.org/htdocs/roscms/js/cms_website.js [iso-8859-1] Wed Jan  7
08:43:03 2009
@@ -1961,15 +1961,10 @@
       break;
 
     case 'diff':
+    case 'diff2': 
       document.getElementById('editzone').innerHTML = '<div
id="frmdiff">'+ http_request.responseText + '</div>';
       loadEditor('diffentry');
-      document.getElementById('frmeditdiff').innerHTML =
CDiffString(document.getElementById('frmeditdiff1').innerHTML,
document.getElementById('frmeditdiff2').innerHTML);
-      break;
-
-    // update diff-area with new entries start diff-process; called from within
diff-area
-    case 'diff2': 
-      document.getElementById('frmdiff').innerHTML = http_request.responseText;
-      document.getElementById('frmeditdiff').innerHTML =
CDiffString(document.getElementById('frmeditdiff1').innerHTML,
document.getElementById('frmeditdiff2').innerHTML);
+      document.getElementById('frmeditdiff').innerHTML =
WDiffShortenOutput(WDiffString(document.getElementById('frmeditdiff1').innerHTML,
document.getElementById('frmeditdiff2').innerHTML));
       break;
 
     case 'changetags':

Added: branches/danny-web/reactos.org/htdocs/roscms/js/diff.js
URL:
http://svn.reactos.org/svn/reactos/branches/danny-web/reactos.org/htdocs/ro…
==============================================================================
--- branches/danny-web/reactos.org/htdocs/roscms/js/diff.js (added)
+++ branches/danny-web/reactos.org/htdocs/roscms/js/diff.js [iso-8859-1] Wed Jan  7
08:43:03 2009
@@ -1,0 +1,1108 @@
+/*
+ 
+Name:    diff.js
+Version: 0.9.5a (April 6, 2008)
+Info:    http://en.wikipedia.org/wiki/User:Cacycle/diff
+Code:    http://en.wikipedia.org/wiki/User:Cacycle/diff.js
+ 
+JavaScript diff algorithm by [[en:User:Cacycle]]
(http://en.wikipedia.org/wiki/User_talk:Cacycle).
+Outputs html/css-formatted new text with highlighted deletions, inserts, and block
moves.
+ 
+The program uses cross-browser code and should work with all modern browsers. It has been
tested with:
+* Mozilla Firefox 1.5.0.1
+* Mozilla SeaMonkey 1.0
+* Opera 8.53
+* Internet Explorer 6.0.2900.2180
+* Internet Explorer 7.0.5730.11
+This program is also compatibel with Greasemonkey
+ 
+An implementation of the word-based algorithm from:
+ 
+Communications of the ACM 21(4):264 (1978)
+http://doi.acm.org/10.1145/359460.359467
+ 
+With the following additional feature:
+ 
+* Word types have been optimized for MediaWiki source texts
+* Additional post-pass 5 code for resolving islands caused by adding
+	two common words at the end of sequences of common words
+* Additional detection of block borders and color coding of moved blocks and their
original position
+* Optional "intelligent" omission of unchanged parts from the output
+ 
+This code is used by the MediaWiki in-browser text editors [[en:User:Cacycle/editor]] and
[[en:User:Cacycle/wikEd]]
+and the enhanced diff view tool wikEdDiff [[en:User:Cacycle/wikEd]].
+ 
+Usage: var htmlText = WDiffString(oldText, newText);
+ 
+This code has been released into the public domain.
+ 
+Datastructures:
+ 
+text: an object that holds all text related datastructures
+	.newWords: consecutive words of the new text (N)
+	.oldWords: consecutive words of the old text (O)
+	.newToOld: array of corresponding word number in old text (NA)
+	.oldToNew: array of corresponding word number in new text (OA)
+	.message:  output message for testing purposes
+ 
+symbol['word']: symbol table for passes 1 - 3, holds words as a hash
+	.newCtr:  new word occurences counter (NC)
+	.oldCtr:  old word occurences counter (OC)
+	.toNew:   table last old word number
+	.toOld:   last new word number (OLNA)
+ 
+block: an object that holds block move information
+	blocks indexed after new text:
+	.newStart:  new text word number of start of this block
+	.newLength: element number of this block including non-words
+	.newWords:  true word number of this block
+	.newNumber: corresponding block index in old text
+	.newBlock:  moved-block-number of a block that has been moved here
+	.newLeft:   moved-block-number of a block that has been moved from this border
leftwards
+	.newRight:  moved-block-number of a block that has been moved from this border
rightwards
+	.newLeftIndex:  index number of a block that has been moved from this border leftwards
+	.newRightIndex: index number of a block that has been moved from this border rightwards
+	blocks indexed after old text:
+	.oldStart:  word number of start of this block
+	.oldToNew:  corresponding new text word number of start
+	.oldLength: element number of this block including non-words
+	.oldWords:  true word number of this block
+ 
+*/
+ 
+ 
+// css for change indicators
+if (typeof(wDiffStyleDelete) == 'undefined') { window.wDiffStyleDelete =
'font-weight: normal; text-decoration: none; color: #fff; background-color:
#990033;'; }
+if (typeof(wDiffStyleInsert) == 'undefined') { window.wDiffStyleInsert =
'font-weight: normal; text-decoration: none; color: #fff; background-color:
#009933;'; }
+if (typeof(wDiffStyleMoved)  == 'undefined') { window.wDiffStyleMoved  =
'font-weight: bold;  color: #000; vertical-align: text-bottom; font-size: xx-small;
padding: 0; border: solid 1px;'; }
+if (typeof(wDiffStyleBlock)  == 'undefined') { window.wDiffStyleBlock  = [
+	'color: #000; background-color: #ffff80;',
+	'color: #000; background-color: #c0ffff;',
+	'color: #000; background-color: #ffd0f0;',
+	'color: #000; background-color: #ffe080;',
+	'color: #000; background-color: #aaddff;',
+	'color: #000; background-color: #ddaaff;',
+	'color: #000; background-color: #ffbbbb;',
+	'color: #000; background-color: #d8ffa0;',
+	'color: #000; background-color: #d0d0d0;'
+]; }
+ 
+// html for change indicators, {number} is replaced by the block number
+// {block} is replaced by the block style, class and html comments are important for
shortening the output
+if (typeof(wDiffHtmlMovedRight)  == 'undefined') { window.wDiffHtmlMovedRight  =
'<input class="wDiffHtmlMovedRight" type="button"
value="&gt;" style="' + wDiffStyleMoved + '
{block}"><!--wDiffHtmlMovedRight-->'; }
+if (typeof(wDiffHtmlMovedLeft)   == 'undefined') { window.wDiffHtmlMovedLeft   =
'<input class="wDiffHtmlMovedLeft" type="button"
value="&lt;" style="' + wDiffStyleMoved + '
{block}"><!--wDiffHtmlMovedLeft-->'; }
+ 
+if (typeof(wDiffHtmlBlockStart)  == 'undefined') { window.wDiffHtmlBlockStart  =
'<span class="wDiffHtmlBlock" style="{block}">'; }
+if (typeof(wDiffHtmlBlockEnd)    == 'undefined') { window.wDiffHtmlBlockEnd    =
'</span><!--wDiffHtmlBlock-->'; }
+ 
+if (typeof(wDiffHtmlDeleteStart) == 'undefined') { window.wDiffHtmlDeleteStart =
'<span class="wDiffHtmlDelete" style="' + wDiffStyleDelete +
'">'; }
+if (typeof(wDiffHtmlDeleteEnd)   == 'undefined') { window.wDiffHtmlDeleteEnd   =
'</span><!--wDiffHtmlDelete-->'; }
+ 
+if (typeof(wDiffHtmlInsertStart) == 'undefined') { window.wDiffHtmlInsertStart =
'<span class="wDiffHtmlInsert" style="' + wDiffStyleInsert +
'">'; }
+if (typeof(wDiffHtmlInsertEnd)   == 'undefined') { window.wDiffHtmlInsertEnd   =
'</span><!--wDiffHtmlInsert-->'; }
+ 
+// minimal number of real words for a moved block (0 for always displaying block move
indicators)
+if (typeof(wDiffBlockMinLength) == 'undefined') { window.wDiffBlockMinLength = 3;
}
+ 
+// exclude identical sequence starts and endings from change marking
+if (typeof(wDiffWordDiff) == 'undefined') { window.wDiffWordDiff = true; }
+ 
+// enable recursive diff to resolve problematic sequences
+if (typeof(wDiffRecursiveDiff) == 'undefined') { window.wDiffRecursiveDiff =
true; }
+ 
+// enable block move display
+if (typeof(wDiffShowBlockMoves) == 'undefined') { window.wDiffShowBlockMoves =
true; }
+ 
+// remove unchanged parts from final output
+ 
+// characters before diff tag to search for previous heading, paragraph, line break, cut
characters
+if (typeof(wDiffHeadingBefore)   == 'undefined') { window.wDiffHeadingBefore   =
1500; }
+if (typeof(wDiffParagraphBefore) == 'undefined') { window.wDiffParagraphBefore =
1500; }
+if (typeof(wDiffLineBeforeMax)   == 'undefined') { window.wDiffLineBeforeMax   =
1000; }
+if (typeof(wDiffLineBeforeMin)   == 'undefined') { window.wDiffLineBeforeMin   = 
500; }
+if (typeof(wDiffBlankBeforeMax)  == 'undefined') { window.wDiffBlankBeforeMax  =
1000; }
+if (typeof(wDiffBlankBeforeMin)  == 'undefined') { window.wDiffBlankBeforeMin  = 
500; }
+if (typeof(wDiffCharsBefore)     == 'undefined') { window.wDiffCharsBefore     = 
500; }
+ 
+// characters after diff tag to search for next heading, paragraph, line break, or
characters
+if (typeof(wDiffHeadingAfter)   == 'undefined') { window.wDiffHeadingAfter   =
1500; }
+if (typeof(wDiffParagraphAfter) == 'undefined') { window.wDiffParagraphAfter =
1500; }
+if (typeof(wDiffLineAfterMax)   == 'undefined') { window.wDiffLineAfterMax   =
1000; }
+if (typeof(wDiffLineAfterMin)   == 'undefined') { window.wDiffLineAfterMin   = 
500; }
+if (typeof(wDiffBlankAfterMax)  == 'undefined') { window.wDiffBlankAfterMax  =
1000; }
+if (typeof(wDiffBlankAfterMin)  == 'undefined') { window.wDiffBlankAfterMin  = 
500; }
+if (typeof(wDiffCharsAfter)     == 'undefined') { window.wDiffCharsAfter     = 
500; }
+ 
+// maximal fragment distance to join close fragments
+if (typeof(wDiffFragmentJoin)  == 'undefined') { window.wDiffFragmentJoin = 1000;
}
+if (typeof(wDiffOmittedChars)  == 'undefined') { window.wDiffOmittedChars =
'…'; }
+if (typeof(wDiffOmittedLines)  == 'undefined') { window.wDiffOmittedLines =
'<hr style="height: 2px; margin: 1em 10%;">'; }
+if (typeof(wDiffNoChange)      == 'undefined') { window.wDiffNoChange     =
'<hr style="height: 2px; margin: 1em 20%;">'; }
+ 
+// compatibility fix for old name of main function
+window.StringDiff = window.WDiffString;
+ 
+ 
+// WDiffString: main program
+// input: oldText, newText, strings containing the texts
+// returns: html diff
+ 
+window.WDiffString = function(oldText, newText) {
+ 
+// IE / Mac fix
+	oldText = oldText.replace(/(\r\n)/g, '\n');
+	newText = newText.replace(/(\r\n)/g, '\n');
+ 
+	var text = {};
+	text.newWords = [];
+	text.oldWords = [];
+	text.newToOld = [];
+	text.oldToNew = [];
+	text.message = '';
+	var block = {};
+	var outText = '';
+ 
+// trap trivial changes: no change
+	if (oldText == newText) {
+		outText = newText;
+		outText = WDiffEscape(outText);
+		outText = WDiffHtmlFormat(outText);
+		return(outText);
+	}
+ 
+// trap trivial changes: old text deleted
+	if ( (oldText == null) || (oldText.length == 0) ) {
+		outText = newText;
+		outText = WDiffEscape(outText);
+		outText = WDiffHtmlFormat(outText);
+		outText = wDiffHtmlInsertStart + outText + wDiffHtmlInsertEnd;
+		return(outText);
+	}
+ 
+// trap trivial changes: new text deleted
+	if ( (newText == null) || (newText.length == 0) ) {
+		outText = oldText;
+		outText = WDiffEscape(outText);
+		outText = WDiffHtmlFormat(outText);
+		outText = wDiffHtmlDeleteStart + outText + wDiffHtmlDeleteEnd;
+		return(outText);
+	}
+ 
+// split new and old text into words
+	WDiffSplitText(oldText, newText, text);
+ 
+// calculate diff information
+	WDiffText(text);
+ 
+//detect block borders and moved blocks
+	WDiffDetectBlocks(text, block);
+ 
+// process diff data into formatted html text
+	outText = WDiffToHtml(text, block);
+ 
+// IE fix
+	outText = outText.replace(/> ( *)</g, '>&nbsp;$1<');
+ 
+	return(outText);
+}
+ 
+ 
+// WDiffSplitText: split new and old text into words
+// input: oldText, newText, strings containing the texts
+// changes: text.newWords and text.oldWords, arrays containing the texts in arrays of
words
+ 
+window.WDiffSplitText = function(oldText, newText, text) {
+ 
+// convert strange spaces
+	oldText = oldText.replace(/[\t\u000b\u00a0\u2028\u2029]+/g, ' ');
+	newText = newText.replace(/[\t\u000b\u00a0\u2028\u2029]+/g, ' ');
+ 
+// split old text into words
+ 
+//              /     |    |    |    |    |   |  |     |   |  |  |    |    |    | /
+	var pattern = /[\w]+|\[\[|\]\]|\{\{|\}\}|\n+|
+|&\w+;|'''|''|=+|\{\||\|\}|\|\-|./g;
+	var result;
+	do {
+		result = pattern.exec(oldText);
+		if (result != null) {
+			text.oldWords.push(result[0]);
+		}
+	} while (result != null);
+ 
+// split new text into words
+	do {
+		result = pattern.exec(newText);
+		if (result != null) {
+			text.newWords.push(result[0]);
+		}
+	} while (result != null);
+ 
+	return;
+}
+ 
+ 
+// WDiffText: calculate diff information
+// input: text.newWords and text.oldWords, arrays containing the texts in arrays of
words
+// optionally for recursive calls: newStart, newEnd, oldStart, oldEnd, recursionLevel
+// changes: text.newToOld and text.oldToNew, containing the line numbers in the other
version
+ 
+window.WDiffText = function(text, newStart, newEnd, oldStart, oldEnd, recursionLevel) {
+ 
+	symbol = new Object();
+	symbol.newCtr = [];
+	symbol.oldCtr = [];
+	symbol.toNew = [];
+	symbol.toOld = [];
+ 
+// set defaults
+	newStart = newStart || 0;
+	newEnd = newEnd || text.newWords.length;
+	oldStart = oldStart || 0;
+	oldEnd = oldEnd || text.oldWords.length;
+	recursionLevel = recursionLevel || 0;
+ 
+// limit recursion depth
+	if (recursionLevel > 10) {
+		return;
+	}
+ 
+// pass 1: parse new text into symbol table s
+ 
+	var word;
+	for (var i = newStart; i < newEnd; i ++) {
+		word = text.newWords[i];
+ 
+// add new entry to symbol table
+		if ( symbol[word] == null) {
+			symbol[word] = { newCtr: 0, oldCtr: 0, toNew: null, toOld: null };
+		}
+ 
+// increment symbol table word counter for new text
+		symbol[word].newCtr ++;
+ 
+// add last word number in new text
+		symbol[word].toNew = i;
+	}
+ 
+// pass 2: parse old text into symbol table
+ 
+	for (var j = oldStart; j < oldEnd; j ++) {
+		word = text.oldWords[j];
+ 
+// add new entry to symbol table
+		if ( symbol[word] == null) {
+			symbol[word] = { newCtr: 0, oldCtr: 0, toNew: null, toOld: null };
+		}
+ 
+// increment symbol table word counter for old text
+		symbol[word].oldCtr ++;
+ 
+// add last word number in old text
+		symbol[word].toOld = j;
+	}
+ 
+// pass 3: connect unique words
+ 
+	for (var i in symbol) {
+ 
+// find words in the symbol table that occur only once in both versions
+		if ( (symbol[i].newCtr == 1) && (symbol[i].oldCtr == 1) ) {
+			var toNew = symbol[i].toNew;
+			var toOld = symbol[i].toOld;
+ 
+// do not use spaces as unique markers
+			if ( ! /\s/.test( text.newWords[toNew] ) ) {
+ 
+// connect from new to old and from old to new
+				text.newToOld[toNew] = toOld;
+				text.oldToNew[toOld] = toNew;
+			}
+		}
+	}
+ 
+// pass 4: connect adjacent identical words downwards
+ 
+	for (var i = newStart; i < newEnd - 1; i ++) {
+ 
+// find already connected pairs
+		if (text.newToOld[i] != null) {
+			j = text.newToOld[i];
+ 
+// check if the following words are not yet connected
+			if ( (text.newToOld[i + 1] == null) && (text.oldToNew[j + 1] == null) ) {
+ 
+// if the following words are the same connect them
+				if ( text.newWords[i + 1] == text.oldWords[j + 1] ) {
+					text.newToOld[i + 1] = j + 1;
+					text.oldToNew[j + 1] = i + 1;
+				}
+			}
+		}
+	}
+ 
+// pass 5: connect adjacent identical words upwards
+ 
+	for (var i = newEnd - 1; i > newStart; i --) {
+ 
+// find already connected pairs
+		if (text.newToOld[i] != null) {
+			j = text.newToOld[i];
+ 
+// check if the preceeding words are not yet connected
+			if ( (text.newToOld[i - 1] == null) && (text.oldToNew[j - 1] == null) ) {
+ 
+// if the preceeding words are the same connect them
+				if ( text.newWords[i - 1] == text.oldWords[j - 1] ) {
+					text.newToOld[i - 1] = j - 1;
+					text.oldToNew[j - 1] = i - 1;
+				}
+			}
+		}
+	}
+ 
+// recursively diff still unresolved regions downwards
+ 
+	if (wDiffRecursiveDiff) {
+		i = newStart;
+		j = oldStart;
+		while (i < newEnd) {
+			if (text.newToOld[i - 1] != null) {
+				j = text.newToOld[i - 1] + 1;
+			}
+ 
+// check for the start of an unresolved sequence
+			if ( (text.newToOld[i] == null) && (text.oldToNew[j] == null) ) {
+ 
+// determine the ends of the sequences
+				var iStart = i;
+				var iEnd = i;
+				while ( (text.newToOld[iEnd] == null) && (iEnd < newEnd) ) {
+					iEnd ++;
+				}
+				var iLength = iEnd - iStart;
+ 
+				var jStart = j;
+				var jEnd = j;
+				while ( (text.oldToNew[jEnd] == null) && (jEnd < oldEnd) ) {
+					jEnd ++;
+				}
+				var jLength = jEnd - jStart;
+ 
+// recursively diff the unresolved sequence
+				if ( (iLength > 0) && (jLength > 0) ) {
+					if ( (iLength > 1) || (jLength > 1) ) {
+						if ( (iStart != newStart) || (iEnd != newEnd) || (jStart != oldStart) || (jEnd !=
oldEnd) ) {
+							WDiffText(text, iStart, iEnd, jStart, jEnd, recursionLevel + 1);
+						}
+					}
+				}
+				i = iEnd;
+			}
+			else {
+				i ++;
+			}
+		}
+	}
+ 
+// recursively diff still unresolved regions upwards
+ 
+	if (wDiffRecursiveDiff) {
+		i = newEnd - 1;
+		j = oldEnd - 1;
+		while (i >= newStart) {
+			if (text.newToOld[i + 1] != null) {
+				j = text.newToOld[i + 1] - 1;
+			}
+ 
+// check for the start of an unresolved sequence
+			if ( (text.newToOld[i] == null) && (text.oldToNew[j] == null) ) {
+ 
+// determine the ends of the sequences
+				var iStart = i;
+				var iEnd = i + 1;
+				while ( (text.newToOld[iStart - 1] == null) && (iStart >= newStart) ) {
+					iStart --;
+				}
+				var iLength = iEnd - iStart;
+ 
+				var jStart = j;
+				var jEnd = j + 1;
+				while ( (text.oldToNew[jStart - 1] == null) && (jStart >= oldStart) ) {
+					jStart --;
+				}
+				var jLength = jEnd - jStart;
+ 
+// recursively diff the unresolved sequence
+				if ( (iLength > 0) && (jLength > 0) ) {
+					if ( (iLength > 1) || (jLength > 1) ) {
+						if ( (iStart != newStart) || (iEnd != newEnd) || (jStart != oldStart) || (jEnd !=
oldEnd) ) {
+							WDiffText(text, iStart, iEnd, jStart, jEnd, recursionLevel + 1);
+						}
+					}
+				}
+				i = iStart - 1;
+			}
+			else {
+				i --;
+			}
+		}
+	}
+	return;
+}
+ 
+ 
+// WDiffToHtml: process diff data into formatted html text
+// input: text.newWords and text.oldWords, arrays containing the texts in arrays of
words
+//   text.newToOld and text.oldToNew, containing the line numbers in the other version
+//   block data structure
+// returns: outText, a html string
+ 
+window.WDiffToHtml = function(text, block) {
+ 
+	var outText = text.message;
+ 
+	var blockNumber = 0;
+	var i = 0;
+	var j = 0;
+	var movedAsInsertion;
+ 
+// cycle through the new text
+	do {
+		var movedIndex = [];
+		var movedBlock = [];
+		var movedLeft = [];
+		var blockText = '';
+		var identText = '';
+		var delText = '';
+		var insText = '';
+		var identStart = '';
+ 
+// check if a block ends here and finish previous block
+		if (movedAsInsertion != null) {
+			if (movedAsInsertion == false) {
+				identStart += wDiffHtmlBlockEnd;
+			}
+			else {
+				identStart += wDiffHtmlInsertEnd;
+			}
+			movedAsInsertion = null;
+		}
+ 
+// detect block boundary
+		if ( (text.newToOld[i] != j) || (blockNumber == 0 ) ) {
+			if ( ( (text.newToOld[i] != null) || (i >= text.newWords.length) ) && (
(text.oldToNew[j] != null) || (j >= text.oldWords.length) ) ) {
+ 
+// block moved right
+				var moved = block.newRight[blockNumber];
+				if (moved > 0) {
+					var index = block.newRightIndex[blockNumber];
+					movedIndex.push(index);
+					movedBlock.push(moved);
+					movedLeft.push(false);
+				}
+ 
+// block moved left
+				moved = block.newLeft[blockNumber];
+				if (moved > 0) {
+					var index = block.newLeftIndex[blockNumber];
+					movedIndex.push(index);
+					movedBlock.push(moved);
+					movedLeft.push(true);
+				}
+ 
+// check if a block starts here
+				moved = block.newBlock[blockNumber];
+				if (moved > 0) {
+ 
+// mark block as inserted text
+					if (block.newWords[blockNumber] < wDiffBlockMinLength) {
+						identStart += wDiffHtmlInsertStart;
+						movedAsInsertion = true;
+					}
+ 
+// mark block by color
+					else {
+						if (moved > wDiffStyleBlock.length) {
+							moved = wDiffStyleBlock.length;
+						}
+						identStart += WDiffHtmlCustomize(wDiffHtmlBlockStart, moved - 1);
+						movedAsInsertion = false;
+					}
+				}
+ 
+				if (i >= text.newWords.length) {
+					i ++;
+				}
+				else {
+					j = text.newToOld[i];
+					blockNumber ++;
+				}
+			}
+		}
+ 
+// get the correct order if moved to the left as well as to the right from here
+		if (movedIndex.length == 2) {
+			if (movedIndex[0] > movedIndex[1]) {
+				movedIndex.reverse();
+				movedBlock.reverse();
+				movedLeft.reverse();
+			}
+		}
+ 
+// handle left and right block moves from this position
+		for (var m = 0; m < movedIndex.length; m ++) {
+ 
+// insert the block as deleted text
+			if (block.newWords[ movedIndex[m] ] < wDiffBlockMinLength) {
+				var movedStart = block.newStart[ movedIndex[m] ];
+				var movedLength = block.newLength[ movedIndex[m] ];
+				var str = '';
+				for (var n = movedStart; n < movedStart + movedLength; n ++) {
+					str += text.newWords[n];
+				}
+				str = WDiffEscape(str);
+				str = str.replace(/\n/g, '&para;<br>');
+				blockText += wDiffHtmlDeleteStart + str + wDiffHtmlDeleteEnd;
+			}
+ 
+// add a placeholder / move direction indicator
+			else {
+				if (movedBlock[m] > wDiffStyleBlock.length) {
+					movedBlock[m] = wDiffStyleBlock.length;
+				}
+				if (movedLeft[m]) {
+					blockText += WDiffHtmlCustomize(wDiffHtmlMovedLeft, movedBlock[m] - 1);
+				}
+				else {
+					blockText += WDiffHtmlCustomize(wDiffHtmlMovedRight, movedBlock[m] - 1);
+				}
+			}
+		}
+ 
+// collect consecutive identical text
+		while ( (i < text.newWords.length) && (j < text.oldWords.length) ) {
+			if ( (text.newToOld[i] == null) || (text.oldToNew[j] == null) ) {
+				break;
+			}
+			if (text.newToOld[i] != j) {
+				break;
+			}
+			identText += text.newWords[i];
+			i ++;
+			j ++;
+		}
+ 
+// collect consecutive deletions
+		while ( (text.oldToNew[j] == null) && (j < text.oldWords.length) ) {
+			delText += text.oldWords[j];
+			j ++;
+		}
+ 
+// collect consecutive inserts
+		while ( (text.newToOld[i] == null) && (i < text.newWords.length) ) {
+			insText += text.newWords[i];
+			i ++;
+		}
+ 
+// remove leading and trailing similarities betweein delText and ins from highlighting
+		var preText = '';
+		var postText = '';
+		if (wDiffWordDiff) {
+			if ( (delText != '') && (insText != '') ) {
+ 
+// remove leading similarities
+				while ( delText.charAt(0) == insText.charAt(0) && (delText != '')
&& (insText != '') ) {
+					preText = preText + delText.charAt(0);
+					delText = delText.substr(1);
+					insText = insText.substr(1);
+				}
+ 
+// remove trailing similarities
+				while ( delText.charAt(delText.length - 1) == insText.charAt(insText.length - 1)
&& (delText != '') && (insText != '') ) {
+					postText = delText.charAt(delText.length - 1) + postText;
+					delText = delText.substr(0, delText.length - 1);
+					insText = insText.substr(0, insText.length - 1);
+				}
+			}
+		}
+ 
+// output the identical text, deletions and inserts
+ 
+// moved from here indicator
+		if (blockText != '') {
+			outText += blockText;
+		}
+ 
+// identical text
+		if (identText != '') {
+			outText += identStart + WDiffEscape(identText);
+		}
+		outText += preText;
+ 
+// deleted text
+		if (delText != '') {
+			delText = wDiffHtmlDeleteStart + WDiffEscape(delText) + wDiffHtmlDeleteEnd;
+			delText = delText.replace(/\n/g, '&para;<br>');
+			outText += delText;
+		}
+ 
+// inserted text
+		if (insText != '') {
+			insText = wDiffHtmlInsertStart + WDiffEscape(insText) + wDiffHtmlInsertEnd;
+			insText = insText.replace(/\n/g, '&para;<br>');
+			outText += insText;
+		}
+		outText += postText;
+	} while (i <= text.newWords.length);
+ 
+	outText += '\n';
+	outText = WDiffHtmlFormat(outText);
+ 
+	return(outText);
+}
+ 
+ 
+// WDiffEscape: replaces html-sensitive characters in output text with character
entities
+ 
+window.WDiffEscape = function(text) {
+ 
+	text = text.replace(/&/g, '&amp;');
+	text = text.replace(/</g, '&lt;');
+	text = text.replace(/>/g, '&gt;');
+	text = text.replace(/\"/g, '&quot;');
+ 
+	return(text);
+}
+ 
+ 
+// HtmlCustomize: customize indicator html: replace {number} with the block number,
{block} with the block style
+ 
+window.WDiffHtmlCustomize = function(text, block) {
+ 
+	text = text.replace(/\{number\}/, block);
+	text = text.replace(/\{block\}/, wDiffStyleBlock[block]);
+ 
+	return(text);
+}
+ 
+ 
+// HtmlFormat: replaces newlines and multiple spaces in text with html code
+ 
+window.WDiffHtmlFormat = function(text) {
+ 
+	text = text.replace(/  /g, ' &nbsp;');
+	text = text.replace(/\n/g, '<br>');
+ 
+	return(text);
+}
+ 
+ 
+// WDiffDetectBlocks: detect block borders and moved blocks
+// input: text object, block object
+ 
+window.WDiffDetectBlocks = function(text, block) {
+ 
+	block.oldStart  = [];
+	block.oldToNew  = [];
+	block.oldLength = [];
+	block.oldWords  = [];
+	block.newStart  = [];
+	block.newLength = [];
+	block.newWords  = [];
+	block.newNumber = [];
+	block.newBlock  = [];
+	block.newLeft   = [];
+	block.newRight  = [];
+	block.newLeftIndex  = [];
+	block.newRightIndex = [];
+ 
+	var blockNumber = 0;
+	var wordCounter = 0;
+	var realWordCounter = 0;
+ 
+// get old text block order
+	if (wDiffShowBlockMoves) {
+		var j = 0;
+		var i = 0;
+		do {
+ 
+// detect block boundaries on old text
+			if ( (text.oldToNew[j] != i) || (blockNumber == 0 ) ) {
+				if ( ( (text.oldToNew[j] != null) || (j >= text.oldWords.length) ) && (
(text.newToOld[i] != null) || (i >= text.newWords.length) ) ) {
+					if (blockNumber > 0) {
+						block.oldLength[blockNumber - 1] = wordCounter;
+						block.oldWords[blockNumber - 1] = realWordCounter;
+						wordCounter = 0;
+						realWordCounter = 0;
+					}
+ 
+					if (j >= text.oldWords.length) {
+						j ++;
+					}
+					else {
+						i = text.oldToNew[j];
+						block.oldStart[blockNumber] = j;
+						block.oldToNew[blockNumber] = text.oldToNew[j];
+						blockNumber ++;
+					}
+				}
+			}
+ 
+// jump over identical pairs
+			while ( (i < text.newWords.length) && (j < text.oldWords.length) ) {
+				if ( (text.newToOld[i] == null) || (text.oldToNew[j] == null) ) {
+					break;
+				}
+				if (text.oldToNew[j] != i) {
+					break;
+				}
+				i ++;
+				j ++;
+				wordCounter ++;
+				if ( /\w/.test( text.newWords[i] ) ) {
+					realWordCounter ++;
+				}
+			}
+ 
+// jump over consecutive deletions
+			while ( (text.oldToNew[j] == null) && (j < text.oldWords.length) ) {
+				j ++;
+			}
+ 
+// jump over consecutive inserts
+			while ( (text.newToOld[i] == null) && (i < text.newWords.length) ) {
+				i ++;
+			}
+		} while (j <= text.oldWords.length);
+ 
+// get the block order in the new text
+		var lastMin;
+		var currMinIndex;
+		lastMin = null;
+ 
+// sort the data by increasing start numbers into new text block info
+		for (var i = 0; i < blockNumber; i ++) {
+			currMin = null;
+			for (var j = 0; j < blockNumber; j ++) {
+				curr = block.oldToNew[j];
+				if ( (curr > lastMin) || (lastMin == null) ) {
+					if ( (curr < currMin) || (currMin == null) ) {
+						currMin = curr;
+						currMinIndex = j;
+					}
+				}
+			}
+			block.newStart[i] = block.oldToNew[currMinIndex];
+			block.newLength[i] = block.oldLength[currMinIndex];
+			block.newWords[i] = block.oldWords[currMinIndex];
+			block.newNumber[i] = currMinIndex;
+			lastMin = currMin;
+		}
+ 
+// detect not moved blocks
+		for (var i = 0; i < blockNumber; i ++) {
+			if (block.newBlock[i] == null) {
+				if (block.newNumber[i] == i) {
+					block.newBlock[i] = 0;
+				}
+			}
+		}
+ 
+// detect switches of neighbouring blocks
+		for (var i = 0; i < blockNumber - 1; i ++) {
+			if ( (block.newBlock[i] == null) && (block.newBlock[i + 1] == null) ) {
+				if (block.newNumber[i] - block.newNumber[i + 1] == 1) {
+					if ( (block.newNumber[i + 1] - block.newNumber[i + 2] != 1) || (i + 2 >=
blockNumber) ) {
+ 
+// the shorter one is declared the moved one
+						if (block.newLength[i] < block.newLength[i + 1]) {
+							block.newBlock[i] = 1;
+							block.newBlock[i + 1] = 0;
+						}
+						else {
+							block.newBlock[i] = 0;
+							block.newBlock[i + 1] = 1;
+						}
+					}
+				}
+			}
+		}
+ 
+// mark all others as moved and number the moved blocks
+		j = 1;
+		for (var i = 0; i < blockNumber; i ++) {
+			if ( (block.newBlock[i] == null) || (block.newBlock[i] == 1) ) {
+				block.newBlock[i] = j++;
+			}
+		}
+ 
+// check if a block has been moved from this block border
+		for (var i = 0; i < blockNumber; i ++) {
+			for (var j = 0; j < blockNumber; j ++) {
+ 
+				if (block.newNumber[j] == i) {
+					if (block.newBlock[j] > 0) {
+ 
+// block moved right
+						if (block.newNumber[j] < j) {
+							block.newRight[i] = block.newBlock[j];
+							block.newRightIndex[i] = j;
+						}
+ 
+// block moved left
+						else {
+							block.newLeft[i + 1] = block.newBlock[j];
+							block.newLeftIndex[i + 1] = j;
+						}
+					}
+				}
+			}
+		}
+	}
+	return;
+}
+ 
+ 
+// WDiffShortenOutput: remove unchanged parts from final output
+// input: the output of WDiffString
+// returns: the text with removed unchanged passages indicated by (...)
+ 
+window.WDiffShortenOutput = function(diffText) {
+ 
+// html <br/> to newlines
+	diffText = diffText.replace(/<br[^>]*>/g, '\n');
+ 
+// scan for diff html tags
+	var regExpDiff = new RegExp('<\\w+
class=\\"(\\w+)\\"[^>]*>(.|\\n)*?<!--\\1-->', 'g');
+	var tagStart = [];
+	var tagEnd = [];
+	var i = 0;
+	var found;
+	while ( (found = regExpDiff.exec(diffText)) != null ) {
+ 
+// combine consecutive diff tags
+		if ( (i > 0) && (tagEnd[i - 1] == found.index) ) {
+			tagEnd[i - 1] = found.index + found[0].length;
+		}
+		else {
+			tagStart[i] = found.index;
+			tagEnd[i] = found.index + found[0].length;
+			i ++;
+		}
+	}
+ 
+// no diff tags detected
+	if (tagStart.length == 0) {
+		return(wDiffNoChange);
+	}
+ 
+// define regexps
+	var regExpHeading = new RegExp('\\n=+.+?=+ *\\n|\\n\\{\\||\\n\\|\\}',
'g');
+	var regExpParagraph = new RegExp('\\n\\n+', 'g');
+	var regExpLine = new RegExp('\\n+', 'g');
+	var regExpBlank = new RegExp('(<[^>]+>)*\\s+', 'g');
+ 
+// determine fragment border positions around diff tags
+	var rangeStart = [];
+	var rangeEnd = [];
+	var rangeStartType = [];
+	var rangeEndType = [];
+	for (var i = 0; i < tagStart.length; i ++) {
+		var found;
+ 
+// find last heading before diff tag
+		var lastPos = tagStart[i] - wDiffHeadingBefore;
+		if (lastPos < 0) {
+			lastPos = 0;
+		}
+		regExpHeading.lastIndex = lastPos;
+		while ( (found = regExpHeading.exec(diffText)) != null ) {
+			if (found.index > tagStart[i]) {
+				break;
+			}
+			rangeStart[i] = found.index;
+			rangeStartType[i] = 'heading';
+		}
+ 
+// find last paragraph before diff tag
+		if (rangeStart[i] == null) {
+			lastPos = tagStart[i] - wDiffParagraphBefore;
+			if (lastPos < 0) {
+				lastPos = 0;
+			}
+			regExpParagraph.lastIndex = lastPos;
+			while ( (found = regExpParagraph.exec(diffText)) != null ) {
+				if (found.index > tagStart[i]) {
+					break;
+				}
+				rangeStart[i] = found.index;
+				rangeStartType[i] = 'paragraph';
+			}
+		}
+ 
+// find line break before diff tag
+		if (rangeStart[i] == null) {
+			lastPos = tagStart[i] - wDiffLineBeforeMax;
+			if (lastPos < 0) {
+				lastPos = 0;
+			}
+			regExpLine.lastIndex = lastPos;
+			while ( (found = regExpLine.exec(diffText)) != null ) {
+				if (found.index > tagStart[i] - wDiffLineBeforeMin) {
+					break;
+				}
+				rangeStart[i] = found.index;
+				rangeStartType[i] = 'line';
+			}
+		}
+ 
+// find blank before diff tag
+		if (rangeStart[i] == null) {
+			lastPos = tagStart[i] - wDiffBlankBeforeMax;
+			if (lastPos < 0) {
+				lastPos = 0;
+			}
+			regExpBlank.lastIndex = lastPos;
+			while ( (found = regExpBlank.exec(diffText)) != null ) {
+				if (found.index > tagStart[i] - wDiffBlankBeforeMin) {
+					break;
+				}
+				rangeStart[i] = found.index;
+				rangeStartType[i] = 'blank';
+			}
+		}
+ 
+// fixed number of chars before diff tag
+		if (rangeStart[i] == null) {
+			rangeStart[i] = tagStart[i] - wDiffCharsBefore;
+			rangeStartType[i] = 'chars';
+			if (rangeStart[i] < 0) {
+				rangeStart[i] = 0;
+			}
+		}
+ 
+// find first heading after diff tag
+		regExpHeading.lastIndex = tagEnd[i];
+		if ( (found = regExpHeading.exec(diffText)) != null ) {
+			if (found.index < tagEnd[i] + wDiffHeadingAfter) {
+				rangeEnd[i] = found.index + found[0].length;
+				rangeEndType[i] = 'heading';
+			}
+		}
+ 
+// find first paragraph after diff tag
+		if (rangeEnd[i] == null) {
+			regExpParagraph.lastIndex = tagEnd[i];
+			if ( (found = regExpParagraph.exec(diffText)) != null ) {
+				if (found.index < tagEnd[i] + wDiffParagraphAfter) {
+					rangeEnd[i] = found.index;
+					rangeEndType[i] = 'paragraph';
+				}
+			}
+		}
+ 
+// find first line break after diff tag
+		if (rangeEnd[i] == null) {
+			regExpLine.lastIndex = tagEnd[i] + wDiffLineAfterMin;
+			if ( (found = regExpLine.exec(diffText)) != null ) {
+				if (found.index < tagEnd[i] + wDiffLineAfterMax) {
+					rangeEnd[i] = found.index;
+					rangeEndType[i] = 'break';
+				}
+			}
+		}
+ 
+// find blank after diff tag
+		if (rangeEnd[i] == null) {
+			regExpBlank.lastIndex = tagEnd[i] + wDiffBlankAfterMin;
+			if ( (found = regExpBlank.exec(diffText)) != null ) {
+				if (found.index < tagEnd[i] + wDiffBlankAfterMax) {
+					rangeEnd[i] = found.index;
+					rangeEndType[i] = 'blank';
+				}
+			}
+		}
+ 
+// fixed number of chars after diff tag
+		if (rangeEnd[i] == null) {
+			rangeEnd[i] = tagEnd[i] + wDiffCharsAfter;
+			if (rangeEnd[i] > diffText.length) {
+				rangeEnd[i] = diffText.length;
+				rangeEndType[i] = 'chars';
+			}
+		}
+	}
+ 
+// remove overlaps, join close fragments
+	var fragmentStart = [];
+	var fragmentEnd = [];
+	var fragmentStartType = [];
+	var fragmentEndType = [];
+	fragmentStart[0] = rangeStart[0];
+	fragmentEnd[0] = rangeEnd[0];
+	fragmentStartType[0] = rangeStartType[0];
+	fragmentEndType[0] = rangeEndType[0];
+	var j = 1;
+	for (var i = 1; i < rangeStart.length; i ++) {
+		if (rangeStart[i] > fragmentEnd[j - 1] + wDiffFragmentJoin) {
+			fragmentStart[j] = rangeStart[i];
+			fragmentEnd[j] = rangeEnd[i];
+			fragmentStartType[j] = rangeStartType[i];
+			fragmentEndType[j] = rangeEndType[i];
+			j ++;
+		}
+		else {
+			fragmentEnd[j - 1] = rangeEnd[i];
+			fragmentEndType[j - 1] = rangeEndType[i];
+		}
+	}
+ 
+// assemble the fragments
+	var outText = '';
+	for (var i = 0; i < fragmentStart.length; i ++) {
+ 
+// get text fragment
+		var fragment = diffText.substring(fragmentStart[i], fragmentEnd[i]);
+		var fragment = fragment.replace(/^\n+|\n+$/g, '');
+ 
+// add inline marks for omitted chars and words
+		if (fragmentStart[i] > 0) {
+			if (fragmentStartType[i] == 'chars') {
+				fragment = wDiffOmittedChars + fragment;
+			}
+			else if (fragmentStartType[i] == 'blank') {
+				fragment = wDiffOmittedChars + ' ' + fragment;
+			}
+		}
+		if (fragmentEnd[i] < diffText.length) {
+			if (fragmentStartType[i] == 'chars') {
+				fragment = fragment + wDiffOmittedChars;
+			}
+			else if (fragmentStartType[i] == 'blank') {
+				fragment = fragment + ' ' + wDiffOmittedChars;
+			}
+		}
+ 
+// add omitted line separator
+		if (fragmentStart[i] > 0) {
+			outText += wDiffOmittedLines;
+		}
+ 
+// encapsulate span errors
+		outText += '<div>' + fragment + '</div>';
+	}
+ 
+// add trailing omitted line separator
+	if (fragmentEnd[i - 1] < diffText.length) {
+		outText = outText + wDiffOmittedLines;
+	}
+ 
+// remove leading and trailing empty lines
+	outText = outText.replace(/^(<div>)\n+|\n+(<\/div>)$/g, '$1$2');
+ 
+// convert to html linebreaks
+	outText = outText.replace(/\n/g, '<br />');
+ 
+	return(outText);
+}
+ 

Modified: branches/danny-web/reactos.org/htdocs/roscms/lib/Export_XML.class.php
URL:
http://svn.reactos.org/svn/reactos/branches/danny-web/reactos.org/htdocs/ro…
==============================================================================
--- branches/danny-web/reactos.org/htdocs/roscms/lib/Export_XML.class.php [iso-8859-1]
(original)
+++ branches/danny-web/reactos.org/htdocs/roscms/lib/Export_XML.class.php [iso-8859-1] Wed
Jan  7 08:43:03 2009
@@ -149,7 +149,7 @@
       $tdata .= '<view curpos="'.$page_offset.'"
pagelimit="'.$this->page_limit.'"
pagemax="'.$ptm_entries.'"
tblcols="|'.$this->column_list.'|" />';
 
       // prepare for usage in loop
-      $stmt_trans=&DBConnection::getInstance()->prepare("SELECT r.data_id,
d.name, d.type, r.id, r.version, r.lang_id, r.datetime, r.user_id FROM
".ROSCMST_ENTRIES." d JOIN ".ROSCMST_REVISIONS." r ON r.data_id=d.id
WHERE d.id = :data_id AND r.version > 0 AND r.lang_id = :lang WHERE r.archive =
:archive LIMIT 1");
+      $stmt_trans=&DBConnection::getInstance()->prepare("SELECT r.data_id,
d.name, d.type, r.id, r.version, r.lang_id, r.datetime, r.user_id FROM
".ROSCMST_ENTRIES." d JOIN ".ROSCMST_REVISIONS." r ON r.data_id=d.id
WHERE d.id = :data_id AND r.version > 0 AND r.lang_id = :lang AND r.archive = :archive
LIMIT 1");
      
$stmt_trans->bindParam('archive',$this->archive_mode,PDO::PARAM_BOOL);
      
$stmt_trans->bindParam('lang',$this->translation_lang,PDO::PARAM_INT);
       $stmt_stext=&DBConnection::getInstance()->prepare("SELECT content FROM
".ROSCMST_STEXT." WHERE rev_id = :rev_id AND name = 'title' LIMIT
1");