static GtkWidget* create_menu()
{
GtkWidget* menu;
menu = gtk_menu_new();
menu_item_state = gtk_menu_item_new_with_label("State: ");
gtk_widget_set_sensitive(menu_item_state, FALSE);
GtkWidget* delay3 = gtk_menu_item_new_with_label("delay 3 min");
GtkWidget* delay5 = gtk_menu_item_new_with_label("delay 5 min");
GtkWidget* pause = gtk_menu_item_new_with_label("pause");
GtkWidget* unpause = gtk_menu_item_new_with_label("continue");
GtkWidget* rest_now = gtk_menu_item_new_with_label("rest now");
GtkWidget* quit = gtk_menu_item_new_with_label("quit");
GtkWidget* sep1 = gtk_separator_menu_item_new();
GtkWidget* sep2 = gtk_separator_menu_item_new();
GtkWidget* sep3 = gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item_state);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), sep1);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), delay3);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), delay5);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), sep2);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), pause);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), unpause);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), rest_now);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), sep3);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), quit);
g_signal_connect (G_OBJECT(delay3), "activate",
G_CALLBACK(on_delay), GUINT_TO_POINTER(180));
g_signal_connect (G_OBJECT(delay5), "activate",
G_CALLBACK(on_delay), GUINT_TO_POINTER(300));
g_signal_connect (G_OBJECT(pause), "activate",
G_CALLBACK(on_pause), NULL);
g_signal_connect (G_OBJECT(unpause), "activate",
G_CALLBACK(on_unpause), NULL);
g_signal_connect (G_OBJECT(rest_now), "activate",
G_CALLBACK(on_rest_now), NULL);
g_signal_connect (G_OBJECT(quit), "activate",
G_CALLBACK(on_quit), NULL);
gtk_widget_show_all(menu);
return menu;
}
/*
* CreateBarSubMenu
*
* Create a submenu within an existing submenu. (In other words, it's not
* the menubar.)
*
* menu - existing submenu
* szName - label to be given to the new submenu off of this submenu
*
* returns new menu widget
*/
GtkWidget *CreateBarSubMenu (GtkWidget *menu, char *szName)
{
GtkWidget *menuitem;
GtkWidget *submenu;
/* --- Create menu --- */
menuitem = gtk_menu_item_new_with_label (szName);
/* --- Add it to the menubar --- */
gtk_menu_bar_append (GTK_MENU_BAR (menu), menuitem);
gtk_widget_show (menuitem);
/* --- Get a menu and attach to the menuitem --- */
submenu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
/* --- Viola! --- */
return (submenu);
}
void show_user(void)
{
gint UID = getuid();
struct passwd *p = getpwuid(UID);
user_button = gtk_button_new_with_label(strtok(p->pw_gecos, ",\n\t\0"));
gtk_button_set_relief(GTK_BUTTON(user_button), GTK_RELIEF_NONE);
g_signal_connect(G_OBJECT(user_button), "button-press-event", G_CALLBACK(show_user_context), NULL);
g_signal_connect(G_OBJECT(user_button), "destroy", G_CALLBACK(redraw_user), NULL);
user_menu = gtk_menu_new();
GtkWidget *logout = gtk_menu_item_new_with_label("Logout");
gtk_menu_shell_append(GTK_MENU_SHELL(user_menu), logout);
g_signal_connect(G_OBJECT(logout), "button-press-event", G_CALLBACK(user_logout), NULL);
gtk_widget_show_all(user_menu);
gtk_box_pack_end(GTK_BOX(box), user_button, FALSE, FALSE, 5);
}
static void
property_dialog_setup_option_menu (GtkWidget *option_menu,
GCallback func,
gpointer user_data,
gconstpointer str1, ...)
{
GtkWidget *menu;
GtkWidget *menu_item;
gint i;
va_list args;
gconstpointer str;
gint type;
menu = gtk_option_menu_get_menu (GTK_OPTION_MENU (option_menu));
if (menu) {
gtk_widget_destroy (menu);
}
menu = gtk_menu_new ();
va_start (args, str1);
for (str = str1, i = 0; str != NULL; str = va_arg (args, gpointer), i++) {
menu_item = gtk_menu_item_new_with_label (str);
gtk_widget_show (menu_item);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
type = va_arg (args, gint);
g_object_set_data (G_OBJECT (menu_item),
"data",
GINT_TO_POINTER (type));
if (func) {
g_signal_connect (menu_item,
"activate",
func,
user_data);
}
}
va_end (args);
gtk_widget_show (menu);
gtk_option_menu_set_menu (GTK_OPTION_MENU (option_menu), menu);
}
static void
gpp_append_new_item (GladeProjectProperties *properties,
GtkWidget *popup,
const gchar *label,
GCallback activate_cb)
{
GtkWidget *item;
if (label)
item = gtk_menu_item_new_with_label (label);
else
item = gtk_separator_menu_item_new ();
if (activate_cb)
g_signal_connect (item, "activate", activate_cb, properties);
gtk_menu_shell_append (GTK_MENU_SHELL (popup), item);
gtk_widget_show (item);
}
/*
* Sets the properties of the widget. This is used for both applying the
* properties changed in the property editor, and also for loading.
*/
static void
gb_option_menu_set_properties (GtkWidget * widget, GbWidgetSetArgData * data)
{
gchar *items;
GtkWidget *menu, *menuitem;
gint choice;
items = gb_widget_input_text (data, Items);
if (data->apply)
{
gchar *pos = items;
gchar *items_end = &items[strlen (items)];
menu = gtk_menu_new ();
gtk_signal_connect (GTK_OBJECT (menu), "deactivate",
GTK_SIGNAL_FUNC (gb_option_menu_on_option_selected),
widget);
while (pos < items_end)
{
gchar *item_end = strchr (pos, '\n');
if (item_end == NULL)
item_end = items_end;
*item_end = '\0';
menuitem = gtk_menu_item_new_with_label (pos);
gtk_widget_show (menuitem);
gtk_menu_append (GTK_MENU (menu), menuitem);
pos = item_end + 1;
}
gtk_option_menu_set_menu (GTK_OPTION_MENU (widget), menu);
}
if (data->action == GB_APPLYING)
g_free (items);
choice = gb_widget_input_int (data, Choice);
if (data->apply)
{
gtk_option_menu_set_history (GTK_OPTION_MENU (widget), choice);
}
}
GList*
icon_theme_init()
{
// Build a menu list of available themes.
icon_theme_set_theme(NULL);
if(_debug_){
gint n_elements;
gchar** path[64];
gtk_icon_theme_get_search_path(icon_theme, path, &n_elements);
int i;
for(i=0;i<n_elements;i++){
dbg(2, "icon_theme_path=%s", path[0][i]);
}
g_strfreev(*path);
}
GtkWidget* menu = gtk_menu_new();
GPtrArray* names = g_ptr_array_new();
get_theme_names(names);
int i; for (i = 0; i < names->len; i++) {
char* name = names->pdata[i];
dbg(2, "name=%s", name);
GtkWidget* item = gtk_menu_item_new_with_label(name);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
g_object_set_data(G_OBJECT(item), "theme", g_strdup(name)); //make sure this string is free'd when menu is updated.
g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(icon_theme_on_select), NULL);
g_free(name);
}
gtk_widget_show_all(menu);
g_ptr_array_free(names, TRUE);
return themes = g_list_append(NULL, menu);
}
static gboolean show_menu(GtkWidget *widget, GdkEventButton *event)
{
GtkWidget *menu = gtk_menu_new();
GtkWidget *header_item;
if (event->button != 1)
return FALSE;
/* Create the menu items */
header_item = gtk_menu_item_new_with_label("Help");
gtk_widget_set_sensitive(header_item, FALSE);
gtk_menu_append(GTK_MENU(menu), header_item);
gtk_widget_show(header_item);
/* Contact button */
GtkWidget* contact_item = gtk_image_menu_item_new_with_label("Contact Us");
g_signal_connect(contact_item, "activate", G_CALLBACK(contact_clicked), NULL);
gtk_menu_append(GTK_MENU(menu), contact_item);
gtk_widget_show(contact_item);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(contact_item), get_resized_icon(CONTACT_ICON));
/* Knowledge button */
GtkWidget* knowledge_item = gtk_image_menu_item_new_with_label("Help Center");
g_signal_connect(knowledge_item, "activate", G_CALLBACK(knowledge_clicked), NULL);
gtk_menu_append(GTK_MENU(menu), knowledge_item);
gtk_widget_show(knowledge_item);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(knowledge_item), get_resized_icon(KNOWLEDGE_ICON));
/* Screenshot button */
GtkWidget* screenshot_item = gtk_image_menu_item_new_with_label("Report a Problem");
g_signal_connect(screenshot_item, "activate", G_CALLBACK(screenshot_clicked), NULL);
gtk_menu_append(GTK_MENU(menu), screenshot_item);
gtk_widget_show(screenshot_item);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(screenshot_item), get_resized_icon(SCREENSHOT_ICON));
g_signal_connect(menu, "selection-done", G_CALLBACK(selection_done), NULL);
/* Show the menu. */
gtk_menu_popup(GTK_MENU(menu), NULL, NULL,
(GtkMenuPositionFunc) menu_pos, widget,
event->button, event->time);
return TRUE;
}
/**
* Add to any menu
* mostly for allowing to assign for TrackWaypoint layer menus
*/
void vik_ext_tool_datasources_add_menu_items_to_menu ( VikWindow *vw, GtkMenu *menu )
{
GList *iter;
for (iter = ext_tool_datasources_list; iter; iter = iter->next) {
VikExtTool *ext_tool = NULL;
gchar *label = NULL;
ext_tool = VIK_EXT_TOOL ( iter->data );
label = vik_ext_tool_get_label ( ext_tool );
if ( label ) {
GtkWidget *item = NULL;
item = gtk_menu_item_new_with_label ( _(label) );
g_free ( label ); label = NULL;
// Store tool's ref into the menu entry
g_object_set_data ( G_OBJECT(item), VIK_TOOL_DATASOURCE_KEY, ext_tool );
g_signal_connect ( G_OBJECT(item), "activate", G_CALLBACK(ext_tool_datasources_open_cb), vw );
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show ( item );
}
}
}
void create_list_for_type(pa_devicelist_t *list) {
int i, j;
for(i = 0; i < 16; i++) {
if(!list[i].initialized)
break;
for(j = 0; j < list[i].n_ports; j++) {
GtkWidget *widget = gtk_menu_item_new_with_label(list[i].ports[j].description);
gtk_menu_append(GTK_MENU_SHELL (menu),widget);
gtk_widget_show(widget);
// HER VAR VI. SEGFAULT SOMEWHERE
pa_device_port_t *dp = malloc(sizeof(pa_device_port_t));
dp->device = list[i];
dp->port = list[i].ports[j];
g_signal_connect(G_OBJECT(widget), "activate", G_CALLBACK(activate_action), dp);
}
}
}
void fill_app_indicator(pa_devicelist_t *input, pa_devicelist_t *output) {
gtk_widget_destroy(menu);
GtkWidget *menu_items[3];
menu = gtk_menu_new();
create_list_for_type(input);
add_separator_to_menu();
create_list_for_type(output);
add_separator_to_menu();
GtkWidget *btn_quit = gtk_menu_item_new_with_label("Quit");
gtk_menu_append(GTK_MENU_SHELL (menu),btn_quit);
gtk_widget_show(btn_quit);
g_signal_connect (btn_quit, "activate",
G_CALLBACK (gtk_main_quit), NULL);
app_indicator_set_menu (indicator, GTK_MENU (menu));
}
static void
populate_menus (GladeXML *dialog)
{
gint corner, action;
GtkWidget *menu;
GtkWidget *menuitem;
for (corner = REGION_FIRST_CORNER; REGION_IS_CORNER (corner);
++corner) {
menu = gtk_menu_new();
for (action = 0; action < HANDLED_ACTIONS; ++action) {
menuitem = gtk_menu_item_new_with_label (
action_descriptions[action]);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
}
gtk_option_menu_set_menu (GTK_OPTION_MENU (
WID (corners[corner].action_menu_id)),
menu);
}
}
void view_popup_menu(GtkWidget *treeview, GdkEventButton *event, gpointer userdata)
{
GtkWidget *menu, *menuitem;
menu = gtk_menu_new();
menuitem = gtk_menu_item_new_with_label("Do something");
g_signal_connect(menuitem, "activate",(GCallback) view_popup_menu_onDoSomething, treeview);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
gtk_widget_show_all(menu);
/* Note: event can be NULL here when called from view_onPopupMenu;
* gdk_event_get_time() accepts a NULL argument */
gtk_menu_popup(GTK_MENU(menu),
NULL, NULL, NULL, NULL,
(event != NULL) ? event->button : 0,
gdk_event_get_time((GdkEvent*)event));
}
/*
* gtunet_create_tray_menu
*
* Create the menu on the tray icon
*/
GtkMenu *
gtunet_create_tray_menu ()
{
GtkWidget *tray_menu;
GtkWidget *tray_menu_quit;
tray_menu_quit = gtk_menu_item_new_with_label("Quit");
g_signal_connect(G_OBJECT(tray_menu_quit),
"activate",
G_CALLBACK (on_button_quit_clicked),
NULL);
tray_menu = gtk_menu_new();
gtk_menu_shell_append((GtkMenuShell *)tray_menu, tray_menu_quit);
gtk_widget_show(tray_menu_quit);
return (GtkMenu *)tray_menu;
}
int main(int argc, char *argv[]) { // {{{
if (!gtk_init_check(&argc, &argv)) {
std::cout << "Could not init GTK." << std::endl;
return 1;
}
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *menubar, *viewmenu, *view, *tog_stat, *statusbar; // menubar
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), vbox);
menubar = gtk_menu_bar_new();
viewmenu = gtk_menu_new();
view = gtk_menu_item_new_with_label("View");
tog_stat = gtk_check_menu_item_new_with_label("View Statusbar");
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(tog_stat), TRUE);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(view), viewmenu);
gtk_menu_shell_append(GTK_MENU_SHELL(viewmenu), tog_stat);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), view);
gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 3);
statusbar = gtk_statusbar_new();
gtk_box_pack_end(GTK_BOX(vbox), statusbar, FALSE, TRUE, 1);
gtk_widget_show_all(window);
g_signal_connect_swapped(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect_swapped(G_OBJECT(tog_stat), "activate", G_CALLBACK(toggle_statusbar), statusbar);
gtk_main();
return 0;
} // }}}
/**
* Create a menu with the list of accounts. This list is
* clickable and activates func if specified.
* used for now to add a submenu item in a main menu
*
* \param func Function to call when a line is selected
* \param activate_currrent If set to TRUE, does not mark as
* unsensitive current account
* \param include_closed If set to TRUE, include the closed accounts
*
* \return A newly created menu
*/
GtkWidget *gsb_account_create_menu_list ( GCallback func,
gboolean activate_currrent,
gboolean include_closed )
{
GtkWidget *menu;
GtkWidget *item;
GSList *list_tmp;
menu = gtk_menu_new ();
list_tmp = gsb_data_account_get_list_accounts ();
while ( list_tmp )
{
gint i;
i = gsb_data_account_get_no_account ( list_tmp -> data );
if ( i >= 0 && ( !gsb_data_account_get_closed_account (i) || include_closed ) )
{
item = gtk_menu_item_new_with_label ( gsb_data_account_get_name (i));
g_object_set_data ( G_OBJECT ( item ),
"account_number",
GINT_TO_POINTER (i));
if ( func )
g_signal_connect ( G_OBJECT ( item ), "activate", G_CALLBACK(func), NULL );
gtk_menu_shell_append ( GTK_MENU_SHELL ( menu ), item );
if ( !activate_currrent &&
gsb_gui_navigation_get_current_account () == i)
{
gtk_widget_set_sensitive ( item, FALSE );
}
gtk_widget_show ( item );
}
list_tmp = list_tmp -> next;
}
return ( menu );
}
/* returns a GtkMenu containing all available profiles for
* monitor [mon] */
static int
fill_profiles_menu (DdccApplet *applet)
{
struct profile* profile;
GtkWidget* item;
if (!ddcci_get_all_profiles (applet->monitor))
return 0;
for (profile=applet->monitor->profiles;profile;profile=profile->next) {
item = gtk_menu_item_new_with_label ((gchar*)profile->name);
g_object_set_data (G_OBJECT (item), "ddcc_profile", profile);
g_signal_connect (item, "activate",
G_CALLBACK (change_profile_cb), applet);
gtk_widget_show (item);
gtk_container_add (GTK_CONTAINER (applet->w_profiles_menu),
item);
}
return 1;
}
void update_bookmark_menu() {
GList *bookmarks;
gint i;
if (browser->bookmark_menu) {
gtk_menu_item_set_submenu(GTK_MENU_ITEM(browser->bookmark_menu_item), NULL);
browser->bookmark_menu = NULL;
}
browser->bookmark_menu = gtk_menu_new();
bookmarks = prefs_get_list("coverweb_bookmark_");
for (i = 0; i < g_list_length(bookmarks); ++i) {
gchar *bookmark = g_list_nth_data(bookmarks, i);
GtkWidget *bookitem = gtk_menu_item_new_with_label(bookmark);
gtk_menu_shell_append(GTK_MENU_SHELL (browser->bookmark_menu), bookitem);
g_signal_connect (G_OBJECT (bookitem), "activate", G_CALLBACK(bookmark_menu_item_cb), (gpointer) browser);
gtk_widget_show(bookitem);
}
gtk_menu_item_set_submenu(GTK_MENU_ITEM (browser->bookmark_menu_item), browser->bookmark_menu);
}
/**
*显示接收附件的TreeView的弹出菜单回调函数.(待接收和已接收都用此函数)
* @param widget TreeView
* @param event 事件
*/
gint DialogPeer::RcvTreePopup(GtkWidget *treeview,GdkEvent *event)
{
GtkWidget *menu,*menuitem;
GdkEventButton *event_button;
menu = gtk_menu_new();
menuitem = gtk_menu_item_new_with_label(_("Remove Selected"));
g_signal_connect_swapped(menuitem, "activate", G_CALLBACK(RemoveSelectedRcv), treeview);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
if (event->type == GDK_BUTTON_PRESS) {
event_button = (GdkEventButton *) event;
if (event_button->button == 3) {
gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL,
event_button->button, event_button->time);
gtk_widget_show(menuitem);
return TRUE;
}
}
return FALSE;
}
// Build the menu from the list of strings
static void BuildRecentFilesMenu (GtkWidget *menu, GtkSignalFunc pfn, gpointer data)
{
int Nix ;
char *pszBaseName = NULL ;
GtkWidget *menu_item = NULL ;
gtk_container_foreach (GTK_CONTAINER (menu), (GtkCallback)gtk_widget_destroy, NULL) ;
for (Nix = 0 ; Nix < icRecentFiles ; Nix++)
{
pszBaseName = base_name (ppszRecentFiles[Nix]) ;
menu_item = gtk_menu_item_new_with_label (pszBaseName) ;
gtk_widget_ref (menu_item) ;
gtk_object_set_data (GTK_OBJECT (menu_item), "file", ppszRecentFiles[Nix]) ;
gtk_object_set_data (GTK_OBJECT (menu_item), "parent", menu) ;
gtk_widget_show (menu_item) ;
gtk_container_add (GTK_CONTAINER (menu), menu_item) ;
gtk_signal_connect (GTK_OBJECT (menu_item), "activate", pfn, data) ;
}
}
static void
create_menu_entry (GtkWidget * menu, int index,
GtkWidget * box, GtkDataboxGraph * graph)
{
GtkWidget *menu_items;
char buf[128];
col_sel *sel = g_new0 (col_sel, 1);
sel->index = index;
sel->box = box;
sel->graph = graph;
sprintf (buf, "Change Color #%d", index);
menu_items = gtk_menu_item_new_with_label (buf);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
g_signal_connect_swapped (G_OBJECT (menu_items), "activate",
G_CALLBACK (menu_color_change_cb),
(gpointer) sel);
gtk_widget_show (menu_items);
}
void iceb_pm_vibor(class iceb_u_spisok *strmenu,GtkWidget **opt,int *nomer_str)
{
*opt = gtk_option_menu_new();
GtkWidget *menu = gtk_menu_new();
int nomer=0;
GtkWidget *item;
for(int ii=0; ii < strmenu->kolih(); ii++)
{
item = gtk_menu_item_new_with_label (strmenu->ravno_toutf(ii));
gtk_signal_connect (GTK_OBJECT (item), "activate",GtkSignalFunc(iceb_pm_vibor_get),nomer_str);
gtk_object_set_user_data(GTK_OBJECT(item),(gpointer)nomer++);
gtk_widget_show (item);
gtk_menu_append (GTK_MENU (menu), item);
}
gtk_option_menu_set_menu (GTK_OPTION_MENU (*opt), menu);
gtk_option_menu_set_history(GTK_OPTION_MENU(*opt),*nomer_str);
}
int main(int argc, char **argv)
{
bindtextdomain("tray_randr", LOCALE_DIR);
textdomain("tray_randr");
gtk_init(&argc, &argv);
icon = (GtkStatusIcon *)
gtk_status_icon_new_from_file(ICON_PATH "randr.png");
menu = gtk_menu_new();
newitem(&item_swext, _("Switch to external display"), CMD_SWEXT);
newitem(&item_swint, _("Switch to built-in display"), CMD_SWINT);
newitem(&item_clone, _("Use both displays"), CMD_CLONE);
sep = gtk_separator_menu_item_new();
gtk_widget_show(sep);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), sep);
newitem(&item_ext1024, _("Set ext. resolution to 1024x768"), CMD_1024);
newitem(&item_ext800, _("Set ext. resolution to 800x600"), CMD_800);
newitem(&item_ext640, _("Set ext. resolution to 640x480"), CMD_640);
g_signal_connect(G_OBJECT(icon), "popup-menu",
G_CALLBACK(popup), NULL);
sep = gtk_separator_menu_item_new();
gtk_widget_show(sep);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), sep);
item_quit = gtk_menu_item_new_with_label(_("Quit"));
gtk_widget_show(item_quit);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item_quit);
g_signal_connect(G_OBJECT(item_quit), "activate", G_CALLBACK(quit), NULL);
gtk_main();
return 0;
}
static GtkMenu *
build_sort_field_base_menu (SortFlowState *state)
{
gint start;
gint end;
gint index;
GtkWidget *menu = gtk_menu_new ();
GList* items = NULL;
if (state->sel != NULL) {
if (state->is_cols) {
start = state->sel->v_range.cell.a.col;
end = state->sel->v_range.cell.b.col;
index = state->sel->v_range.cell.a.row;
} else {
start = state->sel->v_range.cell.a.row;
end = state->sel->v_range.cell.b.row;
index = state->sel->v_range.cell.a.col;
}
build_sort_field_menu (start, end, index, menu, state,
state->sort_items);
items = gtk_container_get_children (GTK_CONTAINER (menu));
}
if (items == NULL) {
GtkWidget *item;
item = (GtkWidget *) gtk_menu_item_new_with_label(state->is_cols ?
_("no available column"): _("no available row"));
gtk_widget_set_sensitive( GTK_WIDGET (item), FALSE);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
}
g_list_free (items);
return GTK_MENU (menu);
}
static void
xfce_constructor (XfcePanelPlugin *plugin)
{
MultiloadPlugin *multiload = multiload_new();
multiload->panel_data = plugin;
multiload->panel_orientation = xfce_panel_plugin_get_orientation (plugin);
gtk_container_add (GTK_CONTAINER (plugin), GTK_WIDGET(multiload->container));
multiload_ui_read (multiload);
multiload_start(multiload);
/* show the panel's right-click menu on this ebox */
xfce_panel_plugin_add_action_widget (plugin, GTK_WIDGET(multiload->container));
/* plugin signals */
g_signal_connect(G_OBJECT(plugin), "free-data", G_CALLBACK (xfce_free_cb), multiload);
g_signal_connect(G_OBJECT(plugin), "save", G_CALLBACK (xfce_save_cb), multiload);
g_signal_connect(G_OBJECT(plugin), "size-changed", G_CALLBACK (xfce_size_changed_cb), multiload);
g_signal_connect(G_OBJECT(plugin), "orientation-changed", G_CALLBACK (xfce_orientation_changed_cb), multiload);
/* menu items */
GtkMenuItem *mi_separator = GTK_MENU_ITEM(gtk_separator_menu_item_new ());
GtkMenuItem *mi_help = GTK_MENU_ITEM(gtk_menu_item_new_with_mnemonic (_("_Help")));
GtkMenuItem *mi_sysmon = GTK_MENU_ITEM(gtk_menu_item_new_with_label(_("Start task manager")));
xfce_panel_plugin_menu_show_configure (plugin);
xfce_panel_plugin_menu_show_about (plugin);
xfce_panel_plugin_menu_insert_item (plugin, mi_separator);
xfce_panel_plugin_menu_insert_item (plugin, mi_help);
xfce_panel_plugin_menu_insert_item (plugin, mi_sysmon);
g_signal_connect (G_OBJECT (plugin), "configure-plugin", G_CALLBACK (xfce_configure_cb), multiload);
g_signal_connect (G_OBJECT (plugin), "about", G_CALLBACK (xfce_about_cb), NULL);
g_signal_connect (G_OBJECT (mi_help), "activate", G_CALLBACK (xfce_help_cb), NULL);
g_signal_connect (G_OBJECT (mi_sysmon), "activate", G_CALLBACK (xfce_sysmon_cb), multiload);
gtk_widget_show(GTK_WIDGET(mi_separator));
gtk_widget_show(GTK_WIDGET(mi_help));
gtk_widget_show(GTK_WIDGET(mi_sysmon));
}
int32 AddMenu(CefRefPtr<CefBrowser> browser, ExtensionString title, ExtensionString command,
ExtensionString position, ExtensionString relativeId)
{
// if (tag == kTagNotFound) {
// tag = NativeMenuModel::getInstance(getMenuParent(browser)).getOrCreateTag(command, ExtensionString());
// } else {
// // menu already there
// return NO_ERROR;
// }
GtkWidget* menuBar = GetMenuBar(browser);
GtkWidget* menuWidget = gtk_menu_new();
GtkWidget* menuHeader = gtk_menu_item_new_with_label(title.c_str());
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuHeader), menuWidget);
gtk_menu_shell_append(GTK_MENU_SHELL(menuBar), menuHeader);
gtk_widget_show(menuHeader);
// FIXME add lookup for menu widgets
_menuWidget = menuWidget;
return NO_ERROR;
}
static void
fill_menu (GtkWidget *menu)
{
struct dirent *e;
char *dname = gnome_unconditional_pixmap_file ("same-gnome");
DIR *dir;
int itemno = 0;
dir = opendir (dname);
if (!dir)
return;
while ((e = readdir (dir)) != NULL){
GtkWidget *item;
char *s = strdup (e->d_name);
if (!strstr (e->d_name, ".png")) {
free (s);
continue;
}
item = gtk_menu_item_new_with_label (s);
gtk_widget_show (item);
gtk_menu_append (GTK_MENU(menu), item);
gtk_signal_connect (GTK_OBJECT(item), "activate",
GTK_SIGNAL_FUNC (set_selection), s);
gtk_signal_connect (GTK_OBJECT(item), "destroy",
GTK_SIGNAL_FUNC (free_str), s);
if (!strcmp(scenario, s))
{
gtk_menu_set_active(GTK_MENU(menu), itemno);
}
itemno++;
}
closedir (dir);
}
/**
* Create a menu containing a link to all possible CSV fields. This
* is normally an event triggered by a click on a GtkTreeViewColumn.
*
* \param col Column that triggered event.
* \param field Position of column that triggered event.
* \param assistant Assistant that contains the column.
*
* \return A newly-created GtkMenu.
*/
GtkWidget * csv_import_fields_menu ( GtkTreeViewColumn * col, gint field,
GtkWidget * assistant )
{
GtkWidget * menu, * item;
int i;
menu = gtk_menu_new();
for ( i = 0 ; csv_fields[i] . name ; i++ )
{
item = gtk_menu_item_new_with_label ( (gchar *) _( csv_fields[i] . name ) );
g_object_set_data ( G_OBJECT ( item ), "column", col );
g_object_set_data ( G_OBJECT ( item ), "field", GINT_TO_POINTER( field - 1 ) );
g_object_set_data ( G_OBJECT ( item ), "assistant", assistant );
g_signal_connect ( G_OBJECT ( item ), "activate",
G_CALLBACK ( csv_import_change_field ), GINT_TO_POINTER( i ) );
gtk_menu_shell_append ( GTK_MENU_SHELL ( menu ), item );
}
gtk_widget_show_all ( menu );
return menu;
}
static gboolean
goio_console_update_device_menu (GtkWidget *menu)
{
GtkWidget *sub_menu;
GtkWidget *menu_item;
GSList *device_names = NULL;//ngi_sensor_world_get_available_device_names(NGI_SENSOR_WORLD (sensor_world));
GSList *iter;
g_return_val_if_fail (menu != NULL, FALSE);
g_return_val_if_fail (GTK_MENU_ITEM (menu), FALSE);
sub_menu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (menu));
if (!device_names)
device_names = g_slist_append(device_names, g_string_new ("None"));
GList *current = gtk_container_get_children (GTK_CONTAINER (sub_menu));
GList *iterc;
for (iterc = current; iterc; iterc = g_list_next (iterc))
{
gtk_container_remove (GTK_CONTAINER (sub_menu),GTK_WIDGET (iterc->data));
}
for (iter = device_names; iter; iter = g_slist_next (iter))
{
GString *label_name = iter->data;
menu_item = gtk_menu_item_new_with_label (label_name->str);
gtk_menu_shell_append (GTK_MENU_SHELL (sub_menu), menu_item);
g_signal_connect_swapped (G_OBJECT (menu_item), "activate",
G_CALLBACK (goio_console_device_selected),
menu_item);
gtk_widget_show (menu_item);
}
return TRUE;
}
static GtkWidget *init_menu_item_manual_charset(gchar *manual_charset)
{
static GtkLabel *label;
gchar *str;
if (other_codeset_title == NULL)
other_codeset_title = _("Other Codeset");
str = manual_charset
? g_strdup_printf("%s (%s)", other_codeset_title, manual_charset)
: g_strdup_printf("%s...", other_codeset_title);
if (!menu_item_manual_charset) {
menu_item_manual_charset = gtk_menu_item_new_with_label(str);
label = GTK_LABEL(gtk_bin_get_child(GTK_BIN(menu_item_manual_charset)));
} else
// gtk_label_set_text(GTK_LABEL(GTK_BIN(menu_item_manual_charset)->child), str);
gtk_label_set_text(label, str);
g_free(str);
return menu_item_manual_charset;
}
