* add avahi-utils in autoconf

git-svn-id: file:///home/lennart/svn/public/avahi/trunk@211 941a03a8-eaeb-0310-b9a0-b1bbd8fe43fe

9 files changed, 357 insertions, 129 deletions

diff --git a/avahi-utils/Makefile.am b/avahi-utils/Makefile.am
new file mode 100644
index 0000000..ac8686e
--- /dev/null
+++ b/avahi-utils/Makefile.am
@@ -0,0 +1,6 @@
+SUBDIRS=avahi
+
+avahiscriptsdir = $(bindir)
+avahiscripts_SCRIPTS = avahi-publish-address avahi-publish-service avahi-dump-all
+
+EXTRA_DIST = $(avahiscripts_SCRIPTS)
diff --git a/avahi-utils/SimpleGladeApp.py b/avahi-utils/SimpleGladeApp.py
deleted file mode 100644
index 6d204e3..0000000
--- a/avahi-utils/SimpleGladeApp.py
+++ /dev/null
@@ -1,122 +0,0 @@
-# SimpleGladeApp.py
-# Module that provides an object oriented abstraction to pygtk and libglade.
-# Copyright (C) 2004 Sandino Flores Moreno
-
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License, or (at your option) any later version.
-#
-# This library 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
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
-# USA
-
-try:
-        import os
-        import sys
-        import gtk
-        import gtk.glade
-        import weakref
-except ImportError:
-        print "Error importing pygtk2 and pygtk2-libglade"
-        sys.exit(1)
-
-class SimpleGladeApp(dict):
-        def __init__(self, glade_filename, main_widget_name=None, domain=None, **kwargs):
-                if os.path.isfile(glade_filename):
-                        self.glade_path = glade_filename
-                else:
-                        glade_dir = os.path.split( sys.argv[0] )[0]
-                        self.glade_path = os.path.join(glade_dir, glade_filename)
-                for key, value in kwargs.items():
-                        try:
-                                setattr(self, key, weakref.proxy(value) )
-                        except TypeError:
-                                setattr(self, key, value)
-                self.glade = None
-                gtk.glade.set_custom_handler(self.custom_handler)
-                self.glade = gtk.glade.XML(self.glade_path, main_widget_name, domain)
-                if main_widget_name:
-                        self.main_widget = self.glade.get_widget(main_widget_name)
-                else:
-                        self.main_widget = None
-                self.signal_autoconnect()
-                self.new()
-
-        def signal_autoconnect(self):
-                signals = {}
-                for attr_name in dir(self):
-                        attr = getattr(self, attr_name)
-                        if callable(attr):
-                                signals[attr_name] = attr
-                self.glade.signal_autoconnect(signals)
-
-        def custom_handler(self,
-                        glade, function_name, widget_name,
-                        str1, str2, int1, int2):
-                if hasattr(self, function_name):
-                        handler = getattr(self, function_name)
-                        return handler(str1, str2, int1, int2)
-
-        def __getattr__(self, name):
-                if name in self:
-                        data = self[name]
-                        return data
-                else:
-                        widget = self.glade.get_widget(name)
-                        if widget != None:
-                                self[name] = widget
-                                return widget
-                        else:
-                                raise AttributeError, name
-
-        def __setattr__(self, name, value):
-                self[name] = value
-
-        def new(self):
-                pass
-
-        def on_keyboard_interrupt(self):
-                pass
-
-        def gtk_widget_show(self, widget, *args):
-                widget.show()
-
-        def gtk_widget_hide(self, widget, *args):
-                widget.hide()
-
-        def gtk_widget_grab_focus(self, widget, *args):
-                widget.grab_focus()
-
-        def gtk_widget_destroy(self, widget, *args):
-                widget.destroy()
-
-        def gtk_window_activate_default(self, widget, *args):
-                widget.activate_default()
-
-        def gtk_true(self, *args):
-                return gtk.TRUE
-
-        def gtk_false(self, *args):
-                return gtk.FALSE
-
-        def gtk_main_quit(self, *args):
-                gtk.main_quit()
-
-        def main(self):
-                gtk.main()
-
-        def quit(self):
-                gtk.main_quit()
-
-        def run(self):
-                try:
-                        self.main()
-                except KeyboardInterrupt:
-                        self.on_keyboard_interrupt()
diff --git a/avahi-utils/avahi-discover b/avahi-utils/avahi-discover.in
index 9ebae71..9734ae6 100755
--- a/avahi-utils/avahi-discover
+++ b/avahi-utils/avahi-discover.in
@@ -1,14 +1,13 @@
-#!/usr/bin/python2.4
+#!/usr/bin/env @PYTHON@
 # -*-python-*-
 # $Id$
 
 import os
 import gtk
 import gobject
