From 6f3875af3eb75e86060e64c991ce64ef53f5a255 Mon Sep 17 00:00:00 2001
From: Edouard DUPIN <yui.heero@gmail.com>
Date: Wed, 25 Dec 2013 23:56:09 +0100
Subject: [PATCH] [DEV] add some element display

---
 monkClass.py   |  15 ++++
 monkEnum.py    |  24 +++++-
 monkHtml.py    | 202 ++++++++++++++++++++++++++++++++-----------------
 monkModule.py  |  16 ++++
 monkNode.py    |  47 +++++++++++-
 theme/base.css |   5 +-
 theme/menu.css |   3 +-
 7 files changed, 237 insertions(+), 75 deletions(-)

diff --git a/monkClass.py b/monkClass.py
index f99f2a7..849ac2b 100644
--- a/monkClass.py
+++ b/monkClass.py
@@ -1,6 +1,7 @@
 #!/usr/bin/python
 import monkDebug as debug
 import monkNode as Node
+import monkModule as module
 
 
 ##
@@ -57,6 +58,20 @@ class Class(Node.Node):
 				ret += element['access'] + " " + element['class']
 		ret += " { ... };"
 		return ret
+	
+	def get_parents(self):
+		if len(self.inherit) == 0:
+			return []
+		# note this ony get the first parent ...
+		parent = module.get_element_with_name(self.inherit[0]['class'])
+		cparent = []
+		if parent != None:
+			debug.info(" plop : " + self.name + " " + str(parent) + " " + parent.get_name())
+			cparent = parent.get_parents()
+			pass
+		#heritage = parent.
+		cparent.append(self.inherit[0])
+		return cparent
 
 
 
diff --git a/monkEnum.py b/monkEnum.py
index 20557ad..60980f0 100644
--- a/monkEnum.py
+++ b/monkEnum.py
@@ -39,7 +39,25 @@ class Enum(Node.Node):
 			if len(element) > 2:
 				if element[1] == '=':
 					for tmp in element[2:]:
-						value += tmp
-			self.listElement.append({'name' : element[0], 'value' : value})
+						value = tmp
+			if value == "":
+				if self.baseValue == None:
+					value = "???"
+				else:
+					value = str(self.baseValue)
+					self.baseValue += 1
+			else:
+				try:
+					tmpVal = int(value)
+					self.baseValue = tmpVal + 1
+				except:
+					debug.debug("can not parse enum value : '" + value + "'")
+					self.baseValue = None
+			self.listElement.append({'name' : element[0], 'value' : value, 'doc' : ""})
 		
-		debug.verbose("enum list : " + str(self.listElement))
\ No newline at end of file
+		debug.verbose("enum list : " + str(self.listElement))
+	
+	def get_enum_list(self):
+		return self.listElement
+
+
diff --git a/monkHtml.py b/monkHtml.py
index 97d49aa..a2314a9 100644
--- a/monkHtml.py
+++ b/monkHtml.py
@@ -98,41 +98,42 @@ def white_space(size) :
 		ret += " "
 	return ret
 
-def generate_menu(element, namespaceStack=[], level=1):
+def generate_menu(element, level=1):
+	namespaceStack = element.get_namespace()
 	listBase = element.get_all_sub_type(['namespace'])
 	if len(listBase) == 0:
 		return ""
 	ret = ""
 	ret += '<ul class="niveau' + str(level) + '">\n'
 	for element in listBase:
-		namespaceStack.append(element['node'].get_name())
-		retTmp = generate_menu(element['node'], namespaceStack, level+1)
-		namespaceStack.pop()
+		retTmp = generate_menu(element['node'], level+1)
 		if retTmp != "":
 			subMenu = ' class="sousmenu"'
 		else:
 			subMenu = ''
-		ret += '	<li' + subMenu + '>' + generate_link(element['node'], namespaceStack) + '\n'
+		ret += '	<li' + subMenu + '>' + generate_link(element['node']) + '\n'
 		ret += retTmp
 		ret += '	</li>\n'
 	ret += '</ul>\n'
 	return ret
 
-def generate_html_page_name(element, namespaceStack):
+def generate_html_page_name(element):
+	namespaceStack = element.get_namespace()
 	link = ""
 	for name in namespaceStack:
 		link += name + "__"
 	return element.get_node_type() + "_" + link + element.get_name() + '.html'
 
