You can check out pre-release branch here:

Please see “Pre-release Notes” in the README for some important information about using the svn version.

We’re putting on the finishing touches, so updates should continue over the next few days (hours?). If you do try it out & have any problems please let us know in #mumbles (freenode), or on the forum.

Please note, that while I appreciate any comment, those with questions are encouraged to post on the forum It’s easy for questions (that are probably useful to others) to get lost in the comment thread.

I will try to respond to the backlogged questions in the next day or two. Again, I apologize for the hiccup. Thanks for stopping by.

The mumbles plugin here will work with the screenlet (it will continue to work with the simple twittercheck script there as well).

Let me know what you think.

Note: mumbles users will most likely want to turn off “use libnotify” in the screentlet preferences. This is my opinion of how applications should use libnotify/dbus. Provide the users with a default libnotify notification, but also, the option to turn it off while continuing to send DBus notifications that other apps can pick up. Here’s to hoping this practice catches on!

[edit 03.24: Updated the twitter check script. Added option to check public timeline (by default if no account information is supplied) and fixed bug preventing script from running via Gnome Sessions. If you previously downloaded the file, it's advised to update. Links below point to current version.]

If you’re looking to get right to the plugin, download here, or find more information below. But first, some updates:

I realize it’s been a long while since I’ve posted anything. I had a failry busy last 6 months, but I hope to keep the site a bit more up to date going forward. Thanks to all of you still hanging around and sending comments.

So, in an attempt to keep the project moving foward and to encourage more participation, I wanted to post a few ways to get in touch with me and with others working on/using mumbles. Like always email (dot_j at this domain), and comments work, but I also want to keep the conversation about mumbles open and ongoing. So I have created a few new avenues of discussion:

IRC: #mumbles on irc.freenode.net

I try to hang around in here as much as possible. If you stop by and I’m not responding or away, try to hang around - I will respond when I can. I’m hoping other users and developers will also start to hang out here to help with plugins, questions and ideas.

Twitter: http://twitter.com/dot_j

I just got turned onto twitter and quickly realized it would be (among other things) a great place to talk about mumbles. It takes a little more time and attention to update the website and often there are things I’m working on or thinking about related to mumbles that do not warrant a full post here, so why not twitter?

Please consider taking part in either of these ways of following the mumbles project. I have recieved lots of feedback/suggestions and have a roadmap scetched out (post coming soon) for version 0.5 and I hope to see the discussion and participation pick up with new development.

And now for the plugin:

Download the Twitter Check Script & Mumbles Plugin

People have asked for it, and I now have an account, so I better have a plugin, right? It’s in an early stage with lots of room for improvements (version 0.5 will include some new functionality that will be added in future updates), but it works and is a great way to keep an eye on your twitter account. See the README in the archive for instructions. Like always, more information can be found at

http://www.mumbles-project.org/plugins

http://www.mumbles-project.org/extras

By popular demand…

I finally took the plunge, installed Amarok, started mucking around with their scripting capabilities, and came out with a script that allowed me to create a mumbles plugin using the methodology outlined here.

I have seen that there are plans to switch to DBus in the next version of Amarok (and KDE for that matter), but in the meantime, this little script should do the trick.

I took the same approach with this script, as I had with the Firefox and Thunderbird extensions in that none of them are mumbles-specific. They all use a a pretty straight forward python class that extends a DBus service object to send signals. The script sends a signal to the DBus rather than to mumbles with the hope that other applications besides mumbles could make use of it by listening for those signals. I would like to see a common set of these scripts for applications that do not send DBus signals (or have no DBus support) on their own but have a scripting/plugin interface - building these extensions is a step in that direction and I hope they catch on (and are developed further to support more features/signals).

Installation instructions are included in the download file.

Download

• Download Files

Also See

• Download Just the Amarok DBus Script
• Amarok Scripts
• Mumbles Plugins
• Mumbles Extras

This tutorial will show you how to write a mumbles plugin for Evolution that sends a notification when new mail is received.

Plugin Files

If you want to save yourself some typing (or indenting!) time, or just want to grab the plugin, the files for the tutorial are available here.

[edit: If you're using a newer version of Evolution (I have 2.12.1 in Gutsy), a new parameter has been added to the NewMail signal. I have updated the tutorial below to include handling of this parameter, however the files linked above do not yet include this update. Updates will appear shortly in svn

Requirements for this tutorial

• mumbles version 0.4
• dbus-monitor
• Evoultion

The DBus

As mumbles makes use of DBus, the first step in writing a plugin for mumbles is to look for the DBus signals, to which, we are able to connect. I like a simple command line application called dbus-monitor for this.

So, let's watch what happens on the DBus while running Evolution. First in a terminal type:

dbus-monitor

Next start Evolution.

In the output of dbus-monitor you should see (among other things) a few lines that look similar to:

signal sender=:1.62 -> dest=(null destination) path=/org/gnome/evolution/mail/newmail;
  interface=org.gnome.evolution.mail.dbus.Signal; member=MessageReading
  string "Inbox"

Here, we see a DBus signal named 'MessageReading'. In our example, we're interested in what happens when new mail is received. So send your self a test message and click Send/Receive. You should then see, when your message arrives, in dbus-monitor something like:

signal sender=:1.62 -> dest=(null destination) path=/org/gnome/evolution/mail/newmail;
  interface=org.gnome.evolution.mail.dbus.Signal; member=Newmail
  string "mbox:/home/dot_j/.evolution/mail/local#Inbox"
  string "Inbox"
  uint32 1

[edit: depending on your version of Evolution you may not see the last uint32]

We see that when, new mail arrives, a signal is sent to the DBus called 'NewMail'. A few other things we'll need to note are:

• The signal name (member): NewMail
• The path: /org/gnome/evolution/mail/newmail
• The interface: org.gnome.evolution.mail.dbus.Signal
• And the two paramaters that are sent to the signal:
  • “mbox:/home/dot_j/.evolution/mail/local#Inbox”
  • “Inbox“
  • [edit: "uint23 1" for newer versions]

Writing the plugin

We’ll make use of those shortly in the code for the plugin. We got what we needed from dbus-monitor, so go ahead and close it and create a new directory in your home directory for our plugin:

mkdir ~/evolution_plugin

If you have mumbles installed locally and have dug around in the directories, you may have seen the structure of a mumbles plugin. Each plugin has a file named

setup.py

and a directory named

src

The src directory contains another python file called

__init__.py

setup.py is just that - a setup file for our plugin and __init__.py in the src directory is the source file for our plugin.

Now let’s get down to business. Let’s setup that structure in a new directory for our plugin:

mkdir ~/evolution_plugin/src

Next, create setup.py in your favorite editor:

gedit ~/evolution_plugin/setup.py

And enter:

#————————————————————————
# A Mumbles Plugin for Evolution
#   Copyright (c) 2007 dot_j <dot_j[at]mumbles-project[dot]org>
#   Lisenced under the GPL
#————————————————————————

from setuptools import setup
import sys, os
from shutil import copy

__author__ = ‘dot_j[AT]mumbles-project[DOT]org’
__doc__ = ‘An Evolution plugin for mumbles’
__version__ = ‘0.1′

setup(
    name=‘EvolutionMumbles’,
    version=__version__,
    description=__doc__,
    author=__author__,
    packages=[‘evolution’],
    package_dir={‘evolution’:’src’},
    entry_points=”‘
    [mumbles.plugins]
    Evolution = evolution:EvolutionMumbles
    ‘”
)

And save setup.py

Pretty straight forward setup here. We define our author, documentation and plugin version tags and add what we need in order to build our python egg (plugin). For more information about eggs and setuptools see here.

Now create our plugin source file

gedit ~/evolution_plugin/src/__init__.py

And enter:

#————————————————————————
# A Mumbles Plugin for Evolution
#   Copyright (c) 2007 dot_j <dot_j[at]mumbles-project[dot]org>
#   Lisenced under the GPL
#————————————————————————

# We’ll extend the MumblesPlugin class to create our Evolution plugin
from MumblesPlugin import *

class EvolutionMumbles(MumblesPlugin):

    # Give our plugin a name (using the same name we used in setup.py).
    plugin_name = “EvolutionMumbles”

    # Use the dbus interface we saw in dbus-notify
    dbus_interface = “org.gnome.evolution.mail.dbus.Signal”

    # Use the dbus path we saw in dbus-notify
    dbus_path = “/org/gnome/evolution/mail/newmail”

    # Configure our plugin icon
    icons = {‘evolution’ : ‘evolution.png’}

    # setup the __init__ function where we define
    # the dbus signal(s), to which, we are connecting.
    # Note this function takes 2 parameters (mumbles_notify and
    # session_bus) that we will hand off to our
    # MumblesPlugin parent class
    def __init__(self, mumbles_notify, session_bus):

        # Here, we tell our plugin to connect the dbus signal
        # ‘Newmail’ to our plugin class’s ‘NewMail’ function
        self.signal_config = {
            “Newmail”: self.NewMail
        }

        # and hand off our mumbles_notify and session_bus objects to our parent
        MumblesPlugin.__init__(self, mumbles_notify, session_bus)

    # NewMail function
    # This will get called when a NewMail signal is received on the DBus from Evolution
    # Note the function takes 2 parameters (the two we saw in the dbus-monitor activity)
    # [edit: newer versions of Evolution may have a 3rd parameter,
    # the follwoing should work with or without this parameter]
    def NewMail(self, mbox_path, folder_name, some_int=None):

        # Get our icon using the key we used above when configuring our icons dictionary
        icon = self.get_icon(‘evolution’)

        # Define what we want to send in our notification:
        # Send a simple title
        title = ‘Evolution: New Mail!’

        # Let’s send our folder name as our notification message
        message = folder_name

        # If you want to try an advanced version of the plugin,
        # see if you can use the supplied mbox_path to get more information
        # about the message that just arrived! And be sure to let us know
        # about your efforts.

        # Finally, using our mumbles_notification object, send the notification
        self.mumbles_notify.alert(self.plugin_name, title, message, icon)

And just 60 lines of code (with comments!) - not too bad, right? And we’re almost there. But first, we need to create that icon we used and put it where our plugin can find it.

So, create a plugins directory in your hidden .mumbles directory in your home folder. If you have run mumbles already, you will already have a directory called ~/.mumbles. If not, create that first, then create the plugin and plugin/icons directories there.

mkdir ~/.mumbles (if you need to, but you shouldn’t)
mkdir ~/.mumbles/plugins
mkdir ~/.mumbles/plugins/icons

The default themes that come with mumbles will support an image around 20×20 pixels. So for this example, I used the Evolution icon I had in in /usr/share/icons/hicolor/22×22/apps/evolution.png

cp /usr/share/icons/hicolor/22×22/apps/evolution.png ~/.mumbles/plugins/icons

Build and install the plugin

cd ~/evolution_plugin (if you’re not already there)
python setup.py bdist_egg

This will use our setup.py file to create our plugin. After it runs, you should see a file named

EvolutionMumbles-0.1-py2.5.egg

in the dist directory that was created by the build process. Here the -py2.5 part of the filename refers to what version of python you are using (it may vary, but if you are able to start mumbles, should not matter).

The .egg file is our plugin, so the only thing left to do is copy that to the mumbles plugin directory.

cp dist/EvolutionMumbles-0.1-py2.5.egg ~/.mumbles/plugins

Try it

That’s it! Now run mumbles and send yourself another email. You should see your new mail notification!

Thanks for following along. I hope you found this tutorial both helpful and interesting. And I hope it inspired you to write a plugin of your own. If you expand on this example, or write a new plugin for your favorite application be sure to let us know!

Files

Download tutorial files here.

Download and Installation instructions for 0.4 can be found here.

New to this Release:

New Plugins

• mumbles now has plugins for Gaim, Pidgin, Rhythmbox, Firefox*, Thunderbird*, and custom notifications.

*Firefox and Thunderbird plugins require a DBus extension. Please see the extras page for more information.

Theme Support

• mumbles 0.4 introduces theming ability. This release comes with 6 standard themes and the ability to support custom themes.

mumbles-send script

• mumbles-send is a script included with mumbles that allows sending of custom notifications. See the download page for an example of how to use mumbles-send.

Growl Network Notification Support

• When started with Growl Network Notification support, mumbles can receive notifications over the network using the Growl network protocol. mumbles-send can also send Growl network notifications. Use mumbles with your Mac, or just send notifications to another computer running mumbles with Growl Network Notifications enabled. See the Growl section of the mumbles preferences pane or run ‘mumbles –help’ (or ‘mumbles-send –help’) for information about enabling and configuring Growl Network Notification support.

Daemon mode

• Want to just run mumbles in the background without a panel applet? Run ‘mumbles -d’ to start in deamon mode.

Click Handling

• mumbles now supports click handling. Right clicks close the notification and the Firefox plugin opens the downloaded file on left click.

Bug fixes and code improvements

• What’s a release without them?

I hope you dig it.

• Let me know what you think, what you’d like to see and whatever else is on your mind. I have some tutorials ready to roll out so check back here for updates on using the new features in mumbles 0.4 including: writing a plugin, creating custom themes and how to unleash the awesomeness that is network enabled notifications!

I’ve been preoccupied with the job thing, so I haven’t been working too much on Mumbles. With the most recent updates (svn is at a state where release 0.4 is coming shortly), it’s at the point where it does what I wanted it to do (scratched the itch as they say), so going forward, the project is really going to be driven by those of you that use it (and take the time to file a request). So please let me know what you want from the project in the comments for this post. More application plugins? Which applications would you like to see Mumbles support? New features? Better configuration?

As a starting point, here are some things I’ve been thinking about (and built the project with the idea of implementing in future releases):

* RSS notifications - I’ve had a request for this from another user and would like to see this myself - it’s probably the next thing I’ll work on. I’m a bit undecided about how to pursue this - should there be a script for something like Liferea that sends dbus notifications, should I write a simple RSS aggregator that sends dbus notifications? Any ideas/comments?

* Plugin-specific configuration - It seems like an option to only get a notification if your name is said in an IRC room makes sense. I also have the ability to handle clicks on the notification, so things like brining the application to focus or opening the website for the RSS feed make sense (the code in svn has some of this implemented). I believe Growl also keeps notifications open if you mouse over them - should Mumbles?

* libnotify output - I’ve been thinking it makes sense to make output plugins much like the application (input) plugins and have seen some comments from others who prefer libnotify alerts. So why not let you choose to use the Mumbles (composite enabled) notification or a libnotify notification - or any other kind of output for that matter (save to a database, SMS, email…?)

* Documentation/Tutorials - I’d like to drive contributions and assume writing some documentation or a tutorial about how to write a plugin would help on that front. Contributions about contribution would be good too. I’ve seen a few comments about how people are using Mumbles with other applications and feel the word could really get out with a few examples about how to use the mumbles-send script and/or the Mumbles dbus object (like Chris’ Thunderbird example)

* Themeable notifications/images - one could “theme” Mumbles by just swapping out the background image - do we want the ability to easily support themes (or use Gnome settings)? Should mumbles use buddy icons/album art/whatever else for the notification icons (see the point above about plugin-specific) configuration). Do we want to be able to choose font styles/sizes?

* deb package - I would really like to see this in order to make installation easier. I don’t have much experience with packaging files, so any help here would be greatly appreciated. What systems are you using Mumbles on? - do we want rpm, debs…?

That will hopefully get things going. Thanks to those of you following the project - the floor is open - I look forward to your ideas & comments.

The setup script has been updated to build the egg, so if you update or check out the current version, the installation will remain the same. If you just check out the Pidgin plugin you can either run the newest setup.py script or build the egg yourself from src/plugins/pidgin:

python setup.py develop –install-dir .. -m