Beispiel #1
0
static void
seach_entry_populate_popup (GtkEntry *entry, PraghaPreferences *preferences)
{
	GtkWidget *popup_menu, *item;
	gboolean instant_search, approximate_search;

	popup_menu = gtk_menu_new ();

	/* Instant search. */

	item = gtk_check_menu_item_new_with_label (_("Refine the search while writing"));
	gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), item);

	instant_search = pragha_preferences_get_instant_search(preferences);
	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), instant_search);
	g_signal_connect (G_OBJECT (item), "toggled",
				G_CALLBACK (search_entry_instant_option_toggled), preferences);
	gtk_widget_show (item);

	/* Aproximate search. */

	item = gtk_check_menu_item_new_with_label (_("Search approximate words"));
	gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), item);

	approximate_search = pragha_preferences_get_approximate_search(preferences);
	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), approximate_search);
	g_signal_connect (G_OBJECT (item), "toggled",
				G_CALLBACK (search_entry_approximate_option_toggled), preferences);
	gtk_widget_show (item);

	gtk_menu_attach_to_widget(GTK_MENU(popup_menu), GTK_WIDGET(entry), NULL);

	gtk_menu_popup(GTK_MENU(popup_menu), NULL, NULL,
			(GtkMenuPositionFunc) menu_position, entry,
			0, gtk_get_current_event_time());
}
Beispiel #2
0
static void _e2_option_sel_activated_cb (GtkMenuItem *menu_item, E2_OptionSet *set)
{
	GtkWidget *controller = g_object_get_data (G_OBJECT (menu_item),
		"e2-controller-widget");
	if (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (controller),
		"e2-controller-blocked")))
			return;
	if (!gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (menu_item)))
		return;
//	NEEDCLOSEBGL
	GSList *group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (menu_item));
