Пример #1
0
int main(int argc, char *argv[])
{
    GtkWidget *item;
    GtkMenuShell *menu;
    GError *error = NULL;

    if (!gtk_init_with_args(&argc, &argv, NULL, NULL, NULL, &error)) {
        fprintf(stderr, "gtk init: %s\n", error->message);
        g_error_free(error);
        return 1;
    }

    /* Status icon */
    status_icon = gtk_status_icon_new_from_icon_name(LOGO_ICON);
    gtk_status_icon_set_visible(status_icon, TRUE);

    g_signal_connect(G_OBJECT(status_icon), "button_press_event",
        G_CALLBACK(status_icon_on_button_press), NULL);

    /* App menu */
    app_menu = gtk_menu_new();
    menu = GTK_MENU_SHELL(app_menu);

    /* Settings menu */
    settings_menu = gtk_menu_new();
    menu = GTK_MENU_SHELL(settings_menu);

    /* About */
    item = gtk_menu_item_new_with_mnemonic(_("_About"));
    g_signal_connect(item, "activate", G_CALLBACK(menu_on_about), NULL);
    gtk_menu_shell_append(menu, item);

    /* Quit */
    item = gtk_menu_item_new_with_mnemonic(_("_Quit"));
    g_signal_connect(item, "activate", G_CALLBACK(menu_on_quit), NULL);

    gtk_menu_shell_append(menu, item);

    init_xcb();

    gtk_widget_show_all(app_menu);
    gtk_widget_show_all(settings_menu);

    gtk_main();

    return 0;
}
Пример #2
0
void gprj_menu_init()
{
	GtkWidget *image;

	s_sep_item = gtk_separator_menu_item_new();
	gtk_widget_show(s_sep_item);
	gtk_container_add(GTK_CONTAINER(geany->main_widgets->project_menu), s_sep_item);

	image = gtk_image_new_from_stock(GTK_STOCK_FIND, GTK_ICON_SIZE_MENU);
	gtk_widget_show(image);
	s_fif_item = gtk_image_menu_item_new_with_mnemonic(_("Find in Project Files"));
	gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(s_fif_item), image);
	gtk_widget_show(s_fif_item);
	gtk_container_add(GTK_CONTAINER(geany->main_widgets->project_menu), s_fif_item);
	g_signal_connect((gpointer) s_fif_item, "activate", G_CALLBACK(on_find_in_project), NULL);
	keybindings_set_item(plugin_key_group, KB_FIND_IN_PROJECT, kb_callback,
		0, 0, "find_in_project", _("Find in project files"), s_fif_item);

	image = gtk_image_new_from_stock(GTK_STOCK_FIND, GTK_ICON_SIZE_MENU);
	gtk_widget_show(image);
	s_ff_item = gtk_image_menu_item_new_with_mnemonic(_("Find Project File"));
	gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(s_ff_item), image);
	gtk_widget_show(s_ff_item);
	gtk_container_add(GTK_CONTAINER(geany->main_widgets->project_menu), s_ff_item);
	g_signal_connect((gpointer) s_ff_item, "activate", G_CALLBACK(on_find_file), NULL);
	keybindings_set_item(plugin_key_group, KB_FIND_FILE, kb_callback,
		0, 0, "find_file", _("Find project file"), s_ff_item);

	s_shs_item = gtk_menu_item_new_with_mnemonic(_("Swap Header/Source"));
	gtk_widget_show(s_shs_item);
	gtk_container_add(GTK_CONTAINER(geany->main_widgets->project_menu), s_shs_item);
	g_signal_connect((gpointer) s_shs_item, "activate", G_CALLBACK(on_swap_header_source), NULL);
	keybindings_set_item(plugin_key_group, KB_SWAP_HEADER_SOURCE, kb_callback,
		0, 0, "swap_header_source", _("Swap header/source"), s_shs_item);

	s_context_sep_item = gtk_separator_menu_item_new();
	gtk_widget_show(s_context_sep_item);
	gtk_menu_shell_prepend(GTK_MENU_SHELL(geany->main_widgets->editor_menu), s_context_sep_item);

	s_context_osf_item = gtk_menu_item_new_with_mnemonic(_("Open Selected File (gproject)"));
	gtk_widget_show(s_context_osf_item);
	gtk_menu_shell_prepend(GTK_MENU_SHELL(geany->main_widgets->editor_menu), s_context_osf_item);
	g_signal_connect((gpointer) s_context_osf_item, "activate", G_CALLBACK(on_open_selected_file), NULL);

	gprj_menu_activate_menu_items(FALSE);
}
Пример #3
0
void menu_item_new(GtkMenu* pMenu, const gchar* title, GCallback callback, gpointer userData)
{
	GtkWidget* pMenuItem = NULL;

	pMenuItem = gtk_menu_item_new_with_mnemonic(title);
	gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);
	g_signal_connect(G_OBJECT(pMenuItem), "activate", callback, userData);
}
Пример #4
0
/*#
    @method new_with_mnemonic GtkMenuItem
    @brief Creates a new GtkMenuItem containing a label.
    @param label The text of the button, with an underscore in front of the mnemonic character
    @return a new GtkMenuItem

    The label will be created using gtk_label_new_with_mnemonic(), so underscores
    in label indicate the mnemonic for the menu item.
 */