-from SimpleGladeApp import SimpleGladeApp
 
 import avahi, dbus, gobject, sys
-
+from avahi.SimpleGladeApp import SimpleGladeApp
 
 try:
     import dbus.glib
@@ -19,7 +18,7 @@ service_type_browsers = {}
 service_browsers = {}
 
 
-glade_dir = "../avahi-discover/"
+glade_dir = "@prefix@/share/@PACKAGE@/interfaces"
 
 class Main_window(SimpleGladeApp):
     def __init__(self, path="avahi-discover.glade", root="main_window", domain=None, **kwargs):
diff --git a/avahi-utils/avahi-dump-all b/avahi-utils/avahi-dump-all.in
index 035f581..6e27240 100755
--- a/avahi-utils/avahi-dump-all
+++ b/avahi-utils/avahi-dump-all.in
@@ -1,4 +1,4 @@
-#!/usr/bin/python2.4
+#!/usr/bin/env @PYTHON@
 # -*-python-*-
 # $Id$ 
 
diff --git a/avahi-utils/avahi-publish-address b/avahi-utils/avahi-publish-address.in
index d03f928..43921e8 100755
--- a/avahi-utils/avahi-publish-address
+++ b/avahi-utils/avahi-publish-address.in
@@ -1,4 +1,4 @@
-#!/usr/bin/python2.4
+#!/usr/bin/env @PYTHON@
 # -*-python-*-
 # $Id$
 
diff --git a/avahi-utils/avahi-publish-service b/avahi-utils/avahi-publish-service.in
index d823f14..e6bb39c 100755
--- a/avahi-utils/avahi-publish-service
+++ b/avahi-utils/avahi-publish-service.in
@@ -1,4 +1,4 @@
-#!/usr/bin/python2.4
+#!/usr/bin/env @PYTHON@
 # -*-python-*-
 # $Id$
 
