Пример #1
0
void pMenu::constructor() {
  gtkMenu = gtk_menu_new();
  widget = gtk_image_menu_item_new_with_mnemonic("");
  gtk_menu_item_set_submenu(GTK_MENU_ITEM(widget), gtkMenu);
  setText(menu.state.text);
}
Пример #2
0
static GObject *
matewnck_action_menu_constructor (GType                  type,
                              guint                  n_construct_properties,
                              GObjectConstructParam *construct_properties)
{
  GObject               *obj;
  MatewnckActionMenu        *menu;
  MatewnckActionMenuPrivate *priv;
  GtkWidget             *submenu;
  GtkWidget             *separator;
  GSList                *pin_group;
  MatewnckScreen            *screen;


  obj = G_OBJECT_CLASS (matewnck_action_menu_parent_class)->constructor (type,
                                                                     n_construct_properties,
                                                                     construct_properties);

  menu = MATEWNCK_ACTION_MENU (obj);
  priv = menu->priv;

  if (priv->window == NULL)
    {
      g_warning ("No window specified during creation of the action menu");
      return obj;
    }

  g_object_weak_ref (G_OBJECT (priv->window), window_weak_notify, menu);
  g_object_weak_ref (G_OBJECT (menu), object_weak_notify, priv->window);

  priv->minimize_item = make_menu_item (MINIMIZE);

  gtk_menu_shell_append (GTK_MENU_SHELL (menu),
                         priv->minimize_item);

  priv->maximize_item = make_menu_item (MAXIMIZE);

  gtk_menu_shell_append (GTK_MENU_SHELL (menu),
                         priv->maximize_item);

  priv->move_item = make_menu_item (MOVE);
  gtk_menu_shell_append (GTK_MENU_SHELL (menu),
                         priv->move_item);

  set_item_text (priv->move_item, _("_Move"));
  set_item_stock (priv->move_item, NULL);

  priv->resize_item = make_menu_item (RESIZE);
  gtk_menu_shell_append (GTK_MENU_SHELL (menu),
                         priv->resize_item);

  set_item_text (priv->resize_item, _("_Resize"));
  set_item_stock (priv->move_item, NULL);

  priv->workspace_separator = separator = gtk_separator_menu_item_new ();
  gtk_widget_show (separator);
  gtk_menu_shell_append (GTK_MENU_SHELL (menu),
                         separator);

  priv->above_item = make_check_menu_item (ABOVE,
                                          _("Always On _Top"));

  gtk_menu_shell_append (GTK_MENU_SHELL (menu),
                         priv->above_item);

  pin_group = NULL;

  priv->pin_item = make_radio_menu_item (PIN, &pin_group,
                                        _("_Always on Visible Workspace"));
  gtk_menu_shell_append (GTK_MENU_SHELL (menu),
                         priv->pin_item);

  priv->unpin_item = make_radio_menu_item (UNPIN, &pin_group,
                                          _("_Only on This Workspace"));
  gtk_menu_shell_append (GTK_MENU_SHELL (menu),
                         priv->unpin_item);

  priv->left_item = make_menu_item (LEFT);
  gtk_menu_shell_append (GTK_MENU_SHELL (menu),
                         priv->left_item);
  set_item_text (priv->left_item, _("Move to Workspace _Left"));
  set_item_stock (priv->left_item, NULL);

  priv->right_item = make_menu_item (RIGHT);
  gtk_menu_shell_append (GTK_MENU_SHELL (menu),
                         priv->right_item);
  set_item_text (priv->right_item, _("Move to Workspace R_ight"));
  set_item_stock (priv->right_item, NULL);

  priv->up_item = make_menu_item (UP);
  gtk_menu_shell_append (GTK_MENU_SHELL (menu),
                         priv->up_item);
  set_item_text (priv->up_item, _("Move to Workspace _Up"));
  set_item_stock (priv->up_item, NULL);

  priv->down_item = make_menu_item (DOWN);
  gtk_menu_shell_append (GTK_MENU_SHELL (menu),
                         priv->down_item);
  set_item_text (priv->down_item, _("Move to Workspace _Down"));
  set_item_stock (priv->down_item, NULL);

  priv->workspace_item = gtk_menu_item_new_with_mnemonic (_("Move to Another _Workspace"));
  gtk_widget_show (priv->workspace_item);

  submenu = gtk_menu_new ();
  gtk_menu_item_set_submenu (GTK_MENU_ITEM (priv->workspace_item),
                             submenu);

  gtk_menu_shell_append (GTK_MENU_SHELL (menu),
                         priv->workspace_item);

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

  priv->close_item = make_menu_item (CLOSE);

  gtk_menu_shell_append (GTK_MENU_SHELL (menu),
                         priv->close_item);

  set_item_text (priv->close_item, _("_Close"));
  set_item_stock (priv->close_item, MATEWNCK_STOCK_DELETE);

  g_signal_connect_object (G_OBJECT (priv->window),
                           "state_changed",
                           G_CALLBACK (state_changed_callback),
                           G_OBJECT (menu),
                           0);

  g_signal_connect_object (G_OBJECT (priv->window),
                           "actions_changed",
                           G_CALLBACK (actions_changed_callback),
                           G_OBJECT (menu),
                           0);

  g_signal_connect_object (G_OBJECT (priv->window),
                           "workspace_changed",
                           G_CALLBACK (workspace_changed_callback),
                           G_OBJECT (menu),
                           0);

  screen = matewnck_window_get_screen (priv->window);

  g_signal_connect_object (G_OBJECT (screen),
                           "workspace_created",
                           G_CALLBACK (screen_workspace_callback),
                           G_OBJECT (menu),
                           0);

  g_signal_connect_object (G_OBJECT (screen),
                           "workspace_destroyed",
                           G_CALLBACK (screen_workspace_callback),
                           G_OBJECT (menu),
                           0);

  g_signal_connect_object (G_OBJECT (screen),
                           "viewports_changed",
                           G_CALLBACK (viewports_changed_callback),
                           G_OBJECT (menu),
                           0);

  update_menu_state (menu);

  return obj;
}
Пример #3
0
static GtkWidget *vte_create_popup_menu(void)
{
	GtkWidget *menu, *item;
	GtkAccelGroup *accel_group;

	menu = gtk_menu_new();

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

	item = gtk_image_menu_item_new_from_stock(GTK_STOCK_COPY, NULL);
	gtk_widget_add_accelerator(item, "activate", accel_group,
		GDK_c, GEANY_PRIMARY_MOD_MASK | GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE);
	gtk_widget_show(item);
	gtk_container_add(GTK_CONTAINER(menu), item);
	g_signal_connect(item, "activate", G_CALLBACK(vte_popup_menu_clicked), GINT_TO_POINTER(POPUP_COPY));

	item = gtk_image_menu_item_new_from_stock(GTK_STOCK_PASTE, NULL);
	gtk_widget_add_accelerator(item, "activate", accel_group,
		GDK_v, GEANY_PRIMARY_MOD_MASK | GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE);
	gtk_widget_show(item);
	gtk_container_add(GTK_CONTAINER(menu), item);
	g_signal_connect(item, "activate", G_CALLBACK(vte_popup_menu_clicked), GINT_TO_POINTER(POPUP_PASTE));

	item = gtk_separator_menu_item_new();
	gtk_widget_show(item);
	gtk_container_add(GTK_CONTAINER(menu), item);

	item = gtk_image_menu_item_new_from_stock(GTK_STOCK_SELECT_ALL, NULL);
	gtk_widget_show(item);
	gtk_container_add(GTK_CONTAINER(menu), item);
	g_signal_connect(item, "activate", G_CALLBACK(vte_popup_menu_clicked), GINT_TO_POINTER(POPUP_SELECTALL));

	item = gtk_separator_menu_item_new();
	gtk_widget_show(item);
	gtk_container_add(GTK_CONTAINER(menu), item);

	item = gtk_image_menu_item_new_with_mnemonic(_("_Set Path From Document"));
	gtk_widget_show(item);
	gtk_container_add(GTK_CONTAINER(menu), item);
	g_signal_connect(item, "activate", G_CALLBACK(vte_popup_menu_clicked), GINT_TO_POINTER(POPUP_CHANGEPATH));

	item = gtk_image_menu_item_new_with_mnemonic(_("_Restart Terminal"));
	gtk_widget_show(item);
	gtk_container_add(GTK_CONTAINER(menu), item);
	g_signal_connect(item, "activate", G_CALLBACK(vte_popup_menu_clicked), GINT_TO_POINTER(POPUP_RESTARTTERMINAL));

	item = gtk_separator_menu_item_new();
	gtk_widget_show(item);
	gtk_container_add(GTK_CONTAINER(menu), item);

	item = gtk_image_menu_item_new_from_stock(GTK_STOCK_PREFERENCES, NULL);
	gtk_widget_show(item);
	gtk_container_add(GTK_CONTAINER(menu), item);
	g_signal_connect(item, "activate", G_CALLBACK(vte_popup_menu_clicked), GINT_TO_POINTER(POPUP_PREFERENCES));

	msgwin_menu_add_common_items(GTK_MENU(menu));

	item = gtk_separator_menu_item_new();
	gtk_widget_show(item);
	gtk_container_add(GTK_CONTAINER(menu), item);

	/* the IM submenu should always be the last item to be consistent with other GTK popup menus */
	vc->im_submenu = gtk_menu_new();

	item = gtk_image_menu_item_new_with_mnemonic(_("_Input Methods"));
	gtk_widget_show(item);
	gtk_container_add(GTK_CONTAINER(menu), item);

	gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), vc->im_submenu);
	/* submenu populated after vte realized */
	return menu;
}
Пример #4
0
/* New dialog */
void
new_cb()
{
	// If another nn is open, call delete_cb()
	if(nn != NULL)
		delete_cb();
	
	GtkWidget *tmp;	

	// Dialog where select the net neurons number
	new_w = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title(GTK_WINDOW(new_w), "New Neural Network");
	gtk_window_resize(GTK_WINDOW(new_w), 300, 180);
	//g_signal_connect(G_OBJECT(window), "destroy", 
	//                     G_CALLBACK(gtk_main_quit), NULL);
    
	GtkWidget *mbox = gtk_vbox_new(1, 0);
	gtk_container_add(GTK_CONTAINER(new_w), mbox);


	GtkWidget *menu = gtk_menu_bar_new();
	gtk_box_pack_start(GTK_BOX(mbox),menu,TRUE,TRUE,0);

	// 
	GtkWidget *menu_file = gtk_menu_item_new_with_label("File");
	gtk_menu_bar_append (GTK_MENU_BAR(menu), menu_file);

	GtkWidget *menu_sub = gtk_menu_new();
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_file), menu_sub);

	GtkWidget *menuitem = gtk_menu_item_new_with_label ("Quit");
	g_signal_connect(G_OBJECT(menuitem), "clicked", G_CALLBACK(save_cb), NULL);
	gtk_menu_append(GTK_MENU(menu_sub), menuitem);


	// Input neurons
	tmp = gtk_hbox_new(0,0);
	gtk_box_pack_start(GTK_BOX(mbox),tmp,FALSE,FALSE,0);

	gtk_box_pack_start(GTK_BOX(tmp),gtk_label_new("Input neurons: "),FALSE,FALSE,0);
	input_spin = gtk_spin_button_new(
		GTK_ADJUSTMENT(gtk_adjustment_new(2.0, 0.0, 10000.0, 1.0, 10.0, 10.0)), 
		1.0, 0);
	gtk_box_pack_start(GTK_BOX(tmp),input_spin,FALSE,FALSE,0);

	// Hidden neurons
	tmp = gtk_hbox_new(0,0);
	gtk_box_pack_start(GTK_BOX(mbox),tmp,FALSE,FALSE,0);

	gtk_box_pack_start(GTK_BOX(tmp),gtk_label_new("Hidden neurons: "),FALSE,FALSE,0);
	hidden_spin = gtk_spin_button_new(
		GTK_ADJUSTMENT(gtk_adjustment_new(3.0, 0.0, 10000.0, 1.0, 10.0, 10.0)), 
		1.0, 0);
	gtk_box_pack_start(GTK_BOX(tmp),hidden_spin,FALSE,FALSE,0);

	// Output neurons
	tmp = gtk_hbox_new(0,0);
	gtk_box_pack_start(GTK_BOX(mbox),tmp,FALSE,FALSE,0);

	gtk_box_pack_start(GTK_BOX(tmp),gtk_label_new("Output neurons: "),FALSE,FALSE,0);
	output_spin = gtk_spin_button_new(
		GTK_ADJUSTMENT(gtk_adjustment_new(1.0, 0.0, 10000.0, 1.0, 10.0, 10.0)), 
		1.0, 0);
	gtk_box_pack_start(GTK_BOX(tmp),output_spin,FALSE,FALSE,0);
	
	// Learning neurons
	tmp = gtk_hbox_new(0,0);
	gtk_box_pack_start(GTK_BOX(mbox),tmp,FALSE,FALSE,0);

	gtk_box_pack_start(GTK_BOX(tmp),gtk_label_new("Learning rate: "),FALSE,FALSE,0);
	learning_spin = gtk_spin_button_new(
		GTK_ADJUSTMENT(gtk_adjustment_new(0.6, 0.0, 1.0, 0.02, 0.6, 0.1)), 
		1.0, 2);
	gtk_box_pack_start(GTK_BOX(tmp),learning_spin,FALSE,FALSE,0);
	
	// Combo for transfer function
	
	tmp = gtk_hbox_new(0,0);
	gtk_box_pack_start(GTK_BOX(mbox),tmp,FALSE,FALSE,0);
	GtkWidget *new_button = gtk_button_new_with_label("New");
	g_signal_connect(G_OBJECT(new_button), "clicked", G_CALLBACK(new_do_cb), NULL);
	gtk_container_add(GTK_CONTAINER(tmp), new_button);
	GtkWidget *cancel_button = gtk_button_new_with_label("Cancel");
	g_signal_connect(G_OBJECT(cancel_button), "clicked", G_CALLBACK(new_cancel_cb), NULL);
	gtk_container_add(GTK_CONTAINER(tmp), cancel_button);
	 
	gtk_widget_show_all(new_w);
}
Пример #5
0
int
main (int argc, char *argv[])
{
  GtkWidget *box;
  GtkWidget *menubar;
  GtkWidget *menuitem;
  GtkWidget *menu;
  GtkWidget *button;
  GtkAccelGroup *accel_group;

  gtk_init (&argc, &argv);

  manager = gtk_recent_manager_get_default ();

  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_window_set_default_size (GTK_WINDOW (window), -1, -1);
  gtk_window_set_title (GTK_WINDOW (window), "Recent Chooser Menu Test");
  g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);

  accel_group = gtk_accel_group_new ();
  gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
  
  box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
  gtk_container_add (GTK_CONTAINER (window), box);
  gtk_widget_show (box);

  menubar = gtk_menu_bar_new ();
  gtk_box_pack_start (GTK_BOX (box), menubar, FALSE, TRUE, 0);
  gtk_widget_show (menubar);

  menu = create_file_menu (accel_group);
  menuitem = gtk_menu_item_new_with_mnemonic ("_File");
  gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
  gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
  gtk_widget_show (menuitem);

  menu = create_recent_chooser_menu (4);
  menuitem = gtk_menu_item_new_with_mnemonic ("_Recently Used");
  gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
  gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
  gtk_widget_show (menuitem);

  label = gtk_label_new ("No recent item selected");
  gtk_box_pack_start (GTK_BOX (box), label, TRUE, TRUE, 0);
  gtk_widget_show (label);

  button = gtk_button_new_with_label ("Close");
  g_signal_connect_swapped (button, "clicked",
                            G_CALLBACK (gtk_widget_destroy),
                            window);
  gtk_box_pack_end (GTK_BOX (box), button, TRUE, TRUE, 0);
  gtk_widget_set_can_default (button, TRUE);
  gtk_widget_grab_default (button);
  gtk_widget_show (button);

  gtk_widget_show (window);

  gtk_main ();

  return 0;
}
Пример #6
0
RtTraceGtk::RtTraceGtk( void *tr_parent_ctx, GtkWidget *tr_parent_wid, pwr_tObjid tr_objid,
			pwr_tStatus *status) :
  RtTrace( tr_parent_ctx, tr_objid, status), parent_wid(tr_parent_wid), toplevel(0), nav_shell(0)
{

  const int	window_width = 900;
  const int    	window_height = 800;
  const int    	nav_width = 180;
  pwr_tStatus 	sts;
  pwr_tObjid	window_objid;
  pwr_tClassId	cid;
  char   	title[220];
  pwr_tOName   	hostname;
  pwr_tOName   	plcconnect;
  pwr_tFileName fname;

  sts = gdh_ObjidToName( tr_objid, name, sizeof(name), cdh_mNName); 
  if (EVEN(sts)) {
    *status = sts;
    return;
  }
  strcpy( title, "Trace ");
  strcat( title, name);

  /* Find plcwindow */
  sts = gdh_GetObjectClass( tr_objid, &cid);
  if ( EVEN(sts)) {
    *status = sts;
    return;
  }

  if ( !(cid == pwr_cClass_windowplc ||
         cid == pwr_cClass_windowcond ||
         cid == pwr_cClass_windoworderact ||
         cid == pwr_cClass_windowsubstep )) {
    sts = gdh_GetChild( tr_objid, &window_objid);
    if ( EVEN(sts)) {
      *status = sts;
      return;
    }
  }
  else
    window_objid = tr_objid; 

  sts = gdh_GetObjectClass( window_objid, &cid);
  if ( EVEN(sts)) {
    *status = sts;
    return;
  }

  if ( !(cid == pwr_cClass_windowplc ||
         cid == pwr_cClass_windowcond ||
         cid == pwr_cClass_windoworderact ||
         cid == pwr_cClass_windowsubstep )) {
    *status = 0;
    return;
  }

  sts = get_filename( window_objid, filename, &m_has_host, hostname, 
		      plcconnect);
  if ( EVEN(sts)) {
    *status = sts;
    return;
  }

  /* Create object context */
  objid = window_objid;
  if ( m_has_host) {
    strcpy( m_hostname, hostname);
    strcpy( m_plcconnect, plcconnect);
  }

  char *titleutf8 = g_convert( title, -1, "UTF-8", "ISO8859-1", NULL, NULL, NULL);

  // Gtk
  toplevel = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW, 
					 "default-height", window_height,
					 "default-width", window_width,
					 "title", titleutf8,
					 NULL);
  g_free( titleutf8);

  g_signal_connect( toplevel, "delete_event", G_CALLBACK(delete_event), this);
  g_signal_connect( toplevel, "destroy", G_CALLBACK(destroy_event), this);

  CoWowGtk::SetWindowIcon( toplevel);

  GtkAccelGroup *accel_g = (GtkAccelGroup *) g_object_new(GTK_TYPE_ACCEL_GROUP, NULL);
  gtk_window_add_accel_group(GTK_WINDOW(toplevel), accel_g);

  GtkMenuBar *menu_bar = (GtkMenuBar *) g_object_new(GTK_TYPE_MENU_BAR, NULL);

  // File Entry
  // Submenu Print
  GtkWidget *file_print = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Print"));
  g_signal_connect( file_print, "activate", 
		    G_CALLBACK(activate_print), this);

  GtkWidget *file_print_select = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("Print _Selected Documents"));
  g_signal_connect( file_print_select, "activate", 
		    G_CALLBACK(activate_printselect), this);

  GtkWidget *file_savetrace = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("Save _Trace"));
  g_signal_connect( file_savetrace, "activate", 
		    G_CALLBACK(activate_savetrace), this);

  GtkWidget *file_restoretrace = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Restore Trace"));
  g_signal_connect( file_restoretrace, "activate", 
		    G_CALLBACK(activate_restoretrace), this);

  GtkWidget *file_cleartrace = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("C_lear Trace"));
  g_signal_connect( file_cleartrace, "activate", 
		    G_CALLBACK(activate_cleartrace), this);

  GtkWidget *file_close = gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE, accel_g);
  g_signal_connect(file_close, "activate", G_CALLBACK(activate_close), this);

  GtkMenu *file_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
  gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_print);
  gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_print_select);
  gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_savetrace);
  gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_restoretrace);
  gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_cleartrace);
  gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_close);

  GtkWidget *file = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_File"));
  gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), file);
  gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), GTK_WIDGET(file_menu));

  // Functions Entry
  GtkWidget *functions_open_object = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Open Object"));
  g_signal_connect( functions_open_object, "activate", 
		    G_CALLBACK(activate_open_object), this);
  gtk_widget_add_accelerator( functions_open_object, "activate", accel_g,
  			      'a', GdkModifierType(GDK_CONTROL_MASK), 
  			      GTK_ACCEL_VISIBLE);

  GtkWidget *functions_open_subwindow = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("Open S_ubwindow"));
  g_signal_connect( functions_open_subwindow, "activate", 
		    G_CALLBACK(activate_open_subwindow), this);
  gtk_widget_add_accelerator( functions_open_subwindow, "activate", accel_g,
  			      'l', GdkModifierType(GDK_CONTROL_MASK), 
  			      GTK_ACCEL_VISIBLE);

  GtkWidget *functions_display_object = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Display object in Navigator"));
  g_signal_connect( functions_display_object, "activate", 
		    G_CALLBACK(activate_display_object), this);
  gtk_widget_add_accelerator( functions_display_object, "activate", accel_g,
  			      'd', GdkModifierType(GDK_CONTROL_MASK), 
  			      GTK_ACCEL_VISIBLE);

  GtkWidget *functions_show_cross = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Show Crossreferences"));
  g_signal_connect( functions_show_cross, "activate", 
		    G_CALLBACK(activate_show_cross), this);
  gtk_widget_add_accelerator( functions_show_cross, "activate", accel_g,
  			      'r', GdkModifierType(GDK_CONTROL_MASK), 
  			      GTK_ACCEL_VISIBLE);

  GtkWidget *functions_open_classgraph = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Open ObjectGraph"));
  g_signal_connect( functions_open_classgraph, "activate", 
		    G_CALLBACK(activate_open_classgraph), this);
  gtk_widget_add_accelerator( functions_open_classgraph, "activate", accel_g,
  			      'g', GdkModifierType(GDK_CONTROL_MASK), 
  			      GTK_ACCEL_VISIBLE);

  GtkWidget *functions_collect_insert = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Collect Insert"));
  g_signal_connect( functions_collect_insert, "activate", 
		    G_CALLBACK(activate_collect_insert), this);
  gtk_widget_add_accelerator( functions_collect_insert, "activate", accel_g,
  			      'v', GdkModifierType(GDK_CONTROL_MASK), 
  			      GTK_ACCEL_VISIBLE);

  GtkMenu *functions_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
  gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_open_object);
  gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_open_subwindow);
  gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_display_object);
  gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_show_cross);
  gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_open_classgraph);
  gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_collect_insert);

  GtkWidget *functions = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Functions"));
  gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), functions);
  gtk_menu_item_set_submenu(GTK_MENU_ITEM(functions), GTK_WIDGET(functions_menu));


  // View Entry

  GtkWidget *view_zoom_in = gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_IN, NULL);
  g_signal_connect( view_zoom_in, "activate", 
		    G_CALLBACK(activate_zoomin), this);
  gtk_widget_add_accelerator( view_zoom_in, "activate", accel_g,
  			      'i', GdkModifierType(GDK_CONTROL_MASK), 
  			      GTK_ACCEL_VISIBLE);

  GtkWidget *view_zoom_out = gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_OUT, NULL);
  g_signal_connect( view_zoom_out, "activate", 
		    G_CALLBACK(activate_zoomout), this);
  gtk_widget_add_accelerator( view_zoom_out, "activate", accel_g,
  			      'o', GdkModifierType(GDK_CONTROL_MASK), 
  			      GTK_ACCEL_VISIBLE);

  GtkWidget *view_zoom_reset = gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_100, NULL);
  g_signal_connect( view_zoom_reset, "activate", 
		    G_CALLBACK(activate_zoomreset), this);
  gtk_widget_add_accelerator( view_zoom_reset, "activate", accel_g,
  			      'b', GdkModifierType(GDK_CONTROL_MASK), 
  			      GTK_ACCEL_VISIBLE);

  // Submenu ScanTime
  GSList *view_sc_group = NULL;
  GtkWidget *view_scantime1 = gtk_radio_menu_item_new_with_mnemonic( view_sc_group, 
									"0.50 s");
  view_sc_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(view_scantime1));
  g_signal_connect( view_scantime1, "activate", 
		    G_CALLBACK(activate_scantime1), this);

  GtkWidget *view_scantime2 = gtk_radio_menu_item_new_with_mnemonic( view_sc_group, 
									"0.20 s");
  view_sc_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(view_scantime1));
  g_signal_connect( view_scantime2, "activate", 
		    G_CALLBACK(activate_scantime2), this);

  GtkWidget *view_scantime3 = gtk_radio_menu_item_new_with_mnemonic( view_sc_group, 
									"0.10 s");
  view_sc_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(view_scantime1));
  g_signal_connect( view_scantime3, "activate", 
		    G_CALLBACK(activate_scantime3), this);

  GtkWidget *view_scantime4 = gtk_radio_menu_item_new_with_mnemonic( view_sc_group, 
									"0.05 s");
  view_sc_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(view_scantime1));
  g_signal_connect( view_scantime4, "activate", 
		    G_CALLBACK(activate_scantime4), this);

  GtkWidget *view_scantime5 = gtk_radio_menu_item_new_with_mnemonic( view_sc_group, 
									"0.02 s");
  g_signal_connect( view_scantime5, "activate", 
		    G_CALLBACK(activate_scantime5), this);

  GtkWidget *view_sc = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_ScanTime"));
  GtkMenu *view_sc_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
  gtk_menu_shell_append(GTK_MENU_SHELL(view_sc_menu), view_scantime1);
  gtk_menu_shell_append(GTK_MENU_SHELL(view_sc_menu), view_scantime2);
  gtk_menu_shell_append(GTK_MENU_SHELL(view_sc_menu), view_scantime3);
  gtk_menu_shell_append(GTK_MENU_SHELL(view_sc_menu), view_scantime4);
  gtk_menu_shell_append(GTK_MENU_SHELL(view_sc_menu), view_scantime5);

  gtk_menu_item_set_submenu(GTK_MENU_ITEM(view_sc),
			    GTK_WIDGET(view_sc_menu));

  GtkMenu *view_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
  gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_in);
  gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_out);
  gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_reset);
  gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_sc);

  GtkWidget *view = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_View"));
  gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), view);
  gtk_menu_item_set_submenu(GTK_MENU_ITEM(view), GTK_WIDGET(view_menu));

  // Mode entry
  GSList *mode_group = NULL;
  GtkWidget *mode_view = gtk_radio_menu_item_new_with_mnemonic( mode_group, CoWowGtk::translate_utf8("V_iew"));
  mode_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(mode_view));
  g_signal_connect( mode_view, "activate", 
		    G_CALLBACK(activate_view), this);

  GtkWidget *mode_trace = gtk_radio_menu_item_new_with_mnemonic( mode_group, CoWowGtk::translate_utf8("_Trace"));
  mode_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(mode_trace));
  g_signal_connect( mode_trace, "activate", 
		    G_CALLBACK(activate_trace), this);

  GtkWidget *mode_simulate = gtk_radio_menu_item_new_with_mnemonic( mode_group, CoWowGtk::translate_utf8("_Simulate"));
  gtk_widget_add_accelerator( mode_simulate, "activate", accel_g,
  			      's', GdkModifierType(GDK_CONTROL_MASK | GDK_SHIFT_MASK), 
  			      GTK_ACCEL_VISIBLE);
  g_signal_connect( mode_simulate, "activate", 
		    G_CALLBACK(activate_simulate), this);

  GtkMenu *mode_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
  gtk_menu_shell_append(GTK_MENU_SHELL(mode_menu), mode_view);
  gtk_menu_shell_append(GTK_MENU_SHELL(mode_menu), mode_trace);
  gtk_menu_shell_append(GTK_MENU_SHELL(mode_menu), mode_simulate);

  GtkWidget *mode = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Mode"));
  gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), mode);
  gtk_menu_item_set_submenu(GTK_MENU_ITEM(mode), GTK_WIDGET(mode_menu));

  // Menu Help
  GtkWidget *help_help = gtk_image_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("On _Trace"));
  gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(help_help), 
				 gtk_image_new_from_stock( "gtk-help", GTK_ICON_SIZE_MENU));
  g_signal_connect(help_help, "activate", G_CALLBACK(activate_help), this);
  gtk_widget_add_accelerator( help_help, "activate", accel_g,
			      'h', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);

  GtkWidget *help_plcpgm = gtk_check_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("On _PlcPgm"));
  g_signal_connect( help_plcpgm, "activate", 
		    G_CALLBACK(activate_helpplc), this);

  GtkMenu *help_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
  gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_help);
  gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_plcpgm);

  GtkWidget *help = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Help"));
  gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), help);
  gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), GTK_WIDGET(help_menu));

  // Toolbar
  GtkToolbar *tools = (GtkToolbar *) g_object_new(GTK_TYPE_TOOLBAR, NULL);

  GtkWidget *tools_display_object = gtk_button_new();
  dcli_translate_filename( fname, "$pwr_exe/xtt_navigator.png");
  gtk_container_add( GTK_CONTAINER(tools_display_object), 
		     gtk_image_new_from_file( fname));
  g_signal_connect(tools_display_object, "clicked", G_CALLBACK(activate_display_object), this);
  gtk_toolbar_append_widget( tools, tools_display_object, "Display object in Navigator", "");
  
  GtkWidget *tools_show_cross = gtk_button_new();
  dcli_translate_filename( fname, "$pwr_exe/xtt_crossref.png");
  gtk_container_add( GTK_CONTAINER(tools_show_cross), 
		     gtk_image_new_from_file( fname));
  g_signal_connect(tools_show_cross, "clicked", G_CALLBACK(activate_show_cross), this);
  gtk_toolbar_append_widget( tools, tools_show_cross, "Show Crossreferences", "");
  
  GtkWidget *tools_zoom_in = gtk_button_new();
  dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_in.png");
  gtk_container_add( GTK_CONTAINER(tools_zoom_in), 
		     gtk_image_new_from_file( fname));
  g_signal_connect(tools_zoom_in, "clicked", G_CALLBACK(activate_zoomin), this);
  gtk_toolbar_append_widget( tools, tools_zoom_in, "Zoom in", "");

  GtkWidget *tools_zoom_out = gtk_button_new();
  dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_out.png");
  gtk_container_add( GTK_CONTAINER(tools_zoom_out), 
		     gtk_image_new_from_file( fname));
  g_signal_connect(tools_zoom_out, "clicked", G_CALLBACK(activate_zoomout), this);
  gtk_toolbar_append_widget( tools, tools_zoom_out, "Zoom out", "");

  GtkWidget *tools_zoom_reset = gtk_button_new();
  dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_reset.png");
  gtk_container_add( GTK_CONTAINER(tools_zoom_reset), 
		     gtk_image_new_from_file( fname));
  g_signal_connect(tools_zoom_reset, "clicked", G_CALLBACK(activate_zoomreset), this);
  gtk_toolbar_append_widget( tools, tools_zoom_reset, "Zoom reset", "");

  // Flow widget
  GtkWidget *flow_scrolled = scrolledflowwidgetgtk_new( init_flow, 
							this, &flow_widget);
  gtk_widget_show_all(flow_widget);

  nav_widget = flownavwidgetgtk_new( flow_widget);

  GtkWidget *paned = gtk_hpaned_new();
  gtk_paned_pack1( GTK_PANED(paned), flow_scrolled, TRUE, TRUE);
  gtk_paned_pack2( GTK_PANED(paned), nav_widget, FALSE, TRUE);

  GtkWidget *vbox = gtk_vbox_new( FALSE, 0);
  gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(menu_bar), FALSE, FALSE, 0);
  gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(tools), FALSE, FALSE, 0);
  gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(paned), TRUE, TRUE, 0);

  gtk_container_add( GTK_CONTAINER(toplevel), vbox);
  gtk_widget_show_all( toplevel);

  gtk_paned_set_position( GTK_PANED(paned), window_width - nav_width);

