Пример #1
0
static void
search_entry_populate_popup (GtkEntry       *entry,
                             GtkMenu        *menu,
                             GeditViewFrame *frame)
{
	GtkWidget *menu_item;

	frame->priv->disable_popdown = TRUE;
	g_signal_connect (menu, "hide",
			  G_CALLBACK (search_enable_popdown), frame);

	if (frame->priv->search_mode == GOTO_LINE)
		return;

	/* separator */
	menu_item = gtk_separator_menu_item_new ();
	gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item);
	gtk_widget_show (menu_item);

	add_popup_menu_items (GTK_WIDGET (menu), frame);
}
Пример #2
0
static void
on_browser_populate_popup (GwhBrowser *browser,
                           GtkMenu    *menu,
                           gpointer    dummy)
{
  GtkWidget  *item;
  gboolean    auto_reload = FALSE;
  
  item = gtk_separator_menu_item_new ();
  gtk_widget_show (item);
  gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
  
  g_object_get (G_OBJECT (G_settings), "browser-auto-reload", &auto_reload,
                NULL);
  item = gtk_check_menu_item_new_with_mnemonic (_("Reload upon document saving"));
  gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), auto_reload);
  gtk_widget_show (item);
  gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
  g_signal_connect (item, "toggled", G_CALLBACK (on_item_auto_reload_toggled),
                    NULL);
}
Пример #3
0
/*
 *===========================================================================
 * M E N U B A R
 *===========================================================================
 */
