コード例 #1
2
ファイル: testtoolbar.c プロジェクト: GYGit/gtk
gint
main (gint argc, gchar **argv)
{
  GtkWidget *window, *toolbar, *grid, *treeview, *scrolled_window;
  GtkWidget *hbox, *hbox1, *hbox2, *checkbox, *option_menu, *menu;
  gint i;
  static const gchar *toolbar_styles[] = { "icons", "text", "both (vertical)",
					   "both (horizontal)" };
  GtkToolItem *item;
  GtkListStore *store;
  GtkWidget *image;
  GtkWidget *menuitem;
  GtkWidget *button;
  GtkWidget *label;
  GIcon *gicon;
  GSList *group;
  
  gtk_init (&argc, &argv);

  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

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

  grid = gtk_grid_new ();
  gtk_container_add (GTK_CONTAINER (window), grid);

  toolbar = gtk_toolbar_new ();
  gtk_grid_attach (GTK_GRID (grid), toolbar, 0, 0, 2, 1);

  hbox1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3);
  gtk_container_set_border_width (GTK_CONTAINER (hbox1), 5);
  gtk_grid_attach (GTK_GRID (grid), hbox1, 1, 1, 1, 1);

  hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
  gtk_container_set_border_width (GTK_CONTAINER (hbox2), 5);
  gtk_grid_attach (GTK_GRID (grid), hbox2, 1, 2, 1, 1);

  checkbox = gtk_check_button_new_with_mnemonic("_Vertical");
  gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0);
  g_signal_connect (checkbox, "toggled",
		    G_CALLBACK (change_orientation), toolbar);

  checkbox = gtk_check_button_new_with_mnemonic("_Show Arrow");
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), TRUE);
  gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0);
  g_signal_connect (checkbox, "toggled",
		    G_CALLBACK (change_show_arrow), toolbar);

  checkbox = gtk_check_button_new_with_mnemonic("_Set Toolbar Style:");
  g_signal_connect (checkbox, "toggled", G_CALLBACK (set_toolbar_style_toggled), toolbar);
  gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0);

  option_menu = gtk_combo_box_text_new ();
  gtk_widget_set_sensitive (option_menu, FALSE);  
  g_object_set_data (G_OBJECT (checkbox), "option-menu", option_menu);
  
  for (i = 0; i < G_N_ELEMENTS (toolbar_styles); i++)
    gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (option_menu), toolbar_styles[i]);
  gtk_combo_box_set_active (GTK_COMBO_BOX (option_menu),
                            gtk_toolbar_get_style (GTK_TOOLBAR (toolbar)));
  gtk_box_pack_start (GTK_BOX (hbox2), option_menu, FALSE, FALSE, 0);
  g_signal_connect (option_menu, "changed",
		    G_CALLBACK (change_toolbar_style), toolbar);

  checkbox = gtk_check_button_new_with_mnemonic("_Set Icon Size:"); 
  g_signal_connect (checkbox, "toggled", G_CALLBACK (set_icon_size_toggled), toolbar);
  gtk_box_pack_start (GTK_BOX (hbox2), checkbox, FALSE, FALSE, 0);

  option_menu = gtk_combo_box_text_new ();
  g_object_set_data (G_OBJECT (checkbox), "option-menu", option_menu);
  gtk_widget_set_sensitive (option_menu, FALSE);
  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (option_menu), "small toolbar");
  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (option_menu), "large toolbar");

  gtk_box_pack_start (GTK_BOX (hbox2), option_menu, FALSE, FALSE, 0);
  g_signal_connect (option_menu, "changed",
		    G_CALLBACK (icon_size_history_changed), toolbar);
  
  scrolled_window = gtk_scrolled_window_new (NULL, NULL);
  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
				  GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
  gtk_widget_set_hexpand (scrolled_window, TRUE);
  gtk_widget_set_vexpand (scrolled_window, TRUE);
  gtk_grid_attach (GTK_GRID (grid), scrolled_window, 1, 3, 1, 1);

  store = create_items_list (&treeview);
  gtk_container_add (GTK_CONTAINER (scrolled_window), treeview);
  
  item = gtk_tool_button_new (NULL, NULL);
  gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "document-new");
  gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Custom label");
  add_item_to_list (store, item, "New");
  gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
  gdk_threads_add_timeout (3000, (GSourceFunc) timeout_cb, item);
  gtk_tool_item_set_expand (item, TRUE);

  menu = gtk_menu_new ();
  for (i = 0; i < 20; i++)
    {
      char *text;
      text = g_strdup_printf ("Menuitem %d", i);
      menuitem = gtk_menu_item_new_with_label (text);
      g_free (text);
      gtk_widget_show (menuitem);
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
    }

  item = gtk_menu_tool_button_new (NULL, NULL);
  gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "document-open");
  gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Open");
  gtk_menu_tool_button_set_menu (GTK_MENU_TOOL_BUTTON (item), menu);
  add_item_to_list (store, item, "Open");
  gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
  gdk_threads_add_timeout (3000, (GSourceFunc) timeout_cb1, item);
 
  menu = gtk_menu_new ();
  for (i = 0; i < 20; i++)
    {
      char *text;
      text = g_strdup_printf ("A%d", i);
      menuitem = gtk_menu_item_new_with_label (text);
      g_free (text);
      gtk_widget_show (menuitem);
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
    }

  item = gtk_menu_tool_button_new (NULL, NULL);
  gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "go-previous");
  gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Back");
  gtk_menu_tool_button_set_menu (GTK_MENU_TOOL_BUTTON (item), menu);
  add_item_to_list (store, item, "BackWithHistory");
  gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
 
  item = gtk_separator_tool_item_new ();
  add_item_to_list (store, item, "-----");    
  gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
  
  image = gtk_image_new_from_icon_name ("dialog-warning", GTK_ICON_SIZE_DIALOG);
  item = gtk_tool_item_new ();
  gtk_widget_show (image);
  gtk_container_add (GTK_CONTAINER (item), image);
  add_item_to_list (store, item, "(Custom Item)");    
  gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
  
  item = gtk_tool_button_new (NULL, NULL);
  gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "go-previous");
  gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Back");
  add_item_to_list (store, item, "Back");    
  gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);

  item = gtk_separator_tool_item_new ();
  add_item_to_list (store, item, "-----");  
  gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
  
  item = gtk_tool_button_new (NULL, NULL);
  gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "go-next");
  gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Forward");
  add_item_to_list (store, item, "Forward");  
  gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);

  item = gtk_toggle_tool_button_new ();
  gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Bold");
  gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "format-text-bold");
  g_signal_connect (item, "toggled", G_CALLBACK (bold_toggled), NULL);
  add_item_to_list (store, item, "Bold");  
  gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
  gtk_widget_set_sensitive (GTK_WIDGET (item), FALSE);

  item = gtk_separator_tool_item_new ();
  add_item_to_list (store, item, "-----");  
  gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
  gtk_tool_item_set_expand (item, TRUE);
  gtk_separator_tool_item_set_draw (GTK_SEPARATOR_TOOL_ITEM (item), FALSE);
  g_assert (gtk_toolbar_get_nth_item (GTK_TOOLBAR (toolbar), 0) != 0);
  
  item = gtk_radio_tool_button_new (NULL);
  gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Left");
  gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "format-justify-left");
  group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (item));
  add_item_to_list (store, item, "Left");
  gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
  
  
  item = gtk_radio_tool_button_new (group);
  gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Center");
  gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "format-justify-center");
  group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (item));
  add_item_to_list (store, item, "Center");
  gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);

  item = gtk_radio_tool_button_new (group);
  gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Right");
  gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "format-justify-right");
  add_item_to_list (store, item, "Right");
  gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);

  item = gtk_tool_button_new (gtk_image_new_from_file ("apple-red.png"), "_Apple");
  add_item_to_list (store, item, "Apple");
  gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
  gtk_tool_button_set_use_underline (GTK_TOOL_BUTTON (item), TRUE);

  gicon = g_content_type_get_icon ("video/ogg");
  image = gtk_image_new_from_gicon (gicon, GTK_ICON_SIZE_LARGE_TOOLBAR);
  g_object_unref (gicon);
  item = gtk_tool_button_new (image, "Video");
  add_item_to_list (store, item, "Video");
  gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);

  image = gtk_image_new_from_icon_name ("utilities-terminal", GTK_ICON_SIZE_LARGE_TOOLBAR);
  item = gtk_tool_button_new (image, "Terminal");
  add_item_to_list (store, item, "Terminal");
  gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);

  image = gtk_spinner_new ();
  gtk_spinner_start (GTK_SPINNER (image));
  item = gtk_tool_button_new (image, "Spinner");
  add_item_to_list (store, item, "Spinner");
  gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);

  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
  gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
  gtk_widget_set_hexpand (hbox, TRUE);
  gtk_grid_attach (GTK_GRID (grid), hbox, 1, 4, 1, 1);

  button = gtk_button_new_with_label ("Drag me to the toolbar");
  gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);

  label = gtk_label_new ("Drop index:");
  gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);

  label = gtk_label_new ("");
  gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);

  checkbox = gtk_check_button_new_with_mnemonic("_Right to left");
  if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL)
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), TRUE);
  else
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), FALSE);
  g_signal_connect (checkbox, "toggled", G_CALLBACK (rtl_toggled), NULL);

  gtk_box_pack_end (GTK_BOX (hbox), checkbox, FALSE, FALSE, 0);
  
  gtk_drag_source_set (button, GDK_BUTTON1_MASK,
		       target_table, G_N_ELEMENTS (target_table),
		       GDK_ACTION_MOVE);
  gtk_drag_dest_set (toolbar, GTK_DEST_DEFAULT_DROP,
		     target_table, G_N_ELEMENTS (target_table),
		     GDK_ACTION_MOVE);
  g_signal_connect (toolbar, "drag_motion",
		    G_CALLBACK (toolbar_drag_motion), NULL);
  g_signal_connect (toolbar, "drag_leave",
		    G_CALLBACK (toolbar_drag_leave), NULL);
  g_signal_connect (toolbar, "drag_drop",
		    G_CALLBACK (toolbar_drag_drop), label);

  gtk_widget_show_all (window);

  g_signal_connect (window, "delete_event", G_CALLBACK (gtk_main_quit), NULL);
  
  g_signal_connect (toolbar, "popup_context_menu", G_CALLBACK (popup_context_menu), NULL);
  
  gtk_main ();
  
  return 0;
}
コード例 #2
0
WVselGtk::WVselGtk (
  pwr_tStatus   *status,
  void		*wv_parent_ctx,
  GtkWidget	*wv_parent_wid,
  const char   	*wv_name,
  ldh_tWBContext wv_wbctx,
  char		*volumename,
  int		(*bc_success)( void *, pwr_tVolumeId *, int),
  void		(*bc_cancel)(),
  int		(*bc_time_to_exit)( void *),
  int		show_volumes,
  wb_eType      wv_wb_type) : 
  WVsel(status,wv_parent_ctx,wv_name,wv_wbctx,volumename,bc_success,bc_cancel,
	bc_time_to_exit,show_volumes,wv_wb_type), parent_wid(wv_parent_wid)
{
  int		sts;
  pwr_tVolumeId volid, *volume_ptr;
  pwr_tVolumeId	volume;
  pwr_tClassId	classid;
  char		volname[80];
  int		size;
  int		volume_count;
  int		display_window;
  GtkCellRenderer *text_renderer;
  GtkTreeViewColumn *name_column;

  strcpy( volname, "");
  if ( volumename != NULL && *volumename != 0 && !show_volumes)
    /* Start the navigater for this volume */
    strcpy( volname, volumename);
  else if ( !show_volumes && wb_type != wb_eType_Buffer)
  {
    /* If there is only one volume in the db, select this volume */
    volume_count = 0;

    sts = ldh_GetVolumeList( wbctx, &volume);
    while ( ODD(sts) )
    {
      sts = ldh_GetVolumeClass( wbctx, volume, &classid);
      if (EVEN(sts)) { *status = sts; return; }
  
      if ( cdh_isClassVolumeClass( classid) ||
 	   classid == pwr_eClass_WorkBenchVolume ||
	   volume == ldh_cRtVolume)
      {
        sts = ldh_GetNextVolume( wbctx, volume, &volume);
        continue;
      }
      sts = ldh_VolumeIdToName( wbctx, volume, volname, sizeof(volname),
	    &size);
      if (EVEN(sts)) { *status = sts; return; }
      volume_count++;

      sts = ldh_GetNextVolume( wbctx, volume, &volume);
    }
    if ( volume_count != 1)
      strcpy( volname, "");
  }

  
  //  If volume name is supplied, find this volume and open the navigator.

  if ( strcmp( volname, "") && wb_type != wb_eType_Buffer)
    /* Check syntax, if new volumes is found, show the window */
    sts = check_volumelist( 1, &display_window);

  if ( strcmp( volname, "") && !display_window)
  {
    sts = ldh_VolumeNameToId( wbctx, volname, &volid);
    WFoe::error_msg(sts);
    if ( ODD(sts))
    {
      volume_ptr = (pwr_tVolumeId *) calloc( 1, sizeof( pwr_tVolumeId));
      *volume_ptr = volid;
      (vsel_bc_success) ( (void *)this, volume_ptr, 1);
      if (vsel_bc_cancel != NULL)
        (vsel_bc_cancel) ();

      *status = LOGIN__SUCCESS;
      return;
    }
    else
      printf( "-- Unable to open volume '%s', volume doesn't exist\n",
	volname);
  }


  // Create the window
  widgets.toplevel = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW, 
					 "default-height", 400,
					 "default-width", 500,
					 "title", name,
					 NULL);

  CoWowGtk::SetWindowIcon( widgets.toplevel);

  // Menu
  GtkAccelGroup *accel_g = (GtkAccelGroup *) g_object_new(GTK_TYPE_ACCEL_GROUP, NULL);
  gtk_window_add_accel_group(GTK_WINDOW(widgets.toplevel), accel_g);

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

  // File Entry
  GtkWidget *file_close = gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE, accel_g);
  g_signal_connect(file_close, "activate", G_CALLBACK(WVselGtk::activate_close), this);

  GtkMenu *file_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
  gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_close);

  GtkWidget *file = gtk_menu_item_new_with_mnemonic("_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_showall = gtk_check_menu_item_new_with_mnemonic( "_Show All Volumes");
  g_signal_connect( functions_showall, "activate", 
		    G_CALLBACK(WVselGtk::activate_showall), this);
  gtk_widget_add_accelerator( functions_showall, "activate", accel_g,
			      'a', 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_showall);

  GtkWidget *functions = gtk_menu_item_new_with_mnemonic("F_unctions");
  gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), functions);
  gtk_menu_item_set_submenu(GTK_MENU_ITEM(functions), GTK_WIDGET(functions_menu));

  // List widget
  store = gtk_list_store_new( 1, G_TYPE_STRING);

  widgets.volumelist = (GtkWidget *) g_object_new(GTK_TYPE_TREE_VIEW,
				 "model", store,
				 "rules-hint", TRUE,
				 "headers-visible", FALSE,
				 "reorderable", TRUE,
				 "enable-search", TRUE,
				 "search-column", 0,
				 NULL);

  text_renderer = gtk_cell_renderer_text_new();
  name_column = gtk_tree_view_column_new_with_attributes( NULL,
							  text_renderer,
							  "text", 0,
							  NULL);

  g_object_set( name_column,
		"resizable", TRUE,
		"clickable", TRUE,
		NULL);

  gtk_tree_view_append_column( GTK_TREE_VIEW(widgets.volumelist), name_column);

  GtkWidget *ok_button = gtk_button_new_with_label( "Ok");
  gtk_widget_set_size_request( ok_button, 70, 25);
  g_signal_connect( ok_button, "clicked", 
 		    G_CALLBACK(activate_ok), this);

  GtkWidget *cancel_button = gtk_button_new_with_label( "Cancel");
  gtk_widget_set_size_request( cancel_button, 70, 25);
  g_signal_connect( cancel_button, "clicked", 
 		    G_CALLBACK(activate_cancel), this);

  GtkWidget *hboxbuttons = gtk_hbox_new( TRUE, 40);
  gtk_box_pack_start( GTK_BOX(hboxbuttons), ok_button, FALSE, FALSE, 20);
  gtk_box_pack_end( GTK_BOX(hboxbuttons), cancel_button, FALSE, FALSE, 20);

  GtkWidget *scrolled_window = gtk_scrolled_window_new( NULL, NULL);
  gtk_container_add( GTK_CONTAINER( scrolled_window), widgets.volumelist);

  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), scrolled_window, TRUE, TRUE, 0);
  gtk_box_pack_end( GTK_BOX(vbox), hboxbuttons, FALSE, FALSE, 10);

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

  // GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(widgets.volumelist));
  // gtk_tree_selection_set_mode( selection, GTK_SELECTION_SINGLE);

  sts = load_volumelist();
  WFoe::error_msg(sts);

  // Set input focus to the scrolled list widget
  gtk_widget_grab_focus( widgets.volumelist);


  wow = new CoWowGtk( widgets.toplevel);

  if ( wb_type != wb_eType_Buffer)
    sts = check_volumelist( 0, &display_window);

  *status = LOGIN__SUCCESS;
}
コード例 #3
0
ファイル: testtreemenu.c プロジェクト: BoozzyAmdJin/gtk-
static void
tree_menu (void)
{
  GtkWidget *window, *widget;
  GtkWidget *menubar, *vbox;
  GtkCellArea *area;
  GtkTreeModel *store;

  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

  gtk_window_set_title (GTK_WINDOW (window), "GtkTreeMenu");

  vbox  = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4);
  gtk_widget_show (vbox);

  menubar = gtk_menu_bar_new ();
  gtk_widget_show (menubar);

  store = simple_tree_model ();
  area  = create_cell_area ();

