Esempio n. 1
0
 def endElement(self, name):
     if name == 'chapter':
         self._endArticle()
         
     elif name == 'div':
         self._endArticle()
         
     elif name == 'p':
         self._endDfn = False
         OsisHandler.endElement(self, name)
         
     elif name == 'seg':
         if self._inDfn:
             self._writeHtml('</%s>' % self._keywordTag)
             if self._keywordTag == 'h4':
                 self._writeHtml('\n<div class="glossary-entry">')
             self._inDfn = False
             self._endDfn = True
             
     elif name == 'title':
         if self._inTitle:
             self._inTitle = False
             if self._ignoreTitle:
                 self._ignoreTitle = False                       
             elif self._headerProcessed:
                 if self._inChapterTitle:
                     self._titleTag = '<h3 toclevel = 2>' 
                     self._inChapterTitle = False
                     self._entryTocLevel = 3
                 else:
                     self._glossTitleWritten = True
                 self._writeTitle()
                 
     else:
         OsisHandler.endElement(self, name)
Esempio n. 2
0
 def startDocument(self):
     OsisHandler.startDocument(self)
     self._bibleHtmlOpen = False
     self._bibleIntroWritten = False
     self._bibleStarting = True
     self._bookHtmlOpen = False
     self._bookTitle = ''
     self._canonicalTitleWritten = False
     self._chapterTitle = ''
     self._chFootnoteMarker = ''
     self._chNumWritten = False
     self._chHeadingWritten = False
     self._firstBook = True
     self._groupEmpty = False
     self._groupHtmlOpen = False
     self._groupIndex = 0
     self._inCanonicalTitle = False
     self._inChapterTitle = False
     self._ignoreChEnd = False
     self._ignoreDivEnd = False
     self._inFootnoteRef = False
     self._inIntro = False
     self._introDivTextFound = False
     self._introStyleStarted = False
     self._introText = ''
     self._introTextFound = False
     self._introTitleWritten = False
     self._inVerse = False 
     self._psDivTitle = False
     self._psDivTitleFound = False
     self._readyForSubtitle = False
     self._verseNumWritten = False
     self._verseText = ''
     self._verseTextFound = False
     self._defaultHeaderLevel = 3  
Esempio n. 3
0
    def startDocument(self):
        OsisHandler.startDocument(self)
        self._endDfn = False
        self._glossTitleWritten = False
        self._headerProcessed = False
        self._inArticle = False
        self._inChapterTitle = False
        self._inDfn = False
        self._foundGlossaryDiv = False
        self._inChapter = False
        self._entryTocLevel = 2 
        self._defaultHeaderLevel = 3                    # Avoid header level 2 as this would appear in table of contents
        
        # Select appropriate setting for FB2 for whether individual entries should be in the toc       
        if self._context.outputFmt == 'fb2':
            self._context.config.glossEntriesInToc = self._context.config.glossEntriesInTocFb2;
            
            if self._context.config.glossEntriesInToc:
                self._keywordTag = 'h4'

        # If there are multiple glossaries and Testament headers are used,
        # create an overall title for the glossaries at the Testament level if title is set in config
        if len(self._context.glossaries) > 1 and self._context.topHeaderLevel == 1 and self._context.config.glossTitleSet:
            self._htmlWriter.open('glossary.txt')
            self._htmlWriter.write('<h1>%s</h1>\n' % self._context.config.glossaryTitle)
            self._htmlWriter.close()
            self._context.topHeaderLevel = 2
Esempio n. 4
0
 def _writeFootnoteMarker(self, refBook, noteRef):
     if self._inChapterTitle:
         refString = self._footnoteMarker(refBook, noteRef)    
         self._chFootnoteMarker += refString
     else:
         OsisHandler._writeFootnoteMarker(self, refBook, noteRef)
     self._footnoteMarkerWritten = True