GtkWidget*
createMenubar()
{
    GtkWidget* menuitem;
    GtkWidget* rootmenu;
    GtkWidget* menu;

    menu = gtk_menu_new();

    menuitem = gtk_menu_item_new_with_mnemonic("_New");
    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
    g_signal_connect(
        G_OBJECT(menuitem), "activate", G_CALLBACK(fileNew), NULL);

    menuitem = gtk_menu_item_new_with_mnemonic("_Open");
    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);

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

    menuitem = gtk_menu_item_new_with_mnemonic("_Quit");
    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);

    GtkWidget* menubar = gtk_menu_bar_new();

    rootmenu = gtk_menu_item_new_with_mnemonic("_File");
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(rootmenu), menu);
    gtk_menu_shell_append(GTK_MENU_SHELL(menubar), rootmenu);

    menu = gtk_menu_new();

    menuitem = gtk_menu_item_new_with_mnemonic("_About");
    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);

    rootmenu = gtk_menu_item_new_with_mnemonic("_Help");
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(rootmenu), menu);
    gtk_menu_shell_append(GTK_MENU_SHELL(menubar), rootmenu);

    return menubar;
}
static gboolean
create_popup_menu_item (GeditCollaborationWindowHelper *helper,
                        GtkMenu                        *menu,
                        const gchar                    *id,
                        gboolean                        create_separator)
{
	GtkAction *action;
	GtkWidget *item;
	GtkActionGroup *ac;

	action = get_action (helper, id);
	g_object_get (action, "action-group", &ac, NULL);

	if (!gtk_action_get_sensitive (action) ||
	    !gtk_action_group_get_sensitive (ac))
	{
		g_object_unref (ac);
		return FALSE;
	}

	gtk_action_set_accel_group (action,
	                            gtk_ui_manager_get_accel_group (helper->priv->uimanager));

	g_object_unref (ac);

	if (create_separator)
	{
		item = gtk_separator_menu_item_new ();
		gtk_widget_show (item);

		gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
	}

	item = gtk_action_create_menu_item (action);
	gtk_widget_show (item);

	gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);

	return TRUE;
}
Пример #5
0
static void
xfce_constructor (XfcePanelPlugin *plugin)
{
	MultiloadPlugin *multiload = multiload_new();

	multiload->panel_data = plugin;
	multiload->panel_orientation = xfce_panel_plugin_get_orientation (plugin);
	gtk_container_add (GTK_CONTAINER (plugin), GTK_WIDGET(multiload->container));

	multiload_ui_read (multiload);
	multiload_start(multiload);


	/* show the panel's right-click menu on this ebox */
	xfce_panel_plugin_add_action_widget (plugin, GTK_WIDGET(multiload->container));


	/* plugin signals */
	g_signal_connect(G_OBJECT(plugin), "free-data",           G_CALLBACK (xfce_free_cb),                multiload);
	g_signal_connect(G_OBJECT(plugin), "save",                G_CALLBACK (xfce_save_cb),                multiload);
	g_signal_connect(G_OBJECT(plugin), "size-changed",        G_CALLBACK (xfce_size_changed_cb),        multiload);
	g_signal_connect(G_OBJECT(plugin), "orientation-changed", G_CALLBACK (xfce_orientation_changed_cb), multiload);

	/* menu items */
	GtkMenuItem *mi_separator = GTK_MENU_ITEM(gtk_separator_menu_item_new ());
	GtkMenuItem *mi_help = GTK_MENU_ITEM(gtk_menu_item_new_with_mnemonic (_("_Help")));
	GtkMenuItem *mi_sysmon = GTK_MENU_ITEM(gtk_menu_item_new_with_label(_("Start task manager")));
	xfce_panel_plugin_menu_show_configure (plugin);
	xfce_panel_plugin_menu_show_about (plugin);
	xfce_panel_plugin_menu_insert_item (plugin, mi_separator);
	xfce_panel_plugin_menu_insert_item (plugin, mi_help);
	xfce_panel_plugin_menu_insert_item (plugin, mi_sysmon);
	g_signal_connect (G_OBJECT (plugin), "configure-plugin",	G_CALLBACK (xfce_configure_cb), multiload);
	g_signal_connect (G_OBJECT (plugin), "about",				G_CALLBACK (xfce_about_cb), NULL);
	g_signal_connect (G_OBJECT (mi_help), "activate",			G_CALLBACK (xfce_help_cb), NULL);
	g_signal_connect (G_OBJECT (mi_sysmon), "activate",			G_CALLBACK (xfce_sysmon_cb), multiload);
	gtk_widget_show(GTK_WIDGET(mi_separator));
	gtk_widget_show(GTK_WIDGET(mi_help));
	gtk_widget_show(GTK_WIDGET(mi_sysmon));
}
static gboolean
xfdesktop_special_file_icon_populate_context_menu(XfdesktopIcon *icon,
                                                  GtkWidget *menu)
{
    XfdesktopSpecialFileIcon *special_file_icon = XFDESKTOP_SPECIAL_FILE_ICON(icon);
    GtkWidget *mi, *img;

    if(XFDESKTOP_SPECIAL_FILE_ICON_TRASH != special_file_icon->priv->type)
        return FALSE;

    img = gtk_image_new_from_icon_name("document-open", GTK_ICON_SIZE_MENU);
    mi = xfdesktop_menu_create_menu_item_with_mnemonic(_("_Open"), img);
    gtk_widget_show(mi);
    gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);
    g_signal_connect(G_OBJECT(mi), "activate",
                     G_CALLBACK(xfdesktop_special_file_icon_trash_open), icon);

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

    if(special_file_icon->priv->trash_item_count == 0) {
        img = gtk_image_new_from_icon_name("user-trash", GTK_ICON_SIZE_MENU);
    } else {
        img = gtk_image_new_from_icon_name("user-trash-full", GTK_ICON_SIZE_MENU);
    }

    mi = xfdesktop_menu_create_menu_item_with_mnemonic(_("_Empty Trash"), img);
    gtk_widget_show(mi);
    gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);
    if(special_file_icon->priv->trash_item_count > 0) {
        g_signal_connect(G_OBJECT(mi), "activate",
                         G_CALLBACK(xfdesktop_special_file_icon_trash_empty),
                         icon);
    } else
        gtk_widget_set_sensitive(mi, FALSE);

    return TRUE;
}
Пример #7
0
static void
is_indicator_constructed(GObject *object)
{
  IsIndicator *self = IS_INDICATOR(object);
  GtkActionGroup *action_group;
  GtkUIManager *ui_manager;
  GError *error = NULL;
  GtkWidget *menu;

  action_group = gtk_action_group_new("AppActions");
  gtk_action_group_set_translation_domain(action_group, GETTEXT_PACKAGE);
  gtk_action_group_add_actions(action_group,
                               entries, n_entries,
                               self);

  ui_manager = gtk_ui_manager_new();
  gtk_ui_manager_insert_action_group(ui_manager, action_group, 0);
  if (!gtk_ui_manager_add_ui_from_string(ui_manager, ui_info, -1, &error))
  {
    g_error("Failed to build menus: %s\n", error->message);
  }

  menu = gtk_ui_manager_get_widget(ui_manager, "/ui/Indicator");
  /* manually add separator since specifying it in the ui description
     means it gets optimised out (since there is no menu item above it)
     but if we manually add it and show the whole menu then all is
     good... */
  gtk_menu_shell_prepend(GTK_MENU_SHELL(menu),
                         gtk_separator_menu_item_new());
  gtk_widget_show_all(menu);

  is_indicator_set_label(self, _("No Sensors"));
  is_indicator_set_menu(self, GTK_MENU(menu));
#if HAVE_APPINDICATOR
  app_indicator_set_status(APP_INDICATOR(self), APP_INDICATOR_STATUS_ACTIVE);
#endif

  fake_add_enable_sensors(IS_INDICATOR(object));
}
Пример #8
0
static void tray_icon_on_menu(GtkStatusIcon *status_icon, guint button, guint activate_time, gpointer user_data)
{
    GtkWidget *titleMenuItem = gtk_menu_item_new_with_label(menu_title);
    gtk_widget_set_sensitive(titleMenuItem, FALSE);
    openMenuItem = gtk_menu_item_new_with_label("Open");
    if (!url) {
        gtk_widget_set_sensitive(openMenuItem, FALSE);
        gtk_widget_set_sensitive(copyMenuItem, FALSE);
    }
    GtkWidget *exitMenuItem = gtk_menu_item_new_with_label("Exit");
    GtkWidget *menu = gtk_menu_new();

    g_signal_connect(G_OBJECT(openMenuItem), "activate", G_CALLBACK(handle_open), NULL);
    g_signal_connect(G_OBJECT(exitMenuItem), "activate", G_CALLBACK(tray_exit), NULL);

    gtk_menu_shell_append(GTK_MENU_SHELL(menu), openMenuItem);
    gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());
    gtk_menu_shell_append(GTK_MENU_SHELL(menu), exitMenuItem);
    gtk_widget_show_all(menu);

    gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, 0, gtk_get_current_event_time());
}
Пример #9
0
static GtkWidget *bmark_popup_menu(Tbfwin * bfwin, gboolean show_bmark_specific, gboolean show_file_specific) {
	GtkWidget *menu, *menu_item;

	menu = gtk_menu_new();
	if (show_bmark_specific) {
		menu_item = gtk_menu_item_new_with_label(_("Goto bookmark"));
		g_signal_connect(GTK_OBJECT(menu_item), "activate", G_CALLBACK(bmark_popup_menu_goto_lcb),
						 bfwin);
		gtk_menu_append(GTK_MENU(menu), menu_item);
	
		menu_item = gtk_separator_menu_item_new();
		gtk_menu_append(GTK_MENU(menu), menu_item);
	
		menu_item = gtk_menu_item_new_with_label(_("Edit"));
		g_signal_connect(GTK_OBJECT(menu_item), "activate", G_CALLBACK(bmark_popup_menu_rename_lcb),
						 bfwin);
		gtk_menu_append(GTK_MENU(menu), menu_item);
		menu_item = gtk_menu_item_new_with_label(_("Delete"));
		g_signal_connect(GTK_OBJECT(menu_item), "activate", G_CALLBACK(bmark_popup_menu_del_lcb),
						 bfwin);
		gtk_menu_append(GTK_MENU(menu), menu_item);
	}
	if (show_file_specific) {
		menu_item = gtk_menu_item_new_with_label(_("Delete all in document"));
		g_signal_connect(GTK_OBJECT(menu_item), "activate", G_CALLBACK(bmark_popup_menu_deldoc_lcb),
						 bfwin);
		gtk_menu_append(GTK_MENU(menu), menu_item);
	}
	menu_item = gtk_menu_item_new_with_label(_("Delete all"));
	g_signal_connect(GTK_OBJECT(menu_item), "activate", G_CALLBACK(bmark_popup_menu_delall_lcb),
					 bfwin);
	gtk_menu_append(GTK_MENU(menu), menu_item);

	gtk_widget_show_all(menu);
	g_signal_connect_after(G_OBJECT(menu), "destroy", G_CALLBACK(destroy_disposable_menu_cb), menu);

	return menu;
}
Пример #10
0
static gboolean button_press_event_cb (GtkWidget *widget, GdkEventButton *event,
                                       WebKitWebView *view)
{
	if (event && event->button != 3)
		return FALSE;
	// GtkMenu API is horrible for non-persistant menus. Make it persistant.
	static GtkWidget *menu = 0;
	if (menu)
		gtk_widget_destroy (menu);
	menu = gtk_menu_new();
	// add a couple of items (based on GtkTextView)
	GtkWidget *item;
	item = gtk_image_menu_item_new_from_stock (GTK_STOCK_COPY, NULL);
	gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
	if (webkit_web_view_can_copy_clipboard (view))
		g_signal_connect (item, "activate", G_CALLBACK (copy_activate_cb), widget);
	else
		gtk_widget_set_sensitive (item, FALSE);
	item = gtk_separator_menu_item_new();
	gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
	item = gtk_image_menu_item_new_from_stock (GTK_STOCK_SELECT_ALL, NULL);
	gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
	g_signal_connect (item, "activate", G_CALLBACK (select_all_activate_cb), widget);

	int button, event_time;
	if (event) {
		button = event->button;
		event_time = event->time;
	}
	else {
		button = 0;
		event_time = gtk_get_current_event_time();
	}
	gtk_menu_attach_to_widget (GTK_MENU (menu), widget, NULL);
	gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, button, event_time);
	gtk_widget_show_all (menu);
	return TRUE;
}
Пример #11
0
static void
populate_host_list(login_dlg *ldlg) {
	GtkWidget *menu, *item, *box, *icon, *label;
	GSList *l;
	JamHost *h;
	int i = 0, history = -1;

	menu = gtk_menu_new();
	for (l = conf.hosts; l != NULL; l = l->next) {
		h = l->data;
		item = gtk_menu_item_new();
		box = gtk_hbox_new(FALSE, 3);
		icon = gtk_image_new_from_stock(jam_host_get_stock_icon(h), GTK_ICON_SIZE_MENU);
		label = gtk_label_new(h->name);
		gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
		gtk_box_pack_start(GTK_BOX(box), icon, FALSE, FALSE, 0);
		gtk_box_pack_start(GTK_BOX(box), label, TRUE, TRUE, 0);
		gtk_container_add(GTK_CONTAINER(item), box);
		gtk_widget_show_all(item);
		gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
		if (ldlg->curhost && (g_ascii_strcasecmp(h->name, ldlg->curhost->name) == 0))
			history = i;
		i++;
	}

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

	item = gtk_menu_item_new_with_label(_("Add/Edit Servers..."));
	g_signal_connect(G_OBJECT(item), "activate",
			G_CALLBACK(addedit_host_cb), ldlg);
	gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
	
	gtk_widget_show_all(menu);
	gtk_option_menu_set_menu(GTK_OPTION_MENU(ldlg->mhost), menu);
	if (history >= 0)
		gtk_option_menu_set_history(GTK_OPTION_MENU(ldlg->mhost), history);
}
Пример #12
0
void
setup_view_menu(BotViewer *viewer)
{
    GtkWidget *view_menu = viewer->view_menu;

    // bookmarks

    gtk_menu_append(GTK_MENU(view_menu), gtk_separator_menu_item_new());

    // predefined viewpoints
    GtkWidget *setview_y_up_item = gtk_menu_item_new_with_mnemonic("Y axis up");
    gtk_menu_append(GTK_MENU(view_menu), setview_y_up_item);
    g_signal_connect(G_OBJECT(setview_y_up_item), "activate", 
            G_CALLBACK(on_setview_y_up_item), viewer);

    // predefined viewpoints
    GtkWidget *setview_x_up_item = gtk_menu_item_new_with_mnemonic("X axis up");
    gtk_menu_append(GTK_MENU(view_menu), setview_x_up_item);
    g_signal_connect(G_OBJECT(setview_x_up_item), "activate", 
            G_CALLBACK(on_setview_x_up_item), viewer);

    gtk_widget_show_all(view_menu);
}
Пример #13
0
GtkWidget *
gtk_create_menu_bar(GtkWidget *event_box) {
    GtkWidget *menu_bar, *menu, *menu_items, *action_menu, *help_menu;
    GdkColor color;

    menu_bar = gtk_menu_bar_new();

    menu = gtk_menu_new();

    menu_items = gtk_menu_item_new_with_label("Restart Game");
    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_items);
    g_signal_connect(menu_items, "activate", G_CALLBACK(restart_game_menu_event_handler),
            (gpointer) event_box);
    menu_items = gtk_separator_menu_item_new();
    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_items);
    menu_items = gtk_menu_item_new_with_label("Quit");
    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_items);
    g_signal_connect(menu_items, "activate", G_CALLBACK(quit_menu_event_handler),
            NULL);
    action_menu = gtk_menu_item_new_with_mnemonic("_Action");
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(action_menu), menu);
    gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), action_menu);

    menu = gtk_menu_new();
    menu_items = gtk_menu_item_new_with_label("About");
    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_items);
    g_signal_connect(menu_items, "activate", G_CALLBACK(about_menu_event_handler),
            (gpointer) event_box);
    help_menu = gtk_menu_item_new_with_mnemonic("_Help");
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(help_menu), menu);
    gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), help_menu);

    gdk_color_parse(MENU_BAR_COLOR, &color);
    gtk_widget_modify_bg(menu_bar, GTK_STATE_NORMAL, &color);

    return menu_bar;
}
Пример #14
0
GtkWidget* create_menu_icon(struct _tray_icon *tray)
{
	GtkWidget *menu = gtk_menu_new();
	
	GtkWidget *menuitem = gtk_image_menu_item_new_with_mnemonic(_("Вкл./Выкл. Xneur"));

	GtkWidget *image = gtk_image_new_from_stock("gtk-refresh", GTK_ICON_SIZE_MENU);
	gtk_widget_set_name(image, "image");
	gtk_widget_show(image);
	gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menuitem), image);

	gtk_widget_show(menuitem);
	gtk_container_add(GTK_CONTAINER(menu), menuitem);
	g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(xneur_start_stop), tray);
	
	menuitem = gtk_image_menu_item_new_from_stock("gtk-preferences", NULL);
	gtk_widget_show(menuitem);
	gtk_container_add(GTK_CONTAINER(menu), menuitem);
	g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(xneur_preference), tray);
	
	menuitem = gtk_separator_menu_item_new();
	gtk_widget_show(menuitem);
	gtk_container_add(GTK_CONTAINER(menu), menuitem);
	gtk_widget_set_sensitive(menuitem, FALSE);
	
	menuitem = gtk_image_menu_item_new_from_stock("gtk-about", NULL);
	gtk_widget_show(menuitem);
	gtk_container_add(GTK_CONTAINER(menu), menuitem);
	g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(xneur_about), tray);	

	menuitem = gtk_image_menu_item_new_from_stock("gtk-quit", NULL);
	gtk_widget_show(menuitem);
	gtk_container_add(GTK_CONTAINER(menu), menuitem);
	g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(xneur_exit), tray);

 	return menu;
}
Пример #15
0
static void indicator_fitbit_init(IndicatorFitbit *self)
{
    GtkWidget *sep;

    self->priv = INDICATOR_FITBIT_GET_PRIVATE(self);

    /* zero-initialize everything */
    memset(self->priv, 0, sizeof(IndicatorFitbitPrivate));

    self->priv->accessible_desc = _("Fitbit");
    self->priv->menu = GTK_MENU(gtk_menu_new());

    /* create separator */
    sep = gtk_separator_menu_item_new();
    gtk_menu_shell_append(GTK_MENU_SHELL(self->priv->menu), sep);
    gtk_widget_show(sep);

    /* create the account setup menuitem */
    self->priv->account_item_label = gtk_label_new(NULL);
    gtk_misc_set_alignment(GTK_MISC(self->priv->account_item_label), 0, 0);
    gtk_label_set_use_markup(GTK_LABEL(self->priv->account_item_label), TRUE);
    gtk_label_set_markup(GTK_LABEL(self->priv->account_item_label), _("Account Setup"));
    gtk_widget_show(self->priv->account_item_label);

    self->priv->account_item = gtk_menu_item_new();
    g_signal_connect(self->priv->account_item, "activate", G_CALLBACK(account_item_activated_cb), self);
    gtk_container_add(GTK_CONTAINER(self->priv->account_item), self->priv->account_item_label);
    gtk_widget_show(self->priv->account_item);

    gtk_menu_shell_append(GTK_MENU_SHELL(self->priv->menu), self->priv->account_item);

    /* find trackers */
    refresh_trackers(self);

    /* stay up to date */
    fitbitd_watch_changes(trackers_change_cb, self);
}
static void
mateconf_bookmarks_update_menu (GtkWidget *menu)
{
	GSList *list, *tmp;
	GtkWidget *menuitem, *window;
	MateConfClient *client;

	window = g_object_get_data (G_OBJECT (menu), "editor-window");
	client = mateconf_client_get_default ();
	
	/* Get the old list and then set it */
	list = mateconf_client_get_list (client,
				     "/apps/mateconf-editor/bookmarks", MATECONF_VALUE_STRING, NULL);

	if (list != NULL) {
		menuitem = gtk_separator_menu_item_new ();
		gtk_widget_show (menuitem);
		gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
	}

	for (tmp = list; tmp; tmp = tmp->next) {
		menuitem = gtk_image_menu_item_new_with_label (tmp->data);
		g_signal_connect (menuitem, "activate",
				  G_CALLBACK (mateconf_bookmarks_bookmark_activated), window);
		g_object_set_data_full (G_OBJECT (menuitem), "mateconf-key", g_strdup (tmp->data), g_free);
		gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), gtk_image_new_from_stock (STOCK_BOOKMARK,
													 GTK_ICON_SIZE_MENU));
		gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
		gtk_widget_show_all (menuitem);

		g_free (tmp->data);
	}

	g_object_unref (client);
	g_slist_free (list);
}
Пример #17
0
static void
populate_popup_cb (G_GNUC_UNUSED GtkWidget *text_view, GtkMenu *menu, EntryProperties *eprop)
{
	GtkTextIter iter;
	gtk_text_view_get_iter_at_position (eprop->priv->view, &iter, NULL,
					    eprop->priv->bx, eprop->priv->by);

	GSList *tags = NULL, *tagp = NULL;
	
	tags = gtk_text_iter_get_tags (&iter);
	for (tagp = tags;  tagp != NULL;  tagp = tagp->next) {
		GtkTextTag *tag = tagp->data;
		GValue *binvalue;
		
		binvalue = g_object_get_data (G_OBJECT (tag), "binvalue");
		if (binvalue) {
			GtkWidget *item;

			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_label (_("Save"));
			gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item);
			g_signal_connect (G_OBJECT (item), "activate",
					  G_CALLBACK (data_save_cb), eprop);
			g_object_set_data (G_OBJECT (item), "binvalue", binvalue);
			gtk_widget_show (item);

			break;
		}
        }

	if (tags) 
		g_slist_free (tags);
}
Пример #18
0
Файл: fbxkb.c Проект: kba/fbxkb
static void
menu_create()
{
    int i;
    GtkWidget *mi, *img;
    
    ENTER;
    menu = gtk_menu_new();
    /* flags */
    for (i = 0; i < ngroups; i++) {
        mi = gtk_image_menu_item_new_with_label(group[i].name);
        g_signal_connect(G_OBJECT(mi), "activate",
                (GCallback)menu_activated, GINT_TO_POINTER(i));
        gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);
        gtk_widget_show(mi);
        img = gtk_image_new_from_pixbuf(group[i].flag);
        gtk_widget_show(img);
        gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(mi), img);
    }
    /* separator */
    mi = gtk_separator_menu_item_new();
    gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);
    gtk_widget_show(mi);
    /* about */
    mi = gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT, NULL);
    g_signal_connect(G_OBJECT(mi), "activate", (GCallback)menu_about, NULL);
    gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
    gtk_widget_show (mi);
    /* exit */
    mi = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, NULL);
    g_signal_connect(G_OBJECT(mi), "activate", (GCallback)menu_exit, NULL);
    gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
    gtk_widget_show (mi);

    RET();
}
Пример #19
0
void on_trayicon_menu (GtkStatusIcon *status_icon,
		       guint          button,
		       guint          activate_time,
		       gpointer       user_data)
{
  GromitData *data = (GromitData *) user_data;
  if(data->debug)
    g_printerr("DEBUG: trayicon menu popup\n");

  /* create the menu */
  GtkWidget *menu = gtk_menu_new ();
  /* Create the menu items */
  //TODO option menu
  GtkWidget* sep_item = gtk_separator_menu_item_new();
  GtkWidget* quit_item = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, NULL);


  /* Add them to the menu */
  gtk_menu_shell_append (GTK_MENU_SHELL (menu), sep_item);
  gtk_menu_shell_append (GTK_MENU_SHELL (menu), quit_item);

  /* Attach the callback functions to the respective activate signal */
  g_signal_connect(G_OBJECT (quit_item), "activate",
		   G_CALLBACK (gtk_main_quit),
		   NULL);


  /* We do need to show menu items */
  gtk_widget_show (sep_item);
  gtk_widget_show (quit_item);


  /* show menu */
  gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL,
                  0, gtk_get_current_event_time());
}
Пример #20
0
JNIEXPORT jlong JNICALL
Java_org_gnome_gtk_GtkSeparatorMenuItem_gtk_1separator_1menu_1item_1new
(
	JNIEnv* env,
	jclass cls
)
{
	GtkWidget* result;
	jlong _result;

	// call function
	result = gtk_separator_menu_item_new();

	// translate return value to JNI type
	_result = (jlong) result;

	// cleanup return value
	if (result != NULL) {
		bindings_java_memory_cleanup((GObject*)result, TRUE);
	}

	// and finally
	return _result;
}
Пример #21
0
static void menu_tree_changed(GMenuTree *tree, gpointer user_data) 
{
    GMenuTreeDirectory *root = NULL;
    GtkWidget *menuitem = NULL;

    popup = gtk_menu_new();

    gmenu_tree_load_sync(tree, NULL);

    root = gmenu_tree_get_root_directory(tree);
    if (root) {
        traverse_directory(root, NULL);
        gmenu_tree_item_unref(root);
        root = NULL;
    }

    gtk_menu_shell_append(GTK_MENU_SHELL(popup), gtk_separator_menu_item_new());

    menuitem = menu_item_new_with_icon_name_text("logout", _("Logout"));
    gtk_menu_shell_append(GTK_MENU_SHELL(popup), menuitem);
    g_object_connect(G_OBJECT(menuitem), 
        "signal::activate", G_CALLBACK(logout), NULL, 
        NULL);
}
Пример #22
0
void
create_tray_menu (GtkWidget *app)
{
	GtkWidget *menuitem;
	GList *node;
	int index;
	
	node = settings.presets;
	tray_menu = gtk_menu_new();

	for (index = 0; node; index++, node = node->next) {
		preset *ps;

		ps = (preset *) node->data;
		menuitem = gtk_menu_item_new_with_label (ps->title);
		
		gtk_menu_shell_insert (GTK_MENU_SHELL (tray_menu), menuitem, index);
		
		g_signal_connect (menuitem,
                                  "activate",
                                  G_CALLBACK(preset_menuitem_activate_cb),
                                  GINT_TO_POINTER (index));

		gtk_widget_show (menuitem);
	}
	
	gtk_menu_shell_append (GTK_MENU_SHELL (tray_menu),
                               gtk_separator_menu_item_new ());

	mute_menuitem = gtk_check_menu_item_new_with_label (_("Muted"));
	gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mute_menuitem),
                                        mixer->get_volume() == 0);
	gtk_menu_shell_append (GTK_MENU_SHELL (tray_menu), mute_menuitem);

	mute_menuitem_toggled_cb_id = g_signal_connect (mute_menuitem,
                                                        "toggled",
                                                        G_CALLBACK (mute_menuitem_toggled_cb),
                                                        (gpointer) app);
	gtk_widget_show (mute_menuitem);

	menuitem = gtk_menu_item_new_with_mnemonic (_("_Record"));
	gtk_menu_shell_append (GTK_MENU_SHELL(tray_menu), menuitem);
	g_signal_connect (menuitem,
                          "activate",
                          G_CALLBACK(record_menuitem_activate_cb),
                          app);
	gtk_widget_show (menuitem);

	gtk_menu_shell_append (GTK_MENU_SHELL (tray_menu),
                               gtk_separator_menu_item_new ());
	
	showwindow_menuitem = gtk_check_menu_item_new_with_label (_("Show Window"));
	gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (showwindow_menuitem),
                                        TRUE);
	gtk_menu_shell_append (GTK_MENU_SHELL (tray_menu), showwindow_menuitem);
	g_signal_connect (showwindow_menuitem,
                          "activate",
                          G_CALLBACK (showwindow_menuitem_toggled_cb),
                          (gpointer) app);
	gtk_widget_show(showwindow_menuitem);

	menuitem = gtk_menu_item_new_with_mnemonic (_("_Quit"));
	gtk_menu_shell_append (GTK_MENU_SHELL (tray_menu), menuitem);
	g_signal_connect (menuitem,
                          "activate",
                          G_CALLBACK(quit_menuitem_activate_cb),
                          NULL);
	gtk_widget_show (menuitem);

	gtk_widget_show_all (tray_menu);
}
Пример #23
0
void
greeter_system_append_system_menu (GtkWidget *menu)
{
	GtkWidget *w, *sep;
	gint i = 0;

	/* should never be allowed by the UI */
	if ( ! mdm_config_get_bool (MDM_KEY_SYSTEM_MENU) ||
	    ve_string_empty (g_getenv ("MDM_IS_LOCAL")))
		return;	

	/*
	 * Disable Configuration if using accessibility (AddGtkModules) since
	 * using it with accessibility causes a hang.
	 */
	if (mdm_config_get_bool (MDM_KEY_CONFIG_AVAILABLE) &&
	    !mdm_config_get_bool (MDM_KEY_ADD_GTK_MODULES) &&
	    bin_exists (mdm_config_get_string (MDM_KEY_CONFIGURATOR))) {
		w = gtk_image_menu_item_new_with_mnemonic (_("Confi_gure Login Manager..."));
		gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (w),
			gtk_image_new_from_icon_name ("mdmsetup", GTK_ICON_SIZE_MENU));

		gtk_menu_shell_append (GTK_MENU_SHELL (menu), w);
		gtk_widget_show (GTK_WIDGET (w));
		g_signal_connect (G_OBJECT (w), "activate",
				  G_CALLBACK (greeter_config_handler),
				  NULL);
	}

	if (MdmRebootFound || MdmHaltFound || MdmSuspendFound) {
		sep = gtk_separator_menu_item_new ();
		gtk_menu_shell_append (GTK_MENU_SHELL (menu), sep);
		gtk_widget_show (sep);
	}

	if (MdmRebootFound && mdm_common_is_action_available ("REBOOT")) {
 		w = gtk_image_menu_item_new_with_mnemonic (_("_Restart"));
 		gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (w),
 					       gtk_image_new_from_icon_name ("system-restart", GTK_ICON_SIZE_MENU));
		gtk_menu_shell_append (GTK_MENU_SHELL (menu), w);
		gtk_widget_show (GTK_WIDGET (w));
		g_signal_connect (G_OBJECT (w), "activate",
				  G_CALLBACK (query_greeter_restart_handler),
				  NULL);
	}

	if (MdmHaltFound && mdm_common_is_action_available ("HALT")) {
 		w = gtk_image_menu_item_new_with_mnemonic (_("Shut _Down"));
 		gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (w), 
 					       gtk_image_new_from_icon_name ("system-shut-down", GTK_ICON_SIZE_MENU));
		gtk_menu_shell_append (GTK_MENU_SHELL (menu), w);
		gtk_widget_show (GTK_WIDGET (w));
		g_signal_connect (G_OBJECT (w), "activate",
				  G_CALLBACK (query_greeter_halt_handler),
				  NULL);
	}

	if (MdmSuspendFound && mdm_common_is_action_available ("SUSPEND")) {
 		w = gtk_image_menu_item_new_with_mnemonic (_("Sus_pend"));
 		gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (w),
 					       gtk_image_new_from_icon_name ("system-suspend", GTK_ICON_SIZE_MENU));
		gtk_menu_shell_append (GTK_MENU_SHELL (menu), w);
		gtk_widget_show (GTK_WIDGET (w));
		g_signal_connect (G_OBJECT (w), "activate",
				  G_CALLBACK (query_greeter_suspend_handler),
				  NULL);
	}	

}
Пример #24
0
void PopupMenu::show(const IntRect& rect, FrameView* view, int index)
{
    ASSERT(client());

    if (!m_popup) {
        m_popup = GTK_MENU(gtk_menu_new());
#if GLIB_CHECK_VERSION(2,10,0)
        g_object_ref_sink(G_OBJECT(m_popup));
#else
        g_object_ref(G_OBJECT(m_popup));
        gtk_object_sink(GTK_OBJECT(m_popup));
#endif
        g_signal_connect(m_popup, "unmap", G_CALLBACK(menuUnmapped), this);
    } else
        gtk_container_foreach(GTK_CONTAINER(m_popup), reinterpret_cast<GtkCallback>(menuRemoveItem), this);

    int x, y;
    gdk_window_get_origin(GTK_WIDGET(view->containingWindow())->window, &x, &y);
    m_menuPosition = view->contentsToWindow(rect.location());
    m_menuPosition = IntPoint(m_menuPosition.x() + x, m_menuPosition.y() + y + rect.height());
    m_indexMap.clear();

    const int size = client()->listSize();
    for (int i = 0; i < size; ++i) {
        GtkWidget* item;
        if (client()->itemIsSeparator(i))
            item = gtk_separator_menu_item_new();
        else
            item = gtk_menu_item_new_with_label(client()->itemText(i).utf8().data());

        m_indexMap.add(item, i);
        g_signal_connect(item, "activate", G_CALLBACK(menuItemActivated), this);

        // FIXME: Apply the RenderStyle from client()->itemStyle(i)
        gtk_widget_set_sensitive(item, client()->itemIsEnabled(i));
        gtk_menu_shell_append(GTK_MENU_SHELL(m_popup), item);
        gtk_widget_show(item);
    }

    gtk_menu_set_active(m_popup, index);


    // The size calls are directly copied from gtkcombobox.c which is LGPL
    GtkRequisition requisition;
    gtk_widget_set_size_request(GTK_WIDGET(m_popup), -1, -1);
    gtk_widget_size_request(GTK_WIDGET(m_popup), &requisition);
    gtk_widget_set_size_request(GTK_WIDGET(m_popup), MAX(rect.width(), requisition.width), -1);

    GList* children = GTK_MENU_SHELL(m_popup)->children;
    if (size)
        for (int i = 0; i < size; i++) {
            if (i > index)
              break;

            GtkWidget* item = reinterpret_cast<GtkWidget*>(children->data);
            GtkRequisition itemRequisition;
            gtk_widget_get_child_requisition(item, &itemRequisition);
            m_menuPosition.setY(m_menuPosition.y() - itemRequisition.height);

            children = g_list_next(children);
        }
    else
        // Center vertically the empty popup in the combo box area
        m_menuPosition.setY(m_menuPosition.y() - rect.height() / 2);

    gtk_menu_popup(m_popup, NULL, NULL, reinterpret_cast<GtkMenuPositionFunc>(menuPositionFunction), this, 0, gtk_get_current_event_time());
}
Пример #25
0
/*! \brief Translate a resource tree into a menu structure
 *
 *  \param [in] menu    The GHidMainMenu widget to be acted on
 *  \param [in] shall   The base menu shell (a menu bar or popup menu)
 *  \param [in] res     The base of the resource tree
 * */
