tegaki-recognize

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Copyright (C) 2009 The Tegaki project contributors
#
# This program 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; either version 2 of the License, or
# (at your option) any later version.
#
# This program 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 this program; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

# Contributors to this file:
# - Mathieu Blondel

import base64
from optparse import OptionParser

from tegaki.character import Character
from tegaki.recognizer import Recognizer

VERSION = '0.4'

ICON = \
"""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"""

class TegakiRecognizeError(Exception):
    pass

class TegakiRecognize(object):

    def __init__(self, options):
        self._position = None
        self._hide = options.hide
        self._simple = options.simple
        self._dont_quit = options.dont_quit
        self._init_pixbuf()
        self._create_window()
        self._init_status_icon()
        self._size = None

    def _init_pixbuf(self):
        data = base64.b64decode(ICON.replace("\n", ""))
        loader = gdk.PixbufLoader()
        loader.write(data)
        loader.close()
        self._pixbuf = loader.get_pixbuf()

    def _init_status_icon(self):
        self._status_icon = gtk.StatusIcon()
        self._status_icon.set_from_pixbuf(self._pixbuf)

        self._status_icon.connect("activate", self._on_activate)
        self._status_icon.connect("popup-menu", self._on_popup)

        self._status_icon.set_visible(True)

    def _create_window(self):
        self._window = gtk.Window()
        self._window.set_icon(self._pixbuf)
        self._window.set_position(gtk.WIN_POS_CENTER)
        self._window.set_title("Tegaki")
        self._window.set_accept_focus(False)

        if self._simple:
            rw = SimpleRecognizerWidget()
        else:
            rw = SmartRecognizerWidget()
        self._window.add(rw)

        rw.connect("commit-string", self._on_commit)
        self._window.connect("delete-event", self._on_delete_event)

        # add quit button if the option "don't quit" is passed
        if self._dont_quit:
            vbox = rw.get_toolbar_vbox()
            button = gtk.Button()
            image = gtk.image_new_from_stock(gtk.STOCK_QUIT, 
                                             gtk.ICON_SIZE_BUTTON)
            button.set_image(image)
            button.connect("clicked", lambda x: gtk.main_quit())
            vbox.pack_start(button, expand=False)

        if not self._hide:
            self._window.show_all()

    def _save_window_position(self):
        self._size = self._window.get_size()
        self._position = self._window.get_position()

    def _load_window_position(self):
        if self._size and self._position:
            self._window.resize(*self._size)
            self._window.move(*self._position)

    def _on_delete_event(self, widget, event):
        if self._dont_quit:
            self._save_window_position()
            self._window.hide()
            return True # don't propagate the event
        else:
            gtk.main_quit()

    def _on_activate(self, widget):
        if self._window.get_property("visible"):
            self._save_window_position()
            self._window.hide()
        else:
            self._window.show_all()
            self._load_window_position()

    def _on_popup(self, widget, button, time):
        menu = gtk.Menu()
        quit = gtk.ImageMenuItem(gtk.STOCK_QUIT)
        quit.connect("activate", lambda x: gtk.main_quit())
        menu.append(quit)
        menu.show_all()
        menu.popup(None, None, None, button, time)

    def _on_commit(self, widget, string):
        if not send_unicode(unicode(string, "utf8")):
            # save to clipboard if send_unicode isn't supported
            clipboard = gtk.Clipboard()
            clipboard.set_text(string)

    def run(self):
        gtk.main()

def recognize(recognizer, model, fileobj):
    char = Character()
    char.read(fileobj)
    writing = char.get_writing()

    recognizers = Recognizer.get_available_recognizers()

    if not recognizer in recognizers:
        raise TegakiRecognizeError, "Not an available recognizer."

    recognizer_klass = recognizers[recognizer]
    recognizer = recognizer_klass()

    models = recognizer_klass.get_available_models()

    if not model in models:
        raise TegakiRecognizeError, "Not an available model."

    recognizer.set_model(model)

    print "\n".join(["%s %f" % (c,s) for c,s in recognizer.recognize(writing)])


usage = """usage: %prog [options] recognizer model [xmlfile]

recognizer        a recognizer available on the system

model             a model name available for that recognizer on the system
"""

parser = OptionParser(usage=usage, version="%prog " + VERSION)
parser.add_option("", "--hide",
                  action="store_true", dest="hide", default=False,
                  help="don't show window on startup")
parser.add_option("-s", "--simple",
                  action="store_true", dest="simple", default=False,
                  help="use simple recognizer instead of the smart one")
parser.add_option("-d", "--dont-quit",
                  action="store_true", dest="dont_quit", default=False,
                  help="don't quit when main window is closed")

(options, args) = parser.parse_args()

import sys

try:
    if len(args) >= 2:
        # command line
        fileobj = sys.stdin if len(args) == 2 or args[2] == "-" else open(args[2])
        recognize(args[0], args[1], fileobj)
    else:
        # GUI
        import gtk
        from gtk import gdk

        from tegakigtk.recognizer import SmartRecognizerWidget,SimpleRecognizerWidget
        from tegakigtk.fakekey import send_unicode

        TegakiRecognize(options).run()

except TegakiRecognizeError,e:
    sys.stderr.write(str(e) + "\n\n")

    sys.stderr.write("Available recognizers and models:" + "\n")
    sys.stderr.write("\n".join(["%s (%s)" % (model, recog) \
        for recog, model, meta in Recognizer.get_all_available_models()]) + "\n")