HGKeeper

<!DOCTYPE html>

<html>

<head>

<style>

body{white-space:pre-wrap;}

div.l0{color:#000000;} /* All debug levels. */

div.l1{color:#666666;} /* Misc. */

div.l2{color:#000000;} /* Information. */

div.l3{color:#660000;} /* Warnings. */

div.l4{color:#FF0000;} /* Errors. */

div.l5{color:#FF0000;font-weight:bold;} /* Fatal errors. */

/* Filter levels */

div#pause~div{display:none;}

body.l1 div.l0{display:none;}

body.l2 div.l0,body.l2 div.l1{display:none;}

body.l3 div.l0,body.l3 div.l1,body.l3 div.l2{display:none;}

body.l4 div.l0,body.l4 div.l1,body.l4 div.l2,body.l4 div.l3{display:none;}

body.l5 div.l0,body.l5 div.l1,body.l5 div.l2,body.l5 div.l3,body.l5 div.l4{display:none;}

/* Regex */

div.hide{display:none;}

span.regex{background-color:#ffafaf;font-weight:bold;}

</style>

function nearBottom() {

return ( document.body.scrollTop >= ( document.body.offsetHeight - ( window.innerHeight * 1.5 ) ) );

}

function scrollToBottom() {

document.body.scrollTop = document.body.offsetHeight;

}

regex = {

clear: function () {

var list, i;

var scroll = nearBottom();

/* Remove highlighting SPANs */

list = document.getElementsByClassName('regex');

i = list.length;

while (i--) {

var span = list[i];

var parent = span.parentNode;

var content = span.textContent;

var text = document.createTextNode(content);

parent.replaceChild(text, span);

}

/* Remove hidden DIVs */

list = document.getElementsByClassName('hide');

i = list.length;

while (i--) {

list[i].classList.remove('hide');

}

if (scroll)

scrollToBottom();

this.enabled = false;

highlightTextNodes: function (div, start_pos, end_pos) {

var data = [], node, range, span, contents;

var ind, end_ind

var this_start, this_end;

ind = 0;

div.normalize();

node = div;

/* First, find the container nodes and offsets to apply highlighting. */

do {

if (node.nodeType === Node.TEXT_NODE) {

end_ind = ind + node.length;

if (start_pos <= ind)

this_start = 0;

else if (start_pos < end_ind)

this_start = start_pos - ind;

else

this_start = -1;

if (end_pos < end_ind)

this_end = end_pos - ind;

else

this_end = end_ind - ind;

if (this_start != -1 && this_start < this_end) {

data.push(this_end, this_start, node);

}

ind = end_ind;

}

if (node.hasChildNodes()) {

node = node.firstChild;

} else {

while (node != div) {

var next = node.nextSibling;

if (next) {

node = next;

break;

} else {

node = node.parentNode;

}

} while (node != div);

/* Second, apply highlighting to saved sections. Changing the DOM is

automatically reflected in all WebKit API, so we have to do this after

finding the offsets, or things could get complicated. */

while (data.length) {

node = data.pop();

this_start = data.pop();

this_end = data.pop();

range = document.createRange();

range.setStart(node, this_start);

range.setEnd(node, this_end);

span = document.createElement('span');

span.className = 'regex';

contents = range.extractContents();

range.insertNode(span);

span.appendChild(contents);

}

match: function (div) {

var text, match_info;

var m, count, start_pos, end_pos;

text = div.textContent;

if (!text)

return;

/* We do a first pass to see if it matches at all. If it does we work out

* the offsets to highlight.

this.regex.lastIndex = 0;

var match_info = this.regex.exec(text);

if ((match_info != null) != this.invert) {

/* If we're not highlighting or the expression is inverted, we're

* done and move on.

if (!this.highlight || this.invert)

return;

do {

if (match_info === null)

break;

count = match_info.length;

if (count === 1)

m = 0;

else

m = 1;

/* We do this because JS doesn't provide a sufficient means to

determine the indices of matched groups. So we're just going

to highlight the entire match instead. */

m = 0; count = 1;

for (; m < count; m++) {

start_pos = match_info.index;

end_pos = this.regex.lastIndex;

if (end_pos == -1)

break;

this.highlightTextNodes(div, start_pos, end_pos);

}

/* Workaround broken API for empty matches */

if (match_info.index == this.regex.lastIndex)

this.regex.lastIndex++;

} while (match_info = this.regex.exec(text));

} else {

div.classList.add('hide');

}

filterAll: function (str, inv, high) {

this.regex = new RegExp(str, 'gi');

this.invert = inv;

this.highlight = high;

this.enabled = true;

var list = document.getElementsByTagName('div');

for (var i = 0; i < list.length; i++)

this.match(list[i]);

highlight: false,

invert: false,

enabled: false,

regex: undefined

}

function append(level, time, cat, msg) {

var div = document.createElement('div');

div.className = 'l' + level;

div.appendChild(document.createTextNode('(' + time + ') '));

if (cat) {

var cat_n = document.createElement('b');

cat_n.appendChild(document.createTextNode(cat + ':'));

div.appendChild(cat_n);

div.appendChild(document.createTextNode(' '));

}

div.appendChild(document.createTextNode(msg));

if (regex.enabled)

regex.match(div);

var scroll = nearBottom();

document.body.appendChild(div);

if (scroll)

scrollToBottom();

}

function clear() {

document.body.innerHTML = '';

}

function pauseOutput() {

document.body.insertAdjacentHTML('beforeEnd', '<div id=pause></div>');

}

function resumeOutput() {

var pause = document.getElementById('pause');

if (pause) {

var parent = pause.parentNode;

parent.removeChild(pause);

scrollToBottom();

}

function setFilterLevel(l) {

var scroll = nearBottom();

document.body.className = 'l'+l;

if (scroll)

scrollToBottom();

}

</script>

</head>

</html>

pidgin/pidgin