-def generate_name(element, namespaceStack):
+def generate_name(element):
+	namespaceStack = element.get_namespace()
 	link = ""
 	for name in namespaceStack:
 		link += name + "::"
 	return element.get_node_type() + ": " + link + element.get_name()
 
 
-def generate_link(element, namespaceStack):
-	return '<a href="' + generate_html_page_name(element, namespaceStack) + '">' + element.get_name() + '</a>'
+def generate_link(element):
+	return '<a href="' + generate_html_page_name(element) + '">' + element.get_name() + '</a>'
 
 def calculate_methode_size(list):
 	returnSize = 0;
@@ -218,80 +219,143 @@ def generate_stupid_index_page(outFolder, header, footer, myLutinDoc):
 	file.write(footer)
 	file.close();
 
-def generate_page(outFolder, header, footer, element, namespaceStack=[]):
+def generate_page(outFolder, header, footer, element):
+	namespaceStack = element.get_namespace()
 	if element.get_node_type() in ['library', 'application', 'namespace', 'class', 'struct', 'enum', 'union']:
 		listBase = element.get_all_sub_type(['library', 'application', 'namespace', 'class', 'struct', 'enum', 'union'])
 		for elem in listBase:
-			if element.get_node_type() in ['namespace', 'class', 'struct']:
-				namespaceStack.append(element.get_name())
-				generate_page(outFolder, header, footer, elem['node'], namespaceStack)
-				namespaceStack.pop()
-			else:
-				generate_page(outFolder, header, footer, elem['node'], namespaceStack)
-	filename = outFolder + '/' + generate_html_page_name(element, namespaceStack)
+			generate_page(outFolder, header, footer, elem['node'])
+	filename = outFolder + '/' + generate_html_page_name(element)
 	monkTools.create_directory_of_file(filename);
 	file = open(filename, "w")
 	file.write(header)
-	file.write("<h1>" + generate_name(element, namespaceStack) + "</h1>");
-	file.write("<hr/>");
-	if element.get_node_type() == 'library':
-		file.write("TODO : the page ...");
-	elif element.get_node_type() == 'application':
-		file.write("TODO : the page ...");
-	elif element.get_node_type() == 'namespace':
-		file.write("TODO : the page ...");
-	elif element.get_node_type() == 'class':
-		# calculate element size :
-		listBase = element.get_all_sub_type(['methode', 'constructor', 'destructor'])
-		displayLen = calculate_methode_size(listBase)
+	file.write('<h1>' + generate_name(element) + '</h1>');
+	file.write('<hr/>');
+	
+	documentation = parse_doxygen(element.get_doc())
+	if len(documentation) != 0:
+		file.write('<h2>Description:</h2>\n')
+		file.write(documentation)
+		file.write('<br/>\n')
+	
+	if element.get_node_type() in ['library', 'application', 'namespace', 'class', 'struct']:
+		for nameElement in ['namespace', 'class', 'struct', 'enum', 'union']:
+			listBase = element.get_all_sub_type(nameElement)
+			if len(listBase) == 0:
+				continue
+			file.write('<h2>' + nameElement + ':</h2>\n');
+			file.write('<ul>\n');
+			for elem in listBase:
+				file.write('<li>' + generate_link(elem['node']) + '</li>')
+			file.write('</ul>\n');
 		
-		file.write("<h2>Constructor and Destructor:</h2>\n")
-		file.write("<pre>\n");
-		listBaseConstructor = element.get_all_sub_type(['constructor'])
-		for elem in listBaseConstructor:
-			ret = write_methode(elem, namespaceStack, displayLen)
-			file.write(ret)
-		listBaseDestructor = element.get_all_sub_type(['destructor'])
-		for elem in listBaseDestructor:
-			ret = write_methode(elem, namespaceStack, displayLen)
-			file.write(ret)
-		file.write("</pre>\n");
-		file.write("<br/>\n")
+	# calculate element size :
+	listBase = element.get_all_sub_type(['methode', 'constructor', 'destructor'])
+	displayLen = calculate_methode_size(listBase)
+	
+	if    element.get_node_type() == 'class' \
+	   or element.get_node_type() == 'struct':
 		