#if 0
  // Navigator window
  nav_shell = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW, 
					  "default-height", 200,
					  "default-width", 200,
					  "title", "Navigator",
					  NULL);
  g_signal_connect( nav_shell, "delete_event", G_CALLBACK(nav_delete_event), this);

  nav_widget = flownavwidgetgtk_new( flow_widget);
  gtk_container_add( GTK_CONTAINER(nav_shell), nav_widget);
  gtk_widget_show_all( nav_shell);
#endif

  wow = new CoWowGtk( toplevel);
  trace_timerid = wow->timer_new();

  viewsetup();
  flow_Open( flow_ctx, filename);

  gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( mode_trace), TRUE);
  gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( view_scantime1), TRUE);

  //trasetup();
  //trace_start();

#if defined OS_LINUX
  {
    struct stat info;

    if ( stat( filename, &info) != -1)
      version = info.st_ctime;    
  }
#endif

  // Check version
  unsigned int flow_version;
  pwr_tUInt32 window_version;
  pwr_tAName aname;

  flow_GetCtxUserVersion( flow_ctx, &flow_version);

  strcpy( aname, name);
  strcat( aname, ".Version");

  sts = gdh_GetObjectInfo( aname, &window_version, sizeof(window_version));
  if ( EVEN(sts)) return;

  if ( flow_version > window_version)
    wow->DisplayError( "Version mismatch", "Trace file is newer than database version");
  else if ( flow_version < window_version)
    wow->DisplayError( "Version mismatch", "Trace file is older than database version");
}
Пример #7
0
static GtkWidget *create_menubar(GFunc *quit_proc) {
	GtkWidget *menubar;
	GtkWidget *menu,*menu_item;
	GtkWidget *menu_entry_play, *menu_entry_pause, *menu_entry_conn, *menu_entry_disconn;
/* 	GtkActionGroup *group;
	GtkUIManager *ui_manager; */

	menubar = gtk_menu_bar_new();

	/* action group whatever *
	group = gtk_action_group_new("MainActionGroup");
	gtk_action_group_add_actions(group,entries,NUM_ENTRIES,NULL);
	* UI Manager *
	ui_manager = gtk_ui_manager_new();
	gtk_ui_manager_insert_action_group(ui_manager, group, 0);
	* adjust path !!! *
	gtk_ui_manager_add_ui_from_file(ui_manager, "menu.ui", NULL);
	menubar = gtk_ui_manager_get_widget(ui_manager, "/MenuBar"); */

	/* item: Playlist */
	menu_item = gtk_menu_item_new_with_mnemonic ("_Playlist");
	gtk_container_add(GTK_CONTAINER(menubar), menu_item);

	/* create menubox for the item */
	menu = gtk_menu_new ();
  	gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), menu);

	/* action: add url */
	menu_add_entry(GTK_CONTAINER(menu), "_Add Media Resource Locator", G_CALLBACK(gui_add_mrl_win), NULL);
	/* action: delete */
	menu_add_entry(GTK_CONTAINER(menu), "_Delete Songs", G_CALLBACK(pl_del_songs), NULL);
	/* action: get current song lyrics */
	// menu_add_entry(GTK_CONTAINER(menu), "_Get lyrics", G_CALLBACK(pl_get_current_song_lyrics), NULL);

	/* menu_entry = gtk_menu_item_new_with_mnemonic("Media _Browser");
	gtk_container_add(GTK_CONTAINER(menu), menu_entry);
	g_signal_connect(G_OBJECT(menu_entry), "activate",
					 G_CALLBACK(media_browser_window_show), NULL);
	g_signal_connect(G_OBJECT(menu_entry), "activate",
					 G_CALLBACK(media_database_read), NULL); */

	/* action: separator */
	menu_add_separator(GTK_CONTAINER(menu));
	/* action: reload playlist */
	menu_add_entry(GTK_CONTAINER(menu), "_Reload playlist", G_CALLBACK(playlist_update_tree_cb), NULL);

	/* action reload media browser */
	menu_add_entry(GTK_CONTAINER(menu), "Reload _Media Browser", G_CALLBACK(mb_reread_cb), NULL);

	/* action: separator */
	menu_add_separator(GTK_CONTAINER(menu));

	/* action: properties dialog */
	menu_add_entry(GTK_CONTAINER(menu), "_Properties", G_CALLBACK(mpd_new_properties_window_cb), (gpointer)MpdWin.win);

	/* action: quit */
#ifdef CLOSE
	menu_add_entry(GTK_CONTAINER(menu), "_Close", G_CALLBACK(quit_proc), MpdWin.win);
#else
	menu_add_entry(GTK_CONTAINER(menu), "_Quit", G_CALLBACK(quit_proc), MpdWin.win);
#endif

	/* item: MPD */
	menu_item = gtk_menu_item_new_with_mnemonic ("_MPD");
	gtk_container_add(GTK_CONTAINER(menubar), menu_item);

	/* create menubox for the item */
	menu = gtk_menu_new ();
  	gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), menu);

	/* action: connect/disconnect */
	menu_entry_disconn = menu_add_entry_stock_icon(GTK_CONTAINER(menu), "_Disconnect", GTK_STOCK_DISCONNECT, G_CALLBACK(mpd_disconnect_cb), NULL);
	menu_entry_conn = menu_add_entry_stock_icon(GTK_CONTAINER(menu), "_Connect", GTK_STOCK_CONNECT, G_CALLBACK(mpd_connect_cb), NULL);

	/* separator */
	menu_add_separator(GTK_CONTAINER(menu));

	/* action: Previous */
	menu_add_entry_stock_icon(GTK_CONTAINER(menu), "P_revious", GTK_STOCK_MEDIA_PREVIOUS, G_CALLBACK(action), ACTION_TYPE_TO_GPOINTER(ACTION_PREVIOUS));

	/* action: Play */
	menu_entry_play = menu_add_entry_stock_icon(GTK_CONTAINER(menu), "_Play", GTK_STOCK_MEDIA_PLAY, G_CALLBACK(action), ACTION_TYPE_TO_GPOINTER(ACTION_PLAY_PAUSE));

	/* action: Pause */
	menu_entry_pause = menu_add_entry_stock_icon(GTK_CONTAINER(menu), "_Pause", GTK_STOCK_MEDIA_PAUSE, G_CALLBACK(action), ACTION_TYPE_TO_GPOINTER(ACTION_PLAY_PAUSE));


	/* action: Stop */
	menu_add_entry_stock_icon(GTK_CONTAINER(menu), "_Stop", GTK_STOCK_MEDIA_STOP, G_CALLBACK(action), ACTION_TYPE_TO_GPOINTER(ACTION_STOP));

	/* action: Next */
	menu_add_entry_stock_icon(GTK_CONTAINER(menu), "_Next", GTK_STOCK_MEDIA_NEXT, G_CALLBACK(action), ACTION_TYPE_TO_GPOINTER(ACTION_NEXT));

	/* action: separator */
	menu_add_separator(GTK_CONTAINER(menu));

	/* action: Update DB */
	menu_add_entry(GTK_CONTAINER(menu), "_Update DB", G_CALLBACK(action), ACTION_TYPE_TO_GPOINTER(ACTION_UPDATE_DB));

	/* action: Shuffle Playlist */
	menu_add_entry(GTK_CONTAINER(menu), "R_andom", G_CALLBACK(action), ACTION_TYPE_TO_GPOINTER(ACTION_RANDOM));

	/* action: Repeat */
	menu_add_entry(GTK_CONTAINER(menu), "R_epeat", G_CALLBACK(action), ACTION_TYPE_TO_GPOINTER(ACTION_REPEAT));

	/* action: Xfade */
	menu_add_entry(GTK_CONTAINER(menu), "_Xfade", G_CALLBACK(action), ACTION_TYPE_TO_GPOINTER(ACTION_XFADE));

	/* item: Help */
	menu_item = gtk_menu_item_new_with_mnemonic ("_Help");
	gtk_container_add(GTK_CONTAINER(menubar), menu_item);

	/* create menubox for the item */
	menu = gtk_menu_new ();
  	gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), menu);

	/* action: log window */
