id = N_("Version Comparison")

has_menu = False

shows_info = False

def __init__(self, parent, book):

self.mod = None

super(VerseCompareFrame, self).__init__(parent)

self.SetBook(book)

def SetReference(self, ref, reload=False, settings_changed=False):

if not ref:

return

last_reference = verse_comparison_settings["reference"]

if VerseList(last_reference).VerseInRange(ref):

ref = last_reference

if ref == self.reference and not reload: return

text = "<h3>%s</h3>" % ref

self.reference = ref

verse_comparison_settings["reference"] = ref

text_func = [

self.get_compare_text,

self.get_parallel_text

][verse_comparison_settings["parallel"]]

self.SetPage(text_func(ref))

self.gui_reference.SetValue(GetBestRange(ref, userOutput=True))

self.gui_reference.currentverse = ref

self.update_title()

def get_parallel_text(self, ref):

vk = SW.VerseKey()

verselist = vk.ParseVerseList(to_str(ref), "", True)

items = []

text = ["<table class='parallel_view'>", "<tr>"]

for item in self.book.GetModules():

name = item.Name()

if name in verse_comparison_settings["comparison_modules"]:

items.append((

item,

list(self.book.GetReference_yield(

verselist, module=item, max_verses=176, skip_linked_verses=False

))

))

text.append(u"<th>%s</th>" % process_html_for_module(item,

u"<b><a href='%s:%s'>"

"%s</a></b>" % (BIBLE_VERSION_PROTOCOL, name, name))

)

text.append("</tr>")

# if we have no bibles to compare, return the empty string

if not items:

return ""

rows = []

was_clipped = False

try:

self.book.templatelist.append(config.parallel_template)

while True:

text.append("<tr>")

for module, refs in items:

if not refs:

text.append("</tr>")

break

body_dict, headings = refs.pop(0)

if not body_dict:

was_clipped = True

# remove opening row

text.pop()

break

text_direction = get_module_css_text_direction(module)

text.append(u'<td class="parallel_verse" module="%s" dir="%s">' % (module.Name(), text_direction))

t = ""

for heading_dict in headings:

t += biblemgr.bible.templatelist[-1].\

headings.safe_substitute(heading_dict)

t += biblemgr.bible.templatelist[-1].\

body.safe_substitute(body_dict)

t = process_html_for_module(module, t)

text.append(t)

text.append("</td>")

else:

text.append("</tr>")

continue

break

finally:

self.book.templatelist.pop()

text.append("</table>")

if was_clipped:

text.append(config.MAX_VERSES_EXCEEDED() % 177)

return ''.join(text)

def get_compare_text(self, ref):

text = ""

mod = self.book.mod

try:

self.book.templatelist.append(config.verse_compare_template)

for item in self.book.GetModules():

if item.Name() in \

verse_comparison_settings["comparison_modules"]:

self.book.mod = item

# We exclude tags since otherwise the same tags appear in

# every version, which isn't very sensible.

module_text = process_html_for_module(item,

self.book.GetReference(ref, display_tags=False)

)

text += u'<span class="parallel_verse" module="%s">%s</span>' % (item.Name(), module_text)

finally:

self.book.mod = mod

self.book.templatelist.pop()

return text

def update_title(self, shown=None):

m = guiconfig.mainfrm

p = m.get_pane_for_frame(self)

ref = GetBestRange(self.reference, userOutput=True)

text = "%s - %s" % (self.title, ref)

m.set_pane_title(p.name, text)

def get_menu_items(self, event=None):

actions = super(VerseCompareFrame, self).get_menu_items(event)

actions = (

(MenuItem(

_("Set books to compare"),

self.set_versions,

doc=_("Set the books this version comparison will use")

), IN_POPUP),

) + actions

return actions

def set_versions(self):

modules = self.book.GetModuleList()

mcd = MultiChoiceDialog(guiconfig.mainfrm,

_("Choose books to compare in the verse comparison window"),

_("Choose books"),

choices=modules)

selections = [idx for idx, module in enumerate(modules)

if module in verse_comparison_settings["comparison_modules"]]

mcd.SetSelections(selections)

if mcd.ShowModal() == wx.ID_OK:

verse_comparison_settings["comparison_modules"] = [

modules[idx] for idx in mcd.GetSelections()

]

self.reload()

mcd.Destroy()

get_verified = BookFrame.get_verified_multi_verses

def create_toolbar_items(self):

super(VerseCompareFrame, self).create_toolbar_items()

self.gui_book_choice = self.toolbar.InsertTool(3, wx.ID_ANY,

guiutil.bmp("book.png"),

shortHelpString=_("Choose books to compare")

)

self.gui_parallel = self.toolbar.InsertTool(4, wx.ID_ANY,

guiutil.bmp("text_columns.png"),

isToggle=True,

shortHelpString=_("View in parallel mode")

)

self.toolbar.ToggleTool(self.gui_parallel.Id,

verse_comparison_settings["parallel"]

)

self.toolbar.InsertSeparator(5)

self.toolbar.Bind(wx.EVT_TOOL, self.on_parallel_toggle,

id=self.gui_parallel.Id)

self.toolbar.Bind(wx.EVT_TOOL, lambda evt:self.set_versions(),

id=self.gui_book_choice.Id)

def on_parallel_toggle(self, event):

verse_comparison_settings["parallel"] = event.Checked()

self.reload()

def reload(self):

self.SetReference(self.reference, reload=True)

refresh = reload

def get_reference_textbox(self):

return self.gui_reference

def get_module_for_strongs_search(self, element):

"""Finds which Bible in the comparison window this Strongs number is

associated with, and returns it.

This ensures that the search will be made against a version with

Strongs numbers.

"""

def get_attribute(element, attribute_name):

attributes = element.GetAttributes()

attribute = attributes.GetNamedItem(attribute_name)

return attribute.GetNodeValue()

while element.IsOk():

if get_attribute(element, "class") == "parallel_verse":

return get_attribute(element, "module")