//	NEEDOPENBGL
	gint index = 2 - g_slist_index (group, menu_item);
	e2_option_sel_set_direct (set, index);
}
Beispiel #3
0
static void
add_popup_menu_items (GtkWidget      *menu,
                      GeditViewFrame *frame)
{
	GtkWidget *menu_item;

	/* create "Wrap Around" menu item. */
	menu_item = gtk_check_menu_item_new_with_mnemonic (_("_Wrap Around"));
	g_signal_connect (G_OBJECT (menu_item), "toggled",
			  G_CALLBACK (wrap_around_menu_item_toggled),
			  frame);
	gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item);
	gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item),
					frame->priv->wrap_around);
	gtk_widget_show (menu_item);

	/* create "Match Entire Word Only" menu item. */
	menu_item = gtk_check_menu_item_new_with_mnemonic (_("Match _Entire Word Only"));
	g_signal_connect (G_OBJECT (menu_item), "toggled",
			  G_CALLBACK (match_entire_word_menu_item_toggled),
			  frame);
	gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item);
	gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item),
					GEDIT_SEARCH_IS_ENTIRE_WORD (frame->priv->search_flags));
	gtk_widget_show (menu_item);

	/* create "Match Case" menu item. */
	menu_item = gtk_check_menu_item_new_with_mnemonic (_("_Match Case"));
	g_signal_connect (G_OBJECT (menu_item), "toggled",
			  G_CALLBACK (match_case_menu_item_toggled),
			  frame);
	gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item);
	gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item),
					GEDIT_SEARCH_IS_CASE_SENSITIVE (frame->priv->search_flags));
	gtk_widget_show (menu_item);
}
Beispiel #4
0
static void
activate_cb(GtkWidget *w, JamDoc *doc) {
	const gchar *user;
	JamAccount *acc = jam_doc_get_account(doc);

	if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(w)))
		return;

	user = gtk_label_get_text(GTK_LABEL(GTK_BIN(w)->child));

	if (g_ascii_strcasecmp(user, jam_account_get_username(acc)) == 0)
		user = NULL; /* post as normal user. */

	jam_doc_set_usejournal(doc, user);
}
Beispiel #5
0
void toggle_chat_window(gpointer data, guint action, GtkWidget * w)
{
	ChatWidgets *list;

	for (list = chats; list; list = list->next) {
		if (!list->container)
			continue;

		if (GTK_CHECK_MENU_ITEM(w)->active) {
			gtk_widget_show(list->container);
		} else {
			gtk_widget_hide(list->container);
		}
	}
}
Beispiel #6
0
static GtkWidget *build_port_menu(void)
{
	gint i;
	GtkWidget *item;
	GdkPixmap *pixmap;
	GtkWidget *image;
	GtkWidget *menu;
	MapTheme *theme = theme_get_current();

	menu = gtk_menu_new();

	for (i = 0; i <= ANY_RESOURCE; i++) {
		item =
		    gtk_image_menu_item_new_with_mnemonic(gettext
							  (port_names[i]));

		gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
		g_signal_connect(G_OBJECT(item), "activate",
				 G_CALLBACK(select_port_resource_cb),
				 GINT_TO_POINTER(i));

		pixmap = theme->port_tiles[i];
		if (i >= NO_RESOURCE || pixmap == NULL)
			continue;

		image = gtk_image_new_from_pixmap(pixmap, NULL);
		gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item),
					      image);
	}
	gtk_menu_shell_append(GTK_MENU_SHELL(menu),
			      gtk_separator_menu_item_new());
	for (i = 0; i < 6; i++) {
		item =
		    gtk_check_menu_item_new_with_label(Q_
						       (port_direction_names
							[i]));
		gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM
						      (item), TRUE);
		gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
		g_signal_connect(G_OBJECT(item), "toggled",
				 G_CALLBACK(select_port_direction_cb),
				 GINT_TO_POINTER(i));
		port_directions[i] = item;
	}
	gtk_widget_show_all(menu);

	return menu;
}
Beispiel #7
0
/* Create and show the popup menu */
static void show_popup_menu(TilemDisasmView *dv, GdkEventButton *event)
{
	GtkWidget *menu, *item;
	dword curpos;

	if (dv->popup_menu)
		gtk_widget_destroy(dv->popup_menu);
	dv->popup_menu = menu = gtk_menu_new();

	/* Enable/disable breakpoint */

	item = gtk_check_menu_item_new_with_mnemonic(_("_Breakpoint Here"));

	get_cursor_line(dv, &curpos, NULL);
	if (curpos == (dword) -1)
		gtk_widget_set_sensitive(item, FALSE);
	else if (find_line_bp(dv, curpos))
		gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);

	g_signal_connect(item, "toggled",
	                 G_CALLBACK(toggle_bp), dv);

	gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
	gtk_widget_show(item);

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

	/* Jump to address */

	item = gtk_menu_item_new_with_mnemonic(_("_Go to Address..."));
	g_signal_connect(item, "activate", G_CALLBACK(prompt_go_to), dv);
	gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
	gtk_widget_show(item);

	item = gtk_menu_item_new_with_mnemonic(_("Go to P_C"));
	g_signal_connect(item, "activate", G_CALLBACK(go_to_pc), dv);
	gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
	gtk_widget_show(item);

	if (event)
		gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL,
		               event->button, event->time);
	else
		gtk_menu_popup(GTK_MENU(menu), NULL, NULL, &place_menu, dv,
		               0, gtk_get_current_event_time());
}
static void check_rotation_menu_item(struct screen_info *info,
        xcb_randr_rotation_t rotation, gboolean is_active)
{
    GtkWidget *item = info->rotation_menu_items[rotation];

    if (!item) {
        g_warning("Unknown rotation item\n");
        return;
    }

    g_signal_handlers_block_by_func(G_OBJECT(item), G_CALLBACK(menu_on_item),
            (gpointer)info);
    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), is_active);
    g_signal_handlers_unblock_by_func(G_OBJECT(item), G_CALLBACK(menu_on_item),
            (gpointer)info);
}
Beispiel #9
0
void      explorer_force_pause           (Explorer *self)
{
    /* Force rendering to pause now, but keep note of its original state
     * so that explorer_restore_pause() can undo this as necessary.
     */
    GtkCheckMenuItem *paused = GTK_CHECK_MENU_ITEM(glade_xml_get_widget(self->xml, "pause_menu"));
    gboolean original_state = gtk_check_menu_item_get_active(paused);
    gtk_check_menu_item_set_active(paused, TRUE);

    /* Now, on_pause_rendering_toggle just disabled unpause_on_restore since
     * typically only a user changes the pause_menu state. We want to turn
     * that back on if we just paused it and originally it was unpaused,
     * so that explorer_restore_pause() does the Right Thing (tm).
     */
    self->unpause_on_restore = !original_state;
}
Beispiel #10
0
void
gnc_split_reg2_double_line_cb (GtkWidget *w, gpointer data)
{
    GNCSplitReg2 *gsr = data;
    GncTreeModelSplitReg *model = gnc_ledger_display2_get_split_model_register (gsr->ledger);
    gboolean use_double_line;

    use_double_line = gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (w));
    if (use_double_line == model->use_double_line)
        return;

    gnc_tree_model_split_reg_config (model, model->type, model->style, use_double_line);

    // This will re-display the view.
    gnc_tree_view_split_reg_set_format (gnc_ledger_display2_get_split_view_register (gsr->ledger));
}
Beispiel #11
0
void on_show_range1_activate(GtkMenuItem * menuitem, gpointer user_data)
{
	GtkTreeViewColumn *col;

	show_range = GTK_CHECK_MENU_ITEM(menuitem)->active;
	col = gtk_tree_view_get_column(GTK_TREE_VIEW(tree2_w), COL_NO);
	if (col)
		gtk_tree_view_column_set_visible(col, show_range);
	col = gtk_tree_view_get_column(GTK_TREE_VIEW(tree2_w), COL_MOD);
	if (col)
		gtk_tree_view_column_set_visible(col, show_range);
	col = gtk_tree_view_get_column(GTK_TREE_VIEW(tree2_w), COL_YES);
	if (col)
		gtk_tree_view_column_set_visible(col, show_range);

}
Beispiel #12
0
G_MODULE_EXPORT gboolean
on_winMain_delete_event(void)
{
	/* return false to allow destroy */
	if(
#ifdef CFG_USE_RADIO
			gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(chkTray))
#else
			gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(chkTray))