#if _GTK_TREE_MENU_WAS_A_PUBLIC_CLASS_
  menuitem = gtk_menu_item_new_with_label ("Grid");
  menu = create_menu_grid_demo ();
  gtk_widget_show (menu);
  gtk_widget_show (menuitem);
  gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
  gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);

  menuitem = gtk_menu_item_new_with_label ("Tree");
  menu = simple_tree_menu ();
  gtk_widget_show (menu);
  gtk_widget_show (menuitem);
  gtk_menu_shell_prepend (GTK_MENU_SHELL (menubar), menuitem);
  gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);

  g_signal_connect (menu, "menu-activate", G_CALLBACK (menu_activated_cb), NULL);

  gtk_box_pack_start (GTK_BOX (vbox), menubar, FALSE, FALSE, 0);
#endif

  /* Add a combo box with the same menu ! */
  widget = gtk_combo_box_new_with_area (area);
  gtk_combo_box_set_model (GTK_COMBO_BOX (widget), store);
  gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
  gtk_widget_show (widget);
  gtk_box_pack_end (GTK_BOX (vbox), widget, FALSE, FALSE, 0);

  /* Now add some controls */
  widget = gtk_combo_box_text_new ();
  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Horizontal");
  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Vertical");
  gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
  gtk_widget_show (widget);
  gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);

  g_signal_connect (G_OBJECT (widget), "changed",
                    G_CALLBACK (orientation_changed), area);

  widget = gtk_check_button_new_with_label ("Align 2nd Cell");
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
  gtk_widget_show (widget);
  gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
  
  g_signal_connect (G_OBJECT (widget), "toggled",
                    G_CALLBACK (align_cell_2_toggled), area);

  widget = gtk_check_button_new_with_label ("Align 3rd Cell");
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE);
  gtk_widget_show (widget);
  gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
  
  g_signal_connect (G_OBJECT (widget), "toggled",
                    G_CALLBACK (align_cell_3_toggled), area);

  widget = gtk_check_button_new_with_label ("Expand 1st Cell");
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
  gtk_widget_show (widget);
  gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
  
  g_signal_connect (G_OBJECT (widget), "toggled",
                    G_CALLBACK (expand_cell_1_toggled), area);

  widget = gtk_check_button_new_with_label ("Expand 2nd Cell");
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE);
  gtk_widget_show (widget);
  gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
  
  g_signal_connect (G_OBJECT (widget), "toggled",
                    G_CALLBACK (expand_cell_2_toggled), area);

  widget = gtk_check_button_new_with_label ("Expand 3rd Cell");
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
  gtk_widget_show (widget);
  gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
  
  g_signal_connect (G_OBJECT (widget), "toggled",
                    G_CALLBACK (expand_cell_3_toggled), area);

#if _GTK_TREE_MENU_WAS_A_PUBLIC_CLASS_
  widget = gtk_check_button_new_with_label ("Submenu Headers");
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
  gtk_widget_show (widget);
  gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
  
  g_signal_connect (G_OBJECT (widget), "toggled",
                    G_CALLBACK (submenu_headers_toggled), menu);

  widget = gtk_check_button_new_with_label ("Tearoff menu");
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
  gtk_widget_show (widget);
  gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
  
  g_signal_connect (G_OBJECT (widget), "toggled",
                    G_CALLBACK (tearoff_toggled), menu);
#endif

  gtk_container_add (GTK_CONTAINER (window), vbox);

  gtk_widget_show (window);
}
コード例 #4
0
ファイル: glade-popup.c プロジェクト: metaltrrocker/glade
static GtkWidget *
glade_popup_create_menu (GladeWidget      *widget,
                         GladePlaceholder *placeholder, 
			 GladeProject     *project,
			 gboolean          packing)
{
  GtkWidget          *popup_menu;
  GtkWidget          *separator;
  gboolean            sensitive;
  GladeWidgetAdaptor *adaptor;

  popup_menu = gtk_menu_new ();

  adaptor = glade_project_get_add_item (project);

  if (adaptor)
    {
      RootAddData *data = g_new (RootAddData, 1);
      
      data->adaptor = adaptor;
      data->project = project;
      data->parent = placeholder ? glade_placeholder_get_parent (placeholder) : widget;
      data->placeholder = placeholder;
      
      g_object_set_data_full (G_OBJECT (popup_menu), "root-data-destroy-me", 
			      data, (GDestroyNotify)g_free);

      glade_popup_append_item (popup_menu, _("_Add widget here"),
                               data->parent != NULL,
			       glade_popup_widget_add_cb,
			       data);

      glade_popup_append_item (popup_menu, _("Add widget as _toplevel"), TRUE,
                               glade_popup_root_add_cb, data);

      separator = gtk_separator_menu_item_new ();
      gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), separator);
      gtk_widget_show (separator);
    }

  sensitive = (widget != NULL);

  glade_popup_append_item (popup_menu, _("_Select"), sensitive,
                           glade_popup_select_cb, widget);
  glade_popup_append_item (popup_menu, _("Cu_t"), sensitive,
                           glade_popup_cut_cb, widget);
  glade_popup_append_item (popup_menu, _("_Copy"), sensitive,
                           glade_popup_copy_cb, widget);

  /* paste is placholder specific when the popup is on a placeholder */
  sensitive = glade_clipboard_get_has_selection (glade_app_get_clipboard ());

  if (placeholder)
    glade_popup_append_item (popup_menu, _("_Paste"), sensitive,
                             glade_popup_placeholder_paste_cb, placeholder);
  else if (widget)
    glade_popup_append_item (popup_menu, _("_Paste"), sensitive,
                             glade_popup_paste_cb, widget);
  else
    glade_popup_append_item (popup_menu, _("_Paste"), sensitive,
                             glade_popup_paste_cb, NULL);


  glade_popup_append_item (popup_menu, _("_Delete"), (widget != NULL),
                           glade_popup_delete_cb, widget);


  /* packing actions are a little different on placholders */
  if (placeholder)
    {
      if (widget && glade_widget_get_actions (widget))
        {
          GtkWidget *separator = gtk_separator_menu_item_new ();
          gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), separator);
          gtk_widget_show (separator);

          glade_popup_action_populate_menu_real
              (popup_menu,
               widget,
               glade_widget_get_actions (widget),
               G_CALLBACK (glade_popup_menuitem_activated), widget);
        }

      if (glade_placeholder_packing_actions (placeholder))
        {
          GtkWidget *separator = gtk_separator_menu_item_new ();
          gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), separator);
          gtk_widget_show (separator);

          glade_popup_action_populate_menu_real
              (popup_menu,
               widget,
               glade_placeholder_packing_actions (placeholder),
               G_CALLBACK (glade_popup_menuitem_ph_packing_activated),
               placeholder);
        }
    }
  else if (widget && (glade_widget_get_actions (widget) || 
		      (packing && glade_widget_get_pack_actions (widget))))
    {
      GtkWidget *separator = gtk_separator_menu_item_new ();
      gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), separator);
      gtk_widget_show (separator);

      glade_popup_action_populate_menu (popup_menu, widget, NULL, packing);
    }

  return popup_menu;
}
コード例 #5
0
int main( int argc, char *argv[])
{
    GtkWidget *window;
    GtkWidget *vbox;
    GtkWidget *menubar;
    GtkWidget *filemenu, *item_file, *item_new, *item_open,*item_quit;
    GtkWidget *editmenu, *item_edit, *item_undo, *item_redo, *item_cut, *item_copy, *item_paste;
    GtkWidget *sep;
    GtkAccelGroup *accel_group = NULL;  //定义快捷键组

    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 better");

    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

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


    item_file = gtk_menu_item_new_with_mnemonic("_File");   //替代 gtk_menu_item_new_with_label("File");
    item_new = gtk_image_menu_item_new_from_stock(GTK_STOCK_NEW, NULL);  //替代gtk_menu_item_new_with_label("New");
    item_open = gtk_image_menu_item_new_from_stock(GTK_STOCK_OPEN, NULL);//替代gtk_menu_item_new_with_label("Open");
    sep = gtk_separator_menu_item_new();    //生成一条分割线
    item_quit = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT,accel_group);//替代gtk_menu_item_new_with_label("Quit");

    gtk_widget_add_accelerator(item_quit, "activate", accel_group, GDK_q,GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);

    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_open);
    gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), sep);       //加入分割线到file菜单中
    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_mnemonic("_Edit");
    item_undo = gtk_image_menu_item_new_from_stock(GTK_STOCK_UNDO, NULL);
    item_redo = gtk_image_menu_item_new_from_stock(GTK_STOCK_REDO, NULL);
    sep = gtk_separator_menu_item_new();
    item_cut = gtk_image_menu_item_new_from_stock(GTK_STOCK_CUT, NULL);
    item_copy = gtk_image_menu_item_new_from_stock(GTK_STOCK_COPY, NULL);
    item_paste = gtk_image_menu_item_new_from_stock(GTK_STOCK_PASTE, NULL);

    gtk_widget_add_accelerator(item_undo, "activate", accel_group, GDK_z,GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
    gtk_widget_add_accelerator(item_redo, "activate", accel_group, GDK_r,GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
    gtk_widget_add_accelerator(item_cut, "activate", accel_group, GDK_x,GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
    gtk_widget_add_accelerator(item_copy, "activate", accel_group, GDK_c,GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
    gtk_widget_add_accelerator(item_paste, "activate", accel_group, GDK_v,GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);

    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_edit), editmenu);

    gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), item_undo);
    gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), item_redo);
    gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), sep);
    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(G_OBJECT(item_quit),
                     "activate",G_CALLBACK(gtk_main_quit), NULL);

    gtk_widget_show_all(window);
    gtk_main();
    return 0;
}
コード例 #6
0
ファイル: selector.c プロジェクト: Akenyshka/libwnck
static void
wnck_selector_insert_window (WnckSelector *selector, WnckWindow *window)
{
  GtkWidget     *item;
  WnckScreen    *screen;
  WnckWorkspace *workspace;
  int            workspace_n;
  int            i;

  screen = wnck_selector_get_screen (selector);
  workspace = wnck_window_get_workspace (window);

  if (!workspace && !wnck_window_is_pinned (window))
    return;

  item = wnck_selector_create_window (selector, window);

  if (!workspace || workspace == wnck_screen_get_active_workspace (screen))
    {
      /* window is pinned or in the current workspace
       * => insert before the separator */
      GList *l, *children;

      i = 0;

      children = gtk_container_get_children (GTK_CONTAINER (selector->priv->menu));
      for (l = children; l; l = l->next)
        {
          if (GTK_IS_SEPARATOR_MENU_ITEM (l->data))
            break;
          i++;
        }
      g_list_free (children);

      gtk_menu_shell_insert (GTK_MENU_SHELL (selector->priv->menu),
                             item, i);
    }
  else
    {
      workspace_n = wnck_workspace_get_number (workspace);

      if (workspace_n == wnck_screen_get_workspace_count (screen) - 1)
        /* window is in last workspace => just append */
        gtk_menu_shell_append (GTK_MENU_SHELL (selector->priv->menu), item);
      else
        {
          /* insert just before the next workspace item */
          GList *l, *children;

          i = 0;

          children = gtk_container_get_children (GTK_CONTAINER (selector->priv->menu));
          for (l = children; l; l = l->next)
            {
              int j;
              j = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (l->data),
                                                      "wnck-selector-workspace-n"));
              if (j - 1 == workspace_n + 1)
                break;
              i++;
            }
          g_list_free (children);

          gtk_menu_shell_insert (GTK_MENU_SHELL (selector->priv->menu),
                                 item, i);
        }
    }
}
コード例 #7
0
ファイル: remminaicon.c プロジェクト: 4myPAL/Remmina
static void
remmina_icon_populate_extra_menu_item (GtkWidget *menu)
{
    GtkWidget *menuitem;
    gboolean new_ontop;
    GHashTableIter iter;
    gchar *tmp;
    gint n;

    new_ontop = remmina_pref.applet_new_ontop;

    /* Iterate all discovered services from Avahi */
    if (remmina_icon.avahi)
    {
        g_hash_table_iter_init (&iter, remmina_icon.avahi->discovered_services);
        while (g_hash_table_iter_next (&iter, NULL, (gpointer*) &tmp))
        {
            menuitem = remmina_applet_menu_item_new (REMMINA_APPLET_MENU_ITEM_DISCOVERED, tmp);
            gtk_widget_show (menuitem);
            remmina_applet_menu_add_item (
                REMMINA_APPLET_MENU (menu),
                REMMINA_APPLET_MENU_ITEM (menuitem));
        }
    }

    /* Separator */
    menuitem = gtk_separator_menu_item_new ();
    gtk_widget_show (menuitem);
    if (new_ontop)
    {
        gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menuitem);
    }
    else
    {
        gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
    }

    /* New Connection */
    menuitem = remmina_applet_menu_item_new (REMMINA_APPLET_MENU_ITEM_NEW);
    gtk_widget_show (menuitem);
    remmina_applet_menu_register_item (
        REMMINA_APPLET_MENU (menu),
        REMMINA_APPLET_MENU_ITEM (menuitem));
    if (new_ontop)
    {
        gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menuitem);
    }
    else
    {
        gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
    }

    /* Existing window */
    if (remmina_pref.minimize_to_tray)
    {
        n = remmina_widget_pool_foreach (remmina_icon_foreach_window, menu);
        if (n > 0)
        {
            /* Separator */
            menuitem = gtk_separator_menu_item_new ();
            gtk_widget_show (menuitem);
            gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem, n);
        }
    }

    g_signal_connect (G_OBJECT (menu), "launch-item",
        G_CALLBACK (remmina_icon_on_launch_item), NULL);
    g_signal_connect (G_OBJECT (menu), "edit-item",
        G_CALLBACK (remmina_icon_on_edit_item), NULL);
}
コード例 #8
0
ファイル: elsa-launcher.c プロジェクト: AOSC-Dev/elsa-shell
/*
 * This function inherit from gnome-menus/util/test-menu-spec.c
 */