Esempio n. 5
0
    def __init__(self, htmlWriter, context):
        OsisHandler.__init__(self, htmlWriter, context)
        self._bibleHtmlOpen = False
        self._bibleIntroWritten = False             # A Bible introduction has been written
        self._bibleStarting = True                  # Not yet found first Bible chapter
        self._bookTitle = ''                        # Book title either from config or found in OSIS
        self._bookHtmlOpen = False
        self._bookTitleFound = False                # Found title which will be used as book title
        self._bookTitleWritten = False              # Title of current book written to output file
        self._canonicalTitleWritten = False         # Last output written was a canonical title
        self._chFootnoteMarker = ''                 # Footnote marker in a chapter title
        self._chNumWritten = False                  # Chapter number written before current verse
        self._chHeadingWritten = False              # Found or generated a title at the start of a chapter 
        self._chapterTitle = ''                     # HTML for chapter title ready to be written to output
        self._chTitleWritten = False                # Chapter title has been written to output
        self._docStructure = DocStructure()
        self._firstBook = True                      # First book of testament
        self._firstTitle = False                    # Next title found will be first in book
        self._firstVerse = False                    # Current verse is first in chapter
        self._footnoteMarkerWritten = False         # Marker for current footnote has been written (and any scripture reference processed)
        self._groupEmpty = False                    # No books yet found in current book group
        self._groupIndex = 0                        # Used to check for start of new testament where separate book groups not used
        self._groupIntroWritten = False             # A testament introduction has been written for current testament
        self._groupHtmlOpen = False
        self._groupTitle = ''                       # Title for current testament, obtained from config
        self._groupTitleWritten = False             # The current testament title has been written
        self._inCanonicalTitle = False              # Currently processing a canonical title
        self._inChapterTitle = False                # Currently processing a chapter title
        self._ignoreChEnd = False                   # Processing <chapter> tag which is a milestone tag
        self._ignoreDivEnd = False                  # Processing <div> tag which is a milestone tag
        self._inFootnoteRef = False                 # Processing initial reference in a footnote
        self._inIntro = False                       # Processing an introduction rather than scripture
        self._introDivTextFound = False             # Some text has been processed for current introduction <div>
        self._introStyleStarted = False             # Found first occurrence of 'x-introduction' (sub)type in current introduction
        self._introText = ''                        # Html generated for current introduction
        self._introTextFound = False                # Some text has been processed for current introduction
        self._introTitleWritten = False             # A title for the current introduction has been written
        self._inVerse = False                       # Currently within a scripture verse and not within a canonical title
        self._lineSpan = False                      # Current poetic line in first line of chapter, to the right of a chapter number
        self._psDivTitle = False                    # Title being processed had been identified as a Psalm division title or subtitle
        self._psDivTitleFound = False               # Last title processed was a Psalm division title, so next may be corresponding subtitle
        self._readyForSubtitle = False              # Last title processed was a book title, so next may be corresponding subtitle
        self._singleChapterBook = False             # Current book should have only one chapter
        self._startingChapter = False               # <chapter> tag processed, but initial <verse> tag not yet found
        self._verseEmpty = True                     # Not yet processed any text in this verse (excluding canonical title)
        self._verseNumWritten = False               # Html for the number of the current verse has been generater
        self._verseText = ''                        # Text of verse currently beeing processed

        
        # For fb2, we need chapter/psalm titles.
        # If no format has been provided, set up format as the chapter/psalm number only
        
        if self._context.outputFmt == 'fb2':
            if self._context.config.chapterTitle == '':
                self._context.config.chapterTitle = '%s'
            if self._context.config.psalmTitle == '':
                self._context.config.psalmTitle = '%s'
Esempio n. 6
0
 def __init__(self, htmlWriter, context):
     OsisHandler.__init__(self, htmlWriter, context)
     self._endDfn = False                            # Just written </dfn> tag
     self._glossTitleWritten = False                 # The title for the glossary has been written out
     self._inArticle = False                         # Currently processing a glossary entry
     self._inChapterTitle = False                    # The title currently being processed is a chapter title
     self._inDfn = False                             # Currently within an OSIS <seg> tag for a keyword
     self._foundGlossaryDiv = False                  # A div with type="glossary" has been found
     self._inChapter = False                         # Currently between start and end chapter tags
     self._entryTocLevel = 2                         # Level for toc entries for individual entries
     self._keywordTag = 'dfn'                        # Tag to use for keywords
