style: Start applying PEP8 to Python files, indentation issues

Done with `autopep8 --select=E1`, fixes:

- E101 - Reindent all lines.
- E112 - Fix under-indented comments.
- E113 - Fix over-indented comments.
- E115 - Fix under-indented comments.
- E116 - Fix over-indented comments.
- E121 - Fix a badly indented line.
- E122 - Fix a badly indented line.
- E123 - Fix a badly indented line.
- E124 - Fix a badly indented line.
- E125 - Fix indentation undistinguish from the next logical line.
- E126 - Fix a badly indented line.
- E127 - Fix a badly indented line.
- E128 - Fix a badly indented line.
- E129 - Fix a badly indented line.

6 files changed, 1939 insertions, 1939 deletions

diff --git a/doc/tools/doc_merge.py b/doc/tools/doc_merge.py
index 536770bee4..27f46960be 100644
--- a/doc/tools/doc_merge.py
+++ b/doc/tools/doc_merge.py
@@ -17,195 +17,195 @@ tab=0
 old_classes={}
 
 def write_string(_f, text,newline=True):
-	for t in range(tab):
-		_f.write("\t")
-	_f.write(text)
-	if (newline):
-		_f.write("\n")
+    for t in range(tab):
+        _f.write("\t")
+    _f.write(text)
+    if (newline):
+        _f.write("\n")
 
 def escape(ret):
-	ret=ret.replace("&","&");
-	ret=ret.replace("<","&gt;");
-	ret=ret.replace(">","&lt;");
-	ret=ret.replace("'","&apos;");
-	ret=ret.replace("\"","&quot;");
-	return ret
+    ret=ret.replace("&","&amp;");
+    ret=ret.replace("<","&gt;");
+    ret=ret.replace(">","&lt;");
+    ret=ret.replace("'","&apos;");
+    ret=ret.replace("\"","&quot;");
+    return ret
 
 
 def inc_tab():
-	global tab
-	tab+=1
+    global tab
+    tab+=1
 
 def dec_tab():
-	global tab
-	tab-=1
+    global tab
+    tab-=1
 
 write_string(f,'<?xml version="1.0" encoding="UTF-8" ?>')
 write_string(f,'<doc version="'+new_doc.attrib["version"]+'">')
 
 def get_tag(node,name):
-	tag=""
-	if (name in node.attrib):
-		tag=' '+name+'="'+escape(node.attrib[name])+'" '
-	return tag
+    tag=""
+    if (name in node.attrib):
+        tag=' '+name+'="'+escape(node.attrib[name])+'" '
+    return tag
 
 def find_method_descr(old_class,name):
 
-	methods = old_class.find("methods")
-	if(methods!=None and len(list(methods))>0):
-		for m in list(methods):
-			if (m.attrib["name"]==name):
-				description=m.find("description")
-				if (description!=None and description.text.strip()!=""):
-					return description.text
+    methods = old_class.find("methods")
+    if(methods!=None and len(list(methods))>0):
+        for m in list(methods):
+            if (m.attrib["name"]==name):
+                description=m.find("description")
+                if (description!=None and description.text.strip()!=""):
+                    return description.text
 
-	return None
+    return None
 
 def find_signal_descr(old_class,name):
 
-	signals = old_class.find("signals")
-	if(signals!=None and len(list(signals))>0):
-		for m in list(signals):
-			if (m.attrib["name"]==name):
-				description=m.find("description")
-				if (description!=None and description.text.strip()!=""):
-					return description.text
+    signals = old_class.find("signals")
+    if(signals!=None and len(list(signals))>0):
+        for m in list(signals):
+            if (m.attrib["name"]==name):
+                description=m.find("description")
+                if (description!=None and description.text.strip()!=""):
+                    return description.text
 
-	return None
+    return None
 
 def find_constant_descr(old_class,name):
 
-	if (old_class==None):
-		return None
-	constants = old_class.find("constants")
-	if(constants!=None and len(list(constants))>0):
-		for m in list(constants):
-			if (m.attrib["name"]==name):
-				if (m.text.strip()!=""):
-					return m.text
-	return None
+    if (old_class==None):
+        return None
+    constants = old_class.find("constants")
+    if(constants!=None and len(list(constants))>0):
+        for m in list(constants):
+            if (m.attrib["name"]==name):
+                if (m.text.strip()!=""):
+                    return m.text
+    return None
 
 def write_class(c):
-	class_name = c.attrib["name"]
-	print("Parsing Class: "+class_name)
-	if (class_name in old_classes):
-		old_class=old_classes[class_name]
-	else:
-		old_class=None
+    class_name = c.attrib["name"]
+    print("Parsing Class: "+class_name)
+    if (class_name in old_classes):
+        old_class=old_classes[class_name]
+    else:
+        old_class=None
 
 
-	category=get_tag(c,"category")
-	inherits=get_tag(c,"inherits")
-	write_string(f,'<class name="'+class_name+'" '+category+inherits+'>')
-	inc_tab()
+    category=get_tag(c,"category")
+    inherits=get_tag(c,"inherits")
+    write_string(f,'<class name="'+class_name+'" '+category+inherits+'>')
+    inc_tab()
 
-	write_string(f,"<brief_description>")
+    write_string(f,"<brief_description>")
 
-	if (old_class!=None):
-		old_brief_descr=old_class.find("brief_description")
-		if (old_brief_descr!=None):
-			write_string(f,escape(old_brief_descr.text.strip()))
+    if (old_class!=None):
+        old_brief_descr=old_class.find("brief_description")
+        if (old_brief_descr!=None):
+            write_string(f,escape(old_brief_descr.text.strip()))
 
 
-	write_string(f,"</brief_description>")
+    write_string(f,"</brief_description>")
 
-	write_string(f,"<description>")
-	if (old_class!=None):
-		old_descr=old_class.find("description")
-		if (old_descr!=None):
-			write_string(f,escape(old_descr.text.strip()))
+    write_string(f,"<description>")
+    if (old_class!=None):
+        old_descr=old_class.find("description")
+        if (old_descr!=None):
+            write_string(f,escape(old_descr.text.strip()))
 
-	write_string(f,"</description>")
+    write_string(f,"</description>")
 
-	methods = c.find("methods")
-	if(methods!=None and len(list(methods))>0):
+    methods = c.find("methods")
+    if(methods!=None and len(list(methods))>0):
 
-		write_string(f,"<methods>")
-		inc_tab()
+        write_string(f,"<methods>")
+        inc_tab()
 
-		for m in list(methods):
-			qualifiers=get_tag(m,"qualifiers")
+        for m in list(methods):
+            qualifiers=get_tag(m,"qualifiers")
 
-			write_string(f,'<method name="'+escape(m.attrib["name"])+'" ' +qualifiers+'>')
-			inc_tab()
+            write_string(f,'<method name="'+escape(m.attrib["name"])+'" ' +qualifiers+'>')
+            inc_tab()
 
-			for a in list(m):
-				if (a.tag=="return"):
-					typ=get_tag(a,"type")
-					write_string(f,'<return'+typ+'>');
-					write_string(f,'</return>');
-				elif (a.tag=="argument"):
+            for a in list(m):
+                if (a.tag=="return"):
+                    typ=get_tag(a,"type")
+                    write_string(f,'<return'+typ+'>');
+                    write_string(f,'</return>');
+                elif (a.tag=="argument"):
 
-					default=get_tag(a,"default")
+                    default=get_tag(a,"default")
 
-					write_string(f,'<argument index="'+a.attrib["index"]+'" name="'+escape(a.attrib["name"])+'" type="'+a.attrib["type"]+'"' +default+'>');
-					write_string(f,'</argument>');
+                    write_string(f,'<argument index="'+a.attrib["index"]+'" name="'+escape(a.attrib["name"])+'" type="'+a.attrib["type"]+'"' +default+'>');
+                    write_string(f,'</argument>');
 
-			write_string(f,'<description>');
-			if (old_class!=None):
-				old_method_descr=find_method_descr(old_class,m.attrib["name"])
-				if (old_method_descr):
-					write_string(f,escape(escape(old_method_descr.strip())))
+            write_string(f,'<description>');
+            if (old_class!=None):
+                old_method_descr=find_method_descr(old_class,m.attrib["name"])
+                if (old_method_descr):
+                    write_string(f,escape(escape(old_method_descr.strip())))
 
-			write_string(f,'</description>');
-			dec_tab()
-			write_string(f,"</method>")
-		dec_tab()
-		write_string(f,"</methods>")
+            write_string(f,'</description>');
+            dec_tab()
+            write_string(f,"</method>")
+        dec_tab()
+        write_string(f,"</methods>")
 
-	signals = c.find("signals")
-	if(signals!=None and len(list(signals))>0):
+    signals = c.find("signals")
+    if(signals!=None and len(list(signals))>0):
 
-		write_string(f,"<signals>")
-		inc_tab()
+        write_string(f,"<signals>")
+        inc_tab()
 
-		for m in list(signals):
+        for m in list(signals):
 
-			write_string(f,'<signal name="'+escape(m.attrib["name"])+'">')
-			inc_tab()
+            write_string(f,'<signal name="'+escape(m.attrib["name"])+'">')
+            inc_tab()
 
-			for a in list(m):
-				if (a.tag=="argument"):
+            for a in list(m):
+                if (a.tag=="argument"):
 
-					write_string(f,'<argument index="'+a.attrib["index"]+'" name="'+escape(a.attrib["name"])+'" type="'+a.attrib["type"]+'">');
-					write_string(f,'</argument>');
+                    write_string(f,'<argument index="'+a.attrib["index"]+'" name="'+escape(a.attrib["name"])+'" type="'+a.attrib["type"]+'">');
+                    write_string(f,'</argument>');
 
-			write_string(f,'<description>');
-			if (old_class!=None):
-				old_signal_descr=find_signal_descr(old_class,m.attrib["name"])
-				if (old_signal_descr):
-					write_string(f,escape(old_signal_descr.strip()))
-			write_string(f,'</description>');
-			dec_tab()
-			write_string(f,"</signal>")
-		dec_tab()
-		write_string(f,"</signals>")
+            write_string(f,'<description>');
+            if (old_class!=None):
+                old_signal_descr=find_signal_descr(old_class,m.attrib["name"])
+                if (old_signal_descr):
+                    write_string(f,escape(old_signal_descr.strip()))
+            write_string(f,'</description>');
+            dec_tab()
+            write_string(f,"</signal>")
+        dec_tab()
+        write_string(f,"</signals>")
 
-	constants = c.find("constants")
-	if(constants!=None and len(list(constants))>0):
+    constants = c.find("constants")
+    if(constants!=None and len(list(constants))>0):
 
-		write_string(f,"<constants>")
-		inc_tab()
+        write_string(f,"<constants>")
+        inc_tab()
 
-		for m in list(constants):
+        for m in list(constants):
 
-			write_string(f,'<constant name="'+escape(m.attrib["name"])+'" value="'+m.attrib["value"]+'">')
-			old_constant_descr=find_constant_descr(old_class,m.attrib["name"])
-			if (old_constant_descr):
-				write_string(f,escape(old_constant_descr.strip()))
-			write_string(f,"</constant>")
+            write_string(f,'<constant name="'+escape(m.attrib["name"])+'" value="'+m.attrib["value"]+'">')
+            old_constant_descr=find_constant_descr(old_class,m.attrib["name"])
+            if (old_constant_descr):
+                write_string(f,escape(old_constant_descr.strip()))
+            write_string(f,"</constant>")
 
-		dec_tab()
-		write_string(f,"</constants>")
+        dec_tab()
+        write_string(f,"</constants>")
 
-	dec_tab()
-	write_string(f,"</class>")
+    dec_tab()
+    write_string(f,"</class>")
 
 for c in list(old_doc):
-	old_classes[c.attrib["name"]]=c
+    old_classes[c.attrib["name"]]=c
 
 for c in list(new_doc):
-	write_class(c)
+    write_class(c)
 write_string(f,'</doc>\n')
 
 
diff --git a/doc/tools/doc_status.py b/doc/tools/doc_status.py
index f0ede405ce..00907bb01d 100755
--- a/doc/tools/doc_status.py
+++ b/doc/tools/doc_status.py
@@ -11,66 +11,66 @@ import xml.etree.ElementTree as ET
 ################################################################################
 
 flags = {
-	'c': platform.platform() != 'Windows', # Disable by default on windows, since we use ANSI escape codes
-	'b': False,
-	'g': False,
-	's': False,
-	'u': False,
-	'h': False,
-	'p': False,
-	'o': True,
-	'i': False,
+    'c': platform.platform() != 'Windows', # Disable by default on windows, since we use ANSI escape codes
+    'b': False,
+    'g': False,
+    's': False,
+    'u': False,
+    'h': False,
+    'p': False,
+    'o': True,
+    'i': False,
 }
 flag_descriptions = {
-	'c': 'Toggle colors when outputting.',
-	'b': 'Toggle showing only not fully described classes.',
-	'g': 'Toggle showing only completed classes.',
-	's': 'Toggle showing comments about the status.',
-	'u': 'Toggle URLs to docs.',
-	'h': 'Show help and exit.',
-	'p': 'Toggle showing percentage as well as counts.',
-	'o': 'Toggle overall column.',
-	'i': 'Toggle collapse of class items columns.',
+    'c': 'Toggle colors when outputting.',
+    'b': 'Toggle showing only not fully described classes.',
+    'g': 'Toggle showing only completed classes.',
+    's': 'Toggle showing comments about the status.',
+    'u': 'Toggle URLs to docs.',
+    'h': 'Show help and exit.',
+    'p': 'Toggle showing percentage as well as counts.',
+    'o': 'Toggle overall column.',
+    'i': 'Toggle collapse of class items columns.',
 }
 long_flags = {
-	'colors': 'c',
-	'use-colors': 'c',
+    'colors': 'c',
+    'use-colors': 'c',
 
-	'bad': 'b',
-	'only-bad': 'b',
+    'bad': 'b',
+    'only-bad': 'b',
 
-	'good': 'g',
-	'only-good': 'g',
+    'good': 'g',
+    'only-good': 'g',
 
-	'comments': 's',
-	'status': 's',
+    'comments': 's',
+    'status': 's',
 
-	'urls': 'u',
-	'gen-url': 'u',
+    'urls': 'u',
+    'gen-url': 'u',
 
-	'help': 'h',
+    'help': 'h',
 
-	'percent': 'p',
-	'use-percentages': 'p',
+    'percent': 'p',
+    'use-percentages': 'p',
 
-	'overall': 'o',
-	'use-overall': 'o',
+    'overall': 'o',
+    'use-overall': 'o',
 
-	'items': 'i',
-	'collapse': 'i',
+    'items': 'i',
+    'collapse': 'i',
 }
 table_columns = ['name', 'brief_description', 'description', 'methods', 'constants', 'members', 'signals']
 table_column_names = ['Name', 'Brief Desc.', 'Desc.', 'Methods', 'Constants', 'Members', 'Signals']
 colors = {
-	'name': [36], # cyan
-	'part_big_problem': [4, 31], # underline, red
-	'part_problem': [31], # red
-	'part_mostly_good': [33], # yellow
-	'part_good': [32], # green
-	'url': [4, 34], # underline, blue
-	'section': [1, 4], # bold, underline
-	'state_off': [36], # cyan
-	'state_on': [1, 35], # bold, magenta/plum
+    'name': [36], # cyan
+    'part_big_problem': [4, 31], # underline, red
+    'part_problem': [31], # red
+    'part_mostly_good': [33], # yellow
+    'part_good': [32], # green
+    'url': [4, 34], # underline, blue
+    'section': [1, 4], # bold, underline
+    'state_off': [36], # cyan
+    'state_on': [1, 35], # bold, magenta/plum
 }
 overall_progress_description_weigth = 10
 
@@ -81,22 +81,22 @@ overall_progress_description_weigth = 10
 ################################################################################
 
 def validate_tag(elem, tag):
-	if elem.tag != tag:
-		print('Tag mismatch, expected "' + tag + '", got ' + elem.tag)
-		sys.exit(255)
+    if elem.tag != tag:
+        print('Tag mismatch, expected "' + tag + '", got ' + elem.tag)
+        sys.exit(255)
 
 def color(color, string):
-	if flags['c']:
-		color_format = ''
-		for code in colors[color]:
-			color_format += '\033[' + str(code) + 'm'
-		return color_format + string + '\033[0m'
-	else:
-		return string
+    if flags['c']:
+        color_format = ''
+        for code in colors[color]:
+            color_format += '\033[' + str(code) + 'm'
+        return color_format + string + '\033[0m'
+    else:
+        return string
 
 ansi_escape = re.compile(r'\x1b[^m]*m')
 def nonescape_len(s):
-	return len(ansi_escape.sub('', s))
+    return len(ansi_escape.sub('', s))
 
 
 
@@ -105,138 +105,138 @@ def nonescape_len(s):
 ################################################################################
 
 class ClassStatusProgress:
-	def __init__(self, described = 0, total = 0):
-		self.described = described
-		self.total = total
-
-	def __add__(self, other):
-		return ClassStatusProgress(self.described + other.described, self.total + other.total)
-
-	def increment(self, described):
-		if described:
-			self.described += 1
-		self.total += 1
-
-	def is_ok(self):
-		return self.described >= self.total
-
-	def to_configured_colored_string(self):
-		if flags['p']:
-			return self.to_colored_string('{percent}% ({has}/{total})', '{pad_percent}{pad_described}{s}{pad_total}')
-		else:
-			return self.to_colored_string()
-
-	def to_colored_string(self, format='{has}/{total}', pad_format='{pad_described}{s}{pad_total}'):
-		ratio = self.described/self.total if self.total != 0 else 1
-		percent = round(100*ratio)
-		s = format.format(has = str(self.described), total = str(self.total), percent = str(percent))
-		if self.described >= self.total:
-			s = color('part_good', s)
-		elif self.described >= self.total/4*3:
-			s = color('part_mostly_good', s)
-		elif self.described > 0:
-			s = color('part_problem', s)
-		else:
-			s = color('part_big_problem', s)
-		pad_size = max(len(str(self.described)), len(str(self.total)))
-		pad_described = ''.ljust(pad_size - len(str(self.described)))
-		pad_percent = ''.ljust(3 - len(str(percent)))
-		pad_total = ''.ljust(pad_size - len(str(self.total)))
-		return pad_format.format(pad_described = pad_described, pad_total = pad_total, pad_percent = pad_percent, s = s)
+    def __init__(self, described = 0, total = 0):
+        self.described = described
+        self.total = total
+
+    def __add__(self, other):
+        return ClassStatusProgress(self.described + other.described, self.total + other.total)
+
+    def increment(self, described):
+        if described:
+            self.described += 1
+        self.total += 1
+
+    def is_ok(self):
+        return self.described >= self.total
+
+    def to_configured_colored_string(self):
+        if flags['p']:
+            return self.to_colored_string('{percent}% ({has}/{total})', '{pad_percent}{pad_described}{s}{pad_total}')
+        else:
+            return self.to_colored_string()
+
+    def to_colored_string(self, format='{has}/{total}', pad_format='{pad_described}{s}{pad_total}'):
+        ratio = self.described/self.total if self.total != 0 else 1
+        percent = round(100*ratio)
+        s = format.format(has = str(self.described), total = str(self.total), percent = str(percent))
+        if self.described >= self.total:
+            s = color('part_good', s)
+        elif self.described >= self.total/4*3:
+            s = color('part_mostly_good', s)
+        elif self.described > 0:
+            s = color('part_problem', s)
+        else:
+            s = color('part_big_problem', s)
+        pad_size = max(len(str(self.described)), len(str(self.total)))
+        pad_described = ''.ljust(pad_size - len(str(self.described)))
+        pad_percent = ''.ljust(3 - len(str(percent)))
+        pad_total = ''.ljust(pad_size - len(str(self.total)))
+        return pad_format.format(pad_described = pad_described, pad_total = pad_total, pad_percent = pad_percent, s = s)
 
 
 class ClassStatus:
-	def __init__(self, name=''):
-		self.name = name
-		self.has_brief_description = True
-		self.has_description = True
-		self.progresses = {
-			'methods': ClassStatusProgress(),
-			'constants': ClassStatusProgress(),
-			'members': ClassStatusProgress(),
-			'signals': ClassStatusProgress()
-		}
+    def __init__(self, name=''):
+        self.name = name
+        self.has_brief_description = True
+        self.has_description = True
+        self.progresses = {
+            'methods': ClassStatusProgress(),
+            'constants': ClassStatusProgress(),
+            'members': ClassStatusProgress(),
+            'signals': ClassStatusProgress()
+        }
 
-	def __add__(self, other):
-		new_status = ClassStatus()
-		new_status.name = self.name
-		new_status.has_brief_description = self.has_brief_description and other.has_brief_description
-		new_status.has_description = self.has_description and other.has_description
-		for k in self.progresses:
-			new_status.progresses[k] = self.progresses[k] + other.progresses[k]
-		return new_status
+    def __add__(self, other):
+        new_status = ClassStatus()
+        new_status.name = self.name
+        new_status.has_brief_description = self.has_brief_description and other.has_brief_description
+        new_status.has_description = self.has_description and other.has_description
+        for k in self.progresses:
+            new_status.progresses[k] = self.progresses[k] + other.progresses[k]
+        return new_status
 
-	def is_ok(self):
-		ok = True
-		ok = ok and self.has_brief_description
-		ok = ok and self.has_description
-		for k in self.progresses:
-			ok = ok and self.progresses[k].is_ok()
-		return ok
+    def is_ok(self):
+        ok = True
+        ok = ok and self.has_brief_description
+        ok = ok and self.has_description
+        for k in self.progresses:
+            ok = ok and self.progresses[k].is_ok()
+        return ok
 
-	def make_output(self):
-		output = {}
-		output['name'] = color('name', self.name)
+    def make_output(self):
+        output = {}
+        output['name'] = color('name', self.name)
 
-		ok_string = color('part_good', 'OK')
-		missing_string = color('part_big_problem', 'MISSING')
+        ok_string = color('part_good', 'OK')
+        missing_string = color('part_big_problem', 'MISSING')
 
-		output['brief_description'] = ok_string if self.has_brief_description else missing_string
-		output['description'] = ok_string if self.has_description else missing_string
+        output['brief_description'] = ok_string if self.has_brief_description else missing_string
+        output['description'] = ok_string if self.has_description else missing_string
 
-		description_progress = ClassStatusProgress(
-			(self.has_brief_description + self.has_description) * overall_progress_description_weigth,
-			2 * overall_progress_description_weigth
-		)
-		items_progress = ClassStatusProgress()
+        description_progress = ClassStatusProgress(
+            (self.has_brief_description + self.has_description) * overall_progress_description_weigth,
+            2 * overall_progress_description_weigth
+        )
+        items_progress = ClassStatusProgress()
 
-		for k in ['methods', 'constants', 'members', 'signals']:
-			items_progress += self.progresses[k]
-			output[k] = self.progresses[k].to_configured_colored_string()
+        for k in ['methods', 'constants', 'members', 'signals']:
+            items_progress += self.progresses[k]
+            output[k] = self.progresses[k].to_configured_colored_string()
 
-		output['items'] = items_progress.to_configured_colored_string()
+        output['items'] = items_progress.to_configured_colored_string()
 
-		output['overall'] = (description_progress + items_progress).to_colored_string('{percent}%', '{pad_percent}{s}')
+        output['overall'] = (description_progress + items_progress).to_colored_string('{percent}%', '{pad_percent}{s}')
 
-		if self.name.startswith('Total'):
-			output['url'] = color('url', 'http://docs.godotengine.org/en/latest/classes/_classes.html')
-			if flags['s']:
-				output['comment'] = color('part_good', 'ALL OK')
-		else:
-			output['url'] = color('url', 'http://docs.godotengine.org/en/latest/classes/class_{name}.html'.format(name=self.name.lower()))
+        if self.name.startswith('Total'):
+            output['url'] = color('url', 'http://docs.godotengine.org/en/latest/classes/_classes.html')
+            if flags['s']:
+                output['comment'] = color('part_good', 'ALL OK')
+        else:
+            output['url'] = color('url', 'http://docs.godotengine.org/en/latest/classes/class_{name}.html'.format(name=self.name.lower()))
 
-			if flags['s'] and not flags['g'] and self.is_ok():
-				output['comment'] = color('part_good', 'ALL OK')
+            if flags['s'] and not flags['g'] and self.is_ok():
+                output['comment'] = color('part_good', 'ALL OK')
 
-		return output
+        return output
 
-	def generate_for_class(c):
-		status = ClassStatus()
-		status.name = c.attrib['name']
-		for tag in list(c):
+    def generate_for_class(c):
+        status = ClassStatus()
+        status.name = c.attrib['name']
+        for tag in list(c):
 
-			if tag.tag == 'brief_description':
-				status.has_brief_description = len(tag.text.strip()) > 0
+            if tag.tag == 'brief_description':
+                status.has_brief_description = len(tag.text.strip()) > 0
 
-			elif tag.tag == 'description':
-				status.has_description = len(tag.text.strip()) > 0
+            elif tag.tag == 'description':
+                status.has_description = len(tag.text.strip()) > 0
 
-			elif tag.tag in ['methods', 'signals']:
-				for sub_tag in list(tag):
-					descr = sub_tag.find('description')
-					status.progresses[tag.tag].increment(len(descr.text.strip()) > 0)
+            elif tag.tag in ['methods', 'signals']:
+                for sub_tag in list(tag):
+                    descr = sub_tag.find('description')
+                    status.progresses[tag.tag].increment(len(descr.text.strip()) > 0)
 
-			elif tag.tag in ['constants', 'members']:
-				for sub_tag in list(tag):
-					status.progresses[tag.tag].increment(len(sub_tag.text.strip()) > 0)
+            elif tag.tag in ['constants', 'members']:
+                for sub_tag in list(tag):
+                    status.progresses[tag.tag].increment(len(sub_tag.text.strip()) > 0)
 
-			elif tag.tag in ['theme_items']:
-				pass #Ignore those tags, since they seem to lack description at all
+            elif tag.tag in ['theme_items']:
+                pass #Ignore those tags, since they seem to lack description at all
 
-			else:
-				print(tag.tag, tag.attrib)
+            else:
+                print(tag.tag, tag.attrib)
 
-		return status
+        return status
 
 
 
@@ -248,31 +248,31 @@ input_file_list = []
 input_class_list = []
 
 for arg in sys.argv[1:]:
-	if arg.startswith('--'):
-		flags[long_flags[arg[2:]]] = not flags[long_flags[arg[2:]]]
-	elif arg.startswith('-'):
-		for f in arg[1:]:
-			flags[f] = not flags[f]
-	elif arg.endswith('.xml'):
-		input_file_list.append(arg)
-	else:
-		input_class_list.append(arg)
+    if arg.startswith('--'):
+        flags[long_flags[arg[2:]]] = not flags[long_flags[arg[2:]]]
+    elif arg.startswith('-'):
+        for f in arg[1:]:
+            flags[f] = not flags[f]
+    elif arg.endswith('.xml'):
+        input_file_list.append(arg)
+    else:
+        input_class_list.append(arg)
 
 if flags['i']:
-	for r in ['methods', 'constants', 'members', 'signals']:
-		index = table_columns.index(r)
-		del table_column_names[index]
-		del table_columns[index]
-	table_column_names.append('Items')
-	table_columns.append('items')
+    for r in ['methods', 'constants', 'members', 'signals']:
+        index = table_columns.index(r)
+        del table_column_names[index]
+        del table_columns[index]
+    table_column_names.append('Items')
+    table_columns.append('items')
 
 if flags['o'] == (not flags['i']):
-	table_column_names.append('Overall')
-	table_columns.append('overall')
+    table_column_names.append('Overall')
+    table_columns.append('overall')
 
 if flags['u']:
-	table_column_names.append('Docs URL')
-	table_columns.append('url')
+    table_column_names.append('Docs URL')
+    table_columns.append('url')
 
 
 ################################################################################
@@ -280,28 +280,28 @@ if flags['u']:
 ################################################################################
 
 if len(input_file_list) < 1 or flags['h']:
-	if not flags['h']:
-		print(color('section', 'Invalid usage') + ': At least one classes.xml file is required')
-	print(color('section', 'Usage') + ': doc_status.py [flags] <classes.xml> [class names]')
-	print('\t< and > signify required parameters, while [ and ] signify optional parameters.')
-	print('\tNote that you can give more than one classes file, in which case they will be merged on-the-fly.')
-	print(color('section', 'Available flags') + ':')
-	possible_synonym_list = list(long_flags)
-	possible_synonym_list.sort()
-	flag_list = list(flags)
-	flag_list.sort()
-	for flag in flag_list:
-		synonyms = [color('name', '-' + flag)]
-		for synonym in possible_synonym_list:
-			if long_flags[synonym] == flag:
-				synonyms.append(color('name', '--' + synonym))
-
-		print(('{synonyms} (Currently '+color('state_'+('on' if flags[flag] else 'off'), '{value}')+')\n\t{description}').format(
-			synonyms = ', '.join(synonyms),
-			value = ('on' if flags[flag] else 'off'),
-			description = flag_descriptions[flag]
-		))
-	sys.exit(0)
+    if not flags['h']:
+        print(color('section', 'Invalid usage') + ': At least one classes.xml file is required')
+    print(color('section', 'Usage') + ': doc_status.py [flags] <classes.xml> [class names]')
+    print('\t< and > signify required parameters, while [ and ] signify optional parameters.')
+    print('\tNote that you can give more than one classes file, in which case they will be merged on-the-fly.')
+    print(color('section', 'Available flags') + ':')
+    possible_synonym_list = list(long_flags)
+    possible_synonym_list.sort()
+    flag_list = list(flags)
+    flag_list.sort()
+    for flag in flag_list:
+        synonyms = [color('name', '-' + flag)]
+        for synonym in possible_synonym_list:
+            if long_flags[synonym] == flag:
+                synonyms.append(color('name', '--' + synonym))
+
+        print(('{synonyms} (Currently '+color('state_'+('on' if flags[flag] else 'off'), '{value}')+')\n\t{description}').format(
+            synonyms = ', '.join(synonyms),
+            value = ('on' if flags[flag] else 'off'),
+            description = flag_descriptions[flag]
+        ))
+    sys.exit(0)
 
 
 
@@ -313,25 +313,25 @@ class_names = []
 classes = {}
 
 for file in input_file_list:
-	tree = ET.parse(file)
-	doc = tree.getroot()
+    tree = ET.parse(file)
+    doc = tree.getroot()
 
-	if 'version' not in doc.attrib:
-		print('Version missing from "doc"')
-		sys.exit(255)
+    if 'version' not in doc.attrib:
+        print('Version missing from "doc"')
+        sys.exit(255)
 
-	version = doc.attrib['version']
+    version = doc.attrib['version']
 
-	for c in list(doc):
-		if c.attrib['name'] in class_names:
-			continue
-		class_names.append(c.attrib['name'])
-		classes[c.attrib['name']] = c
+    for c in list(doc):
+        if c.attrib['name'] in class_names:
+            continue
+        class_names.append(c.attrib['name'])
+        classes[c.attrib['name']] = c
 
 class_names.sort()
 
 if len(input_class_list) < 1:
-	input_class_list = class_names
+    input_class_list = class_names
 
 
 
@@ -346,32 +346,32 @@ table_column_chars = '|'
 total_status = ClassStatus('Total')
 
 for cn in input_class_list:
-	if not cn in classes:
-		print('Cannot find class ' + cn + '!')
-		sys.exit(255)
+    if not cn in classes:
+        print('Cannot find class ' + cn + '!')
+        sys.exit(255)
 
-	c = classes[cn]
-	validate_tag(c, 'class')
-	status = ClassStatus.generate_for_class(c)
+    c = classes[cn]
+    validate_tag(c, 'class')
+    status = ClassStatus.generate_for_class(c)
 
-	if flags['b'] and status.is_ok():
-		continue
-	if flags['g'] and not status.is_ok():
-		continue
+    if flags['b'] and status.is_ok():
+        continue
+    if flags['g'] and not status.is_ok():
+        continue
 
-	total_status = total_status + status
-	out = status.make_output()
-	row = []
-	for column in table_columns:
-		if column in out:
-			row.append(out[column])
-		else:
-			row.append('')
+    total_status = total_status + status
+    out = status.make_output()
+    row = []
+    for column in table_columns:
+        if column in out:
+            row.append(out[column])
+        else:
+            row.append('')
 
-	if 'comment' in out and out['comment'] != '':
-		row.append(out['comment'])
+    if 'comment' in out and out['comment'] != '':
+        row.append(out['comment'])
 
-	table.append(row)
+    table.append(row)
 
 
 
@@ -381,50 +381,50 @@ for cn in input_class_list:
 ################################################################################
 
 if len(table) == 1:
-	print(color('part_big_problem', 'No classes suitable for printing!'))
-	sys.exit(0)
+    print(color('part_big_problem', 'No classes suitable for printing!'))
+    sys.exit(0)
 
 if len(table) > 2:
-	total_status.name = 'Total = {0}'.format(len(table) - 1)
-	out = total_status.make_output()
-	row = []
-	for column in table_columns:
-		if column in out:
-			row.append(out[column])
-		else:
-			row.append('')
-	table.append(row)
+    total_status.name = 'Total = {0}'.format(len(table) - 1)
+    out = total_status.make_output()
+    row = []
+    for column in table_columns:
+        if column in out:
+            row.append(out[column])
+        else:
+            row.append('')
+    table.append(row)
 
 table_column_sizes = []
 for row in table:
-	for cell_i, cell in enumerate(row):
-		if cell_i >= len(table_column_sizes):
-			table_column_sizes.append(0)
+    for cell_i, cell in enumerate(row):
+        if cell_i >= len(table_column_sizes):
+            table_column_sizes.append(0)
 
-		table_column_sizes[cell_i] = max(nonescape_len(cell), table_column_sizes[cell_i])
+        table_column_sizes[cell_i] = max(nonescape_len(cell), table_column_sizes[cell_i])
 
 divider_string = table_row_chars[0]
 for cell_i in range(len(table[0])):
-	divider_string += table_row_chars[1] * (table_column_sizes[cell_i] + 2) + table_row_chars[0]
+    divider_string += table_row_chars[1] * (table_column_sizes[cell_i] + 2) + table_row_chars[0]
 print(divider_string)
 
 for row_i, row in enumerate(table):
-	row_string = table_column_chars
-	for cell_i, cell in enumerate(row):
-		padding_needed = table_column_sizes[cell_i] - nonescape_len(cell) + 2
-		if cell_i == 0:
-			row_string += table_row_chars[2] + cell + table_row_chars[2]*(padding_needed-1)
-		else:
-			row_string += table_row_chars[2]*math.floor(padding_needed/2) + cell + table_row_chars[2]*math.ceil((padding_needed/2))
-		row_string += table_column_chars
+    row_string = table_column_chars
+    for cell_i, cell in enumerate(row):
+        padding_needed = table_column_sizes[cell_i] - nonescape_len(cell) + 2
+        if cell_i == 0:
+            row_string += table_row_chars[2] + cell + table_row_chars[2]*(padding_needed-1)
+        else:
+            row_string += table_row_chars[2]*math.floor(padding_needed/2) + cell + table_row_chars[2]*math.ceil((padding_needed/2))
+        row_string += table_column_chars
 
-	print(row_string)
+    print(row_string)
 
-	if row_i == 0 or row_i == len(table) - 2:
-		print(divider_string)
+    if row_i == 0 or row_i == len(table) - 2:
+        print(divider_string)
 
 print(divider_string)
 
 if total_status.is_ok() and not flags['g']:
-	print('All listed classes are ' + color('part_good', 'OK') + '!')
+    print('All listed classes are ' + color('part_good', 'OK') + '!')
 