static void traverse_directory(GMenuTreeDirectory *dir, GtkWidget *parent) 
{
    GMenuTreeIter *iter = NULL;
    GtkWidget *dir_submenu = parent ? gtk_menu_new() : NULL;
    GtkWidget *entry_submenu = gtk_menu_new();
    GIcon *icon = NULL;
    const char *text = NULL;
    GtkWidget *menuitem = NULL;

    iter = gmenu_tree_directory_iter(dir);

    while (TRUE) {
        gpointer item = NULL;

        switch (gmenu_tree_iter_next(iter)) {
        case GMENU_TREE_ITEM_INVALID:
            goto done;

        case GMENU_TREE_ITEM_ENTRY:
            item = gmenu_tree_iter_get_entry(iter);
            GDesktopAppInfo *appinfo = gmenu_tree_entry_get_app_info((GMenuTreeEntry *)item);
            icon = g_app_info_get_icon((GAppInfo *)appinfo);
            text = g_app_info_get_display_name((GAppInfo *)appinfo);
            menuitem = menu_item_new_with_icon_text(icon, text);
            gtk_menu_shell_append(GTK_MENU_SHELL(entry_submenu), menuitem);
            g_object_connect(G_OBJECT(menuitem), 
                "signal::activate", G_CALLBACK(menu_item_activate), appinfo,
                NULL);
            break;

        case GMENU_TREE_ITEM_DIRECTORY:
            item = gmenu_tree_iter_get_directory(iter);
            icon = gmenu_tree_directory_get_icon((GMenuTreeDirectory *)item);
            text = gmenu_tree_directory_get_name((GMenuTreeDirectory *)item);
            menuitem = menu_item_new_with_icon_text(icon, text);
            gtk_menu_shell_append(dir_submenu ? 
                                      GTK_MENU_SHELL(dir_submenu) : 
                                      GTK_MENU_SHELL(popup), 
                                  menuitem);

            traverse_directory(item, menuitem);
            break;
        }

        if (item) {
            gmenu_tree_item_unref(item);
            item = NULL;
        }

        continue;

done:
        break;
    }

    if (parent) {
        if (dir_submenu)
            gtk_menu_item_set_submenu(GTK_MENU_ITEM(parent), dir_submenu);

        gtk_menu_item_set_submenu(GTK_MENU_ITEM(parent), entry_submenu);
    }

    if (iter) {
        gmenu_tree_iter_unref(iter);
        iter = NULL;
    }
}
コード例 #9
0
ファイル: callbacks.c プロジェクト: Gwyki/gromit-mpx
void on_trayicon_activate (GtkStatusIcon *status_icon,
			   gpointer       user_data)
{
  GromitData *data = (GromitData *) user_data;
  if(data->debug)
    g_printerr("DEBUG: trayicon activated\n");

  /* create the menu */
  GtkWidget *menu = gtk_menu_new ();
  
  /* Create the menu items */
  GtkWidget* toggle_paint_item = gtk_image_menu_item_new_with_label ("Toggle Painting");
  GtkWidget* clear_item = gtk_image_menu_item_new_with_label ("Clear Screen");
  GtkWidget* toggle_vis_item = gtk_image_menu_item_new_with_label ("Toggle Visibility");
  GtkWidget* thicker_lines_item = gtk_image_menu_item_new_with_label ("Thicker Lines");
  GtkWidget* thinner_lines_item = gtk_image_menu_item_new_with_label ("Thinner Lines");
  GtkWidget* opacity_bigger_item = gtk_image_menu_item_new_with_label ("Bigger Opacity");
  GtkWidget* opacity_lesser_item = gtk_image_menu_item_new_with_label ("Lesser Opacity");
  GtkWidget* undo_item = gtk_image_menu_item_new_with_label ("Undo");
  GtkWidget* redo_item = gtk_image_menu_item_new_with_label ("Redo");


  /* Add them to the menu */
  gtk_menu_shell_append (GTK_MENU_SHELL (menu), toggle_paint_item);
  gtk_menu_shell_append (GTK_MENU_SHELL (menu), clear_item);
  gtk_menu_shell_append (GTK_MENU_SHELL (menu), toggle_vis_item);
  gtk_menu_shell_append (GTK_MENU_SHELL (menu), thicker_lines_item);
  gtk_menu_shell_append (GTK_MENU_SHELL (menu), thinner_lines_item);
  gtk_menu_shell_append (GTK_MENU_SHELL (menu), opacity_bigger_item);
  gtk_menu_shell_append (GTK_MENU_SHELL (menu), opacity_lesser_item);
  gtk_menu_shell_append (GTK_MENU_SHELL (menu), undo_item);
  gtk_menu_shell_append (GTK_MENU_SHELL (menu), redo_item);


  /* Attach the callback functions to the respective activate signal */
  // TODO add per-device submenu for toggle_paint_item 
  g_signal_connect(G_OBJECT (clear_item), "activate",
		   G_CALLBACK (on_clear),
		   data);
  g_signal_connect(G_OBJECT (toggle_vis_item), "activate",
		   G_CALLBACK (on_toggle_vis),
		   data);

  g_signal_connect(G_OBJECT (thicker_lines_item), "activate",
		   G_CALLBACK (on_thicker_lines),
		   data);
  g_signal_connect(G_OBJECT (thinner_lines_item), "activate",
		   G_CALLBACK (on_thinner_lines),
		   data);
  g_signal_connect(G_OBJECT (opacity_bigger_item), "activate",
		   G_CALLBACK (on_opacity_bigger),
		   data);
  g_signal_connect(G_OBJECT (opacity_lesser_item), "activate",
		   G_CALLBACK (on_opacity_lesser),
		   data);

  g_signal_connect(G_OBJECT (undo_item), "activate",
		   G_CALLBACK (on_undo),
		   data);
  g_signal_connect(G_OBJECT (redo_item), "activate",
		   G_CALLBACK (on_redo),
		   data);
 

  /* We do need to show menu items */
  gtk_widget_show (toggle_paint_item);
  gtk_widget_show (clear_item);
  gtk_widget_show (toggle_vis_item);
  gtk_widget_show (thicker_lines_item);
  gtk_widget_show (thinner_lines_item);
  gtk_widget_show (opacity_bigger_item);
  gtk_widget_show (opacity_lesser_item);
  gtk_widget_show (undo_item);
  gtk_widget_show (redo_item);
 

  /* show menu */
  gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL,
                  0, gtk_get_current_event_time());
}
コード例 #10
0
ファイル: usejournal.c プロジェクト: andy-shev/LogJam
GtkWidget*
usejournal_build_menu(const char *defaultjournal, const char *currentjournal,
		GSList *journals, gpointer doc) {
	GtkWidget *menu, *curmenu, *item, *label;
	GSList *group = NULL;
	GSList *l;
	char *journal;
	char *curmenuprefix = NULL;
	char prefix[30];

	curmenu = menu = gtk_menu_new();

	item = gtk_radio_menu_item_new_with_label(group, defaultjournal);
	group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(item));
	g_signal_connect(G_OBJECT(item), "activate",
			G_CALLBACK(activate_cb), doc);

	if (currentjournal == NULL)
		gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);

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

	for (l = journals; l != NULL; l = l->next) {
		journal = (char*)l->data;

		if (curmenuprefix) {
			/* try to match this item to the prefix. */
			if (sharedprefix(curmenuprefix, journal)) {
				/* match. */
			} else {
				curmenu = menu;
				curmenuprefix = NULL;
			}
		}
		if (!curmenuprefix && l->next) {
			/* try to see if this begins a new prefix. */
			char *nextjournal = (char*)l->next->data;
			int ofs;
			ofs = sharedprefix(journal, nextjournal);
			if (ofs) {
				/* make a new submenu for these shared-prefix journals. */
				memcpy(prefix, journal, ofs);
				prefix[ofs] = 0;

				item = gtk_menu_item_new();
				label = gtk_label_new(NULL);
				gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
				gtk_label_set_markup(GTK_LABEL(label), prefix);
				gtk_container_add(GTK_CONTAINER(item), label);
				gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
				curmenu = gtk_menu_new();
				curmenuprefix = prefix;
				gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), curmenu);
				gtk_widget_show_all(item);
			}
		}
		item = gtk_radio_menu_item_new_with_label(group, journal);
		if (currentjournal && strcmp(currentjournal, journal) == 0)
			gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
		g_signal_connect(G_OBJECT(item), "activate",
				G_CALLBACK(activate_cb), doc);
		gtk_widget_show(item);
		gtk_menu_shell_append(GTK_MENU_SHELL(curmenu), item);

		group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(item));
	}

	return menu;
}
コード例 #11
0
ファイル: cpuicon.c プロジェクト: micove/awn-extras
static void 
awn_CPUicon_show_context_menu(AwnCPUicon *self)
{
  AwnCPUiconPrivate *priv;
  AwnApplet         *applet;
  GtkWidget         *item;
  GtkWidget         *submenu;
  gboolean          render_bg;

  g_object_get (self,
                "render-bg", &render_bg,
                NULL);
  
  priv = AWN_CPUICON_GET_PRIVATE (self);
  if (priv->context_menu)
  {
    gtk_widget_destroy (priv->context_menu);
  }
  g_object_get (self,
                "applet",&applet,
                NULL);
  
  priv->context_menu = awn_applet_create_default_menu(applet);
  item = gtk_menu_item_new_with_label (_("Graph Type"));
  gtk_menu_shell_append(GTK_MENU_SHELL(priv->context_menu), item);
  
  submenu = gtk_menu_new ();
  gtk_menu_item_set_submenu (GTK_MENU_ITEM(item),submenu);
  
  /* Translators: refers to a graph type */
  item = gtk_menu_item_new_with_label (_("Area"));
  gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item);
  g_signal_connect_swapped (item, "activate", G_CALLBACK(change_to_area), self);
  item = gtk_menu_item_new_with_label (_("Circle"));
  gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item);
  g_signal_connect_swapped (item, "activate", G_CALLBACK(change_to_circle), self);  
  item = gtk_menu_item_new_with_label (_("Bars"));
  gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item);
  g_signal_connect_swapped (item, "activate", G_CALLBACK(change_to_bars), self);  
  item = gtk_menu_item_new_with_label (_("Default"));
  gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item);
  g_signal_connect_swapped (item, "activate", G_CALLBACK(change_to_default), self);  

/*  item = gtk_menu_item_new_with_label ("Add Icon");
  gtk_menu_shell_append(GTK_MENU_SHELL(priv->context_menu), item);
  submenu = gtk_menu_new ();
  gtk_menu_item_set_submenu (GTK_MENU_ITEM(item),submenu);
  item = gtk_menu_item_new_with_label ("CPU");
  gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item);
*/
/*  item = gtk_menu_item_new_with_label ("Remove Icon");
  gtk_menu_shell_append(GTK_MENU_SHELL(priv->context_menu), item);  
*/
  item = gtk_check_menu_item_new_with_label (_("Render Background"));
  gtk_check_menu_item_set_active ( GTK_CHECK_MENU_ITEM (item),render_bg);  
  gtk_menu_shell_append(GTK_MENU_SHELL(priv->context_menu), item);
  g_signal_connect_swapped (item, "activate", G_CALLBACK(change_render_bg), self);  

  item = awn_applet_create_about_item_simple (applet,
                                              "Copyright 2009 Rodney Cryderman <*****@*****.**>\n",
                                              AWN_APPLET_LICENSE_GPLV2,
                                              VERSION);
  gtk_menu_shell_append(GTK_MENU_SHELL(priv->context_menu), item);
  
  gtk_widget_show_all (priv->context_menu);
  awn_utils_show_menu_images (GTK_MENU(priv->context_menu));
  awn_applet_popup_gtk_menu (applet, priv->context_menu, 0, gtk_get_current_event_time());
}
コード例 #12
0
static void add_screen(xcb_randr_get_screen_info_reply_t *reply)
{
    const gchar *title = "Display";
    GtkWidget *item = gtk_menu_item_new_with_label(title);
    GtkMenuShell *menu = GTK_MENU_SHELL(app_menu);
    struct screen_info *info = g_malloc(sizeof *info);
    xcb_randr_rotation_t rotation = normalize_rotation(reply->rotation);
    xcb_randr_rotation_t rotations = reply->rotations;

    info->label_menu_item = item;
    info->rotation_menu_group = NULL;
    info->rotation = rotation;
    info->config_timestamp = reply->config_timestamp;
    info->root = reply->root;
    info->sizeID = reply->sizeID;
    info->rate = reply->rate;
    screens_info = g_slist_append(screens_info, info);

    gtk_widget_set_sensitive(item, FALSE);
    gtk_menu_shell_append(menu, item);

#define R(rot, title) \
    if (rotations & XCB_RANDR_ROTATION_##rot) \
        add_screen_rotation(info, XCB_RANDR_ROTATION_##rot, title, \
                XCB_RANDR_ROTATION_##rot & rotation)
    R(ROTATE_0, "Landscape");
    R(ROTATE_90, "Portrait");
    R(ROTATE_180, "Landscape Flipped");
    R(ROTATE_270, "Portrait Flipped");

    if (rotations & xcb_rotations_mask && rotations & xcb_reflections_mask)
        gtk_menu_shell_append(menu, gtk_separator_menu_item_new());

    R(REFLECT_X, "Reflected X");
    R(REFLECT_Y, "Reflected Y");
#undef R

    gtk_menu_shell_append(menu, gtk_separator_menu_item_new());
    gtk_widget_show_all(app_menu);

    /* Get screen resources */
    xcb_randr_get_screen_resources_current_cookie_t resources_cookie;
    xcb_randr_get_screen_resources_current_reply_t *resources_reply;
    xcb_generic_error_t *err = NULL;

    resources_cookie = xcb_randr_get_screen_resources_current(conn,
            info->root);
    resources_reply = xcb_randr_get_screen_resources_current_reply(conn,
            resources_cookie, &err);
    if (err) {
        g_warning("Get Screen Resources returned error %u\n", err->error_code);
        return;
    }

    /* Get screen outputs */
    xcb_randr_output_t *outputs;
    guint i;
    gchar *output_name;

    outputs = xcb_randr_get_screen_resources_current_outputs(resources_reply);
    for (i = 0; i < resources_reply->num_outputs; i++) {
        xcb_randr_get_output_info_reply_t *output_info_reply;
        xcb_randr_get_output_info_cookie_t output_info_cookie =
            xcb_randr_get_output_info_unchecked(conn, outputs[i],
                    resources_reply->config_timestamp);
        output_info_reply =
            xcb_randr_get_output_info_reply(conn, output_info_cookie, NULL);
        /* Show only if connected */
        switch (output_info_reply->connection) {
            case XCB_RANDR_CONNECTION_DISCONNECTED:
            case XCB_RANDR_CONNECTION_UNKNOWN:
                continue;
            case XCB_RANDR_CONNECTION_CONNECTED:
                break;
        }
        output_name = get_output_name(output_info_reply);
        /* Put output names on the menu */
        gtk_menu_item_set_label(GTK_MENU_ITEM(item), output_name);
        g_free(output_name);
        /* TODO: concatenate multiple names or pick them intelligently */
    }
}
コード例 #13
0
ファイル: main.c プロジェクト: 4179e1/misc
int main (int argc, char *argv[]) {
	Reg *reg;
	reg = g_slice_new (Reg);
	if (reg == NULL)
	{
		fprintf (stderr, "Error: not engouh space\n");
		exit (1);
	}

	reg->path = malloc (sizeof (char) * MAX_VALUE_NAME);
	if (reg->path == NULL)
	{
		fprintf (stderr, "Error: not engouh space\n");
		exit (1);
	}

	GtkWidget *window;
	GtkWidget *vbox;
	GtkWidget *menubar;
	GtkWidget *sw;
	GtkWidget *hpaned;
	GtkWidget *treeview;
	GtkWidget *listview;
	GtkWidget *statusbar;

	GtkTreeSelection *selection;

	GtkWidget *file;
	GtkWidget *edit;
	GtkWidget *option;

	GtkWidget *filemenu;
	GtkWidget *file_quit;

	GtkWidget *editmenu;
	GtkWidget *edit_insert_reg_sz;
	GtkWidget *edit_delete_key;

	GtkWidget *optionmenu;
	GtkWidget *option_add_to_run;
	GtkWidget *option_bind_gateway;

	gtk_init (&argc, &argv);

	window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title (GTK_WINDOW (window), "注册表编辑器");
	gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER);
	gtk_window_set_default_size (GTK_WINDOW (window), 600, 400);

	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, FALSE, 0);

	hpaned = gtk_hpaned_new ();
	gtk_box_pack_start (GTK_BOX (vbox), hpaned, TRUE, TRUE, 0);

	sw = gtk_scrolled_window_new (NULL, NULL);
	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
	gtk_paned_add1 (GTK_PANED (hpaned), sw);

	treeview = create_tree_view_and_model();
	gtk_container_add (GTK_CONTAINER (sw), treeview);
	gtk_widget_set_size_request (treeview, 150, 0);

	sw = gtk_scrolled_window_new (NULL, NULL);
	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
	gtk_paned_add2 (GTK_PANED (hpaned), sw);

	listview = create_list_view_and_model();
	gtk_container_add (GTK_CONTAINER (sw), listview);
	selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (listview));

	statusbar = gtk_statusbar_new();
	gtk_box_pack_start (GTK_BOX (vbox), statusbar, FALSE, FALSE, 0);

	file = gtk_menu_item_new_with_mnemonic ("_File");
	edit = gtk_menu_item_new_with_mnemonic ("_Edit");
	option = gtk_menu_item_new_with_mnemonic ("_Option");
	gtk_menu_shell_append (GTK_MENU_SHELL (menubar), file);
	gtk_menu_shell_append (GTK_MENU_SHELL (menubar), edit);
	gtk_menu_shell_append (GTK_MENU_SHELL (menubar), option);

	filemenu = gtk_menu_new();
	editmenu = gtk_menu_new();
	optionmenu = gtk_menu_new();
	gtk_menu_item_set_submenu (GTK_MENU_ITEM (file), filemenu);
	gtk_menu_item_set_submenu (GTK_MENU_ITEM (edit), editmenu);
	gtk_menu_item_set_submenu (GTK_MENU_ITEM (option), optionmenu);

	file_quit = gtk_image_menu_item_new_from_stock (GTK_STOCK_QUIT, NULL);
	gtk_menu_shell_append (GTK_MENU_SHELL (filemenu), file_quit);

	edit_insert_reg_sz = gtk_menu_item_new_with_label ("插入键值(REG_SZ)");
	edit_delete_key = gtk_menu_item_new_with_label ("删除选定键值");
	gtk_menu_shell_append (GTK_MENU_SHELL (editmenu), edit_insert_reg_sz);
	gtk_menu_shell_append (GTK_MENU_SHELL (editmenu), edit_delete_key);

	option_add_to_run = gtk_menu_item_new_with_label ("加入启动项");
	option_bind_gateway = gtk_menu_item_new_with_label ("绑定网关");
	gtk_menu_shell_append (GTK_MENU_SHELL (optionmenu), option_add_to_run);
	gtk_menu_shell_append (GTK_MENU_SHELL (optionmenu), option_bind_gateway);

	reg->rootkey = HKEY_CLASSES_ROOT;
	reg->path[0] = '\0';
	reg->treeview = treeview;
	reg->listview = listview;
	reg->selection = selection;
	reg->progname = argv[0];

	gtk_widget_show_all (window);

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

	g_signal_connect (GTK_TREE_VIEW (treeview), "row-activated", G_CALLBACK (on_tree_view_row_activated), reg);

	g_signal_connect (GTK_MENU_ITEM (file_quit), "activate", G_CALLBACK (gtk_main_quit), NULL);
	g_signal_connect (GTK_MENU_ITEM (edit_insert_reg_sz), "activate", G_CALLBACK (on_edit_insert_reg_sz_activate), reg);
	g_signal_connect (GTK_MENU_ITEM (edit_delete_key), "activate", G_CALLBACK (on_edit_delete_key_activate), reg);
	g_signal_connect (GTK_MENU_ITEM (option_add_to_run), "activate", G_CALLBACK (on_option_add_to_run_activate), reg);
	g_signal_connect (GTK_MENU_ITEM (option_bind_gateway), "activate", G_CALLBACK (on_option_bind_gateway_activate), reg);