Esempio n. 7
0
 def _writeTitle(self):
     if len(self._titleText) > 0:
         origInVerse = self._inVerse
         if self._psDivTitle:
             self._inVerse = False      # causes title to be written before Psalm heading
         titleWritten = OsisHandler._writeTitle(self)
         self._inVerse = origInVerse
         return titleWritten
     else:
         return False
Esempio n. 8
0
 def _writeHtml(self, html):
     if self._inFootnote and not self._writingFootnoteMarker:
         OsisHandler._writeHtml(self, html)
     elif not self._inTitle and not self._inCaption:
         self._suppressBreaks = False
         if self._inIntro:
             self._introText += html
         elif self._inVerse and not self._verseEmpty:
             self._verseText += html
         else:
             OsisHandler._writeHtml(self, html)
         self._breakCount = 0   # will be overwritten if called from _writeBreak()
     else:
         OsisHandler._writeHtml(self, html)
Esempio n. 9
0
 def startElement(self, name, attrs):
     if not self._inWork:
         OsisHandler.startElement(self, name, attrs)
Esempio n. 10
0
 def endDocument(self):
     self._footnotes.writeFootnotes()
     OsisHandler.endDocument(self)
Esempio n. 11
0
    def _processBodyTag(self, name, attrs):
        if name == 'chapter':
            self._endArticle()
            sId = self._getAttributeValue(attrs, 'sId')
            if sId is not None:
                self._inChapter = True
            else:
                eId = self._getAttributeValue(attrs, 'sId')
                if eId is not None:
                    self._inChapter = False
                    self._entryTocLevel = 2 
                    
                                  
        elif name == 'div':
            divType = self._getAttributeValue(attrs, 'type')
            if divType == 'glossary':
                self._htmlWriter.open(self._osisIDWork)
                self._breakCount = 2
                self._foundGlossaryDiv = True
            elif not self._foundGlossaryDiv:
                typeStr = ''
                if divType is not None:
                    typeStr = 'type %s' % divType
                print 'Unexpected <div> found - type %s' % typeStr
                
        elif name == 'reference':
            # reference are ignored apart from glossary references
            refType = self._getAttributeValue(attrs, 'type')
            if refType == "x-glosslink" and self._endDfn:
                self._writeHtml(u' \u2014 ')
                self._endDfn = False
            OsisHandler._processReference(self, attrs)

        elif name == 'seg':
            segType = self._getAttributeValue(attrs, 'type')
            if segType == 'keyword':
                self._closeParagraph()
                self._endArticle()
                articleTag = 'article'
                if self._context.outputFmt != 'epub':
                    articleTag = 'div'
                levelAttr = ''
                if self._context.config.glossEntriesInToc:
                    levelAttr = ' toclevel="%d"' % self._entryTocLevel
                if self._keywordTag == 'dfn':                   # fb2 will not generate toc entry if within <div>
                    self._writeHtml('\n<%s class="glossary-entry">' % articleTag)
                self._writeHtml('\n<%s%s>' % (self._keywordTag, levelAttr))
                self._inArticle = True
                self._inDfn = True
                    
        elif name == 'title':
            self._endArticle()
            titleType = self._getAttributeValue(attrs,'type')
            if titleType == 'runningHead':
                self._inTitle = True
                self._ignoreTitle = True
            elif titleType == 'x-chapterLabel':
                if not self._glossTitleWritten:
                    self._writeDefaultTitle()
                self._inTitle = True
                self._inChapterTitle = True
                self._titleText = ''
            else:
                if not self._glossTitleWritten:
                    self._titleTag = '<h%d>' % self._context.topHeaderLevel
                else:
                    level = self._getAttributeValue(attrs,'level')
                    if level is not None:
                        headerLevel = int(level) + self._context.topHeaderLevel
                    else:
                        headerLevel = self._defaultHeaderLevel
                    subType = self._getAttributeValue(attrs,'subType')
                    if subType is not None:
                        self._titleTag = '<h%d class="%s">' % (headerLevel, subType)
                    else:
                        self._titleTag = '<h%d>' % (headerLevel)
                self._inTitle = True
                self._titleText = ''
                    
        else:
            OsisHandler._processBodyTag(self, name, attrs)