diff --git a/doc/tools/makedoku.py b/doc/tools/makedoku.py
index 7c3ca29af8..f00a4614d5 100644
--- a/doc/tools/makedoku.py
+++ b/doc/tools/makedoku.py
@@ -8,17 +8,17 @@ input_list = []
 
 
 for arg in sys.argv[1:]:
-  input_list.append(arg)
+    input_list.append(arg)
 
 if len(input_list) < 1:
-  print("usage: makedoku.py <classes.xml>")
-  sys.exit(0)
+    print("usage: makedoku.py <classes.xml>")
+    sys.exit(0)
 
 
 def validate_tag(elem,tag):
-  if (elem.tag != tag):
-    print("Tag mismatch, expected '"+tag+"', got "+elem.tag);
-    sys.exit(255)
+    if (elem.tag != tag):
+        print("Tag mismatch, expected '"+tag+"', got "+elem.tag);
+        sys.exit(255)
 
 
 class_names=[]
@@ -27,289 +27,289 @@ classes={}
 
 def make_class_list(class_list,columns):
 
-	f=open("class_list.txt","wb")
-	prev=0
-	col_max = len(class_list) / columns + 1
-	print("col max is ", col_max)
-	col_count = 0
-	row_count = 0
-	last_initial = ""
-	fit_columns=[]
+    f=open("class_list.txt","wb")
+    prev=0
+    col_max = len(class_list) / columns + 1
+    print("col max is ", col_max)
+    col_count = 0
+    row_count = 0
+    last_initial = ""
+    fit_columns=[]
 
-	for n in range(0,columns):
-		fit_columns+=[[]]
+    for n in range(0,columns):
+        fit_columns+=[[]]
 
-	indexers=[]
-	last_initial=""
+    indexers=[]
+    last_initial=""
 
-	idx=0
-	for n in class_list:
-		col = idx/col_max
-		if (col>=columns):
-			col=columns-1
-		fit_columns[col]+=[n]
-		idx+=1
-		if (n[:1]!=last_initial):
-			indexers+=[n]
-		last_initial=n[:1]
+    idx=0
+    for n in class_list:
+        col = idx/col_max
+        if (col>=columns):
+            col=columns-1
+        fit_columns[col]+=[n]
+        idx+=1
+        if (n[:1]!=last_initial):
+            indexers+=[n]
+        last_initial=n[:1]
 
 
-	row_max=0
+    row_max=0
 
-	for n in range(0,columns):
-		if (len(fit_columns[n])>row_max):
-			row_max=len(fit_columns[n])
+    for n in range(0,columns):
+        if (len(fit_columns[n])>row_max):
+            row_max=len(fit_columns[n])
 
 
-	for r in range(0,row_max):
-		s="|"
-		for c in range(0,columns):
-			if (r>=len(fit_columns[c])):
-				continue
+    for r in range(0,row_max):
+        s="|"
+        for c in range(0,columns):
+            if (r>=len(fit_columns[c])):
+                continue
 
-			classname = fit_columns[c][r]
-			initial=classname[0]
-			if (classname in indexers):
-				s+="**"+initial+"**|"
-			else:
-				s+=" |"
+            classname = fit_columns[c][r]
+            initial=classname[0]
+            if (classname in indexers):
+                s+="**"+initial+"**|"
+            else:
+                s+=" |"
 
-			s+="[["+classname.lower()+"|"+classname+"]]|"
+            s+="[["+classname.lower()+"|"+classname+"]]|"
 
-		s+="\n"
-		f.write(s)
+        s+="\n"
+        f.write(s)
 
 
 def dokuize_text(txt):
 
-	return txt
+    return txt
 
 
 def dokuize_text(text):
- pos=0
- while(True):
-  pos = text.find("[",pos)
-  if (pos==-1):
-   break
-
-  endq_pos=text.find("]",pos+1)
-  if (endq_pos==-1):
-   break
-
-  pre_text=text[:pos]
-  post_text=text[endq_pos+1:]
-  tag_text=text[pos+1:endq_pos]
-
-  if (tag_text in class_names):
-    tag_text="[["+tag_text.lower()+"|"+tag_text+"]]"
-  else: #command
-   cmd=tag_text
-   space_pos=tag_text.find(" ")
-   if (cmd.find("html")==0):
-    cmd=tag_text[:space_pos]
-    param=tag_text[space_pos+1:]
-    tag_text="<"+param+">"
-   elif(cmd.find("method")==0):
-    cmd=tag_text[:space_pos]
-    param=tag_text[space_pos+1:]
-
-    if (param.find(".")!=-1):
-     class_param,method_param=param.split(".")
-     tag_text="[["+class_param.lower()+"#"+method_param+"|"+class_param+'.'+method_param+"]]"
-    else:
-     tag_text="[[#"+param+"|"+param+"]]"
-   elif (cmd.find("image=")==0):
-    tag_text="{{"+cmd[6:]+"}}"
-   elif (cmd.find("url=")==0):
-    tag_text="[["+cmd[4:]+"|"
-   elif (cmd=="/url"):
-    tag_text="]]>"
-   elif (cmd=="center"):
-    tag_text=""
-   elif (cmd=="/center"):
-    tag_text=""
-   elif (cmd=="br"):
-    tag_text="\\\\\n"
-   elif (cmd=="i" or cmd=="/i"):
-    tag_text="//"
-   elif (cmd=="b" or cmd=="/b"):
-    tag_text="**"
-   elif (cmd=="u" or cmd=="/u"):
-    tag_text="__"
-   else:
-    tag_text="["+tag_text+"]"
-
-
-  text=pre_text+tag_text+post_text
-  pos=len(pre_text)+len(tag_text)
-
- #tnode = ET.SubElement(parent,"div")
- #tnode.text=text
- return text
+    pos=0
+    while(True):
+        pos = text.find("[",pos)
+        if (pos==-1):
+            break
+
+        endq_pos=text.find("]",pos+1)
+        if (endq_pos==-1):
+            break
+
+        pre_text=text[:pos]
+        post_text=text[endq_pos+1:]
+        tag_text=text[pos+1:endq_pos]
+
+        if (tag_text in class_names):
+            tag_text="[["+tag_text.lower()+"|"+tag_text+"]]"
+        else: #command
+            cmd=tag_text
+            space_pos=tag_text.find(" ")
+            if (cmd.find("html")==0):
+                cmd=tag_text[:space_pos]
+                param=tag_text[space_pos+1:]
+                tag_text="<"+param+">"
+            elif(cmd.find("method")==0):
+                cmd=tag_text[:space_pos]
+                param=tag_text[space_pos+1:]
+
+                if (param.find(".")!=-1):
+                    class_param,method_param=param.split(".")
+                    tag_text="[["+class_param.lower()+"#"+method_param+"|"+class_param+'.'+method_param+"]]"
+                else:
+                    tag_text="[[#"+param+"|"+param+"]]"
+            elif (cmd.find("image=")==0):
+                tag_text="{{"+cmd[6:]+"}}"
+            elif (cmd.find("url=")==0):
+                tag_text="[["+cmd[4:]+"|"
+            elif (cmd=="/url"):
+                tag_text="]]>"
+            elif (cmd=="center"):
+                tag_text=""
+            elif (cmd=="/center"):
+                tag_text=""
+            elif (cmd=="br"):
+                tag_text="\\\\\n"
+            elif (cmd=="i" or cmd=="/i"):
+                tag_text="//"
+            elif (cmd=="b" or cmd=="/b"):
+                tag_text="**"
+            elif (cmd=="u" or cmd=="/u"):
+                tag_text="__"
+            else:
+                tag_text="["+tag_text+"]"
+
+
+        text=pre_text+tag_text+post_text
+        pos=len(pre_text)+len(tag_text)
+
+    #tnode = ET.SubElement(parent,"div")
+    #tnode.text=text
+    return text
 
 
 def make_type(t):
-	global class_names
-	if (t in class_names):
-		return "[["+t.lower()+"|"+t+"]]"
-	return t
+    global class_names
+    if (t in class_names):
+        return "[["+t.lower()+"|"+t+"]]"
+    return t
 
 
 def make_method(f,name,m,declare,event=False):
 
-	s="  * "
-	ret_type="void"
-	args=list(m)
-	mdata={}
-	mdata["argidx"]=[]
-	for a in args:
-		if (a.tag=="return"):
-			idx=-1
-		elif (a.tag=="argument"):
-			idx=int(a.attrib["index"])
-		else:
-			continue
-
-		mdata["argidx"].append(idx)
-		mdata[idx]=a
-
-
-
-	if (not event):
-		if (-1 in mdata["argidx"]):
-			s+=make_type(mdata[-1].attrib["type"])
-		else:
-			s+="void"
-		s+=" "
-
-	if (declare):
-
-		#span.attrib["class"]="funcdecl"
-		#a=ET.SubElement(span,"a")
-		#a.attrib["name"]=name+"_"+m.attrib["name"]
-		#a.text=name+"::"+m.attrib["name"]
-		s+="**"+m.attrib["name"]+"**"
-	else:
-		s+="[[#"+m.attrib["name"]+"|"+m.attrib["name"]+"]]"
+    s="  * "
+    ret_type="void"
+    args=list(m)
+    mdata={}
+    mdata["argidx"]=[]
+    for a in args:
+        if (a.tag=="return"):
+            idx=-1
+        elif (a.tag=="argument"):
+            idx=int(a.attrib["index"])
+        else:
+            continue
+
+        mdata["argidx"].append(idx)
+        mdata[idx]=a
+
+
+
+    if (not event):
+        if (-1 in mdata["argidx"]):
+            s+=make_type(mdata[-1].attrib["type"])
+        else:
+            s+="void"
+        s+=" "
+
+    if (declare):
+
+        #span.attrib["class"]="funcdecl"
+        #a=ET.SubElement(span,"a")
+        #a.attrib["name"]=name+"_"+m.attrib["name"]
+        #a.text=name+"::"+m.attrib["name"]
+        s+="**"+m.attrib["name"]+"**"
+    else:
+        s+="[[#"+m.attrib["name"]+"|"+m.attrib["name"]+"]]"
 
-	s+="**(**"
-	argfound=False
-	for a in mdata["argidx"]:
-		arg=mdata[a]
-		if (a<0):
-			continue
-		if (a>0):
-			s+=", "
-		else:
-			s+=" "
+    s+="**(**"
+    argfound=False
+    for a in mdata["argidx"]:
+        arg=mdata[a]
+        if (a<0):
+            continue
+        if (a>0):
+            s+=", "
+        else:
+            s+=" "
 
-		s+=make_type(arg.attrib["type"])
-		if ("name" in arg.attrib):
-			s+=" "+arg.attrib["name"]
-		else:
-			s+=" arg"+str(a)
+        s+=make_type(arg.attrib["type"])
+        if ("name" in arg.attrib):
+            s+=" "+arg.attrib["name"]
+        else:
+            s+=" arg"+str(a)
 
-		if ("default" in arg.attrib):
-			s+="="+arg.attrib["default"]
+        if ("default" in arg.attrib):
+            s+="="+arg.attrib["default"]
 
 
-		argfound=True
+        argfound=True
 
-	if (argfound):
-		s+=" "
-	s+="**)**"
+    if (argfound):
+        s+=" "
+    s+="**)**"
 
-	if ("qualifiers" in m.attrib):
-		s+=" "+m.attrib["qualifiers"]
+    if ("qualifiers" in m.attrib):
+        s+=" "+m.attrib["qualifiers"]
 
-	f.write(s+"\n")
+    f.write(s+"\n")
 
 
 def make_doku_class(node):
 
-	name = node.attrib["name"]
+    name = node.attrib["name"]
 
-	f=open(name.lower()+".txt","wb")
+    f=open(name.lower()+".txt","wb")
 
-	f.write("======  "+name+"  ======\n")
+    f.write("======  "+name+"  ======\n")
 
-	if ("inherits" in node.attrib):
-		inh=node.attrib["inherits"].strip()
-		f.write("**Inherits:** [["+inh.lower()+"|"+inh+"]]\\\\\n")
-	if ("category" in node.attrib):
-		f.write("**Category:** "+node.attrib["category"].strip()+"\\\\\n")
+    if ("inherits" in node.attrib):
+        inh=node.attrib["inherits"].strip()
+        f.write("**Inherits:** [["+inh.lower()+"|"+inh+"]]\\\\\n")
+    if ("category" in node.attrib):
+        f.write("**Category:** "+node.attrib["category"].strip()+"\\\\\n")
 
-	briefd = node.find("brief_description")
-	if (briefd!=None):
-		f.write("=====  Brief Description  ======\n")
-		f.write( dokuize_text(briefd.text.strip())+"\n" )
+    briefd = node.find("brief_description")
+    if (briefd!=None):
+        f.write("=====  Brief Description  ======\n")
+        f.write( dokuize_text(briefd.text.strip())+"\n" )
 
-	methods = node.find("methods")
+    methods = node.find("methods")
 
-	if(methods!=None and len(list(methods))>0):
-		f.write("=====  Member Functions  ======\n")
-		for m in list(methods):
-			make_method(f,node.attrib["name"],m,False)
+    if(methods!=None and len(list(methods))>0):
+        f.write("=====  Member Functions  ======\n")
+        for m in list(methods):
+            make_method(f,node.attrib["name"],m,False)
 
-	events = node.find("signals")
-	if(events!=None and len(list(events))>0):
-		f.write("=====  Signals  ======\n")
-		for m in list(events):
-			make_method(f,node.attrib["name"],m,True,True)
+    events = node.find("signals")
+    if(events!=None and len(list(events))>0):
+        f.write("=====  Signals  ======\n")
+        for m in list(events):
+            make_method(f,node.attrib["name"],m,True,True)
 
-	members = node.find("members")
+    members = node.find("members")
 
-	if(members!=None and len(list(members))>0):
-		f.write("=====  Member Variables  ======\n")
+    if(members!=None and len(list(members))>0):
+        f.write("=====  Member Variables  ======\n")
 
-		for c in list(members):
-			s = "  * "
-			s+=make_type(c.attrib["type"])+" "
-			s+="**"+c.attrib["name"]+"**"
-			if (c.text.strip()!=""):
-				s+=" - "+c.text.strip()
-			f.write(s+"\n")
+        for c in list(members):
+            s = "  * "
+            s+=make_type(c.attrib["type"])+" "
+            s+="**"+c.attrib["name"]+"**"
+            if (c.text.strip()!=""):
+                s+=" - "+c.text.strip()
+            f.write(s+"\n")
 
 
 
-	constants = node.find("constants")
-	if(constants!=None and len(list(constants))>0):
-		f.write("=====  Numeric Constants  ======\n")
-		for c in list(constants):
-			s = "  * "
-			s+="**"+c.attrib["name"]+"**"
-			if ("value" in c.attrib):
-				s+=" = **"+c.attrib["value"]+"**"
-			if (c.text.strip()!=""):
-				s+=" - "+c.text.strip()
-			f.write(s+"\n")
+    constants = node.find("constants")
+    if(constants!=None and len(list(constants))>0):
+        f.write("=====  Numeric Constants  ======\n")
+        for c in list(constants):
+            s = "  * "
+            s+="**"+c.attrib["name"]+"**"
+            if ("value" in c.attrib):
+                s+=" = **"+c.attrib["value"]+"**"
+            if (c.text.strip()!=""):
+                s+=" - "+c.text.strip()
+            f.write(s+"\n")
 
 
-	descr=node.find("description")
-	if (descr!=None and descr.text.strip()!=""):
-		f.write("=====  Description  ======\n")
-		f.write(dokuize_text(descr.text.strip())+"\n")
+    descr=node.find("description")
+    if (descr!=None and descr.text.strip()!=""):
+        f.write("=====  Description  ======\n")
+        f.write(dokuize_text(descr.text.strip())+"\n")
 
-	methods = node.find("methods")
+    methods = node.find("methods")
 
-	if(methods!=None and len(list(methods))>0):
-		f.write("=====  Member Function Description  ======\n")
-		for m in list(methods):
+    if(methods!=None and len(list(methods))>0):
+        f.write("=====  Member Function Description  ======\n")
+        for m in list(methods):
 
-			d=m.find("description")
-			if (d==None or d.text.strip()==""):
-				continue
-			f.write("==  "+m.attrib["name"]+"  ==\n")
-			make_method(f,node.attrib["name"],m,False)
-			f.write("\\\\\n")
-			f.write(dokuize_text(d.text.strip()))
-			f.write("\n")
+            d=m.find("description")
+            if (d==None or d.text.strip()==""):
+                continue
+            f.write("==  "+m.attrib["name"]+"  ==\n")
+            make_method(f,node.attrib["name"],m,False)
+            f.write("\\\\\n")
+            f.write(dokuize_text(d.text.strip()))
+            f.write("\n")
 
 
 
 
 
-	"""
+    """
   div=ET.Element("div")
   div.attrib["class"]="class";
 
