Ticket #4176: latex.py

# -*- coding: utf-8 -*-
## This file is part of Gajim.
##
## Gajim is free software; you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published
## by the Free Software Foundation; version 3 only.
##
## Gajim is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
## GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with Gajim.  If not, see <http://www.gnu.org/licenses/>.
##

'''
LaTeX Plugin.

based on Acronym Plugin by Mateusz Biliński
:author: Yves Fischer <yvesf@xapek.org>
:since: 17th June 2008
:copyright: Copyright (2008) Yves Fischer
:license: GPL
'''


from threading import Thread
from random import random
import sys,gtk,gobject

gtk.gdk.threads_init() ##for gtk.gdk.thread_[enter|leave]()


#following constants are taken from Pidgin Latex Plugin
def latex_template(code):
        return """\\documentclass[12pt]{article}
\\usepackage[dvips]{graphicx}
\\usepackage{amsmath}
\\usepackage{amssymb}
\\pagestyle{empty}
\\begin{document}
\\begin{gather*}
%s
\\end{gather*}
\\end{document}""" % (code)


#used in pidgin-latex, necessary in gajim?
"""
FILTER_AND="&amp;"
FILTER_LT= "&lt;"
FILTER_GT="&gt;"
FILTER_BR="<br>"
"""

""" 
Yes, this is simply a copy/paste of KopeteTex blacklist.
But too bad in LaTeX and system security to verify all 
of this
"""
BLACKLIST=[
        "\def",
        "\\let",
        "\\futurelet",
        "\\newcommand",
        "\\renewcomment",
        "\\else",
        "\\fi",
        "\\write",
        "\\input",
        "\\include",
        "\\chardef",
        "\\catcode",
        "\\makeatletter",
        "\\noexpand",
        "\\toksdef",
        "\\every",
        "\\errhelp",
        "\\errorstopmode",
        "\\scrollmode",
        "\\nonstopmode",
        "\\batchmode",
        "\\read",
        "\\csname",
        "\\newhelp",
        "\\relax",
        "\\afterground",
        "\\afterassignment",
        "\\expandafter",
        "\\noexpand",
        "\\special",
        "\\command",
        "\\loop",
        "\\repeat",
        "\\toks",
        "\\output",
        "\\line",
        "\\mathcode",
        "\\name",
        "\\item",
        "\\section",
        "\\mbox",
        "\\DeclareRobustCommand"
]




"""

"""
class LatexRenderer(Thread):
        def __init__(self, iter_start, iter_end, buffer, widget):
                Thread.__init__(self)

                self.code = iter_start.get_text(iter_end)
                self.mark_name = "LatexRendererMark%d" % (int(random() * 100000))
                self.mark = buffer.create_mark(self.mark_name, iter_start, True)

                self.buffer = buffer
                self.widget = widget

                #delete code and show message "processing"
                self.buffer.delete(iter_start, iter_end)
                #iter_start.forward_char()
                self.buffer.insert(iter_start, "Processing LaTeX")

                self.start() #start background processing

        def run(self):
                gtk.gdk.threads_enter() #its nearly non-sense using this in a full thread
                #should be fine-grained later
                try:
                        if self.check_code():
                                self.show_image()
                        else:
                                self.show_error("There are bad commands!")
                except:
                        pass
                finally:
                        gtk.gdk.threads_leave()
                        self.buffer.delete_mark(self.mark)

        def show_error(self, message):
                iter_mark = self.buffer.get_iter_at_mark(self.mark)
                iter_end = iter_mark.copy().forward_search("Processing LaTeX", gtk.TEXT_SEARCH_TEXT_ONLY)[1]
                self.buffer.delete(iter_mark, iter_end)


                pixbuf = self.widget.render_icon(gtk.STOCK_STOP, gtk.ICON_SIZE_BUTTON)
                self.buffer.insert_pixbuf(iter_end, pixbuf)
                self.buffer.insert(iter_end, message)

        def show_image(self):
                from os import system
                fn = "/tmp/gajim_latex-" + str(int(random() * 100000))

                f = open(fn+".tex", 'w')
                f.write(latex_template(self.code.split("$$")[1]))
                f.close()

                system("latex --interaction=nonstopmode -output-directory=/tmp -output-format=dvi %s.tex" % fn)

                system("dvipng -T tight -x 1200 -z 9 -bg transparent -o %s.png %s.dvi" % (fn, fn))

                try:
                        pixbuf = gtk.gdk.pixbuf_new_from_file(fn + ".png")
                        iter_mark = self.buffer.get_iter_at_mark(self.mark)
                        iter_end = iter_mark.copy().forward_search("Processing LaTeX", gtk.TEXT_SEARCH_TEXT_ONLY)[1]
                        self.buffer.delete(iter_mark, iter_end)

                        self.buffer.insert_pixbuf(iter_end, pixbuf)
                except gobject.GError:
                        self.show_error("Cant open %s.png, something around invoking latex goes wrong" % fn)
                finally:
                        system("rm -vf %s.png %s.log %s.aux %s.tex" % (fn, fn, fn, fn))

        def check_code(self):
                for bad_cmd in BLACKLIST:
                        if self.code.find(bad_cmd) != -1:
                                print "Found bad command %s" % bad_cmd
                                return False
                return True