Esempio n. 12
0
    def _processBodyTag(self, name, attrs):   
        if name == 'chapter':
            osisId = self._getAttributeValue(attrs,'osisID')
            if osisId is not None:
                # Start of a chapter
                # If this is the first chapter of the book, write book title and any intro

                if self._inIntro:   
                    if len(self._introText) > 0:
                        # Remove unwanted breaks at start of intro before writing
                        while self._introText.startswith('<br />'):
                            self._introText = self._introText[6:]
                        if self._bibleStarting and self._context.config.bibleIntro and not self._bibleIntroWritten:
                            self._htmlWriter.open('bible')
                            self._bibleHtmlOpen = True
                            self._closeParagraph()
                            self._writeIntroText()
                            self._bibleIntroWritten = True
                            self._introText = ''
                        elif self._firstBook and self._context.config.testamentIntro and not self._groupIntroWritten:
                            self._openGroupHtml()
                            self._closeParagraph()
                            self._writeIntroText()
                            self._introText = ''
                            self._groupIntroWritten = True
                            
                    # Ensure testament title is written
                    if self._firstBook and not self._groupTitleWritten and self._groupTitle != '':
                        self._openGroupHtml()
                    
                    self._openBookHtml()

                    if self._bookTitleFound or not self._context.config.bookTitlesInOSIS:
                        self._writeBookTitle()
                    if len(self._introText) > 0:
                        if not self._bookTitleWritten:
                            self._writeBookTitle()
                        self._introText += '<br />\n' 
                        self._writeIntroText()
                        self._introText = ''
                    self._inIntro = False
                    self._introStyleStarted = False
                
                chId = self._getAttributeValue(attrs,'sID')
                if chId is not None:
                    self._ignoreChEnd = True        # This is a milestone tag
                else:
                    self._ignoreChEnd = False       # This is an enclosing tag
                    chId = osisId
                self._docStructure.newChapter(chId)
                                
                # If a chapter/psalm heading format is defined, then write the heading
                self._chapterTitle = ''
                self._chTitleWritten = False
                self._chHeadingWritten = False
                self._startingChapter = True
                titleFormat = ''
                bookId = self._docStructure.bookId
                if bookId == 'Ps':
                    titleFormat = self._context.config.psalmTitle
                elif not self._singleChapterBook:
                    titleFormat = self._context.config.chapterTitle
                if titleFormat != '':
                    title = titleFormat % self._docStructure.chapter
                    self._chapterTitle = '<h3 chapter="%s" class="x-chapter-title">%s</h3><br />' % (self._docStructure.chapter, title)             
     
                self._bibleStarting = False
                self._firstBook = False
                
                # Do not write chapter number yet, in case there is a heading to write
            
            else:
                chId = self._getAttributeValue(attrs,'eID')
                if chId is not None:
                    self._docStructure.endChapter(chId)
                    self._writeBreak(True)
                else:
                    print 'Chapter tag does not have expected attributes - ignoring'
                    
        elif name == 'div':
            divType = self._getAttributeValue(attrs, 'type')
            if divType == 'bookGroup':
                if self._docStructure.startGroup():
                    groupNumber = self._docStructure.groupNumber
                    self._startGroup(groupNumber)

            elif divType == 'book':
                self._groupEmpty = False
                
                # Finish off any preceding Bible or testament introduction
                if self._bibleHtmlOpen or self._groupHtmlOpen:
                    self._footnotes.writeFootnotes()
                    self._htmlWriter.close()
                    self._bibleHtmlOpen = False
                    self._groupHtmlOpen = False
                
                # See which book is starting
                bookRef = self._getAttributeValue(attrs,'osisID')
                if self._docStructure.startBook(bookRef):
                    if not self._context.config.testamentGroups:
                        groupIndex = self._context.config.bookGroup(bookRef)
                        if not self._firstBook and groupIndex != self._groupIndex:
                            self._docStructure.groupNumber += 1
                            self._startGroup(self._docStructure.groupNumber)

                        self._groupIndex = groupIndex
                            
                    self._bookTitle = self._context.config.bookTitle(bookRef)
                    self._inIntro = True
                    self._introText = ''
                    self._introTextFound = False
                    self._introTitleWritten = False
                    self._bookTitleFound = False
                    self._bookTitleWritten = False
                    self._firstTitle = True
                    self._verseTextFound = False
                    print 'Processing book ', bookRef
                    if bookRef == 'Phlm' or bookRef == '2John' or bookRef == '3John' or bookRef == 'Jude' or bookRef == 'Obad':
                        self._singleChapterBook = True
                    else:
                        self._singleChapterBook = False
                    # Don't open book HTML yet, in case there is a testament introduction to write
                    
            elif divType == 'section':
                secRef = self._getAttributeValue(attrs, 'sID')
                self._docStructure.startSection(secRef)
                if secRef is not None:
                    self._ignoreDivEnd = True           # Milestone tag
                    
            elif divType == 'introduction' or divType == 'preface' or divType == 'coverPage' or divType == 'titlePage':
                if self._bibleStarting and not self._docStructure.inGroup:
                    self._introDivTextFound = False
                    if not self._bibleHtmlOpen:
                        self._htmlWriter.open('bible')
                        self._bibleHtmlOpen = True
                        self._introTextFound = False
                        self._bibleIntroWritten = True
                    self._docStructure.startIntro()
                elif self._docStructure.inGroup and self._groupEmpty:
                    self._introDivTextFound = False
                    if not self._groupHtmlOpen:
                        self._openGroupHtml()
                        self._introTextFound = False
                    self._docStructure.startIntro()
                else:
                    self._docStructure.otherDiv()
 
            else:
                secRef = self._getAttributeValue(attrs, 'eID')
                if secRef is not None:
                    divType = self._docStructure.endDiv(secRef)
                    self._ignoreDivEnd = True
                else:
                    self._docStructure.otherDiv()
                    
        elif name == 'foreign':
            verseEmpty = self._verseEmpty
            if self._inVerse:
                # prevents style being applied to verse number
                self._verseEmpty = False
            self._writeHtml('<span class="foreign">')
            self._verseEmpty = verseEmpty
              
        elif name == 'hi':
            verseEmpty = self._verseEmpty
            if self._inVerse:
                self._verseEmpty = False  # Prevents highlight being applied to verse number
            OsisHandler._handleHi(self, attrs)
            self._verseEmpty = verseEmpty
            
        elif name == 'l':
            self._lineSpan = False
            htmlTag = self._lineHtml(attrs)
            if self._inVerse and self._verseEmpty:
                if self._chNumWritten:
                    self._lineSpan = True
                    self._verseText = self._verseText + '<span class="first-line">'
                else:
                    self._verseText = htmlTag + self._verseText
            else:
                self._verseEmpty = False
                self._writeHtml(htmlTag)
                if self._introStyleStarted:
                    self._writeHtml('<span class="x-introduction">')
            
        elif name == 'lg':
            if not self._inIntro and not self._bookTitleWritten and self._bookHtmlOpen:
                self._writeBookTitle()
            if self._firstVerse and not self._chTitleWritten and not self._singleChapterBook:
                self._writeChapterTitleOrNumber()
            OsisHandler._processBodyTag(self, name, attrs)
            
        elif name == 'list':
            listType = self._getAttributeValue(attrs, 'subType')
            if listType is None and self._inIntro and self._introStyleStarted:
                htmlTag = '<ul class="x-introduction">\n'
                self._writeHtml(htmlTag)
            else:
                OsisHandler._processBodyTag(self, name, attrs)
            
        elif name == 'p':
            self._endGeneratedPara()
            if not self._inIntro and not self._bookTitleWritten and self._bookHtmlOpen:
                self._writeBookTitle()
            if self._firstVerse and not self._chTitleWritten and not self._singleChapterBook:
                self._writeChapterTitleOrNumber()
            overrideSubType = None
            if self._inVerse and self._verseEmpty and self._chNumWritten:
                overrideSubType='first-para'
            elif self._introStyleStarted:
                overrideSubType = 'x-introduction'
            paraTag = self._generateParaTag(attrs, overrideSubType)
            if 'x-introduction' in paraTag and self._inIntro:
                self._introStyleStarted = True
            self._inParagraph = True
            if self._inVerse and self._verseEmpty:
                self._verseText = paraTag + self._verseText
            else:
                self._writeHtml(paraTag)

        elif name == 'reference':
            # reference tags are expected but are ignored
            # apart from glossary references and references in footnotes
            refType = self._getAttributeValue(attrs, 'type')
            if refType == "x-glossary":
                verseEmpty = self._verseEmpty
                if self._inVerse:
                    # prevents style being applied to verse number
                    self._verseEmpty = False
                OsisHandler._processReference(self, attrs)
                self._verseEmpty = verseEmpty
    
            elif self._inFootnote and not self._footnoteMarkerWritten:
                self._inFootnoteRef = True
                osisRef = self._getAttributeValue(attrs, 'osisRef')
                if osisRef is None:
                    # reference not supplied as an attribute
                    verseRef = '%s:%s' % (self._docStructure.chapter, self._docStructure.verse)
                    self._startFootnoteAndWriteMarker(verseRef)
                elif not self._footnoteRef(osisRef):
                    # We already have a reference, so do not process contents of this reference tag
                    self._inFootnoteRef = False
                    self._inFootnote = False
                    self._ignoreText = True
                    
            elif self._figHtml != '':
                self._ignoreText = True
       
        elif name == 'title':
            canonical = self._getAttributeValue(attrs,'canonical')
            if canonical == 'true':
                # A canonical title has special treatment
                # Make sure Psalm title or number is written before the cannonical title
                if not self._bookTitleWritten:
                    self._writeBookTitle()
                if self._startingChapter and not self._chTitleWritten:
                    self._writeChapterTitleOrNumber()
                    self._startingChapter = False
                if self._inVerse:
                    # A canonical title is not part of the verse
                    self._inVerse = False
                    self._verseText = ''
                    if self._firstVerse and not self._chTitleWritten:
                        self._writeChapterTitleOrNumber()
                if self._context.canonicalClassDefined:
                    self._writeHtml('<span class="canonical">')
                else:
                    self._writeHtml('<i>')
                self._inCanonicalTitle = True
                    
            else:
                titleType = self._getAttributeValue(attrs,'type')
                if titleType == 'runningHead':
                    self._inTitle = True
                    self._ignoreTitle = True
                elif titleType == 'x-chapterLabel':
                    if self._singleChapterBook:
                        self._inTitle = True
                        self._ignoreTitle = True
                    else: 
                        self._chapterTitle = ''
                        self._inChapterTitle = True
                else:
                    level = self._getAttributeValue(attrs,'level')
                    if level is not None:
                        # Header levels 1 and 2 are for testaments and books, so titles start at 3
                        headerLevel = int(level) + 2
                    else:
                        headerLevel = self._defaultHeaderLevel
                    subType = self._getAttributeValue(attrs,'subType')
                    chapter = ''
                    if (self._context.outputFmt != 'fb2'):
                        if (not self._singleChapterBook) and (self._startingChapter or (self._inVerse and self._firstVerse and self._verseEmpty and not self._canonicalTitleWritten)):
                            if not self._chHeadingWritten:
                                chapter = ' chapter="%s"' % self._docStructure.chapter
                    if self._readyForSubtitle and headerLevel == 4:
                         self._titleTag = '<h4 class="book-subtitle">'              
                    elif subType is not None:
                        self._titleTag = '<h%d class="%s"%s>' % (headerLevel, subType, chapter)
                    else:
                        self._titleTag = '<h%d%s>' % (headerLevel, chapter)
                    self._inTitle = True
                    self._titleText = ''
                    self._readyForSubtitle = False
                    
        elif name == 'transChange':
            verseEmpty = self._verseEmpty
            if self._inVerse:
                # prevents style being applied to verse number
                self._verseEmpty = False
            self._writeHtml('<span class="transChange">')
            self._verseEmpty = verseEmpty
                    
        elif name == 'verse':
            verse = self._getAttributeValue(attrs,'sID')
            if verse is not None:
                self._startVerse(verse)
            else:
                verse = self._getAttributeValue(attrs,'eID')
                if verse is not None:
                    self._docStructure.endVerse(verse)
                    if not self._lineGroupPara:
                        self._endGeneratedPara()
                    if not self._verseEmpty:
                        if self._chHeadingWritten:
                            # remove chapter attribute from chapter number if a chapter heading has been written
                            self._verseText = re.sub(r'span chapter="\d+"', 'span', self._verseText)
                        # Add a break if immediately following a canonical title
                        if self._canonicalTitleWritten:
                            self._htmlWriter.write('<br />')
                            self._canonicalTitleWritten = False
                        self._htmlWriter.write(self._verseText + '\n')
                        self._firstVerse = False
                        self._chHeadingWritten = False
                    self._inVerse = False
                    self._verseText =''
        else:
             OsisHandler._processBodyTag(self, name, attrs)