//	g_signal_connect (selection, "changed", G_CALLBACK (on_changed), collection);

	gtk_main();	

	free (reg->path);
	g_slice_free (Reg, reg);

	return 0;
}
コード例 #14
0
ファイル: applet.c プロジェクト: clefebvre/mate-panel
GtkWidget *
mate_panel_applet_create_menu (AppletInfo *info)
{
	GtkWidget   *menu;
	GtkWidget   *menuitem;
	GList       *l;
	PanelWidget *panel_widget;
	gboolean     added_anything = FALSE;

	panel_widget = mate_panel_applet_get_panel_widget (info);

	menu = g_object_ref_sink (gtk_menu_new ());

	/* connect the show & deactivate signal, so that we can "disallow" and
	 * "re-allow" autohide when the menu is shown/deactivated.
	 */
	g_signal_connect (menu, "show",
			  G_CALLBACK (applet_menu_show), info);
	g_signal_connect (menu, "deactivate",
			  G_CALLBACK (applet_menu_deactivate), info);

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

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

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

		added_anything = TRUE;
	}

	if (!panel_lockdown_get_locked_down ()) {
		GtkWidget *image;
		gboolean   locked;
		gboolean   lockable;
		gboolean   movable;
		gboolean   removable;

		lockable = mate_panel_applet_lockable (info);
		movable = mate_panel_applet_can_freely_move (info);
		removable = panel_profile_id_lists_are_writable ();

		locked = panel_widget_get_applet_locked (panel_widget, info->widget);

		if (added_anything) {
			menuitem = gtk_separator_menu_item_new ();
			gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
			gtk_widget_show (menuitem);
		}

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

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

		g_assert (info->move_item == NULL);

		info->move_item = menuitem;
		g_object_add_weak_pointer (G_OBJECT (menuitem),
					   (gpointer *) &info->move_item);

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

		menuitem = gtk_check_menu_item_new_with_mnemonic (_("Loc_k To Panel"));
		gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menuitem),
						locked);
		g_signal_connect (menuitem, "toggled",
				  G_CALLBACK (mate_panel_applet_lock), info);
		gtk_widget_show (menuitem);
		gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
		gtk_widget_set_sensitive (menuitem, lockable);

		added_anything = TRUE;
	}

	if ( ! added_anything) {
		g_object_unref (menu);
		return NULL;
	}

/* Set up theme and transparency support */
#if GTK_CHECK_VERSION (3, 0, 0) 
	GtkWidget *toplevel = gtk_widget_get_toplevel (menu);
/* Fix any failures of compiz/other wm's to communicate with gtk for transparency */
	GdkScreen *screen = gtk_widget_get_screen(GTK_WIDGET(toplevel));
	GdkVisual *visual = gdk_screen_get_rgba_visual(screen);
	gtk_widget_set_visual(GTK_WIDGET(toplevel), visual); 
/* Set menu and it's toplevel window to follow panel theme */
	GtkStyleContext *context;
	context = gtk_widget_get_style_context (GTK_WIDGET(toplevel));
	gtk_style_context_add_class(context,"gnome-panel-menu-bar");
	gtk_style_context_add_class(context,"mate-panel-menu-bar");
#endif
	return menu;
}
コード例 #15
0
ファイル: testtreeview.c プロジェクト: batman52/dingux-code
int
main (int    argc,
      char **argv)
{
  GtkWidget *window;
  GtkWidget *sw;
  GtkWidget *tv;
  GtkWidget *table;
  GtkWidget *om;
  GtkWidget *menu;
  GtkTreeModel *model;
  gint i;
  
  gtk_init (&argc, &argv);

  our_pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **) book_closed_xpm);  
  
#if 0
  models[MODEL_TYPES] = GTK_TREE_MODEL (gtk_tree_model_types_new ());
#endif
  models[MODEL_LIST] = create_list_model ();
  models[MODEL_TREE] = create_tree_model ();

  model = create_list_model ();
  models[MODEL_SORTED_LIST] = gtk_tree_model_sort_new_with_model (model);
  g_object_unref (model);

  model = create_tree_model ();
  models[MODEL_SORTED_TREE] = gtk_tree_model_sort_new_with_model (model);
  g_object_unref (model);

  models[MODEL_EMPTY_LIST] = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_INT));
  models[MODEL_EMPTY_TREE] = GTK_TREE_MODEL (gtk_tree_store_new (1, G_TYPE_INT));
  
  models[MODEL_NULL] = NULL;

  run_automated_tests ();
  
  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
  gtk_window_set_default_size (GTK_WINDOW (window), 430, 400);

  table = gtk_table_new (3, 1, FALSE);

  gtk_container_add (GTK_CONTAINER (window), table);

  tv = gtk_tree_view_new_with_model (models[0]);
  
  gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (tv),
					  GDK_BUTTON1_MASK,
					  row_targets,
					  G_N_ELEMENTS (row_targets),
					  GDK_ACTION_MOVE | GDK_ACTION_COPY);

  gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (tv),
					row_targets,
					G_N_ELEMENTS (row_targets),
					GDK_ACTION_MOVE | GDK_ACTION_COPY);
  
  /* Model menu */

  menu = gtk_menu_new ();
  
  i = 0;
  while (i < MODEL_LAST)
    {
      GtkWidget *mi;
      const char *name;

      name = model_names[i];
      
      mi = gtk_menu_item_new_with_label (name);

      gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);

#if 0
      window = create_prop_editor (G_OBJECT (models[i]));

      gtk_window_set_title (GTK_WINDOW (window),                            
                            name);
