void plugin_init(G_GNUC_UNUSED GeanyData *data){ /* init gettext and friends */ main_locale_init(LOCALEDIR, GETTEXT_PACKAGE); menu_item_shift_left = gtk_menu_item_new_with_mnemonic(_("Shift Left")); gtk_widget_show(menu_item_shift_left); gtk_container_add(GTK_CONTAINER(geany->main_widgets->tools_menu), menu_item_shift_left); g_signal_connect(menu_item_shift_left, "activate", G_CALLBACK(shift_left_cb), NULL); menu_item_shift_right = gtk_menu_item_new_with_mnemonic(_("Shift Right")); gtk_widget_show(menu_item_shift_right); gtk_container_add(GTK_CONTAINER(geany->main_widgets->tools_menu), menu_item_shift_right); g_signal_connect(menu_item_shift_right, "activate", G_CALLBACK(shift_right_cb), NULL); /* make sure our menu items aren't called when there is no doc open */ ui_add_document_sensitive(menu_item_shift_right); ui_add_document_sensitive(menu_item_shift_left); /* setup keybindings */ keybindings_set_item(plugin_key_group, KB_SHIFT_LEFT, kb_shift_left, 0, GDK_CONTROL_MASK, "shift_left", _("Shift Left"), menu_item_shift_left); keybindings_set_item(plugin_key_group, KB_SHIFT_RIGHT, kb_shift_right, 0, GDK_CONTROL_MASK, "shift_right", _("Shift Right"), menu_item_shift_right); }
/* creates plugin's tool's menu */ static GtkWidget * create_tools_menu_item (void) { GtkWidget *menu; GtkWidget *item; /* build submenu */ menu = gtk_menu_new (); /* build "document current symbol" item */ item = menu_add_item (GTK_MENU_SHELL (menu), _("_Document Current Symbol"), _("Generate documentation for the current symbol"), NULL, G_CALLBACK (document_current_symbol_handler), NULL); ui_add_document_sensitive (item); /* build "document all" item */ item = menu_add_item (GTK_MENU_SHELL (menu), _("Document _All Symbols"), _("Generate documentation for all symbols in the " "current document"), NULL, G_CALLBACK (document_all_symbols_handler), NULL); ui_add_document_sensitive (item); /* separator */ item = gtk_separator_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); /* build "reload" item */ item = menu_add_item (GTK_MENU_SHELL (menu), _("_Reload Configuration Files"), _("Force reloading of the configuration files"), GTK_STOCK_REFRESH, G_CALLBACK (reload_configuration_hanlder), NULL); /* language filetypes opener */ item = menu_add_item (GTK_MENU_SHELL (menu), _("_Edit Current Language Configuration"), _("Open the current language configuration file for " "editing"), GTK_STOCK_EDIT, G_CALLBACK (open_current_filetype_conf_handler), NULL); ui_add_document_sensitive (item); /* separator */ item = gtk_separator_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); /* help/manual opening */ item = menu_add_item (GTK_MENU_SHELL (menu), _("Open _Manual"), _("Open the manual in a browser"), GTK_STOCK_HELP, G_CALLBACK (open_manual_handler), NULL); /* build tools menu item */ item = gtk_menu_item_new_with_mnemonic (_("_Documentation Generator")); gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), menu); gtk_widget_show_all (item); return item; }
void sc_gui_update_toolbar(void) { /* toolbar item is not requested, so remove the item if it exists */ if (! sc_info->show_toolbar_item) { if (sc_info->toolbar_button != NULL) { gtk_widget_hide(GTK_WIDGET(sc_info->toolbar_button)); } } else { if (sc_info->toolbar_button == NULL) { sc_info->toolbar_button = gtk_toggle_tool_button_new_from_stock(GTK_STOCK_SPELL_CHECK); plugin_add_toolbar_item(geany_plugin, sc_info->toolbar_button); ui_add_document_sensitive(GTK_WIDGET(sc_info->toolbar_button)); g_signal_connect(sc_info->toolbar_button, "toggled", G_CALLBACK(toolbar_item_toggled_cb), NULL); } gtk_widget_show(GTK_WIDGET(sc_info->toolbar_button)); sc_ignore_callback = TRUE; gtk_toggle_tool_button_set_active( GTK_TOGGLE_TOOL_BUTTON(sc_info->toolbar_button), sc_info->check_while_typing); sc_ignore_callback = FALSE; } }
/* Called by Geany to initialize the plugin */ static gboolean demo_init(GeanyPlugin *plugin, gpointer data) { GtkWidget *demo_item; GeanyData *geany_data = plugin->geany_data; /* Add an item to the Tools menu */ demo_item = gtk_menu_item_new_with_mnemonic(_("_Demo Plugin")); gtk_widget_show(demo_item); gtk_container_add(GTK_CONTAINER(geany_data->main_widgets->tools_menu), demo_item); g_signal_connect(demo_item, "activate", G_CALLBACK(item_activate), plugin); /* make the menu item sensitive only when documents are open */ ui_add_document_sensitive(demo_item); /* keep a pointer to the menu item, so we can remove it when the plugin is unloaded */ main_menu_item = demo_item; welcome_text = g_strdup(_("Hello World!")); /* This might seem strange but is a method to get the GeanyPlugin pointer passed to * on_editor_notify(). PluginCallback functions get the same data that was set via * GEANY_PLUING_REGISTER_FULL() or geany_plugin_set_data() by default (unless the data pointer * was set to non-NULL at compile time). * This is really only done for demoing PluginCallback. Actual plugins will use real custom * data and perhaps embed the GeanyPlugin or GeanyData pointer their if they also use * PluginCallback. */ geany_plugin_set_data(plugin, plugin, NULL); return TRUE; }
/* --------------------------------------------------------------------- * Initialization * --------------------------------------------------------------------- */ void switch_head_impl_init() { log_func(); GtkWidget* edit_menu = ui_lookup_widget(geany->main_widgets->window, "edit1_menu"); /* Add the menu item and make it sensitive only when a document is opened */ menu_item = gtk_menu_item_new_with_mnemonic(_("Switch header/implementation")); gtk_widget_show(menu_item); gtk_container_add(GTK_CONTAINER(edit_menu), menu_item); ui_add_document_sensitive(menu_item); /* Callback connection */ g_signal_connect(G_OBJECT(menu_item), "activate", G_CALLBACK(menu_item_activate), NULL); /* Initialize the key binding : */ keybindings_set_item( plugin_key_group, KEY_ID_SWITCH_HEAD_IMPL, (GeanyKeyCallback)(&menu_item_activate), GDK_s, GDK_MOD1_MASK | GDK_SHIFT_MASK, "switch_head_impl", _("Switch header/implementation"), /* used in the Preferences dialog */ menu_item); /* TODO : we should use the languages specified by the user or the default list */ fill_default_languages_list(); }
/* adds the menu item in the editor's popup menu */ static void add_edit_menu_item (PluginData *pdata) { GtkWidget *parent_menu; parent_menu = gtk_menu_item_get_submenu (GTK_MENU_ITEM ( ui_lookup_widget (geany->main_widgets->editor_menu, "comments"))); if (! parent_menu) { parent_menu = geany->main_widgets->editor_menu; pdata->separator_item = gtk_separator_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (parent_menu), pdata->separator_item); gtk_widget_show (pdata->separator_item); } pdata->edit_menu_item = gtk_menu_item_new_with_label (_("Insert Documentation Comment")); pdata->edit_menu_item_hid = g_signal_connect (pdata->edit_menu_item, "activate", G_CALLBACK (editor_menu_acivated_handler), pdata); gtk_menu_shell_append (GTK_MENU_SHELL (parent_menu), pdata->edit_menu_item); gtk_widget_show (pdata->edit_menu_item); /* make item document-presence sensitive */ ui_add_document_sensitive (pdata->edit_menu_item); /* and attach a keybinding */ keybindings_set_item (pdata->kb_group, KB_INSERT, insert_comment_keybinding_handler, GDK_d, GDK_CONTROL_MASK | GDK_SHIFT_MASK, "instert_doc", _("Insert Documentation Comment"), pdata->edit_menu_item); }
/* --------------------------------------------------------------------- * Initialization * --------------------------------------------------------------------- */ void goto_file_init(void) { GtkWidget* edit_menu; log_func(); edit_menu = ui_lookup_widget(geany->main_widgets->window, "edit1_menu"); /* Add the menu item, sensitive only when a document is opened */ menu_item = gtk_menu_item_new_with_mnemonic(_("Go to File...")); gtk_widget_show(menu_item); gtk_container_add(GTK_CONTAINER(edit_menu), menu_item); ui_add_document_sensitive(menu_item); /* Callback connection */ g_signal_connect(G_OBJECT(menu_item), "activate", G_CALLBACK(menu_item_activate), NULL); /* Initialize the key binding : */ keybindings_set_item( plugin_key_group, KEY_ID_GOTO_FILE, (GeanyKeyCallback)(&menu_item_activate), GDK_g, GDK_MOD1_MASK | GDK_SHIFT_MASK, "goto_file", _("Go to File"), /* used in the Preferences dialog */ menu_item); }
static void show_icon(void) { mailbutton = GTK_WIDGET(gtk_tool_button_new_from_stock(GEANYSENDMAIL_STOCK_MAIL)); plugin_add_toolbar_item(geany_plugin, GTK_TOOL_ITEM(mailbutton)); ui_add_document_sensitive(mailbutton); #if GTK_CHECK_VERSION(2, 12, 0) gtk_tool_item_set_tooltip_text(GTK_TOOL_ITEM(mailbutton), _("Send by mail")); #endif g_signal_connect (G_OBJECT(mailbutton), "clicked", G_CALLBACK(send_as_attachment), NULL); gtk_widget_show_all (mailbutton); icon_in_toolbar = TRUE; }
void plugin_init(GeanyData *data) { GeanyKeyGroup *key_group; GKeyFile *config = g_key_file_new(); gchar *default_lang; default_lang = sc_speller_get_default_lang(); sc_info = g_new0(SpellCheck, 1); sc_info->config_file = g_strconcat(geany->app->configdir, G_DIR_SEPARATOR_S, "plugins", G_DIR_SEPARATOR_S, "spellcheck", G_DIR_SEPARATOR_S, "spellcheck.conf", NULL); g_key_file_load_from_file(config, sc_info->config_file, G_KEY_FILE_NONE, NULL); sc_info->default_language = utils_get_setting_string(config, "spellcheck", "language", default_lang); sc_info->check_while_typing = utils_get_setting_boolean(config, "spellcheck", "check_while_typing", FALSE); sc_info->check_on_document_open = utils_get_setting_boolean(config, "spellcheck", "check_on_document_open", FALSE); sc_info->show_toolbar_item = utils_get_setting_boolean(config, "spellcheck", "show_toolbar_item", TRUE); sc_info->show_editor_menu_item = utils_get_setting_boolean(config, "spellcheck", "show_editor_menu_item", TRUE); sc_info->show_editor_menu_item_sub_menu = utils_get_setting_boolean(config, "spellcheck", "show_editor_menu_item_sub_menu", TRUE); sc_info->dictionary_dir = utils_get_setting_string(config, "spellcheck", "dictionary_dir", NULL); sc_info->use_msgwin = utils_get_setting_boolean(config, "spellcheck", "use_msgwin", FALSE); g_key_file_free(config); g_free(default_lang); sc_info->menu_item = gtk_image_menu_item_new_from_stock(GTK_STOCK_SPELL_CHECK, NULL); ui_add_document_sensitive(sc_info->menu_item); sc_gui_update_toolbar(); sc_gui_init(); sc_speller_init(); sc_gui_update_menu(); gtk_widget_show_all(sc_info->menu_item); /* setup keybindings */ key_group = plugin_set_key_group(geany_plugin, "spellcheck", KB_COUNT, NULL); keybindings_set_item(key_group, KB_SPELL_CHECK, sc_gui_kb_run_activate_cb, 0, 0, "spell_check", _("Run Spell Check"), sc_info->submenu_item_default); keybindings_set_item(key_group, KB_SPELL_TOOGLE_TYPING, sc_gui_kb_toggle_typing_activate_cb, 0, 0, "spell_toggle_typing", _("Toggle Check While Typing"), NULL); }
void init_menuentries(void) { int i = 0; GtkWidget *tmp = NULL; /* Build up menu entry for table_convert based on global file type*/ main_menu_item = gtk_menu_item_new_with_mnemonic(_("_Convert to table")); gtk_container_add(GTK_CONTAINER(geany->main_widgets->tools_menu), main_menu_item); ui_widget_set_tooltip_text(main_menu_item, _("Converts current marked list to a table.")); g_signal_connect(G_OBJECT(main_menu_item), "activate", G_CALLBACK(cb_table_convert), NULL); gtk_widget_show_all(main_menu_item); ui_add_document_sensitive(main_menu_item); /* Build up menu entries for table convert based on explicit choice * This is needed for e.g. different wiki-Syntax or differenz stiles * within a special file type */ menu_tableconvert = gtk_image_menu_item_new_with_mnemonic(_("_More TableConvert")); gtk_container_add(GTK_CONTAINER(geany->main_widgets->tools_menu), menu_tableconvert); menu_tableconvert_menu = gtk_menu_new (); gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_tableconvert), menu_tableconvert_menu); for (i = 0; i < TC_END; i++) { tmp = NULL; tmp = gtk_menu_item_new_with_mnemonic(_(tablerules[i].type)); gtk_container_add(GTK_CONTAINER(menu_tableconvert_menu), tmp); g_signal_connect(G_OBJECT(tmp), "activate", G_CALLBACK(cb_table_convert_type), GINT_TO_POINTER(i)); } ui_add_document_sensitive(menu_tableconvert); /* Show the menu */ gtk_widget_show_all(menu_tableconvert); }
/** * name: plugin_init * * The Geany plugin initialization function. This is called automatically by Geany when a user installs the plugin. * * @param data GeanyData. * @return void **/ void plugin_init(G_GNUC_UNUSED GeanyData *data) { //Get hold of the Edit menu widget. GtkWidget* parent_menu = ui_lookup_widget(GTK_WIDGET(geany->main_widgets->window), "edit1_menu");//"tools1_menu" // Create the 'LispEdit: eval' menu, assign it to the callback function cb_eval // and attach it to parent_menu. eval_menu_item = gtk_menu_item_new_with_mnemonic(EVAL_MENU_STR); gtk_widget_show(eval_menu_item); gtk_container_add(GTK_CONTAINER(parent_menu), eval_menu_item); g_signal_connect(eval_menu_item, "activate", G_CALLBACK(cb_eval), NULL); // Create the 'LispEdit: macroexpand-1' menu, assign it to the callback function cb_macroexpand_1 // and attach it to parent_menu. macroexpand_1_menu_item = gtk_menu_item_new_with_mnemonic(MACROEXPAND_MENU_STR); gtk_widget_show(macroexpand_1_menu_item); gtk_container_add(GTK_CONTAINER(parent_menu), macroexpand_1_menu_item); g_signal_connect(macroexpand_1_menu_item, "activate", G_CALLBACK(cb_macroexpand_1), NULL); /* make sure our menu items aren't called when there is no doc open */ ui_add_document_sensitive(eval_menu_item); ui_add_document_sensitive(macroexpand_1_menu_item); // setup keybindings for the callback functions. keybindings_set_item(plugin_key_group, KB_MACROEXPAND, on_macroexpand_1_key, GDK_Return, MACROEXPAND_KEY_SEQ, MACROEXPAND_ID_STR, MACROEXPAND_MENU_STR, macroexpand_1_menu_item); keybindings_set_item(plugin_key_group, KB_EVAL, on_eval_key, GDK_Return, EVAL_KEY_SEQ, EVAL_ID_STR, EVAL_MENU_STR, eval_menu_item); //Initialiase the binding to the Geany virtual terminal (VTE). init_vte(); }
void plugin_init(GeanyData *data) { GtkWidget * submenu; GtkWidget * encrypt; GtkWidget * sign; GtkWidget * decrypt; GtkWidget * verify; gpgme_error_t err = geanypg_init_gpgme(); if (err) { geanypg_show_err_msg(err); return; } /* Create a new menu item and show it */ main_menu_item = gtk_menu_item_new_with_mnemonic("GeanyPG"); gtk_widget_show(main_menu_item); ui_add_document_sensitive(main_menu_item); submenu = gtk_menu_new(); gtk_widget_show(submenu); encrypt = gtk_menu_item_new_with_mnemonic(_("Encrypt")); sign = gtk_menu_item_new_with_mnemonic(_("Sign")); decrypt = gtk_menu_item_new_with_mnemonic(_("Decrypt / Verify")); verify = gtk_menu_item_new_with_mnemonic(_("Verify detached signature")); gtk_widget_show(encrypt); gtk_widget_show(sign); gtk_widget_show(decrypt); gtk_widget_show(verify); gtk_menu_shell_append(GTK_MENU_SHELL(submenu), encrypt); gtk_menu_shell_append(GTK_MENU_SHELL(submenu), sign); gtk_menu_shell_append(GTK_MENU_SHELL(submenu), decrypt); gtk_menu_shell_append(GTK_MENU_SHELL(submenu), verify); gtk_menu_item_set_submenu(GTK_MENU_ITEM(main_menu_item), submenu); /* Attach the new menu item to the Tools menu */ gtk_container_add(GTK_CONTAINER(geany->main_widgets->tools_menu), main_menu_item); /* Connect the menu item with a callback function * which is called when the item is clicked */ g_signal_connect(encrypt, "activate", G_CALLBACK(geanypg_encrypt_cb), NULL); g_signal_connect(sign, "activate", G_CALLBACK(geanypg_sign_cb), NULL); g_signal_connect(decrypt, "activate", G_CALLBACK(geanypg_decrypt_cb), NULL); g_signal_connect(verify, "activate", G_CALLBACK(geanypg_verify_cb), NULL); }
/** * \brief Called by Geany to initialize the plugin. * \note data is the same as geany_data. */ void plugin_init(GeanyData *data) { const GeanyIndentPrefs *iprefs = editor_get_indent_prefs(NULL); gms_hnd = gms_new(geany->main_widgets->window, data->interface_prefs->editor_font , iprefs->width, geany->app->configdir ) ; /* Add an item to the Tools menu */ gms_item = gtk_menu_item_new_with_mnemonic(_("_Mini-Script")); gtk_widget_show(gms_item); gtk_container_add(GTK_CONTAINER(geany->main_widgets->tools_menu), gms_item); g_signal_connect(gms_item, "activate", G_CALLBACK(item_activate), NULL); /* make the menu item sensitive only when documents are open */ ui_add_document_sensitive(gms_item); }
/* Called by Geany to initialize the plugin */ void plugin_init(GeanyData G_GNUC_UNUSED *data) { GKeyFile *config = g_key_file_new(); gchar *kb_label = _("Send file by mail"); GtkWidget *menu_mail = NULL; GeanyKeyGroup *key_group; config_file = g_strconcat(geany->app->configdir, G_DIR_SEPARATOR_S, "plugins", G_DIR_SEPARATOR_S, "geanysendmail", G_DIR_SEPARATOR_S, "mail.conf", NULL); /* Initialising options from config file */ g_key_file_load_from_file(config, config_file, G_KEY_FILE_NONE, NULL); mailer = g_key_file_get_string(config, "tools", "mailer", NULL); address = g_key_file_get_string(config, "tools", "address", NULL); use_address_dialog = g_key_file_get_boolean(config, "tools", "address_usage", NULL); icon_in_toolbar = g_key_file_get_boolean(config, "icon", "show_icon", NULL); g_key_file_free(config); add_stock_item(); if (icon_in_toolbar == TRUE) { show_icon(); } /* Build up menu entry */ menu_mail = gtk_menu_item_new_with_mnemonic(_("_Mail document")); gtk_container_add(GTK_CONTAINER(geany->main_widgets->tools_menu), menu_mail); gtk_widget_set_tooltip_text(menu_mail, _("Sends the opened file as unzipped attachment by any mailer from your $PATH")); g_signal_connect(G_OBJECT(menu_mail), "activate", G_CALLBACK(send_as_attachment), NULL); /* setup keybindings */ key_group = plugin_set_key_group(geany_plugin, "sendmail", COUNT_KB, NULL); keybindings_set_item(key_group, SENDMAIL_KB, key_send_as_attachment, 0, 0, "send_file_as_attachment", kb_label, menu_mail); gtk_widget_show_all(menu_mail); ui_add_document_sensitive(menu_mail); main_menu_item = menu_mail; }
void plugin_init(GeanyData *data) { GtkWidget *item, *menu; GeanyKeyGroup *key_group; menu_items.main = item = gtk_menu_item_new_with_mnemonic(_("_Split Window")); gtk_menu_shell_append(GTK_MENU_SHELL(geany_data->main_widgets->tools_menu), item); ui_add_document_sensitive(item); menu = gtk_menu_new(); gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_items.main), menu); menu_items.horizontal = item = gtk_menu_item_new_with_mnemonic(_("_Side by Side")); g_signal_connect(item, "activate", G_CALLBACK(on_split_horizontally), NULL); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); menu_items.vertical = item = gtk_menu_item_new_with_mnemonic(_("_Top and Bottom")); g_signal_connect(item, "activate", G_CALLBACK(on_split_vertically), NULL); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); menu_items.unsplit = item = gtk_menu_item_new_with_mnemonic(_("_Unsplit")); g_signal_connect(item, "activate", G_CALLBACK(on_unsplit), NULL); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); gtk_widget_show_all(menu_items.main); set_state(STATE_UNSPLIT); /* setup keybindings */ key_group = plugin_set_key_group(geany_plugin, "split_window", KB_COUNT, NULL); keybindings_set_item(key_group, KB_SPLIT_HORIZONTAL, kb_activate, 0, 0, "split_horizontal", _("Side by Side"), menu_items.horizontal); keybindings_set_item(key_group, KB_SPLIT_VERTICAL, kb_activate, 0, 0, "split_vertical", _("Top and Bottom"), menu_items.vertical); keybindings_set_item(key_group, KB_SPLIT_UNSPLIT, kb_activate, 0, 0, "split_unsplit", _("_Unsplit"), menu_items.unsplit); }
/* Called by Geany to initialize the plugin */ void plugin_init(G_GNUC_UNUSED GeanyData *data) { GtkWidget *menu_lipsum = NULL; GKeyFile *config = g_key_file_new(); gchar *config_file = NULL; GeanyKeyGroup *key_group; main_locale_init(LOCALEDIR, GETTEXT_PACKAGE); config_file = g_strconcat(geany->app->configdir, G_DIR_SEPARATOR_S, "plugins", G_DIR_SEPARATOR_S, "geanylipsum", G_DIR_SEPARATOR_S, "lipsum.conf", NULL); /* Initialising options from config file if there is any*/ g_key_file_load_from_file(config, config_file, G_KEY_FILE_NONE, NULL); lipsum = utils_get_setting_string(config, "snippets", "lipsumtext", default_loremipsum); g_key_file_free(config); g_free(config_file); /* Building menu entry */ menu_lipsum = gtk_image_menu_item_new_with_mnemonic(_("_Lipsum")); gtk_widget_set_tooltip_text(menu_lipsum, _("Include Pseudotext to your code")); gtk_widget_show(menu_lipsum); g_signal_connect((gpointer) menu_lipsum, "activate", G_CALLBACK(lipsum_activated), NULL); gtk_container_add(GTK_CONTAINER(geany->main_widgets->tools_menu), menu_lipsum); ui_add_document_sensitive(menu_lipsum); main_menu_item = menu_lipsum; /* init keybindings */ key_group = plugin_set_key_group(geany_plugin, "geanylipsum", COUNT_KB, NULL); keybindings_set_item(key_group, LIPSUM_KB_INSERT, kblipsum_insert, 0, 0, "insert_lipsum", _("Insert Lipsum text"), menu_lipsum); }
void plugin_init(GeanyData *data) { /* initializes the libxml2 */ LIBXML_TEST_VERSION /* mutilanguage support */ main_locale_init(LOCALEDIR, GETTEXT_PACKAGE); /* put the menu into the Tools */ main_menu_item = gtk_menu_item_new_with_mnemonic(_("PrettyPrinter XML")); ui_add_document_sensitive(main_menu_item); gtk_widget_show(main_menu_item); gtk_container_add(GTK_CONTAINER(geany->main_widgets->tools_menu), main_menu_item); /* init keybindings */ keybindings_set_item(plugin_key_group, 0, kb_run_xml_pretty_print, 0, 0, "run_pretty_printer_xml", _("Run the PrettyPrinter XML"), main_menu_item); /* add activation callback */ g_signal_connect(main_menu_item, "activate", G_CALLBACK(xml_format), NULL); }
void plugin_init(G_GNUC_UNUSED GeanyData *data) { GeanyKeyGroup *group; GtkWidget *menu, *item; fmt_prefs_init(); #define CONNECT(sig, cb) \ plugin_signal_connect(geany_plugin, NULL, sig, TRUE, G_CALLBACK(cb), NULL) CONNECT("editor-notify", on_editor_notify); CONNECT("project-dialog-open", on_project_dialog_open); CONNECT("project-dialog-close", on_project_dialog_close); CONNECT("project-dialog-confirmed", on_project_dialog_confirmed); CONNECT("project-open", on_project_open); CONNECT("project-close", on_project_close); CONNECT("project-save", on_project_save); CONNECT("document-before-save", on_document_before_save); #undef CONNECT group = plugin_set_key_group(geany_plugin, _("Code Formatting"), 3, (GeanyKeyGroupCallback)on_key_binding); main_menu_item = gtk_menu_item_new_with_label(_("Code Format")); ui_add_document_sensitive(main_menu_item); g_signal_connect(main_menu_item, "map", G_CALLBACK(on_tools_item_map), NULL); menu = gtk_menu_new(); gtk_menu_item_set_submenu(GTK_MENU_ITEM(main_menu_item), menu); item = gtk_check_menu_item_new_with_label(_("Auto-Formatting")); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); g_signal_connect(item, "toggled", G_CALLBACK(on_auto_format_item_toggled), NULL); g_signal_connect(item, "map", G_CALLBACK(on_auto_format_item_map), NULL); item = gtk_separator_menu_item_new(); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); item = gtk_menu_item_new_with_label(_("Current Line or Selection")); g_signal_connect(item, "activate", G_CALLBACK(on_menu_item_activate), GINT_TO_POINTER(FORMAT_KEY_REGION)); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); keybindings_set_item(group, FORMAT_KEY_REGION, NULL, 0, 0, "format_region", _("Format current line or selection"), item); item = gtk_menu_item_new_with_label(_("Entire Document")); g_signal_connect(item, "activate", G_CALLBACK(on_menu_item_activate), GINT_TO_POINTER(FORMAT_KEY_DOCUMENT)); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); keybindings_set_item(group, FORMAT_KEY_DOCUMENT, NULL, 0, 0, "format_document", _("Format entire document"), item); item = gtk_menu_item_new_with_label(_("Entire Session")); g_signal_connect(item, "activate", G_CALLBACK(on_menu_item_activate), GINT_TO_POINTER(FORMAT_KEY_SESSION)); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); keybindings_set_item(group, FORMAT_KEY_SESSION, NULL, 0, 0, "format_session", _("Format entire session"), item); item = gtk_separator_menu_item_new(); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); item = gtk_menu_item_new_with_label(_("Open Configuration File")); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); g_signal_connect(item, "activate", G_CALLBACK(on_open_config_file), NULL); g_signal_connect(item, "map", G_CALLBACK(on_open_config_item_map), NULL); gtk_widget_show_all(main_menu_item); gtk_menu_shell_append(GTK_MENU_SHELL(geany_data->main_widgets->tools_menu), main_menu_item); }
/* Called by Geany to initialize the plugin */ void plugin_init(GeanyData G_GNUC_UNUSED *data) { GKeyFile *config = g_key_file_new(); gchar *config_file_old = NULL; gchar *config_dir = NULL; gchar *config_dir_old = NULL; gchar *kb_label = _("Send file by mail"); GtkWidget *menu_mail = NULL; GeanyKeyGroup *key_group; config_file = g_strconcat(geany->app->configdir, G_DIR_SEPARATOR_S, "plugins", G_DIR_SEPARATOR_S, "sendmail", G_DIR_SEPARATOR_S, "mail.conf", NULL); #ifndef G_OS_WIN32 /* We try only to move if we are on not Windows platform */ config_file_old = g_strconcat(geany->app->configdir, G_DIR_SEPARATOR_S, "plugins", G_DIR_SEPARATOR_S, "geanysendmail", G_DIR_SEPARATOR_S, "mail.conf", NULL); config_dir = g_strconcat(geany->app->configdir, G_DIR_SEPARATOR_S, "plugins", G_DIR_SEPARATOR_S, "sendmail", NULL); config_dir_old = g_strconcat(geany->app->configdir, G_DIR_SEPARATOR_S, "plugins", G_DIR_SEPARATOR_S, "geanysendmail", NULL); if (g_file_test(config_file_old, G_FILE_TEST_EXISTS)) { if (dialogs_show_question( _("Renamed plugin detected!\n" "\n" "GeanySendMail has been renamed to sendmail -- you surely have " "already recognised it. \n" "Geany is able to migrate your old plugin configuration by " "moving the old configuration file to new location.\n" "Move now?"))) { if (g_rename(config_dir_old, config_dir) == 0) { dialogs_show_msgbox(GTK_MESSAGE_INFO, _("Your configuration directory has been " "successfully moved from \"%s\" to \"%s\"."), config_dir_old, config_dir); } else { /* If there was an error on migrating we need * to load from original one. * When saving new configuration it will go to * new folder so migration should * be implicit. */ g_free(config_file); config_file = g_strdup(config_file_old); dialogs_show_msgbox( GTK_MESSAGE_WARNING, _("Your old configuration directory \"%s\" could " "not be moved to \"%s\" (%s). " "Please move manually the directory to the new location."), config_dir_old, config_dir, g_strerror(errno)); } } } g_free(config_dir_old); g_free(config_dir); g_free(config_file_old); #endif /* Initialising options from config file */ g_key_file_load_from_file(config, config_file, G_KEY_FILE_NONE, NULL); mailer = g_key_file_get_string(config, "tools", "mailer", NULL); address = g_key_file_get_string(config, "tools", "address", NULL); use_address_dialog = g_key_file_get_boolean(config, "tools", "address_usage", NULL); icon_in_toolbar = g_key_file_get_boolean(config, "icon", "show_icon", NULL); g_key_file_free(config); add_stock_item(); if (icon_in_toolbar == TRUE) { show_icon(); } /* Build up menu entry */ menu_mail = gtk_menu_item_new_with_mnemonic(_("_Mail document")); gtk_container_add(GTK_CONTAINER(geany->main_widgets->tools_menu), menu_mail); gtk_widget_set_tooltip_text(menu_mail, _("Sends the opened file as unzipped attachment by any mailer from your $PATH")); g_signal_connect(G_OBJECT(menu_mail), "activate", G_CALLBACK(send_as_attachment), NULL); /* setup keybindings */ key_group = plugin_set_key_group(geany_plugin, "sendmail", COUNT_KB, NULL); keybindings_set_item(key_group, SENDMAIL_KB, key_send_as_attachment, 0, 0, "send_file_as_attachment", kb_label, menu_mail); gtk_widget_show_all(menu_mail); ui_add_document_sensitive(menu_mail); main_menu_item = menu_mail; }
void plugin_init(G_GNUC_UNUSED GeanyData *data) { GtkContainer *menu; GtkWidget *item; GeanyKeyGroup *plugin_key_group; plugin_key_group = plugin_set_key_group(geany_plugin, "extra_select", COUNT_KB, NULL); item = gtk_menu_item_new_with_mnemonic(_("E_xtra Selection")); main_menu_item = item; gtk_container_add(GTK_CONTAINER(geany->main_widgets->tools_menu), item); ui_add_document_sensitive(item); menu = GTK_CONTAINER(gtk_menu_new()); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), GTK_WIDGET(menu)); item = gtk_check_menu_item_new_with_mnemonic(_("_Column Mode")); column_mode_item = GTK_CHECK_MENU_ITEM(item); gtk_container_add(menu, item); g_signal_connect(item, "toggled", G_CALLBACK(on_column_mode_toggled), NULL); keybindings_set_item(plugin_key_group, COLUMN_MODE_KB, on_column_mode_key, 0, 0, "column_mode", _("Column mode"), item); item = gtk_menu_item_new_with_mnemonic(_("Select to _Line")); gtk_container_add(menu, item); g_signal_connect(item, "activate", G_CALLBACK(on_goto_line_activate), NULL); keybindings_set_item(plugin_key_group, GOTO_LINE_EXTEND_KB, on_goto_line_key, 0, 0, "goto_line_extend", _("Select to line"), item); item = gtk_menu_item_new_with_mnemonic(_("Select to Matching _Brace")); gtk_container_add(menu, item); g_signal_connect(item, "activate", G_CALLBACK(on_brace_match_activate), NULL); keybindings_set_item(plugin_key_group, BRACE_MATCH_EXTEND_KB, on_brace_match_key, 0, 0, "brace_match_extend", _("Select to matching brace"), item); item = gtk_menu_item_new_with_mnemonic(_("_Toggle Stream/Rectangular")); gtk_container_add(menu, item); g_signal_connect(item, "activate", G_CALLBACK(on_convert_selection_activate), NULL); keybindings_set_item(plugin_key_group, CONVERT_SELECTION_KB, on_convert_selection_key, 0, 0, "convert_selection", _("Convert selection"), item); g_signal_connect(main_menu_item, "activate", G_CALLBACK(on_extra_select_activate), item); gtk_container_add(menu, gtk_separator_menu_item_new()); item = gtk_menu_item_new_with_mnemonic(_("_Set Anchor")); gtk_container_add(menu, item); g_signal_connect(item, "activate", G_CALLBACK(on_set_anchor_activate), NULL); keybindings_set_item(plugin_key_group, SET_ANCHOR_KB, on_set_anchor_key, 0, 0, "set_anchor", _("Set anchor"), item); item = gtk_menu_item_new_with_mnemonic(_("Select to _Anchor")); gtk_container_add(menu, item); g_signal_connect(item, "activate", G_CALLBACK(on_select_to_anchor_activate), NULL); keybindings_set_item(plugin_key_group, ANCHOR_EXTEND_KB, on_select_to_anchor_key, 0, 0, "select_to_anchor", _("Select to anchor"), item); item = gtk_menu_item_new_with_mnemonic(_("_Rectangle Select to Anchor")); anchor_rect_select_item = item; gtk_container_add(menu, item); g_signal_connect(item, "activate", G_CALLBACK(on_select_rectangle_activate), NULL); keybindings_set_item(plugin_key_group, ANCHOR_RECTEXTEND_KB, on_select_rectangle_key, 0, 0, "rect_select_to_anchor", _("Rectangle select to anchor"), item); gtk_widget_show_all(main_menu_item); go_to_line1_item = g_object_get_data((gpointer) geany->main_widgets->window, "go_to_line1"); update_home_key(); plugin_signal_connect(geany_plugin, G_OBJECT(geany->main_widgets->window), "key-press-event", FALSE, G_CALLBACK(on_key_press_event), NULL); }
/* Called by Geany to initialize the plugin */ void plugin_init(G_GNUC_UNUSED GeanyData *data) { GtkWidget *menu_lipsum = NULL; GKeyFile *config = g_key_file_new(); gchar *config_file = NULL; gchar *config_file_old = NULL; gchar *config_dir = NULL; gchar *config_dir_old = NULL; GeanyKeyGroup *key_group; config_file = g_strconcat(geany->app->configdir, G_DIR_SEPARATOR_S, "plugins", G_DIR_SEPARATOR_S, "geanylipsum", G_DIR_SEPARATOR_S, "lipsum.conf", NULL); #ifndef G_OS_WIN32 /* We try only to move if we are on not Windows platform */ config_dir_old = g_build_filename(geany->app->configdir, "plugins", "geanylipsum", NULL); config_file_old = g_build_filename(config_dir_old, "lipsum.conf", NULL); config_dir = g_build_filename(geany->app->configdir, "plugins", "lipsum", NULL); if (g_file_test(config_file_old, G_FILE_TEST_EXISTS)) { if (dialogs_show_question( _("Renamed plugin detected!\n" "\n" "As you may have already noticed, GeanyLipsum has been " "renamed to just Lipsum. \n" "Geany is able to migrate your old plugin configuration by " "moving the old configuration file to new location.\n" "Warning: This will not include your keybindings.\n" "Move now?"))) { if (g_rename(config_dir_old, config_dir) == 0) { dialogs_show_msgbox(GTK_MESSAGE_INFO, _("Your configuration directory has been " "successfully moved from \"%s\" to \"%s\"."), config_dir_old, config_dir); } else { /* If there was an error on migrating we need * to load from original one. * When saving new configuration it will go to * new folder so migration should * be implicit. */ g_free(config_file); config_file = g_strdup(config_file_old); dialogs_show_msgbox( GTK_MESSAGE_WARNING, _("Your old configuration directory \"%s\" could " "not be moved to \"%s\" (%s). " "Please manually move the directory to the new location."), config_dir_old, config_dir, g_strerror(errno)); } } } g_free(config_dir_old); g_free(config_dir); g_free(config_file_old); #endif /* Initialising options from config file if there is any*/ g_key_file_load_from_file(config, config_file, G_KEY_FILE_NONE, NULL); lipsum = utils_get_setting_string(config, "snippets", "lipsumtext", default_loremipsum); g_key_file_free(config); g_free(config_file); /* Building menu entry */ menu_lipsum = gtk_image_menu_item_new_with_mnemonic(_("_Lipsum...")); gtk_widget_set_tooltip_text(menu_lipsum, _("Include Pseudotext to your code")); gtk_widget_show(menu_lipsum); g_signal_connect((gpointer) menu_lipsum, "activate", G_CALLBACK(lipsum_activated), NULL); gtk_container_add(GTK_CONTAINER(geany->main_widgets->tools_menu), menu_lipsum); ui_add_document_sensitive(menu_lipsum); main_menu_item = menu_lipsum; /* init keybindings */ key_group = plugin_set_key_group(geany_plugin, "lipsum", COUNT_KB, NULL); keybindings_set_item(key_group, LIPSUM_KB_INSERT, kblipsum_insert, 0, 0, "insert_lipsum", _("Insert Lipsum text"), menu_lipsum); }
void plugin_init(G_GNUC_UNUSED GeanyData *gdata) { GeanyKeyGroup *scope_key_group; char *gladefile = g_build_filename(PLUGINDATADIR, "scope.glade", NULL); GError *gerror = NULL; GtkWidget *menubar1 = find_widget(geany->main_widgets->window, "menubar1"); guint item; const MenuKey *menu_key = debug_menu_keys; ToolItem *tool_item = toolbar_items; const ScopeCallback *scb; main_locale_init(LOCALEDIR, GETTEXT_PACKAGE); scope_key_group = plugin_set_key_group(geany_plugin, "scope", COUNT_KB, NULL); builder = gtk_builder_new(); gtk_builder_set_translation_domain(builder, GETTEXT_PACKAGE); scp_tree_store_register_dynamic(); if (!gtk_builder_add_from_file(builder, gladefile, &gerror)) { msgwin_status_add(_("Scope: %s."), gerror->message); g_warning(_("Scope: %s."), gerror->message); g_error_free(gerror); g_object_unref(builder); builder = NULL; } g_free(gladefile); if (!builder) return; /* interface */ #ifndef G_OS_UNIX gtk_widget_hide(get_widget("terminal_show")); #endif debug_item = get_widget("debug_item"); if (menubar1) gtk_menu_shell_insert(GTK_MENU_SHELL(menubar1), debug_item, DEBUG_MENU_ITEM_POS); else gtk_container_add(GTK_CONTAINER(geany->main_widgets->tools_menu), debug_item); menu_connect("debug_menu", &debug_menu_info, NULL); ui_add_document_sensitive(get_widget("scope_reset_markers")); ui_add_document_sensitive(get_widget("scope_cleanup_files")); for (item = 0; item < EVALUATE_KB; item++, menu_key++) { keybindings_set_item(scope_key_group, item, on_scope_key, 0, 0, menu_key->name, _(menu_key->label), debug_menu_items[item].widget); } geany_statusbar = GTK_STATUSBAR(gtk_widget_get_parent(geany->main_widgets->progressbar)); debug_statusbar = get_widget("debug_statusbar"); debug_state_label = GTK_LABEL(get_widget("debug_state_label")); gtk_box_pack_end(GTK_BOX(geany_statusbar), debug_statusbar, FALSE, FALSE, 0); debug_panel = get_widget("debug_panel"); gtk_notebook_append_page(GTK_NOTEBOOK(geany->main_widgets->message_window_notebook), debug_panel, get_widget("debug_label")); /* startup */ gtk216_init(); program_init(); prefs_init(); conterm_init(); inspect_init(); register_init(); parse_init(); debug_init(); views_init(); thread_init(); break_init(); watch_init(); stack_init(); local_init(); memory_init(); menu_init(); menu_set_popup_keybindings(scope_key_group, item); for (item = 0; tool_item->index != -1; item++, tool_item++) { GtkMenuItem *menu_item = GTK_MENU_ITEM(debug_menu_items[tool_item->index].widget); GtkToolItem *button = gtk_tool_button_new(NULL, gtk_menu_item_get_label(menu_item)); gtk_tool_button_set_use_underline(GTK_TOOL_BUTTON(button), gtk_menu_item_get_use_underline(menu_item)); g_signal_connect(button, "clicked", G_CALLBACK(on_toolbar_button_clicked), GINT_TO_POINTER(tool_item->index)); g_signal_connect(button, "toolbar-reconfigured", G_CALLBACK(on_toolbar_reconfigured), tool_item); tool_item->widget = GTK_WIDGET(button); plugin_add_toolbar_item(geany_plugin, button); } toolbar_update_state(DS_INACTIVE); views_update_state(DS_INACTIVE); configure_toolbar(); g_signal_connect(debug_panel, "switch-page", G_CALLBACK(on_view_changed), NULL); for (scb = scope_callbacks; scb->name; scb++) plugin_signal_connect(geany_plugin, NULL, scb->name, FALSE, scb->callback, NULL); }