#endif
			){
		tray_toggle();
		return TRUE;
	}
	return FALSE;
}
Beispiel #13
0
int main(int argc,char *argv[])
{
    GtkWidget *window;
    GtkWidget *vbox;

    GtkWidget *menubar;
    GtkWidget *viewmenu;
    GtkWidget *view;
    GtkWidget *tog_stat;
    GtkWidget *statusbar;

    gtk_init(&argc,&argv);

    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER);
    gtk_window_set_default_size(GTK_WINDOW(window),250,200);
    gtk_window_set_title(GTK_WINDOW(window),"view statusbar");

    vbox = gtk_vbox_new(FALSE,0);
    gtk_container_add(GTK_CONTAINER(window),vbox);

    menubar = gtk_menu_bar_new();
    viewmenu = gtk_menu_new();

    view = gtk_menu_item_new_with_label("View");
    tog_stat = gtk_check_menu_item_new_with_label("View Statusbar");
    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(tog_stat),TRUE);

    gtk_menu_item_set_submenu(GTK_MENU_ITEM(view),viewmenu);
    gtk_menu_shell_append(GTK_MENU_SHELL(viewmenu),tog_stat);
    gtk_menu_shell_append(GTK_MENU_SHELL(menubar),view);

    gtk_box_pack_start(GTK_BOX(vbox),menubar,FALSE,FALSE,3);

    statusbar = gtk_statusbar_new();
    gtk_box_pack_end(GTK_BOX(vbox),statusbar,FALSE,TRUE,1);

    g_signal_connect_swapped(G_OBJECT(window),"destroy",G_CALLBACK(gtk_main_quit),NULL);

    g_signal_connect(G_OBJECT(tog_stat),"activate",G_CALLBACK(toggle_statusbar),statusbar);

    gtk_widget_show_all(window);

    gtk_main();

    return 0;
}
static
GtkWidget *
convert_menu(const struct PP_Flash_Menu *pp_menu)
{
    GtkWidget *menu = gtk_menu_new();

    for (uintptr_t k = 0; k < pp_menu->count; k ++) {
        const struct PP_Flash_MenuItem pp_mi = pp_menu->items[k];
        GtkWidget *mi = NULL;

        switch (pp_mi.type) {
        case PP_FLASH_MENUITEM_TYPE_NORMAL:
            mi = gtk_menu_item_new_with_label(pp_mi.name);
            break;
        case PP_FLASH_MENUITEM_TYPE_CHECKBOX:
            mi = gtk_check_menu_item_new_with_label(pp_mi.name);
            gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mi), pp_mi.checked != PP_FALSE);
            break;
        case PP_FLASH_MENUITEM_TYPE_SEPARATOR:
            mi = gtk_separator_menu_item_new();
            break;
        case PP_FLASH_MENUITEM_TYPE_SUBMENU:
            mi = gtk_menu_item_new_with_label(pp_mi.name);
            break;
        }

        if (!mi)
            continue;

        gtk_widget_set_sensitive(mi, pp_mi.enabled != PP_FALSE);
        gtk_widget_show(mi);
        gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);

        if (pp_mi.type == PP_FLASH_MENUITEM_TYPE_SUBMENU) {
            gtk_menu_item_set_submenu(GTK_MENU_ITEM(mi), convert_menu(pp_mi.submenu));
        } else {
            // each menu item have specific id associated
            g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menu_item_activated),
                             (void*)(size_t)pp_mi.id);
            // connect "button-press-event" to workaround submenu "activate" signal missing issue
            g_signal_connect(G_OBJECT(mi), "button-press-event", G_CALLBACK(menu_item_button_press),
                             (void*)(size_t)pp_mi.id);
        }
    }

    return menu;
}
Beispiel #15
0
void termit_on_switch_page(GtkNotebook *notebook, gpointer arg, guint page, gpointer user_data)
{
    TERMIT_GET_TAB_BY_INDEX(pTab, page);
    TRACE("%s page=%d vte=%p", __FUNCTION__, page, pTab->vte);
    // it seems that set_active eventually calls toggle callback
    /*((GtkCheckMenuItem*)termit.mi_show_scrollbar)->active = pTab->scrollbar_is_shown;*/
    gpointer pHandlerId = g_object_get_data(G_OBJECT(termit.mi_show_scrollbar), "handlerId");
    if (pHandlerId) {
        g_signal_handler_disconnect(G_OBJECT(termit.mi_show_scrollbar), *((gulong*)pHandlerId));
    }
    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(termit.mi_show_scrollbar), pTab->scrollbar_is_shown);
    termit_set_show_scrollbar_signal(termit.mi_show_scrollbar, pHandlerId);

    termit_set_statusbar_message(page);
    if (configs.allow_changing_title)
        termit_set_window_title(pTab->title);
}
Beispiel #16
0
static void on_widget_toggle(GtkWidget *widget, Explorer* self)
{
    /* Toggle visibility of another widget. This widget should be named
     * toggle_foo to control the visibility of a widget named foo.
     */
    const gchar *name;
    GtkWidget *toggled;

    name = gtk_widget_get_name(widget);
    g_assert(!strncmp((void *) name, "toggle_", 7));
    toggled = glade_xml_get_widget(self->xml, name+7);

    if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget)))
	gtk_widget_show(toggled);
    else
	gtk_widget_hide(toggled);
}
Beispiel #17
0
void
on_toggle_status_bar_activate          (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
    GtkWidget *sb = lookup_widget (mainwin, "statusbar");
    if (sb) {
        if (!gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (menuitem))) {
            deadbeef->conf_set_int ("gtkui.statusbar.visible", 0);
            gtk_widget_hide (sb);
        }
        else {
            deadbeef->conf_set_int ("gtkui.statusbar.visible", 1);
            gtk_widget_show (sb);
        }
    }
    deadbeef->sendmessage (DB_EV_CONFIGCHANGED, 0, 0, 0);
}
Beispiel #18
0
static void dev_menuitem_toggled(GtkMenuItem *item, GtkComboBox *combo)
{
	GtkTreeModel *model = gtk_combo_box_get_model(combo);
	GtkTreeIter iter;

	if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(item)))
		return;
	
	if (gtk_tree_model_get_iter_first(model, &iter)) do {
		gchar *name;
		gtk_tree_model_get(model, &iter, 0, &name, -1);
		if (g_str_equal(name, gtk_menu_item_get_label(item))) {
			gtk_combo_box_set_active_iter(combo, &iter);
			return;
		}
	} while (gtk_tree_model_iter_next(model, &iter));
}
Beispiel #19
0
static void
gtk_check_menu_item_activate (GtkMenuItem *menu_item)
{
  GtkCheckMenuItemPrivate *priv;

  GtkCheckMenuItem *check_menu_item = GTK_CHECK_MENU_ITEM (menu_item);
  priv = check_menu_item->priv;

  priv->active = !priv->active;

  gtk_check_menu_item_toggled (check_menu_item);
  gtk_widget_queue_draw (GTK_WIDGET (check_menu_item));

  GTK_MENU_ITEM_CLASS (gtk_check_menu_item_parent_class)->activate (menu_item);

  g_object_notify (G_OBJECT (check_menu_item), "active");
}
Beispiel #20
0
static void
remmina_icon_populate_additional_menu_item (GtkWidget *menu)
{
    GtkWidget *menuitem;

    menuitem = gtk_image_menu_item_new_with_label (_("Open Main Window"));
    gtk_widget_show (menuitem);
    gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem),
        gtk_image_new_from_icon_name ("remmina", GTK_ICON_SIZE_MENU));
    gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
    g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK (remmina_icon_main), NULL);

    menuitem = gtk_image_menu_item_new_from_stock (GTK_STOCK_PREFERENCES, NULL);
    gtk_widget_show (menuitem);
    gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
    g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK (remmina_icon_preferences), NULL);

    menuitem = gtk_image_menu_item_new_from_stock (GTK_STOCK_ABOUT, NULL);
    gtk_widget_show (menuitem);
    gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
    g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK (remmina_icon_about), NULL);

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