@@ -487,20 +487,20 @@ def make_doku_class(node):
   return div
 """
 for file in input_list:
-	tree = ET.parse(file)
-	doc=tree.getroot()
+    tree = ET.parse(file)
+    doc=tree.getroot()
 
-	if ("version" not in doc.attrib):
-		print("Version missing from 'doc'")
-		sys.exit(255)
+    if ("version" not in doc.attrib):
+        print("Version missing from 'doc'")
+        sys.exit(255)
 
-	version=doc.attrib["version"]
+    version=doc.attrib["version"]
 
-	for c in list(doc):
-		if (c.attrib["name"] in class_names):
-			continue
-		class_names.append(c.attrib["name"])
-		classes[c.attrib["name"]]=c
+    for c in list(doc):
+        if (c.attrib["name"] in class_names):
+            continue
+        class_names.append(c.attrib["name"])
+        classes[c.attrib["name"]]=c
 
 
 class_names.sort()
@@ -508,7 +508,7 @@ class_names.sort()
 make_class_list(class_names,4)
 
 for cn in class_names:
-	c=classes[cn]
-	make_doku_class(c)
+    c=classes[cn]
+    make_doku_class(c)
 
 
diff --git a/doc/tools/makehtml.py b/doc/tools/makehtml.py
index b0a8cbda88..12f92883a4 100644
--- a/doc/tools/makehtml.py
+++ b/doc/tools/makehtml.py
@@ -6,676 +6,676 @@ import xml.etree.ElementTree as ET
 from xml.sax.saxutils import escape, unescape
 
 html_escape_table = {
- '"': "&quot;",
- "'": "&apos;"
+    '"': "&quot;",
+    "'": "&apos;"
 }
 
 html_unescape_table = {v:k for k, v in html_escape_table.items()}
 
 def html_escape(text):
- return escape(text, html_escape_table)
+    return escape(text, html_escape_table)
 
 def html_unescape(text):
- return unescape(text, html_unescape_table)
+    return unescape(text, html_unescape_table)
 
 input_list = []
 
 single_page=True
 
 for arg in sys.argv[1:]:
- if arg[:1] == "-":
-  if arg[1:] == "multipage":
-   single_page = False
-  if arg[1:] == "singlepage":
-   single_page = True
- else:
-  input_list.append(arg)
+    if arg[:1] == "-":
+        if arg[1:] == "multipage":
+            single_page = False
+        if arg[1:] == "singlepage":
+            single_page = True
+    else:
+        input_list.append(arg)
 
 if len(input_list) < 1:
-  print("usage: makehtml.py <classes.xml>")
-  sys.exit(0)
+    print("usage: makehtml.py <classes.xml>")
+    sys.exit(0)
 
 
 def validate_tag(elem,tag):
-  if (elem.tag != tag):
-    print("Tag mismatch, expected '"+tag+"', got "+elem.tag);
-    sys.exit(255)
+    if (elem.tag != tag):
+        print("Tag mismatch, expected '"+tag+"', got "+elem.tag);
+        sys.exit(255)
 
 def make_html_bottom(body):
- #make_html_top(body,True)
- ET.SubElement(body,"hr")
- copyright = ET.SubElement(body,"span")
- copyright.text = "Copyright 2008-2010 Codenix SRL"
+    #make_html_top(body,True)
+    ET.SubElement(body,"hr")
+    copyright = ET.SubElement(body,"span")
+    copyright.text = "Copyright 2008-2010 Codenix SRL"
 
 def make_html_top(body,bottom=False):
 
- if (bottom):
-  ET.SubElement(body,"hr")
-
- table = ET.SubElement(body,"table")
- table.attrib["class"]="top_table"
- tr = ET.SubElement(table,"tr")
- td = ET.SubElement(tr,"td")
- td.attrib["class"]="top_table"
-
- img = ET.SubElement(td,"image")
- img.attrib["src"]="images/logo.png"
- td = ET.SubElement(tr,"td")
- td.attrib["class"]="top_table"
- a = ET.SubElement(td,"a")
- a.attrib["href"]="index.html"
- a.text="Index"
- td = ET.SubElement(tr,"td")
- td.attrib["class"]="top_table"
- a = ET.SubElement(td,"a")
- a.attrib["href"]="alphabetical.html"
- a.text="Classes"
- td = ET.SubElement(tr,"td")
- td.attrib["class"]="top_table"
- a = ET.SubElement(td,"a")
- a.attrib["href"]="category.html"
- a.text="Categories"
- td = ET.SubElement(tr,"td")
- a = ET.SubElement(td,"a")
- a.attrib["href"]="inheritance.html"
- a.text="Inheritance"
- if (not bottom):
-  ET.SubElement(body,"hr")
+    if (bottom):
+        ET.SubElement(body,"hr")
+
+    table = ET.SubElement(body,"table")
+    table.attrib["class"]="top_table"
+    tr = ET.SubElement(table,"tr")
+    td = ET.SubElement(tr,"td")
+    td.attrib["class"]="top_table"
+
+    img = ET.SubElement(td,"image")
+    img.attrib["src"]="images/logo.png"
+    td = ET.SubElement(tr,"td")
+    td.attrib["class"]="top_table"
+    a = ET.SubElement(td,"a")
+    a.attrib["href"]="index.html"
+    a.text="Index"
+    td = ET.SubElement(tr,"td")
+    td.attrib["class"]="top_table"
+    a = ET.SubElement(td,"a")
+    a.attrib["href"]="alphabetical.html"
+    a.text="Classes"
+    td = ET.SubElement(tr,"td")
+    td.attrib["class"]="top_table"
+    a = ET.SubElement(td,"a")
+    a.attrib["href"]="category.html"
+    a.text="Categories"
+    td = ET.SubElement(tr,"td")
+    a = ET.SubElement(td,"a")
+    a.attrib["href"]="inheritance.html"
+    a.text="Inheritance"
+    if (not bottom):
+        ET.SubElement(body,"hr")
 
 
 
 
 def make_html_class_list(class_list,columns):
 
-  div=ET.Element("div")
-  div.attrib["class"]="ClassList";
-
-  h1=ET.SubElement(div,"h2")
-  h1.text="Alphabetical Class List"
-
-  table=ET.SubElement(div,"table")
-  table.attrib["class"]="class_table"
-  table.attrib["width"]="100%"
-  prev=0
-
-  col_max = len(class_list) / columns + 1
-  print("col max is ", col_max)
-  col_count = 0
-  row_count = 0
-  last_initial = ""
-  fit_columns=[]
-
-  for n in range(0,columns):
-   fit_columns+=[[]]
-
-  indexers=[]
-  last_initial=""
-
-  idx=0
-  for n in class_list:
-   col = int(idx/col_max)
-   if (col>=columns):
-    col=columns-1
-   fit_columns[col]+=[n]
-   idx+=1
-   if (n[:1]!=last_initial):
-    indexers+=[n]
-    last_initial=n[:1]
-
-  row_max=0
-
-  for n in range(0,columns):
-   if (len(fit_columns[n])>row_max):
-    row_max=len(fit_columns[n])
-
-
-  for r in range(0,row_max):
-   tr = ET.SubElement(table,"tr")
-   for c in range(0,columns):
-    tdi = ET.SubElement(tr,"td")
-    tdi.attrib["align"]="right"
-    td = ET.SubElement(tr,"td")
-    if (r>=len(fit_columns[c])):
-     continue
+    div=ET.Element("div")
+    div.attrib["class"]="ClassList";
+
+    h1=ET.SubElement(div,"h2")
+    h1.text="Alphabetical Class List"
+
+    table=ET.SubElement(div,"table")
+    table.attrib["class"]="class_table"
+    table.attrib["width"]="100%"
+    prev=0
+
+    col_max = len(class_list) / columns + 1
+    print("col max is ", col_max)
+    col_count = 0
+    row_count = 0
+    last_initial = ""
+    fit_columns=[]
+
+    for n in range(0,columns):
+        fit_columns+=[[]]
+
+    indexers=[]
+    last_initial=""
+
+    idx=0
+    for n in class_list:
+        col = int(idx/col_max)
+        if (col>=columns):
+            col=columns-1
+        fit_columns[col]+=[n]
+        idx+=1
+        if (n[:1]!=last_initial):
+            indexers+=[n]
+            last_initial=n[:1]
+
+    row_max=0
+
+    for n in range(0,columns):
+        if (len(fit_columns[n])>row_max):
+            row_max=len(fit_columns[n])
+
+
+    for r in range(0,row_max):
+        tr = ET.SubElement(table,"tr")
+        for c in range(0,columns):
+            tdi = ET.SubElement(tr,"td")
+            tdi.attrib["align"]="right"
+            td = ET.SubElement(tr,"td")
+            if (r>=len(fit_columns[c])):
+                continue
+
+            classname = fit_columns[c][r]
+            print(classname)
+            if (classname in indexers):
+
+                span = ET.SubElement(tdi, "span")
+                span.attrib["class"] = "class_index_letter"
+                span.text = classname[:1].upper()
+
+            if (single_page):
+                link="#"+classname
+            else:
+                link=classname+".html"
+
+            a=ET.SubElement(td,"a")
+            a.attrib["href"]=link
+            a.text=classname
+
+
+    if (not single_page):
+        cat_class_list=ET.Element("html")
+        csscc = ET.SubElement(cat_class_list, "link")
+        csscc.attrib["href"] = "main.css"
+        csscc.attrib["rel"] = "stylesheet"
+        csscc.attrib["type"] = "text/css"
+        bodycc = ET.SubElement(cat_class_list, "body")
+        make_html_top(bodycc)
+
+        cat_class_parent=bodycc
+    else:
+        cat_class_parent=div
+
+
+
+
+    h1=ET.SubElement(cat_class_parent,"h2")
+    h1.text="Class List By Category"
+
+    class_cat_table={}
+    class_cat_list=[]
+
+    for c in class_list:
+        clss = classes[c]
+        if ("category" in clss.attrib):
+            class_cat=clss.attrib["category"]
+        else:
+            class_cat="Core"
+        if (class_cat.find("/")!=-1):
+            class_cat=class_cat[class_cat.rfind("/")+1:]
+        if (not class_cat in class_cat_list):
+            class_cat_list.append(class_cat)
+            class_cat_table[class_cat]=[]
+        class_cat_table[class_cat].append(c)
+
+    class_cat_list.sort()
+
+    ct = ET.SubElement(cat_class_parent,"table")
+    for cl in class_cat_list:
+        l = class_cat_table[cl]
+        l.sort()
+        tr = ET.SubElement(ct,"tr")
+        tr.attrib["class"]="category_title"
+        td = ET.SubElement(ct,"td")
+        td.attrib["class"]="category_title"
+
+        a = ET.SubElement(td,"a")
+        a.attrib["class"]="category_title"
+        a.text=cl
+        a.attrib["name"]="CATEGORY_"+cl
+
+        td = ET.SubElement(ct,"td")
+        td.attrib["class"]="category_title"
+
+        for clt in l:
+            tr = ET.SubElement(ct,"tr")
+            td = ET.SubElement(ct,"td")
+            make_type(clt,td)
+            clss=classes[clt]
+            bd = clss.find("brief_description")
+            bdtext=""
+            if (bd!=None):
+                bdtext=bd.text
+            td = ET.SubElement(ct,"td")
+            td.text=bdtext
+
+    if (not single_page):
+        make_html_bottom(bodycc)
+        catet_out = ET.ElementTree(cat_class_list)
+        catet_out.write("category.html")
+
+
+    if (not single_page):
+        inh_class_list=ET.Element("html")
+        cssic = ET.SubElement(inh_class_list, "link")
+        cssic.attrib["href"] = "main.css"
+        cssic.attrib["rel"] = "stylesheet"
+        cssic.attrib["type"] = "text/css"
+        bodyic = ET.SubElement(inh_class_list, "body")
+        make_html_top(bodyic)
+        inh_class_parent=bodyic
+    else:
+        inh_class_parent=div
 
-    classname = fit_columns[c][r]
-    print(classname)
-    if (classname in indexers):
 
-     span = ET.SubElement(tdi, "span")
-     span.attrib["class"] = "class_index_letter"
-     span.text = classname[:1].upper()
 
-    if (single_page):
-      link="#"+classname
-    else:
-      link=classname+".html"
 
-    a=ET.SubElement(td,"a")
-    a.attrib["href"]=link
-    a.text=classname
+    h1=ET.SubElement(inh_class_parent,"h2")
+    h1.text="Class List By Inheritance"
 
+    itemlist = ET.SubElement(inh_class_parent,"list")
 
-  if (not single_page):
-   cat_class_list=ET.Element("html")
-   csscc = ET.SubElement(cat_class_list, "link")
-   csscc.attrib["href"] = "main.css"
-   csscc.attrib["rel"] = "stylesheet"
-   csscc.attrib["type"] = "text/css"
-   bodycc = ET.SubElement(cat_class_list, "body")
-   make_html_top(bodycc)
-
-   cat_class_parent=bodycc
-  else:
-   cat_class_parent=div
-
-
-
-
-  h1=ET.SubElement(cat_class_parent,"h2")
-  h1.text="Class List By Category"
-
-  class_cat_table={}
-  class_cat_list=[]
-
-  for c in class_list:
-   clss = classes[c]
-   if ("category" in clss.attrib):
-    class_cat=clss.attrib["category"]
-   else:
-    class_cat="Core"
-   if (class_cat.find("/")!=-1):
-    class_cat=class_cat[class_cat.rfind("/")+1:]
-   if (not class_cat in class_cat_list):
-    class_cat_list.append(class_cat)
-    class_cat_table[class_cat]=[]
-   class_cat_table[class_cat].append(c)
-
-  class_cat_list.sort()
-
-  ct = ET.SubElement(cat_class_parent,"table")
-  for cl in class_cat_list:
-   l = class_cat_table[cl]
-   l.sort()
-   tr = ET.SubElement(ct,"tr")
-   tr.attrib["class"]="category_title"
-   td = ET.SubElement(ct,"td")
-   td.attrib["class"]="category_title"
-
-   a = ET.SubElement(td,"a")
-   a.attrib["class"]="category_title"
-   a.text=cl
-   a.attrib["name"]="CATEGORY_"+cl
-
-   td = ET.SubElement(ct,"td")
-   td.attrib["class"]="category_title"
-
-   for clt in l:
-    tr = ET.SubElement(ct,"tr")
-    td = ET.SubElement(ct,"td")
-    make_type(clt,td)
-    clss=classes[clt]
-    bd = clss.find("brief_description")
-    bdtext=""
-    if (bd!=None):
-     bdtext=bd.text
-    td = ET.SubElement(ct,"td")
-    td.text=bdtext
-
-  if (not single_page):
-   make_html_bottom(bodycc)
-   catet_out = ET.ElementTree(cat_class_list)
-   catet_out.write("category.html")
-
-
-  if (not single_page):
-   inh_class_list=ET.Element("html")
-   cssic = ET.SubElement(inh_class_list, "link")
-   cssic.attrib["href"] = "main.css"
-   cssic.attrib["rel"] = "stylesheet"
-   cssic.attrib["type"] = "text/css"
-   bodyic = ET.SubElement(inh_class_list, "body")
-   make_html_top(bodyic)
-   inh_class_parent=bodyic
-  else:
-   inh_class_parent=div
-
-
-
-
-  h1=ET.SubElement(inh_class_parent,"h2")
-  h1.text="Class List By Inheritance"
-
-  itemlist = ET.SubElement(inh_class_parent,"list")
-
-  class_inh_table={}
-
-  def add_class(clss):
-   if (clss.attrib["name"] in class_inh_table):
-    return #already added
-   parent_list=None
-
-   if ("inherits" in clss.attrib):
-    inhc = clss.attrib["inherits"]
-    if (not (inhc in class_inh_table)):
-     add_class(classes[inhc])
-
-    parent_list = class_inh_table[inhc].find("div")
-    if (parent_list == None):
-     parent_div = ET.SubElement(class_inh_table[inhc],"div")
-     parent_list = ET.SubElement(parent_div,"list")
-     parent_div.attrib["class"]="inh_class_list"
-    else:
-     parent_list = parent_list.find("list")
+    class_inh_table={}
+
+    def add_class(clss):
+        if (clss.attrib["name"] in class_inh_table):
+            return #already added
+        parent_list=None
+
+        if ("inherits" in clss.attrib):
+            inhc = clss.attrib["inherits"]
+            if (not (inhc in class_inh_table)):
+                add_class(classes[inhc])
+
+            parent_list = class_inh_table[inhc].find("div")
+            if (parent_list == None):
+                parent_div = ET.SubElement(class_inh_table[inhc],"div")
+                parent_list = ET.SubElement(parent_div,"list")
+                parent_div.attrib["class"]="inh_class_list"
+            else:
+                parent_list = parent_list.find("list")
 
 
-   else:
-    parent_list=itemlist
+        else:
+            parent_list=itemlist
 
-   item = ET.SubElement(parent_list,"li")
+        item = ET.SubElement(parent_list,"li")
 #   item.attrib["class"]="inh_class_list"
-   class_inh_table[clss.attrib["name"]]=item
-   make_type(clss.attrib["name"],item)
+        class_inh_table[clss.attrib["name"]]=item
+        make_type(clss.attrib["name"],item)
 
 
-  for c in class_list:
-   add_class(classes[c])
+    for c in class_list:
+        add_class(classes[c])
 
-  if (not single_page):
-   make_html_bottom(bodyic)
-   catet_out = ET.ElementTree(inh_class_list)
-   catet_out.write("inheritance.html")
+    if (not single_page):
+        make_html_bottom(bodyic)
+        catet_out = ET.ElementTree(inh_class_list)
+        catet_out.write("inheritance.html")
 
 
 
 
 
-  #h1=ET.SubElement(div,"h2")
-  #h1.text="Class List By Inheritance"
+    #h1=ET.SubElement(div,"h2")
+    #h1.text="Class List By Inheritance"
 
-  return div
+    return div
 
 
 def make_type(p_type,p_parent):
- if (p_type=="RefPtr"):
-  p_type="Resource"
-
- if (p_type in class_names):
-  a=ET.SubElement(p_parent,"a")
-  a.attrib["class"]="datatype_existing"
-  a.text=p_type+" "
-  if (single_page):
-   a.attrib["href"]="#"+p_type
-  else:
-   a.attrib["href"]=p_type+".html"
- else:
-  span=ET.SubElement(p_parent,"span")
-  span.attrib["class"]="datatype"
-  span.text=p_type+" "
+    if (p_type=="RefPtr"):
+        p_type="Resource"
+
+    if (p_type in class_names):
+        a=ET.SubElement(p_parent,"a")
+        a.attrib["class"]="datatype_existing"
+        a.text=p_type+" "
+        if (single_page):
+            a.attrib["href"]="#"+p_type
+        else:
+            a.attrib["href"]=p_type+".html"
+    else:
+        span=ET.SubElement(p_parent,"span")
+        span.attrib["class"]="datatype"
+        span.text=p_type+" "
 
 
 
 def make_text_def(class_name,parent,text):
- text = html_escape(text)
- pos=0
- while(True):
-  pos = text.find("[",pos)
-  if (pos==-1):
-   break
-
-  endq_pos=text.find("]",pos+1)
-  if (endq_pos==-1):
-   break
-
-  pre_text=text[:pos]
-  post_text=text[endq_pos+1:]
-  tag_text=text[pos+1:endq_pos]
-
-  if (tag_text in class_names):
-   if (single_page):
-    tag_text='<a href="#'+tag_text+'">'+tag_text+'</a>'
-   else:
-    tag_text='<a href="'+tag_text+'.html">'+tag_text+'</a>'
-  else: #command
-   cmd=tag_text
-   space_pos=tag_text.find(" ")
-   if (cmd.find("html")==0):
-    cmd=tag_text[:space_pos]
-    param=tag_text[space_pos+1:]
-    tag_text="<"+param+">"
-   elif(cmd.find("method")==0):
-    cmd=tag_text[:space_pos]
-    param=tag_text[space_pos+1:]
-
-    if (not single_page and param.find(".")!=-1):
-     class_param,method_param=param.split(".")
-     tag_text=tag_text='<a href="'+class_param+'.html#'+class_param+"_"+method_param+'">'+class_param+'.'+method_param+'()</a>'
-    else:
-     tag_text=tag_text='<a href="#'+class_name+"_"+param+'">'+class_name+'.'+param+'()</a>'
-   elif (cmd.find("image=")==0):
-    print("found image: "+cmd)
-    tag_text="<img src="+cmd[6:]+"/>"
-   elif (cmd.find("url=")==0):
-    tag_text="<a href="+cmd[4:]+">"
-   elif (cmd=="/url"):
-    tag_text="</a>"
-   elif (cmd=="center"):
-    tag_text="<div align=\"center\">"
-   elif (cmd=="/center"):
-    tag_text="</div>"
-   elif (cmd=="br"):
-    tag_text="<br/>"
-   elif (cmd=="i" or cmd=="/i" or cmd=="b" or cmd=="/b" or cmd=="u" or cmd=="/u"):
-    tag_text="<"+tag_text+">" #html direct mapping
-   else:
-    tag_text="["+tag_text+"]"
+    text = html_escape(text)
+    pos=0
+    while(True):
+        pos = text.find("[",pos)
+        if (pos==-1):
+            break
+
+        endq_pos=text.find("]",pos+1)
+        if (endq_pos==-1):
+            break
+
+        pre_text=text[:pos]
+        post_text=text[endq_pos+1:]
+        tag_text=text[pos+1:endq_pos]
+
+        if (tag_text in class_names):
+            if (single_page):
+                tag_text='<a href="#'+tag_text+'">'+tag_text+'</a>'
+            else:
+                tag_text='<a href="'+tag_text+'.html">'+tag_text+'</a>'
+        else: #command
+            cmd=tag_text
+            space_pos=tag_text.find(" ")
+            if (cmd.find("html")==0):
+                cmd=tag_text[:space_pos]
+                param=tag_text[space_pos+1:]
+                tag_text="<"+param+">"
+            elif(cmd.find("method")==0):
+                cmd=tag_text[:space_pos]
+                param=tag_text[space_pos+1:]
+
+                if (not single_page and param.find(".")!=-1):
+                    class_param,method_param=param.split(".")
+                    tag_text=tag_text='<a href="'+class_param+'.html#'+class_param+"_"+method_param+'">'+class_param+'.'+method_param+'()</a>'
+                else:
+                    tag_text=tag_text='<a href="#'+class_name+"_"+param+'">'+class_name+'.'+param+'()</a>'
+            elif (cmd.find("image=")==0):
+                print("found image: "+cmd)
+                tag_text="<img src="+cmd[6:]+"/>"
+            elif (cmd.find("url=")==0):
+                tag_text="<a href="+cmd[4:]+">"
+            elif (cmd=="/url"):
+                tag_text="</a>"
+            elif (cmd=="center"):
+                tag_text="<div align=\"center\">"
+            elif (cmd=="/center"):
+                tag_text="</div>"
+            elif (cmd=="br"):
+                tag_text="<br/>"
+            elif (cmd=="i" or cmd=="/i" or cmd=="b" or cmd=="/b" or cmd=="u" or cmd=="/u"):
+                tag_text="<"+tag_text+">" #html direct mapping
+            else:
+                tag_text="["+tag_text+"]"
+
+
+        text=pre_text+tag_text+post_text
+        pos=len(pre_text)+len(tag_text)
+
+    #tnode = ET.SubElement(parent,"div")
+    #tnode.text=text
+    text="<div class=\"description\">"+text+"</div>"
+    try:
+        tnode=ET.XML(text)
+        parent.append(tnode)
+    except:
+        print("Error parsing description text: '"+text+"'")
+        sys.exit(255)
+
+
+    return tnode
+
 
 
-  text=pre_text+tag_text+post_text
-  pos=len(pre_text)+len(tag_text)
 
- #tnode = ET.SubElement(parent,"div")
- #tnode.text=text
- text="<div class=\"description\">"+text+"</div>"
- try:
-  tnode=ET.XML(text)
-  parent.append(tnode)
- except:
-  print("Error parsing description text: '"+text+"'")
-  sys.exit(255)
+def make_method_def(name,m,declare,event=False):
 
+    mdata={}
 
- return tnode
 
+    if (not declare):
+        div=ET.Element("tr")
+        div.attrib["class"]="method"
+        ret_parent=ET.SubElement(div,"td")
+        ret_parent.attrib["align"]="right"
+        func_parent=ET.SubElement(div,"td")
+    else:
+        div=ET.Element("div")
+        div.attrib["class"]="method"
+        ret_parent=div
+        func_parent=div
+
+    mdata["argidx"]=[]
+    mdata["name"]=m.attrib["name"]
+    qualifiers=""
+    if ("qualifiers" in m.attrib):
+        qualifiers=m.attrib["qualifiers"]
+
+    args=list(m)
+    for a in args:
+        if (a.tag=="return"):
+            idx=-1
+        elif (a.tag=="argument"):
+            idx=int(a.attrib["index"])
+        else:
+            continue
+
+        mdata["argidx"].append(idx)
+        mdata[idx]=a
+
+    if (not event):
+        if (-1 in mdata["argidx"]):
+            make_type(mdata[-1].attrib["type"],ret_parent)
+            mdata["argidx"].remove(-1)
+        else:
+            make_type("void",ret_parent)
+
+    span=ET.SubElement(func_parent,"span")
+    if (declare):
+        span.attrib["class"]="funcdecl"
+        a=ET.SubElement(span,"a")
+        a.attrib["name"]=name+"_"+m.attrib["name"]
+        a.text=name+"::"+m.attrib["name"]
+    else:
+        span.attrib["class"]="identifier funcdef"
+        a=ET.SubElement(span,"a")
+        a.attrib["href"]="#"+name+"_"+m.attrib["name"]
+        a.text=m.attrib["name"]
 
+    span=ET.SubElement(func_parent,"span")
+    span.attrib["class"]="symbol"
+    span.text=" ("
 
+    for a in mdata["argidx"]:
+        arg=mdata[a]
+        if (a>0):
+            span=ET.SubElement(func_parent,"span")
+            span.text=", "
+        else:
+            span=ET.SubElement(func_parent,"span")
+            span.text=" "
 
-def make_method_def(name,m,declare,event=False):
 
- mdata={}
-
-
- if (not declare):
-  div=ET.Element("tr")
-  div.attrib["class"]="method"
-  ret_parent=ET.SubElement(div,"td")
-  ret_parent.attrib["align"]="right"
-  func_parent=ET.SubElement(div,"td")
- else:
-  div=ET.Element("div")
-  div.attrib["class"]="method"
-  ret_parent=div
-  func_parent=div
-
- mdata["argidx"]=[]
- mdata["name"]=m.attrib["name"]
- qualifiers=""
- if ("qualifiers" in m.attrib):
-  qualifiers=m.attrib["qualifiers"]
-
- args=list(m)
- for a in args:
-  if (a.tag=="return"):
-   idx=-1
-  elif (a.tag=="argument"):
-   idx=int(a.attrib["index"])
-  else:
-   continue
-
-  mdata["argidx"].append(idx)
-  mdata[idx]=a
-
- if (not event):
-  if (-1 in mdata["argidx"]):
-   make_type(mdata[-1].attrib["type"],ret_parent)
-   mdata["argidx"].remove(-1)
-  else:
-   make_type("void",ret_parent)
-
- span=ET.SubElement(func_parent,"span")
- if (declare):
-  span.attrib["class"]="funcdecl"
-  a=ET.SubElement(span,"a")
-  a.attrib["name"]=name+"_"+m.attrib["name"]
-  a.text=name+"::"+m.attrib["name"]
- else:
-  span.attrib["class"]="identifier funcdef"
-  a=ET.SubElement(span,"a")
-  a.attrib["href"]="#"+name+"_"+m.attrib["name"]
-  a.text=m.attrib["name"]
-
- span=ET.SubElement(func_parent,"span")
- span.attrib["class"]="symbol"
- span.text=" ("
-
- for a in mdata["argidx"]:
-  arg=mdata[a]
-  if (a>0):
-   span=ET.SubElement(func_parent,"span")
-   span.text=", "
-  else:
-   span=ET.SubElement(func_parent,"span")
-   span.text=" "
-
-
-  make_type(arg.attrib["type"],func_parent)
-
-  span=ET.SubElement(func_parent,"span")
-  span.text=arg.attrib["name"]
-  if ("default" in arg.attrib):
-   span.text=span.text+"="+arg.attrib["default"]
-
-
- span=ET.SubElement(func_parent,"span")
- span.attrib["class"]="symbol"
- if (len(mdata["argidx"])):
-  span.text=" )"
- else:
-  span.text=")"
-
- if (qualifiers):
-  span=ET.SubElement(func_parent,"span")
-  span.attrib["class"]="qualifier"
-  span.text=" "+qualifiers
-
- return div
+        make_type(arg.attrib["type"],func_parent)
+
+        span=ET.SubElement(func_parent,"span")
+        span.text=arg.attrib["name"]
+        if ("default" in arg.attrib):
+            span.text=span.text+"="+arg.attrib["default"]
+
+
+    span=ET.SubElement(func_parent,"span")
+    span.attrib["class"]="symbol"
+    if (len(mdata["argidx"])):
+        span.text=" )"
+    else:
+        span.text=")"
+
+    if (qualifiers):
+        span=ET.SubElement(func_parent,"span")
+        span.attrib["class"]="qualifier"
+        span.text=" "+qualifiers
+
+    return div
 
 
 def make_html_class(node):
 
-  div=ET.Element("div")
-  div.attrib["class"]="class";
+    div=ET.Element("div")
+    div.attrib["class"]="class";
 
-  a=ET.SubElement(div,"a")
-  a.attrib["name"]=node.attrib["name"]
+    a=ET.SubElement(div,"a")
+    a.attrib["name"]=node.attrib["name"]
 
-  h3=ET.SubElement(a,"h3")
-  h3.attrib["class"]="title class_title"
-  h3.text=node.attrib["name"]
+    h3=ET.SubElement(a,"h3")
+    h3.attrib["class"]="title class_title"
+    h3.text=node.attrib["name"]
 
-  briefd = node.find("brief_description")
-  if (briefd!=None):
-   div2=ET.SubElement(div,"div")
-   div2.attrib["class"]="description class_description"
-   div2.text=briefd.text
+    briefd = node.find("brief_description")
+    if (briefd!=None):
+        div2=ET.SubElement(div,"div")
+        div2.attrib["class"]="description class_description"
+        div2.text=briefd.text
 
-  if ("inherits" in node.attrib):
-   ET.SubElement(div,"br")
+    if ("inherits" in node.attrib):
+        ET.SubElement(div,"br")
 
-   div2=ET.SubElement(div,"div")
-   div2.attrib["class"]="inheritance";
+        div2=ET.SubElement(div,"div")
+        div2.attrib["class"]="inheritance";
 
-   span=ET.SubElement(div2,"span")
-   span.text="Inherits: "
+        span=ET.SubElement(div2,"span")
+        span.text="Inherits: "
 
-   make_type(node.attrib["inherits"],div2)
+        make_type(node.attrib["inherits"],div2)
 
-  if ("category" in node.attrib):
-   ET.SubElement(div,"br")
+    if ("category" in node.attrib):
+        ET.SubElement(div,"br")
 
-   div3=ET.SubElement(div,"div")
-   div3.attrib["class"]="category";
+        div3=ET.SubElement(div,"div")
+        div3.attrib["class"]="category";
 
-   span=ET.SubElement(div3,"span")
-   span.attrib["class"]="category"
-   span.text="Category: "
+        span=ET.SubElement(div3,"span")
+        span.attrib["class"]="category"
+        span.text="Category: "
 
-   a = ET.SubElement(div3,"a")
-   a.attrib["class"]="category_ref"
-   a.text=node.attrib["category"]
-   catname=a.text
-   if (catname.rfind("/")!=-1):
-    catname=catname[catname.rfind("/"):]
-   catname="CATEGORY_"+catname
+        a = ET.SubElement(div3,"a")
+        a.attrib["class"]="category_ref"
+        a.text=node.attrib["category"]
+        catname=a.text
+        if (catname.rfind("/")!=-1):
+            catname=catname[catname.rfind("/"):]
+        catname="CATEGORY_"+catname
 
-   if (single_page):
-    a.attrib["href"]="#"+catname
-   else:
-    a.attrib["href"]="category.html#"+catname
+        if (single_page):
+            a.attrib["href"]="#"+catname
+        else:
+            a.attrib["href"]="category.html#"+catname
 
 
-  methods = node.find("methods")
+    methods = node.find("methods")
 
-  if(methods!=None and len(list(methods))>0):
+    if(methods!=None and len(list(methods))>0):
 
-   h4=ET.SubElement(div,"h4")
-   h4.text="Public Methods:"
+        h4=ET.SubElement(div,"h4")
+        h4.text="Public Methods:"
 
-   method_table=ET.SubElement(div,"table")
-   method_table.attrib["class"]="method_list";
+        method_table=ET.SubElement(div,"table")
+        method_table.attrib["class"]="method_list";
 
-   for m in list(methods):
-#    li = ET.SubElement(div2, "li")
-    method_table.append( make_method_def(node.attrib["name"],m,False) )
+        for m in list(methods):
+            #li = ET.SubElement(div2, "li")
+            method_table.append( make_method_def(node.attrib["name"],m,False) )
 
-  events = node.find("signals")
+    events = node.find("signals")
 
-  if(events!=None and len(list(events))>0):
-   h4=ET.SubElement(div,"h4")
-   h4.text="Events:"
+    if(events!=None and len(list(events))>0):
+        h4=ET.SubElement(div,"h4")
+        h4.text="Events:"
 
-   event_table=ET.SubElement(div,"table")
-   event_table.attrib["class"]="method_list";
+        event_table=ET.SubElement(div,"table")
+        event_table.attrib["class"]="method_list";
 
-   for m in list(events):
-#    li = ET.SubElement(div2, "li")
-    event_table.append( make_method_def(node.attrib["name"],m,False,True) )
+        for m in list(events):
+            #li = ET.SubElement(div2, "li")
+            event_table.append( make_method_def(node.attrib["name"],m,False,True) )
 
 
-  members = node.find("members")
-  if(members!=None and len(list(members))>0):
+    members = node.find("members")
+    if(members!=None and len(list(members))>0):
 
-   h4=ET.SubElement(div,"h4")
-   h4.text="Public Variables:"
-   div2=ET.SubElement(div,"div")
-   div2.attrib["class"]="member_list";
+        h4=ET.SubElement(div,"h4")
+        h4.text="Public Variables:"
+        div2=ET.SubElement(div,"div")
+        div2.attrib["class"]="member_list";
 
-   for c in list(members):
+        for c in list(members):
 
-    li = ET.SubElement(div2, "li")
-    div3=ET.SubElement(li,"div")
-    div3.attrib["class"]="member";
-    make_type(c.attrib["type"],div3)
-    span=ET.SubElement(div3,"span")
-    span.attrib["class"]="identifier member_name"
-    span.text=" "+c.attrib["name"]+" "
-    span=ET.SubElement(div3,"span")
-    span.attrib["class"]="member_description"
-    span.text=c.text
+            li = ET.SubElement(div2, "li")
+            div3=ET.SubElement(li,"div")
+            div3.attrib["class"]="member";
+            make_type(c.attrib["type"],div3)
+            span=ET.SubElement(div3,"span")
+            span.attrib["class"]="identifier member_name"
+            span.text=" "+c.attrib["name"]+" "
+            span=ET.SubElement(div3,"span")
+            span.attrib["class"]="member_description"
+            span.text=c.text
 
 
-  constants = node.find("constants")
-  if(constants!=None and len(list(constants))>0):
+    constants = node.find("constants")
+    if(constants!=None and len(list(constants))>0):
 
-   h4=ET.SubElement(div,"h4")
-   h4.text="Constants:"
-   div2=ET.SubElement(div,"div")
-   div2.attrib["class"]="constant_list";
+        h4=ET.SubElement(div,"h4")
+        h4.text="Constants:"
+        div2=ET.SubElement(div,"div")
+        div2.attrib["class"]="constant_list";
 
-   for c in list(constants):
-    li = ET.SubElement(div2, "li")
-    div3=ET.SubElement(li,"div")
-    div3.attrib["class"]="constant";
+        for c in list(constants):
+            li = ET.SubElement(div2, "li")
+            div3=ET.SubElement(li,"div")
+            div3.attrib["class"]="constant";
 
-    span=ET.SubElement(div3,"span")
-    span.attrib["class"]="identifier constant_name"
-    span.text=c.attrib["name"]+" "
-    if ("value" in c.attrib):
-     span=ET.SubElement(div3,"span")
-     span.attrib["class"]="symbol"
-     span.text="= "
-     span=ET.SubElement(div3,"span")
-     span.attrib["class"]="constant_value"
-     span.text=c.attrib["value"]+" "
-    span=ET.SubElement(div3,"span")
-    span.attrib["class"]="constant_description"
-    span.text=c.text
+            span=ET.SubElement(div3,"span")
+            span.attrib["class"]="identifier constant_name"
+            span.text=c.attrib["name"]+" "
+            if ("value" in c.attrib):
+                span=ET.SubElement(div3,"span")
+                span.attrib["class"]="symbol"
+                span.text="= "
+                span=ET.SubElement(div3,"span")
+                span.attrib["class"]="constant_value"
+                span.text=c.attrib["value"]+" "
+            span=ET.SubElement(div3,"span")
+            span.attrib["class"]="constant_description"
+            span.text=c.text
 
 #  ET.SubElement(div,"br")
 
 
-  descr=node.find("description")
-  if (descr!=None and descr.text.strip()!=""):
-   h4=ET.SubElement(div,"h4")
-   h4.text="Description:"
+    descr=node.find("description")
+    if (descr!=None and descr.text.strip()!=""):
+        h4=ET.SubElement(div,"h4")
+        h4.text="Description:"
 
-   make_text_def(node.attrib["name"],div,descr.text)
+        make_text_def(node.attrib["name"],div,descr.text)
 #   div2=ET.SubElement(div,"div")
 #   div2.attrib["class"]="description";
 #   div2.text=descr.text
 
 
 
-  if(methods!=None or events!=None):
+    if(methods!=None or events!=None):
 
-   h4=ET.SubElement(div,"h4")
-   h4.text="Method Documentation:"
-   iter_list = []
-   if (methods!=None):
-    iter_list+=list(methods)
-   if (events!=None):
-    iter_list+=list(events)
+        h4=ET.SubElement(div,"h4")
+        h4.text="Method Documentation:"
+        iter_list = []
+        if (methods!=None):
+            iter_list+=list(methods)
+        if (events!=None):
+            iter_list+=list(events)
 
-   for m in iter_list:
+        for m in iter_list:
 
-    descr=m.find("description")
+            descr=m.find("description")
 
-    if (descr==None or descr.text.strip()==""):
-     continue;
+            if (descr==None or descr.text.strip()==""):
+                continue;
 
-    div2=ET.SubElement(div,"div")
-    div2.attrib["class"]="method_doc";
+            div2=ET.SubElement(div,"div")
+            div2.attrib["class"]="method_doc";
 
 
-    div2.append( make_method_def(node.attrib["name"],m,True) )
-	#anchor = ET.SubElement(div2, "a")
-	#anchor.attrib["name"] =
-    make_text_def(node.attrib["name"],div2,descr.text)
-    #div3=ET.SubElement(div2,"div")
-    #div3.attrib["class"]="description";
-    #div3.text=descr.text
+            div2.append( make_method_def(node.attrib["name"],m,True) )
+            #anchor = ET.SubElement(div2, "a")
+            #anchor.attrib["name"] =
+            make_text_def(node.attrib["name"],div2,descr.text)
+            #div3=ET.SubElement(div2,"div")
+            #div3.attrib["class"]="description";
+            #div3.text=descr.text
 
 
-  return div
+    return div
 
 class_names=[]
 classes={}
 
 for file in input_list:
- tree = ET.parse(file)
- doc=tree.getroot()
+    tree = ET.parse(file)
+    doc=tree.getroot()
 
- if ("version" not in doc.attrib):
-   print("Version missing from 'doc'")
-   sys.exit(255)
+    if ("version" not in doc.attrib):
+        print("Version missing from 'doc'")
+        sys.exit(255)
 
-   version=doc.attrib["version"]
+        version=doc.attrib["version"]
 
- for c in list(doc):
-   if (c.attrib["name"] in class_names):
-    continue
-   class_names.append(c.attrib["name"])
-   classes[c.attrib["name"]]=c
+    for c in list(doc):
+        if (c.attrib["name"] in class_names):
+            continue
+        class_names.append(c.attrib["name"])
+        classes[c.attrib["name"]]=c
 
 html = ET.Element("html")
 css = ET.SubElement(html, "link")
@@ -685,7 +685,7 @@ css.attrib["type"] = "text/css"
 
 body = ET.SubElement(html, "body")
 if (not single_page):
- make_html_top(body)
+    make_html_top(body)
 
 
 
@@ -694,27 +694,27 @@ class_names.sort()
 body.append( make_html_class_list(class_names,5) )
 
 for cn in class_names:
- c=classes[cn]
- if (single_page):
-  body.append( make_html_class(c))
- else:
-  html2 = ET.Element("html")
-  css = ET.SubElement(html2, "link")
-  css.attrib["href"] = "main.css"
-  css.attrib["rel"] = "stylesheet"
-  css.attrib["type"] = "text/css"
-  body2 = ET.SubElement(html2, "body" )
-  make_html_top(body2)
-  body2.append( make_html_class(c) );
-  make_html_bottom(body2)
-  et_out = ET.ElementTree(html2)
-  et_out.write(c.attrib["name"]+".html")
+    c=classes[cn]
+    if (single_page):
+        body.append( make_html_class(c))
+    else:
+        html2 = ET.Element("html")
+        css = ET.SubElement(html2, "link")
+        css.attrib["href"] = "main.css"
+        css.attrib["rel"] = "stylesheet"
+        css.attrib["type"] = "text/css"
+        body2 = ET.SubElement(html2, "body" )
+        make_html_top(body2)
+        body2.append( make_html_class(c) );
+        make_html_bottom(body2)
+        et_out = ET.ElementTree(html2)
+        et_out.write(c.attrib["name"]+".html")
 
 
 et_out = ET.ElementTree(html)
 if (single_page):
- et_out.write("singlepage.html")
+    et_out.write("singlepage.html")
 else:
- make_html_bottom(body)
- et_out.write("alphabetical.html")
+    make_html_bottom(body)
+    et_out.write("alphabetical.html")
 
diff --git a/doc/tools/makemd.py b/doc/tools/makemd.py
index e0fbe9af03..2c9d697039 100644
--- a/doc/tools/makemd.py
+++ b/doc/tools/makemd.py
@@ -7,17 +7,17 @@ import xml.etree.ElementTree as ET
 input_list = []
 
 for arg in sys.argv[1:]:
-	input_list.append(arg)
+    input_list.append(arg)
 
 if len(input_list) < 1:
-	print 'usage: makemd.py <classes.xml>'
-	sys.exit(0)
+    print 'usage: makemd.py <classes.xml>'
+    sys.exit(0)
 
 
 def validate_tag(elem, tag):
-	if elem.tag != tag:
-		print "Tag mismatch, expected '" + tag + "', got " + elem.tag
-		sys.exit(255)
+    if elem.tag != tag:
+        print "Tag mismatch, expected '" + tag + "', got " + elem.tag
+        sys.exit(255)
 
 
 class_names = []
@@ -26,321 +26,321 @@ classes = {}
 
 def make_class_list(class_list, columns):
 
-	f = open('class_list.md', 'wb')
-	prev = 0
-	col_max = len(class_list) / columns + 1
-	print ('col max is ', col_max)
-	col_count = 0
-	row_count = 0
-	last_initial = ''
-	fit_columns = []
-
-	for n in range(0, columns):
-		fit_columns += [[]]
-
-	indexers = []
-	last_initial = ''
-
-	idx = 0
-	for n in class_list:
-		col = idx / col_max
-		if col >= columns:
-			col = columns - 1
-		fit_columns[col] += [n]
-		idx += 1
-		if n[:1] != last_initial:
-			indexers += [n]
-		last_initial = n[:1]
-
-	row_max = 0
-	f.write("\n")
-
-	for n in range(0, columns):
-		if len(fit_columns[n]) > row_max:
-			row_max = len(fit_columns[n])
-
-	f.write("| ")
-	for n in range(0, columns):
-		f.write(" | |")
-
-	f.write("\n")
-	f.write("| ")
-	for n in range(0, columns):
-		f.write(" --- | ------- |")
-	f.write("\n")
-
-	for r in range(0, row_max):
-		s = '| '
-		for c in range(0, columns):
-			if r >= len(fit_columns[c]):
-				continue
-
-			classname = fit_columns[c][r]
-			initial = classname[0]
-			if classname in indexers:
-				s += '**' + initial + '** | '
-			else:
-				s += ' | '
-
-			s += '[' + classname + '](class_'+ classname.lower()+') | '
-
-		s += '\n'
-		f.write(s)
+    f = open('class_list.md', 'wb')
+    prev = 0
+    col_max = len(class_list) / columns + 1
+    print ('col max is ', col_max)
+    col_count = 0
+    row_count = 0
+    last_initial = ''
+    fit_columns = []
+
+    for n in range(0, columns):
+        fit_columns += [[]]
+
+    indexers = []
+    last_initial = ''
+
+    idx = 0
+    for n in class_list:
+        col = idx / col_max
+        if col >= columns:
+            col = columns - 1
+        fit_columns[col] += [n]
+        idx += 1
+        if n[:1] != last_initial:
+            indexers += [n]
+        last_initial = n[:1]
+
+    row_max = 0
+    f.write("\n")
+
+    for n in range(0, columns):
+        if len(fit_columns[n]) > row_max:
+            row_max = len(fit_columns[n])
+
+    f.write("| ")
+    for n in range(0, columns):
+        f.write(" | |")
+
+    f.write("\n")
+    f.write("| ")
+    for n in range(0, columns):
+        f.write(" --- | ------- |")
+    f.write("\n")
+
+    for r in range(0, row_max):
+        s = '| '
+        for c in range(0, columns):
+            if r >= len(fit_columns[c]):
+                continue
+
+            classname = fit_columns[c][r]
+            initial = classname[0]
+            if classname in indexers:
+                s += '**' + initial + '** | '
+            else:
+                s += ' | '
+
+            s += '[' + classname + '](class_'+ classname.lower()+') | '
+
+        s += '\n'
+        f.write(s)
 
 
 def dokuize_text(txt):
 
-	return txt
+    return txt
 
 
 def dokuize_text(text):
-	pos = 0
-	while True:
-		pos = text.find('[', pos)
-		if pos == -1:
-			break
-
-		endq_pos = text.find(']', pos + 1)
-		if endq_pos == -1:
-			break
-
-		pre_text = text[:pos]
-		post_text = text[endq_pos + 1:]
-		tag_text = text[pos + 1:endq_pos]
-
-		if tag_text in class_names:
-			tag_text = make_type(tag_text)
-		else:
-
-		# command
-
-			cmd = tag_text
-			space_pos = tag_text.find(' ')
-			if cmd.find('html') == 0:
-				cmd = tag_text[:space_pos]
-				param = tag_text[space_pos + 1:]
-				tag_text = '<' + param + '>'
-			elif cmd.find('method') == 0:
-				cmd = tag_text[:space_pos]
-				param = tag_text[space_pos + 1:]
-
-				if param.find('.') != -1:
-					(class_param, method_param) = param.split('.')
-					tag_text = '['+class_param+'.'+method_param.replace("_","&#95;")+'](' + class_param.lower() + '#' \
-						+ method_param + ')'
-				else:
-					tag_text = '[' + param.replace("_","&#95;") + '](#' + param + ')'
-			elif cmd.find('image=') == 0:
-				tag_text = '![](' + cmd[6:] + ')'
-			elif cmd.find('url=') == 0:
-				tag_text = '[' + cmd[4:] + ']('+cmd[4:]
-			elif cmd == '/url':
-				tag_text = ')'
-			elif cmd == 'center':
-				tag_text = ''
-			elif cmd == '/center':
-				tag_text = ''
-			elif cmd == 'br':
-				tag_text = '\n'
-			elif cmd == 'i' or cmd == '/i':
-				tag_text = '_'
-			elif cmd == 'b' or cmd == '/b':
-				tag_text = '**'
-			elif cmd == 'u' or cmd == '/u':
-				tag_text = '__'
-			else:
-				tag_text = '[' + tag_text + ']'
-
-		text = pre_text + tag_text + post_text
-		pos = len(pre_text) + len(tag_text)
+    pos = 0
+    while True:
+        pos = text.find('[', pos)
+        if pos == -1:
+            break
+
+        endq_pos = text.find(']', pos + 1)
+        if endq_pos == -1:
+            break
+
+        pre_text = text[:pos]
+        post_text = text[endq_pos + 1:]
+        tag_text = text[pos + 1:endq_pos]
+
+        if tag_text in class_names:
+            tag_text = make_type(tag_text)
+        else:
+
+            # command
+
+            cmd = tag_text
+            space_pos = tag_text.find(' ')
+            if cmd.find('html') == 0:
+                cmd = tag_text[:space_pos]
+                param = tag_text[space_pos + 1:]
+                tag_text = '<' + param + '>'
+            elif cmd.find('method') == 0:
+                cmd = tag_text[:space_pos]
+                param = tag_text[space_pos + 1:]
+
+                if param.find('.') != -1:
+                    (class_param, method_param) = param.split('.')
+                    tag_text = '['+class_param+'.'+method_param.replace("_","&#95;")+'](' + class_param.lower() + '#' \
+                        + method_param + ')'
+                else:
+                    tag_text = '[' + param.replace("_","&#95;") + '](#' + param + ')'
+            elif cmd.find('image=') == 0:
+                tag_text = '![](' + cmd[6:] + ')'
+            elif cmd.find('url=') == 0:
+                tag_text = '[' + cmd[4:] + ']('+cmd[4:]
+            elif cmd == '/url':
+                tag_text = ')'
+            elif cmd == 'center':
+                tag_text = ''
+            elif cmd == '/center':
+                tag_text = ''
+            elif cmd == 'br':
+                tag_text = '\n'
+            elif cmd == 'i' or cmd == '/i':
+                tag_text = '_'
+            elif cmd == 'b' or cmd == '/b':
+                tag_text = '**'
+            elif cmd == 'u' or cmd == '/u':
+                tag_text = '__'
+            else:
+                tag_text = '[' + tag_text + ']'
+
+        text = pre_text + tag_text + post_text
+        pos = len(pre_text) + len(tag_text)
 
  # tnode = ET.SubElement(parent,"div")
  # tnode.text=text
 
-	return text
+    return text
 
 
 def make_type(t):
-	global class_names
-	if t in class_names:
-		return '[' + t + '](class_' + t.lower() + ')'
-	return t
+    global class_names
+    if t in class_names:
+        return '[' + t + '](class_' + t.lower() + ')'
+    return t
 
 
 def make_method(
-	f,
-	name,
-	m,
-	declare,
-	event=False,
-	):
-
-	s = '  * '
-	ret_type = 'void'
-	args = list(m)
-	mdata = {}
-	mdata['argidx'] = []
-	for a in args:
-		if a.tag == 'return':
-			idx = -1
-		elif a.tag == 'argument':
-			idx = int(a.attrib['index'])
-		else:
-			continue
-
-		mdata['argidx'].append(idx)
-		mdata[idx] = a
-
-	if not event:
-		if -1 in mdata['argidx']:
-			s += make_type(mdata[-1].attrib['type'])
-		else:
-			s += 'void'
-		s += ' '
-
-	if declare:
-
-		# span.attrib["class"]="funcdecl"
-		# a=ET.SubElement(span,"a")
-		# a.attrib["name"]=name+"_"+m.attrib["name"]
-		# a.text=name+"::"+m.attrib["name"]
-
-		s += ' **'+m.attrib['name'].replace("_","&#95;")+'** '
-	else:
-		s += ' **['+ m.attrib['name'].replace("_","&#95;")+'](#' + m.attrib['name'] + ')** '
-
-	s += ' **(**'
-	argfound = False
-	for a in mdata['argidx']:
-		arg = mdata[a]
-		if a < 0:
-			continue
-		if a > 0:
-			s += ', '
-		else:
-			s += ' '
-
-		s += make_type(arg.attrib['type'])
-		if 'name' in arg.attrib:
-			s += ' ' + arg.attrib['name']
-		else:
-			s += ' arg' + str(a)
-
-		if 'default' in arg.attrib:
-			s += '=' + arg.attrib['default']
-
-		argfound = True
-
-	if argfound:
-		s += ' '
-	s += ' **)**'
-
-	if 'qualifiers' in m.attrib:
-		s += ' ' + m.attrib['qualifiers']
-
-	f.write(s + '\n')
+        f,
+        name,
+        m,
+        declare,
+        event=False,
+):
+
+    s = '  * '
+    ret_type = 'void'
+    args = list(m)
+    mdata = {}
+    mdata['argidx'] = []
+    for a in args:
+        if a.tag == 'return':
+            idx = -1
+        elif a.tag == 'argument':
+            idx = int(a.attrib['index'])
+        else:
+            continue
+
+        mdata['argidx'].append(idx)
+        mdata[idx] = a
+
+    if not event:
+        if -1 in mdata['argidx']:
+            s += make_type(mdata[-1].attrib['type'])
+        else:
+            s += 'void'
+        s += ' '
+
+    if declare:
+
+        # span.attrib["class"]="funcdecl"
+        # a=ET.SubElement(span,"a")
+        # a.attrib["name"]=name+"_"+m.attrib["name"]
+        # a.text=name+"::"+m.attrib["name"]
+
+        s += ' **'+m.attrib['name'].replace("_","&#95;")+'** '
+    else:
+        s += ' **['+ m.attrib['name'].replace("_","&#95;")+'](#' + m.attrib['name'] + ')** '
+
+    s += ' **(**'
+    argfound = False
+    for a in mdata['argidx']:
+        arg = mdata[a]
+        if a < 0:
+            continue
+        if a > 0:
+            s += ', '
+        else:
+            s += ' '
+
+        s += make_type(arg.attrib['type'])
+        if 'name' in arg.attrib:
+            s += ' ' + arg.attrib['name']
+        else:
+            s += ' arg' + str(a)
+
+        if 'default' in arg.attrib:
+            s += '=' + arg.attrib['default']
+
+        argfound = True
+
+    if argfound:
+        s += ' '
+    s += ' **)**'
+
+    if 'qualifiers' in m.attrib:
+        s += ' ' + m.attrib['qualifiers']
+
+    f.write(s + '\n')
 
 
 def make_doku_class(node):
 
-	name = node.attrib['name']
-
-	f = open("class_"+name.lower() + '.md', 'wb')
-
-	f.write('#  ' + name + '  \n')
-
-	if 'inherits' in node.attrib:
-		inh = node.attrib['inherits'].strip()
-		f.write('####**Inherits:** '+make_type(inh)+'\n')
-	if 'category' in node.attrib:
-		f.write('####**Category:** ' + node.attrib['category'].strip()
-				+ '\n')
-
-	briefd = node.find('brief_description')
-	if briefd != None:
-		f.write('\n###  Brief Description  \n')
-		f.write(dokuize_text(briefd.text.strip()) + '\n')
-
-	methods = node.find('methods')
-
-	if methods != None and len(list(methods)) > 0:
-		f.write('\n###  Member Functions \n')
-		for m in list(methods):
-			make_method(f, node.attrib['name'], m, False)
-
-	events = node.find('signals')
-	if events != None and len(list(events)) > 0:
-		f.write('\n###  Signals  \n')
-		for m in list(events):
-			make_method(f, node.attrib['name'], m, True, True)
-
-	members = node.find('members')
-
-	if members != None and len(list(members)) > 0:
-		f.write('\n###  Member Variables  \n')
-
-		for c in list(members):
-			s = '  * '
-			s += make_type(c.attrib['type']) + ' '
-			s += '**' + c.attrib['name'] + '**'
-			if c.text.strip() != '':
-				s += ' - ' + c.text.strip()
-			f.write(s + '\n')
-
-	constants = node.find('constants')
-	if constants != None and len(list(constants)) > 0:
-		f.write('\n###  Numeric Constants  \n')
-		for c in list(constants):
-			s = '  * '
-			s += '**' + c.attrib['name'] + '**'
-			if 'value' in c.attrib:
-				s += ' = **' + c.attrib['value'] + '**'
-			if c.text.strip() != '':
-				s += ' - ' + c.text.strip()
-			f.write(s + '\n')
-
-	descr = node.find('description')
-	if descr != None and descr.text.strip() != '':
-		f.write('\n###  Description  \n')
-		f.write(dokuize_text(descr.text.strip()) + '\n')
-
-	methods = node.find('methods')
-
-	if methods != None and len(list(methods)) > 0:
-		f.write('\n###  Member Function Description  \n')
-		for m in list(methods):
-
-			d = m.find('description')
-			if d == None or d.text.strip() == '':
-				continue
-			f.write('\n#### <a name="'+m.attrib['name']+'">' + m.attrib['name'] + '</a>\n')
-			make_method(f, node.attrib['name'], m, True)
-			f.write('\n')
-			f.write(dokuize_text(d.text.strip()))
-			f.write('\n')
+    name = node.attrib['name']
+
+    f = open("class_"+name.lower() + '.md', 'wb')
+
+    f.write('#  ' + name + '  \n')
+
+    if 'inherits' in node.attrib:
+        inh = node.attrib['inherits'].strip()
+        f.write('####**Inherits:** '+make_type(inh)+'\n')
+    if 'category' in node.attrib:
+        f.write('####**Category:** ' + node.attrib['category'].strip()
+                + '\n')
+
+    briefd = node.find('brief_description')
+    if briefd != None:
+        f.write('\n###  Brief Description  \n')
+        f.write(dokuize_text(briefd.text.strip()) + '\n')
+
+    methods = node.find('methods')
+
+    if methods != None and len(list(methods)) > 0:
+        f.write('\n###  Member Functions \n')
+        for m in list(methods):
+            make_method(f, node.attrib['name'], m, False)
+
+    events = node.find('signals')
+    if events != None and len(list(events)) > 0:
+        f.write('\n###  Signals  \n')
+        for m in list(events):
+            make_method(f, node.attrib['name'], m, True, True)
+
+    members = node.find('members')
+
+    if members != None and len(list(members)) > 0:
+        f.write('\n###  Member Variables  \n')
+
+        for c in list(members):
+            s = '  * '
+            s += make_type(c.attrib['type']) + ' '
+            s += '**' + c.attrib['name'] + '**'
+            if c.text.strip() != '':
+                s += ' - ' + c.text.strip()
+            f.write(s + '\n')
+
+    constants = node.find('constants')
+    if constants != None and len(list(constants)) > 0:
+        f.write('\n###  Numeric Constants  \n')
+        for c in list(constants):
+            s = '  * '
+            s += '**' + c.attrib['name'] + '**'
+            if 'value' in c.attrib:
+                s += ' = **' + c.attrib['value'] + '**'
+            if c.text.strip() != '':
+                s += ' - ' + c.text.strip()
+            f.write(s + '\n')
+
+    descr = node.find('description')
+    if descr != None and descr.text.strip() != '':
+        f.write('\n###  Description  \n')
+        f.write(dokuize_text(descr.text.strip()) + '\n')
+
+    methods = node.find('methods')
+
+    if methods != None and len(list(methods)) > 0:
+        f.write('\n###  Member Function Description  \n')
+        for m in list(methods):
+
+            d = m.find('description')
+            if d == None or d.text.strip() == '':
+                continue
+            f.write('\n#### <a name="'+m.attrib['name']+'">' + m.attrib['name'] + '</a>\n')
+            make_method(f, node.attrib['name'], m, True)
+            f.write('\n')
+            f.write(dokuize_text(d.text.strip()))
+            f.write('\n')
 
 
 for file in input_list:
-	tree = ET.parse(file)
-	doc = tree.getroot()
+    tree = ET.parse(file)
+    doc = tree.getroot()
 
-	if 'version' not in doc.attrib:
-		print "Version missing from 'doc'"
-		sys.exit(255)
+    if 'version' not in doc.attrib:
+        print "Version missing from 'doc'"
+        sys.exit(255)
 
-	version = doc.attrib['version']
+    version = doc.attrib['version']
 
-	for c in list(doc):
-		if c.attrib['name'] in class_names:
-			continue
-		class_names.append(c.attrib['name'])
-		classes[c.attrib['name']] = c
+    for c in list(doc):
+        if c.attrib['name'] in class_names:
+            continue
+        class_names.append(c.attrib['name'])
+        classes[c.attrib['name']] = c
 
 class_names.sort()
 
 make_class_list(class_names, 2)
 
 for cn in class_names:
-	c = classes[cn]
-	make_doku_class(c)
+    c = classes[cn]
+    make_doku_class(c)
 
diff --git a/doc/tools/makerst.py b/doc/tools/makerst.py
index 718cf4a275..583f9afeaa 100644
--- a/doc/tools/makerst.py
+++ b/doc/tools/makerst.py
@@ -8,505 +8,505 @@ import xml.etree.ElementTree as ET
 input_list = []
 
 for arg in sys.argv[1:]:
-	input_list.append(arg)
+    input_list.append(arg)
 
 if len(input_list) < 1:
-	print 'usage: makerst.py <classes.xml>'
-	sys.exit(0)
+    print 'usage: makerst.py <classes.xml>'
+    sys.exit(0)
 
 
 def validate_tag(elem, tag):
-	if elem.tag != tag:
-		print "Tag mismatch, expected '" + tag + "', got " + elem.tag
-		sys.exit(255)
+    if elem.tag != tag:
+        print "Tag mismatch, expected '" + tag + "', got " + elem.tag
+        sys.exit(255)
 
 
 class_names = []
 classes = {}
 
 def ul_string(str,ul):
-	str+="\n"
-	for i in range(len(str)-1):
-		str+=ul
-	str+="\n"
-	return str
+    str+="\n"
+    for i in range(len(str)-1):
+        str+=ul
+    str+="\n"
+    return str
 
 def make_class_list(class_list, columns):
 
-	f = codecs.open('class_list.rst', 'wb', 'utf-8')
-	prev = 0
-	col_max = len(class_list) / columns + 1
-	print ('col max is ', col_max)
-	col_count = 0
-	row_count = 0
-	last_initial = ''
-	fit_columns = []
-
-	for n in range(0, columns):
-		fit_columns += [[]]
-
-	indexers = []
-	last_initial = ''
-
-	idx = 0
-	for n in class_list:
-		col = idx / col_max
-		if col >= columns:
-			col = columns - 1
-		fit_columns[col] += [n]
-		idx += 1
-		if n[:1] != last_initial:
-			indexers += [n]
-		last_initial = n[:1]
-
-	row_max = 0
-	f.write("\n")
-
-	for n in range(0, columns):
-		if len(fit_columns[n]) > row_max:
-			row_max = len(fit_columns[n])
-
-	f.write("| ")
-	for n in range(0, columns):
-		f.write(" | |")
-
-	f.write("\n")
-	f.write("+")
-	for n in range(0, columns):
-		f.write("--+-------+")
-	f.write("\n")
-
-	for r in range(0, row_max):
-		s = '+ '
-		for c in range(0, columns):
-			if r >= len(fit_columns[c]):
-				continue
-
-			classname = fit_columns[c][r]
-			initial = classname[0]
-			if classname in indexers:
-				s += '**' + initial + '** | '
-			else:
-				s += ' | '
-
-			s += '[' + classname + '](class_'+ classname.lower()+') | '
-
-		s += '\n'
-		f.write(s)
-
-	for n in range(0, columns):
-		f.write("--+-------+")
-	f.write("\n")
+    f = codecs.open('class_list.rst', 'wb', 'utf-8')
+    prev = 0
+    col_max = len(class_list) / columns + 1
+    print ('col max is ', col_max)
+    col_count = 0
+    row_count = 0
+    last_initial = ''
+    fit_columns = []
+
+    for n in range(0, columns):
+        fit_columns += [[]]
+
+    indexers = []
+    last_initial = ''
+
+    idx = 0
+    for n in class_list:
+        col = idx / col_max
+        if col >= columns:
+            col = columns - 1
+        fit_columns[col] += [n]
+        idx += 1
+        if n[:1] != last_initial:
+            indexers += [n]
+        last_initial = n[:1]
+
+    row_max = 0
+    f.write("\n")
+
+    for n in range(0, columns):
+        if len(fit_columns[n]) > row_max:
+            row_max = len(fit_columns[n])
+
+    f.write("| ")
+    for n in range(0, columns):
+        f.write(" | |")
+
+    f.write("\n")
+    f.write("+")
+    for n in range(0, columns):
+        f.write("--+-------+")
+    f.write("\n")
+
+    for r in range(0, row_max):
+        s = '+ '
+        for c in range(0, columns):
+            if r >= len(fit_columns[c]):
+                continue
+
+            classname = fit_columns[c][r]
+            initial = classname[0]
+            if classname in indexers:
+                s += '**' + initial + '** | '
+            else:
+                s += ' | '
+
+            s += '[' + classname + '](class_'+ classname.lower()+') | '
+
+        s += '\n'
+        f.write(s)
+
+    for n in range(0, columns):
+        f.write("--+-------+")
+    f.write("\n")
 
 
 def rstize_text(text,cclass):
 
-	# Linebreak + tabs in the XML should become two line breaks unless in a "codeblock"
-	pos = 0
-	while True:
-		pos = text.find('\n', pos)
-		if pos == -1:
-			break
-
-		pre_text = text[:pos]
-		while text[pos+1] == '\t':
-			pos += 1
-		post_text = text[pos+1:]
-
-		# Handle codeblocks
-		if post_text.startswith("[codeblock]"):
-			end_pos = post_text.find("[/codeblock]")
-			if end_pos == -1:
-				sys.exit("ERROR! [codeblock] without a closing tag!")
-
-			code_text = post_text[len("[codeblock]"):end_pos]
-			post_text = post_text[end_pos:]
-
-			# Remove extraneous tabs
-			code_pos = 0
-			while True:
-				code_pos = code_text.find('\n', code_pos)
-				if code_pos == -1:
-					break
-
-				to_skip = 0
-				while code_pos+to_skip+1 < len(code_text) and code_text[code_pos+to_skip+1] == '\t':
-					to_skip += 1
-
-				if len(code_text[code_pos+to_skip+1:])==0:
-					code_text = code_text[:code_pos] + "\n"
-					code_pos += 1
-				else:
-					code_text = code_text[:code_pos] + "\n    " + code_text[code_pos+to_skip+1:]
-					code_pos += 5 - to_skip
-
-			text = pre_text + "\n[codeblock]" + code_text + post_text
-			pos += len("\n[codeblock]" + code_text)
-
-		# Handle normal text
-		else:
-			text = pre_text + "\n\n" + post_text
-			pos += 2
-
-	# Escape * character to avoid interpreting it as emphasis
-	pos = 0
-	while True:
-		pos = text.find('*', pos)
-		if pos == -1:
-			break
-		text = text[:pos] + "\*" + text[pos + 1:]
-		pos += 2
-
-	# Escape _ character at the end of a word to avoid interpreting it as an inline hyperlink
-	pos = 0
-	while True:
-		pos = text.find('_', pos)
-		if pos == -1:
-			break
-		if not text[pos + 1].isalnum(): # don't escape within a snake_case word
-			text = text[:pos] + "\_" + text[pos + 1:]
-			pos += 2
-		else:
-			pos += 1
-
-	# Handle [tags]
-	pos = 0
-	while True:
-		pos = text.find('[', pos)
-		if pos == -1:
-			break
-
-		endq_pos = text.find(']', pos + 1)
-		if endq_pos == -1:
-			break
-
-		pre_text = text[:pos]
-		post_text = text[endq_pos + 1:]
-		tag_text = text[pos + 1:endq_pos]
-
-		if tag_text in class_names:
-			tag_text = make_type(tag_text)
-		else: # command
-			cmd = tag_text
-			space_pos = tag_text.find(' ')
-			if cmd.find('html') == 0:
-				cmd = tag_text[:space_pos]
-				param = tag_text[space_pos + 1:]
-				tag_text = param
-			elif cmd.find('method') == 0:
-				cmd = tag_text[:space_pos]
-				param = tag_text[space_pos + 1:]
-
-				if param.find('.') != -1:
-					(class_param, method_param) = param.split('.')
-					tag_text = ':ref:`'+class_param+'.'+method_param+'<class_' + class_param + '_' + method_param + '>`'
-				else:
-					tag_text = ':ref:`' + param + '<class_' + cclass +"_"+ param + '>`'
-			elif cmd.find('image=') == 0:
-				tag_text = "" #'![](' + cmd[6:] + ')'
-			elif cmd.find('url=') == 0:
-				tag_text = ':ref:`' + cmd[4:] + '<'+cmd[4:]+">`"
-			elif cmd == '/url':
-				tag_text = ')'
-			elif cmd == 'center':
-				tag_text = ''
-			elif cmd == '/center':
-				tag_text = ''
-			elif cmd == 'codeblock':
-				tag_text = '\n::\n'
-			elif cmd == '/codeblock':
-				tag_text = ''
-				# Strip newline if the tag was alone on one
-				if pre_text[-1] == '\n':
-					pre_text = pre_text[:-1]
-			elif cmd == 'br':
-				# Make a new paragraph instead of a linebreak, rst is not so linebreak friendly
-				tag_text = '\n\n'
-				# Strip potential leading spaces
-				while post_text[0] == ' ':
-					post_text = post_text[1:]
-			elif cmd == 'i' or cmd == '/i':
-				tag_text = '*'
-			elif cmd == 'b' or cmd == '/b':
-				tag_text = '**'
-			elif cmd == 'u' or cmd == '/u':
-				tag_text = ''
-			elif cmd == 'code' or cmd == '/code':
-				tag_text = '``'
-			else:
-				tag_text = ':ref:`' + tag_text + '<class_'+tag_text.lower()+'>`'
-
-		text = pre_text + tag_text + post_text
-		pos = len(pre_text) + len(tag_text)
+    # Linebreak + tabs in the XML should become two line breaks unless in a "codeblock"
+    pos = 0
+    while True:
+        pos = text.find('\n', pos)
+        if pos == -1:
+            break
+
+        pre_text = text[:pos]
+        while text[pos+1] == '\t':
+            pos += 1
+        post_text = text[pos+1:]
+
+        # Handle codeblocks
+        if post_text.startswith("[codeblock]"):
+            end_pos = post_text.find("[/codeblock]")
+            if end_pos == -1:
+                sys.exit("ERROR! [codeblock] without a closing tag!")
+
+            code_text = post_text[len("[codeblock]"):end_pos]
+            post_text = post_text[end_pos:]
+
+            # Remove extraneous tabs
+            code_pos = 0
+            while True:
+                code_pos = code_text.find('\n', code_pos)
+                if code_pos == -1:
+                    break
+
+                to_skip = 0
+                while code_pos+to_skip+1 < len(code_text) and code_text[code_pos+to_skip+1] == '\t':
+                    to_skip += 1
+
+                if len(code_text[code_pos+to_skip+1:])==0:
+                    code_text = code_text[:code_pos] + "\n"
+                    code_pos += 1
+                else:
+                    code_text = code_text[:code_pos] + "\n    " + code_text[code_pos+to_skip+1:]
+                    code_pos += 5 - to_skip
+
+            text = pre_text + "\n[codeblock]" + code_text + post_text
+            pos += len("\n[codeblock]" + code_text)
+
+        # Handle normal text
+        else:
+            text = pre_text + "\n\n" + post_text
+            pos += 2
+
+    # Escape * character to avoid interpreting it as emphasis
+    pos = 0
+    while True:
+        pos = text.find('*', pos)
+        if pos == -1:
+            break
+        text = text[:pos] + "\*" + text[pos + 1:]
+        pos += 2
+
+    # Escape _ character at the end of a word to avoid interpreting it as an inline hyperlink
+    pos = 0
+    while True:
+        pos = text.find('_', pos)
+        if pos == -1:
+            break
+        if not text[pos + 1].isalnum(): # don't escape within a snake_case word
+            text = text[:pos] + "\_" + text[pos + 1:]
+            pos += 2
+        else:
+            pos += 1
+
+    # Handle [tags]
+    pos = 0
+    while True:
+        pos = text.find('[', pos)
+        if pos == -1:
+            break
+
+        endq_pos = text.find(']', pos + 1)
+        if endq_pos == -1:
+            break
+
+        pre_text = text[:pos]
+        post_text = text[endq_pos + 1:]
+        tag_text = text[pos + 1:endq_pos]
+
+        if tag_text in class_names:
+            tag_text = make_type(tag_text)
+        else: # command
+            cmd = tag_text
+            space_pos = tag_text.find(' ')
+            if cmd.find('html') == 0:
+                cmd = tag_text[:space_pos]
+                param = tag_text[space_pos + 1:]
+                tag_text = param
+            elif cmd.find('method') == 0:
+                cmd = tag_text[:space_pos]
+                param = tag_text[space_pos + 1:]
+
+                if param.find('.') != -1:
+                    (class_param, method_param) = param.split('.')
+                    tag_text = ':ref:`'+class_param+'.'+method_param+'<class_' + class_param + '_' + method_param + '>`'
+                else:
+                    tag_text = ':ref:`' + param + '<class_' + cclass +"_"+ param + '>`'
+            elif cmd.find('image=') == 0:
+                tag_text = "" #'![](' + cmd[6:] + ')'
+            elif cmd.find('url=') == 0:
+                tag_text = ':ref:`' + cmd[4:] + '<'+cmd[4:]+">`"
+            elif cmd == '/url':
+                tag_text = ')'
+            elif cmd == 'center':
+                tag_text = ''
+            elif cmd == '/center':
+                tag_text = ''
+            elif cmd == 'codeblock':
+                tag_text = '\n::\n'
+            elif cmd == '/codeblock':
+                tag_text = ''
+                # Strip newline if the tag was alone on one
+                if pre_text[-1] == '\n':
+                    pre_text = pre_text[:-1]
+            elif cmd == 'br':
+                # Make a new paragraph instead of a linebreak, rst is not so linebreak friendly
+                tag_text = '\n\n'
+                # Strip potential leading spaces
+                while post_text[0] == ' ':
+                    post_text = post_text[1:]
+            elif cmd == 'i' or cmd == '/i':
+                tag_text = '*'
+            elif cmd == 'b' or cmd == '/b':
+                tag_text = '**'
+            elif cmd == 'u' or cmd == '/u':
+                tag_text = ''
+            elif cmd == 'code' or cmd == '/code':
+                tag_text = '``'
+            else:
+                tag_text = ':ref:`' + tag_text + '<class_'+tag_text.lower()+'>`'
+
+        text = pre_text + tag_text + post_text
+        pos = len(pre_text) + len(tag_text)
 
  # tnode = ET.SubElement(parent,"div")
  # tnode.text=text
 
-	return text
+    return text
 
 
 def make_type(t):
-	global class_names
-	if t in class_names:
-		return ':ref:`'+t+'<class_' + t.lower()+'>`'
-	return t
+    global class_names
+    if t in class_names:
+        return ':ref:`'+t+'<class_' + t.lower()+'>`'
+    return t
 
 
 def make_method(
-	f,
-	name,
-	m,
-	declare,
-	cname,
-	event=False,
-	pp=None
-	):
-
-	if (declare or pp==None):
-		t = '- '
-	else:
-		t = ""
-
-	ret_type = 'void'
-	args = list(m)
-	mdata = {}
-	mdata['argidx'] = []
-	for a in args:
-		if a.tag == 'return':
-			idx = -1
-		elif a.tag == 'argument':
-			idx = int(a.attrib['index'])
-		else:
-			continue
-
-		mdata['argidx'].append(idx)
-		mdata[idx] = a
-
-	if not event:
-		if -1 in mdata['argidx']:
-			t += make_type(mdata[-1].attrib['type'])
-		else:
-			t += 'void'
-		t += ' '
-
-	if declare or pp==None:
-
-		# span.attrib["class"]="funcdecl"
-		# a=ET.SubElement(span,"a")
-		# a.attrib["name"]=name+"_"+m.attrib["name"]
-		# a.text=name+"::"+m.attrib["name"]
-
-		s = ' **'+m.attrib['name']+'** '
-	else:
-		s = ':ref:`'+ m.attrib['name']+'<class_' + cname+"_"+m.attrib['name'] + '>` '
-
-	s += ' **(**'
-	argfound = False
-	for a in mdata['argidx']:
-		arg = mdata[a]
-		if a < 0:
-			continue
-		if a > 0:
-			s += ', '
-		else:
-			s += ' '
-
-		s += make_type(arg.attrib['type'])
-		if 'name' in arg.attrib:
-			s += ' ' + arg.attrib['name']
-		else:
-			s += ' arg' + str(a)
-
-		if 'default' in arg.attrib:
-			s += '=' + arg.attrib['default']
-
-		argfound = True
-
-	if argfound:
-		s += ' '
-	s += ' **)**'
-
-	if 'qualifiers' in m.attrib:
-		s += ' ' + m.attrib['qualifiers']
+        f,
+        name,
+        m,
+        declare,
+        cname,
+        event=False,
+        pp=None
+):
+
+    if (declare or pp==None):
+        t = '- '
+    else:
+        t = ""
+
+    ret_type = 'void'
+    args = list(m)
+    mdata = {}
+    mdata['argidx'] = []
+    for a in args:
+        if a.tag == 'return':
+            idx = -1
+        elif a.tag == 'argument':
+            idx = int(a.attrib['index'])
+        else:
+            continue
+
+        mdata['argidx'].append(idx)
+        mdata[idx] = a
+
+    if not event:
+        if -1 in mdata['argidx']:
+            t += make_type(mdata[-1].attrib['type'])
+        else:
+            t += 'void'
+        t += ' '
+
+    if declare or pp==None:
+
+        # span.attrib["class"]="funcdecl"
+        # a=ET.SubElement(span,"a")
+        # a.attrib["name"]=name+"_"+m.attrib["name"]
+        # a.text=name+"::"+m.attrib["name"]
+
+        s = ' **'+m.attrib['name']+'** '
+    else:
+        s = ':ref:`'+ m.attrib['name']+'<class_' + cname+"_"+m.attrib['name'] + '>` '
+
+    s += ' **(**'
+    argfound = False
+    for a in mdata['argidx']:
+        arg = mdata[a]
+        if a < 0:
+            continue
+        if a > 0:
+            s += ', '
+        else:
+            s += ' '
+
+        s += make_type(arg.attrib['type'])
+        if 'name' in arg.attrib:
+            s += ' ' + arg.attrib['name']
+        else:
+            s += ' arg' + str(a)
+
+        if 'default' in arg.attrib:
+            s += '=' + arg.attrib['default']
+
+        argfound = True
+
+    if argfound:
+        s += ' '
+    s += ' **)**'
+
+    if 'qualifiers' in m.attrib:
+        s += ' ' + m.attrib['qualifiers']
 
 #	f.write(s)
-	if (not declare):
-		if (pp!=None):
-			pp.append( (t,s) )
-		else:
-			f.write("- "+t+" "+s+"\n")
-	else:
-		f.write(t+s+"\n")
+    if (not declare):
+        if (pp!=None):
+            pp.append( (t,s) )
+        else:
+            f.write("- "+t+" "+s+"\n")
+    else:
+        f.write(t+s+"\n")
 
 
 def make_heading(title, underline):
-	return title + '\n' + underline*len(title) + "\n\n"
+    return title + '\n' + underline*len(title) + "\n\n"
 
 
 
 def make_rst_class(node):
 
-	name = node.attrib['name']
+    name = node.attrib['name']
 
-	f = codecs.open("class_"+name.lower() + '.rst', 'wb', 'utf-8')
+    f = codecs.open("class_"+name.lower() + '.rst', 'wb', 'utf-8')
 
-	# Warn contributors not to edit this file directly
-	f.write(".. Generated automatically by doc/tools/makerst.py in Godot's source tree.\n")
-	f.write(".. DO NOT EDIT THIS FILE, but the doc/base/classes.xml source instead.\n\n")
+    # Warn contributors not to edit this file directly
+    f.write(".. Generated automatically by doc/tools/makerst.py in Godot's source tree.\n")
+    f.write(".. DO NOT EDIT THIS FILE, but the doc/base/classes.xml source instead.\n\n")
 
-	f.write(".. _class_"+name+":\n\n")
-	f.write(make_heading(name, '='))
+    f.write(".. _class_"+name+":\n\n")
+    f.write(make_heading(name, '='))
 
-	if 'inherits' in node.attrib:
-		inh = node.attrib['inherits'].strip()
+    if 'inherits' in node.attrib:
+        inh = node.attrib['inherits'].strip()
 #		whle inh in classes[cn]
-		f.write('**Inherits:** ')
-		first=True
-		while(inh in classes):
-			if (not first):
-				f.write(" **<** ")
-			else:
-				first=False
-
-			f.write(make_type(inh))
-			inode = classes[inh]
-			if ('inherits' in inode.attrib):
-				inh=inode.attrib['inherits'].strip()
-			else:
-				inh=None
-
-
-		f.write("\n\n")
-
-	inherited=[]
-	for cn in classes:
-		c=classes[cn]
-		if 'inherits' in c.attrib:
-			if (c.attrib['inherits'].strip()==name):
-				inherited.append(c.attrib['name'])
-
-	if (len(inherited)):
-		f.write('**Inherited By:** ')
-		for i in range(len(inherited)):
-			if (i>0):
-				f.write(", ")
-			f.write(make_type(inherited[i]))
-		f.write("\n\n")
-	if 'category' in node.attrib:
-		f.write('**Category:** ' + node.attrib['category'].strip() + "\n\n")
-
-	f.write(make_heading('Brief Description', '-'))
-	briefd = node.find('brief_description')
-	if briefd != None:
-		f.write(rstize_text(briefd.text.strip(),name) + "\n\n")
-
-	methods = node.find('methods')
-
-	if methods != None and len(list(methods)) > 0:
-		f.write(make_heading('Member Functions', '-'))
-		ml=[]
-		for m in list(methods):
-			make_method(f, node.attrib['name'], m, False,name,False,ml)
-		longest_t = 0
-		longest_s = 0
-		for s in ml:
-			sl = len(s[0])
-			if (sl>longest_s):
-				longest_s=sl
-			tl = len(s[1])
-			if (tl>longest_t):
-				longest_t=tl
-
-		sep="+"
-		for i in range(longest_s+2):
-			sep+="-"
-		sep+="+"
-		for i in range(longest_t+2):
-			sep+="-"
-		sep+="+\n"
-		f.write(sep)
-		for s in ml:
-			rt = s[0]
-			while( len(rt) < longest_s ):
-				rt+=" "
-			st = s[1]
-			while( len(st) < longest_t ):
-				st+=" "
-			f.write("| "+rt+" | "+st+" |\n")
-			f.write(sep)
-		f.write('\n')
-
-
-	events = node.find('signals')
-	if events != None and len(list(events)) > 0:
-		f.write(make_heading('Signals', '-'))
-		for m in list(events):
-			make_method(f, node.attrib['name'], m, True,name, True)
-		f.write('\n')
-
-	members = node.find('members')
-	if members != None and len(list(members)) > 0:
-		f.write(make_heading('Member Variables', '-'))
-
-		for c in list(members):
-			s = '- '
-			s += make_type(c.attrib['type']) + ' '
-			s += '**' + c.attrib['name'] + '**'
-			if c.text.strip() != '':
-				s += ' - ' + c.text.strip()
-			f.write(s + '\n')
-		f.write('\n')
-
-	constants = node.find('constants')
-	if constants != None and len(list(constants)) > 0:
-		f.write(make_heading('Numeric Constants', '-'))
-		for c in list(constants):
-			s = '- '
-			s += '**' + c.attrib['name'] + '**'
-			if 'value' in c.attrib:
-				s += ' = **' + c.attrib['value'] + '**'
-			if c.text.strip() != '':
-				s += ' --- ' + rstize_text(c.text.strip(),name)
-			f.write(s + '\n')
-		f.write('\n')
-
-	descr = node.find('description')
-	if descr != None and descr.text.strip() != '':
-		f.write(make_heading('Description', '-'))
-		f.write(rstize_text(descr.text.strip(),name) + "\n\n")
-
-	methods = node.find('methods')
-	if methods != None and len(list(methods)) > 0:
-		f.write(make_heading('Member Function Description', '-'))
-		for m in list(methods):
-			f.write(".. _class_"+name+"_"+m.attrib['name']+":\n\n")
+        f.write('**Inherits:** ')
+        first=True
+        while(inh in classes):
+            if (not first):
+                f.write(" **<** ")
+            else:
+                first=False
+
+            f.write(make_type(inh))
+            inode = classes[inh]
+            if ('inherits' in inode.attrib):
+                inh=inode.attrib['inherits'].strip()
+            else:
+                inh=None
+
+
+        f.write("\n\n")
+
+    inherited=[]
+    for cn in classes:
+        c=classes[cn]
+        if 'inherits' in c.attrib:
+            if (c.attrib['inherits'].strip()==name):
+                inherited.append(c.attrib['name'])
+
+    if (len(inherited)):
+        f.write('**Inherited By:** ')
+        for i in range(len(inherited)):
+            if (i>0):
+                f.write(", ")
+            f.write(make_type(inherited[i]))
+        f.write("\n\n")
+    if 'category' in node.attrib:
+        f.write('**Category:** ' + node.attrib['category'].strip() + "\n\n")
+
+    f.write(make_heading('Brief Description', '-'))
+    briefd = node.find('brief_description')
+    if briefd != None:
+        f.write(rstize_text(briefd.text.strip(),name) + "\n\n")
+
+    methods = node.find('methods')
+
+    if methods != None and len(list(methods)) > 0:
+        f.write(make_heading('Member Functions', '-'))
+        ml=[]
+        for m in list(methods):
+            make_method(f, node.attrib['name'], m, False,name,False,ml)
+        longest_t = 0
+        longest_s = 0
+        for s in ml:
+            sl = len(s[0])
+            if (sl>longest_s):
+                longest_s=sl
+            tl = len(s[1])
+            if (tl>longest_t):
+                longest_t=tl
+
+        sep="+"
+        for i in range(longest_s+2):
+            sep+="-"
+        sep+="+"
+        for i in range(longest_t+2):
+            sep+="-"
+        sep+="+\n"
+        f.write(sep)
+        for s in ml:
+            rt = s[0]
+            while( len(rt) < longest_s ):
+                rt+=" "
+            st = s[1]
+            while( len(st) < longest_t ):
+                st+=" "
+            f.write("| "+rt+" | "+st+" |\n")
+            f.write(sep)
+        f.write('\n')
+
+
+    events = node.find('signals')
+    if events != None and len(list(events)) > 0:
+        f.write(make_heading('Signals', '-'))
+        for m in list(events):
+            make_method(f, node.attrib['name'], m, True,name, True)
+        f.write('\n')
+
+    members = node.find('members')
+    if members != None and len(list(members)) > 0:
+        f.write(make_heading('Member Variables', '-'))
+
+        for c in list(members):
+            s = '- '
+            s += make_type(c.attrib['type']) + ' '
+            s += '**' + c.attrib['name'] + '**'
+            if c.text.strip() != '':
+                s += ' - ' + c.text.strip()
+            f.write(s + '\n')
+        f.write('\n')
+
+    constants = node.find('constants')
+    if constants != None and len(list(constants)) > 0:
+        f.write(make_heading('Numeric Constants', '-'))
+        for c in list(constants):
+            s = '- '
+            s += '**' + c.attrib['name'] + '**'
+            if 'value' in c.attrib:
+                s += ' = **' + c.attrib['value'] + '**'
+            if c.text.strip() != '':
+                s += ' --- ' + rstize_text(c.text.strip(),name)
+            f.write(s + '\n')
+        f.write('\n')
+
+    descr = node.find('description')
+    if descr != None and descr.text.strip() != '':
+        f.write(make_heading('Description', '-'))
+        f.write(rstize_text(descr.text.strip(),name) + "\n\n")
+
+    methods = node.find('methods')
+    if methods != None and len(list(methods)) > 0:
+        f.write(make_heading('Member Function Description', '-'))
+        for m in list(methods):
+            f.write(".. _class_"+name+"_"+m.attrib['name']+":\n\n")
 #			f.write(ul_string(m.attrib['name'],"^"))
-			#f.write('\n<a name="'+m.attrib['name']+'">' + m.attrib['name'] + '</a>\n------\n')
-			make_method(f, node.attrib['name'], m, True,name)
-			f.write('\n')
-			d = m.find('description')
-			if d == None or d.text.strip() == '':
-				continue
-			f.write(rstize_text(d.text.strip(),name))
-			f.write("\n\n")
-		f.write('\n')
+            #f.write('\n<a name="'+m.attrib['name']+'">' + m.attrib['name'] + '</a>\n------\n')
+            make_method(f, node.attrib['name'], m, True,name)
+            f.write('\n')
+            d = m.find('description')
+            if d == None or d.text.strip() == '':
+                continue
+            f.write(rstize_text(d.text.strip(),name))
+            f.write("\n\n")
+        f.write('\n')
 
 
 for file in input_list:
-	tree = ET.parse(file)
-	doc = tree.getroot()
+    tree = ET.parse(file)
+    doc = tree.getroot()
 
-	if 'version' not in doc.attrib:
-		print "Version missing from 'doc'"
-		sys.exit(255)
+    if 'version' not in doc.attrib:
+        print "Version missing from 'doc'"
+        sys.exit(255)
 
-	version = doc.attrib['version']
+    version = doc.attrib['version']
 
-	for c in list(doc):
-		if c.attrib['name'] in class_names:
-			continue
-		class_names.append(c.attrib['name'])
-		classes[c.attrib['name']] = c
+    for c in list(doc):
+        if c.attrib['name'] in class_names:
+            continue
+        class_names.append(c.attrib['name'])
+        classes[c.attrib['name']] = c
 
 class_names.sort()
 
@@ -514,6 +514,6 @@ class_names.sort()
 #make_class_list(class_names, 2)
 
 for cn in class_names:
-	c = classes[cn]
-	make_rst_class(c)
+    c = classes[cn]
+    make_rst_class(c)