void
ghid_main_menu_real_add_resource (GHidMainMenu *menu, GtkMenuShell *shell,
                                  const Resource *res)
{
    int i, j;
    const Resource *tmp_res;
    gchar mnemonic = 0;

    for (i = 0; i < res->c; ++i)
    {
        const gchar *accel = NULL;
        char *menu_label;
        const char *res_val;
        const Resource *sub_res = res->v[i].subres;
        GtkAction *action = NULL;

        switch (resource_type (res->v[i]))
        {
        case 101:   /* name, subres: passthrough */
            ghid_main_menu_real_add_resource (menu, shell, sub_res);
            break;
        case   1:   /* no name, subres */
            tmp_res = resource_subres (sub_res, "a");  /* accelerator */
            res_val = resource_value (sub_res, "m");   /* mnemonic */
            if (res_val)
                mnemonic = res_val[0];
            /* The accelerator resource will have two values, like
             *   a={"Ctrl-Q" "Ctrl<Key>q"}
             * The first Gtk ignores. The second needs to be translated. */
            if (tmp_res)
                accel = check_unique_accel
                        (translate_accelerator (tmp_res->v[1].value));

            /* Now look for the first unnamed value (not a subresource) to
             * figure out the name of the menu or the menuitem. */
            res_val = "button";
            for (j = 0; j < sub_res->c; ++j)
                if (resource_type (sub_res->v[j]) == 10)
                {
                    res_val = _(sub_res->v[j].value);
                    break;
                }
            /* Hack '_' in based on mnemonic value */
            if (!mnemonic)
                menu_label = g_strdup (res_val);
            else
            {
                char *post_ = strchr (res_val, mnemonic);
                if (post_ == NULL)
                    menu_label = g_strdup (res_val);
                else
                {
                    GString *tmp = g_string_new ("");
                    g_string_append_len (tmp, res_val, post_ - res_val);
                    g_string_append_c (tmp, '_');
                    g_string_append (tmp, post_);
                    menu_label = g_string_free (tmp, FALSE);
                }
            }
            /* If the subresource we're processing also has unnamed
             * subresources, it's a submenu, not a regular menuitem. */
            if (sub_res->flags & FLAG_S)
            {
                /* SUBMENU */
                GtkWidget *submenu = gtk_menu_new ();
                GtkWidget *item = gtk_menu_item_new_with_mnemonic (menu_label);
                GtkWidget *tearoff = gtk_tearoff_menu_item_new ();

                gtk_menu_shell_append (shell, item);
                gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), submenu);

                /* add tearoff to menu */
                gtk_menu_shell_append (GTK_MENU_SHELL (submenu), tearoff);
                /* recurse on the newly-added submenu */
                ghid_main_menu_real_add_resource (menu,
                                                  GTK_MENU_SHELL (submenu),
                                                  sub_res);
            }
            else
            {
                /* NON-SUBMENU: MENU ITEM */
                const char *checked = resource_value (sub_res, "checked");
                const char *label = resource_value (sub_res, "sensitive");
                const char *tip = resource_value (sub_res, "tip");
                if (checked)
                {
                    /* TOGGLE ITEM */
                    gchar *name = g_strdup_printf ("MainMenuAction%d",
                                                   action_counter++);

                    action = GTK_ACTION (gtk_toggle_action_new (name, menu_label,
                                         tip, NULL));
                    /* checked=foo       is a binary flag (checkbox)
                     * checked=foo,bar   is a flag compared to a value (radio) */
                    gtk_toggle_action_set_draw_as_radio
                    (GTK_TOGGLE_ACTION (action), !!strchr (checked, ','));
                }
                else if (label && strcmp (label, "false") == 0)
                {
                    /* INSENSITIVE ITEM */
                    GtkWidget *item = gtk_menu_item_new_with_label (menu_label);
                    gtk_widget_set_sensitive (item, FALSE);
                    gtk_menu_shell_append (shell, item);
                }
                else
                {
                    /* NORMAL ITEM */
                    gchar *name = g_strdup_printf ("MainMenuAction%d", action_counter++);
                    action = gtk_action_new (name, menu_label, tip, NULL);
                }
            }
            /* Connect accelerator, if there is one */
            if (action)
            {
                GtkWidget *item;
                gtk_action_set_accel_group (action, menu->accel_group);
                gtk_action_group_add_action_with_accel (menu->action_group,
                                                        action, accel);
                gtk_action_connect_accelerator (action);
                g_signal_connect (G_OBJECT (action), "activate", menu->action_cb,
                                  (gpointer) sub_res);
                g_object_set_data (G_OBJECT (action), "resource",
                                   (gpointer) sub_res);
                item = gtk_action_create_menu_item (action);
                gtk_menu_shell_append (shell, item);
                menu->actions = g_list_append (menu->actions, action);
                menu->special_key_cb (accel, action, sub_res);
            }
            /* Scan rest of resource in case there is more work */
            for (j = 0; j < sub_res->c; j++)
            {
                const char *res_name;
                /* named value = X resource */
                if (resource_type (sub_res->v[j]) == 110)
                {
                    res_name = sub_res->v[j].name;

                    /* translate bg, fg to background, foreground */
                    if (strcmp (res_name, "fg") == 0)   res_name = "foreground";
                    if (strcmp (res_name, "bg") == 0)   res_name = "background";

                    /* ignore special named values (m, a, sensitive) */
                    if (strcmp (res_name, "m") == 0
                            || strcmp (res_name, "a") == 0
                            || strcmp (res_name, "sensitive") == 0
                            || strcmp (res_name, "tip") == 0)
                        break;

                    /* log checked and active special values */
                    if (action && strcmp (res_name, "checked") == 0)
                        g_object_set_data (G_OBJECT (action), "checked-flag",
                                           sub_res->v[j].value);
                    else if (action && strcmp (res_name, "active") == 0)
                        g_object_set_data (G_OBJECT (action), "active-flag",
                                           sub_res->v[j].value);
                    else
                        /* if we got this far it is supposed to be an X
                         * resource.  For now ignore it and warn the user */
                        Message (_("The gtk gui currently ignores \"%s\""
                                   "as part of a menuitem resource.\n"
                                   "Feel free to provide patches\n"),
                                 sub_res->v[j].value);
                }
            }
            break;
        case  10:   /* no name, value */
            /* If we get here, the resource is "-" or "@foo" for some foo */
            if (res->v[i].value[0] == '@')
            {
                GList *children;
                int pos;

                children = gtk_container_get_children (GTK_CONTAINER (shell));
                pos = g_list_length (children);
                g_list_free (children);

                if (strcmp (res->v[i].value, "@layerview") == 0)
                {
                    menu->layer_view_shell = shell;
                    menu->layer_view_pos = pos;
                }
                else if (strcmp (res->v[i].value, "@layerpick") == 0)
                {
                    menu->layer_pick_shell = shell;
                    menu->layer_pick_pos = pos;
                }
                else if (strcmp (res->v[i].value, "@routestyles") == 0)
                {
                    menu->route_style_shell = shell;
                    menu->route_style_pos = pos;
                }
                else
                    Message (_("GTK GUI currently ignores \"%s\" in the menu\n"
                               "resource file.\n"), res->v[i].value);
            }
            else if (strcmp (res->v[i].value, "-") == 0)
            {
                GtkWidget *item = gtk_separator_menu_item_new ();
                gtk_menu_shell_append (shell, item);
            }
            else if (i > 0)
            {
                /* This is an action-less menuitem. It is really only useful
                 * when you're starting to build a new menu and you're looking
                 * to get the layout right. */
                GtkWidget *item
                    = gtk_menu_item_new_with_label (_(res->v[i].value));
                gtk_menu_shell_append (shell, item);
            }
            break;
        }
    }
}
/**
 * @brief Instance initializer function for the \e GtkExperimentTranscript widget
 *
 * @param klass Newly constructed \e GtkExperimentTranscript instance
 */
