Add Freedesktop Notifications plugin (Fixes issue 3414)

Ootion for less-strict html parsing. (Fixes issue 3484)
When the plugins module is more friendly to alternative packages I will repackage commons where it should be.

Change-Id: Icf4afe2ffd9280194dea70601addacbb57bacc4b
Reviewed-on: http://gerrit.dmdirc.com/436
Reviewed-by: Gregory Holmes <greboid@dmdirc.com>
Tested-by: Gregory Holmes <greboid@dmdirc.com>

src/com/dmdirc/addons/freedesktop_notifications/FDNotifyCommand.java

@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2006-2010 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.addons.freedesktop_notifications;
+
+import com.dmdirc.Server;
+import com.dmdirc.commandparser.CommandArguments;
+import com.dmdirc.commandparser.CommandManager;
+import com.dmdirc.commandparser.commands.GlobalCommand;
+import com.dmdirc.ui.interfaces.InputWindow;
+
+import java.util.List;
+
+/**
+ * The FDNotify Command shows a nice popup on using the FreeDesktop
+ * VisualNotifications.
+ *
+ * @author Shane 'Dataforce' McCormack
+ */
+public final class FDNotifyCommand extends GlobalCommand {
+    /** Plugin that owns this command. */
+    final FreeDesktopNotificationsPlugin myPlugin;
+    
+    /**
+     * Creates a new instance of FDNotifyCommand.
+     *
+     * @param myPlugin the plugin creating this command.
+     */
+    public FDNotifyCommand(final FreeDesktopNotificationsPlugin myPlugin) {
+        super();
+        this.myPlugin = myPlugin;
+        CommandManager.registerCommand(this);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void execute(final InputWindow origin, final boolean isSilent, final CommandArguments args) {
+        myPlugin.showNotification("", args.getArgumentsAsString());
+    }
+    
+    
+    /** {@inheritDoc} */
+    @Override
+    public String getName() {
+        return "fdnotify";
+    }
+    
+    /** {@inheritDoc} */
+    @Override
+    public boolean showInHelp() {
+        return true;
+    }
+    
+    /** {@inheritDoc} */
+    @Override
+    public String getHelp() {
+        return "fdnotify <message> - Show a nice popup where available";
+    }
+}

src/com/dmdirc/addons/freedesktop_notifications/FreeDesktopNotificationsPlugin.java

@@ -0,0 +1,223 @@
+/*
+ * Copyright (c) 2006-2010 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.addons.freedesktop_notifications;
+
+import com.dmdirc.plugins.Plugin;
+import com.dmdirc.plugins.PluginInfo;
+import com.dmdirc.plugins.PluginManager;
+import com.dmdirc.util.resourcemanager.ResourceManager;
+import com.dmdirc.logger.ErrorLevel;
+import com.dmdirc.logger.Logger;
+import com.dmdirc.Main;
+import java.io.File;
+import java.io.IOException;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.ArrayList;
+import com.dmdirc.commandparser.CommandManager;
+import com.dmdirc.installer.StreamReader;
+import com.dmdirc.ui.messages.Styliser;
+import com.dmdirc.config.IdentityManager;
+import com.dmdirc.config.Identity;
+import com.dmdirc.config.prefs.PreferencesManager;
+import com.dmdirc.config.prefs.PreferencesCategory;
+import com.dmdirc.config.prefs.PreferencesSetting;
+import com.dmdirc.config.prefs.PreferencesType;
+import com.dmdirc.addons.freedesktop_notifications.commons.StringEscapeUtils;;
+
+/**
+ * This plugin adds freedesktop Style Notifications to dmdirc.
+ *
+ * @author Shane 'Dataforce' McCormack
+ */
+public final class FreeDesktopNotificationsPlugin extends Plugin {
+    /** The DcopCommand we created */
+    private FDNotifyCommand command = null;
+    
+    /** Files dir */
+    private static final String filesDir  = Main.getConfigDir() + "plugins/freedesktop_notifications_files/";
+    
+    /**
+     * Creates a new instance of the FreeDesktopNotifications Plugin.
+     */
+    public FreeDesktopNotificationsPlugin() {
+        super();
+    }
+
+    /**
+     * Used to show a notification using this plugin.
+     *
+     * @param title Title of dialog if applicable
+     * @param message Message to show
+     * @return True if the notification was shown.
+     */
+    public boolean showNotification(final String title, final String message) {
+        final int seconds = IdentityManager.getGlobalConfig().getOptionInt(getDomain(), "general.timeout");
+        final String icon = IdentityManager.getGlobalConfig().getOption(getDomain(), "general.icon");
+        final ArrayList<String> args = new ArrayList<String>();
+        
+        args.add("/usr/bin/env");
+        args.add("python");
+        args.add(filesDir+"notify.py");
+        args.add("-a");
+        args.add("DMDirc");
+        args.add("-i");
+        args.add(icon);
+        args.add("-t");
+        args.add(Integer.toString(seconds * 1000));
+        args.add("-s");
+
+        if (title != null && !title.isEmpty()) {
+            args.add(prepareString(title));
+        } else {
+            args.add("Notification from DMDirc");
+        }
+        args.add(prepareString(message));
+        
+        try {
+            final Process myProcess = Runtime.getRuntime().exec(args.toArray(new String[]{}));
+            final StringBuffer data = new StringBuffer();
+            new StreamReader(myProcess.getErrorStream()).start();
+            new StreamReader(myProcess.getInputStream(), data).start();
+            try { myProcess.waitFor(); } catch (InterruptedException e) { }
+            return true;
+        } catch (SecurityException e) {
+        } catch (IOException e) {
+        }
+        
+        return false;
+    }
+    
+    /**
+     * Prepare the string for sending to dbus.
+     *
+     * @param input Input string
+     * @return Input string after being processed according to config settings.
+     */
+    public final String prepareString(final String input) {
+        final boolean escapehtml = IdentityManager.getGlobalConfig().getOptionBool(getDomain(), "advanced.escapehtml");
+	final boolean strictescape = IdentityManager.getGlobalConfig().getOptionBool(getDomain(), "advanced.strictescape");
+        final boolean stripcodes = IdentityManager.getGlobalConfig().getOptionBool(getDomain(), "advanced.stripcodes");
+
+        String output = input;
+        if (stripcodes) { output = Styliser.stipControlCodes(output); }
+        if (escapehtml) {
+	    if (strictescape) {
+                output = StringEscapeUtils.escapeHtml(output);
+            } else {
+                output = output.replaceAll("&", "&amp;");
+                output = output.replaceAll("<", "&lt;");
+                output = output.replaceAll(">", "&gt;");
+            }
+        }
+        
+        return output;
+    }
+
+    /**
+     * Called when the plugin is loaded.
+     */
+    @Override
+    public void onLoad() {
+        command = new FDNotifyCommand(this);
+
+        // Extract required Files
+        final PluginInfo pi = PluginManager.getPluginManager().getPluginInfoByName("freedesktop_notifications");
+        
+        // This shouldn't actually happen, but check to make sure.
+        if (pi != null) {
+            // Now get the RM
+            try {
+                final ResourceManager res = pi.getResourceManager();
+                
+                // Make sure our files dir exists
+                final File newDir = new File(filesDir);
+                if (!newDir.exists()) {
+                    newDir.mkdirs();
+                }
+            
+                // Now extract the files needed
+                extractFiles(res, newDir, ".py");
+                extractFiles(res, newDir, ".png");
+            } catch (IOException ioe) {
+                Logger.userError(ErrorLevel.LOW, "Unable to open ResourceManager for freedesktop_notifications: "+ioe.getMessage(), ioe);
+            }
+        }
+    }
+    
+    /**
+     * Use the given resource manager to extract files ending with the given suffix
+     *
+     * @param res ResourceManager
+     * @param newDir Directory to extract to.
+     * @param suffix Suffix to extract
+     */
+    private static void extractFiles(final ResourceManager res, final File newDir, final String suffix) {
+        final Map<String, byte[]> resources = res.getResourcesEndingWithAsBytes(suffix);
+        for (Entry<String, byte[]> resource : resources.entrySet()) {
+            try {
+                final String key = resource.getKey();
+                final String resourceName = key.substring(key.lastIndexOf('/'), key.length());
+
+                final File newFile = new File(newDir, resourceName);
+
+                if (!newFile.isDirectory()) {
+                    if (newFile.exists()) { newFile.delete(); }
+                    ResourceManager.getResourceManager().resourceToFile(resource.getValue(), newFile);
+                }
+            } catch (IOException ex) {
+                Logger.userError(ErrorLevel.LOW, "Failed to extract "+suffix+"s for freedesktop_notifications: "+ex.getMessage(), ex);
+            }
+        }
+    }
+
+    /**
+     * Called when this plugin is Unloaded.
+     */
+    @Override
+    public synchronized void onUnload() {
+        CommandManager.unregisterCommand(command);
+    }
+    
+    /** {@inheritDoc} */
+    @Override
+    public void domainUpdated() {
+        final Identity defaults = IdentityManager.getAddonIdentity();
+        defaults.setOption(getDomain(), "general.icon", filesDir+"icon.png");
+    }
+    
+    /** {@inheritDoc} */
+    @Override
+    public void showConfig(final PreferencesManager manager) {
+        final PreferencesCategory general = new PreferencesCategory("FreeDesktop Notifications", "General configuration for FreeDesktop Notifications plugin.");
+        
+        general.addSetting(new PreferencesSetting(PreferencesType.INTEGER, getDomain(), "general.timeout", "Timeout", "Length of time in seconds before the notification popup closes."));
+        general.addSetting(new PreferencesSetting(PreferencesType.TEXT, getDomain(), "general.icon", "icon", "Path to icon to use on the notification."));
+        general.addSetting(new PreferencesSetting(PreferencesType.BOOLEAN, getDomain(), "advanced.escapehtml", "Escape HTML", "Some Implementations randomly parse HTML, escape it before showing?"));
+	general.addSetting(new PreferencesSetting(PreferencesType.BOOLEAN, getDomain(), "advanced.strictescape", "Strict Escape HTML", "Strictly escape HTML or just the basic characters? (&, < and >)"));
+        general.addSetting(new PreferencesSetting(PreferencesType.BOOLEAN, getDomain(), "advanced.stripcodes", "Strip Control Codes", "Strip IRC Control codes from messages?"));
+        
+        manager.getCategory("Plugins").addSubCategory(general);
+    }
+}
+

src/com/dmdirc/addons/freedesktop_notifications/commons/IntHashMap.java

@@ -0,0 +1,364 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * Note: originally released under the GNU LGPL v2.1, 
+ * but rereleased by the original author under the ASF license (above).
+ */
+package com.dmdirc.addons.freedesktop_notifications.commons;
+
+/**
+ * <p>A hash map that uses primitive ints for the key rather than objects.</p>
+ *
+ * <p>Note that this class is for internal optimization purposes only, and may
+ * not be supported in future releases of Apache Commons Lang.  Utilities of
+ * this sort may be included in future releases of Apache Commons Collections.</p>
+ *
+ * @author Justin Couch
+ * @author Alex Chaffee (alex@apache.org)
+ * @author Stephen Colebourne
+ * @since 2.0
+ * @version $Revision$
+ * @see java.util.HashMap
+ */
+class IntHashMap {
+
+    /**
+     * The hash table data.
+     */
+    private transient Entry table[];
+
+    /**
+     * The total number of entries in the hash table.
+     */
+    private transient int count;
+
+    /**
+     * The table is rehashed when its size exceeds this threshold.  (The
+     * value of this field is (int)(capacity * loadFactor).)
+     *
+     * @serial
+     */
+    private int threshold;
+
+    /**
+     * The load factor for the hashtable.
+     *
+     * @serial
+     */
+    private float loadFactor;
+
+    /**
+     * <p>Innerclass that acts as a datastructure to create a new entry in the
+     * table.</p>
+     */
+    private static class Entry {
+        int hash;
+//        int key;    // not used currently
+        Object value;
+        Entry next;
+
+        /**
+         * <p>Create a new entry with the given values.</p>
+         *
+         * @param hash The code used to hash the object with
+         * @param key The key used to enter this in the table
+         * @param value The value for this key
+         * @param next A reference to the next entry in the table
+         */
+        protected Entry(int hash, int key, Object value, Entry next) {
+            this.hash = hash;
+//            this.key = key;
+            this.value = value;
+            this.next = next;
+        }
+    }
+
+    /**
+     * <p>Constructs a new, empty hashtable with a default capacity and load
+     * factor, which is <code>20</code> and <code>0.75</code> respectively.</p>
+     */
+    public IntHashMap() {
+        this(20, 0.75f);
+    }
+
+    /**
+     * <p>Constructs a new, empty hashtable with the specified initial capacity
+     * and default load factor, which is <code>0.75</code>.</p>
+     *
+     * @param  initialCapacity the initial capacity of the hashtable.
+     * @throws IllegalArgumentException if the initial capacity is less
+     *   than zero.
+     */
+    public IntHashMap(int initialCapacity) {
+        this(initialCapacity, 0.75f);
+    }
+
+    /**
+     * <p>Constructs a new, empty hashtable with the specified initial
+     * capacity and the specified load factor.</p>
+     *
+     * @param initialCapacity the initial capacity of the hashtable.
+     * @param loadFactor the load factor of the hashtable.
+     * @throws IllegalArgumentException  if the initial capacity is less
+     *             than zero, or if the load factor is nonpositive.
+     */
+    public IntHashMap(int initialCapacity, float loadFactor) {
+        super();
+        if (initialCapacity < 0) {
+            throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
+        }
+        if (loadFactor <= 0) {
+            throw new IllegalArgumentException("Illegal Load: " + loadFactor);
+        }
+        if (initialCapacity == 0) {
+            initialCapacity = 1;
+        }
+
+        this.loadFactor = loadFactor;
+        table = new Entry[initialCapacity];
+        threshold = (int) (initialCapacity * loadFactor);
+    }
+
+    /**
+     * <p>Returns the number of keys in this hashtable.</p>
+     *
+     * @return  the number of keys in this hashtable.
+     */
+    public int size() {
+        return count;
+    }
+
+    /**
+     * <p>Tests if this hashtable maps no keys to values.</p>
+     *
+     * @return  <code>true</code> if this hashtable maps no keys to values;
+     *          <code>false</code> otherwise.
+     */
+    public boolean isEmpty() {
+        return count == 0;
+    }
+
+    /**
+     * <p>Tests if some key maps into the specified value in this hashtable.
+     * This operation is more expensive than the <code>containsKey</code>
+     * method.</p>
+     *
+     * <p>Note that this method is identical in functionality to containsValue,
+     * (which is part of the Map interface in the collections framework).</p>
+     *
+     * @param      value   a value to search for.
+     * @return     <code>true</code> if and only if some key maps to the
+     *             <code>value</code> argument in this hashtable as
+     *             determined by the <tt>equals</tt> method;
+     *             <code>false</code> otherwise.
+     * @throws  NullPointerException  if the value is <code>null</code>.
+     * @see        #containsKey(int)
+     * @see        #containsValue(Object)
+     * @see        java.util.Map
+     */
+    public boolean contains(Object value) {
+        if (value == null) {
+            throw new NullPointerException();
+        }
+
+        Entry tab[] = table;
+        for (int i = tab.length; i-- > 0;) {
+            for (Entry e = tab[i]; e != null; e = e.next) {
+                if (e.value.equals(value)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    /**
+     * <p>Returns <code>true</code> if this HashMap maps one or more keys
+     * to this value.</p>
+     *
+     * <p>Note that this method is identical in functionality to contains
+     * (which predates the Map interface).</p>
+     *
+     * @param value value whose presence in this HashMap is to be tested.
+     * @return boolean <code>true</code> if the value is contained
+     * @see    java.util.Map
+     * @since JDK1.2
+     */
+    public boolean containsValue(Object value) {
+        return contains(value);
+    }
+
+    /**
+     * <p>Tests if the specified object is a key in this hashtable.</p>
+     *
+     * @param  key  possible key.
+     * @return <code>true</code> if and only if the specified object is a
+     *    key in this hashtable, as determined by the <tt>equals</tt>
+     *    method; <code>false</code> otherwise.
+     * @see #contains(Object)
+     */
+    public boolean containsKey(int key) {
+        Entry tab[] = table;
+        int hash = key;
+        int index = (hash & 0x7FFFFFFF) % tab.length;
+        for (Entry e = tab[index]; e != null; e = e.next) {
+            if (e.hash == hash) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * <p>Returns the value to which the specified key is mapped in this map.</p>
+     *
+     * @param   key   a key in the hashtable.
+     * @return  the value to which the key is mapped in this hashtable;
+     *          <code>null</code> if the key is not mapped to any value in
+     *          this hashtable.
+     * @see     #put(int, Object)
+     */
+    public Object get(int key) {
+        Entry tab[] = table;
+        int hash = key;
+        int index = (hash & 0x7FFFFFFF) % tab.length;
+        for (Entry e = tab[index]; e != null; e = e.next) {
+            if (e.hash == hash) {
+                return e.value;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * <p>Increases the capacity of and internally reorganizes this
+     * hashtable, in order to accommodate and access its entries more
+     * efficiently.</p>
+     *
+     * <p>This method is called automatically when the number of keys
+     * in the hashtable exceeds this hashtable's capacity and load
+     * factor.</p>
+     */
+    protected void rehash() {
+        int oldCapacity = table.length;
+        Entry oldMap[] = table;
+
+        int newCapacity = oldCapacity * 2 + 1;
+        Entry newMap[] = new Entry[newCapacity];
+
+        threshold = (int) (newCapacity * loadFactor);
+        table = newMap;
+
+        for (int i = oldCapacity; i-- > 0;) {
+            for (Entry old = oldMap[i]; old != null;) {
+                Entry e = old;
+                old = old.next;
+
+                int index = (e.hash & 0x7FFFFFFF) % newCapacity;
+                e.next = newMap[index];
+                newMap[index] = e;
+            }
+        }
+    }
+
+    /**
+     * <p>Maps the specified <code>key</code> to the specified
+     * <code>value</code> in this hashtable. The key cannot be
+     * <code>null</code>. </p>
+     *
+     * <p>The value can be retrieved by calling the <code>get</code> method
+     * with a key that is equal to the original key.</p>
+     *
+     * @param key     the hashtable key.
+     * @param value   the value.
+     * @return the previous value of the specified key in this hashtable,
+     *         or <code>null</code> if it did not have one.
+     * @throws  NullPointerException  if the key is <code>null</code>.
+     * @see     #get(int)
+     */
+    public Object put(int key, Object value) {
+        // Makes sure the key is not already in the hashtable.
+        Entry tab[] = table;
+        int hash = key;
+        int index = (hash & 0x7FFFFFFF) % tab.length;
+        for (Entry e = tab[index]; e != null; e = e.next) {
+            if (e.hash == hash) {
+                Object old = e.value;
+                e.value = value;
+                return old;
+            }
+        }
+
+        if (count >= threshold) {
+            // Rehash the table if the threshold is exceeded
+            rehash();
+
+            tab = table;
+            index = (hash & 0x7FFFFFFF) % tab.length;
+        }
+
+        // Creates the new entry.
+        Entry e = new Entry(hash, key, value, tab[index]);
+        tab[index] = e;
+        count++;
+        return null;
+    }
+
+    /**
+     * <p>Removes the key (and its corresponding value) from this
+     * hashtable.</p>
+     *
+     * <p>This method does nothing if the key is not present in the
+     * hashtable.</p>
+     *
+     * @param   key   the key that needs to be removed.
+     * @return  the value to which the key had been mapped in this hashtable,
+     *          or <code>null</code> if the key did not have a mapping.
+     */
+    public Object remove(int key) {
+        Entry tab[] = table;
+        int hash = key;
+        int index = (hash & 0x7FFFFFFF) % tab.length;
+        for (Entry e = tab[index], prev = null; e != null; prev = e, e = e.next) {
+            if (e.hash == hash) {
+                if (prev != null) {
+                    prev.next = e.next;
+                } else {
+                    tab[index] = e.next;
+                }
+                count--;
+                Object oldValue = e.value;
+                e.value = null;
+                return oldValue;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * <p>Clears this hashtable so that it contains no keys.</p>
+     */
+    public synchronized void clear() {
+        Entry tab[] = table;
+        for (int index = tab.length; --index >= 0;) {
+            tab[index] = null;
+        }
+        count = 0;
+    }
+    
+}

src/com/dmdirc/addons/freedesktop_notifications/commons/StringEscapeUtils.java

@@ -0,0 +1,180 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.dmdirc.addons.freedesktop_notifications.commons;
+
+import java.io.IOException;
+import java.io.StringWriter;
+import java.io.Writer;
+import java.util.Locale;
+
+/**
+ * <p>Escapes and unescapes <code>String</code>s for
+ * Java, Java Script, HTML, XML, and SQL.</p>
+ *
+ * @author Apache Jakarta Turbine
+ * @author Purple Technology
+ * @author <a href="mailto:alex@purpletech.com">Alexander Day Chaffee</a>
+ * @author Antony Riley
+ * @author Helge Tesgaard
+ * @author <a href="sean@boohai.com">Sean Brown</a>
+ * @author <a href="mailto:ggregory@seagullsw.com">Gary Gregory</a>
+ * @author Phil Steitz
+ * @author Pete Gieser
+ * @since 2.0
+ * @version $Id$
+ */
+public class StringEscapeUtils {
+    // HTML and XML
+    //--------------------------------------------------------------------------
+    /**
+     * <p>Escapes the characters in a <code>String</code> using HTML entities.</p>
+     *
+     * <p>
+     * For example:
+     * </p> 
+     * <p><code>"bread" & "butter"</code></p>
+     * becomes:
+     * <p>
+     * <code>&amp;quot;bread&amp;quot; &amp;amp; &amp;quot;butter&amp;quot;</code>.
+     * </p>
+     *
+     * <p>Supports all known HTML 4.0 entities, including funky accents.
+     * Note that the commonly used apostrophe escape character (&amp;apos;)
+     * is not a legal entity and so is not supported). </p>
+     *
+     * @param str  the <code>String</code> to escape, may be null
+     * @return a new escaped <code>String</code>, <code>null</code> if null string input
+     * 
+     * @see #unescapeHtml(String)
+     * @see <a href="http://hotwired.lycos.com/webmonkey/reference/special_characters/">ISO Entities</a>
+     * @see <a href="http://www.w3.org/TR/REC-html32#latin1">HTML 3.2 Character Entities for ISO Latin-1</a>
+     * @see <a href="http://www.w3.org/TR/REC-html40/sgml/entities.html">HTML 4.0 Character entity references</a>
+     * @see <a href="http://www.w3.org/TR/html401/charset.html#h-5.3">HTML 4.01 Character References</a>
+     * @see <a href="http://www.w3.org/TR/html401/charset.html#code-position">HTML 4.01 Code positions</a>
+     */
+    public static String escapeHtml(String str) {
+        if (str == null) {
+            return null;
+        }
+        try {
+            StringWriter writer = new StringWriter ((int)(str.length() * 1.5));
+            escapeHtml(writer, str);
+            return writer.toString();
+        } catch (IOException ioe) {
+            //should be impossible
+            throw new UnhandledException(ioe);
+        }
+    }
+
+    /**
+     * <p>Escapes the characters in a <code>String</code> using HTML entities and writes
+     * them to a <code>Writer</code>.</p>
+     *
+     * <p>
+     * For example:
+     * </p> 
+     * <code>"bread" & "butter"</code>
+     * <p>becomes:</p>
+     * <code>&amp;quot;bread&amp;quot; &amp;amp; &amp;quot;butter&amp;quot;</code>.
+     *
+     * <p>Supports all known HTML 4.0 entities, including funky accents.
+     * Note that the commonly used apostrophe escape character (&amp;apos;)
+     * is not a legal entity and so is not supported). </p>
+     *
+     * @param writer  the writer receiving the escaped string, not null
+     * @param string  the <code>String</code> to escape, may be null
+     * @throws IllegalArgumentException if the writer is null
+     * @throws IOException when <code>Writer</code> passed throws the exception from
+     *                                       calls to the {@link Writer#write(int)} methods.
+     * 
+     * @see #escapeHtml(String)
+     * @see #unescapeHtml(String)
+     * @see <a href="http://hotwired.lycos.com/webmonkey/reference/special_characters/">ISO Entities</a>
+     * @see <a href="http://www.w3.org/TR/REC-html32#latin1">HTML 3.2 Character Entities for ISO Latin-1</a>
+     * @see <a href="http://www.w3.org/TR/REC-html40/sgml/entities.html">HTML 4.0 Character entity references</a>
+     * @see <a href="http://www.w3.org/TR/html401/charset.html#h-5.3">HTML 4.01 Character References</a>
+     * @see <a href="http://www.w3.org/TR/html401/charset.html#code-position">HTML 4.01 Code positions</a>
+     */
+    public static void escapeHtml(Writer writer, String string) throws IOException {
+        if (writer == null ) {
+            throw new IllegalArgumentException ("The Writer must not be null.");
+        }
+        if (string == null) {
+            return;
+        }
+        Entities.HTML40.escape(writer, string);
+    }
+
+    //-----------------------------------------------------------------------
+    /**
+     * <p>Unescapes a string containing entity escapes to a string
+     * containing the actual Unicode characters corresponding to the
+     * escapes. Supports HTML 4.0 entities.</p>
+     *
+     * <p>For example, the string "&amp;lt;Fran&amp;ccedil;ais&amp;gt;"
+     * will become "&lt;Fran&ccedil;ais&gt;"</p>
+     *
+     * <p>If an entity is unrecognized, it is left alone, and inserted
+     * verbatim into the result string. e.g. "&amp;gt;&amp;zzzz;x" will
+     * become "&gt;&amp;zzzz;x".</p>
+     *
+     * @param str  the <code>String</code> to unescape, may be null
+     * @return a new unescaped <code>String</code>, <code>null</code> if null string input
+     * @see #escapeHtml(Writer, String)
+     */
+    public static String unescapeHtml(String str) {
+        if (str == null) {
+            return null;
+        }
+        try {
+            StringWriter writer = new StringWriter ((int)(str.length() * 1.5));
+            unescapeHtml(writer, str);
+            return writer.toString();
+        } catch (IOException ioe) {
+            //should be impossible
+            throw new UnhandledException(ioe);
+        }
+    }
+
+    /**
+     * <p>Unescapes a string containing entity escapes to a string
+     * containing the actual Unicode characters corresponding to the
+     * escapes. Supports HTML 4.0 entities.</p>
+     *
+     * <p>For example, the string "&amp;lt;Fran&amp;ccedil;ais&amp;gt;"
+     * will become "&lt;Fran&ccedil;ais&gt;"</p>
+     *
+     * <p>If an entity is unrecognized, it is left alone, and inserted
+     * verbatim into the result string. e.g. "&amp;gt;&amp;zzzz;x" will
+     * become "&gt;&amp;zzzz;x".</p>
+     *
+     * @param writer  the writer receiving the unescaped string, not null
+     * @param string  the <code>String</code> to unescape, may be null
+     * @throws IllegalArgumentException if the writer is null
+     * @throws IOException if an IOException occurs
+     * @see #escapeHtml(String)
+     */
+    public static void unescapeHtml(Writer writer, String string) throws IOException {
+        if (writer == null ) {
+            throw new IllegalArgumentException ("The Writer must not be null.");
+        }
+        if (string == null) {
+            return;
+        }
+        Entities.HTML40.unescape(writer, string);
+    }
+}

src/com/dmdirc/addons/freedesktop_notifications/commons/UnhandledException.java

@@ -0,0 +1,71 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.dmdirc.addons.freedesktop_notifications.commons;
+
+/**
+ * <p>Thrown when it is impossible or undesirable to consume or throw a checked exception.</p>
+ * This exception supplements the standard exception classes by providing a more
+ * semantically rich description of the problem.</p>
+ * 
+ * <p><code>UnhandledException</code> represents the case where a method has to deal
+ * with a checked exception but does not wish to.
+ * Instead, the checked exception is rethrown in this unchecked wrapper.</p>
+ * 
+ * <pre>
+ * public void foo() {
+ *   try {
+ *     // do something that throws IOException
+ *   } catch (IOException ex) {
+ *     // don't want to or can't throw IOException from foo()
+ *     throw new UnhandledException(ex);
+ *   }
+ * }
+ * </pre>
+ *
+ * @author Matthew Hawthorne
+ * @since 2.0
+ * @version $Id$
+ */
+public class UnhandledException extends RuntimeException {
+
+    /**
+     * Required for serialization support.
+     * 
+     * @see java.io.Serializable
+     */
+    private static final long serialVersionUID = 1832101364842773720L;
+
+    /**
+     * Constructs the exception using a cause.
+     *
+     * @param cause  the underlying cause
+     */
+    public UnhandledException(Throwable cause) {
+        super(cause);
+    }
+
+    /**
+     * Constructs the exception using a message and cause.
+     *
+     * @param message  the message to use
+     * @param cause  the underlying cause
+     */
+    public UnhandledException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+}

src/com/dmdirc/addons/freedesktop_notifications/files/notify.py

@@ -0,0 +1,93 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+# Default Configuration (will be overridden by cmd line arguments)
+APPLICATION    = ''        # name of the calling application (will be shown if now summary is available)
+SUMMARY        = ''
+BODY        = ''
+ICON        = 'preferences-desktop-notification'
+TIMEOUT        = 2000        # 0 means, never hide the message; value greater than 0 is the time in ms the message is shown
+
+import sys
+import getopt
+import dbus
+
+def main():
+    dbus = DBus()
+    args = CmdLine(sys.argv[1:])
+    dbus.notify(app_name=args.getApplication(), app_icon=args.getIcon(), summary=args.getSummary(), body=args.getBody(), timeout=args.getTime())
+
+class CmdLine():
+    def __init__(self, argv):
+        try:
+            opts, args = getopt.getopt(argv, 'hs:a:i:t:', ['help', 'summary=', 'app=', 'icon=', 'time='])
+        except getopt.GetoptError:
+            usage()
+            sys.exit(2)
+
+        for opt, arg in opts:
+            if opt in ('-h', '--help'):
+                usage()
+                sys.exit()
+            elif opt in ('-s', '--summary'):
+                self.__summary = arg
+            elif opt in ('-a', '--app'):
+                self.__app = arg
+            elif opt in ('-i', '--icon'):
+                self.__icon = arg
+            elif opt in ('-t', '--time'):
+                self.__time = arg
+
+        if len(args) > 0:
+            self.__body = ' '.join(args)
+
+    def getApplication(self):
+        try:
+            return self.__app
+        except AttributeError:
+            return APPLICATION
+
+    def getSummary(self):
+        try:
+            return self.__summary
+        except AttributeError:
+            return SUMMARY
+
+    def getBody(self):
+        try:
+            return self.__body
+        except AttributeError:
+            return BODY
+
+    def getIcon(self):
+        try:
+            return self.__icon
+        except AttributeError:
+            return ICON
+
+    def getTime(self):
+        try:
+            return int(self.__time)
+        except ValueError:
+            return TIMEOUT
+        except AttributeError:
+            return TIMEOUT
+
+def usage():
+    """print usage message"""
+    print 'Usage: notify.py [-a|--app=<application>] [-i|--icon=<icon name or path>] [-t|--time=<time>] [-s|--summary=<summary>] [<message>]'
+
+class DBus():
+    """Wrapper class for notify daemon dbus interface"""
+
+    def __init__(self):
+        self.__notify = dbus.SessionBus().get_object('org.freedesktop.Notifications', '/org/freedesktop/Notifications')
+    
+    def notify(self, app_name='', replaces_id=dbus.UInt32(), event_id='', app_icon='', summary='', body='', actions=dbus.Array(signature='s'), hints=dbus.Dictionary(signature='sv'), timeout=0):
+        print self.__notify.Notify(app_name, replaces_id, app_icon, summary, body, actions, hints, timeout)
+
+    def closeNotification(self, event_id):
+        self.__notify.CloseNotification(event_id)
+
+if __name__ == "__main__":
+    main();

src/com/dmdirc/addons/freedesktop_notifications/licences/Apache Commons - ASF 2.0

@@ -0,0 +1,175 @@
+The Freedesktop Notifications plugin makes use of part of the Apache
+Commons library, which is licensed under the Apache Software Foundation
+License Version 2, the full text of which is included below.
+
+----------
+
+Licensed to the Apache Software Foundation (ASF) under one or more
+contributor license agreements.  See the NOTICE file distributed with
+this work for additional information regarding copyright ownership.
+The ASF licenses this file to You under the Apache License, Version 2.0
+(the "License"); you may not use this file except in compliance with
+the License.  You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0 (See Below)
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+----------
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and 
+distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright 
+owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities 
+that control, are controlled by, or are under common control with that entity. 
+For the purposes of this definition, "control" means (i) the power, direct or 
+indirect, to cause the direction or management of such entity, whether by 
+contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the 
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising 
+permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including 
+but not limited to software source code, documentation source, and 
+configuration files.
+
+"Object" form shall mean any form resulting from mechanical transformation or 
+translation of a Source form, including but not limited to compiled object 
+code, generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, 
+made available under the License, as indicated by a copyright notice that is 
+included in or attached to the work (an example is provided in the Appendix 
+below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that 
+is based on (or derived from) the Work and for which the editorial revisions, 
+annotations, elaborations, or other modifications represent, as a whole, an 
+original work of authorship. For the purposes of this License, Derivative Works 
+shall not include works that remain separable from, or merely link (or bind by 
+name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original 
+version of the Work and any modifications or additions to that Work or 
+Derivative Works thereof, that is intentionally submitted to Licensor for 
+inclusion in the Work by the copyright owner or by an individual or Legal 
+Entity authorized to submit on behalf of the copyright owner. For the purposes 
+of this definition, "submitted" means any form of electronic, verbal, or 
+written communication sent to the Licensor or its representatives, including 
+but not limited to communication on electronic mailing lists, source code 
+control systems, and issue tracking systems that are managed by, or on behalf 
+of, the Licensor for the purpose of discussing and improving the Work, but 
+excluding communication that is conspicuously marked or otherwise designated in 
+writing by the copyright owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf 
+of whom a Contribution has been received by Licensor and subsequently 
+incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this 
+License, each Contributor hereby grants to You a perpetual, worldwide, 
+non-exclusive, no-charge, royalty-free, irrevocable copyright license to 
+reproduce, prepare Derivative Works of, publicly display, publicly perform, 
+sublicense, and distribute the Work and such Derivative Works in Source or 
+Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of this 
+License, each Contributor hereby grants to You a perpetual, worldwide, 
+non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this 
+section) patent license to make, have made, use, offer to sell, sell, import, 
+and otherwise transfer the Work, where such license applies only to those 
+patent claims licensable by such Contributor that are necessarily infringed by 
+their Contribution(s) alone or by combination of their Contribution(s) with the 
+Work to which such Contribution(s) was submitted. If You institute patent 
+litigation against any entity (including a cross-claim or counterclaim in a 
+lawsuit) alleging that the Work or a Contribution incorporated within the Work 
+constitutes direct or contributory patent infringement, then any patent 
+licenses granted to You under this License for that Work shall terminate as of 
+the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or 
+Derivative Works thereof in any medium, with or without modifications, and in 
+Source or Object form, provided that You meet the following conditions:
+
+   1. You must give any other recipients of the Work or Derivative Works a copy 
+of this License; and
+
+   2. You must cause any modified files to carry prominent notices stating that 
+You changed the files; and
+
+   3. You must retain, in the Source form of any Derivative Works that You 
+distribute, all copyright, patent, trademark, and attribution notices from the 
+Source form of the Work, excluding those notices that do not pertain to any 
+part of the Derivative Works; and
+
+   4. If the Work includes a "NOTICE" text file as part of its distribution, 
+then any Derivative Works that You distribute must include a readable copy of 
+the attribution notices contained within such NOTICE file, excluding those 
+notices that do not pertain to any part of the Derivative Works, in at least 
+one of the following places: within a NOTICE text file distributed as part of 
+the Derivative Works; within the Source form or documentation, if provided 
+along with the Derivative Works; or, within a display generated by the 
+Derivative Works, if and wherever such third-party notices normally appear. The 
+contents of the NOTICE file are for informational purposes only and do not 
+modify the License. You may add Your own attribution notices within Derivative 
+Works that You distribute, alongside or as an addendum to the NOTICE text from 
+the Work, provided that such additional attribution notices cannot be construed 
+as modifying the License.
+
+You may add Your own copyright statement to Your modifications and may provide 
+additional or different license terms and conditions for use, reproduction, or 
+distribution of Your modifications, or for any such Derivative Works as a 
+whole, provided Your use, reproduction, and distribution of the Work otherwise 
+complies with the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise, any 
+Contribution intentionally submitted for inclusion in the Work by You to the 
+Licensor shall be under the terms and conditions of this License, without any 
+additional terms or conditions. Notwithstanding the above, nothing herein shall 
+supersede or modify the terms of any separate license agreement you may have 
+executed with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade names, 
+trademarks, service marks, or product names of the Licensor, except as required 
+for reasonable and customary use in describing the origin of the Work and 
+reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to in 
+writing, Licensor provides the Work (and each Contributor provides its 
+Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 
+KIND, either express or implied, including, without limitation, any warranties 
+or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A 
+PARTICULAR PURPOSE. You are solely responsible for determining the 
+appropriateness of using or redistributing the Work and assume any risks 
+associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory, whether in 
+tort (including negligence), contract, or otherwise, unless required by 
+applicable law (such as deliberate and grossly negligent acts) or agreed to in 
+writing, shall any Contributor be liable to You for damages, including any 
+direct, indirect, special, incidental, or consequential damages of any 
+character arising as a result of this License or out of the use or inability to 
+use the Work (including but not limited to damages for loss of goodwill, work 
+stoppage, computer failure or malfunction, or any and all other commercial 
+damages or losses), even if such Contributor has been advised of the 
+possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work or 
+Derivative Works thereof, You may choose to offer, and charge a fee for, 
+acceptance of support, warranty, indemnity, or other liability obligations 
+and/or rights consistent with this License. However, in accepting such 
+obligations, You may act only on Your own behalf and on Your sole 
+responsibility, not on behalf of any other Contributor, and only if You agree 
+to indemnify, defend, and hold each Contributor harmless for any liability 
+incurred by, or claims asserted against, such Contributor by reason of your 
+accepting any such warranty or additional liability. 

src/com/dmdirc/addons/freedesktop_notifications/plugin.config

@@ -0,0 +1,46 @@
+# This is a DMDirc configuration file.
+
+# This section indicates which sections below take key/value
+# pairs, rather than a simple list. It should be placed above
+# any sections that take key/values.
+keysections:
+  metadata
+  requires
+  updates
+  defaults
+  formatters
+  icons
+  version
+
+metadata:
+  author=Shane <shane@dmdirc.com>
+  mainclass=com.dmdirc.addons.freedesktop_notifications.FreeDesktopNotificationsPlugin
+  description=Adds FreeDesktop-Style Notifications to dmdirc
+  name=freedesktop_notifications
+  nicename=FreeDesktop Notifications Plugin
+
+updates:
+  id=48
+
+version:
+  number=8
+  friendly=0.8
+
+defaults:
+    general.hideoutput=false
+
+requires:
+#    linux os
+
+provides:
+  osd feature
+
+defaults:
+  general.timeout=5
+  general.kdialog=false
+  advanced.escapehtml=true
+  advanced.strictescape=true
+  advanced.stripcodes=true
+
+exports:
+  showNotification in com.dmdirc.addons.freedesktop_notifications.FreeDesktopNotificationsPlugin as showNotification