diff --git a/avahi-utils/avahi/Makefile.am b/avahi-utils/avahi/Makefile.am
new file mode 100644
index 0000000..357d3dc
--- /dev/null
+++ b/avahi-utils/avahi/Makefile.am
@@ -0,0 +1,4 @@
+avahidir = $(pythondir)/avahi
+avahi_PYTHON = __init__.py SimpleGladeApp.py
+
+EXTRA_DIST = $(avahi_PYTHON)
diff --git a/avahi-utils/avahi/SimpleGladeApp.py b/avahi-utils/avahi/SimpleGladeApp.py
new file mode 100644
index 0000000..90c598c
--- /dev/null
+++ b/avahi-utils/avahi/SimpleGladeApp.py
@@ -0,0 +1,341 @@
+"""
+ SimpleGladeApp.py
+ Module that provides an object oriented abstraction to pygtk and libglade.
+ Copyright (C) 2004 Sandino Flores Moreno
+"""
+
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+# USA
+
+import os
+import sys
+import re
+
+import tokenize
+import gtk
+import gtk.glade
+import weakref
+import inspect
+
+__version__ = "1.0"
+__author__ = 'Sandino "tigrux" Flores-Moreno'
+
+def bindtextdomain(app_name, locale_dir=None):
+    """    
+    Bind the domain represented by app_name to the locale directory locale_dir.
+    It has the effect of loading translations, enabling applications for different
+    languages.
+
+    app_name:
+        a domain to look for translations, tipically the name of an application.
+
+    locale_dir:
+        a directory with locales like locale_dir/lang_isocode/LC_MESSAGES/app_name.mo
+        If omitted or None, then the current binding for app_name is used.
+    """    
+    try:
+        import locale
+        import gettext
+        locale.setlocale(locale.LC_ALL, "")
+        gtk.glade.bindtextdomain(app_name, locale_dir)
+        gettext.install(app_name, locale_dir, unicode=1)
+    except (IOError,locale.Error), e:
+        print "Warning", app_name, e
+        __builtins__.__dict__["_"] = lambda x : x
+
+
+class SimpleGladeApp:
+
+    def __init__(self, path, root=None, domain=None, **kwargs):
+        """
+        Load a glade file specified by glade_filename, using root as
+        root widget and domain as the domain for translations.
+
+        If it receives extra named arguments (argname=value), then they are used
+        as attributes of the instance.
+
+        path:
+            path to a glade filename.
+            If glade_filename cannot be found, then it will be searched in the
+            same directory of the program (sys.argv[0])
+
+        root:
+            the name of the widget that is the root of the user interface,
+            usually a window or dialog (a top level widget).
+            If None or ommited, the full user interface is loaded.
+
+        domain:
+            A domain to use for loading translations.
+            If None or ommited, no translation is loaded.
+
+        **kwargs:
+            a dictionary representing the named extra arguments.
+            It is useful to set attributes of new instances, for example:
+                glade_app = SimpleGladeApp("ui.glade", foo="some value", bar="another value")
+            sets two attributes (foo and bar) to glade_app.
+        """        
+        if os.path.isfile(path):
+            self.glade_path = path
+        else:
+            glade_dir = os.path.dirname( sys.argv[0] )
+            self.glade_path = os.path.join(glade_dir, path)
+        for key, value in kwargs.items():
+            try:
+                setattr(self, key, weakref.proxy(value) )
+            except TypeError:
+                setattr(self, key, value)
+        self.glade = None
+        self.install_custom_handler(self.custom_handler)
+        self.glade = self.create_glade(self.glade_path, root, domain)
+        if root:
+            self.main_widget = self.get_widget(root)
+        else:
+            self.main_widget = None
+        self.normalize_names()
+        self.add_callbacks(self)
+        self.new()
+
+    def __repr__(self):
+        class_name = self.__class__.__name__
+        if self.main_widget:
+            root = gtk.Widget.get_name(self.main_widget)
+            repr = '%s(path="%s", root="%s")' % (class_name, self.glade_path, root)
+        else:
+            repr = '%s(path="%s")' % (class_name, self.glade_path)
+        return repr
+
+    def new(self):
+        """
+        Method called when the user interface is loaded and ready to be used.
+        At this moment, the widgets are loaded and can be refered as self.widget_name
+        """
+        pass
+
+    def add_callbacks(self, callbacks_proxy):
+        """
+        It uses the methods of callbacks_proxy as callbacks.
+        The callbacks are specified by using:
+            Properties window -> Signals tab
+            in glade-2 (or any other gui designer like gazpacho).
+
+        Methods of classes inheriting from SimpleGladeApp are used as
+        callbacks automatically.
+
+        callbacks_proxy:
+            an instance with methods as code of callbacks.
+            It means it has methods like on_button1_clicked, on_entry1_activate, etc.
+        """        
+        self.glade.signal_autoconnect(callbacks_proxy)
+
+    def normalize_names(self):
+        """
+        It is internally used to normalize the name of the widgets.
+        It means a widget named foo:vbox-dialog in glade
+        is refered self.vbox_dialog in the code.
+
+        It also sets a data "prefixes" with the list of
+        prefixes a widget has for each widget.
+        """
+        for widget in self.get_widgets():
+            widget_name = gtk.Widget.get_name(widget)
+            prefixes_name_l = widget_name.split(":")
+            prefixes = prefixes_name_l[ : -1]
+            widget_api_name = prefixes_name_l[-1]
+            widget_api_name = "_".join( re.findall(tokenize.Name, widget_api_name) )
+            gtk.Widget.set_name(widget, widget_api_name)
+            if hasattr(self, widget_api_name):
+                raise AttributeError("instance %s already has an attribute %s" % (self,widget_api_name))
+            else:
+                setattr(self, widget_api_name, widget)
+                if prefixes:
+                    gtk.Widget.set_data(widget, "prefixes", prefixes)
+
+    def add_prefix_actions(self, prefix_actions_proxy):
+        """
+        By using a gui designer (glade-2, gazpacho, etc)
+        widgets can have a prefix in theirs names
+        like foo:entry1 or foo:label3
+        It means entry1 and label3 has a prefix action named foo.
+
+        Then, prefix_actions_proxy must have a method named prefix_foo which
+        is called everytime a widget with prefix foo is found, using the found widget
+        as argument.
+
+        prefix_actions_proxy:
+            An instance with methods as prefix actions.
+            It means it has methods like prefix_foo, prefix_bar, etc.
+        """        
+        prefix_s = "prefix_"
+        prefix_pos = len(prefix_s)
+
+        is_method = lambda t : callable( t[1] )
+        is_prefix_action = lambda t : t[0].startswith(prefix_s)
+        drop_prefix = lambda (k,w): (k[prefix_pos:],w)
+
+        members_t = inspect.getmembers(prefix_actions_proxy)
+        methods_t = filter(is_method, members_t)
+        prefix_actions_t = filter(is_prefix_action, methods_t)
+        prefix_actions_d = dict( map(drop_prefix, prefix_actions_t) )
+
+        for widget in self.get_widgets():
+            prefixes = gtk.Widget.get_data(widget, "prefixes")
+            if prefixes:
+                for prefix in prefixes:
+                    if prefix in prefix_actions_d:
+                        prefix_action = prefix_actions_d[prefix]
+                        prefix_action(widget)
+
+    def custom_handler(self,
+            glade, function_name, widget_name,
+            str1, str2, int1, int2):
+        """
+        Generic handler for creating custom widgets, internally used to
+        enable custom widgets (custom widgets of glade).
+
+        The custom widgets have a creation function specified in design time.
+        Those creation functions are always called with str1,str2,int1,int2 as
+        arguments, that are values specified in design time.
+
+        Methods of classes inheriting from SimpleGladeApp are used as
+        creation functions automatically.
+
+        If a custom widget has create_foo as creation function, then the
+        method named create_foo is called with str1,str2,int1,int2 as arguments.
+        """
+        try:
+            handler = getattr(self, function_name)
+            return handler(str1, str2, int1, int2)
+        except AttributeError:
+            return None
+
+    def gtk_widget_show(self, widget, *args):
+        """
+        Predefined callback.
+        The widget is showed.
+        Equivalent to widget.show()
+        """
+        widget.show()
+
+    def gtk_widget_hide(self, widget, *args):
+        """
+        Predefined callback.
+        The widget is hidden.
+        Equivalent to widget.hide()
+        """
+        widget.hide()
+
+    def gtk_widget_grab_focus(self, widget, *args):
+        """
+        Predefined callback.
+        The widget grabs the focus.
+        Equivalent to widget.grab_focus()
+        """
+        widget.grab_focus()
+
+    def gtk_widget_destroy(self, widget, *args):
+        """
+        Predefined callback.
+        The widget is destroyed.
+        Equivalent to widget.destroy()
+        """
+        widget.destroy()
+
+    def gtk_window_activate_default(self, window, *args):
+        """
+        Predefined callback.
+        The default widget of the window is activated.
+        Equivalent to window.activate_default()
+        """
+        widget.activate_default()
+
+    def gtk_true(self, *args):
+        """
+        Predefined callback.
+        Equivalent to return True in a callback.
+        Useful for stopping propagation of signals.
+        """
+        return True
+
+    def gtk_false(self, *args):
+        """
+        Predefined callback.
+        Equivalent to return False in a callback.
+        """
+        return False
+
+    def gtk_main_quit(self, *args):
+        """
+        Predefined callback.
+        Equivalent to self.quit()
+        """
+        self.quit()
+
+    def main(self):
+        """
+        Starts the main loop of processing events.
+        The default implementation calls gtk.main()
+
+        Useful for applications that needs a non gtk main loop.
+        For example, applications based on gstreamer needs to override
+        this method with gst.main()
+
+        Do not directly call this method in your programs.
+        Use the method run() instead.
+        """
+        gtk.main()
+
+    def quit(self):
+        """
+        Quit processing events.
+        The default implementation calls gtk.main_quit()
+        
+        Useful for applications that needs a non gtk main loop.
+        For example, applications based on gstreamer needs to override
+        this method with gst.main_quit()
+        """
+        gtk.main_quit()
+
+    def run(self):
+        """
+        Starts the main loop of processing events checking for Control-C.
+
+        The default implementation checks wheter a Control-C is pressed,
+        then calls on_keyboard_interrupt().
+
+        Use this method for starting programs.
+        """
+        try:
+            self.main()
+        except KeyboardInterrupt:
+            self.on_keyboard_interrupt()
+
+    def on_keyboard_interrupt(self):
+        """
+        This method is called by the default implementation of run()
+        after a program is finished by pressing Control-C.
+        """
+        pass
+
+    def install_custom_handler(self, custom_handler):
+        gtk.glade.set_custom_handler(custom_handler)
+
+    def create_glade(self, glade_path, root, domain):
+        return gtk.glade.XML(self.glade_path, root, domain)
+
+    def get_widget(self, widget_name):
+        return self.glade.get_widget(widget_name)
+
+    def get_widgets(self):
+        return self.glade.get_widget_prefix("")        
diff --git a/avahi-utils/avahi.py b/avahi-utils/avahi/__init__.py
index 1e2761c..1e2761c 100644
--- a/avahi-utils/avahi.py
+++ b/avahi-utils/avahi/__init__.py