#endif

      ++i;
    }
  gtk_widget_show_all (menu);
  
  om = gtk_option_menu_new ();
  gtk_option_menu_set_menu (GTK_OPTION_MENU (om), menu);
  
  gtk_table_attach (GTK_TABLE (table), om,
                    0, 1, 0, 1,
                    0, 0, 
                    0, 0);

  g_signal_connect (om,
                    "changed",
                    G_CALLBACK (model_selected),
		    tv);
  
  /* Columns menu */

  menu = gtk_menu_new ();
  
  i = 0;
  while (i < COLUMNS_LAST)
    {
      GtkWidget *mi;
      const char *name;

      name = column_type_names[i];
      
      mi = gtk_menu_item_new_with_label (name);

      gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);

      ++i;
    }
  gtk_widget_show_all (menu);
  
  om = gtk_option_menu_new ();
  gtk_option_menu_set_menu (GTK_OPTION_MENU (om), menu);
  
  gtk_table_attach (GTK_TABLE (table), om,
                    0, 1, 1, 2,
                    0, 0, 
                    0, 0);

  set_columns_type (GTK_TREE_VIEW (tv), COLUMNS_LOTS);
  gtk_option_menu_set_history (GTK_OPTION_MENU (om), COLUMNS_LOTS);
  
  g_signal_connect (om,
                    "changed",
                    G_CALLBACK (columns_selected),
                    tv);
  
  sw = gtk_scrolled_window_new (NULL, NULL);
  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
                                  GTK_POLICY_AUTOMATIC,
                                  GTK_POLICY_AUTOMATIC);
  
  gtk_table_attach (GTK_TABLE (table), sw,
                    0, 1, 2, 3,
                    GTK_EXPAND | GTK_FILL,
                    GTK_EXPAND | GTK_FILL,
                    0, 0);
  
  gtk_container_add (GTK_CONTAINER (sw), tv);
  
  gtk_widget_show_all (window);
  
  gtk_main ();

  return 0;
}
コード例 #16
0
ファイル: callbacks.c プロジェクト: Ferada/uzbl
void
populate_popup_cb(WebKitWebView *v, GtkMenu *m, void *c) {
    (void) c;
    GUI *g = &uzbl.gui;
    GtkWidget *item;
    MenuItem *mi;
    guint i=0;
    gint context, hit=0;

    if(!g->menu_items)
        return;

    /* check context */
    if((context = get_click_context(NULL)) == -1)
        return;

    for(i=0; i < uzbl.gui.menu_items->len; i++) {
        hit = 0;
        mi = g_ptr_array_index(uzbl.gui.menu_items, i);

        if (mi->context & WEBKIT_HIT_TEST_RESULT_CONTEXT_IMAGE) {
            GdkEventButton ev;
            gint x, y;
            gdk_window_get_pointer(gtk_widget_get_window(GTK_WIDGET(v)), &x, &y, NULL);
            ev.x = x;
            ev.y = y;
            mi->hittest = webkit_web_view_get_hit_test_result(v, &ev);
        }

        if((mi->context > WEBKIT_HIT_TEST_RESULT_CONTEXT_DOCUMENT) &&
                (context & mi->context)) {
            if(mi->issep) {
                item = gtk_separator_menu_item_new();
                gtk_menu_shell_append(GTK_MENU_SHELL(m), item);
                gtk_widget_show(item);
            }
            else {
                item = gtk_menu_item_new_with_label(mi->name);
                g_signal_connect(item, "activate",
                        G_CALLBACK(run_menu_command), mi);
                gtk_menu_shell_append(GTK_MENU_SHELL(m), item);
                gtk_widget_show(item);
            }
            hit++;
        }

        if((mi->context == WEBKIT_HIT_TEST_RESULT_CONTEXT_DOCUMENT)  &&
                (context <= WEBKIT_HIT_TEST_RESULT_CONTEXT_DOCUMENT) &&
                !hit) {
            if(mi->issep) {
                item = gtk_separator_menu_item_new();
                gtk_menu_shell_append(GTK_MENU_SHELL(m), item);
                gtk_widget_show(item);
            }
            else {
                item = gtk_menu_item_new_with_label(mi->name);
                g_signal_connect(item, "activate",
                        G_CALLBACK(run_menu_command), mi);
                gtk_menu_shell_append(GTK_MENU_SHELL(m), item);
                gtk_widget_show(item);
            }
        }
    }
}
コード例 #17
0
WbExpWGtk::WbExpWGtk (
	void *expw_parent_ctx,
	GtkWidget *expw_parent_wid,
	ldh_tSession expw_ldhses,
	const char *expw_name,
	int l_type,
	int l_editmode,
	pwr_tStatus *status) :
  WbExpW( expw_parent_ctx, expw_ldhses, expw_name, l_type, l_editmode, status), parent_wid(expw_parent_wid)
{
  const int	window_width = 1100;
  const int    	window_height = 600;

  toplevel = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW, 
					 "default-height", window_height,
					 "default-width", window_width,
					 "title", expw_name,
					 NULL);

  g_signal_connect( toplevel, "delete_event", G_CALLBACK(delete_event), this);
  g_signal_connect( toplevel, "destroy", G_CALLBACK(destroy_event), this);
  g_signal_connect( toplevel, "focus-in-event", G_CALLBACK(WbExpWGtk::action_inputfocus), 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
  GtkWidget *file_close = gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE, accel_g);
  g_signal_connect(file_close, "activate", G_CALLBACK(WbExpWGtk::activate_exit), this);

  file_export = gtk_menu_item_new_with_mnemonic( btext);
  g_signal_connect(file_export, "activate", G_CALLBACK(WbExpWGtk::activate_export), this);

  GtkMenu *file_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
  gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_export);

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

  // Edit menu
  GtkWidget *edit_update = gtk_menu_item_new_with_mnemonic( "_Update");
  g_signal_connect(edit_update, "activate", G_CALLBACK(WbExpWGtk::activate_update), this);
  gtk_widget_add_accelerator( edit_update, "activate", accel_g,
			      'u', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);

  edit_check_all = gtk_menu_item_new_with_mnemonic( "_Check all");
  g_signal_connect(edit_check_all, "activate", G_CALLBACK(WbExpWGtk::activate_check_all), this);

  edit_check_clear = gtk_menu_item_new_with_mnemonic( "C_heck clear");
  g_signal_connect(edit_check_clear, "activate", G_CALLBACK(WbExpWGtk::activate_check_clear), this);

  edit_check_reset = gtk_menu_item_new_with_mnemonic( "Check _reset");
  g_signal_connect(edit_check_reset, "activate", G_CALLBACK(WbExpWGtk::activate_check_reset), this);

  edit_show_all = gtk_check_menu_item_new_with_mnemonic( "_Show all");
  g_signal_connect( edit_show_all, "activate", 
		    G_CALLBACK(activate_show_all), this);
  gtk_widget_add_accelerator( edit_show_all, "activate", accel_g,
			      'a', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);

  GtkMenu *edit_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
  gtk_menu_shell_append(GTK_MENU_SHELL(edit_menu), edit_update);
  gtk_menu_shell_append(GTK_MENU_SHELL(edit_menu), edit_check_all);
  gtk_menu_shell_append(GTK_MENU_SHELL(edit_menu), edit_check_clear);
  gtk_menu_shell_append(GTK_MENU_SHELL(edit_menu), edit_check_reset);
  gtk_menu_shell_append(GTK_MENU_SHELL(edit_menu), edit_show_all);

  GtkWidget *edit = gtk_menu_item_new_with_mnemonic("_Edit");
  gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), edit);
  gtk_menu_item_set_submenu(GTK_MENU_ITEM(edit), GTK_WIDGET(edit_menu));

  // View menu
  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(WbExpWGtk::activate_zoom_in), this);
  gtk_widget_add_accelerator( view_zoom_in, "activate", accel_g,
			      'i', 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(WbExpWGtk::activate_zoom_out), this);
  gtk_widget_add_accelerator( view_zoom_out, "activate", accel_g,
			      'o', 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(WbExpWGtk::activate_zoom_reset), this);

  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);

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

  // Help Entry
  GtkWidget *help_help = gtk_image_menu_item_new_from_stock(GTK_STOCK_HELP, accel_g);
  g_signal_connect(help_help, "activate", G_CALLBACK(WbExpWGtk::activate_help), this);

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

  GtkWidget *help = gtk_menu_item_new_with_mnemonic("_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);

  pwr_tFileName fname;
  GtkWidget *tools_export = gtk_button_new();
  dcli_translate_filename( fname, "$pwr_exe/wb_export.png");
  gtk_container_add( GTK_CONTAINER(tools_export), 
		     gtk_image_new_from_file( fname));
  g_signal_connect(tools_export, "clicked", G_CALLBACK(activate_export), this);
  g_object_set( tools_export, "can-focus", FALSE, NULL);
  gtk_toolbar_append_widget( tools, tools_export, action, "");

  GtkWidget *tools_update = gtk_button_new();
  dcli_translate_filename( fname, "$pwr_exe/ge_update.png");
  gtk_container_add( GTK_CONTAINER(tools_update), 
		     gtk_image_new_from_file( fname));
  g_signal_connect(tools_update, "clicked", G_CALLBACK(activate_update), this);
  g_object_set( tools_update, "can-focus", FALSE, NULL);
  gtk_toolbar_append_widget( tools, tools_update, "Update", "");

  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_zoom_in), this);
  g_object_set( tools_zoom_in, "can-focus", FALSE, NULL);
  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_zoom_out), this);
  g_object_set( tools_zoom_out, "can-focus", FALSE, NULL);
  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_zoom_reset), this);
  g_object_set( tools_zoom_reset, "can-focus", FALSE, NULL);
  gtk_toolbar_append_widget( tools, tools_zoom_reset, "Zoom reset", "");


  form = gtk_vbox_new( FALSE, 0);

  // Create expwnav
  expwnav = new WbExpWNavGtk( this, form, expw_ldhses, l_type, l_editmode, &nav_widget);

  gtk_box_pack_start( GTK_BOX(form), GTK_WIDGET(menu_bar), FALSE, FALSE, 0);
  gtk_box_pack_start( GTK_BOX(form), GTK_WIDGET(tools), FALSE, FALSE, 0);
  gtk_box_pack_start( GTK_BOX(form), GTK_WIDGET(nav_widget), TRUE, TRUE, 0);

  gtk_container_add( GTK_CONTAINER(toplevel), form);

  gtk_widget_show_all( toplevel);

  wow = new CoWowGtk( toplevel);

  show();
  // expwnav->check_all();
}
コード例 #18
0
void switcher_button_init(SwitcherButton *self)
{
    self->priv = SWITCHER_BUTTON_GET_PRIVATE(self);

    self->priv->osso = osso_initialize("layoutswitcher", VERSION, 0, 0);

    self->priv->model = tabletModel();

    switch (self->priv->model)
    {
        case N800:
            printf("800\n");
            break;
        case N810:
            printf("810\n");
            break;
        case N900:
            printf("900\n");
            break;
        case N770:
            printf("770\n");
            break;
    }

    self->priv->locked = 0;

    self->priv->theme = gtk_icon_theme_get_default();
    self->priv->lock = gtk_icon_theme_load_icon(self->priv->theme, "layoutswitcher-lock", 40, (GtkIconLookupFlags)0, 0);

    self->priv->icon0 = 0;
    self->priv->icon1 = 0;

    self->priv->gconfClient = gconf_client_get_default();

	if (self->priv->model == N800 || self->priv->model == N810)
	{
		gconf_client_add_dir(self->priv->gconfClient, GCONF_DIR_2008, GCONF_CLIENT_PRELOAD_NONE, 0);

		self->priv->gconfNotifyCurrent = gconf_client_notify_add(self->priv->gconfClient,
				GCONF_CURRENT_2008, switcher_button_on_current_changed, self, 0, 0);
		self->priv->gconfNotifyLang0 = gconf_client_notify_add(self->priv->gconfClient,
				GCONF_LANG0_2008, switcher_button_on_language_changed, self, 0, 0);
		self->priv->gconfNotifyLang1 = gconf_client_notify_add(self->priv->gconfClient,
				GCONF_LANG1_2008, switcher_button_on_language_changed, self, 0, 0);
	}
	else if (self->priv->model == N770)
	{
		gconf_client_add_dir(self->priv->gconfClient, GCONF_DIR_2006, GCONF_CLIENT_PRELOAD_NONE, 0);

		self->priv->gconfNotifyCurrent = gconf_client_notify_add(self->priv->gconfClient,
				GCONF_CURRENT_2006, switcher_button_on_current_changed, self, 0, 0);
		self->priv->gconfNotifyLang0 = gconf_client_notify_add(self->priv->gconfClient,
				GCONF_LANG0_2006, switcher_button_on_language_changed, self, 0, 0);
		self->priv->gconfNotifyLang1 = gconf_client_notify_add(self->priv->gconfClient,
				GCONF_LANG1_2006, switcher_button_on_language_changed, self, 0, 0);
	}

    gconf_client_add_dir(self->priv->gconfClient, GCONF_LOCK_DIR, GCONF_CLIENT_PRELOAD_NONE, 0);
    self->priv->gconfNotifyLock = gconf_client_notify_add(self->priv->gconfClient,
        GCONF_LOCK_ENTRY, switcher_button_on_lock_changed, self, 0, 0);

    self->priv->menu = gtk_menu_new();
    self->priv->menuItemCopy = gtk_menu_item_new_with_label("Copy text");
    self->priv->menuItemBlock= gtk_check_menu_item_new_with_label("Block keyboard");
    g_signal_connect(G_OBJECT(self->priv->menuItemCopy), "activate", G_CALLBACK(switcher_button_on_copy_menu), self);
    g_signal_connect(G_OBJECT(self->priv->menuItemBlock), "activate", G_CALLBACK(switcher_button_on_block_menu), self);
    gtk_menu_shell_append(GTK_MENU_SHELL(self->priv->menu), self->priv->menuItemCopy);
    gtk_menu_shell_append(GTK_MENU_SHELL(self->priv->menu), self->priv->menuItemBlock);
    gtk_widget_show_all(self->priv->menu);

    g_signal_connect(G_OBJECT(self), "clicked", G_CALLBACK(switcher_button_on_click), 0);

    if (self->priv->model == N770)
    {
        g_signal_connect(G_OBJECT(self), "tap-and-hold", G_CALLBACK(switcher_button_on_tap_and_hold), 0);
        gtk_widget_tap_and_hold_setup(GTK_WIDGET(self), 0, 0, 0);
    }
    else
    {
    //    g_signal_connect(G_OBJECT(self), "tap-and-hold", G_CALLBACK(switcher_button_on_tap_and_hold), 0);
        gtk_widget_tap_and_hold_setup(GTK_WIDGET(self), self->priv->menu, 0, 0);
    }

    g_signal_connect_after(G_OBJECT(self), "expose-event", G_CALLBACK(switcher_button_on_expose), 0);

    switcher_button_update_languages(self);
}
コード例 #19
0
void PopupMenuGtk::show(const IntRect& rect, FrameView* view, int index)
{
    ASSERT(client());

    if (!m_popup) {
        m_popup = GTK_MENU(gtk_menu_new());
        g_signal_connect(m_popup.get(), "unmap", G_CALLBACK(PopupMenuGtk::menuUnmapped), this);
        g_signal_connect(m_popup.get(), "key-press-event", G_CALLBACK(PopupMenuGtk::keyPressEventCallback), this);
    } else
        gtk_container_foreach(GTK_CONTAINER(m_popup.get()), reinterpret_cast<GtkCallback>(menuRemoveItem), this);

    int x = 0;
    int y = 0;
    GdkWindow* window = gtk_widget_get_window(GTK_WIDGET(view->hostWindow()->platformPageClient()));
    if (window)
        gdk_window_get_origin(window, &x, &y);
    m_menuPosition = view->contentsToWindow(rect.location());
    m_menuPosition = IntPoint(m_menuPosition.x() + x, m_menuPosition.y() + y + rect.height());
    m_indexMap.clear();

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

        m_indexMap.add(item, i);
        g_signal_connect(item, "activate", G_CALLBACK(PopupMenuGtk::menuItemActivated), this);
        g_signal_connect(item, "select", G_CALLBACK(PopupMenuGtk::selectItemCallback), this);

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

    gtk_menu_set_active(m_popup.get(), index);


    // The size calls are directly copied from gtkcombobox.c which is LGPL
    GtkRequisition requisition;
    gtk_widget_set_size_request(GTK_WIDGET(m_popup.get()), -1, -1);
#ifdef GTK_API_VERSION_2
    gtk_widget_size_request(GTK_WIDGET(m_popup.get()), &requisition);
#else
    gtk_widget_get_preferred_size(GTK_WIDGET(m_popup.get()), &requisition, 0);
#endif

    gtk_widget_set_size_request(GTK_WIDGET(m_popup.get()), std::max(rect.width(), requisition.width), -1);

    GList* children = gtk_container_get_children(GTK_CONTAINER(m_popup.get()));
    GList* p = children;
    if (size) {
        for (int i = 0; i < size; i++) {
            if (i > index)
              break;

            GtkWidget* item = reinterpret_cast<GtkWidget*>(p->data);
            GtkRequisition itemRequisition;
#ifdef GTK_API_VERSION_2
            gtk_widget_get_child_requisition(item, &itemRequisition);
#else
            gtk_widget_get_preferred_size(item, &itemRequisition, 0);
#endif
            m_menuPosition.setY(m_menuPosition.y() - itemRequisition.height);

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

    g_list_free(children);
    gtk_menu_popup(m_popup.get(), 0, 0, reinterpret_cast<GtkMenuPositionFunc>(menuPositionFunction), this, 0, gtk_get_current_event_time());
}
コード例 #20
0
ファイル: chat.c プロジェクト: yong93/linphone
GtkWidget* linphone_gtk_init_chatroom(LinphoneChatRoom *cr, const LinphoneAddress *with){
	GtkWidget *chat_view=linphone_gtk_create_widget("chatroom_frame");
	GtkWidget *main_window=linphone_gtk_get_main_window();
	GtkNotebook *notebook=(GtkNotebook *)linphone_gtk_get_widget(main_window,"viewswitch");
	GtkWidget *text=linphone_gtk_get_widget(chat_view,"textview");
	GdkColor color_grey = {0, 32512, 32512, 32512};
	GdkColor color_light_grey = {0, 56832, 60928, 61952};
	GdkColor color_black = {0};
	int idx;
	GtkWidget *button;
	GtkWidget *entry = linphone_gtk_get_widget(chat_view,"text_entry");
	MSList *messages;
	GHashTable *table;
	GtkTextTag *tmp_tag;
	GtkWidget *link_ctx_menu = gtk_menu_new();
	GtkWidget *link_ctx_menu_copy_item = gtk_menu_item_new_with_label(_("Copy"));

	gtk_notebook_append_page(notebook,chat_view,create_tab_chat_header(cr,with));
	idx = gtk_notebook_page_num(notebook, chat_view);
	gtk_notebook_set_current_page(notebook, idx);
	gtk_widget_show(chat_view);
	table=g_hash_table_new_full(g_direct_hash,g_direct_equal,NULL,NULL);
	g_object_set_data(G_OBJECT(chat_view),"cr",cr);
	g_object_set_data(G_OBJECT(chat_view),"from_message",NULL);
	g_object_set_data_full(G_OBJECT(chat_view),"table",table,(GDestroyNotify)g_hash_table_destroy);

	gtk_text_buffer_create_tag(
		gtk_text_view_get_buffer(GTK_TEXT_VIEW(text)),
		"me",
		"foreground_gdk", &color_black,
		"paragraph-background-gdk", &color_light_grey,
		NULL);

	gtk_text_buffer_create_tag(
		gtk_text_view_get_buffer(GTK_TEXT_VIEW(text)),
		"from",
		"weight", PANGO_WEIGHT_BOLD,
		NULL);

	gtk_text_buffer_create_tag(
		gtk_text_view_get_buffer(GTK_TEXT_VIEW(text)),
		"body",
		"indent", 10,
		NULL);

	gtk_text_buffer_create_tag(
		gtk_text_view_get_buffer(GTK_TEXT_VIEW(text)),
		"status",
		"size-points", 9.0,
		"foreground_gdk", &color_grey,
		"style", PANGO_STYLE_ITALIC,
		"justification", GTK_JUSTIFY_RIGHT,
		NULL);

	tmp_tag = gtk_text_buffer_create_tag(
		gtk_text_view_get_buffer(GTK_TEXT_VIEW(text)),
		"link",
		"underline", PANGO_UNDERLINE_SINGLE,
		"foreground_gdk", _linphone_gtk_chatroom_get_link_color(chat_view),
		NULL);
	g_signal_connect(G_OBJECT(tmp_tag), "event", G_CALLBACK(link_event_handler), chat_view);
	g_signal_connect(G_OBJECT(text), "event", G_CALLBACK(chatroom_event), NULL);
	gtk_menu_shell_append(GTK_MENU_SHELL(link_ctx_menu), link_ctx_menu_copy_item);
	g_signal_connect(G_OBJECT(link_ctx_menu_copy_item), "activate", G_CALLBACK(copy_uri_into_clipboard_handler), NULL);
	gtk_widget_show_all(link_ctx_menu);
	g_object_set_data_full(G_OBJECT(text), "link_ctx_menu", link_ctx_menu, g_object_unref);
	g_object_ref_sink(G_OBJECT(link_ctx_menu));

	messages = linphone_chat_room_get_history(cr,NB_MSG_HIST);
	display_history_message(chat_view,messages,with);
	button = linphone_gtk_get_widget(chat_view,"send");
	g_signal_connect_swapped(G_OBJECT(button),"clicked",(GCallback)linphone_gtk_send_text,NULL);

	g_signal_connect_swapped(G_OBJECT(entry),"activate",(GCallback)linphone_gtk_send_text,NULL);
	g_signal_connect_swapped(G_OBJECT(entry),"changed",(GCallback)linphone_gtk_compose_text,NULL);
	g_signal_connect(G_OBJECT(notebook),"switch_page",(GCallback)linphone_gtk_notebook_tab_select,NULL);
	return chat_view;
}
コード例 #21
0
ファイル: selector.c プロジェクト: Akenyshka/libwnck
static void
wnck_selector_on_show (GtkWidget *widget, WnckSelector *selector)
{
  GtkWidget *separator;
  WnckScreen *screen;
  WnckWorkspace *workspace;
  int nb_workspace;
  int i;
  GList **windows_per_workspace;
  GList *windows;
  GList *l, *children;

  /* Remove existing items */
  children = gtk_container_get_children (GTK_CONTAINER (selector->priv->menu));
  for (l = children; l; l = l->next)
    gtk_container_remove (GTK_CONTAINER (selector->priv->menu), l->data);
  g_list_free (children);

  if (selector->priv->window_hash)
    g_hash_table_destroy (selector->priv->window_hash);
  selector->priv->window_hash = g_hash_table_new_full (g_direct_hash,
                                                 g_direct_equal,
                                                 NULL, g_free);

  screen = wnck_selector_get_screen (selector);

  nb_workspace = wnck_screen_get_workspace_count (screen);
  windows_per_workspace = g_malloc0 (nb_workspace * sizeof (GList *));

  /* Get windows ordered by workspaces */
  windows = wnck_screen_get_windows (screen);
  windows = g_list_sort (windows, wnck_selector_windows_compare);

  for (l = windows; l; l = l->next)
    {
      workspace = wnck_window_get_workspace (l->data);
      if (!workspace && wnck_window_is_pinned (l->data))
        workspace = wnck_screen_get_active_workspace (screen);
      if (!workspace)
        continue;
      i = wnck_workspace_get_number (workspace);
      windows_per_workspace[i] = g_list_prepend (windows_per_workspace[i],
                                                 l->data);
    }

  /* Add windows from the current workspace */
  workspace = wnck_screen_get_active_workspace (screen);
  if (workspace)
    {
      i = wnck_workspace_get_number (workspace);

      windows_per_workspace[i] = g_list_reverse (windows_per_workspace[i]);
      for (l = windows_per_workspace[i]; l; l = l->next)
        wnck_selector_append_window (selector, l->data);
      g_list_free (windows_per_workspace[i]);
      windows_per_workspace[i] = NULL;
    }

  /* Add separator */
  separator = gtk_separator_menu_item_new ();
  gtk_menu_shell_append (GTK_MENU_SHELL (selector->priv->menu), separator);

  /* Add windows from other workspaces */
  for (i = 0; i < nb_workspace; i++)
    {
      wnck_selector_add_workspace (selector, screen, i);
      windows_per_workspace[i] = g_list_reverse (windows_per_workspace[i]);
      for (l = windows_per_workspace[i]; l; l = l->next)
        wnck_selector_append_window (selector, l->data);
      g_list_free (windows_per_workspace[i]);
      windows_per_workspace[i] = NULL;
    }
  g_free (windows_per_workspace);

  selector->priv->no_windows_item = wnck_selector_item_new (selector,
		  					    _("No Windows Open"),
							    NULL);
  gtk_widget_set_sensitive (selector->priv->no_windows_item, FALSE);
  gtk_menu_shell_append (GTK_MENU_SHELL (selector->priv->menu),
                         selector->priv->no_windows_item);

  wnck_selector_make_menu_consistent (selector);
}
コード例 #22
0
void cd_switcher_build_windows_list (GtkWidget *pMenu)
{
	GList *pWindowList = NULL;
	pWindowList = cairo_dock_get_current_applis_list ();
	pWindowList = g_list_sort (pWindowList, (GCompareFunc) _compare_icons_stack_order);
	
	// chaque bureau/viewport.
	int iNumDesktop=0, iNumViewportX=0, iNumViewportY=0;
	int k = 0, N = g_desktopGeometry.iNbDesktops * g_desktopGeometry.iNbViewportX * g_desktopGeometry.iNbViewportY;
	int iIndex = cd_switcher_compute_index_from_desktop (myData.switcher.iCurrentDesktop, myData.switcher.iCurrentViewportX, myData.switcher.iCurrentViewportY);
	GString *sDesktopName = g_string_new ("");
	int i, j;
	for (j = 0; j < myData.switcher.iNbLines; j ++)
	{
		for (i = 0; i < myData.switcher.iNbColumns; i ++)
		{
			// on ajoute le nom du bureau/viewport dans le menu.
			GtkWidget *pMenuItem = gtk_separator_menu_item_new ();
			gtk_menu_shell_append(GTK_MENU_SHELL (pMenu), pMenuItem);
			g_object_set (pMenuItem, "height-request", 3, NULL);
			
			if (k < myData.iNbNames)
			{
				if (k == iIndex)
					g_string_printf (sDesktopName, "<b>%s (%s)</b>", myData.cDesktopNames[k], D_("Current"));
				else
					g_string_printf (sDesktopName, "<b>%s</b>", myData.cDesktopNames[k]);
			}
			else
			{
				if (k == iIndex)
					g_string_printf (sDesktopName, "<b>%s %d (%s)</b>", D_("Desktop"), k+1, D_("Current"));
				else
					g_string_printf (sDesktopName, "<b>%s %d</b>", D_("Desktop"), k+1);
			}
			pMenuItem = gldi_menu_add_item (pMenu, sDesktopName->str, NULL, G_CALLBACK (_show_desktop), GINT_TO_POINTER (k));
			GtkWidget *pLabel = gtk_bin_get_child (GTK_BIN(pMenuItem));
			gtk_label_set_use_markup (GTK_LABEL (pLabel), TRUE);
			gtk_misc_set_alignment (GTK_MISC (pLabel), .5, .5);
			
			pMenuItem = gtk_separator_menu_item_new ();
			gtk_menu_shell_append(GTK_MENU_SHELL (pMenu), pMenuItem);
			g_object_set (pMenuItem, "height-request", 3, NULL);
			
			// on ajoute les fenetres du viewport au menu.
			cd_debug ("Windows' listing (%d;%d;%d) ...", iNumDesktop, iNumViewportX, iNumViewportY);
			cd_switcher_foreach_window_on_viewport (iNumDesktop,
				iNumViewportX,
				iNumViewportY,
				(CDSwitcherActionOnViewportFunc) _cd_switcher_add_window_on_viewport,
				pMenu);
			
			// on passe au viewport suivant.
			iNumViewportX ++;
			if (iNumViewportX == g_desktopGeometry.iNbViewportX)
			{
				iNumViewportX = 0;
				iNumViewportY ++;
				if (iNumViewportY == g_desktopGeometry.iNbViewportY)
				{
					iNumViewportY = 0;
					iNumDesktop ++;
				}
			}
			k ++;
			if (k == N)
				break ;
		}
	}
	g_string_free (sDesktopName, TRUE);
}
コード例 #23
0
static void
build_sort_field_menu (gint start, gint end, gint index, GtkWidget *menu, SortFlowState *state, int used)
{
	Sheet *sheet = state->sel->v_range.cell.a.sheet;
	GtkWidget *item;
	GtkWidget *submenu;
	int i;
	int this_end;
	char *str;
	char *str_start;
	char *str_end;
	AddSortFieldMenuState *menu_state;
	gint menu_size;

	menu_size = 1 + end - start;
	if (MAX_MENU_SIZE < menu_size - used) {
		gint submenu_size;
		gint balanced_submenu_size;

		submenu_size = (menu_size + MAX_MENU_SIZE - 1) / MAX_MENU_SIZE;
		balanced_submenu_size = sqrt((double)
					     (menu_size + MAX_MENU_SIZE - 1));
		if (balanced_submenu_size > submenu_size)
			submenu_size = balanced_submenu_size;

		for (i = start; i <= end; i+=submenu_size) {
			this_end = i + submenu_size - 1;
			if (this_end > end)
				this_end = end;

			/* See if there are any fields in this range that aren't already
			   in the sort.
			*/
			if (range_already_in_sort_criteria(i, this_end, state))
				continue;

			str_start = state->is_cols
				? col_row_name (sheet, i, index, state->header, TRUE)
				: col_row_name (sheet, index, i, state->header, FALSE);

			str_end = state->is_cols
				? col_row_name (sheet, this_end, index, state->header, TRUE)
				: col_row_name (sheet, index, this_end, state->header, FALSE);

			str = g_strdup_printf(_("%s to %s"), str_start, str_end);
			g_free(str_start);
			g_free(str_end);

			item = (GtkWidget *) gtk_menu_item_new_with_label(str);
			gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
			gtk_widget_show (item);

			menu_state = g_new(AddSortFieldMenuState, 1);
			menu_state->start = i;
			menu_state->end = this_end;
			menu_state->index = index;
			menu_state->state = state;
			menu_state->done_submenu = FALSE;
			submenu = gtk_menu_new();
			gtk_menu_item_set_submenu(GTK_MENU_ITEM (item), submenu);
			g_signal_connect (item, "activate",
					  G_CALLBACK (cb_sort_field_menu_activate), menu_state);
		}
	}  else {
		for (i = start; i <= end; i++) {
			if (FALSE == already_in_sort_fields(i, state)) {

				str = state->is_cols
					? col_row_name (sheet, i, index, state->header, TRUE)
					: col_row_name (sheet, index, i, state->header, FALSE);
				item = (GtkWidget *) gtk_menu_item_new_with_label(str);
				gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
				gtk_widget_show (item);
				menu_state = g_new(AddSortFieldMenuState, 1);
				menu_state->start = i;
				menu_state->end = i;
				menu_state->index = index;
				menu_state->state = state;
				menu_state->done_submenu = FALSE;
				g_signal_connect (item, "activate",
						  G_CALLBACK (cb_sort_field_selection),
						  menu_state);
			}
		}
	}
}
コード例 #24
0
WCrrGtk::WCrrGtk( 
	GtkWidget      	*xa_parent_wid,
	void 		*xa_parent_ctx, 
	ldh_tSesContext xa_ldhses, 
	pwr_sAttrRef 	*xa_objar,
	int 		xa_advanced_user,
        int             *xa_sts) :
  WCrr( xa_parent_ctx, xa_objar, xa_advanced_user, xa_sts),
  parent_wid(xa_parent_wid)
{
  int sts;
  char *namep;
  int size;
  pwr_tAName   	title;

  *xa_sts = ldh_AttrRefToName( xa_ldhses, &objar, cdh_mNName, &namep, &size);
  if ( EVEN(*xa_sts)) return;

  strncpy( title, namep, sizeof(title));

  toplevel = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW, 
					 "default-height", 420,
					 "default-width", 600,
					 "title", CoWowGtk::convert_utf8(title),
					 NULL);

  g_signal_connect( toplevel, "delete_event", G_CALLBACK(delete_event), this);
  g_signal_connect( toplevel, "destroy", G_CALLBACK(destroy_event), this);
  g_signal_connect( toplevel, "focus-in-event", G_CALLBACK(action_inputfocus), this);

  CoWowGtk::SetWindowIcon( toplevel);

  GtkWidget *vbox = gtk_vbox_new( FALSE, 0);

  // Menu
  // Accelerators
  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
  GtkWidget *file_close = gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE, accel_g);
  g_signal_connect(file_close, "activate", G_CALLBACK(activate_exit), this);

  GtkMenu *file_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
  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_plc = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("Open _Program"));
  g_signal_connect( functions_open_plc, "activate", 
		    G_CALLBACK(activate_openplc), this);
  gtk_widget_add_accelerator( functions_open_plc, "activate", accel_g,
  			      'l', GdkModifierType(GDK_CONTROL_MASK), 
  			      GTK_ACCEL_VISIBLE);


  GtkMenu *func_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
  gtk_menu_shell_append(GTK_MENU_SHELL(func_menu), functions_open_plc);

  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(func_menu));

  // Help entry
  GtkWidget *help_help = gtk_image_menu_item_new_from_stock(GTK_STOCK_HELP, accel_g);
  g_signal_connect(help_help, "activate", G_CALLBACK(activate_help), this);

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

  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));

  xcrrnav = new WAttNavGtk( (void *)this, wattnav_eType_CrossRef, vbox, "Plant", xa_ldhses,
			    objar, 0, xa_advanced_user, 1, wb_eUtility_AttributeEditor, &brow_widget, 
			    &sts);
  // xcrrnav->popup_menu_cb = &xcrr_popup_menu_cb;
  // xcrrnav->start_trace_cb = &xcrr_start_trace_cb;
  // xcrrnav->close_cb = &xcrr_close_cb;

  gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(menu_bar), FALSE, FALSE, 0);
  gtk_box_pack_end( GTK_BOX(vbox), GTK_WIDGET(brow_widget), TRUE, TRUE, 0);
  
  gtk_container_add( GTK_CONTAINER(toplevel), vbox);
  gtk_widget_show_all( toplevel);

  *xa_sts = XATT__SUCCESS;
}
コード例 #25
0
ファイル: glade-popup.c プロジェクト: metaltrrocker/glade
/*
 * glade_popup_action_populate_menu:
 * @menu: a GtkMenu to put the actions menu items.
 * @widget: A #GladeWidget
 * @action: a @widget subaction or NULL to include all actions.
 * @packing: TRUE to include packing actions
 *
 * Populate a GtkMenu with widget's actions
 *
 * Returns the number of action appended to the menu.
 */
