public PluginNameConversationPrefix(Plugin plugin, String separator, ChatColor prefixColor) { this.separator = separator; this.prefixColor = prefixColor; this.plugin = plugin; cachedPrefix = prefixColor + plugin.getDescription().getName() + separator + ChatColor.WHITE; }
public int compareTo(RegisteredServiceProvider<?> other) { if (priority.ordinal() == other.getPriority().ordinal()) { return 0; } else { return priority.ordinal() < other.getPriority().ordinal() ? 1 : -1; } } }
public final String getName() { return getDescription().getName(); } }
private String getPluginList() { StringBuilder pluginList = new StringBuilder(); Plugin[] plugins = Bukkit.getPluginManager().getPlugins(); for (Plugin plugin : plugins) { if (pluginList.length() > 0) { pluginList.append(ChatColor.WHITE); pluginList.append(", "); } pluginList.append(plugin.isEnabled() ? ChatColor.GREEN : ChatColor.RED); pluginList.append(plugin.getDescription().getName()); } return "(" + plugins.length + "): " + pluginList.toString(); } }
/** * Creates a new PluginLogger that extracts the name from a plugin. * * @param context A reference to the plugin */ public PluginLogger(Plugin context) { super(context.getClass().getCanonicalName(), null); String prefix = context.getDescription().getPrefix(); pluginName = prefix != null ? new StringBuilder().append("[").append(prefix).append("] ").toString() : "[" + context.getDescription().getName() + "] "; setParent(context.getServer().getLogger()); setLevel(Level.ALL); }
void register(Plugin plugin) { plugin.getServer().getPluginManager().registerEvents(this, plugin); } }
public static PermissionsResolver factory(Server server, YAMLProcessor config) { if (server.getPluginManager().getPlugin("Vault") == null) { return null; } RegisteredServiceProvider<Permission> rsp = server.getServicesManager().getRegistration(Permission.class); perms = rsp.getProvider(); if (perms == null) { return null; } return new VaultResolver(server); }
public PermissionAttachment(Plugin plugin, Permissible Permissible) { if (plugin == null) { throw new IllegalArgumentException("Plugin cannot be null"); } else if (!plugin.isEnabled()) { throw new IllegalArgumentException("Plugin " + plugin.getDescription().getFullName() + " is disabled"); } this.permissible = Permissible; this.plugin = plugin; }
public static PermissionsResolver factory(Server server, YAMLProcessor config) { // Looking for service RegisteredServiceProvider<PermissionsProvider> serviceProvider = server.getServicesManager().getRegistration(PermissionsProvider.class); if (serviceProvider != null) { return new PluginPermissionsResolver(serviceProvider.getProvider(), serviceProvider.getPlugin()); } // Looking for plugin for (Plugin plugin : server.getPluginManager().getPlugins()) { if (plugin instanceof PermissionsProvider) { return new PluginPermissionsResolver((PermissionsProvider) plugin, plugin); } } return null; }
@Override public String toString() { StringBuilder stringBuilder = new StringBuilder(super.toString()); stringBuilder.deleteCharAt(stringBuilder.length() - 1); stringBuilder.append(", ").append(owningPlugin.getDescription().getFullName()).append(')'); return stringBuilder.toString(); } }
public void registerEvents(Listener listener, Plugin plugin) { if (!plugin.isEnabled()) { throw new IllegalPluginAccessException("Plugin attempted to register " + listener + " while not enabled"); } for (Map.Entry<Class<? extends Event>, Set<RegisteredListener>> entry : plugin.getPluginLoader().createRegisteredListeners(listener, plugin).entrySet()) { getEventListeners(getRegistrationClass(entry.getKey())).registerAll(entry.getValue()); } }
@Override public String toString() { return description.getFullName(); }
/** * Calls the event executor * * @param event The event * @throws EventException If an event handler throws an exception. */ public void callEvent(final Event event) throws EventException { if (event instanceof Cancellable){ if (((Cancellable) event).isCancelled() && isIgnoringCancelled()){ return; } } executor.execute(listener, event); }
public void disablePlugins() { Plugin[] plugins = getPlugins(); for (int i = plugins.length - 1; i >= 0; i--) { disablePlugin(plugins[i]); } }
private Map<?,?> asMap(Object object) throws InvalidDescriptionException { if (object instanceof Map) { return (Map<?,?>) object; } throw new InvalidDescriptionException(object + " is not properly structured."); }
/** * Checks if the given plugin is enabled or not * <p> * Please note that the name of the plugin is case-sensitive. * * @param name Name of the plugin to check * @return true if the plugin is enabled, otherwise false */ public boolean isPluginEnabled(String name) { Plugin plugin = getPlugin(name); return isPluginEnabled(plugin); }
public void registerEvent(Class<? extends Event> event, Listener listener, EventPriority priority, EventExecutor executor, Plugin plugin) { registerEvent(event, listener, priority, executor, plugin, false); }
private void dirtyPermissibles(boolean op) { Set<Permissible> permissibles = getDefaultPermSubscriptions(op); for (Permissible p : permissibles) { p.recalculatePermissions(); } }
@Override public String getDetectionMessage() { return "Using plugin '" + this.plugin.getDescription().getName() + "' for permissions."; }