home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / share / pyshared / LanguageSelector / gtk / SimpleGladeApp.py < prev   
Encoding:
Python Source  |  2009-05-07  |  11.5 KB  |  342 lines
  1. """
  2.  SimpleGladeApp.py
  3.  Module that provides an object oriented abstraction to pygtk and libglade.
  4.  Copyright (C) 2004 Sandino Flores Moreno
  5. """
  6.  
  7. # This library is free software; you can redistribute it and/or
  8. # modify it under the terms of the GNU Lesser General Public
  9. # License as published by the Free Software Foundation; either
  10. # version 2.1 of the License, or (at your option) any later version.
  11. #
  12. # This library is distributed in the hope that it will be useful,
  13. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15. # Lesser General Public License for more details.
  16. #
  17. # You should have received a copy of the GNU Lesser General Public
  18. # License along with this library; if not, write to the Free Software
  19. # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  20. # USA
  21.  
  22. import os
  23. import sys
  24. import re
  25.  
  26. import tokenize
  27. import gtk
  28. import gtk.glade
  29. import weakref
  30. import inspect
  31.  
  32. __version__ = "1.0"
  33. __author__ = 'Sandino "tigrux" Flores-Moreno'
  34.  
  35. def bindtextdomain(app_name, locale_dir=None):
  36.     """    
  37.     Bind the domain represented by app_name to the locale directory locale_dir.
  38.     It has the effect of loading translations, enabling applications for different
  39.     languages.
  40.  
  41.     app_name:
  42.         a domain to look for translations, tipically the name of an application.
  43.  
  44.     locale_dir:
  45.         a directory with locales like locale_dir/lang_isocode/LC_MESSAGES/app_name.mo
  46.         If omitted or None, then the current binding for app_name is used.
  47.     """    
  48.     try:
  49.         import locale
  50.         import gettext
  51.         locale.setlocale(locale.LC_ALL, "")
  52.         gtk.glade.bindtextdomain(app_name, locale_dir)
  53.         gettext.install(app_name, locale_dir, unicode=1)
  54.     except (IOError,locale.Error), e:
  55.         print "Warning", app_name, e
  56.         __builtins__.__dict__["_"] = lambda x : x
  57.  
  58.  
  59. class SimpleGladeApp:
  60.  
  61.     def __init__(self, path, root=None, domain=None, **kwargs):
  62.         """
  63.         Load a glade file specified by glade_filename, using root as
  64.         root widget and domain as the domain for translations.
  65.  
  66.         If it receives extra named arguments (argname=value), then they are used
  67.         as attributes of the instance.
  68.  
  69.         path:
  70.             path to a glade filename.
  71.             If glade_filename cannot be found, then it will be searched in the
  72.             same directory of the program (sys.argv[0])
  73.  
  74.         root:
  75.             the name of the widget that is the root of the user interface,
  76.             usually a window or dialog (a top level widget).
  77.             If None or ommited, the full user interface is loaded.
  78.  
  79.         domain:
  80.             A domain to use for loading translations.
  81.             If None or ommited, no translation is loaded.
  82.  
  83.         **kwargs:
  84.             a dictionary representing the named extra arguments.
  85.             It is useful to set attributes of new instances, for example:
  86.                 glade_app = SimpleGladeApp("ui.glade", foo="some value", bar="another value")
  87.             sets two attributes (foo and bar) to glade_app.
  88.         """        
  89.         if os.path.isfile(path):
  90.             self.glade_path = path
  91.         else:
  92.             glade_dir = os.path.dirname( sys.argv[0] )
  93.             self.glade_path = os.path.join(glade_dir, path)
  94.         for key, value in kwargs.items():
  95.             try:
  96.                 setattr(self, key, weakref.proxy(value) )
  97.             except TypeError:
  98.                 setattr(self, key, value)
  99.         self.glade = None
  100.         self.install_custom_handler(self.custom_handler)
  101.         self.glade = self.create_glade(self.glade_path, root, domain)
  102.         if root:
  103.             self.main_widget = self.get_widget(root)
  104.         else:
  105.             self.main_widget = None
  106.         self.normalize_names()
  107.         self.add_callbacks(self)
  108.         self.new()
  109.  
  110.     def __repr__(self):
  111.         class_name = self.__class__.__name__
  112.         if self.main_widget:
  113.             root = gtk.Widget.get_name(self.main_widget)
  114.             repr = '%s(path="%s", root="%s")' % (class_name, self.glade_path, root)
  115.         else:
  116.             repr = '%s(path="%s")' % (class_name, self.glade_path)
  117.         return repr
  118.  
  119.     def new(self):
  120.         """
  121.         Method called when the user interface is loaded and ready to be used.
  122.         At this moment, the widgets are loaded and can be refered as self.widget_name
  123.         """
  124.         pass
  125.  
  126.     def add_callbacks(self, callbacks_proxy):
  127.         """
  128.         It uses the methods of callbacks_proxy as callbacks.
  129.         The callbacks are specified by using:
  130.             Properties window -> Signals tab
  131.             in glade-2 (or any other gui designer like gazpacho).
  132.  
  133.         Methods of classes inheriting from SimpleGladeApp are used as
  134.         callbacks automatically.
  135.  
  136.         callbacks_proxy:
  137.             an instance with methods as code of callbacks.
  138.             It means it has methods like on_button1_clicked, on_entry1_activate, etc.
  139.         """        
  140.         self.glade.signal_autoconnect(callbacks_proxy)
  141.  
  142.     def normalize_names(self):
  143.         """
  144.         It is internally used to normalize the name of the widgets.
  145.         It means a widget named foo:vbox-dialog in glade
  146.         is refered self.vbox_dialog in the code.
  147.  
  148.         It also sets a data "prefixes" with the list of
  149.         prefixes a widget has for each widget.
  150.         """
  151.         for widget in self.get_widgets():
  152.             widget_name = gtk.Widget.get_name(widget)
  153.             prefixes_name_l = widget_name.split(":")
  154.             prefixes = prefixes_name_l[ : -1]
  155.             widget_api_name = prefixes_name_l[-1]
  156.             widget_api_name = "_".join( re.findall(tokenize.Name, widget_api_name) )
  157.             gtk.Widget.set_name(widget, widget_api_name)
  158.             if hasattr(self, widget_api_name):
  159.                 raise AttributeError("instance %s already has an attribute %s" % (self,widget_api_name))
  160.             else:
  161.                 setattr(self, widget_api_name, widget)
  162.                 if prefixes:
  163.                     gtk.Widget.set_data(widget, "prefixes", prefixes)
  164.  
  165.     def add_prefix_actions(self, prefix_actions_proxy):
  166.         """
  167.         By using a gui designer (glade-2, gazpacho, etc)
  168.         widgets can have a prefix in theirs names
  169.         like foo:entry1 or foo:label3
  170.         It means entry1 and label3 has a prefix action named foo.
  171.  
  172.         Then, prefix_actions_proxy must have a method named prefix_foo which
  173.         is called everytime a widget with prefix foo is found, using the found widget
  174.         as argument.
  175.  
  176.         prefix_actions_proxy:
  177.             An instance with methods as prefix actions.
  178.             It means it has methods like prefix_foo, prefix_bar, etc.
  179.         """        
  180.         prefix_s = "prefix_"
  181.         prefix_pos = len(prefix_s)
  182.  
  183.         is_method = lambda t : callable( t[1] )
  184.         is_prefix_action = lambda t : t[0].startswith(prefix_s)
  185.         drop_prefix = lambda (k,w): (k[prefix_pos:],w)
  186.  
  187.         members_t = inspect.getmembers(prefix_actions_proxy)
  188.         methods_t = filter(is_method, members_t)
  189.         prefix_actions_t = filter(is_prefix_action, methods_t)
  190.         prefix_actions_d = dict( map(drop_prefix, prefix_actions_t) )
  191.  
  192.         for widget in self.get_widgets():
  193.             prefixes = gtk.Widget.get_data(widget, "prefixes")
  194.             if prefixes:
  195.                 for prefix in prefixes:
  196.                     if prefix in prefix_actions_d:
  197.                         prefix_action = prefix_actions_d[prefix]
  198.                         prefix_action(widget)
  199.  
  200.     def custom_handler(self,
  201.             glade, function_name, widget_name,
  202.             str1, str2, int1, int2):
  203.         """
  204.         Generic handler for creating custom widgets, internally used to
  205.         enable custom widgets (custom widgets of glade).
  206.  
  207.         The custom widgets have a creation function specified in design time.
  208.         Those creation functions are always called with str1,str2,int1,int2 as
  209.         arguments, that are values specified in design time.
  210.  
  211.         Methods of classes inheriting from SimpleGladeApp are used as
  212.         creation functions automatically.
  213.  
  214.         If a custom widget has create_foo as creation function, then the
  215.         method named create_foo is called with str1,str2,int1,int2 as arguments.
  216.         """
  217.         try:
  218.             handler = getattr(self, function_name)
  219.             return handler(str1, str2, int1, int2)
  220.         except AttributeError:
  221.             return None
  222.  
  223.     def gtk_widget_show(self, widget, *args):
  224.         """
  225.         Predefined callback.
  226.         The widget is showed.
  227.         Equivalent to widget.show()
  228.         """
  229.         widget.show()
  230.  
  231.     def gtk_widget_hide(self, widget, *args):
  232.         """
  233.         Predefined callback.
  234.         The widget is hidden.
  235.         Equivalent to widget.hide()
  236.         """
  237.         widget.hide()
  238.  
  239.     def gtk_widget_grab_focus(self, widget, *args):
  240.         """
  241.         Predefined callback.
  242.         The widget grabs the focus.
  243.         Equivalent to widget.grab_focus()
  244.         """
  245.         widget.grab_focus()
  246.  
  247.     def gtk_widget_destroy(self, widget, *args):
  248.         """
  249.         Predefined callback.
  250.         The widget is destroyed.
  251.         Equivalent to widget.destroy()
  252.         """
  253.         widget.destroy()
  254.  
  255.     def gtk_window_activate_default(self, window, *args):
  256.         """
  257.         Predefined callback.
  258.         The default widget of the window is activated.
  259.         Equivalent to window.activate_default()
  260.         """
  261.         widget.activate_default()
  262.  
  263.     def gtk_true(self, *args):
  264.         """
  265.         Predefined callback.
  266.         Equivalent to return True in a callback.
  267.         Useful for stopping propagation of signals.
  268.         """
  269.         return True
  270.  
  271.     def gtk_false(self, *args):
  272.         """
  273.         Predefined callback.
  274.         Equivalent to return False in a callback.
  275.         """
  276.         return False
  277.  
  278.     def gtk_main_quit(self, *args):
  279.         """
  280.         Predefined callback.
  281.         Equivalent to self.quit()
  282.         """
  283.         self.quit()
  284.  
  285.     def main(self):
  286.         """
  287.         Starts the main loop of processing events.
  288.         The default implementation calls gtk.main()
  289.  
  290.         Useful for applications that needs a non gtk main loop.
  291.         For example, applications based on gstreamer needs to override
  292.         this method with gst.main()
  293.  
  294.         Do not directly call this method in your programs.
  295.         Use the method run() instead.
  296.         """
  297.         gtk.main()
  298.  
  299.     def quit(self):
  300.         """
  301.         Quit processing events.
  302.         The default implementation calls gtk.main_quit()
  303.         
  304.         Useful for applications that needs a non gtk main loop.
  305.         For example, applications based on gstreamer needs to override
  306.         this method with gst.main_quit()
  307.         """
  308.         gtk.main_quit()
  309.  
  310.     def run(self):
  311.         """
  312.         Starts the main loop of processing events checking for Control-C.
  313.  
  314.         The default implementation checks wheter a Control-C is pressed,
  315.         then calls on_keyboard_interrupt().
  316.  
  317.         Use this method for starting programs.
  318.         """
  319.         try:
  320.             self.main()
  321.         except KeyboardInterrupt:
  322.             self.on_keyboard_interrupt()
  323.  
  324.     def on_keyboard_interrupt(self):
  325.         """
  326.         This method is called by the default implementation of run()
  327.         after a program is finished by pressing Control-C.
  328.         """
  329.         pass
  330.  
  331.     def install_custom_handler(self, custom_handler):
  332.         gtk.glade.set_custom_handler(custom_handler)
  333.  
  334.     def create_glade(self, glade_path, root, domain):
  335.         return gtk.glade.XML(self.glade_path, root, domain)
  336.  
  337.     def get_widget(self, widget_name):
  338.         return self.glade.get_widget(widget_name)
  339.  
  340.     def get_widgets(self):
  341.         return self.glade.get_widget_prefix("")        
  342.