removed annoying output from ClassicDocumentClass. Added support

for determining align and valign for table cells to DocumentClass.
Updated HTMLClass to be able to handle DocumentClass's updated
information. Resolved some insertion problems associated with
ST.py

lib/python/StructuredText/ClassicDocumentClass.py

@@ -430,6 +430,7 @@ class DocumentClass:
        return result
     
     def doc_table(self,paragraph, expr = re.compile('(\s*)([||]+)').match):
+        #print "paragraph=>", type(paragraph), paragraph, paragraph._src
         text    = paragraph.getColorizableTexts()[0]
         m       = expr(text)
         

lib/python/StructuredText/DocumentClass.py

@@ -222,7 +222,11 @@ class StructuredTextRow(ST.StructuredTextDocument):
         apply(ST.StructuredTextDocument.__init__,(self,[]),kw)
         self._columns = []
         for column in row:            
-            self._columns.append(StructuredTextColumn(column[0],column[1],kw))
+            self._columns.append(StructuredTextColumn(column[0],
+                                                      column[1],
+                                                      column[2],
+                                                      column[3],
+                                                      kw))
 
     def getColumns(self):
         return [self._columns]
@@ -245,15 +249,29 @@ class StructuredTextColumn(ST.StructuredTextParagraph):
     or StructuredTextTableData.
     """
     
-    def __init__(self,text,span,kw):
+    def __init__(self,text,span,align,valign,kw):
         apply(ST.StructuredTextParagraph.__init__,(self,text,[]),kw)
         self._span = span
+        self._align = align
+        self._valign = valign
     
     def getSpan(self):
         return self._span
     
     def _getSpan(self):
         return self._span
+    
+    def getAlign(self):
+        return self._align
+    
+    def _getAlign(self):
+        return self.getAlign()
+    
+    def getValign(self):
+        return self._valign
+    
+    def _getValign(self):
+        return self.getValign()
 
 class StructuredTextTableHeader(ST.StructuredTextDocument): pass
 
@@ -599,10 +617,94 @@ class DocumentClass:
                     ROWS.append(COLS)
                     COLS = []
                 else:
-                    COLS[index][0] = COLS[index][0] + strip(row[index][0]) + "\n"
+                    #COLS[index][0] = COLS[index][0] + strip(row[index][0]) + "\n"
+                    COLS[index][0] = COLS[index][0] + (row[index][0]) + "\n"
                     COLS[index][1] = row[index][1]
         
-        return StructuredTextTable(ROWS,text,subs,indent=paragraph.indent)
+        # now that each cell has been munged together,
+        # determine the cell's alignment.
+        # Default is to center. Also determine the cell's
+        # vertical alignment, top, middle, bottom. Default is
+        # to middle        
+        rows = []
+        cols = []
+        for row in ROWS:
+            for index in range(len(row)):
+                topindent       = 0
+                bottomindent    = 0
+                leftindent      = 0
+                rightindent     = 0
+                left            = []
+                right           = []                                    
+                text            = row[index][0]
+                text            = split(text,'\n')
+                text            = text[:len(text)-1]
+                align           = ""
+                valign          = ""
+                for t in text:
+                    t = strip(t)
+                    if not t:
+                        topindent = topindent + 1
+                    else:
+                        break
+                text.reverse()
+                for t in text:
+                    t = strip(t)
+                    if not t:
+                        bottomindent = bottomindent + 1
+                    else:
+                        break
+                text.reverse()
+                tmp   = join(text[topindent:len(text)-bottomindent],"\n")
+                pars  = re.compile("\n\s*\n").split(tmp)
+                for par in pars:
+                    if index > 0:
+                        par = par[1:]
+                    par = split(par, ' ')
+                    for p in par:
+                        if not p:
+                            leftindent = leftindent+1
+                        else:
+                            break
+                    left.append(leftindent)
+                    leftindent = 0
+                    par.reverse()
+                    for p in par:
+                        if not p:
+                            rightindent = rightindent + 1
+                        else:
+                            break
+                    right.append(rightindent)
+                    rightindent = 0
+                left.sort()
+                right.sort()
+
+                if topindent == bottomindent:
+                    valign="middle"
+                elif topindent < 1:
+                    valign="top"
+                elif bottomindent < 1:
+                    valign="bottom"
+                else:
+                    valign="middle"
+
+                if left[0] == right[0]:
+                    align="center"
+                elif left[0] < 1:
+                    align="left"
+                elif right[0] < 1:
+                    align="right"
+                else:
+                    align="left"
+
+                cols.append(row[index][0],row[index][1],align,valign)
+                #print text, align, valign
+                #print text, topindent, bottomindent, left[0], right[0]
+            rows.append(cols)
+            cols = []
+
+        return StructuredTextTable(rows,text,subs,indent=paragraph.indent)
+        #return StructuredTextTable(ROWS,text,subs,indent=paragraph.indent)
             
     def doc_bullet(self, paragraph, expr = re.compile('\s*[-*o]\s+').match):
         top=paragraph.getColorizableTexts()[0]

lib/python/StructuredText/HTMLClass.py

@@ -279,7 +279,10 @@ class HTMLClass:
         for row in doc.getRows()[0]:
             output("<tr>\n")
             for column in row.getColumns()[0]:
-                str = "<td colspan=%s>" % column.getSpan()
+                if hasattr(column,"getAlign"):
+                    str = "<td colspan=%s align=%s valign=%s>" % (column.getSpan(),column.getAlign(),column.getValign())
+                else:
+                    str = "<td colspan=%s>" % column.getSpan()
                 output(str)
                 #for c in doc.getChildNodes():
                 #    getattr(self, self.element_types[c.getNodeName()])(c, level, output)

lib/python/StructuredText/ST.py

@@ -26,7 +26,9 @@ def insert(struct, top, level):
     """
     #print "struct", struct, top-1
     if not top-1 in range(len(struct)):
-        return None
+        if struct:
+            return struct[len(struct)-1].getSubparagraphs()
+        return struct
     run = struct[top-1]
     i    = 0
     while i+1 < level:
@@ -142,8 +144,11 @@ def StructuredText(paragraphs, paragraph_delimiter=re.compile('\n\s*\n')):
             if result > 0:
                 currentlevel = result
             currentindent  = indent
-            run = insert(struct,level,currentlevel)
-            run.append(StructuredTextParagraph(paragraph, indent=indent, level=currentlevel))
+            if not level:
+                struct.append(StructuredTextParagraph(paragraph, indent=indent, level=currentlevel))
+            else:
+                run = insert(struct,level,currentlevel)
+                run.append(StructuredTextParagraph(paragraph, indent=indent, level=currentlevel))
         else:
             if insert(struct,level,currentlevel):
                 run = insert(struct,level,currentlevel)