SLF4J some more plugins.

mediasource_dbus/src/com/dmdirc/addons/mediasource_dbus/DBusMediaSourceManager.java

 
 package com.dmdirc.addons.mediasource_dbus;
 
-import com.dmdirc.DMDircMBassador;
 import com.dmdirc.addons.nowplaying.MediaSource;
-import com.dmdirc.events.UserErrorEvent;
-import com.dmdirc.logger.ErrorLevel;
 
 import java.io.BufferedReader;
 import java.io.File;
 
 import javax.inject.Inject;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static com.dmdirc.util.LogUtils.USER_ERROR;
+
 /**
  * Provides a media source for DBUS players.
  */
 public class DBusMediaSourceManager {
 
+    private static final Logger LOG = LoggerFactory.getLogger(DBusMediaSourceManager.class);
     /** A map of discovered mpris sources. */
     private final Map<String, MediaSource> mprisSources;
-    /** The event bus to post errors to. */
-    private final DMDircMBassador eventBus;
     /** The sources used by this media source. */
     private final List<MediaSource> sources;
     /** The path to qdbus. */
     private String qdbus;
 
     @Inject
-    public DBusMediaSourceManager(final DMDircMBassador eventBus) {
-        this.eventBus = eventBus;
+    public DBusMediaSourceManager() {
         sources = new ArrayList<>();
         mprisSources = new HashMap<>();
     }
                 }
             }
         } catch (IOException ex) {
-            eventBus.publishAsync(new UserErrorEvent(ErrorLevel.HIGH, ex, "Unable to get DBUS info", ""));
+            LOG.error(USER_ERROR, "Unable to get DBUS info", ex);
         } finally {
             if (process != null) {
                 process.destroy();

mediasource_linux_title/src/com/dmdirc/addons/mediasource_linux_title/TitleMediaSource.java

 
 package com.dmdirc.addons.mediasource_linux_title;
 
-import com.dmdirc.DMDircMBassador;
 import com.dmdirc.addons.nowplaying.MediaSource;
 import com.dmdirc.addons.nowplaying.MediaSourceState;
-import com.dmdirc.events.UserErrorEvent;
-import com.dmdirc.logger.ErrorLevel;
 
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static com.dmdirc.util.LogUtils.USER_ERROR;
+
 /**
  * Provides a media source for Linux players using the `xwininfo` command.
  */
 public class TitleMediaSource implements MediaSource {
 
-    /** The event bus to post errors to. */
-    private final DMDircMBassador eventBus;
+    private static final Logger LOG = LoggerFactory.getLogger(TitleMediaSource.class);
     /** The command to use to get the title. */
     private final String command;
     /** The name of the player we're retrieving. */
     /**
      * Creates a new title media source.
      *
-     * @param eventBus The event bus to post errors to
      * @param command  The command to be executed
      * @param name     The name of the media source
      */
-    public TitleMediaSource(final DMDircMBassador eventBus, final String command, final String name) {
-        this.eventBus = eventBus;
+    public TitleMediaSource(final String command, final String name) {
         this.command = command;
         this.name = name;
     }
     }
 
     private String getInfo() {
-
-        final String[] args = new String[]{"/bin/bash", "-c", "xwininfo -root -tree | " + command};
+        final String[] args = {"/bin/bash", "-c", "xwininfo -root -tree | " + command};
         try {
             final Process process = Runtime.getRuntime().exec(args);
             try (InputStreamReader reader = new InputStreamReader(process.getInputStream());
                     return line;
                 }
             } catch (IOException ex) {
-                eventBus.publishAsync(new UserErrorEvent(ErrorLevel.LOW, ex,
-                        "Unable to retrieve media source info", ""));
+                LOG.info(USER_ERROR, "Unable to retrieve media source info", ex);
             }
         } catch (IOException ex) {
-            eventBus.publishAsync(new UserErrorEvent(ErrorLevel.LOW, ex,
-                            "Unable to retrieve media source info", ""));
+            LOG.info(USER_ERROR, "Unable to retrieve media source info", ex);
         }
 
         return "";

scriptplugin/src/com/dmdirc/addons/scriptplugin/ScriptEngineWrapper.java

 
 package com.dmdirc.addons.scriptplugin;
 
-import com.dmdirc.DMDircMBassador;
-import com.dmdirc.events.UserErrorEvent;
-import com.dmdirc.logger.ErrorLevel;
-
 import com.google.common.base.Preconditions;
 
 import java.io.File;
-import java.io.FileNotFoundException;
 import java.io.FileReader;
 import java.io.IOException;
 
 import javax.script.ScriptEngineManager;
 import javax.script.ScriptException;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static com.dmdirc.util.LogUtils.USER_ERROR;
+
 /**
  * Class to create script engines!
  */
 public class ScriptEngineWrapper {
 
-    /** The event bus to post errors to. */
-    private final DMDircMBassador eventBus;
+    private static final Logger LOG = LoggerFactory.getLogger(ScriptEngineWrapper.class);
     /** The Script Engine this wrapper wraps */
     private ScriptEngine engine;
     /** The File this script is from */
      * Create a new ScriptEngineWrapper
      *
      * @param scriptEngineManager Manager to get script engines
-     * @param eventBus            The event bus to post errors to
      * @param filename            Filename of script
      *
-     * @throws java.io.FileNotFoundException If file is not found
-     * @throws javax.script.ScriptException  If there was an error during creation
+     * @throws ScriptException  If there was an error during creation
      */
     protected ScriptEngineWrapper(final ScriptEngineManager scriptEngineManager,
-            final DMDircMBassador eventBus, final String filename)
-            throws FileNotFoundException, ScriptException {
+            final String filename) throws ScriptException {
         Preconditions.checkNotNull(filename, "File cannot be null");
-        this.eventBus = eventBus;
         this.scriptEngineManager = scriptEngineManager;
         file = new File(filename);
 
      *
      * @return Created script engine
      *
-     * @throws javax.script.ScriptException  If there was an error during creation
+     * @throws ScriptException  If there was an error during creation
      */
     protected ScriptEngine createEngine() throws ScriptException {
         final ScriptEngine result = scriptEngineManager.getEngineByName("JavaScript");
             // and do nothing rather that add an error every time a method is called
             // that doesn't exist (such as the action_* methods)
         } catch (ScriptException e) {
-            eventBus.publishAsync(new UserErrorEvent(ErrorLevel.LOW, e,
-                    "Error calling '" + functionName + "' in '" + file.getPath() + "': " +
-                            e.getMessage(), ""));
+            LOG.info(USER_ERROR, "Error calling '{}' in '{}': {}",
+                    functionName, file.getPath(), e.getMessage(), e);
         }
     }
 
             // Tell it that it has been rehashed
             callFunction("onRehashSucess");
         } catch (ScriptException e) {
-            eventBus.publishAsync(new UserErrorEvent(ErrorLevel.LOW, e,
-                    "Reloading '" + file.getPath() + "' failed: " + e.getMessage(), ""));
+            LOG.info(USER_ERROR, "Reloading '{}' failed: {}", file.getPath(), e.getMessage(), e);
             // Tell it that its rehash failed
             callFunction("onRehashFailed", e);
             return false;

scriptplugin/src/com/dmdirc/addons/scriptplugin/ScriptManager.java

 
 package com.dmdirc.addons.scriptplugin;
 
-import com.dmdirc.DMDircMBassador;
 import com.dmdirc.commandline.CommandLineOptionsModule.Directory;
-import com.dmdirc.events.UserErrorEvent;
-import com.dmdirc.logger.ErrorLevel;
 
 import java.io.File;
-import java.io.FileNotFoundException;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.LinkedList;
 import javax.script.ScriptEngineManager;
 import javax.script.ScriptException;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static com.dmdirc.util.LogUtils.USER_ERROR;
+
 public class ScriptManager {
 
+    private static final Logger LOG = LoggerFactory.getLogger(ScriptManager.class);
     /** Script engine manager. */
     private final ScriptEngineManager scriptEngineManager;
     /** Script directory. */
     private final String scriptDirectory;
     /** Store Script State Name,Engine */
     private final Map<String, ScriptEngineWrapper> scripts = new HashMap<>();
-    /** The event bus to post events to. */
-    private final DMDircMBassador eventBus;
 
     @Inject
     public ScriptManager(final ScriptEngineManager scriptEngineManager,
-            @Directory(ScriptModule.SCRIPTS) final String scriptDirectory,
-            final DMDircMBassador eventBus) {
+            @Directory(ScriptModule.SCRIPTS) final String scriptDirectory) {
         this.scriptEngineManager = scriptEngineManager;
         this.scriptDirectory = scriptDirectory;
-        this.eventBus = eventBus;
     }
 
     /**
         if (!scripts.containsKey(scriptFilename)) {
             try {
                 final ScriptEngineWrapper wrapper = new ScriptEngineWrapper(scriptEngineManager,
-                        eventBus, scriptFilename);
+                        scriptFilename);
                 scripts.put(scriptFilename, wrapper);
-            } catch (FileNotFoundException | ScriptException e) {
-                eventBus.publishAsync(new UserErrorEvent(ErrorLevel.LOW, e,
-                        "Error loading '" + scriptFilename + "': " + e.getMessage(), ""));
+            } catch (ScriptException e) {
+                LOG.info(USER_ERROR, "Error loading '{}': {}", scriptFilename, e.getMessage(), e);
                 return false;
             }
         }

scriptplugin/src/com/dmdirc/addons/scriptplugin/ScriptPluginManager.java

 import com.dmdirc.events.DMDircEvent;
 import com.dmdirc.events.PluginLoadedEvent;
 import com.dmdirc.events.PluginUnloadedEvent;
-import com.dmdirc.events.UserErrorEvent;
-import com.dmdirc.logger.ErrorLevel;
 
 import java.io.File;
 import java.io.FileInputStream;
 import javax.inject.Inject;
 import javax.script.ScriptEngineManager;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 import net.engio.mbassy.listener.Handler;
 
+import static com.dmdirc.util.LogUtils.USER_ERROR;
+
 public class ScriptPluginManager {
 
+    private static final Logger LOG = LoggerFactory.getLogger(ScriptPluginManager.class);
     private final DMDircMBassador eventBus;
     private final String scriptDir;
     private final ScriptManager scriptManager;
             try (FileInputStream fis = new FileInputStream(savedVariables)) {
                 globalVariables.load(fis);
             } catch (IOException e) {
-                eventBus.publishAsync(new UserErrorEvent(ErrorLevel.LOW, e,
-                        "Error reading savedVariables from '" + savedVariables.getPath() + "': "
-                                + e.getMessage(), ""));
+                LOG.info(USER_ERROR, "Error reading savedVariables from '{}': {}",
+                        savedVariables.getPath(), e.getMessage(), e);
             }
         }
     }
         try (FileOutputStream fos = new FileOutputStream(savedVariables)) {
             globalVariables.store(fos, "# DMDirc Script Plugin savedVariables");
         } catch (IOException e) {
-            eventBus.publishAsync(new UserErrorEvent(ErrorLevel.LOW, e,"Error reading savedVariables to '"
-                    + savedVariables.getPath() + "': " + e.getMessage(), ""));
+            LOG.info(USER_ERROR, "Error writing savedVariables to '{}': {}",
+                    savedVariables.getPath(), e.getMessage(), e);
         }
     }
 
                 .toUpperCase();
         final List<Object> arguments = new ArrayList<>();
         for (Method method : event.getClass().getMethods()) {
-            if ((method.getName().startsWith("get") && method.getParameterTypes().length == 0)
-                    && !method.getName().equals("getDisplayFormat")) {
+            if (method.getName().startsWith("get") && method.getParameterTypes().length == 0 &&
+                    !"getDisplayFormat".equals(method.getName())) {
                 arguments.add(method.invoke(event));
             }
         }