-		file.write("<h2>Synopsis:</h2>\n")
-		file.write("<pre>\n");
+		if len(element.get_all_sub_type(['constructor', 'destructor'])) != 0:
+			file.write('<h2>Constructor and Destructor:</h2>\n')
+			file.write('<pre>\n');
+			listBaseConstructor = element.get_all_sub_type(['constructor'])
+			for elem in listBaseConstructor:
+				ret = write_methode(elem, namespaceStack, displayLen)
+				file.write(ret)
+			listBaseDestructor = element.get_all_sub_type(['destructor'])
+			for elem in listBaseDestructor:
+				ret = write_methode(elem, namespaceStack, displayLen)
+				file.write(ret)
+			file.write('</pre>\n');
+			file.write('<br/>\n')
+		
+	if element.get_node_type() in ['library', 'application', 'namespace', 'class', 'struct']:
 		listBaseMethode = element.get_all_sub_type(['methode'])
-		displayLen = calculate_methode_size(listBaseMethode)
-		for elem in listBaseMethode:
-			ret = write_methode(elem, namespaceStack, displayLen)
-			file.write(ret)
-		file.write("</pre>\n")
-		file.write("<br/>\n")
-		
-		file.write("<h2>Description:</h2>\n")
+		if len(listBaseMethode) != 0:
+			file.write('<h2>Synopsis:</h2>\n')
+			file.write('<pre>\n');
+			displayLen = calculate_methode_size(listBaseMethode)
+			for elem in listBaseMethode:
+				ret = write_methode(elem, namespaceStack, displayLen)
+				file.write(ret)
+			file.write('</pre>\n')
+			file.write('<br/>\n')
+	
+	# generate herirage list :
+	if element.get_node_type() == 'class':
+		parent = element.get_parents()
+		child = None
+		if parent != []:
+			file.write('<h2>Object Hierarchy:<h2>\n')
+			file.write('<pre>\n');
+			file.write(str(parent));
+			file.write('</pre>\n');
 		
+	
+	if len(listBase) != 0:
 		# display all functions :
-		file.write("<h2>Detail:<h2>\n")
-		for element in listBase:
-			file.write('<h3><a id="' + str(element['node'].get_uid()) + '">' + element['node'].get_name() + '</a></h3>')
-			file.write("<pre>\n");
-			file.write(write_methode(element, namespaceStack, link = False))
-			file.write("</pre>\n");
+		file.write('<h2>Detail:<h2>\n')
+		for subElement in listBase:
+			file.write('<h3><a id="' + str(subElement['node'].get_uid()) + '">' + subElement['node'].get_name() + '</a></h3>')
+			file.write('<pre>\n');
+			file.write(write_methode(subElement, namespaceStack, link = False))
+			file.write('</pre>\n');
 			#debug.info(str(element['node'].get_doc()));
-			file.write(parse_doxygen(element['node'].get_doc()));
-			file.write("<br/>\n");
-			file.write("<hr/>\n");
+			file.write(parse_doxygen(subElement['node'].get_doc()));
+			file.write('<br/>\n');
+			file.write('<hr/>\n');
 		
-	elif element.get_node_type() == 'struct':
+	if element.get_node_type() == 'enum':
+		myElementList = element.get_enum_list()
+		elementSize = 0
+		for enumElement in myElementList:
+			tmpLen = len(enumElement['name'])
+			if tmpLen > elementSize:
+				elementSize = tmpLen
+		
+		
+		file.write('<h2>Value list</h2>\n')
+		if len(myElementList) < 9:
+			nbColumn = 1
+		else:
+			nbColumn = 3
+		
+		file.write('<ul>\n');
+		file.write('<table class="enumeration-list"><tr>\n');
+		nbCol = 0
+		isFirst = True
+		for enumElement in myElementList:
+			if isFirst == True:
+				file.write('<tr>\n');
+			isFirst = False
+			file.write('<td><a href="#' + enumElement['name'] + '">' + enumElement['name'] + '</a></td>')
+			nbCol += 1
+			if nbCol == nbColumn:
+				nbCol = 0
+				file.write('</tr>\n');
+				isFirst = True
+		if isFirst == False:
+			file.write('</tr>\n');
+		file.write('</table>\n');
+		file.write('</ul>\n');
+		
+		file.write("<h2>Detail:<h2>\n")
+		isFirst = True
+		for enumElement in myElementList:
+			if isFirst == False:
+				file.write('<hr/>\n');
+			isFirst = False
+			file.write('<a id="' + enumElement['name'] + '"/>' + enumElement['name'])
+			file.write('<pre>\n')
+			file.write(enumElement['name'] + white_space(elementSize-len(enumElement['name'])) + ' = <span class="code-type">' + enumElement['value'] + '<span>')
+			file.write('</pre>\n')
+			if enumElement['doc'] != "":
+				file.write(parse_doxygen(enumElement['doc']));
+		
+	if element.get_node_type() == 'union':
 		file.write("TODO : the page ...");
