static void general_load (PluginHandle * plugin) { GList * node = g_list_find_custom (loaded_general_plugins, plugin, (GCompareFunc) general_find_cb); if (node != NULL) return; AUDDBG ("Loading %s.\n", plugin_get_name (plugin)); GeneralPlugin * gp = plugin_get_header (plugin); g_return_if_fail (gp != NULL); LoadedGeneral * general = g_slice_new (LoadedGeneral); general->plugin = plugin; general->gp = gp; general->widget = NULL; if (gp->get_widget != NULL) general->widget = gp->get_widget (); if (general->widget != NULL) { AUDDBG ("Adding %s to interface.\n", plugin_get_name (plugin)); g_signal_connect (general->widget, "destroy", (GCallback) gtk_widget_destroyed, & general->widget); interface_add_plugin_widget (plugin, general->widget); } loaded_general_plugins = g_list_prepend (loaded_general_plugins, general); }
static void start_single (int type) { PluginHandle * p; if ((p = find_enabled (type)) != NULL) { AUDDBG ("Starting selected %s plugin %s.\n", table[type].name, plugin_get_name (p)); if (table[type].u.s.set_current (p)) return; AUDDBG ("%s failed to start.\n", plugin_get_name (p)); plugin_set_enabled (p, FALSE); } AUDDBG ("Probing for %s plugin.\n", table[type].name); if ((p = table[type].u.s.probe ()) == NULL) { fprintf (stderr, "FATAL: No %s plugin found.\n", table[type].name); exit (EXIT_FAILURE); } AUDDBG ("Starting %s.\n", plugin_get_name (p)); plugin_set_enabled (p, TRUE); if (! table[type].u.s.set_current (p)) { fprintf (stderr, "FATAL: %s failed to start.\n", plugin_get_name (p)); plugin_set_enabled (p, FALSE); exit (EXIT_FAILURE); } }
static void set_plugin_list(PluginWindow *pluginwindow) { GSList *plugins, *cur, *unloaded; const gchar *text; GtkListStore *store; GtkTreeIter iter; GtkTextBuffer *textbuf; GtkTextIter start_iter, end_iter; GtkTreeSelection *selection; plugins = plugin_get_list(); unloaded = plugin_get_unloaded_list(); store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW (pluginwindow->plugin_list_view))); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), 0, GTK_SORT_ASCENDING); gtk_list_store_clear(store); textbuf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(pluginwindow->plugin_desc)); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(pluginwindow->plugin_desc), FALSE); gtk_text_view_set_editable(GTK_TEXT_VIEW(pluginwindow->plugin_desc), FALSE); gtk_text_buffer_get_start_iter(textbuf, &start_iter); gtk_text_buffer_get_end_iter(textbuf, &end_iter); gtk_text_buffer_delete(textbuf, &start_iter, &end_iter); gtk_widget_set_sensitive(pluginwindow->unload_btn, FALSE); for(cur = plugins; cur != NULL; cur = g_slist_next(cur)) { Plugin *plugin = (Plugin *) cur->data; gtk_list_store_append(store, &iter); text = plugin_get_name(plugin); gtk_list_store_set(store, &iter, PLUGINWINDOW_NAME, text, PLUGINWINDOW_DATA, plugin, PLUGINWINDOW_STYLE, PANGO_STYLE_NORMAL, -1); } for(cur = unloaded; cur != NULL; cur = g_slist_next(cur)) { Plugin *plugin = (Plugin *) cur->data; gtk_list_store_append(store, &iter); text = plugin_get_name(plugin); gtk_list_store_set(store, &iter, PLUGINWINDOW_NAME, text, PLUGINWINDOW_DATA, plugin, PLUGINWINDOW_STYLE, PANGO_STYLE_ITALIC, -1); } selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(pluginwindow->plugin_list_view)); if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter)) gtk_tree_selection_select_iter(selection, &iter); g_slist_free(plugins); }
static bool_t start_multi_cb (PluginHandle * p, void * type) { AUDDBG ("Starting %s.\n", plugin_get_name (p)); if (! table[GPOINTER_TO_INT (type)].u.m.start (p)) { AUDDBG ("%s failed to start; disabling.\n", plugin_get_name (p)); plugin_set_enabled (p, FALSE); } return TRUE; }
void interface_add_plugin_widget (PluginHandle * plugin, GtkWidget * widget) { g_return_if_fail (current_interface); if (PLUGIN_HAS_FUNC (current_interface, run_gtk_plugin)) current_interface->run_gtk_plugin (widget, plugin_get_name (plugin)); else { GtkWidget * window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title ((GtkWindow *) window, plugin_get_name (plugin)); gtk_window_set_default_size ((GtkWindow *) window, 300, 200); gtk_container_add ((GtkContainer *) window, widget); g_signal_connect (window, "delete-event", (GCallback) delete_cb, plugin); gtk_widget_show_all (window); } }
static void effect_remove (PluginHandle * plugin) { GList * node = g_list_find_custom (running_effects, plugin, (GCompareFunc) effect_find_cb); if (node == NULL) return; AUDDBG ("Removing %s without reset.\n", plugin_get_name (plugin)); ((RunningEffect *) node->data)->remove_flag = TRUE; }
static void general_unload (PluginHandle * plugin) { GList * node = g_list_find_custom (loaded_general_plugins, plugin, (GCompareFunc) general_find_cb); if (node == NULL) return; AUDDBG ("Unloading %s.\n", plugin_get_name (plugin)); LoadedGeneral * general = node->data; loaded_general_plugins = g_list_delete_link (loaded_general_plugins, node); if (general->widget != NULL) { AUDDBG ("Removing %s from interface.\n", plugin_get_name (plugin)); interface_remove_plugin_widget (plugin, general->widget); g_return_if_fail (general->widget == NULL); /* not destroyed? */ } g_slice_free (LoadedGeneral, general); }
static bool_t enable_multi (int type, PluginHandle * p, bool_t enable) { AUDDBG ("%sabling %s.\n", enable ? "En" : "Dis", plugin_get_name (p)); plugin_set_enabled (p, enable); if (enable) { if (table[type].u.m.start && ! table[type].u.m.start (p)) { fprintf (stderr, "%s failed to start.\n", plugin_get_name (p)); plugin_set_enabled (p, FALSE); return FALSE; } } else { if (table[type].u.m.stop) table[type].u.m.stop (p); } return TRUE; }
static void effect_insert (PluginHandle * plugin, EffectPlugin * header) { if (g_list_find_custom (running_effects, plugin, (GCompareFunc) effect_find_cb) != NULL) return; AUDDBG ("Adding %s without reset.\n", plugin_get_name (plugin)); RunningEffect * effect = g_malloc (sizeof (RunningEffect)); effect->plugin = plugin; effect->header = header; effect->remove_flag = FALSE; running_effects = g_list_insert_sorted (running_effects, effect, (GCompareFunc) effect_compare); GList * node = g_list_find (running_effects, effect); int channels, rate; if (node->prev != NULL) { RunningEffect * prev = node->prev->data; AUDDBG ("Added %s after %s.\n", plugin_get_name (plugin), plugin_get_name (prev->plugin)); channels = prev->channels_returned; rate = prev->rate_returned; } else { AUDDBG ("Added %s as first effect.\n", plugin_get_name (plugin)); channels = input_channels; rate = input_rate; } AUDDBG ("Starting %s at %d channels, %d Hz.\n", plugin_get_name (plugin), channels, rate); header->start (& channels, & rate); effect->channels_returned = channels; effect->rate_returned = rate; }
static bool_t enable_single (int type, PluginHandle * p) { PluginHandle * old = table[type].u.s.get_current (); AUDDBG ("Switching from %s to %s.\n", plugin_get_name (old), plugin_get_name (p)); plugin_set_enabled (old, FALSE); plugin_set_enabled (p, TRUE); if (table[type].u.s.set_current (p)) return TRUE; fprintf (stderr, "%s failed to start; falling back to %s.\n", plugin_get_name (p), plugin_get_name (old)); plugin_set_enabled (p, FALSE); plugin_set_enabled (old, TRUE); if (table[type].u.s.set_current (old)) return FALSE; fprintf (stderr, "FATAL: %s failed to start.\n", plugin_get_name (old)); plugin_set_enabled (old, FALSE); exit (EXIT_FAILURE); }
bool_t iface_plugin_set_current (PluginHandle * plugin) { hook_call ("config save", NULL); /* tell interface to save layout */ if (current_plugin != NULL) { AUDDBG ("Unloading plugin widgets.\n"); general_cleanup (); AUDDBG ("Unloading visualizers.\n"); vis_cleanup (); AUDDBG ("Unloading %s.\n", plugin_get_name (current_plugin)); interface_unload (); current_plugin = NULL; } if (plugin != NULL) { AUDDBG ("Loading %s.\n", plugin_get_name (plugin)); if (! interface_load (plugin)) return FALSE; current_plugin = plugin; AUDDBG ("Loading visualizers.\n"); vis_init (); AUDDBG ("Loading plugin widgets.\n"); general_init (); } return TRUE; }
void* plugin_discover(char* dirname, Plugin_Manager* pm) { DIR* dir = opendir(dirname); if (!dir) { //char* err = dstring_format("Unable to open path '%s'", dirname); perror("Couldn't open plugin directory"); //free(err); return NULL; } Plugin_DiscoveryState* plugins_state = malloc(sizeof(*plugins_state)); plugins_state->handle_list = NULL; // Look at all DSOs in the plugin directory and attempt to load them. struct dirent* direntry; while ((direntry = readdir(dir))) { char* name = plugin_get_name(direntry->d_name); if (!name) continue; char *fullpath = malloc(strlen(dirname) + strlen(direntry->d_name) + 8); memset(fullpath, 0x00, (strlen(dirname) + strlen(direntry->d_name) + 8)); snprintf(fullpath, (strlen(dirname) + strlen(direntry->d_name) + 8), "%s/%s", dirname, direntry->d_name); // Load the plugin, get the DSO handle and add it to the list void* handle = plugin_load(name, fullpath, pm); if (handle) { Plugin_HandleList* handle_node = malloc(sizeof(*handle_node)); handle_node->handle = handle; handle_node->next = plugins_state->handle_list; plugins_state->handle_list = handle_node; } free(name); free(fullpath); } closedir(dir); // Return a state if plugins were found. if (plugins_state->handle_list) return (void *) plugins_state; else { free(plugins_state); return NULL; } }
static bool_t effect_start_cb (PluginHandle * plugin, EffectStartState * state) { AUDDBG ("Starting %s at %d channels, %d Hz.\n", plugin_get_name (plugin), * state->channels, * state->rate); EffectPlugin * header = plugin_get_header (plugin); g_return_val_if_fail (header != NULL, TRUE); header->start (state->channels, state->rate); RunningEffect * effect = g_malloc (sizeof (RunningEffect)); effect->plugin = plugin; effect->header = header; effect->channels_returned = * state->channels; effect->rate_returned = * state->rate; effect->remove_flag = FALSE; running_effects = g_list_prepend (running_effects, effect); return TRUE; }
static void stop_plugins (int type) { if (headless && type == PLUGIN_TYPE_IFACE) return; plugin_for_enabled (type, misc_cleanup_cb, GINT_TO_POINTER (type)); if (table[type].is_single) { AUDDBG ("Shutting down %s.\n", plugin_get_name (table[type].u.s.get_current ())); table[type].u.s.set_current (NULL); } else { if (table[type].u.m.stop) plugin_for_enabled (type, stop_multi_cb, GINT_TO_POINTER (type)); } }
static void effect_enable (PluginHandle * plugin, EffectPlugin * ep, bool_t enable) { if (ep->preserves_format) { pthread_mutex_lock (& mutex); if (enable) effect_insert (plugin, ep); else effect_remove (plugin); pthread_mutex_unlock (& mutex); } else { AUDDBG ("Reset to add/remove %s.\n", plugin_get_name (plugin)); output_reset (OUTPUT_RESET_EFFECTS_ONLY); } }
static void effect_enable (PluginHandle * plugin, EffectPlugin * ep, bool_t enable) { if (ep->preserves_format) { pthread_mutex_lock (& mutex); if (enable) effect_insert (plugin, ep); else effect_remove (plugin); pthread_mutex_unlock (& mutex); } else { AUDDBG ("Reset to add/remove %s.\n", plugin_get_name (plugin)); int time = playback_get_time (); bool_t paused = playback_get_paused (); playback_stop (); playback_play (time, paused); } }
void gui_chat_printf_date_tags (struct t_gui_buffer *buffer, time_t date, const char *tags, const char *message, ...) { va_list argptr; time_t date_printed; int display_time, length, at_least_one_message_printed; char *pos, *pos_prefix, *pos_tab, *pos_end; char *modifier_data, *new_msg, *ptr_msg; struct t_gui_line *ptr_line; if (!gui_buffer_valid (buffer)) return; if (!message) return; if (gui_init_ok) { if (!buffer) buffer = gui_buffer_search_main (); if (!buffer) return; if (buffer->type != GUI_BUFFER_TYPE_FORMATTED) buffer = gui_buffers; if (buffer->type != GUI_BUFFER_TYPE_FORMATTED) return; } if (!gui_chat_buffer) gui_chat_buffer = malloc (GUI_CHAT_BUFFER_PRINTF_SIZE); if (!gui_chat_buffer) return; va_start (argptr, message); vsnprintf (gui_chat_buffer, GUI_CHAT_BUFFER_PRINTF_SIZE, message, argptr); va_end (argptr); utf8_normalize (gui_chat_buffer, '?'); date_printed = time (NULL); if (date <= 0) date = date_printed; at_least_one_message_printed = 0; pos = gui_chat_buffer; while (pos) { /* display until next end of line */ pos_end = strchr (pos, '\n'); if (pos_end) pos_end[0] = '\0'; /* call modifier for message printed ("weechat_print") */ new_msg = NULL; if (buffer) { length = strlen (plugin_get_name (buffer->plugin)) + 1 + strlen (buffer->name) + 1 + ((tags) ? strlen (tags) : 0) + 1; modifier_data = malloc (length); if (modifier_data) { snprintf (modifier_data, length, "%s;%s;%s", plugin_get_name (buffer->plugin), buffer->name, (tags) ? tags : ""); new_msg = hook_modifier_exec (NULL, "weechat_print", modifier_data, pos); /* no changes in new message */ if (new_msg && (strcmp (message, new_msg) == 0)) { free (new_msg); new_msg = NULL; } free (modifier_data); } } pos_prefix = NULL; display_time = 1; ptr_msg = (new_msg) ? new_msg : pos; /* space followed by tab => prefix ignored */ if ((ptr_msg[0] == ' ') && (ptr_msg[1] == '\t')) { ptr_msg += 2; } else { /* if two first chars are tab, then do not display time */ if ((ptr_msg[0] == '\t') && (ptr_msg[1] == '\t')) { display_time = 0; ptr_msg += 2; } else { /* if tab found, use prefix (before tab) */ pos_tab = strchr (ptr_msg, '\t'); if (pos_tab) { pos_tab[0] = '\0'; pos_prefix = ptr_msg; ptr_msg = pos_tab + 1; } } } if (gui_init_ok) { ptr_line = gui_line_add (buffer, (display_time) ? date : 0, (display_time) ? date_printed : 0, tags, pos_prefix, ptr_msg); if (ptr_line) { if (buffer->print_hooks_enabled) hook_print_exec (buffer, ptr_line); if (ptr_line->data->displayed) at_least_one_message_printed = 1; } } else { if (pos_prefix) string_iconv_fprintf (stdout, "%s ", pos_prefix); string_iconv_fprintf (stdout, "%s\n", ptr_msg); } if (new_msg) free (new_msg); pos = (pos_end && pos_end[1]) ? pos_end + 1 : NULL; } if (gui_init_ok && at_least_one_message_printed) gui_buffer_ask_chat_refresh (buffer, 1); }
static bool_t stop_multi_cb (PluginHandle * p, void * type) { AUDDBG ("Shutting down %s.\n", plugin_get_name (p)); table[GPOINTER_TO_INT (type)].u.m.stop (p); return TRUE; }
int input_exec_command (struct t_gui_buffer *buffer, int any_plugin, struct t_weechat_plugin *plugin, const char *string) { char *command, *command_name, *pos; int rc; if ((!string) || (!string[0])) return WEECHAT_RC_ERROR; command = strdup (string); if (!command) return WEECHAT_RC_ERROR; /* ignore spaces at the end of command */ pos = &command[strlen (command) - 1]; if (pos[0] == ' ') { while ((pos > command) && (pos[0] == ' ')) pos--; pos[1] = '\0'; } /* extract command name */ pos = strchr (command, ' '); command_name = (pos) ? string_strndup (command, pos - command) : strdup (command); if (!command_name) { free (command); return WEECHAT_RC_ERROR; } /* execute command */ rc = WEECHAT_RC_OK; switch (hook_command_exec (buffer, any_plugin, plugin, command)) { case HOOK_COMMAND_EXEC_OK: /* command hooked, OK (executed) */ break; case HOOK_COMMAND_EXEC_ERROR: /* command hooked, error */ rc = WEECHAT_RC_ERROR; break; case HOOK_COMMAND_EXEC_NOT_FOUND: /* * command not found: if unknown commands are accepted by this * buffer, just send input text as data to buffer, * otherwise display error */ if (buffer->input_get_unknown_commands) { input_exec_data (buffer, string); } else { gui_chat_printf_date_tags (NULL, 0, GUI_FILTER_TAG_NO_FILTER, _("%sError: unknown command \"%s\" " "(type /help for help)"), gui_chat_prefix[GUI_CHAT_PREFIX_ERROR], command_name); rc = WEECHAT_RC_ERROR; } break; case HOOK_COMMAND_EXEC_AMBIGUOUS_PLUGINS: /* command is ambiguous (exists for other plugins) */ gui_chat_printf_date_tags (NULL, 0, GUI_FILTER_TAG_NO_FILTER, _("%sError: ambiguous command \"%s\": " "it exists in many plugins and not in " "\"%s\" plugin"), gui_chat_prefix[GUI_CHAT_PREFIX_ERROR], command_name, plugin_get_name (plugin)); rc = WEECHAT_RC_ERROR; break; case HOOK_COMMAND_EXEC_AMBIGUOUS_INCOMPLETE: /* * command is ambiguous (incomplete command and multiple commands * start with this name) */ gui_chat_printf_date_tags (NULL, 0, GUI_FILTER_TAG_NO_FILTER, _("%sError: incomplete command \"%s\" " "and multiple commands start with " "this name"), gui_chat_prefix[GUI_CHAT_PREFIX_ERROR], command_name); rc = WEECHAT_RC_ERROR; break; case HOOK_COMMAND_EXEC_RUNNING: /* command is running */ gui_chat_printf_date_tags (NULL, 0, GUI_FILTER_TAG_NO_FILTER, _("%sError: too many calls to command " "\"%s\" (looping)"), gui_chat_prefix[GUI_CHAT_PREFIX_ERROR], command_name); rc = WEECHAT_RC_ERROR; break; default: break; } free (command); free (command_name); return rc; }
struct t_hashtable * gui_focus_to_hashtable (struct t_gui_focus_info *focus_info, const char *key) { struct t_hashtable *hashtable; char str_value[128], *str_time, *str_prefix, *str_tags, *str_message; const char *nick; hashtable = hashtable_new (32, WEECHAT_HASHTABLE_STRING, WEECHAT_HASHTABLE_STRING, NULL, NULL); if (!hashtable) return NULL; /* key (key from keyboard or mouse event) */ FOCUS_STR("_key", key); /* x,y */ FOCUS_INT("_x", focus_info->x); FOCUS_INT("_y", focus_info->y); /* window */ FOCUS_PTR("_window", focus_info->window); if (focus_info->window) { FOCUS_INT("_window_number", (focus_info->window)->number); } else { FOCUS_STR("_window_number", "*"); } /* buffer */ FOCUS_PTR("_buffer", focus_info->buffer); if (focus_info->buffer) { FOCUS_INT("_buffer_number", (focus_info->buffer)->number); FOCUS_STR("_buffer_plugin", plugin_get_name ((focus_info->buffer)->plugin)); FOCUS_STR("_buffer_name", (focus_info->buffer)->name); FOCUS_STR("_buffer_full_name", (focus_info->buffer)->full_name); hashtable_map ((focus_info->buffer)->local_variables, &gui_focus_buffer_localvar_map_cb, hashtable); } else { FOCUS_PTR("_buffer", NULL); FOCUS_STR("_buffer_number", "-1"); FOCUS_STR("_buffer_plugin", ""); FOCUS_STR("_buffer_name", ""); FOCUS_STR("_buffer_full_name", ""); } /* chat area */ FOCUS_INT("_chat", focus_info->chat); str_time = NULL; str_prefix = NULL; if (focus_info->chat_line) { str_time = gui_color_decode (((focus_info->chat_line)->data)->str_time, NULL); str_prefix = gui_color_decode (((focus_info->chat_line)->data)->prefix, NULL); str_tags = string_build_with_split_string ((const char **)((focus_info->chat_line)->data)->tags_array, ","); str_message = gui_color_decode (((focus_info->chat_line)->data)->message, NULL); nick = gui_line_get_nick_tag (focus_info->chat_line); FOCUS_PTR("_chat_line", focus_info->chat_line); FOCUS_INT("_chat_line_x", focus_info->chat_line_x); FOCUS_INT("_chat_line_y", ((focus_info->chat_line)->data)->y); FOCUS_TIME("_chat_line_date", ((focus_info->chat_line)->data)->date); FOCUS_TIME("_chat_line_date_printed", ((focus_info->chat_line)->data)->date_printed); FOCUS_STR_VAR("_chat_line_time", str_time); FOCUS_STR_VAR("_chat_line_tags", str_tags); FOCUS_STR_VAR("_chat_line_nick", nick); FOCUS_STR_VAR("_chat_line_prefix", str_prefix); FOCUS_STR_VAR("_chat_line_message", str_message); if (str_time) free (str_time); if (str_prefix) free (str_prefix); if (str_tags) free (str_tags); if (str_message) free (str_message); } else { FOCUS_PTR("_chat_line", NULL); FOCUS_STR("_chat_line_x", "-1"); FOCUS_STR("_chat_line_y", "-1"); FOCUS_STR("_chat_line_date", "-1"); FOCUS_STR("_chat_line_date_printed", "-1"); FOCUS_STR("_chat_line_time", ""); FOCUS_STR("_chat_line_tags", ""); FOCUS_STR("_chat_line_nick", ""); FOCUS_STR("_chat_line_prefix", ""); FOCUS_STR("_chat_line_message", ""); } FOCUS_STR_VAR("_chat_word", focus_info->chat_word); FOCUS_STR_VAR("_chat_bol", focus_info->chat_bol); FOCUS_STR_VAR("_chat_eol", focus_info->chat_eol); /* bar/item */ if (focus_info->bar_window) { FOCUS_STR("_bar_name", ((focus_info->bar_window)->bar)->name); FOCUS_STR("_bar_filling", gui_bar_filling_string[gui_bar_get_filling ((focus_info->bar_window)->bar)]); } else { FOCUS_STR("_bar_name", ""); FOCUS_STR("_bar_filling", ""); } FOCUS_STR_VAR("_bar_item_name", focus_info->bar_item); FOCUS_INT("_bar_item_line", focus_info->bar_item_line); FOCUS_INT("_bar_item_col", focus_info->bar_item_col); return hashtable; }
void input_exec_command (struct t_gui_buffer *buffer, int any_plugin, struct t_weechat_plugin *plugin, const char *string) { int rc; char *command, *pos, *ptr_args; if ((!string) || (!string[0])) return; command = strdup (string); if (!command) return ; /* look for end of command */ ptr_args = NULL; pos = &command[strlen (command) - 1]; if (pos[0] == ' ') { while ((pos > command) && (pos[0] == ' ')) pos--; pos[1] = '\0'; } rc = hook_command_exec (buffer, any_plugin, plugin, command); pos = strchr (command, ' '); if (pos) { pos[0] = '\0'; pos++; while (pos[0] == ' ') pos++; ptr_args = pos; if (!ptr_args[0]) ptr_args = NULL; } switch (rc) { case 0: /* command hooked, KO */ gui_chat_printf (NULL, _("%sError with command \"%s\" (try /help %s)"), gui_chat_prefix[GUI_CHAT_PREFIX_ERROR], command + 1, command + 1); break; case 1: /* command hooked, OK (executed) */ break; case -2: /* command is ambiguous (exists for other plugins) */ gui_chat_printf (NULL, _("%sError: ambiguous command \"%s\": it exists " "in many plugins and not in \"%s\" plugin"), gui_chat_prefix[GUI_CHAT_PREFIX_ERROR], command + 1, plugin_get_name (plugin)); break; case -3: /* command is running */ gui_chat_printf (NULL, _("%sError: too much calls to command \"%s\" " "(looping)"), gui_chat_prefix[GUI_CHAT_PREFIX_ERROR], command + 1); break; default: /* no command hooked */ /* * if unknown commands are accepted by this buffer, just send * input text as data to buffer, otherwise display error */ if (buffer->input_get_unknown_commands) { input_exec_data (buffer, string); } else { gui_chat_printf (NULL, _("%sError: unknown command \"%s\" (type " "/help for help)"), gui_chat_prefix[GUI_CHAT_PREFIX_ERROR], command + 1); } break; } free (command); }