//	menu_add_entry(GTK_CONTAINER(menu), "_Log window", G_CALLBACK(open_log_window), NULL);

	/* action: separator */
	menu_add_separator(GTK_CONTAINER(menu));

	/* action: About */
	menu_add_entry(GTK_CONTAINER(menu), "_About", G_CALLBACK(open_about_dialog), NULL);


	gtk_widget_show_all(menubar);

	menu_entries = NULL;
	menu_entries = g_list_append(menu_entries, menu_entry_play);
	menu_entries = g_list_append(menu_entries, menu_entry_pause);
	menu_entries = g_list_append(menu_entries, menu_entry_conn);
	menu_entries = g_list_append(menu_entries, menu_entry_disconn);

	return menubar;
}
Пример #8
0
GtkUIManager *
gl_ui_new (glWindow *window)
{
	GtkUIManager            *ui;
	GtkActionGroup          *actions;
	GError                  *error = NULL;
	GtkWidget               *recent_menu;

	gl_debug (DEBUG_UI, "START");

	g_return_val_if_fail (window && GL_IS_WINDOW (window), NULL);

	gl_debug (DEBUG_UI, "window = %p", window);

	ui = gtk_ui_manager_new ();

	g_signal_connect (ui, "connect_proxy",
			  G_CALLBACK (connect_proxy_cb), window);
	g_signal_connect (ui, "disconnect_proxy",
			  G_CALLBACK (disconnect_proxy_cb), window);

	actions = gtk_action_group_new ("Actions");
        gtk_action_group_set_translation_domain (actions, NULL);
	gtk_action_group_add_actions (actions, entries, n_entries, GTK_WINDOW (window));
	gtk_action_group_add_toggle_actions (actions, 
					     toggle_entries, n_toggle_entries, 
					     window);
	gtk_action_group_add_toggle_actions (actions, 
					     ui_toggle_entries, n_ui_toggle_entries, 
					     ui);

	gtk_ui_manager_insert_action_group (ui, actions, 0);
	gtk_window_add_accel_group (GTK_WINDOW (window), gtk_ui_manager_get_accel_group (ui));

	gl_debug (DEBUG_UI, "Creating ui from string");
	if (!gtk_ui_manager_add_ui_from_string (ui, ui_info, strlen (ui_info), &error)) {
		g_message ("building menus failed: %s", error->message);
		g_error_free (error);
	}

	/* Set the toolbar styles according to prefs */
	set_app_main_toolbar_style (ui);
	set_app_drawing_toolbar_style (ui);
		
	/* Set view grid and markup visibility according to prefs */
	set_view_style (ui);
		
	/* add an Open Recents Submenu */
        recent_menu  = gl_recent_create_menu ();
	g_signal_connect (G_OBJECT (recent_menu), "item-activated",
			  G_CALLBACK (gl_ui_cmd_file_open_recent), window);
	gtk_menu_item_set_submenu (GTK_MENU_ITEM (gtk_ui_manager_get_widget (ui, "/MenuBar/FileMenu/FileRecentsMenu")),
				   recent_menu);


        set_additional_properties (ui);

	gl_ui_util_set_verb_list_sensitive (ui, doc_verbs, FALSE);
	gl_ui_util_set_verb_list_sensitive (ui, paste_verbs, FALSE);

	gl_debug (DEBUG_UI, "END");

	return ui;
}
Пример #9
0
int main(int argc, char *argv[] ) {
    
	int i;
	char track_text[4];


        gtk_init (&argc, &argv);


        
        id3win=gtk_window_new(GTK_WINDOW_TOPLEVEL);
        gtk_window_set_title(GTK_WINDOW(id3win),"MP3info - An ID3 tag editor");
        gtk_window_set_policy (GTK_WINDOW(id3win), FALSE,FALSE,FALSE);
        gtk_widget_set_usize(id3win,450,360);
        gtk_container_border_width(GTK_CONTAINER(id3win),5);
        gtk_signal_connect(GTK_OBJECT(id3win), "delete_event", (GtkSignalFunc) gtk_exit, NULL);
        id3win_frame_global=gtk_vbox_new(FALSE,5);

	/* rmcc was here */

	id3win_menu_bar = gtk_menu_bar_new();
	gtk_widget_show(id3win_menu_bar);
	gtk_box_pack_start(GTK_BOX(id3win_frame_global), id3win_menu_bar, FALSE, TRUE, 1);

	id3win_menu_file = gtk_menu_item_new_with_label("File");
	gtk_widget_show(id3win_menu_file);
	gtk_container_add(GTK_CONTAINER(id3win_menu_bar), id3win_menu_file);
	id3win_menu_fcont = gtk_menu_new();
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(id3win_menu_file), id3win_menu_fcont);

	id3win_menu_open = gtk_menu_item_new_with_label("Open New    ");
	gtk_widget_show(id3win_menu_open);
	gtk_container_add(GTK_CONTAINER(id3win_menu_fcont), id3win_menu_open);
	gtk_signal_connect(GTK_OBJECT(id3win_menu_open), "activate",
	                   GTK_SIGNAL_FUNC(open_mp3_file),
	                   NULL);

	id3win_menu_info = gtk_menu_item_new_with_label("Info        ");
	gtk_widget_show(id3win_menu_info);
	gtk_container_add(GTK_CONTAINER(id3win_menu_fcont), id3win_menu_info);
	gtk_signal_connect(GTK_OBJECT(id3win_menu_info), "activate",
	                   GTK_SIGNAL_FUNC(create_techinfo_win),
	                   NULL);

	id3win_menu_help = gtk_menu_item_new_with_label("      Help");
	gtk_widget_show(id3win_menu_help);
	gtk_container_add(GTK_CONTAINER(id3win_menu_bar), id3win_menu_help);
	gtk_menu_item_right_justify(GTK_MENU_ITEM(id3win_menu_help));
	id3win_menu_hcont = gtk_menu_new();
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(id3win_menu_help), id3win_menu_hcont);

	id3win_menu_about = gtk_menu_item_new_with_label("About    ");
	gtk_widget_show(id3win_menu_about);
	gtk_container_add(GTK_CONTAINER(id3win_menu_hcont), id3win_menu_about);
	gtk_signal_connect(GTK_OBJECT(id3win_menu_about), "activate",
	                   GTK_SIGNAL_FUNC(about_mp3info),
	                   NULL);


	/* rmcc has left the building */
        
        id3win_frame_title=gtk_frame_new("Title");
        gtk_container_border_width(GTK_CONTAINER(id3win_frame_title),5);
        id3win_text_title=gtk_entry_new_with_max_length(30);
        gtk_container_add(GTK_CONTAINER(id3win_frame_title),id3win_text_title);
        gtk_box_pack_start(GTK_BOX(id3win_frame_global),id3win_frame_title,TRUE,TRUE,0);
        
        id3win_frame_artist=gtk_frame_new("Artist");
        gtk_container_border_width(GTK_CONTAINER(id3win_frame_artist),5);
        id3win_text_artist=gtk_entry_new_with_max_length(30);
        gtk_container_add(GTK_CONTAINER(id3win_frame_artist),id3win_text_artist);
        gtk_box_pack_start(GTK_BOX(id3win_frame_global),id3win_frame_artist,TRUE,TRUE,0);
        
        id3win_frame_albyear=gtk_hbox_new(FALSE,30);
        id3win_frame_album=gtk_frame_new("Album");
        gtk_container_border_width(GTK_CONTAINER(id3win_frame_album),5);
        id3win_text_album=gtk_entry_new_with_max_length(30);
        gtk_container_add(GTK_CONTAINER(id3win_frame_album),id3win_text_album);
        gtk_box_pack_start(GTK_BOX(id3win_frame_albyear),id3win_frame_album,TRUE,TRUE,0);
        
        id3win_frame_year=gtk_frame_new("Year");
        gtk_widget_set_usize(id3win_frame_year,2,0);
        gtk_container_border_width(GTK_CONTAINER(id3win_frame_year),5);
        id3win_text_year=gtk_entry_new_with_max_length(4);
        gtk_container_add(GTK_CONTAINER(id3win_frame_year),id3win_text_year);
        gtk_box_pack_start(GTK_BOX(id3win_frame_albyear),id3win_frame_year,TRUE,TRUE,0);
        gtk_box_pack_start(GTK_BOX(id3win_frame_global),id3win_frame_albyear,TRUE,TRUE,0);
        
        id3win_frame_comtrack=gtk_hbox_new(FALSE,30);
        id3win_frame_comment=gtk_frame_new("Comment");
        gtk_container_border_width(GTK_CONTAINER(id3win_frame_comment),5);
        id3win_text_comment=gtk_entry_new_with_max_length(30);
        gtk_container_add(GTK_CONTAINER(id3win_frame_comment),id3win_text_comment);
        gtk_box_pack_start(GTK_BOX(id3win_frame_comtrack),id3win_frame_comment,TRUE,TRUE,0);
        
        id3win_frame_track=gtk_frame_new("Track");
        gtk_widget_set_usize(id3win_frame_track,2,0);
        gtk_container_border_width(GTK_CONTAINER(id3win_frame_track),5);
        id3win_text_track=gtk_entry_new_with_max_length(3);
        gtk_container_add(GTK_CONTAINER(id3win_frame_track),id3win_text_track);
        gtk_box_pack_start(GTK_BOX(id3win_frame_comtrack),id3win_frame_track,TRUE,TRUE,0);
        gtk_box_pack_start(GTK_BOX(id3win_frame_global),id3win_frame_comtrack,TRUE,TRUE,0);
        
        id3win_frame_genre=gtk_frame_new("Genre");
        gtk_container_border_width(GTK_CONTAINER(id3win_frame_genre),5);
        id3win_combo_genre=gtk_combo_new();
        for(i=0;i<MAXGENRE+2;i++) {
        	genrelist = g_list_append(genrelist, typegenre[galphagenreindex[i]]);
        }
        gtk_combo_set_popdown_strings(GTK_COMBO(id3win_combo_genre),genrelist);
        gtk_container_add(GTK_CONTAINER(id3win_frame_genre),id3win_combo_genre);
        gtk_box_pack_start(GTK_BOX(id3win_frame_global),id3win_frame_genre,TRUE,TRUE,0);
        
        id3win_frame_buttons=gtk_hbox_new(TRUE,30);
        id3win_ok_button=gtk_button_new_with_label("OK");
        gtk_box_pack_start(GTK_BOX(id3win_frame_buttons),id3win_ok_button,TRUE,TRUE,0);
	if(read_only) {
	  gtk_widget_set_sensitive (id3win_text_title, FALSE);
	  gtk_widget_set_sensitive (id3win_text_artist, FALSE);
	  gtk_widget_set_sensitive (id3win_text_album, FALSE);
	  gtk_widget_set_sensitive (id3win_text_year, FALSE);
	  gtk_widget_set_sensitive (id3win_text_comment, FALSE);
	  gtk_widget_set_sensitive (id3win_text_track, FALSE);
	  gtk_widget_set_sensitive (id3win_combo_genre, FALSE);	
	} else {
	        id3win_cancel_button=gtk_button_new_with_label("Cancel");
        	gtk_box_pack_start(GTK_BOX(id3win_frame_buttons),id3win_cancel_button,TRUE,TRUE,0);
	        gtk_signal_connect (GTK_OBJECT (id3win_cancel_button), "clicked", GTK_SIGNAL_FUNC (gtk_exit), NULL);
        }

        gtk_widget_set_usize(id3win_frame_buttons,30,20);
        gtk_box_pack_start(GTK_BOX(id3win_frame_global),id3win_frame_buttons,TRUE,TRUE,0);
        
        gtk_container_add(GTK_CONTAINER(id3win),id3win_frame_global);
        
        gtk_signal_connect (GTK_OBJECT (id3win_ok_button), "clicked", GTK_SIGNAL_FUNC (exit_save), NULL);
        
        gtk_widget_show_all(id3win);
        
	memset(&mp3,0,sizeof(mp3info));

	if(argc==2) { 
	   if (! load_mp3(argv[1])) {
		exit(0);
	   }
           gtk_entry_set_text(GTK_ENTRY(id3win_text_title),mp3.id3.title);
           gtk_entry_set_text(GTK_ENTRY(id3win_text_artist),mp3.id3.artist);
           gtk_entry_set_text(GTK_ENTRY(id3win_text_album),mp3.id3.album);
           gtk_entry_set_text(GTK_ENTRY(id3win_text_year),mp3.id3.year);
           gtk_entry_set_text(GTK_ENTRY(id3win_text_comment),mp3.id3.comment);
	   if(mp3.id3.track[0] > 0)
		sprintf(track_text,"%d",(int)mp3.id3.track[0]);
	   else
		track_text[0]=0;
	   gtk_entry_set_text(GTK_ENTRY(id3win_text_track),track_text);
           gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(id3win_combo_genre)->entry), gtext_genre(mp3.id3.genre[0]));
    
	} else {
	   open_mp3_file();
	}

        gtk_main();
	return(0);
			
}
Пример #10
0
static void
create_colors (void)
{
   static GtkWidget *window = NULL;
   GtkWidget *box1 = NULL;
   GtkWidget *box2 = NULL;
   GtkWidget *close_button = NULL;
   GtkWidget *box = NULL;
   GtkWidget *separator;
   GtkWidget *label;
   GtkWidget *menu;
   GtkWidget *root_menu;
   GtkWidget *menu_bar;
   gfloat *X = NULL;
   gfloat *Y = NULL;
   gint i, j;
   GdkColor color;
   GtkDataboxGraph *graph;

   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
   gtk_widget_set_size_request (window, 500, 300);

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

   gtk_window_set_title (GTK_WINDOW (window), "GtkDatabox: Colors");
   gtk_container_set_border_width (GTK_CONTAINER (window), 0);

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

   box = gtk_databox_new ();
   gtk_databox_set_enable_selection (GTK_DATABOX (box), FALSE);
   gtk_databox_set_enable_zoom (GTK_DATABOX (box), FALSE);

   color.red = 0;
   color.green = 0;
   color.blue = 0;
   gtk_widget_modify_bg (box, GTK_STATE_NORMAL, &color);

   menu = gtk_menu_new ();
   root_menu = gtk_menu_item_new_with_label ("Color Menu");
   gtk_menu_item_set_submenu (GTK_MENU_ITEM (root_menu), menu);
   menu_bar = gtk_menu_bar_new ();
   gtk_menu_shell_append (GTK_MENU_SHELL (menu_bar), root_menu);
   gtk_box_pack_start (GTK_BOX (box1), menu_bar, FALSE, TRUE, 0);


   label =
      gtk_label_new
      ("You can change the colors of the shown datasets via the menu.\n\n");
   gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
   separator = gtk_hseparator_new ();
   gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, FALSE, 0);

   g_signal_connect (G_OBJECT (box), "destroy",
		     G_CALLBACK (gtk_main_quit), NULL);


   for (i = 0; i < NO_OF_DATASETS; i++)
   {
      if (!i)
	 X = g_new0 (gfloat, POINTS);
      Y = g_new0 (gfloat, POINTS);
      for (j = 0; j < POINTS; j++)
      {
	 X[j] = j;
	 Y[j] = 100. * sin ((i + 1) * 2 * j * G_PI / POINTS);
      }
      color.red = 65535 * ((i + 1) % 2);
      color.green = (65535 / 2) * ((i + 1) % 3);
      color.blue = (65535 / 3) * ((i + 1) % 4);
      graph = gtk_databox_points_new (POINTS, X, Y, &color, 1);
      gtk_databox_graph_add (GTK_DATABOX (box), graph);
      create_menu_entry (menu, i, box, graph);
   }

   gtk_databox_auto_rescale (GTK_DATABOX (box), 0.05);

   gtk_box_pack_start (GTK_BOX (box1), box, TRUE, TRUE, 0);

   separator = gtk_hseparator_new ();
   gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);

   box2 = gtk_vbox_new (FALSE, 10);
   gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
   gtk_box_pack_end (GTK_BOX (box1), box2, FALSE, TRUE, 0);
   close_button = gtk_button_new_with_label ("close");
   g_signal_connect (G_OBJECT (close_button), "clicked",
		     G_CALLBACK (gtk_main_quit), (gpointer) NULL);
   gtk_box_pack_start (GTK_BOX (box2), close_button, TRUE, TRUE, 0);
   GTK_WIDGET_SET_FLAGS (close_button, GTK_CAN_DEFAULT);
   gtk_widget_grab_default (close_button);





   gtk_widget_show_all (window);

}
Пример #11
0
void open_mainwindow ()
{
	mainwin = gtk_window_new (GTK_WINDOW_TOPLEVEL);
	gtk_window_set_position(GTK_WINDOW(mainwin), GTK_WIN_POS_CENTER);
  	gtk_window_set_default_size(GTK_WINDOW(mainwin), 250, 200);
  	gtk_window_set_title(GTK_WINDOW(mainwin), "Bakamoona v 0.1");
	gtk_window_set_icon(GTK_WINDOW(mainwin), create_pixbuf("images/bkm.png"));

	layout = gtk_vbox_new (FALSE, 0);
	gtk_container_add (GTK_CONTAINER (mainwin), layout);

	menubar = gtk_menu_bar_new ();

/*
  System | Maintenance | Finance | Search | Statistics | About
*/

    // System
    sysmenu = gtk_menu_new();
    sys_menu_item = gtk_menu_item_new_with_label ("System");
    gtk_menu_item_set_submenu (GTK_MENU_ITEM(sys_menu_item), sysmenu);

    // adding bus
    bus_item = gtk_menu_item_new_with_label ("Bus");
    gtk_menu_shell_append (GTK_MENU_SHELL(sysmenu), bus_item);

    busmenu = gtk_menu_new ();
    gtk_menu_item_set_submenu (GTK_MENU_ITEM(bus_item), busmenu);

    addbus = gtk_menu_item_new_with_label ("Add Bus");
    updatebus = gtk_menu_item_new_with_label ("Update Bus");
    deletebus = gtk_menu_item_new_with_label ("Delete Bus");

    gtk_menu_shell_append (GTK_MENU_SHELL(busmenu), addbus);
    gtk_menu_shell_append (GTK_MENU_SHELL(busmenu), updatebus);
    gtk_menu_shell_append (GTK_MENU_SHELL(busmenu), deletebus);

    // adding owner
    owner_item = gtk_menu_item_new_with_label ("Owner");
    gtk_menu_shell_append (GTK_MENU_SHELL(sysmenu), owner_item);

    ownermenu = gtk_menu_new ();
    gtk_menu_item_set_submenu (GTK_MENU_ITEM(owner_item), ownermenu);

    addowner = gtk_menu_item_new_with_label ("Add Owner");
    updateowner = gtk_menu_item_new_with_label ("Update Owner");
    deleteowner = gtk_menu_item_new_with_label ("Delete Owner");

    gtk_menu_shell_append (GTK_MENU_SHELL(ownermenu), addowner);
    gtk_menu_shell_append (GTK_MENU_SHELL(ownermenu), updateowner);
    gtk_menu_shell_append (GTK_MENU_SHELL(ownermenu), deleteowner);

    // adding sparepart 
    sp_item = gtk_menu_item_new_with_label ("Spare Part");
    gtk_menu_shell_append (GTK_MENU_SHELL(sysmenu), sp_item);

    spmenu = gtk_menu_new ();
    gtk_menu_item_set_submenu (GTK_MENU_ITEM(sp_item), spmenu);

    addsp = gtk_menu_item_new_with_label ("Add Spare Part");
    updatesp = gtk_menu_item_new_with_label ("Update Spare Part");
    deletesp = gtk_menu_item_new_with_label ("Delete Spare Part");

    gtk_menu_shell_append (GTK_MENU_SHELL(spmenu), addsp);
    gtk_menu_shell_append (GTK_MENU_SHELL(spmenu), updatesp);
    gtk_menu_shell_append (GTK_MENU_SHELL(spmenu), deletesp);
    
    // adding worker
    worker_item = gtk_menu_item_new_with_label ("Worker");
    gtk_menu_shell_append (GTK_MENU_SHELL(sysmenu), worker_item);

    workermenu = gtk_menu_new ();
    gtk_menu_item_set_submenu (GTK_MENU_ITEM(worker_item), workermenu);

    addworker = gtk_menu_item_new_with_label ("Add Worker");
    updateworker = gtk_menu_item_new_with_label ("Update Worker");
    deleteworker = gtk_menu_item_new_with_label ("Delete Worker");

    gtk_menu_shell_append (GTK_MENU_SHELL(workermenu), addworker);
    gtk_menu_shell_append (GTK_MENU_SHELL(workermenu), updateworker);
    gtk_menu_shell_append (GTK_MENU_SHELL(workermenu), deleteworker);
    
    // adding packages
    package_item = gtk_menu_item_new_with_label ("Package");
    gtk_menu_shell_append (GTK_MENU_SHELL(sysmenu), package_item);

    packagemenu = gtk_menu_new ();
    gtk_menu_item_set_submenu (GTK_MENU_ITEM(package_item), packagemenu);

    addpackage = gtk_menu_item_new_with_label ("Add Package");
    updatepackage = gtk_menu_item_new_with_label ("Update Package");
    deletepackage = gtk_menu_item_new_with_label ("Delete Package");

    gtk_menu_shell_append (GTK_MENU_SHELL(packagemenu), addpackage);
    gtk_menu_shell_append (GTK_MENU_SHELL(packagemenu), updatepackage);
    gtk_menu_shell_append (GTK_MENU_SHELL(packagemenu), deletepackage);

	sep = gtk_separator_menu_item_new();
    quit = gtk_menu_item_new_with_label("Quit");

    gtk_menu_shell_append (GTK_MENU_SHELL(sysmenu), sep);
    gtk_menu_shell_append (GTK_MENU_SHELL(sysmenu), quit);
        
    gtk_menu_shell_append (GTK_MENU_SHELL(menubar), sys_menu_item);

	mntmenu = gtk_menu_new();
    mnt_menu_item = gtk_menu_item_new_with_label ("Maintenance");
    gtk_menu_item_set_submenu (GTK_MENU_ITEM(mnt_menu_item), mntmenu);

	gtk_menu_shell_append (GTK_MENU_SHELL(menubar), mnt_menu_item);

	addmnt = gtk_menu_item_new_with_label ("Add Maintenance");
    updatemnt = gtk_menu_item_new_with_label ("Update Maintenance");

	gtk_menu_shell_append (GTK_MENU_SHELL(mntmenu), addmnt);
	gtk_menu_shell_append (GTK_MENU_SHELL(mntmenu), updatemnt);

	//

	finmenu = gtk_menu_new();
    fin_menu_item = gtk_menu_item_new_with_label ("Finance");
    gtk_menu_item_set_submenu (GTK_MENU_ITEM(fin_menu_item), finmenu);

	gtk_menu_shell_append (GTK_MENU_SHELL(menubar), fin_menu_item);

	addfin = gtk_menu_item_new_with_label ("Add Bill");
    updatefin = gtk_menu_item_new_with_label ("Update Bill");

	gtk_menu_shell_append (GTK_MENU_SHELL(finmenu), addfin);
	gtk_menu_shell_append (GTK_MENU_SHELL(finmenu), updatefin);
	
	//

	searchmenu = gtk_menu_new();
    search_menu_item = gtk_menu_item_new_with_label ("Search");
    gtk_menu_item_set_submenu (GTK_MENU_ITEM(search_menu_item), searchmenu);

	gtk_menu_shell_append (GTK_MENU_SHELL(menubar), search_menu_item);

	search_bus = gtk_menu_item_new_with_label ("Bus");
	search_own = gtk_menu_item_new_with_label ("Owner");
	search_worker = gtk_menu_item_new_with_label ("Worker");
	search_sp = gtk_menu_item_new_with_label ("Spare Part");
	search_bill = gtk_menu_item_new_with_label ("Bill");
	search_mnt = gtk_menu_item_new_with_label ("Maintenance");
	
	gtk_menu_shell_append (GTK_MENU_SHELL(searchmenu), search_bus);
	gtk_menu_shell_append (GTK_MENU_SHELL(searchmenu), search_own);
	gtk_menu_shell_append (GTK_MENU_SHELL(searchmenu), search_worker);
	gtk_menu_shell_append (GTK_MENU_SHELL(searchmenu), search_sp);
	gtk_menu_shell_append (GTK_MENU_SHELL(searchmenu), search_bill);
	gtk_menu_shell_append (GTK_MENU_SHELL(searchmenu), search_mnt);

	//

	aboutmenu = gtk_menu_new();
    about_menu_item = gtk_menu_item_new_with_label ("About");
    gtk_menu_item_set_submenu (GTK_MENU_ITEM(about_menu_item), aboutmenu);

	gtk_menu_shell_append (GTK_MENU_SHELL(menubar), about_menu_item);
	
	devteam = gtk_menu_item_new_with_label ("About DEV team");
	gtk_menu_shell_append (GTK_MENU_SHELL(aboutmenu), devteam);

// end

  	gtk_box_pack_start (GTK_BOX(layout), menubar, FALSE, FALSE, 0);

	toolbar = gtk_toolbar_new();
 	gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);
	gtk_container_set_border_width(GTK_CONTAINER(toolbar), 0);

	quit_tool = gtk_tool_button_new_from_stock (GTK_STOCK_QUIT);
	gtk_toolbar_insert (GTK_TOOLBAR(toolbar), quit_tool, -1);

	new_tool = gtk_tool_button_new_from_stock(GTK_STOCK_NEW);
  	gtk_toolbar_insert (GTK_TOOLBAR(toolbar), new_tool, -1);

	open_tool = gtk_tool_button_new_from_stock(GTK_STOCK_OPEN);
  	gtk_toolbar_insert (GTK_TOOLBAR(toolbar), open_tool, -1);

	save_tool = gtk_tool_button_new_from_stock(GTK_STOCK_SAVE);
  	gtk_toolbar_insert (GTK_TOOLBAR(toolbar), save_tool, -1);

	gtk_box_pack_start (GTK_BOX(layout), toolbar, FALSE, FALSE, 0);

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

	g_signal_connect(G_OBJECT(addbus), "activate",
        G_CALLBACK(add_bus_clicked), NULL);
    g_signal_connect(G_OBJECT(addworker), "activate",
        G_CALLBACK(add_worker_clicked), NULL);
	g_signal_connect(G_OBJECT(addowner), "activate",
        G_CALLBACK(add_owner_clicked), NULL);
	g_signal_connect(G_OBJECT(addsp), "activate",
        G_CALLBACK(add_sparepart_clicked), NULL);
  	g_signal_connect(G_OBJECT(quit), "activate",
        G_CALLBACK(gtk_main_quit), NULL);
	g_signal_connect(G_OBJECT(addmnt), "activate",
        G_CALLBACK(add_maintenance_clicked), NULL);

        g_signal_connect(G_OBJECT(addfin), "activate",
        G_CALLBACK(add_bill_clicked), NULL);

        g_signal_connect(G_OBJECT(addpackage), "activate",
        G_CALLBACK(add_package_clicked), NULL);

	gtk_window_maximize (GTK_WINDOW(mainwin));
  	gtk_widget_show_all(mainwin);

}
Пример #12
0
/**
 * main routine, parses args and reads from console
 */
