#!/usr/bin/python
#
# Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import cairo
import gobject
import gtk
import sys
import time
import os


_OUTPUT_HEADER = \
'''
# AUTOMATICALLY GENERATED -- This data structure is printed out by
# BindingsSetup during execution, and modifications can be pasted from
# there back to here.
'''


class BindingsSetup:
    """Facilitate generation of the binding map for the actual
    KeyboardTest -- it takes the name of a png keyboard image file and
    optionally a corresponding bindings file as its first and second
    command line arguments, respectively.  On each assignment of a new
    binding, it will output the contents for a new bindings file to
    stdout (a bit verbose, but simple).

    UI -- select key region to be highlighted with the mouse, hit
    corresponding key, double click to active tweak mode, fine tune
    highlighted region with the arrow keys (hold shift for neg
    effect), double click to confirm and output current bindings
    datastructure, repeat."""

    # Allow tweak mode adjustment of coords using the arrow keys.
    tweak_keys = {
        0xff51 : [1, 0, 0, 0],
        0xff52 : [0, 1, 0, 0],
        0xff53 : [0, 0, 1, 0],
        0xff54 : [0, 0, 0, 1]}

    def __init__(self, kbd_image, bindings):
        self._kbd_image = kbd_image
        self._press_xy = None
        self._last_coords = None
        self._last_key = None
        self._tweak_mode = False
        self._bindings = bindings

    def fmt_coords(self, coords):
        return '%3d,%-3d %2dx%-2d' % coords

    def fmt_key(self, key):
        return '%4x,%-4x' % key

    def fmt_binding(self, binding):
        key, coords = binding
        return '0x%-4x : %s' % (key, '(%3d,%3d,%3d,%3d)' % coords)

    def tweak_coords(self, d_lft, d_top, d_rgt, d_bot):
        xmin, ymin, xdelta, ydelta = self._last_coords
        xmin -= d_lft
        ymin -= d_top
        xdelta += d_lft + d_rgt
        ydelta += d_top + d_bot
        self._last_coords = (xmin, ymin, xdelta, ydelta)

    def confirm_binding(self):
        kc, kv = self._last_key
        self._bindings[kc] = self._last_coords
        binding_list = [self.fmt_binding(b) for b in
                        sorted(self._bindings.items())]
        print _OUTPUT_HEADER
        print ('\n{\n%s\n}' % ',\n'.join('    %s' % b for b in binding_list))

    def expose_event(self, widget, event):
        context = widget.window.cairo_create()
        context.set_source_surface(self._kbd_image, 0, 0)
        context.paint()
        if self._last_coords:
            context.rectangle(*self._last_coords)
            context.set_source_rgba(0, 0.5, 0, 0.6)
            context.fill()
        return False

    def button_press_event(self, widget, event):
        if not event.button == 1:
            return False
        if self._tweak_mode:
            if event.type == gtk.gdk._2BUTTON_PRESS:
                self.confirm_binding()
                self._tweak_mode = False
                self._press_xy = None
                self._last_coords = None
                self._last_key = None
        else:
            if (event.type == gtk.gdk._2BUTTON_PRESS and
                self._last_coords and self._last_key):
                self._tweak_mode = True
                print 'tweak mode'
            else:
                self._press_xy = (event.x, event.y)
        return True

    def button_release_event(self, widget, event):
        if not event.button == 1:
            return False
        if (not self._tweak_mode) and self._press_xy:
            px, py = self._press_xy
            xmin, xmax = sorted([px, event.x])
            ymin, ymax = sorted([py, event.y])
            xdelta = xmax - xmin
            ydelta = ymax - ymin
            if xdelta and ydelta:
                self._last_coords = (xmin, ymin, xdelta, ydelta)
                print 'coords %s' % self.fmt_coords(self._last_coords)
                widget.queue_draw()
        return True

    def key_press_event(self, widget, event):
        key = (event.keyval, event.hardware_keycode)
        if self._tweak_mode:
            delta = BindingsSetup.tweak_keys.get(event.keyval)
            if delta:
                if 'GDK_SHIFT_MASK' in event.state.value_names:
                    # Reverse the effect if SHIFT is being held down.
                    delta = map((lambda x: 0 - x), delta)
                self.tweak_coords(*delta)
                print 'tweak %s --> %s' % (self.fmt_key(self._last_key),
                                           self.fmt_coords(self._last_coords))
                widget.queue_draw()
        else:
            self._last_key = key
            print 'key    %s %s' % (self.fmt_key(key), repr(event.string))
        return True

def main():
    window = gtk.Window(gtk.WINDOW_TOPLEVEL)
    window.connect('destroy', lambda w: gtk.main_quit())

    window.set_default_size(981, 450)

    bg_color = gtk.gdk.color_parse('midnight blue')
    window.modify_bg(gtk.STATE_NORMAL, bg_color)

    kbd_image = cairo.ImageSurface.create_from_png(sys.argv[1])
    kbd_image_size = (kbd_image.get_width(), kbd_image.get_height())

    bindings = {}
    if len(sys.argv) == 3 and os.path.exists(sys.argv[2]):
        f = open(sys.argv[2], 'r')
        bindings = eval(f.read())
        f.close()

    drawing_area = gtk.DrawingArea()
    drawing_area.set_size_request(*kbd_image_size)

    kt = BindingsSetup(kbd_image, bindings)
    window.connect('key-press-event', kt.key_press_event)
    drawing_area.connect('button_release_event', kt.button_release_event)
    drawing_area.connect('button_press_event', kt.button_press_event)
    drawing_area.connect('expose_event', kt.expose_event)

    drawing_area.show()

    align = gtk.Alignment(xalign=0.5, yalign=0.5)
    align.add(drawing_area)
    align.show()

    drawing_area.set_events(gtk.gdk.EXPOSURE_MASK |
                            gtk.gdk.KEY_PRESS_MASK |
                            gtk.gdk.BUTTON_PRESS_MASK |
                            gtk.gdk.BUTTON_RELEASE_MASK)

    window.add(align)
    window.show()

    gtk.main()

if __name__ == '__main__':
    main()