class LatexPluginConfiguration(gtk.Window):
        def __init__(self):
                gtk.Window.__init__(self)
                self.set_title("Latex Plugin Configuration")
                
                self.pane = gtk.VBox()
                self.add(self.pane)

                self.btn_test = gtk.Button("Test Latex Configuration")
                self.btn_test.connect("clicked", self.start_test)
                self.pane.pack_start(self.btn_test,expand=False)

                self.lbl_messages = gtk.Label("Results:\n")
                self.lbl_messages.set_line_wrap(True)
                self.pane.pack_start(self.lbl_messages)

        def log(self, message):
                self.lbl_messages.set_text(self.lbl_messages.get_text() + "\n" + message)

        
        """
        performs very simple checks (check if executable is in PATH)
        """
        def start_test(self,widget):
                log = self.log
                from os import system
                log("Start Test")
                log("Test Latex Binary")
                ret = system("latex -version")
                if ret != 0:
                        log("No LaTeX binary found in PATH")
                else:
                        log("OK")
                log("Test dvipng")
                ret = system("dvipng --version")
                if ret != 0:
                        log("No dvipng binary found in PATH")
                else:
                        log("OK")

        def run(self,parent):
                self.present()
                self.show_all()


from plugins import GajimPlugin
from plugins.helpers import log, log_calls


class LatexPlugin(GajimPlugin):
        name = u'Latex Plugin'
        short_name = u'latex'
        version = u'0.1'
        description = u'''Invoke Latex to render $$foobar$$ sourrounded Latex equations. Needs latex and dvipng'''
        authors = [u'Yves Fischer <yvesf@xapek.org>']
        homepage = u'http://xapek.org'


        def init(self):
                print "init LatexPlugin"
                self.config_dialog = LatexPluginConfiguration()
                
                self.gui_extension_points = {
                        'chat_control_base' : (self.connect_with_chat_control_base,
                                                                   self.disconnect_from_chat_control_base)
                }

        """
        start rendering if clicked on a link
        """
        @log_calls('LatexPlugin')
        def textview_event_after(self, tag, widget, event, iter):
                if tag.get_property("name") != "latex" or event.type != gtk.gdk.BUTTON_PRESS:
                        return
                dollar_start, iter_start = iter.backward_search("$$", gtk.TEXT_SEARCH_TEXT_ONLY)
                iter_end, dollar_end = iter.forward_search("$$", gtk.TEXT_SEARCH_TEXT_ONLY)
                #code = iter_start.get_text(iter_end)
                #widget.get_buffer().delete(dollar_start, dollar_end)
                #pixbuf = widget.render_icon(gtk.STOCK_EXECUTE, gtk.ICON_SIZE_BUTTON)
                #widget.get_buffer().insert_pixbuf(dollar_start, pixbuf)
                LatexRenderer(dollar_start, dollar_end, widget.get_buffer(), widget)

        """
        called when conversation text widget changes
        """
        @log_calls('AcronymsExpanderPlugin')
        def textbuffer_live_latex_expander(self, tb):
                def split_list(list):
                        newlist = []
                        for i in range(0,len(list)-1,2):
                                newlist.append( [ list[i], list[i+1], ] )
                        return newlist

                assert isinstance(tb,gtk.TextBuffer)
                start_iter = tb.get_start_iter()
                points = []
                tuple_found = start_iter.forward_search("$$", gtk.TEXT_SEARCH_TEXT_ONLY)
                while tuple_found != None:
                        points.append(tuple_found)
                        tuple_found = tuple_found[1].forward_search("$$", gtk.TEXT_SEARCH_TEXT_ONLY)

                for pair in split_list(points):
                        tb.apply_tag_by_name("latex", pair[0][1], pair[1][0])

        @log_calls('AcronymsExpanderPlugin')
        def connect_with_chat_control_base(self, chat_control):
                d = {}
                tv = chat_control.conv_textview.tv
                tb = tv.get_buffer()

                self.latex_tag = gtk.TextTag("latex")
                self.latex_tag.set_property('foreground', "blue")
                self.latex_tag.set_property('underline', "single")
                d['tag_id'] = self.latex_tag.connect('event', self.textview_event_after)                
                tb.get_tag_table().add(self.latex_tag)

                d['h_id'] = tb.connect('changed', self.textbuffer_live_latex_expander)
                chat_control.latexs_expander_plugin_data = d

                return True

        @log_calls('AcronymsExpanderPlugin')
        def disconnect_from_chat_control_base(self, chat_control):
                d = chat_control.latexs_expander_plugin_data
                #tv = chat_control.msg_textview
                tv = chat_control.conv_textview.tv

                tv.get_buffer().disconnect(d['h_id'])
                self.latex_tag.disconnect(d['tag_id'])