gint
glade_popup_action_populate_menu (GtkWidget         *menu,
                                  GladeWidget       *widget,
                                  GladeWidgetAction *action,
                                  gboolean           packing)
{
  gint n;

  g_return_val_if_fail (GTK_IS_MENU (menu), 0);
  g_return_val_if_fail (GLADE_IS_WIDGET (widget), 0);

  g_return_val_if_fail (action == NULL || GLADE_IS_WIDGET_ACTION (action), 0);

  if (action)
    {
      GWActionClass *aclass = glade_widget_action_get_class (action);
      GList         *children = glade_widget_action_get_children (action);
      
      if (glade_widget_get_action (widget, aclass->path) &&
	  glade_widget_action_get_visible (action))
        return glade_popup_action_populate_menu_real (menu,
                                                      widget,
                                                      children,
                                                      G_CALLBACK
                                                      (glade_popup_menuitem_activated),
                                                      widget);

      if (glade_widget_get_pack_action (widget, aclass->path) &&
	  glade_widget_action_get_visible (action))
        return glade_popup_action_populate_menu_real (menu,
                                                      glade_widget_get_parent
                                                      (widget), children,
                                                      G_CALLBACK
                                                      (glade_popup_menuitem_packing_activated),
                                                      widget);

      return 0;
    }

  n = glade_popup_action_populate_menu_real (menu,
                                             widget,
                                             glade_widget_get_actions (widget),
                                             G_CALLBACK
                                             (glade_popup_menuitem_activated),
                                             widget);

  if (packing && glade_widget_get_pack_actions (widget))
    {
      if (n)
        {
          GtkWidget *separator = gtk_separator_menu_item_new ();
          gtk_menu_shell_append (GTK_MENU_SHELL (menu), separator);
          gtk_widget_show (separator);
        }

      n += glade_popup_action_populate_menu_real 
	(menu, glade_widget_get_parent (widget),
	 glade_widget_get_pack_actions (widget),
	 G_CALLBACK (glade_popup_menuitem_packing_activated), widget);
    }

  return n;
}
コード例 #26
0
ファイル: gtkui.cpp プロジェクト: cbeach/nestopia
void gtkui_create() {
	// Create the GTK+ Window
	
	gtkui_image_paths();
	GdkPixbuf *icon = gdk_pixbuf_new_from_file(iconpath, NULL);
	
	char title[24];
	snprintf(title, sizeof(title), "Nestopia UE %s", VERSION);
	
	gtkwindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_icon(GTK_WINDOW(gtkwindow), icon);
	gtk_window_set_title(GTK_WINDOW(gtkwindow), title);
	gtk_window_set_resizable(GTK_WINDOW(gtkwindow), FALSE);
	
	GtkWidget *box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
	gtk_container_add(GTK_CONTAINER(gtkwindow), box);
	
	// Define the menubar and menus
	GtkWidget *menubar = gtk_menu_bar_new();
	
	// Define the File menu
	GtkWidget *filemenu = gtk_menu_new();
	GtkWidget *file = gtk_menu_item_new_with_mnemonic("_File");
	GtkWidget *open = gtk_image_menu_item_new_from_stock(GTK_STOCK_OPEN, NULL);
	GtkWidget *recent = gtk_image_menu_item_new_with_label("Open Recent");
		gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(recent), gtk_image_new_from_stock(GTK_STOCK_OPEN, GTK_ICON_SIZE_MENU));
	GtkWidget *sep_open = gtk_separator_menu_item_new();
	GtkWidget *stateload = gtk_image_menu_item_new_with_mnemonic("_Load State...");
		gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(stateload), gtk_image_new_from_stock(GTK_STOCK_GO_BACK, GTK_ICON_SIZE_MENU));
	GtkWidget *statesave = gtk_image_menu_item_new_with_mnemonic("_Save State...");
		gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(statesave), gtk_image_new_from_stock(GTK_STOCK_SAVE, GTK_ICON_SIZE_MENU));
	
	GtkWidget *quickload = gtk_image_menu_item_new_with_label("Quick Load");
	GtkWidget *qloadmenu = gtk_menu_new();
		GtkWidget *qload0 = gtk_image_menu_item_new_with_label("0");
		GtkWidget *qload1 = gtk_image_menu_item_new_with_label("1");
		GtkWidget *qload2 = gtk_image_menu_item_new_with_label("2");
		GtkWidget *qload3 = gtk_image_menu_item_new_with_label("3");
		GtkWidget *qload4 = gtk_image_menu_item_new_with_label("4");
	
	GtkWidget *quicksave = gtk_image_menu_item_new_with_label("Quick Save");
	GtkWidget *qsavemenu = gtk_menu_new();
		GtkWidget *qsave0 = gtk_image_menu_item_new_with_label("0");
		GtkWidget *qsave1 = gtk_image_menu_item_new_with_label("1");
		GtkWidget *qsave2 = gtk_image_menu_item_new_with_label("2");
		GtkWidget *qsave3 = gtk_image_menu_item_new_with_label("3");
		GtkWidget *qsave4 = gtk_image_menu_item_new_with_label("4");
	
	GtkWidget *sep_state = gtk_separator_menu_item_new();
	GtkWidget *screenshot = gtk_image_menu_item_new_with_mnemonic("S_creenshot...");
		gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(screenshot), gtk_image_new_from_stock(GTK_STOCK_SELECT_COLOR, GTK_ICON_SIZE_MENU));
	GtkWidget *sep_screenshot = gtk_separator_menu_item_new();
	GtkWidget *movieload = gtk_image_menu_item_new_with_label("Load Movie...");
		gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(movieload), gtk_image_new_from_stock(GTK_STOCK_OPEN, GTK_ICON_SIZE_MENU));
	GtkWidget *moviesave = gtk_image_menu_item_new_with_label("Record Movie...");
		gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(moviesave), gtk_image_new_from_stock(GTK_STOCK_MEDIA_RECORD, GTK_ICON_SIZE_MENU));
	GtkWidget *moviestop = gtk_image_menu_item_new_with_label("Stop Movie");
		gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(moviestop), gtk_image_new_from_stock(GTK_STOCK_MEDIA_STOP, GTK_ICON_SIZE_MENU));
	GtkWidget *sep_movie = gtk_separator_menu_item_new();
	GtkWidget *quit = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, NULL);
	
	// Set up the recently used items
	GtkWidget *recent_items = gtk_recent_chooser_menu_new();
	GtkRecentFilter *recent_filter = gtk_recent_filter_new();
		gtk_recent_filter_add_pattern(recent_filter, "*.nes");
		gtk_recent_filter_add_pattern(recent_filter, "*.fds");
		gtk_recent_filter_add_pattern(recent_filter, "*.unf");
		gtk_recent_filter_add_pattern(recent_filter, "*.unif");
		gtk_recent_filter_add_pattern(recent_filter, "*.nsf");
		gtk_recent_filter_add_pattern(recent_filter, "*.zip");
		gtk_recent_filter_add_pattern(recent_filter, "*.7z");
		gtk_recent_filter_add_pattern(recent_filter, "*.txz");
		gtk_recent_filter_add_pattern(recent_filter, "*.tar.xz");
		gtk_recent_filter_add_pattern(recent_filter, "*.xz");
		gtk_recent_filter_add_pattern(recent_filter, "*.tgz");
		gtk_recent_filter_add_pattern(recent_filter, "*.tar.gz");
		gtk_recent_filter_add_pattern(recent_filter, "*.gz");
		gtk_recent_filter_add_pattern(recent_filter, "*.tbz");
		gtk_recent_filter_add_pattern(recent_filter, "*.tar.bz2");
		gtk_recent_filter_add_pattern(recent_filter, "*.bz2");
	gtk_recent_chooser_add_filter(GTK_RECENT_CHOOSER(recent_items), recent_filter);
	
	// Populate the File menu
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), filemenu);
	gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), open);
	gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), recent);
		gtk_menu_item_set_submenu(GTK_MENU_ITEM(recent), recent_items);
	gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), sep_open);
	gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), stateload);
	gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), statesave);
	gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), quickload);
		gtk_menu_item_set_submenu(GTK_MENU_ITEM(quickload), qloadmenu);
		gtk_menu_shell_append(GTK_MENU_SHELL(qloadmenu), qload0);
		gtk_menu_shell_append(GTK_MENU_SHELL(qloadmenu), qload1);
		gtk_menu_shell_append(GTK_MENU_SHELL(qloadmenu), qload2);
		gtk_menu_shell_append(GTK_MENU_SHELL(qloadmenu), qload3);
		gtk_menu_shell_append(GTK_MENU_SHELL(qloadmenu), qload4);
	gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), quicksave);
		gtk_menu_item_set_submenu(GTK_MENU_ITEM(quicksave), qsavemenu);
		gtk_menu_shell_append(GTK_MENU_SHELL(qsavemenu), qsave0);
		gtk_menu_shell_append(GTK_MENU_SHELL(qsavemenu), qsave1);
		gtk_menu_shell_append(GTK_MENU_SHELL(qsavemenu), qsave2);
		gtk_menu_shell_append(GTK_MENU_SHELL(qsavemenu), qsave3);
		gtk_menu_shell_append(GTK_MENU_SHELL(qsavemenu), qsave4);
	gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), sep_state);
	gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), screenshot);
	gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), sep_screenshot);
	gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), movieload);
	gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), moviesave);
	gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), moviestop);
	gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), sep_movie);
	gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), quit);
	
	// Define the Emulator menu
	GtkWidget *emulatormenu = gtk_menu_new();
	GtkWidget *emu = gtk_menu_item_new_with_mnemonic("_Emulator");
	GtkWidget *cont = gtk_image_menu_item_new_with_mnemonic("C_ontinue");
		gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(cont), gtk_image_new_from_stock(GTK_STOCK_MEDIA_PLAY, GTK_ICON_SIZE_MENU));
	GtkWidget *pause = gtk_image_menu_item_new_from_stock(GTK_STOCK_MEDIA_PAUSE, NULL);
	GtkWidget *sep_pause = gtk_separator_menu_item_new();
	GtkWidget *resetsoft = gtk_image_menu_item_new_with_mnemonic("_Reset (Soft)");
		gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(resetsoft), gtk_image_new_from_stock(GTK_STOCK_REFRESH, GTK_ICON_SIZE_MENU));
	GtkWidget *resethard = gtk_image_menu_item_new_with_mnemonic("Reset (_Hard)");
		gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(resethard), gtk_image_new_from_stock(GTK_STOCK_REFRESH, GTK_ICON_SIZE_MENU));
	GtkWidget *sep_reset = gtk_separator_menu_item_new();
	GtkWidget *fullscreen = gtk_image_menu_item_new_from_stock(GTK_STOCK_FULLSCREEN, NULL);
	GtkWidget *sep_fullscreen = gtk_separator_menu_item_new();
	GtkWidget *diskflip = gtk_image_menu_item_new_with_mnemonic("Flip FDS _Disk");
		gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(diskflip), gtk_image_new_from_stock(GTK_STOCK_FLOPPY, GTK_ICON_SIZE_MENU));
	GtkWidget *diskswitch = gtk_image_menu_item_new_with_mnemonic("_Switch FDS Disk");
		gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(diskswitch), gtk_image_new_from_stock(GTK_STOCK_FLOPPY, GTK_ICON_SIZE_MENU));
	GtkWidget *sep_disk = gtk_separator_menu_item_new();
	GtkWidget *cheats = gtk_image_menu_item_new_with_mnemonic("Ch_eats...");
		gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(cheats), gtk_image_new_from_stock(GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_MENU));
	GtkWidget *sep_cheats = gtk_separator_menu_item_new();
	GtkWidget *configuration = gtk_image_menu_item_new_with_mnemonic("_Configuration...");
		gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(configuration), gtk_image_new_from_stock(GTK_STOCK_PREFERENCES, GTK_ICON_SIZE_MENU));
	
	// Populate the Emulator menu
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(emu), emulatormenu);
	gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), cont);
	gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), pause);
	gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), sep_pause);
	gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), resetsoft);
	gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), resethard);
	gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), sep_reset);
	gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), fullscreen);
	gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), sep_fullscreen);
	gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), diskflip);
	gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), diskswitch);
	gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), sep_disk);
	gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), cheats);
	gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), sep_cheats);
	gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), configuration);
	
	// Define the Help menu
	GtkWidget *helpmenu = gtk_menu_new();
	GtkWidget *help = gtk_menu_item_new_with_mnemonic("_Help");
	GtkWidget *about = gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT, NULL);
	
	// Populate the Help menu
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), helpmenu);
	gtk_menu_shell_append(GTK_MENU_SHELL(helpmenu), about);
	
	// Put the menus into the menubar
	gtk_menu_shell_append(GTK_MENU_SHELL(menubar), file);
	gtk_menu_shell_append(GTK_MENU_SHELL(menubar), emu);
	gtk_menu_shell_append(GTK_MENU_SHELL(menubar), help);
	
	// Create the DrawingArea/OpenGL context
	drawingarea = gtk_drawing_area_new();
	//gtk_widget_set_double_buffered(drawingarea, FALSE);
	
	g_object_set_data(G_OBJECT(gtkwindow), "area", drawingarea);
	
	// Set the Drawing Area to be the size of the game output
	gtk_widget_set_size_request(drawingarea, rendersize.w, rendersize.h);
	
	// Create the statusbar
	GtkWidget *statusbar = gtk_statusbar_new();
	
	// Pack the box with the menubar, drawingarea, and statusbar
	gtk_box_pack_start(GTK_BOX(box), menubar, FALSE, FALSE, 0);
	gtk_box_pack_start(GTK_BOX(box), drawingarea, TRUE, TRUE, 0);
	//gtk_box_pack_start(GTK_BOX(box), statusbar, FALSE, FALSE, 0);
	
	// Make it dark if there's a dark theme
	GtkSettings *gtksettings = gtk_settings_get_default();
	g_object_set(G_OBJECT(gtksettings), "gtk-application-prefer-dark-theme", TRUE, NULL);
	
	// Set up the Drag and Drop target
	GtkTargetEntry target_entry[1];

	target_entry[0].target = (gchar*)"text/uri-list";
	target_entry[0].flags = 0;
	target_entry[0].info = 0;
	
	gtk_drag_dest_set(drawingarea, (GtkDestDefaults)(GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP), 
		target_entry, sizeof(target_entry) / sizeof(GtkTargetEntry), (GdkDragAction)(GDK_ACTION_MOVE | GDK_ACTION_COPY));
	
	// Connect the signals
	
	g_signal_connect(G_OBJECT(drawingarea), "drag-data-received",
		G_CALLBACK(gtkui_drag_data), NULL);
	
	g_signal_connect(G_OBJECT(gtkwindow), "delete_event",
		G_CALLBACK(nst_schedule_quit), NULL);
	
	// File menu
	g_signal_connect(G_OBJECT(open), "activate",
		G_CALLBACK(gtkui_file_open), NULL);
	
	g_signal_connect(G_OBJECT(recent_items), "item-activated",
		G_CALLBACK(gtkui_open_recent), NULL);
	
	g_signal_connect(G_OBJECT(stateload), "activate",
		G_CALLBACK(gtkui_state_load), NULL);
	
	g_signal_connect(G_OBJECT(statesave), "activate",
		G_CALLBACK(gtkui_state_save), NULL);
	
	g_signal_connect(G_OBJECT(qload0), "activate",
		G_CALLBACK(gtkui_state_quickload), gpointer(0));
	
	g_signal_connect(G_OBJECT(qload1), "activate",
		G_CALLBACK(gtkui_state_quickload), gpointer(1));
	
	g_signal_connect(G_OBJECT(qload2), "activate",
		G_CALLBACK(gtkui_state_quickload), gpointer(2));
	
	g_signal_connect(G_OBJECT(qload3), "activate",
		G_CALLBACK(gtkui_state_quickload), gpointer(3));
	
	g_signal_connect(G_OBJECT(qload4), "activate",
		G_CALLBACK(gtkui_state_quickload), gpointer(4));
	
	g_signal_connect(G_OBJECT(qsave0), "activate",
		G_CALLBACK(gtkui_state_quicksave), gpointer(0));
	
	g_signal_connect(G_OBJECT(qsave1), "activate",
		G_CALLBACK(gtkui_state_quicksave), gpointer(1));
	
	g_signal_connect(G_OBJECT(qsave2), "activate",
		G_CALLBACK(gtkui_state_quicksave), gpointer(2));
	
	g_signal_connect(G_OBJECT(qsave3), "activate",
		G_CALLBACK(gtkui_state_quicksave), gpointer(3));
	
	g_signal_connect(G_OBJECT(qsave4), "activate",
		G_CALLBACK(gtkui_state_quicksave), gpointer(4));
	
	g_signal_connect(G_OBJECT(statesave), "activate",
		G_CALLBACK(gtkui_state_save), NULL);
	
	g_signal_connect(G_OBJECT(screenshot), "activate",
		G_CALLBACK(gtkui_screenshot_save), NULL);
	
	g_signal_connect(G_OBJECT(moviesave), "activate",
		G_CALLBACK(gtkui_movie_save), NULL);
	
	g_signal_connect(G_OBJECT(movieload), "activate",
		G_CALLBACK(gtkui_movie_load), NULL);
	
	g_signal_connect(G_OBJECT(moviestop), "activate",
		G_CALLBACK(gtkui_movie_stop), NULL);
	
	g_signal_connect(G_OBJECT(quit), "activate",
		G_CALLBACK(nst_schedule_quit), NULL);
	
	// Emulator menu
	g_signal_connect(G_OBJECT(cont), "activate",
		G_CALLBACK(nst_play), NULL);
	
	g_signal_connect(G_OBJECT(pause), "activate",
		G_CALLBACK(nst_pause), NULL);
	
	g_signal_connect(G_OBJECT(resetsoft), "activate",
		G_CALLBACK(gtkui_cb_reset), gpointer(0));
	
	g_signal_connect(G_OBJECT(resethard), "activate",
		G_CALLBACK(gtkui_cb_reset), gpointer(1));
	
	g_signal_connect(G_OBJECT(fullscreen), "activate",
		G_CALLBACK(video_toggle_fullscreen), NULL);
	
	g_signal_connect(G_OBJECT(diskflip), "activate",
		G_CALLBACK(nst_flip_disk), NULL);
	
	g_signal_connect(G_OBJECT(diskswitch), "activate",
		G_CALLBACK(nst_switch_disk), NULL);
	
	g_signal_connect(G_OBJECT(cheats), "activate",
		G_CALLBACK(gtkui_cheats), NULL);
	
	g_signal_connect(G_OBJECT(configuration), "activate",
		G_CALLBACK(gtkui_config), NULL);
	
	// Help menu
	g_signal_connect(G_OBJECT(about), "activate",
		G_CALLBACK(gtkui_about), NULL);
	
	// Key translation
	g_signal_connect(G_OBJECT(gtkwindow), "key-press-event",
		G_CALLBACK(gtkui_cb_convert_key), NULL);
	
	g_signal_connect(G_OBJECT(gtkwindow), "key-release-event",
		G_CALLBACK(gtkui_cb_convert_key), NULL);
	
	// Mouse translation
	gtk_widget_add_events(GTK_WIDGET(drawingarea), GDK_BUTTON_PRESS_MASK);
	gtk_widget_add_events(GTK_WIDGET(drawingarea), GDK_BUTTON_RELEASE_MASK);
	
	g_signal_connect(G_OBJECT(drawingarea), "button-press-event",
		G_CALLBACK(gtkui_cb_convert_mouse), NULL);
	
	g_signal_connect(G_OBJECT(drawingarea), "button-release-event",
		G_CALLBACK(gtkui_cb_convert_mouse), NULL);
	
	gtk_widget_show_all(gtkwindow);
}
コード例 #27
0
ファイル: menu_handlers.c プロジェクト: BMWPower/MegaTunix
void menu_setup(GtkBuilder *toplevel)
{
	GtkWidget *bar = NULL;
	GtkWidget *vbox = NULL;
	GtkWidget *menubar = NULL;
	GtkWidget *menu = NULL;
	GtkWidget *item = NULL;
	GtkWidget *image = NULL;

	vbox = GTK_WIDGET (gtk_builder_get_object(toplevel,"menu_vbox"));
	menubar = gtk_menu_bar_new();
	gtk_box_pack_end(GTK_BOX(vbox),menubar,FALSE,FALSE,0);
	item = gtk_menu_item_new_with_label("File");
	menu = gtk_menu_new();
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),menu);
	gtk_menu_shell_append(GTK_MENU_SHELL(menubar),item);

	/* File Menu */
	item = gtk_image_menu_item_new_with_mnemonic("_New Gauge");
	OBJ_SET(toplevel,"new_gauge_menuitem",item);
	image = gtk_image_new_from_stock("gtk-new",GTK_ICON_SIZE_MENU);
	g_object_set(item,"image",image,NULL);
	if (gtk_minor_version >= 16)
		g_object_set(item,"always-show-image",TRUE,NULL);
	g_signal_connect(G_OBJECT(item),"activate",G_CALLBACK(create_new_gauge),NULL);
	gtk_menu_shell_append(GTK_MENU_SHELL(menu),item);

	item = gtk_image_menu_item_new_with_mnemonic("_Load Gauge");
	OBJ_SET(toplevel,"load_gauge_menuitem",item);
	image = gtk_image_new_from_stock("gtk-open",GTK_ICON_SIZE_MENU);
	g_object_set(item,"image",image,NULL);
	if (gtk_minor_version >= 16)
		g_object_set(item,"always-show-image",TRUE,NULL);
	g_signal_connect(G_OBJECT(item),"activate",G_CALLBACK(load_handler),NULL);
	gtk_menu_shell_append(GTK_MENU_SHELL(menu),item);

	item = gtk_image_menu_item_new_with_mnemonic("_Close");
	OBJ_SET(toplevel,"close_gauge_menuitem",item);
	image = gtk_image_new_from_stock("gtk-close",GTK_ICON_SIZE_MENU);
	g_object_set(item,"image",image,NULL);
	if (gtk_minor_version >= 16)
		g_object_set(item,"always-show-image",TRUE,NULL);
	g_signal_connect(G_OBJECT(item),"activate",G_CALLBACK(close_current_gauge),NULL);
	gtk_menu_shell_append(GTK_MENU_SHELL(menu),item);

	item = gtk_image_menu_item_new_with_mnemonic("S_ave Gauge");
	OBJ_SET(toplevel,"save_gauge_menuitem",item);
	image = gtk_image_new_from_stock("gtk-save",GTK_ICON_SIZE_MENU);
	g_object_set(item,"image",image,NULL);
	if (gtk_minor_version >= 16)
		g_object_set(item,"always-show-image",TRUE,NULL);
	g_signal_connect(G_OBJECT(item),"activate",G_CALLBACK(save_handler),NULL);
	gtk_menu_shell_append(GTK_MENU_SHELL(menu),item);

	item = gtk_image_menu_item_new_with_mnemonic("S_ave Gauge As");
	OBJ_SET(toplevel,"save_as_menuitem",item);
	image = gtk_image_new_from_stock("gtk-save-as",GTK_ICON_SIZE_MENU);
	g_object_set(item,"image",image,NULL);
	if (gtk_minor_version >= 16)
		g_object_set(item,"always-show-image",TRUE,NULL);
	g_signal_connect(G_OBJECT(item),"activate",G_CALLBACK(save_as_handler),NULL);
	gtk_menu_shell_append(GTK_MENU_SHELL(menu),item);

	item = gtk_image_menu_item_new_with_mnemonic("_Quit");
	image = gtk_image_new_from_stock("gtk-quit",GTK_ICON_SIZE_MENU);
	g_object_set(item,"image",image,NULL);
	if (gtk_minor_version >= 16)
		g_object_set(item,"always-show-image",TRUE,NULL);
	g_signal_connect(G_OBJECT(item),"activate",G_CALLBACK(quit_gaugedesigner),NULL);
	gtk_menu_shell_append(GTK_MENU_SHELL(menu),item);
	gtk_widget_show_all(menu);

	/* Edit Menu */
	item = gtk_menu_item_new_with_label("Edit");
	menu = gtk_menu_new();
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),menu);
	gtk_menu_shell_append(GTK_MENU_SHELL(menubar),item);

	item = gtk_image_menu_item_new_with_mnemonic("_General Attributes");
	image = gtk_image_new_from_stock("gtk-select-color",GTK_ICON_SIZE_MENU);
	g_object_set(item,"image",image,NULL);
	if (gtk_minor_version >= 16)
		g_object_set(item,"always-show-image",TRUE,NULL);
	g_signal_connect(G_OBJECT(item),"activate",G_CALLBACK(general_attributes_menu_handler),NULL);
	gtk_menu_shell_append(GTK_MENU_SHELL(menu),item);

	item = gtk_image_menu_item_new_with_mnemonic("Gauge Te_xt");
	image = gtk_image_new_from_stock("gtk-italic",GTK_ICON_SIZE_MENU);
	g_object_set(item,"image",image,NULL);
	if (gtk_minor_version >= 16)
		g_object_set(item,"always-show-image",TRUE,NULL);
	g_signal_connect(G_OBJECT(item),"activate",G_CALLBACK(text_attributes_menu_handler),NULL);
	gtk_menu_shell_append(GTK_MENU_SHELL(menu),item);

	item = gtk_image_menu_item_new_with_mnemonic("Gauge _Tickmarks");
	image = gtk_image_new_from_stock("gtk-preferences",GTK_ICON_SIZE_MENU);
	g_object_set(item,"image",image,NULL);
	if (gtk_minor_version >= 16)
		g_object_set(item,"always-show-image",TRUE,NULL);
	g_signal_connect(G_OBJECT(item),"activate",G_CALLBACK(tick_groups_menu_handler),NULL);
	gtk_menu_shell_append(GTK_MENU_SHELL(menu),item);

	item = gtk_image_menu_item_new_with_mnemonic("Gauge _Warning Thresholds");
	image = gtk_image_new_from_stock("gtk-properties",GTK_ICON_SIZE_MENU);
	g_object_set(item,"image",image,NULL);
	if (gtk_minor_version >= 16)
		g_object_set(item,"always-show-image",TRUE,NULL);
	g_signal_connect(G_OBJECT(item),"activate",G_CALLBACK(warning_ranges_menu_handler),NULL);
	gtk_menu_shell_append(GTK_MENU_SHELL(menu),item);

	item = gtk_image_menu_item_new_with_mnemonic("Gauge _Alert Thresholds");
	image = gtk_image_new_from_stock("gtk-dialog-warning",GTK_ICON_SIZE_MENU);
	g_object_set(item,"image",image,NULL);
	if (gtk_minor_version >= 16)
		g_object_set(item,"always-show-image",TRUE,NULL);
	g_signal_connect(G_OBJECT(item),"activate",G_CALLBACK(alert_ranges_menu_handler),NULL);
	gtk_menu_shell_append(GTK_MENU_SHELL(menu),item);

	item = gtk_image_menu_item_new_with_mnemonic("Gauge _Advanced Graphics");
	image = gtk_image_new_from_stock("gtk-zoom-in",GTK_ICON_SIZE_MENU);
	g_object_set(item,"image",image,NULL);
	if (gtk_minor_version >= 16)
		g_object_set(item,"always-show-image",TRUE,NULL);
	g_signal_connect(G_OBJECT(item),"activate",G_CALLBACK(polygon_menu_handler),NULL);
	gtk_menu_shell_append(GTK_MENU_SHELL(menu),item);
	gtk_widget_show_all(menu);

	/* Help Menu */
	item = gtk_menu_item_new_with_label("Help");
	menu = gtk_menu_new();
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),menu);
	gtk_menu_shell_append(GTK_MENU_SHELL(menubar),item);

	item = gtk_image_menu_item_new_with_mnemonic("_About GaugeDesigner");
	image = gtk_image_new_from_stock("gtk-about",GTK_ICON_SIZE_MENU);
	g_object_set(item,"image",image,NULL);
	if (gtk_minor_version >= 16)
		g_object_set(item,"always-show-image",TRUE,NULL);
	g_signal_connect(G_OBJECT(item),"activate",G_CALLBACK(about_menu_handler),NULL);
	gtk_menu_shell_append(GTK_MENU_SHELL(menu),item);

	return;
}
コード例 #28
0
ファイル: plugin.c プロジェクト: easonoutlook/code-format
void plugin_init(G_GNUC_UNUSED GeanyData *data)
{
  GeanyKeyGroup *group;
  GtkWidget *menu, *item;

  fmt_prefs_init();

#define CONNECT(sig, cb) \
  plugin_signal_connect(geany_plugin, NULL, sig, TRUE, G_CALLBACK(cb), NULL)

  CONNECT("editor-notify", on_editor_notify);
  CONNECT("project-dialog-open", on_project_dialog_open);
  CONNECT("project-dialog-close", on_project_dialog_close);
  CONNECT("project-dialog-confirmed", on_project_dialog_confirmed);
  CONNECT("project-open", on_project_open);
  CONNECT("project-close", on_project_close);
  CONNECT("project-save", on_project_save);
  CONNECT("document-before-save", on_document_before_save);

#undef CONNECT

  group = plugin_set_key_group(geany_plugin, _("Code Formatting"), 3,
                               (GeanyKeyGroupCallback)on_key_binding);

  main_menu_item = gtk_menu_item_new_with_label(_("Code Format"));
  ui_add_document_sensitive(main_menu_item);
  g_signal_connect(main_menu_item, "map", G_CALLBACK(on_tools_item_map), NULL);
  menu = gtk_menu_new();
  gtk_menu_item_set_submenu(GTK_MENU_ITEM(main_menu_item), menu);

  item = gtk_check_menu_item_new_with_label(_("Auto-Formatting"));
  gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
  g_signal_connect(item, "toggled", G_CALLBACK(on_auto_format_item_toggled),
                   NULL);
  g_signal_connect(item, "map", G_CALLBACK(on_auto_format_item_map), NULL);

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

  item = gtk_menu_item_new_with_label(_("Current Line or Selection"));
  g_signal_connect(item, "activate", G_CALLBACK(on_menu_item_activate),
                   GINT_TO_POINTER(FORMAT_KEY_REGION));
  gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
  keybindings_set_item(group, FORMAT_KEY_REGION, NULL, 0, 0, "format_region",
                       _("Format current line or selection"), item);

  item = gtk_menu_item_new_with_label(_("Entire Document"));
  g_signal_connect(item, "activate", G_CALLBACK(on_menu_item_activate),
                   GINT_TO_POINTER(FORMAT_KEY_DOCUMENT));
  gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
  keybindings_set_item(group, FORMAT_KEY_DOCUMENT, NULL, 0, 0,
                       "format_document", _("Format entire document"), item);

  item = gtk_menu_item_new_with_label(_("Entire Session"));
  g_signal_connect(item, "activate", G_CALLBACK(on_menu_item_activate),
                   GINT_TO_POINTER(FORMAT_KEY_SESSION));
  gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
  keybindings_set_item(group, FORMAT_KEY_SESSION, NULL, 0, 0, "format_session",
                       _("Format entire session"), item);

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

  item = gtk_menu_item_new_with_label(_("Open Configuration File"));
  gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
  g_signal_connect(item, "activate", G_CALLBACK(on_open_config_file), NULL);
  g_signal_connect(item, "map", G_CALLBACK(on_open_config_item_map), NULL);

  gtk_widget_show_all(main_menu_item);

  gtk_menu_shell_append(GTK_MENU_SHELL(geany_data->main_widgets->tools_menu),
                        main_menu_item);
}
コード例 #29
0
static void
notebook_popup_menu_show (CajaNavigationWindowPane *pane,
                          GdkEventButton *event)
{
    GtkWidget *popup;
    GtkWidget *item;
    GtkWidget *image;
    int button, event_time;
    gboolean can_move_left, can_move_right;
    CajaNotebook *notebook;

    notebook = CAJA_NOTEBOOK (pane->notebook);

    can_move_left = caja_notebook_can_reorder_current_child_relative (notebook, -1);
    can_move_right = caja_notebook_can_reorder_current_child_relative (notebook, 1);

    popup = gtk_menu_new();

    item = gtk_menu_item_new_with_mnemonic (_("_New Tab"));
    g_signal_connect (item, "activate",
    		  G_CALLBACK (notebook_popup_menu_new_tab_cb),
    		  pane);
    gtk_menu_shell_append (GTK_MENU_SHELL (popup),
    		       item);

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

    item = gtk_menu_item_new_with_mnemonic (_("Move Tab _Left"));
    g_signal_connect (item, "activate",
                      G_CALLBACK (notebook_popup_menu_move_left_cb),
                      pane);
    gtk_menu_shell_append (GTK_MENU_SHELL (popup),
                           item);
    gtk_widget_set_sensitive (item, can_move_left);

    item = gtk_menu_item_new_with_mnemonic (_("Move Tab _Right"));
    g_signal_connect (item, "activate",
                      G_CALLBACK (notebook_popup_menu_move_right_cb),
                      pane);
    gtk_menu_shell_append (GTK_MENU_SHELL (popup),
                           item);
    gtk_widget_set_sensitive (item, can_move_right);

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

    item = gtk_image_menu_item_new_with_mnemonic (_("_Close Tab"));
    image = gtk_image_new_from_stock (GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU);
    gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
    g_signal_connect (item, "activate",
                      G_CALLBACK (notebook_popup_menu_close_cb), pane);
    gtk_menu_shell_append (GTK_MENU_SHELL (popup),
                           item);

    gtk_widget_show_all (popup);

    if (event)
    {
        button = event->button;
        event_time = event->time;
    }
    else
    {
        button = 0;
        event_time = gtk_get_current_event_time ();
    }

    /* TODO is this correct? */
    gtk_menu_attach_to_widget (GTK_MENU (popup),
                               pane->notebook,
                               NULL);

    gtk_menu_popup (GTK_MENU (popup), NULL, NULL, NULL, NULL,
                    button, event_time);
}
コード例 #30
0
ファイル: test-display.c プロジェクト: kinglulu/librsvg
static void
create_popup_menu (ViewerCbInfo * info)
{
    GtkWidget *popup_menu;
    GtkWidget *menu_item;
    GtkWidget *stock;

    popup_menu = gtk_menu_new ();
    gtk_menu_set_accel_group (GTK_MENU (popup_menu), info->accel_group);

    if (info->base_uri) {
        menu_item = gtk_image_menu_item_new_with_label (_("Copy SVG location"));
        stock = gtk_image_new_from_stock (GTK_STOCK_COPY, GTK_ICON_SIZE_MENU);
        gtk_widget_show (stock);
        gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item), stock);
        g_signal_connect (menu_item, "activate", G_CALLBACK (copy_svg_location), info);
        gtk_widget_show (menu_item);
        gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), menu_item);
        gtk_widget_add_accelerator (menu_item, "activate", info->accel_group, GDK_C,
                                    GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
    }

    menu_item = gtk_image_menu_item_new_from_stock (GTK_STOCK_SAVE, NULL);
    g_signal_connect (menu_item, "activate", G_CALLBACK (save_svg), info);
    gtk_widget_show (menu_item);
    gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), menu_item);
    gtk_widget_add_accelerator (menu_item, "activate", info->accel_group, GDK_S, GDK_CONTROL_MASK,
                                GTK_ACCEL_VISIBLE);

    menu_item = gtk_image_menu_item_new_with_label (_("Save as PNG"));
    stock = gtk_image_new_from_stock (GTK_STOCK_SAVE_AS, GTK_ICON_SIZE_MENU);
    gtk_widget_show (stock);
    gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item), stock);
    g_signal_connect (menu_item, "activate", G_CALLBACK (save_pixbuf), info);
    gtk_widget_show (menu_item);
    gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), menu_item);
    gtk_widget_add_accelerator (menu_item, "activate", info->accel_group, GDK_S,
                                GDK_CONTROL_MASK | GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE);