#ifdef HAVE_LIBAVAHI_CLIENT
    menuitem = gtk_check_menu_item_new_with_label (_("Enable Service Discovery"));
    if (remmina_pref.applet_enable_avahi)
    {
        gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menuitem), TRUE);
    }
    gtk_widget_show (menuitem);
    g_signal_connect (G_OBJECT (menuitem), "toggled", G_CALLBACK (remmina_icon_enable_avahi), NULL);
    gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
#endif

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

    menuitem = gtk_image_menu_item_new_from_stock (GTK_STOCK_QUIT, NULL);
    gtk_widget_show (menuitem);
    gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
    g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK (remmina_icon_destroy), NULL);
}
Beispiel #21
0
static void menu_setting_foreach(void (*callback) (window_t *), int id, guint state) {
	int maindone = FALSE;	/* do it only once for EVERY tab */
	window_t *w;

	for (w = windows; w; w = w->next) {
		gtk_window_ui_t *gui = gtk_private_ui(w);

		if (!gui->is_tab || !maindone) {
			if (gui->is_tab)
				maindone = TRUE;
			if (id != -1)
				GTK_CHECK_MENU_ITEM(gui->menu_item[id])->active = state;
			if (callback)
				callback(w);
		}
	}
}
Beispiel #22
0
int main(int argc, char *argv[])
{
  QwertickleGUI* gui = g_new0(QwertickleGUI, 1);

  gst_init(NULL, NULL);
  gtk_init(&argc, &argv);

  gui->statusicon = gtk_status_icon_new_from_file(DATADIR"/qwertickle.png");
  gtk_status_icon_set_visible(gui->statusicon, TRUE);
  gui->mainmenu = GTK_MENU(gtk_menu_new());
  gui->play = GTK_MENU_ITEM(gtk_menu_item_new());
  gui->sep = GTK_SEPARATOR_MENU_ITEM(gtk_separator_menu_item_new());
  gui->quit =
    GTK_IMAGE_MENU_ITEM(gtk_image_menu_item_new_from_stock("gtk-quit", NULL));
  gui->about =
    GTK_IMAGE_MENU_ITEM(gtk_image_menu_item_new_from_stock("gtk-about", NULL));
  gui->enable =
    GTK_CHECK_MENU_ITEM(gtk_check_menu_item_new_with_label("Enable"));

  gtk_menu_shell_append(GTK_MENU_SHELL(gui->mainmenu), GTK_WIDGET(gui->enable));
  gtk_menu_shell_append(GTK_MENU_SHELL(gui->mainmenu), GTK_WIDGET(gui->about));
  gtk_menu_shell_append(GTK_MENU_SHELL(gui->mainmenu), GTK_WIDGET(gui->sep));
  gtk_menu_shell_append(GTK_MENU_SHELL(gui->mainmenu), GTK_WIDGET(gui->quit));

  /* initialize widgets */
  gtk_check_menu_item_set_active(gui->enable, TRUE);

  /* connect signals */
  g_signal_connect(gui->statusicon, "popup-menu", G_CALLBACK(on_menu_pop), gui);
  g_signal_connect(gui->enable, "toggled", G_CALLBACK(on_enable_toggled), gui);
  g_signal_connect(gui->quit, "activate", G_CALLBACK(on_quit_activate), gui);
  g_signal_connect(gui->about, "activate", G_CALLBACK(on_about_activate), gui);
  g_signal_connect(gui->play, "activate", G_CALLBACK(on_play_activate), NULL);

  gtk_widget_show_all(GTK_WIDGET(gui->mainmenu));

  /* Fix freezing bug? close stdout and stdin so Xorg won't have to process
   * the input to stdout when program exit*/
  close(0);
  close(1);

  pthread_create(&thread, NULL, intercept_key_thread, gui->play);
  gtk_main();

  return 0;
}
Beispiel #23
0
G_MODULE_EXPORT void on_statistics_pane1_activate(GtkWidget *wiggy, gpointer data)
{
	GtkWidget *w;

	w=GTK_WIDGET(gtk_builder_get_object (builder, "StatisticsPane"));
	if(w==NULL)
		fprintf(stderr,"Cannot get the statistics pane.\n");
	else {
		switch(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(wiggy))) {
			case 0:
				gtk_widget_hide(w);
				break;
			default:
				gtk_widget_show(w);
		}
	}
}
Beispiel #24
0
static void
overview_ui_add_menu_item (void)
{
  static const gchar *view_menu_name = "menu_view1_menu";
  static const gchar *prev_item_name = "menu_show_sidebar1";
  GtkWidget          *main_window = geany_data->main_widgets->window;
  GtkWidget          *view_menu;
  GtkWidget          *prev_item;
  gint                item_pos;
  gboolean            visible = FALSE;

  view_menu = ui_lookup_widget (main_window, view_menu_name);
  if (! GTK_IS_MENU (view_menu))
    {
      g_critical ("failed to locate the View menu (%s) in Geany's main menu",
                  view_menu_name);
      return;
    }

  overview_ui_menu_item = gtk_check_menu_item_new_with_label (_("Show Overview"));
  prev_item = ui_lookup_widget (main_window, prev_item_name);
  if (! GTK_IS_MENU_ITEM (prev_item))
    {
      g_critical ("failed to locate the Show Sidebar menu item (%s) in Geany's UI",
                  prev_item_name);
      overview_ui_menu_sep = gtk_separator_menu_item_new ();
      gtk_menu_shell_append (GTK_MENU_SHELL (view_menu), overview_ui_menu_sep);
      gtk_menu_shell_append (GTK_MENU_SHELL (view_menu), overview_ui_menu_item);
      gtk_widget_show (overview_ui_menu_sep);
    }
  else
    {
      item_pos = overview_ui_get_menu_item_pos (view_menu, prev_item);
      overview_ui_menu_sep = NULL;
      gtk_menu_shell_insert (GTK_MENU_SHELL (view_menu), overview_ui_menu_item, item_pos);
    }

  g_object_get (overview_ui_prefs, "visible", &visible, NULL);
  gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (overview_ui_menu_item), visible);
  g_object_bind_property (overview_ui_menu_item, "active",
                          overview_ui_prefs, "visible",
                          G_BINDING_DEFAULT);

  gtk_widget_show (overview_ui_menu_item);
}
Beispiel #25
0
/* There are two activatable widgets, a toggle button and a menu item.
 *
 * If a widget is activated and the state of the tool button is the same as
 * the new state of the activated widget, then the other widget was the one
 * that was activated by the user and updated the tool button's state.
 *
 * If the state of the tool button is not the same as the new state of the
 * activated widget, then the activation was activated by the user, and the
 * widget needs to make sure the tool button is updated before the other
 * widget is activated. This will make sure the other widget a tool button
 * in a state that matches its own new state.
 */