FALCON_FUNC MenuItem::new_with_mnemonic( VMARG )
{
    Gtk::ArgCheck1 args( vm, "S" );
    const gchar* label = args.getCString( 0 );
    GtkWidget* wdt = gtk_menu_item_new_with_mnemonic( label );
    vm->retval( new Gtk::MenuItem(
                vm->findWKI( "GtkMenuItem" )->asClass(), (GtkMenuItem*) wdt ) );
}
Пример #5
0
GtkWidget*
gtkui_create_pltmenu (int plt_idx) {
    GtkWidget *plmenu;
    GtkWidget *rename_playlist1;
    GtkWidget *remove_playlist1;
    GtkWidget *add_new_playlist1;
    GtkWidget *separator11;
    GtkWidget *load_playlist1;
    GtkWidget *save_playlist1;
    GtkWidget *save_all_playlists1;

    plmenu = gtk_menu_new ();
    pltmenu_idx = plt_idx;

    rename_playlist1 = gtk_menu_item_new_with_mnemonic (_("Rename Playlist"));
    if (pltmenu_idx == -1) {
        gtk_widget_set_sensitive (rename_playlist1, FALSE);
    }
    gtk_widget_show (rename_playlist1);
    gtk_container_add (GTK_CONTAINER (plmenu), rename_playlist1);

    remove_playlist1 = gtk_menu_item_new_with_mnemonic (_("Remove Playlist"));
    if (pltmenu_idx == -1) {
        gtk_widget_set_sensitive (remove_playlist1, FALSE);
    }
    gtk_widget_show (remove_playlist1);
    gtk_container_add (GTK_CONTAINER (plmenu), remove_playlist1);

    add_new_playlist1 = gtk_menu_item_new_with_mnemonic (_("Add New Playlist"));
    gtk_widget_show (add_new_playlist1);
    gtk_container_add (GTK_CONTAINER (plmenu), add_new_playlist1);

    g_signal_connect ((gpointer) rename_playlist1, "activate",
            G_CALLBACK (on_rename_playlist1_activate),
            NULL);
    g_signal_connect ((gpointer) remove_playlist1, "activate",
            G_CALLBACK (on_remove_playlist1_activate),
            NULL);
    g_signal_connect ((gpointer) add_new_playlist1, "activate",
            G_CALLBACK (on_add_new_playlist1_activate),
            NULL);

    add_tab_actions (plmenu);

    return plmenu;
}
Пример #6
0
/* Generate plugins menu item */
GtkWidget * gzrt_plugins_menu ( void )
{
	GtkWidget * menu_head;
	GtkWidget * menu;
	GtkWidget * item;
	PLUGINS   * p = &plugins;
	static int  init;
	
	/* Create title object */
	menu_head = gtk_menu_item_new_with_mnemonic( "_Plugins" );
	
	/* Create menu object */
	menu = gtk_menu_new();
	gtk_menu_item_set_submenu( GTK_MENU_ITEM(menu_head), menu );
	
	/* Create each respective plugin's entry */
	if( plugins.dl )
		while( p )
		{
			/* Create menu entry */
			item = gtk_image_menu_item_new_with_mnemonic( p->meta->long_name );
			
			/* Add it to menu */
			gtk_container_add( GTK_CONTAINER(menu), item );
			
			/* Set handler */
			if( p->meta->menu_bar )
				g_signal_connect_swapped( G_OBJECT(item), "activate", G_CALLBACK(p->meta->menu_bar), NULL );
			
			/* Call the functions init function (if applicable) */
			if( !init && p->meta->init )
				p->meta->init( &functions );
			
			/* Seek to next */
			p = p->next;
		}
	
	/* Create menu seperator 
	sep = gtk_separator_menu_item_new();
	gtk_container_add( GTK_CONTAINER(menu), sep );*/
	
	/* Create plugin preferences entry 
	item = gtk_menu_item_new_with_mnemonic( "Preferences" );
	g_signal_connect_swapped( G_OBJECT(item), "activate", G_CALLBACK(gzrt_plugins_preferences), NULL );
	gtk_container_add( GTK_CONTAINER(menu), item );*/
	
	/* Initialized */
	init++;
	
	/* Show all */
	gtk_widget_show_all( menu );
	
	/* No plugins? */
	gtk_widget_set_sensitive( menu_head, (plugins.dl ? TRUE : FALSE) );
	
	/* Return final product */
	return menu_head;
}
Пример #7
0
static void
file_entry_populate_popup (GtkEntry *entry, GtkMenu *menu, gpointer storage)
{
	GtkWidget *submenu, *item;
	GtkWidget *entry_file;

	item = gtk_separator_menu_item_new ();
	gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item);
	gtk_widget_show (item);

	item = gtk_menu_item_new_with_mnemonic (_("Selection to"));
	gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item);
	gtk_widget_show (item);

	submenu = gtk_menu_new ();
	gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), submenu);

	item = gtk_menu_item_new_with_label (_("Title"));
	g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (popup_menu_selection_to_title), storage);
	gtk_menu_shell_append (GTK_MENU_SHELL (submenu), item);
	item = gtk_menu_item_new_with_label (_("Artist"));
	g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (popup_menu_selection_to_artist), storage);
	gtk_menu_shell_append (GTK_MENU_SHELL (submenu), item);
	item = gtk_menu_item_new_with_label (_("Album"));
	g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (popup_menu_selection_to_album), storage);
	gtk_menu_shell_append (GTK_MENU_SHELL (submenu), item);
	item = gtk_menu_item_new_with_label (_("Genre"));
	g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (popup_menu_selection_to_genre), storage);
	gtk_menu_shell_append (GTK_MENU_SHELL (submenu), item);
	item = gtk_menu_item_new_with_label (_("Comment"));
	g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (popup_menu_selection_to_comment), storage);
	gtk_menu_shell_append (GTK_MENU_SHELL (submenu), item);

	gtk_widget_show_all (submenu);

	entry_file = g_object_get_data (storage, "entry_file");
	if (!gtk_editable_get_selection_bounds (GTK_EDITABLE(entry_file), NULL, NULL))
		gtk_widget_set_sensitive (submenu, FALSE);

	item = gtk_menu_item_new_with_mnemonic (_("Open folder"));
	g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (popup_menu_open_folder), storage);
	gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item);
	gtk_widget_show (item);
}
Пример #8
0
/* 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;
}
Пример #9
0
static void tb_editor_browser_populate_tool_menu_cb(MidoriBrowser *browser, GtkWidget *menu, MidoriExtension *ext)
{
    GtkWidget *menuitem;

    menuitem = gtk_menu_item_new_with_mnemonic (_("Customize _Toolbar..."));
    g_signal_connect (menuitem, "activate",
        G_CALLBACK (tb_editor_menu_configure_toolbar_activate_cb), browser);
    gtk_widget_show (menuitem);
    gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
}
Пример #10
0
static void
panel_context_menu_build_edition (PanelWidget *panel_widget,
				  GtkWidget   *menu)
{
	GtkWidget *menuitem;

	menuitem = gtk_menu_item_new_with_mnemonic (_("_Add to Panel..."));
	gtk_widget_show (menuitem);
	gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
        g_signal_connect (G_OBJECT (menuitem), "activate",
	      	       	  G_CALLBACK (panel_addto_present), panel_widget);

	if (!panel_layout_is_writable ())
		gtk_widget_set_sensitive (menuitem, FALSE);

	menuitem = gtk_menu_item_new_with_mnemonic (_("_Properties"));
	gtk_widget_show (menuitem);
	gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
	g_signal_connect (menuitem, "activate",
	                  G_CALLBACK (present_properties_dialog),
	                  panel_widget->toplevel);

	menuitem = gtk_menu_item_new_with_mnemonic (_("_Delete This Panel"));
	gtk_widget_show (menuitem);
	gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
	g_signal_connect_swapped (G_OBJECT (menuitem), "activate",
				  G_CALLBACK (panel_context_menu_delete_panel),
				  panel_widget->toplevel);
	g_signal_connect (G_OBJECT (menuitem), "show",
			  G_CALLBACK (panel_context_menu_setup_delete_panel_item),
			  panel_widget->toplevel);

	add_menu_separator (menu);

	menuitem = gtk_menu_item_new_with_mnemonic (_("_New Panel"));
	gtk_widget_show (menuitem);
	gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
	g_signal_connect (menuitem, "activate",
			  G_CALLBACK (panel_context_menu_create_new_panel), 
			  NULL);
	gtk_widget_set_sensitive (menuitem, 
				  panel_layout_is_writable ());
}
Пример #11
0
void menu_shell_add_entry(GtkMenuShell *menu, gchar *label, GCallback callback, gpointer data) {

    GtkWidget *entry;

    entry = gtk_menu_item_new_with_mnemonic(label);
    gtk_menu_shell_append (menu, entry);
    g_signal_connect(G_OBJECT(entry), "activate", callback, data);

    return;
}
Пример #12
0
void plugin_data_setup(geany_django_t* plugin_data)
{
	GeanyData* geany_data = plugin_data->geany_data; /* GTK_CONTAINER needs this */

	plugin_data->main_menu_item = gtk_menu_item_new_with_mnemonic("GeanyDjango");
	gtk_widget_show(plugin_data->main_menu_item);
	gtk_container_add(GTK_CONTAINER(geany->main_widgets->tools_menu), plugin_data->main_menu_item);
	g_signal_connect(plugin_data->main_menu_item, "activate",
			G_CALLBACK(callback_wrapper_cb), plugin_data);
}
Пример #13
0
static gboolean cc_buddy_menu(GtkWidget *menu, PurpleBuddy *b)
{
	GtkWidget *menuitem;

	menuitem = gtk_menu_item_new_with_mnemonic("CrazyChat");
	g_signal_connect(G_OBJECT(menuitem), "activate",
			G_CALLBACK(cc_menu_cb), b);
	gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
	return FALSE;
}
Пример #14
0
GtkWidget *menu_item_add(GtkWidget *menu, const gchar *label,
			 GCallback func, gpointer data)
{
	GtkWidget *item;

	item = gtk_menu_item_new_with_mnemonic(label);
	menu_item_finish(menu, item, func, data);

	return item;
}
Пример #15
0
static GtkWidget *
menu_quick_item (char *cmd, char *label, GtkWidget * menu, int flags,
					  gpointer userdata, char *icon)
{
	GtkWidget *img, *item;

	if (!label)
		item = gtk_menu_item_new ();
	else
	{
		if (icon)
		{
			/*if (flags & XCMENU_MARKUP)
				item = gtk_image_menu_item_new_with_markup (label);
			else*/
				item = gtk_image_menu_item_new_with_mnemonic (label);
			img = gtk_image_new_from_file (icon);
			if (img)
				gtk_image_menu_item_set_image ((GtkImageMenuItem *)item, img);
			else
			{
				img = gtk_image_new_from_stock (icon, GTK_ICON_SIZE_MENU);
				if (img)
					gtk_image_menu_item_set_image ((GtkImageMenuItem *)item, img);
			}
		}
		else
		{
			if (flags & XCMENU_MARKUP)
			{
				item = gtk_menu_item_new_with_label ("");
				if (flags & XCMENU_MNEMONIC)
					gtk_label_set_markup_with_mnemonic (GTK_LABEL (GTK_BIN (item)->child), label);
				else
					gtk_label_set_markup (GTK_LABEL (GTK_BIN (item)->child), label);
			} else
			{
				if (flags & XCMENU_MNEMONIC)
					item = gtk_menu_item_new_with_mnemonic (label);
				else
					item = gtk_menu_item_new_with_label (label);
			}
		}
	}
	gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
	g_object_set_data (G_OBJECT (item), "u", userdata);
	if (cmd)
		g_signal_connect (G_OBJECT (item), "activate",
								G_CALLBACK (popup_menu_cb), cmd);
	if (flags & XCMENU_SHADED)
		gtk_widget_set_sensitive (GTK_WIDGET (item), FALSE);
	gtk_widget_show_all (item);

	return item;
}
Пример #16
0
static void create_menu(MathWindow* window)
{
    GtkAccelGroup* accel_group;
    GtkWidget* menu;
    GtkWidget* menu_item;
    GSList* group = NULL;

    accel_group = gtk_accel_group_new();
    gtk_window_add_accel_group(GTK_WINDOW(window), accel_group);

    /* Calculator menu */
    #define CALCULATOR_MENU_LABEL _("_Calculator")
    /* Mode menu */
    #define MODE_MENU_LABEL _("_Mode")
    /* Help menu label */
    #define HELP_MENU_LABEL _("_Help")
    /* Basic menu label */
    #define MODE_BASIC_LABEL _("_Basic")
    /* Advanced menu label */
    #define MODE_ADVANCED_LABEL _("_Advanced")
    /* Financial menu label */
    #define MODE_FINANCIAL_LABEL _("_Financial")
    /* Programming menu label */
    #define MODE_PROGRAMMING_LABEL _("_Programming")
    /* Help>Contents menu label */
    #define HELP_CONTENTS_LABEL _("_Contents")

    menu = add_menu(window->priv->menu_bar, CALCULATOR_MENU_LABEL);
    add_menu_item(menu, gtk_image_menu_item_new_from_stock(GTK_STOCK_COPY, accel_group), G_CALLBACK(copy_cb), window);
    add_menu_item(menu, gtk_image_menu_item_new_from_stock(GTK_STOCK_PASTE, accel_group), G_CALLBACK(paste_cb), window);
    menu_item = add_menu_item(menu, gtk_image_menu_item_new_from_stock(GTK_STOCK_UNDO, accel_group), G_CALLBACK(undo_cb), window);
    gtk_widget_add_accelerator(menu_item, "activate", accel_group, GDK_KEY_Z, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
    menu_item = add_menu_item(menu, gtk_image_menu_item_new_from_stock(GTK_STOCK_REDO, accel_group), G_CALLBACK(redo_cb), window);
    gtk_widget_add_accelerator(menu_item, "activate", accel_group, GDK_KEY_Z, GDK_CONTROL_MASK | GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE);
    add_menu_item(menu, gtk_separator_menu_item_new(), NULL, NULL);
    add_menu_item(menu, gtk_image_menu_item_new_from_stock(GTK_STOCK_PREFERENCES, accel_group), G_CALLBACK(show_preferences_cb), window);
    add_menu_item(menu, gtk_separator_menu_item_new(), NULL, NULL);
    menu_item = add_menu_item(menu, gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, accel_group), G_CALLBACK(quit_cb), window);
    gtk_widget_add_accelerator(menu_item, "activate", accel_group, GDK_KEY_W, GDK_CONTROL_MASK, 0);

    menu = add_menu(window->priv->menu_bar, MODE_MENU_LABEL);
    window->priv->mode_basic_menu_item = add_menu_item(menu, radio_menu_item_new(&group, MODE_BASIC_LABEL), G_CALLBACK(mode_changed_cb), window);
    g_object_set_data(G_OBJECT(window->priv->mode_basic_menu_item), "calcmode", GINT_TO_POINTER(BASIC));
    window->priv->mode_advanced_menu_item = add_menu_item(menu, radio_menu_item_new(&group, MODE_ADVANCED_LABEL), G_CALLBACK(mode_changed_cb), window);
    g_object_set_data(G_OBJECT(window->priv->mode_advanced_menu_item), "calcmode", GINT_TO_POINTER(ADVANCED));
    window->priv->mode_financial_menu_item = add_menu_item(menu, radio_menu_item_new(&group, MODE_FINANCIAL_LABEL), G_CALLBACK(mode_changed_cb), window);
    g_object_set_data(G_OBJECT(window->priv->mode_financial_menu_item), "calcmode", GINT_TO_POINTER(FINANCIAL));
    window->priv->mode_programming_menu_item = add_menu_item(menu, radio_menu_item_new(&group, MODE_PROGRAMMING_LABEL), G_CALLBACK(mode_changed_cb), window);
    g_object_set_data(G_OBJECT(window->priv->mode_programming_menu_item), "calcmode", GINT_TO_POINTER(PROGRAMMING));

    menu = add_menu(window->priv->menu_bar, HELP_MENU_LABEL);
    menu_item = add_menu_item(menu, gtk_menu_item_new_with_mnemonic(HELP_CONTENTS_LABEL), G_CALLBACK(help_cb), window);
    gtk_widget_add_accelerator(menu_item, "activate", accel_group, GDK_KEY_F1, 0, GTK_ACCEL_VISIBLE);
    add_menu_item(menu, gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT, accel_group), G_CALLBACK(about_cb), window);
}
Пример #17
0
AwnApplet*
awn_applet_factory_initp ( gchar* uid, gint orient, gint height )
{
  AwnApplet *applet = awn_applet_new( uid, orient, height );
  GtkWidget     *trash;
  GtkWidget     *menu;
  GtkWidget     *item;
  
  gnome_vfs_init ();
  
  /* trash */
  trash = trash_applet_new (applet);

  /* menu */
  menu = awn_applet_create_default_menu (applet);

  item = gtk_image_menu_item_new_from_stock (GTK_STOCK_ABOUT, NULL);
  gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item);
  g_signal_connect (G_OBJECT (item), "activate", 
                    G_CALLBACK (show_about), trash);


  item = gtk_image_menu_item_new_from_stock (GTK_STOCK_HELP, NULL);
  gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item);
  g_signal_connect (G_OBJECT (item), "activate", 
                    G_CALLBACK (show_help), trash);


  item = gtk_separator_menu_item_new ();
  gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item);

  item = gtk_menu_item_new_with_mnemonic ("_Empty the Wastebasket");
  gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item);
  g_signal_connect (G_OBJECT (item), "activate", 
                    G_CALLBACK (empty_trash), trash);
  
  item = gtk_image_menu_item_new_from_stock (GTK_STOCK_OPEN, NULL);
  gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item);
  g_signal_connect (G_OBJECT (item), "activate", 
                    G_CALLBACK (open_trash), trash);

  g_signal_connect (G_OBJECT (applet), "button-release-event", 
                    G_CALLBACK (applet_button_release), menu);
                         
  
  gtk_widget_set_size_request (GTK_WIDGET (applet),
                               awn_applet_get_height (applet), 
                               awn_applet_get_height (applet) * 2);
  
  gtk_container_add (GTK_CONTAINER (applet), trash);
  
  gtk_widget_show_all (GTK_WIDGET (menu));

  return applet;
}
void plugin_init(GeanyData *data)
{
	/* read & prepare configuration */
	gchar *config_dir = g_build_path(G_DIR_SEPARATOR_S,
		geany_data->app->configdir, "plugins", "unixtsconverter", NULL);
	plugin_config_path = g_build_path(G_DIR_SEPARATOR_S, config_dir,
										"unixtsconverter.conf", NULL);

	g_mkdir_with_parents(config_dir, S_IRUSR | S_IWUSR | S_IXUSR);
	g_free(config_dir);

	keyfile_plugin = g_key_file_new();

	if (!g_key_file_load_from_file(keyfile_plugin, plugin_config_path,
									G_KEY_FILE_NONE, NULL))
	{
		config_set_defaults(keyfile_plugin);
		config_save_setting(keyfile_plugin, plugin_config_path);
	}
	else
	{
		showResultInMsgPopupWindow = config_get_setting(keyfile_plugin,
									"show_result_in_message_window");

		showErrors = config_get_setting(keyfile_plugin,
									"show_failure_messages");

		useClipboard = config_get_setting(keyfile_plugin,
									"use_clipboard_too");

		autodetectTimestampInMsAndUs = config_get_setting(
				keyfile_plugin,	"autodetect_timestamp_in_ms_us");
	}

	/* ---------------------------- */

	main_menu_item = gtk_menu_item_new_with_mnemonic(
											"Unix Timestamp Converter");
	gtk_widget_show(main_menu_item);
	gtk_container_add(GTK_CONTAINER(geany->main_widgets->tools_menu),
						main_menu_item);
	g_signal_connect(main_menu_item, "activate",
						G_CALLBACK(item_activate_cb), NULL);

	/* Register shortcut key group */
	geany_key_group = plugin_set_key_group(
						geany_plugin, _("unix_ts_converter"), 1, NULL);

	/* Ctrl + Alt + c */
	keybindings_set_item(geany_key_group, 0, kb_run_unix_ts_converter,
                         GDK_c, GDK_CONTROL_MASK | GDK_MOD1_MASK,
                         "run_unix_ts_converter",
                         _("Run the Unix Timestamp Converter"),
                         main_menu_item);
}
Пример #19
0
void plugin_init(GeanyData *data)
{
    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);

    GtkWidget * submenu = gtk_menu_new();
    gtk_widget_show(submenu);
    GtkWidget * encrypt = gtk_menu_item_new_with_mnemonic("Encrypt");
    GtkWidget * sign = gtk_menu_item_new_with_mnemonic("Sign");
    GtkWidget * decrypt = gtk_menu_item_new_with_mnemonic("Decrypt / Verify");
    GtkWidget * 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_append(GTK_MENU(submenu), encrypt);
    gtk_menu_append(GTK_MENU(submenu), sign);
    gtk_menu_append(GTK_MENU(submenu), decrypt);
    gtk_menu_append(GTK_MENU(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);
}
Пример #20
0
static void _popup_file(GtkWidget * menu, DesktopIcon * desktopicon)
{
	Mime * mime;
	GtkWidget * menuitem;

	mime = desktop_get_mime(desktopicon->desktop);
	_popup_mime(mime, desktopicon->mimetype, "open", GTK_STOCK_OPEN,
			G_CALLBACK(_on_icon_open), desktopicon, menu);
	_popup_mime(mime, desktopicon->mimetype, "edit",
#if GTK_CHECK_VERSION(2, 6, 0)
			GTK_STOCK_EDIT,
#else
			_("_Edit"),
#endif
			G_CALLBACK(_on_icon_edit), desktopicon, menu);
	if(desktopicon->isexec == TRUE)
	{
		menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_EXECUTE,
				NULL);
		g_signal_connect_swapped(G_OBJECT(menuitem), "activate",
				G_CALLBACK(_on_icon_run), desktopicon);
		gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
	}
	if(desktopicon->path != NULL && desktopicon->path[0] == '/')
	{
		menuitem = gtk_menu_item_new_with_mnemonic(_("Open _with..."));
		g_signal_connect_swapped(G_OBJECT(menuitem), "activate",
				G_CALLBACK(_on_icon_open_with), desktopicon);
		gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
		if(desktopicon->immutable == FALSE)
		{
			menuitem = gtk_separator_menu_item_new();
			gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
			menuitem = gtk_menu_item_new_with_mnemonic(
					_("_Rename..."));
			g_signal_connect_swapped(G_OBJECT(menuitem), "activate",
					G_CALLBACK(_on_icon_rename),
					desktopicon);
			gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
		}
	}
}
Пример #21
0
static void create_file_menu_items(GtkMenuShell * menu,
                                   GtkAccelGroup * accel_group)
{
    GtkWidget      *menu_item;

    if (menu == NULL)
        return;

    menu_item = gtk_menu_item_new_with_mnemonic(_("_New module"));
    g_signal_connect(menu_item, "activate", G_CALLBACK(menubar_new_mod_cb),
                     NULL);
    gtk_widget_add_accelerator(menu_item, "activate", accel_group, GDK_KEY_n,
                               GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
    gtk_menu_shell_append(menu, menu_item);

    menu_item = gtk_menu_item_new_with_mnemonic(_("_Open module"));
    g_signal_connect(menu_item, "activate", G_CALLBACK(menubar_open_mod_cb),
                     NULL);
    gtk_widget_add_accelerator(menu_item, "activate", accel_group, GDK_KEY_o,
                               GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
    gtk_menu_shell_append(menu, menu_item);

    menu_item = gtk_separator_menu_item_new();
    gtk_menu_shell_append(menu, menu_item);

    menu_item = gtk_menu_item_new_with_mnemonic(_("_Log browser"));
    g_signal_connect(menu_item, "activate", G_CALLBACK(menubar_message_log),
                     NULL);
    gtk_widget_add_accelerator(menu_item, "activate", accel_group, GDK_KEY_l,
                               GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
    gtk_menu_shell_append(menu, menu_item);

    menu_item = gtk_separator_menu_item_new();
    gtk_menu_shell_append(menu, menu_item);

    menu_item = gtk_menu_item_new_with_mnemonic(_("_Quit"));
    g_signal_connect(menu_item, "activate", G_CALLBACK(menubar_app_exit_cb),
                     NULL);
    gtk_widget_add_accelerator(menu_item, "activate", accel_group, GDK_KEY_q,
                               GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
    gtk_menu_shell_append(menu, menu_item);
}
Пример #22
0
static void create_sub_menu(GtkWidget *parent, GeanyFiletypeGroupID group_id, const gchar *title)
{
	GtkWidget *menu, *item;

	menu = gtk_menu_new();
	item = gtk_menu_item_new_with_mnemonic((title));
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), menu);
	gtk_container_add(GTK_CONTAINER(parent), item);
	gtk_widget_show(item);
	group_menus[group_id] = menu;
}
Пример #23
0
static GtkWidget *add_submenu(GtkWidget *menu, const char *label)
{
	GtkWidget *item, *submenu;

	item = gtk_menu_item_new_with_mnemonic(label);
	submenu = gtk_menu_new();
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
	gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
	gtk_widget_show(item);
	return submenu;
}
Пример #24
0
void plugin_init(GeanyData *data)
{
    init_configuration();

    main_menu_item = gtk_menu_item_new_with_mnemonic(_("Check for Updates"));
    gtk_widget_show(main_menu_item);
    gtk_container_add(GTK_CONTAINER(geany->main_widgets->tools_menu),
        main_menu_item);
    g_signal_connect(main_menu_item, "activate",
        G_CALLBACK(manual_check_activated_cb), NULL);
}
Пример #25
0
static GtkWidget *
create_recent_chooser_menu (gint limit)
{
  GtkWidget *menu;
  GtkRecentFilter *filter;
  GtkWidget *menuitem;
  
  menu = gtk_recent_chooser_menu_new_for_manager (manager);

  if (limit > 0)
    gtk_recent_chooser_set_limit (GTK_RECENT_CHOOSER (menu), limit);
  gtk_recent_chooser_set_local_only (GTK_RECENT_CHOOSER (menu), TRUE);
  gtk_recent_chooser_set_show_icons (GTK_RECENT_CHOOSER (menu), TRUE);
  gtk_recent_chooser_set_show_tips (GTK_RECENT_CHOOSER (menu), TRUE);
  gtk_recent_chooser_set_sort_type (GTK_RECENT_CHOOSER (menu),
                                    GTK_RECENT_SORT_MRU);
  gtk_recent_chooser_menu_set_show_numbers (GTK_RECENT_CHOOSER_MENU (menu),
                                            TRUE);

  filter = gtk_recent_filter_new ();
  gtk_recent_filter_set_name (filter, "Gedit files");
  gtk_recent_filter_add_application (filter, "gedit");
  gtk_recent_chooser_add_filter (GTK_RECENT_CHOOSER (menu), filter);
  gtk_recent_chooser_set_filter (GTK_RECENT_CHOOSER (menu), filter);

  g_signal_connect (menu, "item-activated",
                    G_CALLBACK (item_activated_cb),
                    NULL);

  menuitem = gtk_separator_menu_item_new ();
  gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menuitem);
  gtk_widget_show (menuitem);

  menuitem = gtk_menu_item_new_with_label ("Test prepend");
  gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menuitem);
  gtk_widget_show (menuitem);

  menuitem = gtk_separator_menu_item_new ();
  gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
  gtk_widget_show (menuitem);

  menuitem = gtk_menu_item_new_with_label ("Test append");
  gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
  gtk_widget_show (menuitem);

  menuitem = gtk_menu_item_new_with_mnemonic ("Clear");
  gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
  gtk_widget_show (menuitem);

  gtk_widget_show_all (menu);

  return menu;
}
Пример #26
0
Файл: menu.c Проект: be1/jackie
/* append an item to the menu, and connect its callback on "activate" event */
GtkMenuItem* menu_append_item(GtkMenu* menu, gchar* label, GCallback callback, gpointer cb_data)
{
	GtkWidget* item;

	item = gtk_menu_item_new_with_mnemonic (label);
	gtk_menu_shell_append ((GtkMenuShell*) (menu), item);
	if (callback)
		g_signal_connect (G_OBJECT(item), "activate", G_CALLBACK(callback), cb_data);
	gtk_widget_show (item);

	return GTK_MENU_ITEM(item);
}
Пример #27
0
static GtkWidget *create_sub_menu(GtkWidget *parent, const gchar *title)
{
	GtkWidget *menu, *item;

	menu = gtk_menu_new();
	item = gtk_menu_item_new_with_mnemonic((title));
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), menu);
	gtk_container_add(GTK_CONTAINER(parent), item);
	gtk_widget_show(item);

	return menu;
}
Пример #28
0
static GtkAccelGroup *ui_set_menu_item(GtkWidget **menu, GtkWidget **item, 
    char *name) {

    *item = gtk_menu_item_new_with_mnemonic(name);
    *menu = gtk_menu_new();

    GtkAccelGroup *group = gtk_accel_group_new();
    gtk_window_add_accel_group(GTK_WINDOW(mwin->main), group);
    gtk_menu_set_accel_group(GTK_MENU(*menu), group);

    return group;
}
Пример #29
0
static GtkWidget *
menu_add_option (GtkMenu *menu, const gchar *label, gpointer cb, gpointer user_data)
{
	GtkWidget *item;

	g_assert (label);
	item = gtk_menu_item_new_with_mnemonic (label);
	g_signal_connect (item, "activate", G_CALLBACK (cb), user_data);
	gtk_widget_show (item);
	gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
	return item;
}
Пример #30
0
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);
}