#if GTK_CHECK_VERSION(2,10,0)
    menu_item = gtk_image_menu_item_new_from_stock (GTK_STOCK_PRINT, NULL);
    g_signal_connect (menu_item, "activate", G_CALLBACK (print_pixbuf), info);
    gtk_widget_show (menu_item);
    gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), menu_item);
    gtk_widget_add_accelerator (menu_item, "activate", info->accel_group, GDK_P, GDK_CONTROL_MASK,
                                GTK_ACCEL_VISIBLE);
#endif

    menu_item = gtk_image_menu_item_new_from_stock (GTK_STOCK_ZOOM_IN, NULL);
    g_signal_connect (menu_item, "activate", G_CALLBACK (zoom_in), info);
    gtk_widget_show (menu_item);
    gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), menu_item);
    gtk_widget_add_accelerator (menu_item, "activate", info->accel_group, GDK_plus,
                                GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);

    menu_item = gtk_image_menu_item_new_from_stock (GTK_STOCK_ZOOM_OUT, NULL);
    g_signal_connect (menu_item, "activate", G_CALLBACK (zoom_out), info);
    gtk_widget_show (menu_item);
    gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), menu_item);
    gtk_widget_add_accelerator (menu_item, "activate", info->accel_group, GDK_minus,
                                GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);

    info->popup_menu = popup_menu;
}