static void
menu_item_activated (GtkWidget           *menu_item,
		     GtkToggleToolButton *toggle_tool_button)
{
  GtkToolButton *tool_button = GTK_TOOL_BUTTON (toggle_tool_button);
  gboolean menu_active = gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (menu_item));

  if (toggle_tool_button->priv->active != menu_active)
    {
      toggle_tool_button->priv->active = menu_active;

      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (_gtk_tool_button_get_button (tool_button)),
				    toggle_tool_button->priv->active);

      g_object_notify (G_OBJECT (toggle_tool_button), "active");
      g_signal_emit (toggle_tool_button, toggle_signals[TOGGLED], 0);
    }
}
Beispiel #26
0
void menu_info_subitem_update(menu_info_t* mi, uint32_t index, const char* name,
        const char* desc, char* tooltip, const char* icon)
{
    menu_info_item_t* item = menu_info_item_get(mi, index);

   if(item == NULL)
       g_error("[menu_info] subitem not found!");

    gboolean active = mi->parent->target == index;

    g_debug("[menu_info] updating subitem %s %u '%s' %s", menu_info_type_name(mi->type),
            index, desc, active ? " (active)" : "");

    if(!g_str_equal(item->desc, desc))
        gtk_menu_item_set_label(GTK_MENU_ITEM(item->widget), desc);
    if(active)
        gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item->widget), TRUE);
}
Beispiel #27
0
void cwiid_acc(struct cwiid_acc_mesg *mesg)
{
	static gchar str[LBLVAL_LEN];
	double a_x, a_y, a_z, a;
	double roll, pitch;
	
	if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(chkAcc))) {
		g_snprintf(str, LBLVAL_LEN, "%X", mesg->acc[CWIID_X]);
		gtk_label_set_text(GTK_LABEL(lblAccXVal), str);
		gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progAccX),
		                              (double)mesg->acc[CWIID_X]/0xFF);
		g_snprintf(str, LBLVAL_LEN, "%X", mesg->acc[CWIID_Y]);
		gtk_label_set_text(GTK_LABEL(lblAccYVal), str);
		gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progAccY),
		                              (double)mesg->acc[CWIID_Y]/0xFF);
		g_snprintf(str, LBLVAL_LEN, "%X", mesg->acc[CWIID_Z]);
		gtk_label_set_text(GTK_LABEL(lblAccZVal), str);
		gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progAccZ),
		                              (double)mesg->acc[CWIID_Z]/0xFF);

		a_x = ((double)mesg->acc[CWIID_X] - wm_cal.zero[CWIID_X]) /
		      (wm_cal.one[CWIID_X] - wm_cal.zero[CWIID_X]);
		a_y = ((double)mesg->acc[CWIID_Y] - wm_cal.zero[CWIID_Y]) /
		      (wm_cal.one[CWIID_Y] - wm_cal.zero[CWIID_Y]);
		a_z = ((double)mesg->acc[CWIID_Z] - wm_cal.zero[CWIID_Z]) /
		      (wm_cal.one[CWIID_Z] - wm_cal.zero[CWIID_Z]);
		a = sqrt(pow(a_x,2)+pow(a_y,2)+pow(a_z,2));

		roll = atan(a_x/a_z);
		if (a_z <= 0.0) {
			roll += PI * ((a_x > 0.0) ? 1 : -1);
		}
		roll *= -1;

		pitch = atan(a_y/a_z*cos(roll));

		g_snprintf(str, LBLVAL_LEN, "%.2f", a);
		gtk_label_set_text(GTK_LABEL(lblAccVal), str);
		g_snprintf(str, LBLVAL_LEN, "%.2f", roll);
		gtk_label_set_text(GTK_LABEL(lblRollVal), str);
		g_snprintf(str, LBLVAL_LEN, "%.2f", pitch);
		gtk_label_set_text(GTK_LABEL(lblPitchVal), str);
	}
}
Beispiel #28
0
void sc_gui_update_menu(void)
{
    GtkWidget *menu_item;
    guint i;
    static gboolean need_init = TRUE;
    GSList *group = NULL;
    gchar *label;

    if (need_init)
    {
        gtk_container_add(GTK_CONTAINER(geany->main_widgets->tools_menu), sc_info->menu_item);
        need_init = FALSE;
    }

    if (sc_info->main_menu != NULL)
        gtk_widget_destroy(sc_info->main_menu);

    sc_info->main_menu = gtk_menu_new();
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(sc_info->menu_item), sc_info->main_menu);

    sc_info->submenu_item_default = gtk_menu_item_new_with_label(NULL);
    gtk_container_add(GTK_CONTAINER(sc_info->main_menu), sc_info->submenu_item_default);
    g_signal_connect(sc_info->submenu_item_default, "activate",
                     G_CALLBACK(menu_item_toggled_cb), NULL);

    update_labels();

    menu_item = gtk_separator_menu_item_new();
    gtk_container_add(GTK_CONTAINER(sc_info->main_menu), menu_item);

    sc_ignore_callback = TRUE;
    for (i = 0; i < sc_info->dicts->len; i++)
    {
        label = g_ptr_array_index(sc_info->dicts, i);
        menu_item = gtk_radio_menu_item_new_with_label(group, label);
        group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(menu_item));
        if (utils_str_equal(sc_info->default_language, label))
            gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_item), TRUE);
        gtk_container_add(GTK_CONTAINER(sc_info->main_menu), menu_item);
        g_signal_connect(menu_item, "toggled", G_CALLBACK(menu_item_toggled_cb), label);
    }
    sc_ignore_callback = FALSE;
    gtk_widget_show_all(sc_info->main_menu);
}
Beispiel #29
0
void
viewer_load_preferences (Viewer *viewer, const char *fname)
{
    GKeyFile *preferences = g_key_file_new ();
    int loaded = 0;
    if (g_file_test (fname, G_FILE_TEST_IS_REGULAR)) {
        loaded = g_key_file_load_from_file (preferences, fname, 0, NULL);
    }

    if (!loaded) goto done;
    dbg ("loading viewer settings from %s\n", fname);
        
    for (int ridx = 0; ridx < viewer->renderers->len; ridx++) {
        Renderer *renderer = g_ptr_array_index (viewer->renderers, ridx);
        GtkCheckMenuItem *cmi = GTK_CHECK_MENU_ITEM (renderer->cmi);

        GError *err = NULL;
        int enabled = g_key_file_get_boolean (preferences,
                "__libviewer_enabled_renderers", renderer->name, &err);

        if (err) {
            err ("%s\n", err->message);
            g_error_free (err);
        } else {
            gtk_check_menu_item_set_active (cmi, enabled);
        }

        if (renderer->widget) {
            if (g_key_file_has_key (preferences, "__libviewer_show_renderers", 
                        renderer->name, NULL)) {
                renderer->expanded = g_key_file_get_boolean (preferences, 
                        "__libviewer_show_renderers", renderer->name, NULL);
                gtk_expander_set_expanded (GTK_EXPANDER (renderer->expander),
                        renderer->expanded);
            }
        }
    }

    g_signal_emit (G_OBJECT(viewer), viewer_signals[LOAD_PREFERENCES_SIGNAL], 0,
            preferences);

done:
    g_key_file_free (preferences);
}
/**
 * nma_utils_update_password_storage:
 * @passwd_entry: #GtkEntry with the password
 * @secret_flags: secret flags to set
 * @setting: #NMSetting containing the password, or NULL
 * @password_flags_name: name of the secret flags (like psk-flags), or NULL
 *
 * Updates secret flags in the password storage popup menu and also
 * in the @setting (if @setting and @password_flags_name are not NULL).
 *
 */
