Merge branch 'master' of https://github.com/DMDirc/Plugins into qauth

identd/src/com/dmdirc/addons/identd/IdentdPlugin.java

 
 package com.dmdirc.addons.identd;
 
-import com.dmdirc.config.prefs.PluginPreferencesCategory;
-import com.dmdirc.config.prefs.PreferencesCategory;
-import com.dmdirc.config.prefs.PreferencesDialogModel;
-import com.dmdirc.config.prefs.PreferencesSetting;
-import com.dmdirc.config.prefs.PreferencesType;
 import com.dmdirc.plugins.PluginInfo;
 import com.dmdirc.plugins.implementations.BasePlugin;
-import com.dmdirc.util.validators.PortValidator;
 
 import dagger.ObjectGraph;
 
  */
 public class IdentdPlugin extends BasePlugin {
 
-    /** This plugin's plugin info. */
-    private final PluginInfo pluginInfo;
-    /** This plugin's settings domain. */
-    private final String domain;
     /** Identd Manager. */
     private IdentdManager identdManager;
 
-    /**
-     * Creates a new instance of this plugin.
-     *
-     * @param pluginInfo This plugin's plugin info
-     */
-    public IdentdPlugin(final PluginInfo pluginInfo) {
-        this.pluginInfo = pluginInfo;
-        domain = pluginInfo.getDomain();
-    }
-
     @Override
     public void load(final PluginInfo pluginInfo, final ObjectGraph graph) {
         super.load(pluginInfo, graph);

notifications/src/com/dmdirc/addons/notifications/LegacyNotificationHandler.java

+/*
+ * Copyright (c) 2006-2015 DMDirc Developers
+ *
+ * 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.notifications;
+
+import com.dmdirc.plugins.ExportedService;
+import com.dmdirc.plugins.PluginInfo;
+
+/**
+ * A notification handler that works using exported services.
+ */
+public class LegacyNotificationHandler implements NotificationHandler {
+
+    private final PluginInfo pluginInfo;
+
+    public LegacyNotificationHandler(final PluginInfo pluginInfo) {
+        this.pluginInfo = pluginInfo;
+    }
+
+    @Override
+    public void showNotification(final String title, final String message) {
+        final ExportedService source = pluginInfo.getExportedService("showNotification");
+        if (source != null) {
+            source.execute(title, message);
+        }
+    }
+
+}

notifications/src/com/dmdirc/addons/notifications/NotificationCommand.java

 import com.dmdirc.commandparser.commands.IntelligentCommand;
 import com.dmdirc.commandparser.commands.context.CommandContext;
 import com.dmdirc.interfaces.CommandController;
-import com.dmdirc.plugins.ExportedService;
-import com.dmdirc.plugins.PluginInfo;
 import com.dmdirc.ui.input.AdditionalTabTargets;
 
-import java.util.List;
-import java.util.stream.Collectors;
+import java.util.Collection;
 
 import javax.annotation.Nonnull;
 
                 "--method".equalsIgnoreCase(args.getArguments()[0])) {
             if (args.getArguments().length > 1) {
                 final String sourceName = args.getArguments()[1];
-                final ExportedService source = manager.getMethod(sourceName)
-                        .getExportedService("showNotification");
+                final NotificationHandler handler = manager.getHandler(sourceName);
 
-                if (source == null) {
+                if (handler == null) {
                     sendLine(origin, args.isSilent(), FORMAT_ERROR,
                             "Method not found.");
                 } else {
-                    source.execute("DMDirc", args.getArgumentsAsString(2));
+                    handler.showNotification("DMDirc", args.getArgumentsAsString(2));
                 }
             } else {
                 sendLine(origin, args.isSilent(), FORMAT_ERROR,
                         "You must specify a method when using --method.");
             }
-        } else if (manager.hasActiveMethod()) {
-            manager.getPreferredMethod().getExportedService("showNotification")
-                    .execute("DMDirc", args.getArgumentsAsString(0));
+        } else if (manager.hasActiveHandler()) {
+            manager.getPreferredHandler().showNotification("DMDirc", args.getArgumentsAsString(0));
         } else {
             sendLine(origin, args.isSilent(), FORMAT_ERROR,
                     "No active notification methods available.");
      */
     private void doMethodList(final FrameContainer origin,
             final boolean isSilent) {
-        final List<PluginInfo> methods = manager.getMethods();
+        final Collection<String> handlers = manager.getHandlerNames();
 
-        if (methods.isEmpty()) {
+        if (handlers.isEmpty()) {
             sendLine(origin, isSilent, FORMAT_ERROR, "No notification "
                     + "methods available.");
         } else {
             final String[] headers = {"Method"};
-            final String[][] data = new String[methods.size()][1];
+            final String[][] data = new String[handlers.size()][1];
             int i = 0;
-            for (PluginInfo method : methods) {
-                data[i][0] = method.getMetaData().getName();
+            for (String handler : handlers) {
+                data[i][0] = handler;
                 i++;
             }
 
             res.add("--method");
             return res;
         } else if (arg == 1 && "--method".equalsIgnoreCase(context.getPreviousArgs().get(0))) {
-            res.addAll(manager.getMethods().stream()
-                    .map(source -> source.getMetaData().getName())
-                    .collect(Collectors.toList()));
+            res.addAll(manager.getHandlerNames());
             return res;
         }
         return res;

notifications/src/com/dmdirc/addons/notifications/NotificationHandler.java

+/*
+ * Copyright (c) 2006-2015 DMDirc Developers
+ *
+ * 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.notifications;
+
+/**
+ * Handler of notifications.
+ */
+public interface NotificationHandler {
+
+    /**
+     * Displays a notification to the user.
+     *
+     * @param title The title of the notification.
+     * @param message The notification content.
+     */
+    void showNotification(String title, String message);
+
+}

notifications/src/com/dmdirc/addons/notifications/NotificationsManager.java

 
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 import javax.inject.Inject;
 
 
 public class NotificationsManager {
 
-    /** The notification methods that we know of. */
-    private final Collection<String> methods = new ArrayList<>();
+    /** The notification handlers that we know of. */
+    private final Map<String, NotificationHandler> handlers = new HashMap<>();
     /** The user's preferred order for method usage. */
     private List<String> order;
     /** This plugin's settings domain. */
     }
 
     public void onLoad() {
-        methods.clear();
+        handlers.clear();
         loadSettings();
         eventBus.subscribe(this);
         pluginManager.getPluginInfos().stream()
     }
 
     public void onUnload() {
-        methods.clear();
+        handlers.clear();
         eventBus.unsubscribe(this);
     }
 
      */
     private void addPlugin(final PluginInfo target) {
         if (target.hasExportedService("showNotification")) {
-            methods.add(target.getMetaData().getName());
-            addMethodToOrder(target);
+            handlers.put(target.getMetaData().getName(), new LegacyNotificationHandler(pluginInfo));
+            addHandlerToOrder(target);
         }
     }
 
      *
      * @param source The notification method to be tested
      */
-    private void addMethodToOrder(final PluginInfo source) {
+    private void addHandlerToOrder(final PluginInfo source) {
         if (!order.contains(source.getMetaData().getName())) {
             order.add(source.getMetaData().getName());
         }
      * @param target The plugin to be tested
      */
     private void removePlugin(final PluginInfo target) {
-        methods.remove(target.getMetaData().getName());
+        handlers.remove(target.getMetaData().getName());
     }
 
     /**
-     * Retrieves a method based on its name.
+     * Retrieves a handler based on its name.
      *
      * @param name The name to search for
      *
-     * @return The method with the specified name or null if none were found.
+     * @return The handler with the specified name or null if none were found.
      */
-    public PluginInfo getMethod(final String name) {
-        return pluginManager.getPluginInfoByName(name);
+    public NotificationHandler getHandler(final String name) {
+        return handlers.get(name);
     }
 
     /**
-     * Retrieves all the methods registered with this plugin.
+     * Retrieves the names of all the handlers registered with this plugin.
      *
-     * @return All known notification sources
+     * @return All known notification handler names
      */
-    public List<PluginInfo> getMethods() {
-        final List<PluginInfo> plugins = new ArrayList<>();
-        for (String method : methods) {
-            plugins.add(pluginManager.getPluginInfoByName(method));
-        }
-        return plugins;
+    public Collection<String> getHandlerNames() {
+        return handlers.keySet();
     }
 
     /**
-     * Does this plugin have any active notification methods?
+     * Does this plugin have any active notification handler?
      *
-     * @return true iif active notification methods are registered
+     * @return true iif active notification handlers are registered
      */
-    public boolean hasActiveMethod() {
-        return !methods.isEmpty();
+    public boolean hasActiveHandler() {
+        return !handlers.isEmpty();
     }
 
     /**
-     * Returns the user's preferred method if loaded, or null if none loaded.
+     * Returns the user's preferred handler if loaded, or null if none loaded.
      *
-     * @return Preferred notification method
+     * @return Preferred notification handler
      */
-    public PluginInfo getPreferredMethod() {
-        if (methods.isEmpty()) {
+    public NotificationHandler getPreferredHandler() {
+        if (handlers.isEmpty()) {
             return null;
         }
         for (String method : order) {
-            if (methods.contains(method)) {
-                return pluginManager.getPluginInfoByName(method);
+            if (handlers.containsKey(method)) {
+                return handlers.get(method);
             }
         }
         return null;

osd/src/com/dmdirc/addons/osd/OsdPlugin.java

  */
 public class OsdPlugin extends BaseCommandPlugin {
 
-
     /** The OSD Manager that this plugin is using. */
     private OsdManager osdManager;
 

ui_swing/src/com/dmdirc/addons/ui_swing/SwingController.java

 public class SwingController extends BaseCommandPlugin implements UIController {
 
     /** This plugin's plugin info object. */
-    private final PluginInfo pluginInfo;
+    private PluginInfo pluginInfo;
     /** The manager we're using for dependencies. */
     private SwingManager swingManager;
 
-    /**
-     * Instantiates a new SwingController.
-     *
-     * @param pluginInfo      Plugin info
-     */
-    public SwingController(final PluginInfo pluginInfo) {
-        this.pluginInfo = pluginInfo;
-    }
-
     @Override
     public void load(final PluginInfo pluginInfo, final ObjectGraph graph) {
         super.load(pluginInfo, graph);
 
+        this.pluginInfo = pluginInfo;
+
         setObjectGraph(graph.plus(new SwingModule(this, pluginInfo, pluginInfo.getDomain())));
         getObjectGraph().validate();
         swingManager = getObjectGraph().get(SwingManager.class);

ui_swing/src/com/dmdirc/addons/ui_swing/components/addonpanel/PluginPanel.java

 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.Comparator;
 import java.util.List;
 
 import javax.inject.Inject;
 
     /** A version number for this class. */
     private static final long serialVersionUID = 1;
+
+    /** Comparator to use to sort plugins in the panel. */
+    private static final Comparator<? super PluginInfo> COMPARATOR = new PluginInfoComparator();
+
     /** Manager to retrieve plugin information from. */
     private final PluginManager pluginManager;
     /** Manager to use to retrieve addon-related icons. */
         final List<PluginInfo> list = new ArrayList<>();
         final Collection<PluginInfo> sortedList = new ArrayList<>();
         list.addAll(pluginManager.getPluginInfos());
-        Collections.sort(list);
+        Collections.sort(list, COMPARATOR);
         list.stream().filter(plugin -> plugin.getMetaData().getParent() == null).forEach(plugin -> {
             final List<PluginInfo> childList = new ArrayList<>();
             sortedList.add(plugin);
             plugin.getChildren().stream()
                     .filter(child -> !childList.contains(child))
                     .forEach(childList::add);
-            Collections.sort(childList);
+            Collections.sort(childList, COMPARATOR);
             sortedList.addAll(childList);
         });
 
         return "plugins";
     }
 
+    private static class PluginInfoComparator implements Comparator<PluginInfo> {
+
+        @Override
+        public int compare(final PluginInfo o1, final PluginInfo o2) {
+            return o1.getMetaData().getName().compareTo(o2.getMetaData().getName());
+        }
+    }
+
 }