| # Copyright (c) 2012 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. |
| |
| """This module provides GUI for touch device firmware test using GTK.""" |
| |
| import os |
| import re |
| import shutil |
| |
| import gobject |
| import gtk |
| import gtk.gdk |
| import pango |
| import tempfile |
| |
| import common_util |
| import firmware_utils |
| import test_conf as conf |
| |
| from firmware_constants import TFK |
| |
| |
| TITLE = "Touch Firmware Test" |
| |
| |
| class BaseFrame(object): |
| """A simple base frame class.""" |
| def __init__(self, label=None, size=None, aspect=False): |
| # Create a regular/aspect frame |
| self.frame = gtk.AspectFrame() if aspect else gtk.Frame() |
| self.frame.set_shadow_type(gtk.SHADOW_ETCHED_OUT) |
| self.size = size |
| if label: |
| self.frame.set_label(label) |
| self.frame.set_label_align(0.0, 0.0) |
| frame_label = self.frame.get_label_widget() |
| markup_str = '<span foreground="%s" size="x-large">%s</span>' |
| frame_label.set_markup(markup_str % ('black', label)) |
| if size: |
| width, height = size |
| self.frame.set_size_request(width, height) |
| if aspect: |
| self.frame.set(ratio=(float(width) / height)) |
| |
| |
| class PromptFrame(BaseFrame): |
| """A simple frame widget to display the prompt. |
| |
| It consists of: |
| - A frame |
| - a label showing the gesture name |
| - a label showing the prompt |
| - a label showing the keyboard interactions |
| """ |
| |
| def __init__(self, label=None, size=None): |
| super(PromptFrame, self).__init__(label, size) |
| |
| # Create a vertical packing box. |
| self.vbox = gtk.VBox(False, 0) |
| self.frame.add(self.vbox) |
| |
| # Create a label to show the gesture name |
| self.label_gesture = gtk.Label('Gesture Name') |
| self.label_gesture.set_justify(gtk.JUSTIFY_LEFT) |
| self.vbox.pack_start(self.label_gesture, True, True, 0) |
| # Expand the lable to be wider and wrap the line if necessary. |
| if self.size: |
| _, label_height = self.label_gesture.get_size_request() |
| width, _ = self.size |
| label_width = int(width * 0.9) |
| self.label_gesture.set_size_request(label_width, label_height) |
| self.label_gesture.set_line_wrap(True) |
| |
| # Pack a horizontal separator |
| self.vbox.pack_start(gtk.HSeparator(), True, True, 0) |
| |
| # Create a label to show the prompt |
| self.label_prompt = gtk.Label('Prompt') |
| self.label_prompt.set_justify(gtk.JUSTIFY_CENTER) |
| self.vbox.pack_start(self.label_prompt, True, True, 0) |
| |
| # Create a label to show the choice |
| self.label_choice = gtk.Label('') |
| self.label_choice.set_justify(gtk.JUSTIFY_LEFT) |
| self.vbox.pack_start(self.label_choice, True, True, 0) |
| |
| # Show all widgets added to this frame |
| self.frame.show_all() |
| |
| def set_gesture_name(self, string, color='blue'): |
| """Set the gesture name in label_gesture.""" |
| markup_str = '<b><span foreground="%s" size="xx-large"> %s </span></b>' |
| self.label_gesture.set_markup(markup_str % (color, string)) |
| |
| def set_prompt(self, string, color='black'): |
| """Set the prompt in label_prompt.""" |
| markup_str = '<span foreground="%s" size="x-large"> %s </span>' |
| self.label_prompt.set_markup(markup_str % (color, string)) |
| |
| def set_choice(self, string): |
| """Set the choice in label_choice.""" |
| self.label_choice.set_text(string) |
| |
| |
| class ResultFrame(BaseFrame): |
| """A simple frame widget to display the test result. |
| |
| It consists of: |
| - A frame |
| - a scrolled window |
| - a label showing the test result |
| """ |
| SCROLL_STEP = 100.0 |
| |
| def __init__(self, label=None, size=None): |
| super(ResultFrame, self).__init__(label, size) |
| |
| # Create a scrolled window widget |
| self.scrolled_window = gtk.ScrolledWindow() |
| self.scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, |
| gtk.POLICY_AUTOMATIC) |
| self.frame.add(self.scrolled_window) |
| |
| # Create a vertical packing box. |
| self.vbox = gtk.VBox(False, 0) |
| self.scrolled_window.add_with_viewport(self.vbox) |
| |
| # Create a label to show the gesture name |
| self.result = gtk.Label() |
| self.vbox.pack_start(self.result , False, False, 0) |
| |
| # Show all widgets added to this frame |
| self.frame.show_all() |
| |
| # Get the vertical and horizontal adjustments |
| self.vadj = self.scrolled_window.get_vadjustment() |
| self.hadj = self.scrolled_window.get_hadjustment() |
| |
| self._scroll_func_dict = {TFK.UP: self._scroll_up, |
| TFK.DOWN: self._scroll_down, |
| TFK.LEFT: self._scroll_left, |
| TFK.RIGHT: self._scroll_right} |
| |
| def _calc_result_font_size(self): |
| """Calculate the font size so that it does not overflow.""" |
| label_width_in_px, _ = self.size |
| font_size = int(float(label_width_in_px) / conf.num_chars_per_row * |
| pango.SCALE) |
| return font_size |
| |
| def set_result(self, text, color='black'): |
| """Set the text in the result label.""" |
| mod_text = re.sub('<', '<', text) |
| mod_text = re.sub('>', '>', mod_text) |
| markup_str = '<b><span foreground="%s" size="%d"> %s </span></b>' |
| font_size = self._calc_result_font_size() |
| self.result.set_markup(markup_str % (color, font_size, mod_text)) |
| |
| def _calc_inc_value(self, adj): |
| """Calculate new increased value of the specified adjustement object.""" |
| value = adj.get_value() |
| new_value = min(value + self.SCROLL_STEP, adj.upper - adj.page_size) |
| return new_value |
| |
| def _calc_dec_value(self, adj): |
| """Calculate new decreased value of the specified adjustement object.""" |
| value = adj.get_value() |
| new_value = max(value - self.SCROLL_STEP, adj.lower) |
| return new_value |
| |
| def _scroll_down(self): |
| """Scroll the scrolled_window down.""" |
| self.vadj.set_value(self._calc_inc_value(self.vadj)) |
| |
| def _scroll_up(self): |
| """Scroll the scrolled_window up.""" |
| self.vadj.set_value(self._calc_dec_value(self.vadj)) |
| |
| def _scroll_right(self): |
| """Scroll the scrolled_window to the right.""" |
| self.hadj.set_value(self._calc_inc_value(self.hadj)) |
| |
| def _scroll_left(self): |
| """Scroll the scrolled_window to the left.""" |
| self.hadj.set_value(self._calc_dec_value(self.hadj)) |
| |
| def scroll(self, choice): |
| """Scroll the result frame using the choice key.""" |
| scroll_method = self._scroll_func_dict.get(choice) |
| if scroll_method: |
| scroll_method() |
| else: |
| print 'Warning: the key choice "%s" is not legal!' % choice |
| |
| |
| class ImageFrame(BaseFrame): |
| """A simple frame widget to display the mtplot window. |
| |
| It consists of: |
| - An aspect frame |
| - an image widget showing mtplot |
| """ |
| |
| def __init__(self, label=None, size=None): |
| super(ImageFrame, self).__init__(label, size, aspect=True) |
| |
| # Use a fixed widget to display the image. |
| self.fixed = gtk.Fixed() |
| self.frame.add(self.fixed) |
| |
| # Create an image widget. |
| self.image = gtk.Image() |
| self.fixed.put(self.image, 0, 0) |
| |
| # Show all widgets added to this frame |
| self.frame.show_all() |
| |
| def set_from_file(self, filename): |
| """Set the image file.""" |
| self.image.set_from_file(filename) |
| self.frame.show_all() |
| |
| |
| class FirmwareWindow(object): |
| """A simple window class to display the touch firmware test window.""" |
| |
| def __init__(self, size=None, prompt_size=None, result_size=None, |
| image_size=None): |
| # Setup gtk environment correctly. |
| self._setup_gtk_environment() |
| |
| # Create a new window |
| self.win = gtk.Window(gtk.WINDOW_TOPLEVEL) |
| if size: |
| self.win_size = size |
| self.win.resize(*size) |
| self.win.set_title(TITLE) |
| self.win.set_border_width(0) |
| |
| # Create the prompt frame |
| self.prompt_frame = PromptFrame(TITLE, prompt_size) |
| |
| # Create the result frame |
| self.result_frame = ResultFrame("Test results:", size=result_size) |
| |
| # Create the image frame for mtplot |
| self.image_frame = ImageFrame(size=image_size) |
| |
| # Handle layout below |
| self.box0 = gtk.VBox(False, 0) |
| self.box1 = gtk.HBox(False, 0) |
| # Arrange the layout about box0 |
| self.win.add(self.box0) |
| self.box0.pack_start(self.prompt_frame.frame, True, True, 0) |
| self.box0.pack_start(self.box1, True, True, 0) |
| # Arrange the layout about box1 |
| self.box1.pack_start(self.image_frame.frame, True, True, 0) |
| self.box1.pack_start(self.result_frame.frame, True, True, 0) |
| |
| # Capture keyboard events. |
| self.win.add_events(gtk.gdk.KEY_PRESS_MASK | gtk.gdk.KEY_RELEASE_MASK) |
| |
| # Set a handler for delete_event that immediately exits GTK. |
| self.win.connect("delete_event", self.delete_event) |
| |
| # Show all widgets. |
| self.win.show_all() |
| |
| def _setup_gtk_environment(self): |
| """Set up the gtk environment correctly.""" |
| |
| def _warning(msg=None): |
| print 'Warning: fail to setup gtk environment.' |
| if msg: |
| print '\t' + msg |
| print '\tImage files would not be shown properly.' |
| print '\tIt does not affect the test results though.' |
| |
| def _make_symlink(path, symlink): |
| """Remove the symlink if exists. Create a new symlink to point to |
| the given path. |
| """ |
| if os.path.islink(symlink): |
| os.remove(symlink) |
| os.symlink(real_gtk_dir, self.gtk_symlink) |
| self.new_symlink = True |
| |
| self.gtk_symlink = None |
| self.tmp = tempfile.mkdtemp() |
| self.moved_flag = False |
| self.original_gtk_realpath = None |
| self.new_symlink = False |
| |
| # Get LoaderDir: |
| # The output of gdk-pixbuf-query-loaders looks like: |
| # |
| # GdkPixbuf Image Loader Modules file |
| # Automatically generated file, do not edit |
| # Created by gdk-pixbuf-query-loaders from gtk+-2.20.1 |
| # |
| # LoaderDir = /usr/lib64/gtk-2.0/2.10.0/loaders |
| loader_dir_str = common_util.simple_system_output( |
| 'gdk-pixbuf-query-loaders | grep LoaderDir') |
| result = re.search('(/.*?)/(gtk-.*?)/', loader_dir_str) |
| if result: |
| prefix = result.group(1) |
| self.gtk_version = result.group(2) |
| else: |
| _warning('Cannot derive gtk version from LoaderDir.') |
| return |
| |
| # Verify the existence of the loaders file. |
| gdk_pixbuf_loaders = ('/usr/local/etc/%s/gdk-pixbuf.loaders' % |
| self.gtk_version) |
| if not os.path.isfile(gdk_pixbuf_loaders): |
| msg = 'The loaders file "%s" does not exist.' % gdk_pixbuf_loaders |
| _warning(msg) |
| return |
| |
| # Setup the environment variable for GdkPixbuf Image Loader Modules file |
| # so that gtk library could find it. |
| os.environ['GDK_PIXBUF_MODULE_FILE'] = gdk_pixbuf_loaders |
| |
| # In the loaders file, it specifies the paths of various |
| # sharable objects (.so) which are used to load images of corresponding |
| # image formats. For example, for png loader, the path looks like |
| # |
| # "/usr/lib64/gtk-2.0/2.10.0/loaders/libpixbufloader-png.so" |
| # "png" 5 "gtk20" "The PNG image format" "LGPL" |
| # "image/png" "" |
| # "png" "" |
| # "\211PNG\r\n\032\n" "" 100 |
| # |
| # However, the real path for the .so file is under |
| # "/usr/local/lib64/..." |
| # Hence, we would like to make a temporary symlink so that |
| # gtk library could find the .so file correctly. |
| self.gtk_symlink = os.path.join(prefix, self.gtk_version) |
| prefix_list = prefix.split('/') |
| prefix_list.insert(prefix_list.index('usr') + 1, 'local') |
| real_gtk_dir = os.path.join('/', *(prefix_list + [self.gtk_version])) |
| |
| # Make sure that the directory of .so files does exist. |
| if not os.path.isdir(real_gtk_dir): |
| msg = 'The directory of gtk image loaders "%s" does not exist.' |
| _warning(msg % real_gtk_dir) |
| return |
| |
| # Take care of an existing symlink. |
| if os.path.islink(self.gtk_symlink): |
| # If the symlink does not point to the correct path, |
| # save the real path of the symlink and re-create the symlink. |
| if not os.path.samefile(self.gtk_symlink, real_gtk_dir): |
| self.original_gtk_realpath = os.path.realpath(self.gtk_symlink) |
| _make_symlink(real_gtk_dir, self.gtk_symlink) |
| |
| # Take care of an existing directory. |
| elif os.path.isdir(self.gtk_symlink): |
| # Move the directory only if it is not what we expect. |
| if not os.path.samefile(self.gtk_symlink, real_gtk_dir): |
| shutil.move(self.gtk_symlink, self.tmp) |
| self.moved_flag = True |
| _make_symlink(real_gtk_dir, self.gtk_symlink) |
| |
| # Take care of an existing file. |
| # Such a file is not supposed to exist here. Move it anyway. |
| elif os.path.isfile(self.gtk_symlink): |
| shutil.move(self.gtk_symlink, self.tmp) |
| self.moved_flag = True |
| _make_symlink(real_gtk_dir, self.gtk_symlink) |
| |
| # Just create the temporary symlink since there is nothing here. |
| else: |
| _make_symlink(real_gtk_dir, self.gtk_symlink) |
| |
| def close(self): |
| """Cleanup by restoring any symlink, file, or directory if necessary.""" |
| # Remove the symlink that the test created. |
| if self.new_symlink: |
| os.remove(self.gtk_symlink) |
| |
| # Restore the original symlink. |
| if self.original_gtk_realpath: |
| os.symlink(self.original_gtk_realpath, self.gtk_symlink) |
| # Restore the original file or directory. |
| elif self.moved_flag: |
| tmp_gtk_path = os.path.join(self.tmp, self.gtk_version) |
| if (os.path.isdir(tmp_gtk_path) or os.path.isfile(tmp_gtk_path)): |
| shutil.move(tmp_gtk_path, os.path.dirname(self.gtk_symlink)) |
| self.moved_flag = False |
| shutil.rmtree(self.tmp) |
| |
| def register_callback(self, event, callback): |
| """Register a callback function for an event.""" |
| self.win.connect(event, callback) |
| |
| def register_timeout_add(self, callback, timeout): |
| """Register a callback function for gobject.timeout_add.""" |
| return gobject.timeout_add(timeout, callback) |
| |
| def register_io_add_watch(self, callback, fd, data=None, |
| condition=gobject.IO_IN): |
| """Register a callback function for gobject.io_add_watch.""" |
| if data: |
| return gobject.io_add_watch(fd, condition, callback, data) |
| else: |
| return gobject.io_add_watch(fd, condition, callback) |
| |
| def create_key_press_event(self, keyval): |
| """Create a key_press_event.""" |
| event = gtk.gdk.Event(gtk.gdk.KEY_PRESS) |
| # Assign current time to the event |
| event.time = 0 |
| event.keyval = keyval |
| self.win.emit('key_press_event', event) |
| |
| def remove_event_source(self, tag): |
| """Remove the registered callback.""" |
| gobject.source_remove(tag) |
| |
| def delete_event(self, widget, event, data=None): |
| """A handler to exit the window.""" |
| self.stop() |
| return False |
| |
| def set_gesture_name(self, string, color='blue'): |
| """A helper method to set gesture name.""" |
| self.prompt_frame.set_gesture_name(string, color) |
| |
| def set_prompt(self, string, color='black'): |
| """A helper method to set the prompt.""" |
| self.prompt_frame.set_prompt(string, color) |
| |
| def set_choice(self, string): |
| """A helper method to set the choice.""" |
| self.prompt_frame.set_choice(string) |
| |
| def set_result(self, text): |
| """A helper method to set the text in the result.""" |
| self.result_frame.set_result(text) |
| |
| def set_image(self, filename): |
| """Set an image in the image frame.""" |
| self.image_frame.set_from_file(filename) |
| |
| def scroll(self, choice): |
| """Scroll the result frame using the choice key.""" |
| self.result_frame.scroll(choice) |
| |
| def stop(self): |
| """Quit the window.""" |
| self.close() |
| gtk.main_quit() |
| |
| def main(self): |
| """Main function of the window.""" |
| try: |
| gtk.main() |
| except KeyboardInterrupt: |
| self.close() |