void
nma_utils_update_password_storage (GtkWidget *passwd_entry,
                                   NMSettingSecretFlags secret_flags,
                                   NMSetting *setting,
                                   const char *password_flags_name)
{
    GList *menu_list, *iter;
    GtkWidget *menu = NULL;

    /* Update secret flags (WEP_KEY_FLAGS, PSK_FLAGS, ...) in the security setting */
    if (setting && password_flags_name)
        nm_setting_set_secret_flags (setting, password_flags_name, secret_flags, NULL);

    /* Update password-storage popup menu to reflect secret flags */
    menu_list = gtk_menu_get_for_attach_widget (passwd_entry);
    for (iter = menu_list; iter; iter = g_list_next (iter)) {
        if (g_object_get_data (G_OBJECT (iter->data), PASSWORD_STORAGE_MENU_TAG)) {
            menu = iter->data;
            break;
        }
    }

    if (menu) {
        GtkRadioMenuItem *item;
        MenuItem idx;
        GSList *group;
        gboolean with_not_required;
        int i, last;

        /* radio menu group list contains the menu items in reverse order */
        item = (GtkRadioMenuItem *) gtk_menu_get_active (GTK_MENU (menu));
        group = gtk_radio_menu_item_get_group (item);
        with_not_required = !!g_object_get_data (G_OBJECT (menu), MENU_WITH_NOT_REQUIRED_TAG);

        idx = secret_flags_to_menu_item (secret_flags, with_not_required);
        last = g_slist_length (group) - idx - 1;
        for (i = 0; i < last; i++)
            group = g_slist_next (group);

        gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (group->data), TRUE);
        change_password_storage_icon (passwd_entry, idx);
    }
}