int main(int argc, char *argv[])
{
	GtkWidget *menubar, *menu, *menuitem, *vbox;
	GtkWidget *dummMenu, *guestMenu, *switchMenu;
	enumerator_t *enumerator;
	guest_t *guest;

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

	pages = linked_list_create();
	dumm = dumm_create(NULL);

	/* setup window */
	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(quit), NULL);
	gtk_window_set_title(GTK_WINDOW (window), "Dumm");
	gtk_window_set_default_size(GTK_WINDOW (window), 1000, 500);
	g_signal_connect(G_OBJECT(vte_reaper_get()), "child-exited",
					 G_CALLBACK(child_exited), NULL);

	/* add vbox with menubar, notebook */
	vbox = gtk_vbox_new(FALSE, 0);
	gtk_container_add(GTK_CONTAINER(window), vbox);
	menubar = gtk_menu_bar_new();
	gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, TRUE, 0);
	notebook = gtk_notebook_new();
	g_object_set(G_OBJECT(notebook), "homogeneous", TRUE, NULL);
	gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), GTK_POS_BOTTOM);
	gtk_container_add(GTK_CONTAINER(vbox), notebook);

	/* Dumm menu */
	menu = gtk_menu_new();
	dummMenu = gtk_menu_item_new_with_mnemonic("_Dumm");
	gtk_menu_bar_append(GTK_MENU_BAR(menubar), dummMenu);
	gtk_widget_show(dummMenu);
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(dummMenu), menu);

	/* Dumm -> exit */
	menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, NULL);
	g_signal_connect(G_OBJECT(menuitem), "activate",
					 G_CALLBACK(quit), NULL);
	gtk_menu_append(GTK_MENU(menu), menuitem);
	gtk_widget_show(menuitem);

	/* Guest menu */
	menu = gtk_menu_new();
	guestMenu = gtk_menu_item_new_with_mnemonic("_Guest");
	gtk_menu_bar_append(GTK_MENU_BAR(menubar), guestMenu);
	gtk_widget_show(guestMenu);
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(guestMenu), menu);

	/* Guest -> new */
	menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_NEW, NULL);
	g_signal_connect(G_OBJECT(menuitem), "activate",
					 G_CALLBACK(create_guest), NULL);
	gtk_menu_append(GTK_MENU(menu), menuitem);
	gtk_widget_show(menuitem);

	/* Guest -> delete */
	menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_DELETE, NULL);
	g_signal_connect(G_OBJECT(menuitem), "activate",
					 G_CALLBACK(delete_guest), NULL);
	gtk_menu_append(GTK_MENU(menu), menuitem);
	gtk_widget_show(menuitem);

	menuitem = gtk_separator_menu_item_new();
	gtk_menu_append(GTK_MENU(menu), menuitem);
	gtk_widget_show(menuitem);

	/* Guest -> start */
	menuitem = gtk_menu_item_new_with_mnemonic("_Start");
	g_signal_connect(G_OBJECT(menuitem), "activate",
					 G_CALLBACK(start_guest), NULL);
	gtk_menu_append(GTK_MENU(menu), menuitem);
	gtk_widget_show(menuitem);

	/* Guest -> startall */
	menuitem = gtk_menu_item_new_with_mnemonic("Start _all");
	g_signal_connect(G_OBJECT(menuitem), "activate",
					 G_CALLBACK(start_all_guests), NULL);
	gtk_menu_append(GTK_MENU(menu), menuitem);
	gtk_widget_show(menuitem);

	/* Guest -> stop */
	menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_STOP, NULL);
	g_signal_connect(G_OBJECT(menuitem), "activate",
					 G_CALLBACK(stop_guest), NULL);
	gtk_menu_append(GTK_MENU(menu), menuitem);
	gtk_widget_show(menuitem);

	menuitem = gtk_separator_menu_item_new();
	gtk_menu_append(GTK_MENU(menu), menuitem);
	gtk_widget_show(menuitem);

	/* Guest -> connect */
	menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_CONNECT, NULL);
	g_signal_connect(G_OBJECT(menuitem), "activate",
					 G_CALLBACK(connect_guest), NULL);
	gtk_menu_append(GTK_MENU(menu), menuitem);
	gtk_widget_show(menuitem);

	/* Guest -> disconnect */
	menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_DISCONNECT, NULL);
	g_signal_connect(G_OBJECT(menuitem), "activate",
					 G_CALLBACK(disconnect_guest), NULL);
	gtk_menu_append(GTK_MENU(menu), menuitem);
	gtk_widget_set_sensitive(menuitem, FALSE);
	gtk_widget_show(menuitem);

	/* Switch menu */
	menu = gtk_menu_new();
	switchMenu = gtk_menu_item_new_with_mnemonic("_Switch");
	gtk_menu_bar_append(GTK_MENU_BAR(menubar), switchMenu);
	gtk_widget_show(switchMenu);
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(switchMenu), menu);

	/* Switch -> new */
	menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_NEW, NULL);
	g_signal_connect(G_OBJECT(menuitem), "activate",
					 G_CALLBACK(create_switch), NULL);
	gtk_menu_append(GTK_MENU(menu), menuitem);
	gtk_widget_show(menuitem);

	/* Switch -> delete */
	menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_DELETE, NULL);
	g_signal_connect(G_OBJECT(menuitem), "activate",
					 G_CALLBACK(delete_switch), NULL);
	gtk_menu_append(GTK_MENU(menu), menuitem);
	gtk_widget_set_sensitive(menuitem, FALSE);
	gtk_widget_show(menuitem);

	/* show widgets */
	gtk_widget_show(menubar);
	gtk_widget_show(notebook);
	gtk_widget_show(vbox);
	gtk_widget_show(window);

	/* fill notebook with guests */
	enumerator = dumm->create_guest_enumerator(dumm);
	while (enumerator->enumerate(enumerator, (void**)&guest))
	{
		create_page(guest);
	}
	enumerator->destroy(enumerator);

	gtk_main();

	dumm->destroy(dumm);
	pages->destroy_function(pages, g_free);

	library_deinit();
	return 0;
}
Пример #13
0
int main (int argc, char *argv[])
{
    /* Vars */
    GtkWidget *vbox;
    GtkWidget *window;
    GtkWidget *table;
    GtkWidget *label;
    GtkWidget *entry;
    GtkWidget *button;
    GtkWidget* scrolled;
    GtkWidget *menubar;
    GtkWidget *filemenu;
    GtkWidget *file;
    GtkWidget *quit;
    GtkWidget *reindexer;
    
    /* Set default directory to index */
    indexdir = ".";
    
    /* Run the indexer */
    reindex(NULL, NULL);
    
    /* Create the search objects */
    createSearch();

    /* Make the GUI */
    gtk_init(&argc, &argv);

    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    initialize_window(window);

    /* Create a 10x5 table */
    table = gtk_table_new (10, 5, FALSE);
    gtk_container_add (GTK_CONTAINER (window), table);

    /* create a new label. */
    label = gtk_label_new ("Search Terms:" );

    gtk_table_set_homogeneous(GTK_TABLE (table), TRUE);
    gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 1, 2);

    entry = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (entry),1000);
    gtk_table_attach_defaults (GTK_TABLE (table), entry, 1, 3, 1, 2);
    
    button = gtk_button_new_with_label ("OR Search");
    gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (orsearch), (gpointer) entry);
    gtk_table_attach_defaults (GTK_TABLE (table), button, 3, 4, 1, 2);
    
    button = gtk_button_new_with_label ("AND Search");
    gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (andsearch), (gpointer) entry);
    gtk_table_attach_defaults (GTK_TABLE (table), button, 4, 5, 1, 2);
    
    textview  = gtk_text_view_new();
    gtk_text_view_set_editable( GTK_TEXT_VIEW (textview), 0);
    gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (textview), 0);
    scrolled = gtk_scrolled_window_new(NULL, NULL);
    gtk_container_add (GTK_CONTAINER (scrolled), textview);
    gtk_table_attach_defaults (GTK_TABLE (table), scrolled, 0, 5, 2, 10);


    vbox = gtk_vbox_new(FALSE, 0);
    gtk_table_attach_defaults (GTK_TABLE (table), vbox, 0, 5, 0, 1);

    menubar = gtk_menu_bar_new();
    filemenu = gtk_menu_new();

    file = gtk_menu_item_new_with_label("File");
    reindexer = gtk_menu_item_new_with_label("Reindex");
    gtk_signal_connect (GTK_OBJECT (reindexer), "activate", G_CALLBACK(reindex), NULL);
    quit = gtk_menu_item_new_with_label("Quit");
    gtk_signal_connect (GTK_OBJECT (quit), "activate", G_CALLBACK(destroy), NULL);

    gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), filemenu);
    gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), reindexer);
    gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), quit);
    gtk_menu_shell_append(GTK_MENU_SHELL(menubar), file);
    gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 3);


    gtk_widget_show_all(window);

    gtk_main ();
    return 0;
}
Пример #14
0
static void bar_pane_keywords_menu_popup(GtkWidget *widget, PaneKeywordsData *pkd, gint x, gint y)
{
	GtkWidget *menu;
	GtkWidget *item;
	GtkWidget *submenu;
        GtkTreeViewDropPosition pos;

        if (pkd->click_tpath) gtk_tree_path_free(pkd->click_tpath);
        pkd->click_tpath = NULL;
	gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(pkd->keyword_treeview), x, y, &pkd->click_tpath, &pos);

	menu = popup_menu_short_lived();

	menu_item_add_stock(menu, _("Add keyword"), GTK_STOCK_EDIT, G_CALLBACK(bar_pane_keywords_add_dialog_cb), pkd);

	menu_item_add_divider(menu);

	menu_item_add(menu, _("Add keyword to all selected images"), G_CALLBACK(bar_pane_keywords_add_to_selected_cb), pkd);

	menu_item_add_divider(menu);

	if (pkd->click_tpath)
		{
		/* for the entry */
		gchar *text;
		gchar *mark;
		gint i;

		GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));

		GtkTreeIter iter;
                gtk_tree_model_get_iter(model, &iter, pkd->click_tpath);
		gchar *name;

		gtk_tree_model_get(model, &iter, FILTER_KEYWORD_COLUMN_NAME, &name,
						 FILTER_KEYWORD_COLUMN_MARK, &mark, -1);

		text = g_strdup_printf(_("Hide \"%s\""), name);
		menu_item_add_stock(menu, text, GTK_STOCK_EDIT, G_CALLBACK(bar_pane_keywords_hide_cb), pkd);
		g_free(text);

		submenu = gtk_menu_new();
		for (i = 0; i < FILEDATA_MARKS_SIZE; i++)
			{
			text = g_strdup_printf(_("Mark %d"), i + 1);
			item = menu_item_add(submenu, text, G_CALLBACK(bar_pane_keywords_connect_mark_cb), pkd);
			g_object_set_data(G_OBJECT(item), "mark", GINT_TO_POINTER(i + 1));
			g_free(text);
			}
		text = g_strdup_printf(_("Connect \"%s\" to mark"), name);
		item = menu_item_add(menu, text, NULL, NULL);
		gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
		g_free(text);

		menu_item_add_divider(menu);

		text = g_strdup_printf(_("Edit \"%s\""), name);
		menu_item_add_stock(menu, text, GTK_STOCK_EDIT, G_CALLBACK(bar_pane_keywords_edit_dialog_cb), pkd);
		g_free(text);
		text = g_strdup_printf(_("Remove \"%s\""), name);
		menu_item_add_stock(menu, text, GTK_STOCK_DELETE, G_CALLBACK(bar_pane_keywords_delete_cb), pkd);
		g_free(text);


		if (mark && mark[0])
			{
			text = g_strdup_printf(_("Disconnect \"%s\" from mark %s"), name, mark);
			menu_item_add_stock(menu, text, GTK_STOCK_DELETE, G_CALLBACK(bar_pane_keywords_connect_mark_cb), pkd);
			g_free(text);
			}

		menu_item_add_divider(menu);
		g_free(mark);
		g_free(name);
		}
	/* for the pane */


	menu_item_add(menu, _("Expand checked"), G_CALLBACK(bar_pane_keywords_expand_checked_cb), pkd);
	menu_item_add(menu, _("Collapse unchecked"), G_CALLBACK(bar_pane_keywords_collapse_unchecked_cb), pkd);
	menu_item_add(menu, _("Hide unchecked"), G_CALLBACK(bar_pane_keywords_hide_unchecked_cb), pkd);
	menu_item_add(menu, _("Show all"), G_CALLBACK(bar_pane_keywords_show_all_cb), pkd);

	submenu = gtk_menu_new();
	item = menu_item_add(menu, _("On any change"), NULL, NULL);
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);

	menu_item_add_check(submenu, _("Expand checked"), pkd->expand_checked, G_CALLBACK(bar_pane_keywords_expand_checked_toggle_cb), pkd);
	menu_item_add_check(submenu, _("Collapse unchecked"), pkd->collapse_unchecked, G_CALLBACK(bar_pane_keywords_collapse_unchecked_toggle_cb), pkd);
	menu_item_add_check(submenu, _("Hide unchecked"), pkd->hide_unchecked, G_CALLBACK(bar_pane_keywords_hide_unchecked_toggle_cb), pkd);

	gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, 0, GDK_CURRENT_TIME);
}
Пример #15
0
void sc_gui_update_editor_menu_cb(GObject *obj, const gchar *word, gint pos,
                                  GeanyDocument *doc, gpointer user_data)
{
    gchar *search_word;

    g_return_if_fail(doc != NULL && doc->is_valid);

    /* hide the submenu in any case, we will reshow it again if we actually found something */
    gtk_widget_hide(sc_info->edit_menu);
    gtk_widget_hide(sc_info->edit_menu_sep);

    if (! sc_info->show_editor_menu_item)
        return;

    /* if we have a selection, prefer it over the current word */
    if (sci_has_selection(doc->editor->sci))
    {
        gint len = sci_get_selected_text_length(doc->editor->sci);
        search_word = g_malloc(len + 1);
        sci_get_selected_text(doc->editor->sci, search_word);
    }
    else
        search_word = g_strdup(word);

    /* ignore numbers or words starting with digits and non-text */
    if (EMPTY(search_word) || isdigit(*search_word) || ! sc_speller_is_text(doc, pos))
    {
        g_free(search_word);
        return;
    }

    /* ignore too long search words */
    if (strlen(search_word) > 100)
    {
        GtkWidget *menu_item;

        init_editor_submenu();
        menu_item = gtk_menu_item_new_with_label(
                        _("Search term is too long to provide\nspelling suggestions in the editor menu."));
        gtk_widget_set_sensitive(menu_item, FALSE);
        gtk_widget_show(menu_item);
        gtk_container_add(GTK_CONTAINER(sc_info->edit_menu_sub), menu_item);

        menu_item = gtk_menu_item_new_with_label(_("Perform Spell Check"));
        gtk_widget_show(menu_item);
        gtk_container_add(GTK_CONTAINER(sc_info->edit_menu_sub), menu_item);
        g_signal_connect(menu_item, "activate", G_CALLBACK(perform_spell_check_cb), doc);

        g_free(search_word);
        return;
    }

    if (sc_speller_dict_check(search_word) != 0)
    {
        GtkWidget *menu_item, *menu;
        gchar *label;
        gsize n_suggs, i;
        gchar **suggs;

        suggs = sc_speller_dict_suggest(search_word, &n_suggs);

        clickinfo.pos = pos;
        clickinfo.doc = doc;
        setptr(clickinfo.word, search_word);

        menu = init_editor_submenu();

        for (i = 0; i < n_suggs; i++)
        {
            if (i > 0 && i % 10 == 0)
            {
                menu_item = gtk_menu_item_new();
                gtk_widget_show(menu_item);
                gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);

                menu_item = gtk_menu_item_new_with_label(_("More..."));
                gtk_widget_show(menu_item);
                gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);

                menu = gtk_menu_new();
                gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_item), menu);
            }
            menu_item = gtk_menu_item_new_with_label(suggs[i]);
            gtk_widget_show(menu_item);
            gtk_container_add(GTK_CONTAINER(menu), menu_item);
            g_signal_connect(menu_item, "activate",
                             G_CALLBACK(menu_suggestion_item_activate_cb), NULL);
        }
        if (suggs == NULL)
        {
            menu_item = gtk_menu_item_new_with_label(_("(No Suggestions)"));
            gtk_widget_set_sensitive(menu_item, FALSE);
            gtk_widget_show(menu_item);
            gtk_container_add(GTK_CONTAINER(sc_info->edit_menu_sub), menu_item);
        }
        menu_item = gtk_separator_menu_item_new();
        gtk_widget_show(menu_item);
        gtk_container_add(GTK_CONTAINER(sc_info->edit_menu_sub), menu_item);

        label = g_strdup_printf(_("Add \"%s\" to Dictionary"), search_word);
        menu_item = image_menu_item_new(GTK_STOCK_ADD, label);
        gtk_widget_show(menu_item);
        gtk_container_add(GTK_CONTAINER(sc_info->edit_menu_sub), menu_item);
        g_signal_connect(menu_item, "activate",
                         G_CALLBACK(menu_addword_item_activate_cb), GINT_TO_POINTER(FALSE));

        menu_item = image_menu_item_new(GTK_STOCK_REMOVE, _("Ignore All"));
        gtk_widget_show(menu_item);
        gtk_container_add(GTK_CONTAINER(sc_info->edit_menu_sub), menu_item);
        g_signal_connect(menu_item, "activate",
                         G_CALLBACK(menu_addword_item_activate_cb), GINT_TO_POINTER(TRUE));

        if (suggs != NULL)
            sc_speller_dict_free_string_list(suggs);

        g_free(label);
    }
    else
    {
        g_free(search_word);
    }
}
Пример #16
0
struct menu *
gui_gtk_menu_new(struct container *co, GtkWidget **widget)
{
	struct menu *this=g_new0(struct menu, 1);

	this->gui=g_new0(struct menu_gui,1);
        this->gui->co=co;


	GtkWidget *menu,*item,*menu2,*item2,*menu3,*clock;

	menu=gtk_menu_bar_new();
	item=gtk_menu_item_new_with_label("Goto");
	gtk_menu_bar_append(GTK_MENU_BAR(menu), item);
	{
		menu2=gtk_menu_new();
		item2=gtk_menu_item_new_with_label("Abensberg");
		gtk_menu_append (GTK_MENU(menu2), item2); 
		gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
			GTK_SIGNAL_FUNC (menu_goto_abensberg), this);

		item2=gtk_menu_item_new_with_label("Regensburg");
		gtk_menu_append (GTK_MENU(menu2), item2);
		gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
			GTK_SIGNAL_FUNC (menu_goto_regensburg), this);
		item2=gtk_menu_item_new_with_label("Problem");
		gtk_menu_append (GTK_MENU(menu2), item2);
		gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
			GTK_SIGNAL_FUNC (menu_goto_problem), this);
	}
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), menu2);

	item=gtk_menu_item_new_with_label("Window");
	gtk_menu_bar_append(GTK_MENU_BAR(menu), item);
	{
		menu2=gtk_menu_new();

		item2=gtk_menu_item_new_with_label("Clone");
		gtk_menu_append (GTK_MENU(menu2), item2); 
		gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
			GTK_SIGNAL_FUNC (menu_window_clone), this);

		item2=gtk_menu_item_new_with_label("Command");
		gtk_menu_append (GTK_MENU(menu2), item2); 
		gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
			GTK_SIGNAL_FUNC (menu_window_command), this);

		item2=gtk_menu_item_new_with_label("Visible Blocks");
		gtk_menu_append (GTK_MENU(menu2), item2);
		gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
			GTK_SIGNAL_FUNC (menu_window_visible_blocks), co);

		item2=gtk_menu_item_new_with_label("Visible Towns");
		gtk_menu_append (GTK_MENU(menu2), item2);
		gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
			GTK_SIGNAL_FUNC (menu_window_visible_towns), co);

		item2=gtk_menu_item_new_with_label("Visible Polys");
		gtk_menu_append (GTK_MENU(menu2), item2);
		gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
			GTK_SIGNAL_FUNC (menu_window_visible_polys), co);


		item2=gtk_menu_item_new_with_label("Visible Streets");
		gtk_menu_append (GTK_MENU(menu2), item2);
		gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
			GTK_SIGNAL_FUNC (menu_window_visible_streets), co);

		menu_item(this, menu2, "Visible Points", menu_window_visible_points);

		item2=gtk_menu_item_new_with_label("Exit");
		gtk_menu_append (GTK_MENU(menu2), item2); 
		gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
			GTK_SIGNAL_FUNC (exit), this);
	}
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), menu2);

	item=gtk_menu_item_new_with_label("Map");
	gtk_menu_bar_append(GTK_MENU_BAR(menu), item);
	{
		menu2=gtk_menu_new();

		item2=gtk_menu_item_new_with_label("Compare");
		gtk_menu_append (GTK_MENU(menu2), item2); 
		gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
			GTK_SIGNAL_FUNC (menu_map_compare), this);

		item2=gtk_menu_item_new_with_label("Distances");
		gtk_menu_append (GTK_MENU(menu2), item2); 
		gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
			GTK_SIGNAL_FUNC (menu_map_distances), this);
	}
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), menu2);

	item=gtk_menu_item_new_with_label("Route");
	gtk_menu_bar_append(GTK_MENU_BAR(menu), item);
	{
		menu2=gtk_menu_new();

		item2=gtk_menu_item_new_with_label("Start");
		gtk_menu_append (GTK_MENU(menu2), item2); 
		gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
			GTK_SIGNAL_FUNC (route_start), co);

		item2=gtk_menu_item_new_with_label("Trace");
		gtk_menu_append (GTK_MENU(menu2), item2); 
		gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
			GTK_SIGNAL_FUNC (route_trace), co);

		item2=gtk_menu_item_new_with_label("Update");
		gtk_menu_append (GTK_MENU(menu2), item2); 
		gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
			GTK_SIGNAL_FUNC (menu_route_update), this);
	}
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), menu2);

	item=gtk_menu_item_new_with_label("Destinations");
	gtk_menu_bar_append(GTK_MENU_BAR(menu), item);
	menu2=gtk_menu_new();

	item2=gtk_menu_item_new_with_label("Last Destinations");
	gtk_menu_append (GTK_MENU(menu2), item2); 
	menu3=gtk_menu_new();
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(item2), menu3);

	item2=gtk_menu_item_new_with_label("Address");
	gtk_menu_append (GTK_MENU(menu2), item2); 

	{
		FILE *file;
		char buffer[8192];
		double lat,lng,lat_deg,lng_deg;
		char lat_c,lng_c;
		struct destination *dest;
		int pos,len;
		char *utf8,*text,*tok,*label;
		GList *list;
	
		file=fopen("locations.txt","r");
		while (fgets(buffer,8192,file)) {
			dest=malloc(sizeof(*dest));
			dest->co=co;
			len=strlen(buffer)-1;
			while (len >= 0 && buffer[len] == '\n') {
				buffer[len]='\0';
			}
			sscanf(buffer,"%lf %c %lf %c %n",&lat, &lat_c, &lng, &lng_c, &pos);
		
			lat_deg=floor(lat/100);
			lat-=lat_deg*100;
			lat_deg+=lat/60;     	

			lng_deg=floor(lng/100);
			lng-=lng_deg*100;
			lng_deg+=lng/60;          

			transform_mercator(&lng_deg, &lat_deg, &dest->pos);
			
			text=buffer+pos;
			dest->text=strdup(text);
			item2=NULL;
			menu3=menu2;
			while ((tok=strtok(text,"/"))) {
				list=NULL;
				if (item2) {
					menu3=gtk_menu_new();
					gtk_menu_item_set_submenu(GTK_MENU_ITEM(item2), menu3);
				}
				list=gtk_container_get_children(GTK_CONTAINER(menu3));
				while (list) {
					item2=GTK_WIDGET(list->data);
					gtk_label_get(GTK_LABEL(gtk_bin_get_child(GTK_BIN(item2))),&label);
					if (!strcmp(label, tok)) {
						menu3=gtk_menu_item_get_submenu(GTK_MENU_ITEM(item2));
						break;
					}
					list=list->next;
				}
				item2=NULL;
				if (! list) {
					utf8=g_locale_to_utf8(tok,-1,NULL,NULL,NULL);
					item2=gtk_menu_item_new_with_label(utf8);
					gtk_menu_append (GTK_MENU(menu3), item2); 
					g_free(utf8);
				}
				text=NULL;
			}
			gtk_signal_connect(GTK_OBJECT(item2), "activate",
				GTK_SIGNAL_FUNC (menu_destination_selected), dest);
		}
	}
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), menu2);

	item=gtk_menu_item_new();
	clock=gtk_label_new(NULL);
	gtk_menu_item_right_justify(GTK_MENU_ITEM(item));
	gtk_container_add(GTK_CONTAINER(item), clock);
	gtk_menu_bar_append(GTK_MENU_BAR(menu), item);
	menu_clock_update(clock);
	
	*widget=menu;
	return this;
}
Пример #17
0
int
main (int argc, char *argv[])
{
  GtkWidget *button;
  GtkWidget *hbox;
  GtkWidget *vbox;
  GtkWidget *menubar;
  GtkWidget *menuitem;
  GtkWidget *menu;
  GtkWidget *entry;
  GtkWidget *checkbutton;
  GtkAccelGroup *accel_group;

  gtk_init (&argc, &argv);

  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  g_signal_connect (window, "destroy",
		    G_CALLBACK (gtk_main_quit), NULL);
  
  gtk_window_set_title (GTK_WINDOW (window), "Socket Test");
  gtk_container_set_border_width (GTK_CONTAINER (window), 0);

  vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
  gtk_container_add (GTK_CONTAINER (window), vbox);

  menubar = gtk_menu_bar_new ();
  menuitem = gtk_menu_item_new_with_mnemonic ("_File");
  gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);

  menu = gtk_menu_new ();
  gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
  menuitem = gtk_menu_item_new_with_mnemonic ("_Quit");
  g_signal_connect (menuitem, "activate", G_CALLBACK (quit_cb), window);
  gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);

  accel_group = gtk_accel_group_new ();
  gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
  gtk_box_pack_start (GTK_BOX (vbox), menubar, FALSE, FALSE, 0);

  button = gtk_button_new_with_label ("Add Active Child");
  gtk_box_pack_start (GTK_BOX(vbox), button, FALSE, FALSE, 0);

  g_signal_connect_swapped (button, "clicked",
			    G_CALLBACK (add_active_child), vbox);

  button = gtk_button_new_with_label ("Add Passive Child");
  gtk_box_pack_start (GTK_BOX(vbox), button, FALSE, FALSE, 0);

  g_signal_connect_swapped (button, "clicked",
			    G_CALLBACK (add_passive_child), vbox);

  button = gtk_button_new_with_label ("Add Local Active Child");
  gtk_box_pack_start (GTK_BOX(vbox), button, FALSE, FALSE, 0);

  g_signal_connect_swapped (button, "clicked",
			    G_CALLBACK (add_local_active_child), vbox);

  button = gtk_button_new_with_label ("Add Local Passive Child");
  gtk_box_pack_start (GTK_BOX(vbox), button, FALSE, FALSE, 0);

  g_signal_connect_swapped (button, "clicked",
			    G_CALLBACK (add_local_passive_child), vbox);

  button = gtk_button_new_with_label ("Remove Last Child");
  gtk_box_pack_start (GTK_BOX(vbox), button, FALSE, FALSE, 0);

  g_signal_connect_swapped (button, "clicked",
			    G_CALLBACK (remove_child), vbox);

  checkbutton = gtk_check_button_new_with_label ("Grab keyboard");
  gtk_box_pack_start (GTK_BOX (vbox), checkbutton, FALSE, FALSE, 0);

  g_signal_connect (checkbutton, "toggled",
		    G_CALLBACK (grab_window_toggled),
		    window);

  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
  gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);

  entry = gtk_entry_new ();
  gtk_box_pack_start (GTK_BOX(hbox), entry, FALSE, FALSE, 0);

  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
  gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);

  box = hbox;
  
  gtk_widget_show_all (window);

  gtk_main ();

  if (n_children)
    {
      g_print ("Waiting for children to exit\n");

      while (n_children)
	g_main_context_iteration (NULL, TRUE);
    }

  return 0;
}
Пример #18
0
void
add_mainmenu_actions (GtkWidget *mainwin)
{
    DB_plugin_t **plugins = deadbeef->plug_get_list();
    int i;

    for (i = 0; plugins[i]; i++)
    {
        if (!plugins[i]->get_actions)
            continue;

        DB_plugin_action_t *actions = plugins[i]->get_actions (NULL);
        DB_plugin_action_t *action;

        for (action = actions; action; action = action->next)
        {
            char *tmp = NULL;
            if (0 == (action->flags & DB_ACTION_COMMON))
                continue;

            // 1st check if we have slashes
            const char *slash = action->title;
            while (NULL != (slash = strchr (slash, '/'))) {
                if (slash && slash > action->title && *(slash-1) == '\\') {
                    slash++;
                    continue;
                }
                break;
            }
            if (!slash) {
                continue;
            }

            char *ptr = tmp = strdup (action->title);

            char *prev_title = NULL;

            GtkWidget *current = mainwin;
            GtkWidget *previous;

            while (1)
            {
                // find unescaped forward slash
                char *slash = strchr (ptr, '/');
                if (slash && slash > ptr && *(slash-1) == '\\') {
                    ptr = slash + 1;
                    continue;
                }

                if (!slash)
                {
                    GtkWidget *actionitem;
                    actionitem = gtk_image_menu_item_new_with_mnemonic (_(ptr));
                    gtk_widget_show (actionitem);

                    /* Here we have special cases for different submenus */
                    if (0 == strcmp ("File", prev_title))
                        gtk_menu_shell_insert (GTK_MENU_SHELL (current), actionitem, 5);
                    else if (0 == strcmp ("Edit", prev_title))
                        gtk_menu_shell_insert (GTK_MENU_SHELL (current), actionitem, 7);
                    else
                        gtk_container_add (GTK_CONTAINER (current), actionitem);

                    g_signal_connect ((gpointer) actionitem, "activate",
                        G_CALLBACK (on_actionitem_activate),
                        action);
                    break;
                }
                *slash = 0;
                char menuname [1024];

                snprintf (menuname, sizeof (menuname), "%s_menu", ptr);

                previous = current;
                current = lookup_widget (current, menuname);
                if (!current)
                {
                    GtkWidget *newitem;

                    newitem = gtk_menu_item_new_with_mnemonic (ptr);
                    gtk_widget_show (newitem);

                    //If we add new submenu in main bar, add it before 'Help'
                    if (NULL == prev_title)
                        gtk_menu_shell_insert (GTK_MENU_SHELL (previous), newitem, 4);
                    else
                        gtk_container_add (GTK_CONTAINER (previous), newitem);

                    current = gtk_menu_new ();
                    gtk_menu_item_set_submenu (GTK_MENU_ITEM (newitem), current);
                }
                prev_title = ptr;
                ptr = slash + 1;
            }
            if (tmp) {
                free (tmp);
            }
        }
    }
}
Пример #19
0
int main(int argc,char *argv[])
{
  char dmmy[20];
  GtkWidget *main_window;
  GtkWidget *v_box;
  GtkWidget *h_box;
  GtkWidget *box1;
  GtkWidget *box2;
  GtkWidget *right_side;
  GtkWidget *game_border;	
  GtkWidget *next_block_border;
  GdkBitmap *mask;	
  GtkWidget *menu_bar;
  GtkWidget *menu_game;
  GtkWidget *menu_game_menu;
  GtkWidget *separatormenuitem1;
  GtkWidget *separator1;
  GtkWidget *menu_settings;
  GtkWidget *menu_settings_menu;
  GtkWidget *menu_help;
  GtkWidget *menu_help_menu;
  GtkWidget *help1;
  GtkWidget *high_scores1;
  GtkWidget *separator2;
  GtkWidget *about1;
  GtkAccelGroup* accel_group;
  

  //init game values
  game_play=FALSE;
  get_opt_file(options_f,100);
  read_options();
  game_over = TRUE;
  game_pause = FALSE;
  current_x = current_y = 0;
  current_block = current_frame = 0;
  current_score = current_lines = 0;
  current_level = options.level; 
  next_block = next_frame = 0;
  // seed random generator
  srandom(time(NULL));
  //options.shw_nxt = TRUE;
  
  gtk_set_locale();
  gtk_init(&argc,&argv);

  accel_group = gtk_accel_group_new();
  
  // window
  main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  gtk_window_set_policy(GTK_WINDOW(main_window),FALSE,FALSE,TRUE);
  gtk_window_set_title(GTK_WINDOW(main_window),"GTK Tetris");
  g_signal_connect ((gpointer) main_window, "key_press_event",
		    G_CALLBACK (keyboard_event_handler),
		    NULL);
  
  
  // vertical box
  v_box = gtk_vbox_new(FALSE,0);
  gtk_container_add(GTK_CONTAINER(main_window),v_box);
  gtk_widget_show(v_box);
  
  // menu stuff
  menu_bar = gtk_menu_bar_new();
  gtk_widget_show(menu_bar);
  gtk_box_pack_start(GTK_BOX(v_box),menu_bar,FALSE,FALSE,0);
  
  //Game sub-menu
  menu_game=gtk_menu_item_new_with_mnemonic ("_Game");
  gtk_widget_show(menu_game);
  gtk_container_add (GTK_CONTAINER (menu_bar), menu_game);
  
  menu_game_menu=gtk_menu_new ();
  gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_game), menu_game_menu);
  
  menu_game_quick = gtk_menu_item_new_with_mnemonic ("Start Game");
  gtk_widget_show (menu_game_quick);
  gtk_container_add (GTK_CONTAINER (menu_game_menu), menu_game_quick);
  g_signal_connect ((gpointer) menu_game_quick, "activate",
		    G_CALLBACK (game_start_stop),
		    NULL);
  gtk_widget_add_accelerator (menu_game_quick, "activate", accel_group,
			      GDK_G, GDK_CONTROL_MASK,
			      GTK_ACCEL_VISIBLE);
  
  menu_game_stop = gtk_menu_item_new_with_mnemonic ("Stop Game");
  gtk_widget_show (menu_game_stop);
  gtk_container_add (GTK_CONTAINER (menu_game_menu), menu_game_stop);
  g_signal_connect ((gpointer) menu_game_stop, "activate",
		    G_CALLBACK (game_start_stop),
		    NULL);
  gtk_widget_add_accelerator (menu_game_stop, "activate", accel_group,
			      GDK_O, GDK_CONTROL_MASK,
			      GTK_ACCEL_VISIBLE);
  gtk_widget_set_sensitive(menu_game_stop,FALSE);
  
  menu_game_pause = gtk_check_menu_item_new_with_mnemonic ("Pause");
  gtk_widget_show (menu_game_pause);
  gtk_container_add (GTK_CONTAINER (menu_game_menu), menu_game_pause);
  g_signal_connect ((gpointer) menu_game_pause, "activate",
		    G_CALLBACK (game_set_pause),
		    NULL);
  gtk_widget_add_accelerator (menu_game_pause, "activate", accel_group,
			      GDK_P, GDK_CONTROL_MASK,
			      GTK_ACCEL_VISIBLE);
  
  separatormenuitem1 = gtk_menu_item_new ();
  gtk_widget_show (separatormenuitem1);
  gtk_container_add (GTK_CONTAINER (menu_game_menu), separatormenuitem1);
  gtk_widget_set_sensitive (separatormenuitem1, FALSE);
  
  menu_game_quit = gtk_menu_item_new_with_mnemonic ("Quit");
  gtk_widget_show (menu_game_quit);
  gtk_container_add (GTK_CONTAINER (menu_game_menu), menu_game_quit);
  g_signal_connect ((gpointer) menu_game_quit, "activate",
		    G_CALLBACK (gtk_main_quit),
		    NULL);
  gtk_widget_add_accelerator(menu_game_quit,"activate", accel_group,
			     GDK_X, GDK_CONTROL_MASK,
			     GTK_ACCEL_VISIBLE);	
  
  //Settings sub-menu
  menu_settings = gtk_menu_item_new_with_mnemonic ("_Settings");
  gtk_widget_show (menu_settings);
  gtk_container_add (GTK_CONTAINER (menu_bar), menu_settings);
  
  menu_settings_menu=gtk_menu_new ();
  gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_settings), 
			     menu_settings_menu);
  
  menu_game_start = gtk_menu_item_new_with_mnemonic ("Level Settings");
  gtk_widget_show (menu_game_start);
  gtk_container_add (GTK_CONTAINER (menu_settings_menu), menu_game_start);
  g_signal_connect ((gpointer) menu_game_start, "activate",
		    G_CALLBACK (show_new_game),
		    NULL);
  
  menu_game_show_next_block = gtk_check_menu_item_new_with_mnemonic ("Show next block");
  gtk_widget_show (menu_game_show_next_block);
  gtk_container_add (GTK_CONTAINER (menu_settings_menu), 
		     menu_game_show_next_block);
  if (options.shw_nxt) 
    gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_game_show_next_block), 
				    TRUE);
  g_signal_connect ((gpointer) menu_game_show_next_block, "activate",
		    G_CALLBACK (game_show_next_block),
		    NULL);
  gtk_widget_add_accelerator (menu_game_show_next_block, "activate", 
			      accel_group,
			      GDK_N, GDK_CONTROL_MASK,
			      GTK_ACCEL_VISIBLE);
  
  
  separator1 = gtk_menu_item_new ();
  gtk_widget_show (separator1);
  gtk_container_add (GTK_CONTAINER (menu_settings_menu), separator1);
  gtk_widget_set_sensitive (separator1, FALSE);
  
  menu_save_options = gtk_menu_item_new_with_mnemonic ("Save Settings");
  gtk_widget_show (menu_save_options);
  gtk_container_add (GTK_CONTAINER (menu_settings_menu), 
		     menu_save_options);
  g_signal_connect ((gpointer) menu_save_options, "activate",
		    G_CALLBACK (save_options),
		    NULL);
  
  //Help sub-menu
  menu_help=gtk_menu_item_new_with_mnemonic ("_Help");
  gtk_widget_show (menu_help);
  gtk_container_add (GTK_CONTAINER (menu_bar), menu_help);
  
  gtk_menu_item_set_right_justified (GTK_MENU_ITEM(menu_help),TRUE);
  
  menu_help_menu = gtk_menu_new();
  gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_help), 
			     menu_help_menu);
  
  help1 = gtk_menu_item_new_with_mnemonic ("Help");
  gtk_widget_show (help1);
  gtk_container_add (GTK_CONTAINER (menu_help_menu), help1);
  g_signal_connect ((gpointer) help1, "activate",
		    G_CALLBACK (show_help),
		    NULL);
  gtk_widget_add_accelerator (help1, "activate", 
			      accel_group,
			      GDK_F1, (GdkModifierType) 0,
			      GTK_ACCEL_VISIBLE);
  
  high_scores1 = gtk_menu_item_new_with_mnemonic ("High-scores");
  gtk_widget_show (high_scores1);
  gtk_container_add (GTK_CONTAINER (menu_help_menu), high_scores1);
  g_signal_connect ((gpointer) high_scores1, "activate",
		    G_CALLBACK (show_highscore_wrapper),
		    NULL);
  
  separator2 = gtk_menu_item_new ();
  gtk_widget_show (separator2);
  gtk_container_add (GTK_CONTAINER (menu_help_menu), separator2);
  gtk_widget_set_sensitive (separator2, FALSE);
  
  about1 = gtk_menu_item_new_with_mnemonic ("About");
  gtk_widget_show (about1);
  gtk_container_add (GTK_CONTAINER (menu_help_menu), about1);
  g_signal_connect ((gpointer) about1, "activate",
		    G_CALLBACK (show_about),
		    NULL);
  
  // horizontal box
  h_box = gtk_hbox_new(FALSE,1);
  gtk_widget_show(h_box);
  gtk_box_pack_start(GTK_BOX(v_box),h_box,FALSE,FALSE,0);
  
  // game_border
  game_border = gtk_frame_new(NULL);
  gtk_frame_set_shadow_type(GTK_FRAME(game_border),GTK_SHADOW_IN);
  gtk_box_pack_start(GTK_BOX(h_box),game_border,FALSE,FALSE,1);
  gtk_widget_show(game_border);
  
  // game_area
  game_area = gtk_drawing_area_new();
  gtk_widget_show(game_area);
  gtk_drawing_area_size(GTK_DRAWING_AREA(game_area),
			MAX_X*BLOCK_WIDTH,MAX_Y*BLOCK_HEIGHT);
  g_signal_connect ((gpointer) game_area, "expose_event",
		    G_CALLBACK (game_area_expose_event),
		    NULL);
  
  gtk_widget_set_events(game_area, GDK_EXPOSURE_MASK);
  gtk_container_add(GTK_CONTAINER(game_border),game_area);
  
  // right_side
  right_side = gtk_vbox_new(FALSE,0);
  gtk_box_pack_start(GTK_BOX(h_box),right_side,FALSE,FALSE,0);
  gtk_widget_show(right_side);
  
  // next_block_border
  next_block_border = gtk_frame_new(NULL);
  gtk_frame_set_shadow_type(GTK_FRAME(next_block_border),GTK_SHADOW_IN);
  gtk_box_pack_start(GTK_BOX(right_side),next_block_border,FALSE,FALSE,0);
  gtk_widget_show(next_block_border);
  
  // next_block_area
  next_block_area = gtk_drawing_area_new();
  gtk_widget_show(next_block_area);
  gtk_drawing_area_size(GTK_DRAWING_AREA(next_block_area),
			4*BLOCK_WIDTH,4*BLOCK_HEIGHT);
  g_signal_connect ((gpointer) next_block_area, "expose_event",
		    G_CALLBACK (next_block_area_expose_event),
		    NULL);
  gtk_widget_set_events(next_block_area, GDK_EXPOSURE_MASK);
  gtk_container_add(GTK_CONTAINER(next_block_border),next_block_area);
  
  // the score,level and lines labels
  score_label1 = gtk_label_new("Score:");
  gtk_label_set_justify(GTK_LABEL(score_label1),GTK_JUSTIFY_RIGHT);
  gtk_widget_show(score_label1);
  gtk_box_pack_start(GTK_BOX(right_side),score_label1,FALSE,FALSE,3);
  
  score_label2 = gtk_label_new("0");
  set_gtk_color_style(score_label2,0xffff,0,0);
  gtk_label_set_justify(GTK_LABEL(score_label2),GTK_JUSTIFY_RIGHT);
  gtk_widget_show(score_label2);
  gtk_box_pack_start(GTK_BOX(right_side),score_label2,FALSE,FALSE,3);
  
  level_label1 = gtk_label_new("Level:");
  gtk_label_set_justify(GTK_LABEL(level_label1),GTK_JUSTIFY_RIGHT);
  gtk_widget_show(level_label1);
  gtk_box_pack_start(GTK_BOX(right_side),level_label1,FALSE,FALSE,3);
  
  sprintf(dmmy,"%d",current_level);
  level_label2 = gtk_label_new(dmmy);
  set_gtk_color_style(level_label2,0,0,0xffff);
  gtk_label_set_justify(GTK_LABEL(level_label2),GTK_JUSTIFY_RIGHT);
  gtk_widget_show(level_label2);
  gtk_box_pack_start(GTK_BOX(right_side),level_label2,FALSE,FALSE,3);
  
  lines_label1 = gtk_label_new("Lines:");
  gtk_label_set_justify(GTK_LABEL(lines_label1),GTK_JUSTIFY_RIGHT);
  gtk_widget_show(lines_label1);
  gtk_box_pack_start(GTK_BOX(right_side),lines_label1,FALSE,FALSE,3);
  
  lines_label2 = gtk_label_new("0");
  gtk_label_set_justify(GTK_LABEL(lines_label2),GTK_JUSTIFY_RIGHT);
  gtk_widget_show(lines_label2);
  gtk_box_pack_start(GTK_BOX(right_side),lines_label2,FALSE,FALSE,3);
  
  //the game buttons
  //Start_stop
  Start_stop_button = gtk_button_new();
  gtk_widget_show(Start_stop_button);
  g_signal_connect ((gpointer) Start_stop_button, "clicked",
		    G_CALLBACK (game_start_stop),
		    NULL);
  Start_stop_button_label= gtk_label_new(start_stop_str[0]);
  box2 = label_box(right_side, Start_stop_button_label, 
		   start_stop_str[0] );
  gtk_widget_show(box2);
  gtk_container_add (GTK_CONTAINER (Start_stop_button), box2);
  gtk_box_pack_start(GTK_BOX(right_side),Start_stop_button,FALSE,FALSE,3);
  GTK_WIDGET_SET_FLAGS(Start_stop_button, GTK_CAN_DEFAULT);
  gtk_widget_grab_default(Start_stop_button);
  //Pause
  Pause_button = gtk_button_new();
  gtk_widget_show(Pause_button);
  g_signal_connect ((gpointer) Pause_button, "clicked",
		    G_CALLBACK (game_set_pause_b),
		    NULL);
  Pause_button_label = gtk_label_new(pause_str[0]);
  box1 = label_box(right_side, Pause_button_label, pause_str[0] );
  gtk_widget_show(box1);
  gtk_container_add (GTK_CONTAINER (Pause_button), box1);
  gtk_box_pack_start(GTK_BOX(right_side),Pause_button,FALSE,FALSE,3);
  GTK_WIDGET_SET_FLAGS(Pause_button, GTK_CAN_DEFAULT);
  gtk_widget_set_sensitive(Pause_button,FALSE);
  
  gtk_window_add_accel_group (GTK_WINDOW (main_window), accel_group);
  
  gtk_widget_show(main_window);
  
  // Block images...
  blocks_pixmap = gdk_pixmap_create_from_xpm_d(game_area->window,
					       &mask,
					       NULL,
					       (gchar **)blocks_xpm);	
  
  gtk_main ();
  return 0;
}
Пример #20
0
static void notify_incoming_call(struct gtk_mod *mod,
		struct call *call)
{
	static const char *title = "Incoming call";
	const char *msg = call_peeruri(call);
	GtkWidget *call_menu;
	GtkWidget *menu_item;
#if defined(USE_LIBNOTIFY)
	NotifyNotification *notification;