-	elif element.get_node_type() == 'enum':
-		file.write("TODO : the page ...");
-	elif element.get_node_type() == 'union':
-		file.write("TODO : the page ...");
-	else:
-		# not in a specific file ...
-		debug.warning("might not appear here :'" + element.get_node_type() + "' = '" + element.get_name() + "'")
-		pass
+	
 	file.write(footer)
 	file.close();
 	
diff --git a/monkModule.py b/monkModule.py
index 9419320..b1e541a 100644
--- a/monkModule.py
+++ b/monkModule.py
@@ -8,6 +8,7 @@ import monkTools as tools
 import monkNode as Node
 import monkParse as Parse
 import monkHtml
+import re
 
 class Module:
 	##
@@ -104,6 +105,9 @@ class Module:
 					fileCompleteName = os.path.join(root, filename)
 					debug.debug("    Find a file : '" + fileCompleteName + "'")
 					self.add_file(fileCompleteName)
+		# all file is parset ==> now we create the namespacing of ll elements:
+		self.structureLib.set_namespace()
+		
 		# display the hierarchie of all the class and namespace ...
 		#self.structureLib.debug_display()
 		if self.pathGlobalDoc != "":
@@ -356,3 +360,15 @@ def list_all_module_with_desc():
 def get_link_type(type):
 	return ""
 
+def get_element_with_name(type):
+	global moduleList
+	debug.info("try find : " + str(type) + "  ")
+	ret = re.sub(r'::', ':', type)
+	ret = ret.split(":")
+	for mod in moduleList:
+		element = mod['node'].get_base_doc_node().find(ret)
+		if element != None:
+			debug.info("we find : " + type + " = " + str(ret) + "   " + str(element))
+			return element
+	debug.info("we not find : " + type + " = " + str(ret))
+	return None
\ No newline at end of file
diff --git a/monkNode.py b/monkNode.py
index b864e7d..850c7cf 100644
--- a/monkNode.py
+++ b/monkNode.py
@@ -24,6 +24,8 @@ class Node():
 		self.lineNumber = lineNumber
 		self.subList = None
 		self.access = None
+		# namespace elements : (set when all element are parsed ...
+		self.namespace = []
 	
 	def to_str(self):
 		return ""
@@ -135,7 +137,50 @@ class Node():
 			# TODO : Sorted the list ...
 			pass
 		return ret
-
+	
+	def set_namespace(self, hierarchy = []):
+		# store namespaces:
+		self.namespace = hierarchy
+		# set for all sub elements ...
+		if self.subList == None:
+			return
+		if self.nodeType in ['class', 'namespace', 'struct']:
+			for element in self.subList:
+				hierarchy.append(self.get_name())
+				element['node'].set_namespace(hierarchy)
+				hierarchy.pop()
+		elif self.nodeType in ['library', 'application']:
+			for element in self.subList:
+				element['node'].set_namespace()
+	
+	def get_namespace(self):
+		return self.namespace
+	
+	def find(self, list):
+		debug.info("find : " + str(list) + " in " + self.nodeType)
+		if len(list) == 0:
+			return None
+		if self.nodeType in ['library', 'application']:
+			if self.subList == None:
+				return None
+			for element in self.subList:
+				ret = element['node'].find(list)
+				if ret != None:
+					return ret
+			return None
+		if list[0] != self.name:
+			return None
+		if self.nodeType not in ['class', 'namespace', 'struct']:
+			return self
+		tmpList = list[1:]
+		if self.subList == None:
+			return None
+		for element in self.subList:
+			ret = element['node'].find(tmpList)
+			if ret != None:
+				return ret
+		return None
+	
 
 
 class MainNode(Node):
diff --git a/theme/base.css b/theme/base.css
index 22c4ee2..41e43ee 100644
--- a/theme/base.css
+++ b/theme/base.css
@@ -95,7 +95,10 @@ pre {
 	border-radius: 4px;
 }
 
-
+.enumeration-list td {
+	padding-left:10px;
+	padding-right:10px;
+}
 
 .code-function {
 	text-decoration:none;
diff --git a/theme/menu.css b/theme/menu.css
index 26ed389..1c93b04 100644
--- a/theme/menu.css
+++ b/theme/menu.css
@@ -143,4 +143,5 @@ div#menu li a:hover {
 	border-left-color: #000ADE;
 	background: #6699FF;
 	font-weight:bold;
-}
\ No newline at end of file
+}
+