static void
gtk_experiment_transcript_init(GtkExperimentTranscript *klass)
{
	GtkWidget *item, *submenu, *image;

	klass->priv = GTK_EXPERIMENT_TRANSCRIPT_GET_PRIVATE(klass);

	klass->speaker = NULL;

	klass->interactive_format.default_font = NULL;
	klass->interactive_format.default_text_color = NULL;
	klass->interactive_format.default_bg_color = NULL;

	klass->priv->flag_mask = 0;

	klass->priv->time_adjustment = gtk_adjustment_new(0., 0., 0.,
							  0., 0., 0.);
	g_object_ref_sink(klass->priv->time_adjustment);
	klass->priv->time_adj_on_value_changed_id =
		g_signal_connect(G_OBJECT(klass->priv->time_adjustment),
				 "value-changed",
				 G_CALLBACK(time_adj_on_value_changed), klass);

	klass->priv->layer_text = NULL;
	klass->priv->layer_text_layout =
		gtk_widget_create_pango_layout(GTK_WIDGET(klass), NULL);
	pango_layout_set_wrap(klass->priv->layer_text_layout, PANGO_WRAP_WORD_CHAR);
	pango_layout_set_ellipsize(klass->priv->layer_text_layout, PANGO_ELLIPSIZE_END);

	klass->priv->backdrop.start = 0;
	klass->priv->backdrop.end = 0;

	klass->priv->contribs = NULL;
	klass->priv->formats = NULL;
	klass->priv->interactive_format.regexp = NULL;
	klass->priv->interactive_format.attribs = NULL;

	/** @todo It should be possible to reset font and colors (to widget defaults) */
	klass->priv->menu = gtk_menu_new();
	gtk_menu_attach_to_widget(GTK_MENU(klass->priv->menu),
				  GTK_WIDGET(klass), NULL);

	item = gtk_image_menu_item_new_with_mnemonic("Choose _Font...");
	image = gtk_image_new_from_stock(GTK_STOCK_SELECT_FONT,
					 GTK_ICON_SIZE_MENU);
	gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
	g_signal_connect(item, "activate",
			 G_CALLBACK(choose_font_activated), klass);
	gtk_menu_shell_append(GTK_MENU_SHELL(klass->priv->menu), item);
	gtk_widget_show(item);

	item = gtk_image_menu_item_new_with_mnemonic("Choose _Text Color...");
	image = gtk_image_new_from_stock(GTK_STOCK_SELECT_COLOR,
					 GTK_ICON_SIZE_MENU);
	gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
	g_signal_connect(item, "activate",
			 G_CALLBACK(choose_text_color_activated), klass);
	gtk_menu_shell_append(GTK_MENU_SHELL(klass->priv->menu), item);
	gtk_widget_show(item);

	item = gtk_image_menu_item_new_with_mnemonic("Choose _Background Color...");
	image = gtk_image_new_from_stock(GTK_STOCK_SELECT_COLOR,
					 GTK_ICON_SIZE_MENU);
	gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
	g_signal_connect(item, "activate",
			 G_CALLBACK(choose_bg_color_activated), klass);
	gtk_menu_shell_append(GTK_MENU_SHELL(klass->priv->menu), item);
	gtk_widget_show(item);

	submenu = gtk_menu_new();
	item = gtk_menu_item_new_with_label("Text Alignment");
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
	gtk_menu_shell_append(GTK_MENU_SHELL(klass->priv->menu), item);
	gtk_widget_show(item);

	/*
	 * position in alignment_group list corresponds with PangoAlignment
	 * (PANGO_ALIGN_RIGHT, PANGO_ALIGN_CENTER, PANGO_ALIGN_LEFT)
	 */
	item = gtk_radio_menu_item_new_with_mnemonic(NULL, "_Left");
	klass->priv->alignment_group =
			gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(item));
	g_signal_connect(item, "activate",
			 G_CALLBACK(text_alignment_activated), klass);
	gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item);

	item = gtk_radio_menu_item_new_with_mnemonic(klass->priv->alignment_group,
						     "_Center");
	klass->priv->alignment_group =
			gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(item));
	g_signal_connect(item, "activate",
			 G_CALLBACK(text_alignment_activated), klass);
	gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item);

	item = gtk_radio_menu_item_new_with_mnemonic(klass->priv->alignment_group,
						     "_Right");
	klass->priv->alignment_group =
			gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(item));
	g_signal_connect(item, "activate",
			 G_CALLBACK(text_alignment_activated), klass);
	gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item);

	gtk_widget_show_all(submenu);
	gtk_experiment_transcript_set_alignment(klass, PANGO_ALIGN_LEFT);

	item = gtk_separator_menu_item_new();
	gtk_menu_shell_append(GTK_MENU_SHELL(klass->priv->menu), item);
	gtk_widget_show(item);

	klass->priv->menu_reverse_item =
			gtk_check_menu_item_new_with_mnemonic("_Reverse");
	g_signal_connect(klass->priv->menu_reverse_item, "activate",
			 G_CALLBACK(reverse_activated), klass);
	gtk_menu_shell_append(GTK_MENU_SHELL(klass->priv->menu),
			      klass->priv->menu_reverse_item);
	gtk_widget_show(klass->priv->menu_reverse_item);

	gtk_widget_set_can_focus(GTK_WIDGET(klass), TRUE);
}
void add_separator_to_menu() {
    GtkWidget *separator = gtk_separator_menu_item_new();
    gtk_menu_append(GTK_MENU_SHELL (menu),separator);
    gtk_widget_show(separator);
}
Пример #28
0
static GtkWidget *
panel_applet_get_menu (AppletInfo *info)
{
	GtkWidget   *menu;
	GList       *l;
	gboolean     added_anything = FALSE;


	/**
	 *  Separator to split the menu
	 *
	 * APPLET ITEMS
	 * -------------
	 * Move
	 * Remove From Panel
	 */
	GtkSeparatorMenuItem	*separator;

	/**
	 * Variables for the edit menu
	 */

	GtkWidget   *menuitem;
	GtkWidget   *image;
	gboolean     movable;
	gboolean     removable;

	if (info->menu)
		return info->menu;

	menu = panel_applet_create_bare_menu (info);

	/**
	 * Moved the panel_applet_get_edit_menu code to here
	 * to recombine the menu as seen in the traditional
	 * Gnome 2 setup
	 */
	movable = panel_applet_can_freely_move (info);
	removable = panel_layout_is_writable ();

	// Hack. We always added something now :P
	added_anything = TRUE;

	for (l = info->user_menu; l; l = l->next) {
		AppletUserMenu *user_menu = l->data;

		if (user_menu->is_enabled_func && !user_menu->is_enabled_func ())
			continue;

		add_to_submenus (info, "", user_menu->name, user_menu, 
				 menu, info->user_menu);

		added_anything = TRUE;
	}

	// Add the separator before we add the move/remove items (less confusion)
	separator =  gtk_separator_menu_item_new ();
	gtk_widget_show (separator);
	gtk_menu_shell_append (GTK_MENU_SHELL(menu), separator);

	menuitem = gtk_menu_item_new_with_mnemonic (_("_Move"));
	g_signal_connect (menuitem, "activate",
			  G_CALLBACK (move_applet_callback), info);
	gtk_widget_show (menuitem);
	gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
	gtk_widget_set_sensitive (menuitem, movable);

	// TODO: Add a seperator

	menuitem = gtk_image_menu_item_new_with_mnemonic (_("_Remove From Panel"));
	image = gtk_image_new_from_stock (GTK_STOCK_REMOVE,
					  GTK_ICON_SIZE_MENU);
	gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem),
				       image);
	g_signal_connect (menuitem, "activate",
			  G_CALLBACK (applet_remove_callback), info);
	gtk_widget_show (menuitem);
	gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
	gtk_widget_set_sensitive (menuitem, removable);

	if ( ! added_anything) {
                g_signal_handlers_disconnect_by_func (menu,
						      G_CALLBACK (applet_menu_show), info);
                g_signal_handlers_disconnect_by_func (menu,
						      G_CALLBACK (applet_menu_deactivate), info);

		g_object_unref (menu);
		return NULL;
	}

	info->menu = menu;

	panel_lockdown_on_notify (panel_lockdown_get (),
				  NULL,
				  G_OBJECT (info->menu),
				  panel_applet_menu_lockdown_changed,
				  info);

	return info->menu;
}
Пример #29
0
static GtkWidget *create_history_menu(GtkWidget *history_menu) {
	GtkWidget *menu_item, *item_label;
	history_menu = gtk_menu_new();
	g_signal_connect((GObject*)history_menu, "key-press-event", (GCallback)menu_key_pressed, NULL);

	/* Items */
	if ((history != NULL) && (history->data != NULL))
	{
		/* Declare some variables */
		GList* element;
		gint element_number = 0;
		gint element_number_small = 0;
		gchar* primary_temp = gtk_clipboard_wait_for_text(primary);
		gchar* clipboard_temp = gtk_clipboard_wait_for_text(clipboard);
		/* Reverse history if enabled */
		if (prefs.reverse_history)
		{
			history = g_list_reverse(history);
			element_number = g_list_length(history) - 1;
		}
		/* Go through each element and adding each */
		for (element = history; (element != NULL) && (element_number_small < prefs.items_menu); element = element->next)
		{
			history_item *elem_data = element->data;
			GString* string = g_string_new((gchar*)elem_data->content);
			/* Ellipsize text */
			string = ellipsize_string(string);
			/* Remove control characters */
			string = remove_newlines_string(string);
			/* Make new item with ellipsized text */
			gchar* list_item;
			if (prefs.show_indexes)
			{
				list_item = g_strdup_printf("%d. %s", (element_number_small+1), string->str);
			} else {
				list_item = g_strdup(string->str);
			}
			menu_item = gtk_menu_item_new_with_label(list_item);
			g_signal_connect((GObject*)menu_item, "activate", (GCallback)item_selected, GINT_TO_POINTER(element_number));

			/* Modify menu item label properties */
			item_label = gtk_bin_get_child((GtkBin*)menu_item);
			gtk_label_set_single_line_mode((GtkLabel*)item_label, prefs.single_line);

			/* Check if item is also clipboard text and make bold */
			if ((clipboard_temp) && (g_strcmp0((gchar*)elem_data->content, clipboard_temp) == 0))
			{
				gchar* bold_text = g_markup_printf_escaped("<b>%s</b>", list_item);
				gtk_label_set_markup((GtkLabel*)item_label, bold_text);
				g_free(bold_text);
			}
			else if ((primary_temp) && (g_strcmp0((gchar*)elem_data->content, primary_temp) == 0))
			{
				gchar* italic_text = g_markup_printf_escaped("<i>%s</i>", list_item);
				gtk_label_set_markup((GtkLabel*)item_label, italic_text);
				g_free(italic_text);
			}
			g_free(list_item);
			/* Append item */
			gtk_menu_shell_append((GtkMenuShell*)history_menu, menu_item);
			/* Prepare for next item */
			g_string_free(string, TRUE);
			if (prefs.reverse_history)
				element_number--;
			else
				element_number++;
				element_number_small++;
		}
		/* Cleanup */
		g_free(primary_temp);
		g_free(clipboard_temp);
		/* Return history to normal if reversed */
		if (prefs.reverse_history)
			history = g_list_reverse(history);
	}
	else
	{
		/* Nothing in history so adding empty */
		menu_item = gtk_menu_item_new_with_label(_("Empty"));
		gtk_widget_set_sensitive(menu_item, FALSE);
		gtk_menu_shell_append((GtkMenuShell*)history_menu, menu_item);
	}
	if (prefs.statics_show) {
		/* -------------------- */
		gtk_menu_shell_append((GtkMenuShell*)history_menu, gtk_separator_menu_item_new());

		/* Items */
		GList *elem = history;
		int elem_num = 0;
		int elem_num_static = 1;
		while (elem && (elem_num_static <= prefs.statics_items)) {
			history_item *hitem = elem->data;
			if (hitem->is_static) {
				GString* string = g_string_new((gchar*)hitem->content);
				/* Ellipsize text */
				string = ellipsize_string(string);
				/* Remove control characters */
				string = remove_newlines_string(string);
				gchar* list_item;
				if (prefs.show_indexes)
				{
					list_item = g_strdup_printf("%d. %s", (elem_num_static), string->str);
				} else {
					list_item = g_strdup(string->str);
				}
				menu_item = gtk_menu_item_new_with_label(list_item);
				g_signal_connect((GObject*)menu_item, "activate", (GCallback)item_selected, GINT_TO_POINTER(elem_num));
				/* Modify menu item label properties */
				item_label = gtk_bin_get_child((GtkBin*)menu_item);
				gtk_label_set_single_line_mode((GtkLabel*)item_label, prefs.single_line);
				g_free(list_item);
				g_string_free(string, TRUE);
				gtk_menu_shell_append((GtkMenuShell*)history_menu, menu_item);
				elem_num_static++;
			}
			elem_num++;
			elem = elem->next;
		}
	}
	/* Show a notice in offline mode */
	if (prefs.offline_mode) {
		gtk_menu_shell_append((GtkMenuShell*)history_menu, gtk_separator_menu_item_new());

		menu_item = gtk_menu_item_new_with_label("");
		item_label = gtk_bin_get_child((GtkBin*)menu_item);
		gtk_label_set_markup((GtkLabel*)item_label, "<b>Offline mode is ON</b>");
		gtk_label_set_single_line_mode((GtkLabel*)item_label, TRUE);
		gtk_widget_set_sensitive(item_label, FALSE);
		gtk_menu_shell_append((GtkMenuShell*)history_menu, menu_item);
	}
	return history_menu;
}
Пример #30
0
/* Called when status icon is control-clicked */
static gboolean show_actions_menu(gpointer data) {
  /* Declare some variables */
  GtkWidget *menu,       *menu_item,
            *menu_image, *item_label;

  /* Create menu */
  menu = gtk_menu_new();
  g_signal_connect((GObject*)menu, "selection-done", (GCallback)gtk_widget_destroy, NULL);
  /* Actions using: */
  menu_item = gtk_image_menu_item_new_with_label(_("Actions using:"));
  menu_image = gtk_image_new_from_stock(GTK_STOCK_EXECUTE, GTK_ICON_SIZE_MENU);
  gtk_image_menu_item_set_image((GtkImageMenuItem*)menu_item, menu_image);
  g_signal_connect((GObject*)menu_item, "select", (GCallback)gtk_menu_item_deselect, NULL);
  gtk_menu_shell_append((GtkMenuShell*)menu, menu_item);
  /* Clipboard contents */
  gchar* text = gtk_clipboard_wait_for_text(clipboard);
  if (text != NULL)
  {
    menu_item = gtk_menu_item_new_with_label(_("None"));
    /* Modify menu item label properties */
    item_label = gtk_bin_get_child((GtkBin*)menu_item);
    gtk_label_set_single_line_mode((GtkLabel*)item_label, TRUE);
    gtk_label_set_ellipsize((GtkLabel*)item_label, prefs.ellipsize);
    gtk_label_set_width_chars((GtkLabel*)item_label, 30);
    /* Making bold... */
    gchar* bold_text = g_markup_printf_escaped("<b>%s</b>", text);
    gtk_label_set_markup((GtkLabel*)item_label, bold_text);
    g_free(bold_text);
    /* Append menu item */
    g_signal_connect((GObject*)menu_item, "select", (GCallback)gtk_menu_item_deselect, NULL);
    gtk_menu_shell_append((GtkMenuShell*)menu, menu_item);
  }
  else
  {
    /* Create menu item for empty clipboard contents */
    menu_item = gtk_menu_item_new_with_label(_("None"));
    /* Modify menu item label properties */
    item_label = gtk_bin_get_child((GtkBin*)menu_item);
    gtk_label_set_markup((GtkLabel*)item_label, _("<b>None</b>"));
    /* Append menu item */
    g_signal_connect((GObject*)menu_item, "select", (GCallback)gtk_menu_item_deselect, NULL);
    
    gtk_menu_shell_append((GtkMenuShell*)menu, menu_item);
  }
  /* -------------------- */
  gtk_menu_shell_append((GtkMenuShell*)menu, gtk_separator_menu_item_new());
  /* Actions */
  gchar* path = g_build_filename(g_get_user_data_dir(), ACTIONS_FILE, NULL);
  FILE* actions_file = fopen(path, "rb");
  g_free(path);
  /* Check that it opened and begin read */
  if (actions_file)
  {
    gint size;
    size_t fread_return;
    fread_return = fread(&size, 4, 1, actions_file);
    /* Check if actions file is empty */
    if (!size)
    {
      /* File contained no actions so adding empty */
      menu_item = gtk_menu_item_new_with_label(_("Empty"));
      gtk_widget_set_sensitive(menu_item, FALSE);
      gtk_menu_shell_append((GtkMenuShell*)menu, menu_item);
    }
    /* Continue reading items until size is 0 */
    while (size)
    {
      /* Read name */
      gchar* name = (gchar*)g_malloc(size + 1);
      fread_return = fread(name, size, 1, actions_file);
      name[size] = '\0';
      menu_item = gtk_menu_item_new_with_label(name);
      g_free(name);
      fread_return = fread(&size, 4, 1, actions_file);
      /* Read command */
      gchar* command = (gchar*)g_malloc(size + 1);
      fread_return = fread(command, size, 1, actions_file);
      command[size] = '\0';
      fread_return = fread(&size, 4, 1, actions_file);
      /* Append the action */
      gtk_menu_shell_append((GtkMenuShell*)menu, menu_item);
      g_signal_connect((GObject*)menu_item,        "activate",
                       (GCallback)action_selected, (gpointer)command);      
    }
    fclose(actions_file);
  }
  else
  {
    /* File did not open so adding empty */
    menu_item = gtk_menu_item_new_with_label(_("Empty"));
    gtk_widget_set_sensitive(menu_item, FALSE);
    gtk_menu_shell_append((GtkMenuShell*)menu, menu_item);
  }
  /* -------------------- */
  gtk_menu_shell_append((GtkMenuShell*)menu, gtk_separator_menu_item_new());
  /* Edit actions */
  menu_item = gtk_image_menu_item_new_with_mnemonic(_("_Edit actions"));
  menu_image = gtk_image_new_from_stock(GTK_STOCK_EDIT, GTK_ICON_SIZE_MENU);
  gtk_image_menu_item_set_image((GtkImageMenuItem*)menu_item, menu_image);
  g_signal_connect((GObject*)menu_item, "activate", (GCallback)edit_actions_selected, NULL);
  gtk_menu_shell_append((GtkMenuShell*)menu, menu_item);
  /* Popup the menu... */
  gtk_widget_show_all(menu);
  gtk_menu_popup((GtkMenu*)menu, NULL, NULL, NULL, NULL, 1, gtk_get_current_event_time());
  /* Return false so the g_timeout_add() function is called only once */
  return FALSE;
}