	if (!notify_is_initted())
		return;
	notification = notify_notification_new(title, msg, "baresip");
	notify_notification_set_urgency(notification, NOTIFY_URGENCY_CRITICAL);
	notify_notification_show(notification, NULL);
	g_object_unref(notification);

#elif GLIB_CHECK_VERSION(2,40,0)
	char id[64];
	GVariant *target;
	GNotification *notification = g_notification_new(title);

	re_snprintf(id, sizeof id, "incoming-call-%p", call);
	id[sizeof id - 1] = '\0';

#if GLIB_CHECK_VERSION(2,42,0)
	g_notification_set_priority(notification,
			G_NOTIFICATION_PRIORITY_URGENT);
#else
	g_notification_set_urgent(notification, TRUE);
#endif

	target = g_variant_new_int64(GPOINTER_TO_INT(call));
	g_notification_set_body(notification, msg);
	g_notification_add_button_with_target_value(notification,
			"Answer", "app.answer", target);
	g_notification_add_button_with_target_value(notification,
			"Reject", "app.reject", target);
	g_application_send_notification(mod->app, id, notification);
	g_object_unref(notification);

#else
	(void)msg;
	(void)title;
#endif

	/* Add incoming call to the app menu */
	call_menu = gtk_menu_new();
	menu_item = gtk_menu_item_new_with_mnemonic("_Incoming call");
	g_object_set_data(G_OBJECT(menu_item), "call", call);
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_item),
			call_menu);
	gtk_menu_shell_prepend(GTK_MENU_SHELL(mod->app_menu), menu_item);
	mod->incoming_call_menus = g_slist_append(mod->incoming_call_menus,
			menu_item);

	menu_item = gtk_menu_item_new_with_label(call_peeruri(call));
	gtk_widget_set_sensitive(menu_item, FALSE);
	gtk_menu_shell_append(GTK_MENU_SHELL(call_menu), menu_item);

	menu_item = gtk_menu_item_new_with_mnemonic("_Accept");
	g_object_set_data(G_OBJECT(menu_item), "call", call);
	g_signal_connect(G_OBJECT(menu_item), "activate",
			G_CALLBACK(menu_on_incoming_call_answer), mod);
	gtk_menu_shell_append(GTK_MENU_SHELL(call_menu), menu_item);

	menu_item = gtk_menu_item_new_with_mnemonic("_Reject");
	g_object_set_data(G_OBJECT(menu_item), "call", call);
	g_signal_connect(G_OBJECT(menu_item), "activate",
			G_CALLBACK(menu_on_incoming_call_reject), mod);
	gtk_menu_shell_append(GTK_MENU_SHELL(call_menu), menu_item);
}
Пример #21
0
GtkWidget* mooMenuBar (GtkWidget* window)
{
  GtkWidget *menubar, *game, *view, *help;
  GtkWidget *gamemenu, *viewmenu, *helpmenu;
  GtkWidget *newgame, *quit, *hint, *rules, *about;
  GtkWidget *newgame_image, *quit_image, 
            *hint_image, *rules_image;
  GtkWidget *separator;
  
  GtkAccelGroup *accel_group;

  accel_group = gtk_accel_group_new ();
  gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
  gtk_menu_set_accel_group (GTK_MENU (menubar), accel_group);


  /*-------------------------------------------*\ 
   *   Create menubar: Game, View, Help        * 
  \*-------------------------------------------*/  
  
  menubar = gtk_menu_bar_new ();

  game = gtk_menu_item_new_with_mnemonic ("_Game");
  gtk_widget_show (game);
  gtk_container_add (GTK_CONTAINER (menubar), game);
  
  /*-->Game Menu Starts Here<--*/	
  gamemenu = gtk_menu_new ();
  gtk_menu_item_set_submenu (GTK_MENU_ITEM (game), gamemenu);  
  gtk_widget_set_size_request (menubar, -1, 25);
  
  newgame = gtk_image_menu_item_new_with_mnemonic ("_New Game");
  gtk_widget_show (newgame);
  gtk_container_add (GTK_CONTAINER (gamemenu), newgame);
  gtk_widget_add_accelerator (newgame, "activate", accel_group,
                              GDK_N, (GdkModifierType) GDK_CONTROL_MASK,
                              GTK_ACCEL_VISIBLE);

  newgame_image = gtk_image_new_from_stock ("gtk-new", GTK_ICON_SIZE_MENU);

  gtk_widget_show (newgame_image);
  gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (newgame), newgame_image);
  
  g_signal_connect ((gpointer) newgame, "activate",
                    G_CALLBACK (start_newgame), NULL);

  separator = gtk_separator_menu_item_new ();
  gtk_widget_show (separator);
  gtk_container_add (GTK_CONTAINER (gamemenu), separator);
  gtk_widget_set_sensitive (separator, FALSE);

  quit = gtk_image_menu_item_new_with_mnemonic ("_Quit");
  gtk_widget_show (quit);
  gtk_container_add (GTK_CONTAINER (gamemenu), quit);
  gtk_widget_add_accelerator (quit, "activate", accel_group,
                              GDK_Q, (GdkModifierType) GDK_CONTROL_MASK,
                              GTK_ACCEL_VISIBLE);

  quit_image = gtk_image_new_from_stock ("gtk-quit", GTK_ICON_SIZE_MENU);
  //create_pixmap (mainwindow, "Eket Mask.xpm");
  gtk_widget_show (quit_image);
  gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (quit), quit_image);
  
  g_signal_connect ((gpointer) quit, "activate",
                    G_CALLBACK (gtk_main_quit),
                    NULL);
  /*-->Game Menu Ends Here<--*/

  /*-->View Menu Starts Here Here<--*/					
  view = gtk_menu_item_new_with_mnemonic ("_View");
  gtk_widget_show (view);
  gtk_container_add (GTK_CONTAINER (menubar), view);

  viewmenu = gtk_menu_new ();
  gtk_menu_item_set_submenu (GTK_MENU_ITEM (view), viewmenu);

  hint = gtk_image_menu_item_new_with_mnemonic ("Show _Hint");
  gtk_widget_show (hint);
  gtk_container_add (GTK_CONTAINER (viewmenu), hint);
  gtk_widget_add_accelerator (hint, "activate", accel_group,
                              GDK_h, (GdkModifierType) GDK_CONTROL_MASK,
                              GTK_ACCEL_VISIBLE);

  hint_image = gtk_image_new_from_stock ("gtk-dialog-info", GTK_ICON_SIZE_MENU);
  gtk_widget_show (hint_image);
  gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (hint), hint_image);
  
  g_signal_connect ((gpointer) hint, "activate",
                    G_CALLBACK (showHint),
                    NULL);

  /*-->View Menu Ends Here<--*/
  
  /*-->Help Menu Starts Here<--*/
  help = gtk_menu_item_new_with_mnemonic ("_Help");
  gtk_widget_show (help);
  gtk_container_add (GTK_CONTAINER (menubar), help);

  helpmenu = gtk_menu_new ();
  gtk_menu_item_set_submenu (GTK_MENU_ITEM (help), helpmenu);

  rules = gtk_image_menu_item_new_with_mnemonic ("_Rules");
  gtk_widget_show (rules);
  gtk_container_add (GTK_CONTAINER (helpmenu), rules);
  gtk_widget_add_accelerator (rules, "activate", accel_group,
                              GDK_F1, (GdkModifierType) 0,
                              GTK_ACCEL_VISIBLE);

  rules_image = gtk_image_new_from_stock ("gtk-help", GTK_ICON_SIZE_MENU);
  gtk_widget_show (rules_image);
  gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (rules), rules_image);
  
  g_signal_connect ((gpointer) rules, "activate",
                    G_CALLBACK (mooRules), NULL);
  
  separator = gtk_separator_menu_item_new ();
  gtk_widget_show (separator);
  gtk_container_add (GTK_CONTAINER (helpmenu), separator);
  gtk_widget_set_sensitive (separator, FALSE);
 
  about = gtk_image_menu_item_new_from_stock ("gtk-about", accel_group);
  gtk_widget_show (about);
  gtk_container_add (GTK_CONTAINER (helpmenu), about);
  
  g_signal_connect ((gpointer) about, "activate",
                    G_CALLBACK (init_about),
                    NULL);
  
  /*-->Help Menu Ends Here<--*/
  return menubar;
}
Пример #22
0
static void *gtk_thread(void *arg)
{
	struct gtk_mod *mod = arg;
	GtkMenuShell *app_menu;
	GtkWidget *item;
	GError *err = NULL;
	struct le *le;

	gdk_threads_init();
	gtk_init(0, NULL);

	g_set_application_name("baresip");
	mod->app = g_application_new ("com.creytiv.baresip",
			G_APPLICATION_FLAGS_NONE);

	g_application_register (G_APPLICATION (mod->app), NULL, &err);
	if (err != NULL) {
		warning ("Unable to register GApplication: %s",
				err->message);
		g_error_free (err);
		err = NULL;
	}

#ifdef USE_LIBNOTIFY
	notify_init("baresip");
#endif

	mod->status_icon = gtk_status_icon_new_from_icon_name("call-start");
	gtk_status_icon_set_tooltip_text (mod->status_icon, "baresip");

	g_signal_connect(G_OBJECT(mod->status_icon),
			"button_press_event",
			G_CALLBACK(status_icon_on_button_press), mod);
	gtk_status_icon_set_visible(mod->status_icon, TRUE);

	mod->contacts_inited = false;
	mod->dial_dialog = NULL;
	mod->call_windows = NULL;
	mod->incoming_call_menus = NULL;

	/* App menu */
	mod->app_menu = gtk_menu_new();
	app_menu = GTK_MENU_SHELL(mod->app_menu);

	/* Account submenu */
	mod->accounts_menu = gtk_menu_new();
	mod->accounts_menu_group = NULL;
	item = gtk_menu_item_new_with_mnemonic("_Account");
	gtk_menu_shell_append(app_menu, item);
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),
			mod->accounts_menu);

	/* Add accounts to submenu */
	for (le = list_head(uag_list()); le; le = le->next) {
		struct ua *ua = le->data;
		accounts_menu_add_item(mod, ua);
	}

	/* Status submenu */
	mod->status_menu = gtk_menu_new();
	item = gtk_menu_item_new_with_mnemonic("_Status");
	gtk_menu_shell_append(GTK_MENU_SHELL(app_menu), item);
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), mod->status_menu);

	/* Open */
	item = gtk_radio_menu_item_new_with_label(NULL, "Open");
	g_object_set_data(G_OBJECT(item), "presence",
			GINT_TO_POINTER(PRESENCE_OPEN));
	g_signal_connect(item, "activate",
			G_CALLBACK(menu_on_presence_set), mod);
	gtk_menu_shell_append(GTK_MENU_SHELL(mod->status_menu), item);
	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);

	/* Closed */
	item = gtk_radio_menu_item_new_with_label_from_widget(
			GTK_RADIO_MENU_ITEM(item), "Closed");
	g_object_set_data(G_OBJECT(item), "presence",
			GINT_TO_POINTER(PRESENCE_CLOSED));
	g_signal_connect(item, "activate",
			G_CALLBACK(menu_on_presence_set), mod);
	gtk_menu_shell_append(GTK_MENU_SHELL(mod->status_menu), item);

	gtk_menu_shell_append(app_menu, gtk_separator_menu_item_new());

	/* Dial */
	item = gtk_menu_item_new_with_mnemonic("_Dial...");
	gtk_menu_shell_append(app_menu, item);
	g_signal_connect(G_OBJECT(item), "activate",
			G_CALLBACK(menu_on_dial), mod);

	/* Dial contact */
	mod->contacts_menu = gtk_menu_new();
	item = gtk_menu_item_new_with_mnemonic("Dial _contact");
	gtk_menu_shell_append(app_menu, item);
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),
			mod->contacts_menu);

	gtk_menu_shell_append(app_menu, gtk_separator_menu_item_new());

	/* About */
	item = gtk_menu_item_new_with_mnemonic("A_bout");
	g_signal_connect(G_OBJECT(item), "activate",
			G_CALLBACK(menu_on_about), mod);
	gtk_menu_shell_append(app_menu, item);

	gtk_menu_shell_append(app_menu, gtk_separator_menu_item_new());

	/* Quit */
	item = gtk_menu_item_new_with_mnemonic("_Quit");
	g_signal_connect(G_OBJECT(item), "activate",
			G_CALLBACK(menu_on_quit), mod);
	gtk_menu_shell_append(app_menu, item);

	g_action_map_add_action_entries(G_ACTION_MAP(mod->app),
			app_entries, G_N_ELEMENTS(app_entries), mod);

	info("gtk_menu starting\n");

	uag_event_register( ua_event_handler, mod );
	mod->run = true;
	gtk_main();
	mod->run = false;
	uag_event_unregister(ua_event_handler);

	if (mod->dial_dialog) {
		mem_deref(mod->dial_dialog);
		mod->dial_dialog = NULL;
	}

	return NULL;
}
Пример #23
0
static void
hn_others_menu_get_items (GtkMenu *menu,
			  HNOthersButton *button,
			  GtkTreeModel *model,
			  GtkTreeIter *iter)
{
  GtkMenu *submenu = NULL;

  GtkWidget *menu_item = NULL;

  gchar *item_name = NULL;
  gchar *item_comment = NULL;
  GdkPixbuf *item_icon  = NULL;
  GdkPixbuf *item_thumb_icon = NULL;
  gchar *item_exec = NULL;
  gchar *item_service = NULL;
  gchar *item_desktop_id = NULL;
  gchar *item_text_domain = NULL;
  GtkTreeIter child_iter;
  gint children;
  gboolean my_iterator = FALSE;
  
  g_return_if_fail (menu);

  if (!model)
  {
    GtkTreeIter iter0;
    
    model = get_menu_contents();
    iter = g_malloc0 (sizeof (GtkTreeIter));
    my_iterator = TRUE;
    
    /* Get the top level iterator. */
    if (!gtk_tree_model_get_iter_first(model, &iter0) ||
        !gtk_tree_model_iter_children(model, iter, &iter0))
    {
      g_object_unref (G_OBJECT (model));
      return;
    }
  }
  else
  {
    g_object_ref (G_OBJECT (model));
  }
    
  /* Loop! */
  do  {
    item_name = NULL;
    item_icon = NULL;
    item_thumb_icon = NULL;
    item_exec = NULL;
    item_service = NULL;
    item_desktop_id = NULL;
    item_text_domain = NULL;

    gtk_tree_model_get (model, iter,
		        TREE_MODEL_NAME, &item_name,
		        TREE_MODEL_ICON, &item_icon,
		        TREE_MODEL_THUMB_ICON, &item_thumb_icon,
		        TREE_MODEL_EXEC, &item_exec,
		        TREE_MODEL_SERVICE, &item_service,
		        TREE_MODEL_DESKTOP_ID, &item_desktop_id,
		        TREE_MODEL_COMMENT, &item_comment,
		        TREE_MODEL_TEXT_DOMAIN, &item_text_domain,
		        -1);

    children = 0;

    /* If the item has children. */
    if (gtk_tree_model_iter_children (model, &child_iter, iter))
    {
      gchar *child_string = NULL;
      	    
      /* It's a submenu */
      submenu = GTK_MENU (gtk_menu_new ());
      
      gtk_widget_set_name (GTK_WIDGET (submenu),
                           NAVIGATOR_MENU_NAME);
      
      /* Create a menu item and add it to the menu. */
      children = gtk_tree_model_iter_n_children (model, iter);
      child_string = g_strdup_printf(MENU_ITEM_N_ITEMS (children), children);
 
      menu_item = hildon_thumb_menu_item_new_with_labels (
                                (item_text_domain && *item_text_domain) ?
                                dgettext(item_text_domain, item_name):
                                _(item_name),
                                NULL,
                                child_string);
      
      g_free(child_string);
      
      gtk_menu_shell_append (GTK_MENU_SHELL (menu),
      		             GTK_WIDGET (menu_item));
      
      /* Add the submenu icon */
      if (item_icon && item_thumb_icon)
      {
        hildon_thumb_menu_item_set_images (
            		  HILDON_THUMB_MENU_ITEM (menu_item),
            		  gtk_image_new_from_pixbuf (item_icon),
            		  gtk_image_new_from_pixbuf (item_thumb_icon));
      }
      	    
      gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item),
      			         GTK_WIDGET (submenu));
      
      /* Recurse! */
      hn_others_menu_get_items(submenu, button, model, &child_iter);
    }
    else if ( !item_desktop_id || strlen( item_desktop_id ) == 0 )
    {
      /* Empty submenu. Skip "Extras" */
      if (strcmp (item_name, "tana_fi_extras") != 0)
      {
        gchar *child_string;
        submenu = GTK_MENU(gtk_menu_new());
    
        gtk_widget_set_name (GTK_WIDGET(submenu),
      		             NAVIGATOR_MENU_NAME);

        /* Create a menu item and add it to the menu.
         */
        child_string = g_strdup_printf(MENU_ITEM_N_ITEMS(children), children);
        menu_item = hildon_thumb_menu_item_new_with_labels (
      	        (item_text_domain && *item_text_domain)?
      	        dgettext(item_text_domain, item_name):
      	        dgettext("maemo-af-desktop", item_name),
      	        NULL,
      	        child_string);

	g_free(child_string);

        gtk_menu_shell_append (GTK_MENU_SHELL (menu),
      		               GTK_WIDGET (menu_item));

        /* Add the submenu icon */
        if (item_icon)
        {
          hildon_thumb_menu_item_set_images(
      	          HILDON_THUMB_MENU_ITEM(menu_item),
      	          gtk_image_new_from_pixbuf(item_icon),
      	          gtk_image_new_from_pixbuf(item_thumb_icon));
        }

        gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item),
      		                   GTK_WIDGET (submenu));

        /* Create a menu item and add it to the menu. */
        GtkWidget *submenu_item =
                gtk_image_menu_item_new_with_label (MENU_ITEM_EMPTY_SUBMENU_STRING);

        gtk_widget_set_sensitive (submenu_item, FALSE);

        gtk_menu_shell_append (GTK_MENU_SHELL (submenu),
                               GTK_WIDGET (submenu_item));

      }
    }
    else if (strcmp(item_desktop_id, SEPARATOR_STRING) == 0)
    {
      /* Separator */
      menu_item = gtk_separator_menu_item_new();

      gtk_menu_shell_append (GTK_MENU_SHELL (menu),
      		             GTK_WIDGET (menu_item));
      	    
    }
    else
    {
      /* Application */
      menu_item = hildon_thumb_menu_item_new_with_labels (
      		(item_text_domain && *item_text_domain)?
      		dgettext(item_text_domain, item_name):
      		dgettext("maemo-af-desktop", item_name),
      		NULL,
      		/* work around strange behaviour of gettext for
      		 * empty  strings
      		 */
      		(item_comment && *item_comment)?_(item_comment):"");

      if (!item_icon)
      {
        item_icon = get_icon (MENU_ITEM_DEFAULT_APP_ICON,
      		              MENU_ITEM_ICON_SIZE);
      }

      if (!item_thumb_icon)
      {
        item_thumb_icon = get_icon (MENU_ITEM_DEFAULT_APP_ICON,
      		                    MENU_ITEM_THUMB_ICON_SIZE);
      }

      if (item_icon && item_thumb_icon)
      {
        hildon_thumb_menu_item_set_images (
      		   HILDON_THUMB_MENU_ITEM (menu_item),
      		   gtk_image_new_from_pixbuf (item_icon),
      		   gtk_image_new_from_pixbuf (item_thumb_icon));
      }

      gtk_menu_shell_append (GTK_MENU_SHELL (menu),
      		             GTK_WIDGET (menu_item));

      g_object_set_data_full (G_OBJECT (menu_item),
      		              DESKTOP_ENTRY_EXEC_FIELD,
      		              g_strdup (item_exec), 
			      g_free);

      g_object_set_data_full (G_OBJECT(menu_item),
      		              DESKTOP_ENTRY_SERVICE_FIELD,
      		              g_strdup (item_service), 
			      g_free);

      /* Connect the signal and callback */
      g_signal_connect (G_OBJECT (menu_item), 
		        "activate",
      		        G_CALLBACK (hn_others_menu_activate_item),
      		        button);
    }
 
    g_free (item_name);
    
    if (item_icon)
      g_object_unref (G_OBJECT (item_icon));
    
    if (item_thumb_icon)
      g_object_unref (G_OBJECT (item_thumb_icon));
    
    g_free (item_exec);
    g_free (item_service);
    g_free (item_desktop_id);
    g_free (item_comment);
    g_free (item_text_domain);
	    
  } while (gtk_tree_model_iter_next(model, iter));


  if (my_iterator)
  {
    gtk_tree_iter_free (iter);
    
    g_debug ("ref count remaining on model %d (should be 1)",
             G_OBJECT (model)->ref_count);
  }
  
  g_object_unref (G_OBJECT (model));
}
Пример #24
0
void menu(int argc, char* argv[])
{
    GtkWidget* window;
    GtkWidget* box;
    GtkWidget* menubar;
    GtkWidget* menu;
    GtkWidget* editmenu;
    GtkWidget* helpmenu;
    GtkWidget* rootmenu;
    GtkWidget* menuitem;
    GtkAccelGroup* accel_group;
    gtk_init(&argc, &argv);
    window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(window), txt("²Ëµ¥²âÊÔ³ÌÐò"));
    g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL);

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

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

    menu=gtk_menu_new();    //Îļþ²Ëµ¥

    menuitem=gtk_image_menu_item_new_from_stock(GTK_STOCK_NEW, accel_group);
    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
    g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(on_menu_activate), (gpointer)(txt("н¨")));

    menuitem=gtk_image_menu_item_new_from_stock(GTK_STOCK_OPEN, accel_group);
    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
    g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(on_menu_activate), (gpointer)(txt("´ò¿ª")));

    menuitem=gtk_image_menu_item_new_from_stock(GTK_STOCK_SAVE, accel_group);
    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
    g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(on_menu_activate), (gpointer)(txt("±£´æ")));

    menuitem=gtk_image_menu_item_new_from_stock(GTK_STOCK_SAVE_AS, accel_group);
    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
    g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(on_menu_activate), (gpointer)(txt("Áí´æΪ")));

    menuitem=gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, accel_group);
    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
    g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(on_menu_activate), (gpointer)(txt("Í˳ö")));

    rootmenu=gtk_menu_item_new_with_label(txt("Îļþ"));
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(rootmenu), menu);

    menubar=gtk_menu_bar_new();
    gtk_menu_shell_append(GTK_MENU_SHELL(menubar), rootmenu);

    //menuitem=gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, accel_group);
    //gtk_menu_shell_append(GTK_MENU_SHELL(menubar), menuitem);

    rootmenu=gtk_menu_item_new_with_label(txt("±à¼­"));
    editmenu=gtk_menu_new();//±à¼­²Ëµ¥

    menuitem=gtk_image_menu_item_new_from_stock(GTK_STOCK_CUT,accel_group);
    gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), menuitem);
    g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(on_menu_activate), (gpointer)(txt("¼ôÇÐ")));

    menuitem=gtk_image_menu_item_new_from_stock(GTK_STOCK_COPY,accel_group);
    gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), menuitem);
    g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(on_menu_activate), (gpointer)(txt("¸´ÖÆ")));

    menuitem=gtk_image_menu_item_new_from_stock(GTK_STOCK_PASTE,accel_group);
    gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), menuitem);
    g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(on_menu_activate), (gpointer)(txt("Õ³Ìù")));

    menuitem=gtk_image_menu_item_new_from_stock(GTK_STOCK_FIND,accel_group);
    gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), menuitem);
    g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(on_menu_activate), (gpointer)(txt("²éÕÒ")));

    gtk_menu_item_set_submenu(GTK_MENU_ITEM(rootmenu), editmenu);
    gtk_menu_shell_append(GTK_MENU_SHELL(menubar), rootmenu);

    rootmenu=gtk_menu_item_new_with_label(txt("°ïÖú"));
    helpmenu=gtk_menu_new();//°ïÖú²Ëµ¥

    menuitem=gtk_image_menu_item_new_from_stock(GTK_STOCK_HELP,accel_group);
    gtk_menu_shell_append(GTK_MENU_SHELL(helpmenu), menuitem);
    g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(on_menu_activate), (gpointer)(txt("°ïÖú")));

    menuitem=gtk_menu_item_new_with_label(txt("¹ØÓÚ..."));
    gtk_menu_shell_append(GTK_MENU_SHELL(helpmenu), menuitem);
    g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(on_menu_activate), (gpointer)(txt("¹ØÓÚ")));

    gtk_menu_item_set_submenu(GTK_MENU_ITEM(rootmenu), helpmenu);
    gtk_menu_shell_append(GTK_MENU_SHELL(menubar), rootmenu);
    gtk_box_pack_start(GTK_BOX(box), menubar, FALSE, FALSE, 0);
    gtk_widget_show_all(window);
    gtk_main();
}
Пример #25
0
bool wxMenu::GtkAppend(wxMenuItem *mitem, int pos)
{
    GtkWidget *menuItem;

    wxString text;
    GtkLabel* label = NULL;

    if ( mitem->IsSeparator() )
    {
        // TODO
        menuItem = gtk_menu_item_new();
    }
    else if (mitem->GetBitmap().IsOk())
    {
        text = mitem->wxMenuItemBase::GetItemLabel();
        const wxBitmap *bitmap = &mitem->GetBitmap();

        // TODO
        wxUnusedVar(bitmap);
        menuItem = gtk_menu_item_new_with_label( wxGTK_CONV( text ) );
        label = GTK_LABEL( GTK_BIN(menuItem)->child );

        m_prevRadio = NULL;
    }
    else // a normal item
    {
        // text has "_" instead of "&" after mitem->SetItemLabel() so don't use it
        text =  mitem->wxMenuItemBase::GetItemLabel() ;

        switch ( mitem->GetKind() )
        {
            case wxITEM_CHECK:
            {
                menuItem = gtk_check_menu_item_new_with_label( wxGTK_CONV( text ) );
                label = GTK_LABEL( GTK_BIN(menuItem)->child );
                // set new text
                gtk_label_set_text( label, wxGTK_CONV( text ) );
                m_prevRadio = NULL;
                break;
            }

            case wxITEM_RADIO:
            {
                GSList *group = NULL;
                if ( m_prevRadio == NULL )
                {
                    // start of a new radio group
                    m_prevRadio = menuItem = gtk_radio_menu_item_new_with_label( group, wxGTK_CONV( text ) );
                    label = GTK_LABEL( GTK_BIN(menuItem)->child );
                    // set new text
                    gtk_label_set_text( label, wxGTK_CONV( text ) );
                }
                else // continue the radio group
                {
                    group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (m_prevRadio));
                    m_prevRadio = menuItem = gtk_radio_menu_item_new_with_label( group, wxGTK_CONV( text ) );
                    label = GTK_LABEL( GTK_BIN(menuItem)->child );
                }
                break;
            }

            default:
                wxFAIL_MSG( wxT("unexpected menu item kind") );
                // fall through

            case wxITEM_NORMAL:
            {
                menuItem = gtk_menu_item_new_with_label( wxGTK_CONV( text ) );
                label = GTK_LABEL( GTK_BIN(menuItem)->child );
                m_prevRadio = NULL;
                break;
            }
        }

    }

    guint accel_key;
    GdkModifierType accel_mods;
    wxCharBuffer buf = wxGTK_CONV( GetGtkHotKey(*mitem) );

    // wxPrintf( wxT("item: %s hotkey %s\n"), mitem->GetItemLabel().c_str(), GetGtkHotKey(*mitem).c_str() );
    gtk_accelerator_parse( (const char*) buf, &accel_key, &accel_mods);
    if (accel_key != 0)
    {
        gtk_widget_add_accelerator (GTK_WIDGET(menuItem),
                                    "activate",
                                    m_accel,
                                    accel_key,
                                    accel_mods,
                                    GTK_ACCEL_VISIBLE);
    }

    if (pos == -1)
        gtk_menu_shell_append(GTK_MENU_SHELL(m_menu), menuItem);
    else
        gtk_menu_shell_insert(GTK_MENU_SHELL(m_menu), menuItem, pos);

    gtk_widget_show( menuItem );

    if ( !mitem->IsSeparator() )
    {
        wxASSERT_MSG( menuItem, wxT("invalid menuitem") );

        gtk_signal_connect( GTK_OBJECT(menuItem), "select",
                            GTK_SIGNAL_FUNC(gtk_menu_hilight_callback),
                            (gpointer)this );

        gtk_signal_connect( GTK_OBJECT(menuItem), "deselect",
                            GTK_SIGNAL_FUNC(gtk_menu_nolight_callback),
                            (gpointer)this );

        if ( mitem->IsSubMenu() && mitem->GetKind() != wxITEM_RADIO && mitem->GetKind() != wxITEM_CHECK )
        {
            gtk_menu_item_set_submenu( GTK_MENU_ITEM(menuItem), mitem->GetSubMenu()->m_menu );

            gtk_widget_show( mitem->GetSubMenu()->m_menu );
        }
        else
        {
            gtk_signal_connect( GTK_OBJECT(menuItem), "activate",
                                GTK_SIGNAL_FUNC(gtk_menu_clicked_callback),
                                (gpointer)this );
        }

        guint accel_key = gtk_label_parse_uline (GTK_LABEL(label), wxGTK_CONV( text ) );
        if (accel_key != GDK_VoidSymbol)
        {
            gtk_widget_add_accelerator (menuItem,
                                        "activate_item",
                                        gtk_menu_ensure_uline_accel_group(GTK_MENU(m_menu)),
                                        accel_key,
                                        GDK_MOD1_MASK,
                                        GTK_ACCEL_LOCKED);
        }
    }

    mitem->SetMenuItem(menuItem);

    if (ms_locked)
    {
        // This doesn't even exist!
        // gtk_widget_lock_accelerators(mitem->GetMenuItem());
    }

    return true;
}
int main( int argc, char *argv[])
{
    GtkWidget *window;
    GtkWidget *vbox;
    GtkWidget *menubar;
    GtkWidget *filemenu, *item_file, *item_new, *item_quit;
    GtkWidget *editmenu, *item_edit, *item_undo, *item_redo, *item_cut, *item_copy, *item_paste;

    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), "menu demo");

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

    menubar = gtk_menu_bar_new();   //菜单栏构件(menubar),实际上是一个menu shell

    filemenu = gtk_menu_new();      //菜单构件(menu),也是一个menu shell
    item_file = gtk_menu_item_new_with_label("File");
    item_new = gtk_menu_item_new_with_label("New");
    item_quit = gtk_menu_item_new_with_label("Quit");

    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_file), filemenu);

    gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), item_new);
    gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), item_quit); //把“quit”菜单选项被填加进file菜单中
    gtk_menu_shell_append(GTK_MENU_SHELL(menubar), item_file);  //把“file”菜单选项被填加进菜单中(menubar)

    /*这里构建Edit菜单,同上面的file菜单添加方法一样*/
    editmenu = gtk_menu_new();       //菜单构件(menu),也是一个menu shell
    item_edit = gtk_menu_item_new_with_label("Edit");
    item_undo = gtk_menu_item_new_with_label("Undo");
    item_redo = gtk_menu_item_new_with_label("Redo");
    item_cut = gtk_menu_item_new_with_label("Cut");
    item_copy = gtk_menu_item_new_with_label("Copy");
    item_paste = gtk_menu_item_new_with_label("Paste");

    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_edit), editmenu);

    gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), item_redo);
    gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), item_cut);
    gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), item_copy);
    gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), item_paste);
    gtk_menu_shell_append(GTK_MENU_SHELL(menubar), item_edit);      //把“edit”菜单选项被填加进菜单中(menubar)


    /*这里把窗口分为了上中下3个区域,最上面是menubar*/
    gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 3);


    g_signal_connect_swapped(G_OBJECT(window),
                             "destroy",G_CALLBACK(gtk_main_quit), NULL);
    /*信号:当你单击“quit”菜单按钮,程序就会退出。*/
    g_signal_connect(G_OBJECT(item_quit),
                     "activate",G_CALLBACK(gtk_main_quit), NULL);

    gtk_widget_show_all(window);
    gtk_main();
    return 0;
}
Пример #27
0
bool wxMenu::GtkAppend(wxMenuItem *mitem, int pos)
{
    GtkWidget *menuItem;
    switch (mitem->GetKind())
    {
        case wxITEM_SEPARATOR:
            menuItem = gtk_separator_menu_item_new();
            break;
        case wxITEM_CHECK:
            menuItem = gtk_check_menu_item_new_with_label("");
            break;
        case wxITEM_RADIO:
            {
                // See if we need to create a new radio group for this item or
                // add it to an existing one.
                wxMenuItem* radioGroupItem = NULL;

                const size_t numItems = GetMenuItemCount();
                const size_t n = pos == -1 ? numItems
                                           : static_cast<size_t>(pos);
                if ( n > 0 )
                {
                    wxMenuItem* const itemPrev = FindItemByPosition(n - 1);
                    if ( itemPrev->GetKind() == wxITEM_RADIO )
                    {
                        // Appending an item after an existing radio item puts
                        // it into the same radio group.
                        radioGroupItem = itemPrev;
                    }
                }

                if ( n < numItems )
                {
                    wxMenuItem* const itemNext = FindItemByPosition(n);
                    if ( itemNext->GetKind() == wxITEM_RADIO )
                    {
                        // Inserting an item before an existing radio item
                        // also puts it into the existing radio group.
                        radioGroupItem = itemNext;
                    }
                }

                GSList* group = NULL;
                if ( radioGroupItem )
                {
                    group = gtk_radio_menu_item_get_group(
                              GTK_RADIO_MENU_ITEM(radioGroupItem->GetMenuItem())
                            );
                }

                menuItem = gtk_radio_menu_item_new_with_label(group, "");
            }
            break;
        default:
            wxFAIL_MSG("unexpected menu item kind");
            // fall through
        case wxITEM_NORMAL:
            const wxBitmap& bitmap = mitem->GetBitmap();
            const char* stockid;
            if (bitmap.IsOk())
            {
                // always use pixbuf, because pixmap mask does not
                // work with disabled images in some themes
                GtkWidget* image = gtk_image_new_from_pixbuf(bitmap.GetPixbuf());
                menuItem = gtk_image_menu_item_new_with_label("");
                gtk_widget_show(image);
                gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menuItem), image);
            }
            else if ((stockid = wxGetStockGtkID(mitem->GetId())) != NULL)
                // use stock bitmap for this item if available on the assumption
                // that it never hurts to follow GTK+ conventions more closely
                menuItem = gtk_image_menu_item_new_from_stock(stockid, NULL);
            else
                menuItem = gtk_menu_item_new_with_label("");
            break;
    }
    mitem->SetMenuItem(menuItem);

    gtk_menu_shell_insert(GTK_MENU_SHELL(m_menu), menuItem, pos);

    gtk_widget_show( menuItem );

    if ( !mitem->IsSeparator() )
    {
        mitem->SetGtkLabel();
        g_signal_connect (menuItem, "select",
                          G_CALLBACK(menuitem_select), mitem);
        g_signal_connect (menuItem, "deselect",
                          G_CALLBACK(menuitem_deselect), mitem);

        if ( mitem->IsSubMenu() && mitem->GetKind() != wxITEM_RADIO && mitem->GetKind() != wxITEM_CHECK )
        {
            gtk_menu_item_set_submenu( GTK_MENU_ITEM(menuItem), mitem->GetSubMenu()->m_menu );

            gtk_widget_show( mitem->GetSubMenu()->m_menu );
        }
        else
        {
            g_signal_connect(menuItem, "can_activate_accel",
                G_CALLBACK(can_activate_accel), this);
            g_signal_connect (menuItem, "activate",
                              G_CALLBACK(menuitem_activate),
                              mitem);
        }
    }

    return true;
}
Пример #28
0
void do_away_menu()
{
	GtkWidget *menuitem;
	GtkWidget *remmenu;
	GtkWidget *submenu, *submenu2;
	GtkWidget *remitem;
	GtkWidget *image;
	GdkPixbuf *pixbuf, *scale;
	GList *l;
	GSList *awy = away_messages;
	struct away_message *a;
	GList *con;
	GaimConnection *gc = NULL;
	GaimPluginProtocolInfo *prpl_info = NULL;

	int count = 0;

	if (prefs_away_store != NULL) {
		gtk_list_store_clear(prefs_away_store);
		while (awy) {
			GtkTreeIter iter;
			a = (struct away_message *)awy->data;
			gtk_list_store_append(prefs_away_store, &iter);
			gtk_list_store_set(prefs_away_store, &iter,
					0, a->name,
					1, a,
					-1);
			awy = g_slist_next(awy);
		}
	}

	if (awaymenu) {
		l = gtk_container_get_children(GTK_CONTAINER(awaymenu));

		while (l) {
			gtk_container_remove(GTK_CONTAINER(awaymenu), GTK_WIDGET(l->data));
			l = l->next;
		}

		g_list_free(l);

		remmenu = gtk_menu_new();

		menuitem = gtk_menu_item_new_with_label(_("New Away Message"));
		gtk_menu_shell_append(GTK_MENU_SHELL(awaymenu), menuitem);
		gtk_widget_show(menuitem);
		g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(create_away_mess),
				   NULL);

		awy = away_messages;
		while (awy) {
			a = (struct away_message *)awy->data;

			remitem = gtk_menu_item_new_with_label(a->name);
			gtk_menu_shell_append(GTK_MENU_SHELL(remmenu), remitem);
			gtk_widget_show(remitem);
			g_signal_connect(G_OBJECT(remitem), "activate",
					   G_CALLBACK(rem_away_mess), a);

			awy = g_slist_next(awy);

		}

		menuitem = gtk_menu_item_new_with_label(_("Remove Away Message"));
		gtk_menu_shell_append(GTK_MENU_SHELL(awaymenu), menuitem);
		gtk_widget_show(menuitem);
		gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), remmenu);
		gtk_widget_show(remmenu);

		gaim_separator(awaymenu);

		for (con = gaim_connections_get_all(); con != NULL; con = con->next) {
			gc = con->data;

			prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(gc->prpl);

			if (prpl_info->away_states != NULL && prpl_info->set_away != NULL)
				count++;
		}

		if (count == 0) {
		} else if (count == 1) {
			GList *msgs, *tmp;

			for (con = gaim_connections_get_all(); con != NULL; con = con->next) {
				gc = con->data;

				prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(gc->prpl);

				if (prpl_info->away_states && prpl_info->set_away)
					break;
			}

			tmp = msgs = prpl_info->away_states(gc);

			if ((g_list_length(msgs) == 1) && !strcmp(msgs->data, GAIM_AWAY_CUSTOM)) {
				awy = away_messages;

				while (awy) {
					a = (struct away_message *)awy->data;

					menuitem = gtk_menu_item_new_with_label(a->name);
					g_object_set_data(G_OBJECT(menuitem), "away_message", a);
					gtk_menu_shell_append(GTK_MENU_SHELL(awaymenu), menuitem);
					gtk_widget_show(menuitem);
					g_signal_connect(G_OBJECT(menuitem), "activate",
							   G_CALLBACK(do_away_message), a);

					awy = g_slist_next(awy);
				}
			} else
				while (msgs) {
					awy = away_messages;

					menuitem = gtk_menu_item_new_with_label(msgs->data);
					g_object_set_data(G_OBJECT(menuitem), "away_state", msgs->data);
					gtk_menu_shell_append(GTK_MENU_SHELL(awaymenu), menuitem);
					gtk_widget_show(menuitem);

					if (strcmp(msgs->data, GAIM_AWAY_CUSTOM)) {
						g_signal_connect(G_OBJECT(menuitem), "activate",
								   G_CALLBACK(set_gc_state), gc);
					} else {
						submenu = gtk_menu_new();
						gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem),
									  submenu);
						gtk_widget_show(submenu);

						while (awy) {
							a = (struct away_message *)awy->data;

							menuitem = gtk_menu_item_new_with_label(a->name);
							g_object_set_data(G_OBJECT(menuitem), "away_message",
									a);
							gtk_menu_shell_append(GTK_MENU_SHELL(awaymenu),
									menuitem);
							gtk_widget_show(menuitem);
							g_signal_connect(G_OBJECT(menuitem),
									   "activate",
									   G_CALLBACK
									   (do_away_message), a);

							awy = g_slist_next(awy);
						}
					}
					msgs = g_list_next(msgs);
				}

			g_list_free(tmp);
		}
		else {
			for (con = gaim_connections_get_all(); con != NULL; con = con->next) {
				GaimAccount *account;
				char buf[256];
				GList *msgs, *tmp;
				gc = con->data;

				prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(gc->prpl);

				if (!prpl_info->away_states || !prpl_info->set_away)
					continue;

				account = gaim_connection_get_account(gc);

				g_snprintf(buf, sizeof(buf), "%s (%s)",
						   gaim_account_get_username(account),
						   gaim_account_get_protocol_name(account));
				menuitem = gtk_image_menu_item_new_with_label(buf);

				pixbuf = create_prpl_icon(gc->account);
				if (pixbuf) {
					scale = gdk_pixbuf_scale_simple(pixbuf, 16, 16, GDK_INTERP_BILINEAR);
					image = gtk_image_new_from_pixbuf(scale);
					g_object_unref(G_OBJECT(pixbuf));
					g_object_unref(G_OBJECT(scale));
					gtk_widget_show(image);
					gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menuitem),
							image);
				}

				gtk_menu_shell_append(GTK_MENU_SHELL(awaymenu), menuitem);
				gtk_widget_show(menuitem);

				submenu = gtk_menu_new();
				gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), submenu);
				gtk_widget_show(submenu);

				tmp = msgs = prpl_info->away_states(gc);

				if ((g_list_length(msgs) == 1) &&
				    (!strcmp(msgs->data, GAIM_AWAY_CUSTOM))) {
					menuitem = gtk_menu_item_new_with_label(_("Back"));
					gtk_menu_shell_append(GTK_MENU_SHELL(submenu), menuitem);
					gtk_widget_show(menuitem);
					g_signal_connect(G_OBJECT(menuitem), "activate",
							   G_CALLBACK(set_gc_away), gc);

					gaim_separator(submenu);

					awy = away_messages;

					while (awy) {
						a = (struct away_message *)awy->data;

						menuitem = gtk_menu_item_new_with_label(a->name);
						g_object_set_data(G_OBJECT(menuitem), "away_message", a);
						gtk_menu_shell_append(GTK_MENU_SHELL(submenu), menuitem);
						gtk_widget_show(menuitem);
						g_signal_connect(G_OBJECT(menuitem), "activate",
								   G_CALLBACK(set_gc_away), gc);

						awy = g_slist_next(awy);
					}
				} else
					while (msgs) {
						awy = away_messages;

						menuitem = gtk_menu_item_new_with_label(msgs->data);
						g_object_set_data(G_OBJECT(menuitem), "away_state",
									 msgs->data);
						gtk_menu_shell_append(GTK_MENU_SHELL(submenu), menuitem);
						gtk_widget_show(menuitem);

						if (strcmp(msgs->data, GAIM_AWAY_CUSTOM)) {
							g_signal_connect(G_OBJECT(menuitem),
									   "activate",
									   G_CALLBACK(set_gc_state),
									   gc);
						} else {
							submenu2 = gtk_menu_new();
							gtk_menu_item_set_submenu(GTK_MENU_ITEM
										  (menuitem), submenu2);
							gtk_widget_show(submenu2);

							while (awy) {
								a = (struct away_message *)awy->data;

								menuitem =
								    gtk_menu_item_new_with_label(a->
												 name);
								g_object_set_data(G_OBJECT(menuitem),
										"away_message", a);
								gtk_menu_shell_append(GTK_MENU_SHELL(submenu2),
										menuitem);
								gtk_widget_show(menuitem);
								g_signal_connect(G_OBJECT(menuitem),
										   "activate",
										   G_CALLBACK
										   (set_gc_away), gc);

								awy = g_slist_next(awy);
							}
						}
						msgs = g_list_next(msgs);
					}

				g_list_free(tmp);
			}

			menuitem = gtk_menu_item_new_with_label(_("Set All Away"));
			gtk_menu_shell_append(GTK_MENU_SHELL(awaymenu), menuitem);
			gtk_widget_show(menuitem);

			submenu = gtk_menu_new();
			gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), submenu);
			gtk_widget_show(submenu);

			awy = away_messages;

			while (awy) {
				a = (struct away_message *)awy->data;

				menuitem = gtk_menu_item_new_with_label(a->name);
				g_object_set_data(G_OBJECT(menuitem), "away_message", a);
				gtk_menu_shell_append(GTK_MENU_SHELL(submenu), menuitem);
				gtk_widget_show(menuitem);
				g_signal_connect(G_OBJECT(menuitem), "activate",
						   G_CALLBACK(do_away_message), a);

				awy = g_slist_next(awy);
			}
		}
	}

	if (prefs_away_menu) {
		l = gtk_container_get_children(GTK_CONTAINER(prefs_away_menu));
		while (l) {
			gtk_widget_destroy(GTK_WIDGET(l->data));
			l = l->next;
		}
		gtk_widget_hide(GTK_WIDGET(prefs_away_menu));
		default_away_menu_init(GTK_WIDGET(prefs_away_menu));
		gtk_widget_show(prefs_away_menu);
	}
}
Пример #29
0
MetaWindowMenu*
meta_window_menu_new   (MetaFrames         *frames,
                        MetaMenuOp          ops,
                        MetaMenuOp          insensitive,
                        Window              client_xwindow,
                        unsigned long       active_workspace,
                        int                 n_workspaces,
                        MetaWindowMenuFunc  func,
                        gpointer            data)
{
  int i;
  MetaWindowMenu *menu;

  /* FIXME: Modifications to 'ops' should happen in meta_window_show_menu */
  if (n_workspaces < 2)
    ops &= ~(META_MENU_OP_STICK | META_MENU_OP_UNSTICK | META_MENU_OP_WORKSPACES);
  else if (n_workspaces == 2)
    /* #151183: If we only have two workspaces, disable the menu listing them. */
    ops &= ~(META_MENU_OP_WORKSPACES);

  menu = g_new (MetaWindowMenu, 1);
  menu->frames = frames;
  menu->client_xwindow = client_xwindow;
  menu->func = func;
  menu->data = data;
  menu->ops = ops;
  menu->insensitive = insensitive;

  menu->menu = gtk_menu_new ();

  gtk_menu_set_screen (GTK_MENU (menu->menu),
                       gtk_widget_get_screen (GTK_WIDGET (frames)));

  for (i = 0; i < (int) G_N_ELEMENTS (menuitems); i++)
    {
      MenuItem menuitem = menuitems[i];
      if (ops & menuitem.op || menuitem.op == 0)
        {
          GtkWidget *mi;
          MenuData *md;
          unsigned int key;
          MetaVirtualModifier mods;

          mi = menu_item_new (&menuitem, -1);

          /* Set the activeness of radiobuttons. */
          switch (menuitem.op)
            {
            case META_MENU_OP_STICK:
              gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi),
                                              active_workspace == 0xFFFFFFFF);
              break;
            case META_MENU_OP_UNSTICK:
              gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi),
                                              active_workspace != 0xFFFFFFFF);
              break;
            default:
              break;
            }

          if (menuitem.type == MENU_ITEM_WORKSPACE_LIST)
            {
              if (ops & META_MENU_OP_WORKSPACES)
                {
                  Display *display;
                  Window xroot;
                  GdkScreen *screen;
                  GtkWidget *submenu;
                  int j;

                  MenuItem to_another_workspace = {
                    0, MENU_ITEM_NORMAL,
                    NULL, FALSE,
                    N_("Move to Another _Workspace")
                  };

                  meta_verbose ("Creating %d-workspace menu current space %lu\n",
                      n_workspaces, active_workspace);

                  display = gdk_x11_drawable_get_xdisplay (GTK_WIDGET (frames)->window);

                  screen = gdk_drawable_get_screen (GTK_WIDGET (frames)->window);
                  xroot = GDK_DRAWABLE_XID (gdk_screen_get_root_window (screen));

                  submenu = gtk_menu_new ();

                  g_assert (mi==NULL);
                  mi = menu_item_new (&to_another_workspace, -1);
                  gtk_menu_item_set_submenu (GTK_MENU_ITEM (mi), submenu);

                  for (j = 0; j < n_workspaces; j++)
                    {
                      char *label;
                      MenuData *md;
                      unsigned int key;
                      MetaVirtualModifier mods;
                      MenuItem moveitem;
                      GtkWidget *submi;

                      meta_core_get_menu_accelerator (META_MENU_OP_WORKSPACES,
                          j + 1,
                          &key, &mods);

                      label = get_workspace_name_with_accel (display, xroot, j);

                      moveitem.type = MENU_ITEM_NORMAL;
                      moveitem.op = META_MENU_OP_WORKSPACES;
                      moveitem.label = label;
                      submi = menu_item_new (&moveitem, j + 1);

                      g_free (label);

                      if ((active_workspace == (unsigned)j) && (ops & META_MENU_OP_UNSTICK))
                        gtk_widget_set_sensitive (submi, FALSE);

                      md = g_new (MenuData, 1);

                      md->menu = menu;
                      md->op = META_MENU_OP_WORKSPACES;

                      g_object_set_data (G_OBJECT (submi),
                          "workspace",
                          GINT_TO_POINTER (j));

                      gtk_signal_connect_full (GTK_OBJECT (submi),
                          "activate",
                          G_CALLBACK (activate_cb),
                          NULL,
                          md,
                          g_free, FALSE, FALSE);

                      gtk_menu_shell_append (GTK_MENU_SHELL (submenu), submi);

                      gtk_widget_show (submi);
                    }
                  }
                else
                  meta_verbose ("not creating workspace menu\n");
            }
          else if (menuitem.type != MENU_ITEM_SEPARATOR)
            {
              meta_core_get_menu_accelerator (menuitems[i].op, -1,
                                              &key, &mods);

              if (insensitive & menuitem.op)
                gtk_widget_set_sensitive (mi, FALSE);

              md = g_new (MenuData, 1);

              md->menu = menu;
              md->op = menuitem.op;

              gtk_signal_connect_full (GTK_OBJECT (mi),
                                       "activate",
                                       G_CALLBACK (activate_cb),
                                       NULL,
                                       md,
                                       g_free, FALSE, FALSE);
            }

          if (mi)
            {
              gtk_menu_shell_append (GTK_MENU_SHELL (menu->menu), mi);

              gtk_widget_show (mi);
            }
        }
    }

	g_signal_connect (menu->menu, "selection_done", G_CALLBACK(menu_closed), menu);

	return menu;
}
Пример #30
0
void ui_set_menu() {

    mwin->menu = gtk_menu_bar_new();

    GtkAccelGroup *group_file = ui_set_menu_item(&(mwin->menu_file), 
        &(mwin->menu_file_item), "_File");
    GtkAccelGroup *group_edit = ui_set_menu_item(&(mwin->menu_edit), 
        &(mwin->menu_edit_item), "_Edit");
    GtkAccelGroup *group_help = ui_set_menu_item(&(mwin->menu_help), 
        &(mwin->menu_help_item), "_Help");

    /* create submenu items */
    mwin->menu_file_item_open = gtk_menu_item_new_with_mnemonic("_Open");
    mwin->menu_file_item_compare = gtk_menu_item_new_with_mnemonic("_Compare To");
    mwin->menu_file_item_exit = gtk_menu_item_new_with_mnemonic("_Exit");
    mwin->menu_file_item_space = gtk_separator_menu_item_new();
    mwin->menu_edit_item_update = gtk_menu_item_new_with_mnemonic("_Update");
    mwin->menu_edit_item_purge = gtk_menu_item_new_with_mnemonic("_Purge Lists");
    mwin->menu_help_item_about = gtk_menu_item_new_with_mnemonic("_About");

    /* add accelerator keys to menu */
    gtk_widget_add_accelerator(mwin->menu_file_item_open, "activate", 
        group_file, GDK_KEY_O, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
    gtk_widget_add_accelerator(mwin->menu_file_item_compare, "activate", 
        group_file, GDK_KEY_L, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
    gtk_widget_add_accelerator(mwin->menu_file_item_exit, "activate", 
        group_file, GDK_KEY_Q, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
    gtk_widget_add_accelerator(mwin->menu_edit_item_update, "activate", 
        group_edit, GDK_KEY_U, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
    gtk_widget_add_accelerator(mwin->menu_edit_item_purge, "activate", 
        group_edit, GDK_KEY_P, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
    gtk_widget_add_accelerator(mwin->menu_help_item_about, "activate", 
        group_help, GDK_KEY_A, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);

    /* append menu items to menus */
    gtk_menu_shell_append(GTK_MENU_SHELL(mwin->menu_file), mwin->menu_file_item_open);
    gtk_menu_shell_append(GTK_MENU_SHELL(mwin->menu_file), mwin->menu_file_item_compare);
    gtk_menu_shell_append(GTK_MENU_SHELL(mwin->menu_file), mwin->menu_file_item_space);
    gtk_menu_shell_append(GTK_MENU_SHELL(mwin->menu_file), mwin->menu_file_item_exit);
    gtk_menu_shell_append(GTK_MENU_SHELL(mwin->menu_edit), mwin->menu_edit_item_update);
    gtk_menu_shell_append(GTK_MENU_SHELL(mwin->menu_edit), mwin->menu_edit_item_purge);
    gtk_menu_shell_append(GTK_MENU_SHELL(mwin->menu_help), mwin->menu_help_item_about);

    /* attach callback functions to menu-items */
    g_signal_connect_swapped(G_OBJECT(mwin->menu_file_item_open), 
        "activate", G_CALLBACK(menu_signal_open), (gpointer)nb_lists_mov_tab);
    g_signal_connect_swapped(G_OBJECT(mwin->menu_file_item_compare), 
        "activate", G_CALLBACK(menu_signal_open), (gpointer)nb_lists_lst_tab);
    g_signal_connect_swapped(G_OBJECT(mwin->menu_file_item_exit), 
        "activate", G_CALLBACK(menu_signal_quit), (gpointer)mwin->main);
    g_signal_connect_swapped(G_OBJECT(mwin->menu_edit_item_update), 
        "activate", G_CALLBACK(menu_signal_update), (gpointer)mwin->main);
    g_signal_connect_swapped(G_OBJECT(mwin->menu_edit_item_purge), 
        "activate", G_CALLBACK(menu_signal_purge), (gpointer)mwin->main);
    g_signal_connect_swapped(G_OBJECT(mwin->menu_help_item_about), 
        "activate", G_CALLBACK(menu_signal_about), (gpointer)mwin->main);

    /* add submenus to menu items */
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(mwin->menu_file_item), 
        mwin->menu_file);
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(mwin->menu_edit_item), 
        mwin->menu_edit);
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(mwin->menu_help_item), 
        mwin->menu_help);

    /* add to main menubar */
    gtk_menu_shell_append(GTK_MENU_SHELL(mwin->menu), mwin->menu_file_item);
    gtk_menu_shell_append(GTK_MENU_SHELL(mwin->menu), mwin->menu_edit_item);
    gtk_menu_shell_append(GTK_MENU_SHELL(mwin->menu), mwin->menu_help_item);
}