Esempio n. 13
0
 def endElement(self, name):
     if name == 'chapter':
         if self._ignoreChEnd:
             self._ignoreChEnd = False
         else:
             self._docStructure.endChapter(self._docStructure.chapterRef)
             self._writeBreak(True)
   
     elif name == 'div':
         if self._ignoreDivEnd:
             self._ignoreDivEnd = False
         else:
             divType = self._docStructure.endDiv(None)
             if divType == self._docStructure.BOOK:
                 self._footnotes.writeFootnotes()
             elif divType == self._docStructure.GROUP:
                 if self._groupEmpty:
                     print 'Ignoring empty book group'
                     self._docStructure.groupNumber -= 1
                     self._htmlWriter.closeAndRemove()
                     self._groupHtmlOpen = False
             elif divType == self._docStructure.INTRO:
                 if self._bibleHtmlOpen:
                     self._bibleIntroWritten = True
                 elif self._groupHtmlOpen:
                     self._groupIntroWritten = True
                     
     elif name == 'figure':
         if self._inIntro:
             self._introTextFound = True
         OsisHandler.endElement(self, name)
             
     elif name == 'l':
         if self._lineSpan:
             self._writeHtml('</span>\n')
         else:
             if self._inIntro:
                 self._writeHtml('</span>')
             OsisHandler.endElement(self, name)
           
     elif name == 'note':
         if self._inFootnote:
             self._inFootnoteRef = False
         OsisHandler.endElement(self, name)
             
     elif name == 'reference':
         if self._inFootnoteRef:
             self._inFootnoteRef = False
         else:
             OsisHandler.endElement(self, name)
     
     elif name == 'title':
         if self._inTitle:
             self._inTitle = False
             if self._ignoreTitle:
                 self._ignoreTitle = False
                     
             elif self._headerProcessed:
                 titleWritten = False
                 if not self._docStructure.inBook:
                     titleWritten = self._processIntroTitle()
                 elif self._inIntro:
                     titleWritten = self._processBookIntroTitle()
                 else:
                     titleWritten = self._processScriptureTitle()                
                 if titleWritten:
                     self._breakCount = 2
                     self._psDivTitle = False
                     self._canonicalTitleWritten = False
                     if re.search('chapter', self._titleTag) is not None:
                         self._chHeadingWritten = True
             
         elif self._inCanonicalTitle:
             closingTag = ''
             if self._context.canonicalClassDefined:
                 closingTag = '</span>'
             else:
                 closingTag = '</i>' 
             self._inCanonicalTitle = False
             self._writeHtml(closingTag + '<br />\n')
             self._breakCount = 1
             self._canonicalTitleWritten = True
             if self._docStructure.verse != '':
                 self._inVerse = True
                 self._verseEmpty = True
                 if self._chTitleWritten or self._docStructure.verse != '1':
                     self._verseText = '<sup>' + self._docStructure.verse + '</sup>'
                     self._verseNumWritten = True
                     
         elif self._inChapterTitle:
             chAttribute =''
             if not self._chHeadingWritten:
                 chAttribute = 'chapter="%s" ' % self._docStructure.chapter
             self._chapterTitle = '<h3 %s class="x-chapter-title">%s</h3>' % (chAttribute, self._chapterTitle)
             if self._chFootnoteMarker != '':
                 self._chapterTitle += self._chFootnoteMarker
                 self._chFootnoteMarker = ''
             self._chapterTitle += '<br />'
             self._chHeadingWritten = True
             self._inChapterTitle = False
             
     else:
         OsisHandler.endElement(self, name)