GtkWidget *vsvks_vidnal(int *nomerstr)
{
int nomer=0;
GtkWidget *opt = gtk_option_menu_new();
GtkWidget *menu = gtk_menu_new();
GtkWidget *item;
item = gtk_menu_item_new_with_label (iceb_u_toutf(gettext("С НДС")));
gtk_signal_connect (GTK_OBJECT (item), "activate",GTK_SIGNAL_FUNC(iceb_get_menu), nomerstr);
gtk_object_set_user_data(GTK_OBJECT(item),(gpointer)nomer++);
gtk_widget_show (item);
gtk_menu_append (GTK_MENU (menu), item);
item = gtk_menu_item_new_with_label (iceb_u_toutf(gettext("Без НДС")));
gtk_signal_connect (GTK_OBJECT (item), "activate",GTK_SIGNAL_FUNC(iceb_get_menu), nomerstr);
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),*nomerstr);
return(opt);
}
static GtkWidget *create_main_menu()
{
GtkWidget *menu;
GtkWidget *preferences_item;
GtkWidget *pickable_item;
GtkWidget *quit_item;
menu = gtk_menu_new();
preferences_item = create_stock_menu_item("preferences_item",
GTK_STOCK_PREFERENCES, NULL, preferences_menu_item_activate_cb);
gtk_menu_append(GTK_MENU(menu), preferences_item);
/* pickable menu item */
pickable_item = gtk_check_menu_item_new_with_label("Pickable");
gtk_check_menu_item_set_active((GtkCheckMenuItem *)pickable_item, TRUE);
gtk_check_menu_item_set_show_toggle((GtkCheckMenuItem *)pickable_item, TRUE);
gtk_signal_connect_object((gpointer)pickable_item, "toggled",
GTK_SIGNAL_FUNC(pickable_menu_item_toggled_cb), pickable_item);
gtk_widget_show(pickable_item);
gtk_menu_append(GTK_MENU(menu), pickable_item);
quit_item = create_menu_item("quit_item", "Quit",
NULL, quit_menu_item_activate_cb);
gtk_menu_append(GTK_MENU(menu), quit_item);
GLADE_HOOKUP_OBJECT(menu, preferences_item, "preferences_item");
GLADE_HOOKUP_OBJECT(menu, quit_item, "quit_item");
return menu;
}
static void
sp_anchor_menu(SPObject *object, SPDesktop *desktop, GtkMenu *m)
{
SPItem *item;
GtkWidget *w;
item = (SPItem *) object;
/* Link dialog */
w = gtk_menu_item_new_with_mnemonic(_("Link _Properties"));
gtk_object_set_data(GTK_OBJECT(w), "desktop", desktop);
gtk_signal_connect(GTK_OBJECT(w), "activate", GTK_SIGNAL_FUNC(sp_anchor_link_properties), item);
gtk_widget_show(w);
gtk_menu_append(GTK_MENU(m), w);
/* Select item */
w = gtk_menu_item_new_with_mnemonic(_("_Follow Link"));
gtk_signal_connect(GTK_OBJECT(w), "activate", GTK_SIGNAL_FUNC(sp_anchor_link_follow), item);
gtk_widget_show(w);
gtk_menu_append(GTK_MENU(m), w);
/* Reset transformations */
w = gtk_menu_item_new_with_mnemonic(_("_Remove Link"));
gtk_object_set_data(GTK_OBJECT(w), "desktop", desktop);
gtk_signal_connect(GTK_OBJECT(w), "activate", GTK_SIGNAL_FUNC(sp_anchor_link_remove), item);
gtk_widget_show(w);
gtk_menu_append(GTK_MENU(m), w);
}
void build_menus( GtkWidget* window )
{
GtkWidget* menu_bar;
GtkWidget* file_menu;
GtkWidget* file_item;
GtkWidget* file_open;
GtkWidget* file_quit;
menu_bar = gtk_menu_bar_new( );
file_menu = gtk_menu_new( );
file_open = gtk_menu_item_new_with_label( "Open" );
gtk_signal_connect_object( GTK_OBJECT( file_open ), "activate",
GTK_SIGNAL_FUNC( show_open_dialog ), NULL );
gtk_menu_append( GTK_MENU( file_menu ), file_open );
gtk_widget_show( file_open );
file_quit = gtk_menu_item_new_with_label( "Quit" );
gtk_signal_connect_object( GTK_OBJECT( file_quit ), "activate",
GTK_SIGNAL_FUNC( query_quit ), NULL );
gtk_menu_append( GTK_MENU( file_menu ), file_quit );
gtk_widget_show( file_quit );
file_item = gtk_menu_item_new_with_label( "File" );
gtk_menu_item_set_submenu( GTK_MENU_ITEM( file_item ), file_menu );
gtk_widget_show( file_item );
gtk_menu_bar_append( GTK_MENU_BAR( menu_bar ), file_item );
gtk_container_add( GTK_CONTAINER( window ), menu_bar );
gtk_widget_show( menu_bar );
}
static void server_browse_entry_popup(GqBrowserNode *e,
GtkWidget *menu,
GQTreeWidget *ctreeroot,
GQTreeWidgetNode *ctree_node,
GqTab *tab)
{
GtkWidget *menu_item;
GqServer *server;
struct edit_server_cb_data *cbd;
GqBrowserNodeServer *entry;
g_assert(GQ_IS_BROWSER_NODE_SERVER(e));
entry = GQ_BROWSER_NODE_SERVER(e);
server = server_from_node(ctreeroot, ctree_node);
/* Edit Server settings */
menu_item = gtk_menu_item_new_with_label(_("Edit Server"));
gtk_menu_append(GTK_MENU(menu), menu_item);
gtk_widget_show(menu_item);
cbd = (struct edit_server_cb_data *)
g_malloc0(sizeof(struct edit_server_cb_data));
cbd->server = g_object_ref(server);
cbd->tab = tab;
g_signal_connect_swapped(menu_item, "activate",
G_CALLBACK(edit_server_activated),
cbd);
/* explicitly attach cbd to assure call to destructor */
gtk_object_set_data_full(GTK_OBJECT(menu_item), "cbd",
cbd, (GtkDestroyNotify)free_edit_server_cb_data);
gtk_widget_show(menu_item);
if (server == NULL) {
gtk_widget_set_sensitive(menu_item, FALSE);
}
/* Export to LDIF */
menu_item = gtk_menu_item_new_with_label(_("Export to LDIF"));
gtk_menu_append(GTK_MENU(menu), menu_item);
g_signal_connect(menu_item, "activate",
G_CALLBACK(dump_server),
tab);
gtk_widget_show(menu_item);
/* Close connection */
menu_item = gtk_menu_item_new_with_label(_("Close Connection"));
gtk_menu_append(GTK_MENU(menu), menu_item);
g_signal_connect(menu_item, "activate",
G_CALLBACK(tree_row_close_connection),
tab);
gtk_widget_show(menu_item);
if (server == NULL) {
gtk_widget_set_sensitive(menu_item, FALSE);
}
}
void
create_ui_context_menu(GtkWidget *parent_window)
{
ui_context_menu = gtk_menu_new();
gtk_widget_ref (ui_context_menu);
gtk_object_set_data_full (GTK_OBJECT (parent_window), "ui_context_menu", ui_context_menu,
(GtkDestroyNotify) gtk_widget_unref);
ui_context_menu_launch = gtk_menu_item_new_with_label ("Launch UI");
gtk_widget_show (ui_context_menu_launch);
gtk_menu_append (GTK_MENU (ui_context_menu), ui_context_menu_launch);
ui_context_menu_show = gtk_menu_item_new_with_label ("Show UI");
gtk_widget_show (ui_context_menu_show);
gtk_menu_append (GTK_MENU (ui_context_menu), ui_context_menu_show);
ui_context_menu_hide = gtk_menu_item_new_with_label ("Hide UI");
gtk_widget_show (ui_context_menu_hide);
gtk_menu_append (GTK_MENU (ui_context_menu), ui_context_menu_hide);
ui_context_menu_exit = gtk_menu_item_new_with_label ("Exit UI");
gtk_widget_show (ui_context_menu_exit);
gtk_menu_append (GTK_MENU (ui_context_menu), ui_context_menu_exit);
gtk_signal_connect (GTK_OBJECT (ui_context_menu_launch), "activate",
GTK_SIGNAL_FUNC (on_ui_context_menu_activate),
(gpointer)0);
gtk_signal_connect (GTK_OBJECT (ui_context_menu_show), "activate",
GTK_SIGNAL_FUNC (on_ui_context_menu_activate),
(gpointer)1);
gtk_signal_connect (GTK_OBJECT (ui_context_menu_hide), "activate",
GTK_SIGNAL_FUNC (on_ui_context_menu_activate),
(gpointer)2);
gtk_signal_connect (GTK_OBJECT (ui_context_menu_exit), "activate",
GTK_SIGNAL_FUNC (on_ui_context_menu_activate),
(gpointer)3);
}
void ShowTrayMenu()
{
GtkWidget *menu;
GtkWidget *menu_item;
GtkWidget *icon;
int button, event_time;
menu = gtk_menu_new ();
//g_signal_connect (menu, "deactivate", G_CALLBACK(gtk_widget_destroy), NULL);
GtkAccelGroup *accel_group = gtk_accel_group_new();
gtk_menu_set_accel_group (GTK_MENU (menu), accel_group);
// ... add menu items with accelerators ...
menu_item = gtk_image_menu_item_new_with_mnemonic(_("Restore"));
g_signal_connect(menu_item, "activate", G_CALLBACK (on_tray_restore), NULL);
gtk_menu_append(menu, menu_item);
gtk_widget_show (menu_item); // Show the widget
icon = gtk_image_new_from_stock (GTK_STOCK_REFRESH, GTK_ICON_SIZE_MENU);
gtk_widget_show (icon);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item), icon);
menu_item = gtk_image_menu_item_new_with_mnemonic(_("Quit"));
g_signal_connect(menu_item, "activate", G_CALLBACK (on_tray_quit), NULL);
gtk_menu_append(menu, menu_item);
gtk_widget_show (menu_item); // Show the widget
icon = gtk_image_new_from_stock (GTK_STOCK_QUIT, GTK_ICON_SIZE_MENU);
gtk_widget_show (icon);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item), icon);
event_time = gtk_get_current_event_time ();
button = 0; //FIX: allow mouse button to trigger the submenu
gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, button, event_time);
}
GtkWidget *
sp_fill_style_widget_new (void)
{
GtkWidget *spw, *vb, *psel, *hb, *l, *om, *m, *mi;
spw = sp_widget_new_global (INKSCAPE);
vb = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vb);
gtk_container_add (GTK_CONTAINER (spw), vb);
psel = sp_paint_selector_new ();
gtk_widget_show (psel);
gtk_box_pack_start (GTK_BOX (vb), psel, TRUE, TRUE, 0);
g_object_set_data (G_OBJECT (spw), "paint-selector", psel);
g_signal_connect (G_OBJECT (psel), "mode_changed", G_CALLBACK (sp_fill_style_widget_paint_mode_changed), spw);
g_signal_connect (G_OBJECT (psel), "dragged", G_CALLBACK (sp_fill_style_widget_paint_dragged), spw);
g_signal_connect (G_OBJECT (psel), "changed", G_CALLBACK (sp_fill_style_widget_paint_changed), spw);
hb = gtk_hbox_new (FALSE, 4);
gtk_widget_show (hb);
gtk_box_pack_start (GTK_BOX (vb), hb, FALSE, FALSE, 0);
l = gtk_label_new (_("Fill Rule"));
gtk_widget_show (l);
gtk_misc_set_alignment (GTK_MISC (l), 1.0, 0.5);
gtk_box_pack_start (GTK_BOX (hb), l, TRUE, TRUE, 0);
om = gtk_option_menu_new ();
gtk_widget_show (om);
gtk_box_pack_start (GTK_BOX (hb), om, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (spw), "fill-rule", om);
/* 0 - nonzero 1 - evenodd */
m = gtk_menu_new ();
gtk_widget_show (m);
mi = gtk_menu_item_new_with_label (_("nonzero"));
gtk_widget_show (mi);
gtk_menu_append (GTK_MENU (m), mi);
g_object_set_data (G_OBJECT (mi), "fill-rule", (void *)"nonzero");
g_signal_connect (G_OBJECT (mi), "activate", G_CALLBACK (sp_fill_style_widget_fill_rule_activate), spw);
mi = gtk_menu_item_new_with_label (_("evenodd"));
gtk_widget_show (mi);
gtk_menu_append (GTK_MENU (m), mi);
g_object_set_data (G_OBJECT (mi), "fill-rule", (void *)"evenodd");
g_signal_connect (G_OBJECT (mi), "activate", G_CALLBACK (sp_fill_style_widget_fill_rule_activate), spw);
gtk_option_menu_set_menu (GTK_OPTION_MENU (om), m);
g_signal_connect (G_OBJECT (spw), "construct", G_CALLBACK (sp_fill_style_widget_construct), psel);
g_signal_connect (G_OBJECT (spw), "modify_selection", G_CALLBACK (sp_fill_style_widget_modify_selection), psel);
g_signal_connect (G_OBJECT (spw), "change_selection", G_CALLBACK (sp_fill_style_widget_change_selection), psel);
g_signal_connect (G_OBJECT (spw), "attr_changed", G_CALLBACK (sp_fill_style_widget_attr_changed), psel);
sp_fill_style_widget_update (SP_WIDGET (spw), SP_ACTIVE_DESKTOP ? SP_DT_SELECTION (SP_ACTIVE_DESKTOP) : NULL);
return spw;
}
void make_menus(GtkWidget *box)
{
GtkWidget *menu, *menu_bar, *root_menu, *menu_items;
/* FILE menu */
menu = gtk_menu_new ();
menu_items = gtk_menu_item_new_with_label ("Open");
gtk_menu_append (GTK_MENU (menu), menu_items);
gtk_signal_connect_object (GTK_OBJECT (menu_items), "activate",
GTK_SIGNAL_FUNC(open_func), NULL);
gtk_widget_show(menu_items);
menu_items = gtk_menu_item_new_with_label ("Exit");
gtk_menu_append (GTK_MENU (menu), menu_items);
gtk_signal_connect_object (GTK_OBJECT (menu_items), "activate",
GTK_SIGNAL_FUNC(exit_func), NULL);
gtk_widget_show(menu_items);
root_menu = gtk_menu_item_new_with_label ("File");
gtk_widget_show (root_menu);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (root_menu), menu);
menu_bar = gtk_menu_bar_new ();
gtk_box_pack_start (GTK_BOX (box), menu_bar, FALSE, FALSE, 0);
gtk_widget_show (menu_bar);
gtk_menu_bar_append (GTK_MENU_BAR (menu_bar), root_menu);
/* OPTIONS menu */
menu = gtk_menu_new ();
menu_items = gtk_menu_item_new_with_label ("Options");
gtk_menu_append (GTK_MENU (menu), menu_items);
gtk_signal_connect_object (GTK_OBJECT (menu_items), "activate",
GTK_SIGNAL_FUNC(open_options_window), NULL);
gtk_widget_show(menu_items);
// root_menu = gtk_menu_item_new_with_label ("Options");
// gtk_widget_show (root_menu);
root_menu = gtk_menu_item_new_with_label ("Options");
gtk_widget_show (root_menu);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (root_menu), menu);
gtk_menu_bar_append (GTK_MENU_BAR (menu_bar), root_menu);
/* HELP menu */
menu = gtk_menu_new ();
menu_items = gtk_menu_item_new_with_label ("About");
gtk_menu_append (GTK_MENU (menu), menu_items);
gtk_signal_connect_object (GTK_OBJECT (menu_items), "activate",
GTK_SIGNAL_FUNC(open_about_menu), NULL);
gtk_widget_show(menu_items);
menu_items = gtk_menu_item_new_with_label ("Help");
gtk_menu_append (GTK_MENU (menu), menu_items);
gtk_signal_connect_object (GTK_OBJECT (menu_items), "activate",
GTK_SIGNAL_FUNC(open_help_menu), NULL);
gtk_widget_show(menu_items);
root_menu = gtk_menu_item_new_with_label ("Help");
gtk_widget_show (root_menu);
//gtk_menu_item_right_justify(GTK_MENU_ITEM(root_menu)); //(for later)
gtk_menu_item_set_submenu (GTK_MENU_ITEM (root_menu), menu);
gtk_menu_bar_append (GTK_MENU_BAR (menu_bar), root_menu);
}
gboolean on_button_release (GtkWidget *widget, GdkEventButton *event, gpointer data)
{
int item_no = GPOINTER_TO_INT (data);
if (event->button != 3) return FALSE;
GtkWidget *menu = gtk_menu_new ();
GtkWidget *mi = gtk_menu_item_new_with_label (_("Information"));
g_signal_connect (G_OBJECT (mi), "activate", G_CALLBACK (on_click_stash_info), GINT_TO_POINTER (item_no));
gtk_menu_append (menu, mi);
mi = gtk_menu_item_new_with_label (_("Change password"));
g_signal_connect (G_OBJECT (mi), "activate", G_CALLBACK (on_click_change_stash_password), GINT_TO_POINTER (item_no));
gtk_menu_append (menu, mi);
mi = gtk_menu_item_new_with_label (_("Delete encrypted folder"));
g_signal_connect (G_OBJECT (mi), "activate", G_CALLBACK (on_click_delete_stash), GINT_TO_POINTER (item_no));
gtk_menu_append (menu, mi);
gtk_widget_show_all (menu);
gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, widget,
0, event->time);
g_signal_connect (G_OBJECT (menu), "hide", G_CALLBACK (on_dostuff_menu_destroy), NULL);
return TRUE;
}
void set_indicating_menu_items(long ramfs, long mem)
{
char ramfs_text[100];
sprintf(ramfs_text,"ramfs size: %ld MB",ramfs/1024);
char mem_text[100];
sprintf(mem_text,"free RAM: %ld MB", mem/1024);
indicator_menu = gtk_menu_new();
ramfs_item = gtk_menu_item_new_with_label ((const char*)ramfs_text);
freemem_item = gtk_menu_item_new_with_label ((const char*)mem_text);
quit_item = gtk_menu_item_new_with_label ("Quit");
//add menu item to menu
gtk_menu_append(GTK_MENU(indicator_menu),ramfs_item);
gtk_menu_append(GTK_MENU(indicator_menu),freemem_item);
gtk_menu_append(GTK_MENU(indicator_menu),quit_item);
g_signal_connect (G_OBJECT (quit_item),
"activate",
G_CALLBACK (gtk_main_quit),
NULL);
gtk_widget_show (freemem_item);
gtk_widget_show (ramfs_item);
gtk_widget_show (quit_item);
app_indicator_set_menu (indicator, GTK_MENU (indicator_menu));
}
static void create_menu()
{
/* Create needed variables */
GtkWidget *main_menu;
GtkWidget *item_settings;
GtkWidget *item_about;
GtkWidget *item_separator;
GtkWidget *item_close;
/* Create new main menu */
main_menu = gtk_menu_new();
/* Create menu items */
item_settings = gtk_menu_item_new_with_label("Settings");
item_about = gtk_menu_item_new_with_label("About");
item_separator = gtk_separator_menu_item_new();
item_close = gtk_menu_item_new_with_label("Close");
/* Add menu items to right menus*/
gtk_menu_append(main_menu, item_settings);
gtk_menu_append(main_menu, item_about);
gtk_menu_append(main_menu, item_separator);
gtk_menu_append(main_menu, item_close);
hildon_window_set_menu(appdata->window, GTK_MENU(main_menu));
/* Attach the callback functions to the activate signal */
g_signal_connect(G_OBJECT(item_settings), "activate", GTK_SIGNAL_FUNC(menu_settings_clicked), NULL);
g_signal_connect(G_OBJECT(item_about), "activate", GTK_SIGNAL_FUNC(menu_about_clicked), NULL);
g_signal_connect(G_OBJECT(item_close), "activate", GTK_SIGNAL_FUNC(menu_exit_clicked), NULL);
/* Make all menu widgets visible*/
gtk_widget_show_all(GTK_WIDGET(main_menu));
}
void
create_freq_menu(void) {
GtkWidget *menuitem;
int i;
if (menu != NULL) {
gtk_widget_destroy(menu);
}
if (!nstations) {
menu = NULL;
return;
}
menu = gtk_menu_new();
gtk_menu_set_title(GTK_MENU(menu),"frequency menu");
menuitem = gtk_tearoff_menu_item_new();
gtk_menu_append(GTK_MENU(menu),menuitem);
gtk_widget_show(menuitem);
for (i=0; i < nstations; i++) {
menuitem = gtk_menu_item_new_with_label(stations[i].station_name);
gtk_menu_append(GTK_MENU(menu),menuitem);
gtk_signal_connect(GTK_OBJECT(menuitem),"activate",
GTK_SIGNAL_FUNC(freq_menu_activated),GINT_TO_POINTER(i));
}
gtk_widget_show_all(menu);
}
/*
* Adds menu items to a context menu which is just about to appear!
* Add commands to aid in editing a BonoboDockItem, with signals pointing to
* other functions in this file.
*/
static void
gb_bonobo_dock_item_create_popup_menu (GtkWidget * widget, GbWidgetCreateMenuData * data)
{
GtkWidget *menuitem;
/* We can't add items next to floating items or items that have the
BONOBO_DOCK_ITEM_BEH_EXCLUSIVE flag set. */
if (!BONOBO_DOCK_ITEM (widget)->is_floating
&& !(BONOBO_DOCK_ITEM (widget)->behavior & BONOBO_DOCK_ITEM_BEH_EXCLUSIVE))
{
menuitem = gtk_menu_item_new_with_label (_("Add dock item before"));
gtk_widget_show (menuitem);
gtk_menu_append (GTK_MENU (data->menu), menuitem);
gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
GTK_SIGNAL_FUNC (gb_bonobo_dock_item_add_item_before),
widget);
menuitem = gtk_menu_item_new_with_label (_("Add dock item after"));
gtk_widget_show (menuitem);
gtk_menu_append (GTK_MENU (data->menu), menuitem);
gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
GTK_SIGNAL_FUNC (gb_bonobo_dock_item_add_item_after),
widget);
}
}
static GtkMenu *Populate( intf_thread_t *p_intf, GtkMenu *menu,
const char **varnames, vlc_object_t **objects,
unsigned int elements)
{
for( unsigned int i = 0; i < elements ; i++ )
{
if( (!varnames[i] || !*varnames[i]) &&
g_list_length(GTK_MENU_SHELL(menu)->children) )
{
gtk_menu_append( menu, gtk_separator_menu_item_new() );
continue;
}
if( objects[i] )
{
UpdateItem( p_intf, menu, varnames[i], objects[i], true );
}
}
if(!g_list_length(GTK_MENU_SHELL(menu)->children))
{
GtkWidget *menuitem = gtk_menu_item_new_with_label( "Empty" );
gtk_menu_append( menu, menuitem );
gtk_widget_set_sensitive(menuitem, false);
}
return menu;
}
void CreateMenuForMainWindow(GtkWidget *m_oDSPMenu, GtkWidget **m_oTestDSPConnection_item,
GtkWidget *m_oFileMenu, GtkWidget **m_oSaveResults_item, GtkWidget *m_oFileItem, GtkWidget *m_oDSPItem)
{
// Set up menu for the window
gtk_menu_append(GTK_MENU (m_oDSPMenu), m_oTestDSPConnection_item);
gtk_menu_append(GTK_MENU (m_oFileMenu), m_oSaveResults_item);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(m_oFileItem), m_oFileMenu);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(m_oDSPItem), m_oDSPMenu);
}
void
populate_popup_cb(WebKitWebView *v, GtkMenu *m, void *c) {
(void) v;
(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_DOCUMENT) &&
(context & mi->context)) {
if(mi->issep) {
item = gtk_separator_menu_item_new();
gtk_menu_append(GTK_MENU(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->cmd);
gtk_menu_append(GTK_MENU(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_append(GTK_MENU(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->cmd);
gtk_menu_append(GTK_MENU(m), item);
gtk_widget_show(item);
}
}
}
}
void enc_profmenu(struct encdata *enc)
{
char *aprof;
GtkWidget *tmplabel, *tmplabel1, *tmpmenu;
GList *listrunner;
struct encprof *tmp;
tmpmenu = gtk_menu_new();
if(enc->outchan->tipo == MP3) {
tmplabel = gtk_menu_item_new_with_label(_("Save..."));
g_object_set_data(G_OBJECT(tmplabel), "type", (void *) "lame");
tmplabel1 = gtk_menu_item_new_with_label(_("Remove..."));
g_object_set_data(G_OBJECT(tmplabel1), "type", (void *) "lame");
listrunner = g_list_first(lameprof);
} else {
tmplabel = gtk_menu_item_new_with_label(_("Save..."));
g_object_set_data(G_OBJECT(tmplabel), "type", (void *) "ogg");
tmplabel1 = gtk_menu_item_new_with_label(_("Remove..."));
g_object_set_data(G_OBJECT(tmplabel1), "type", (void *) "ogg");
listrunner = g_list_first(vorbisprof);
}
g_signal_connect(G_OBJECT(tmplabel), "activate",
G_CALLBACK(win_profile_save), (void *) enc);
g_signal_connect(G_OBJECT(tmplabel1), "activate",
G_CALLBACK(win_profile_remove), (void *) enc);
gtk_menu_append(GTK_MENU(tmpmenu), tmplabel);
gtk_menu_append(GTK_MENU(tmpmenu), tmplabel1);
tmplabel = gtk_menu_item_new_with_label(_("Load"));
gtk_menu_append(GTK_MENU(tmpmenu), tmplabel);
while(listrunner) {
tmp = (struct encprof *) listrunner->data;
aprof = tmp->name;
tmplabel = gtk_menu_item_new_with_label(aprof);
g_signal_connect(G_OBJECT(tmplabel), "activate",
G_CALLBACK(gcb_enc_put), enc);
gtk_menu_append(GTK_MENU(tmpmenu), tmplabel);
//FIXME : missing remove in profile API
listrunner = g_list_next(listrunner);
}
gtk_menu_item_remove_submenu(GTK_MENU_ITEM(enc->profroot));
gtk_menu_item_set_submenu(GTK_MENU_ITEM(enc->profroot), tmpmenu);
gtk_widget_show_all(tmpmenu);
}
static GtkWidget *
cpufreq_menu(cpufreq *cf){
GList *l;
GSList *group;
char buff[100];
GtkMenuItem* menuitem;
Param* param;
GtkMenu* menu = GTK_MENU(gtk_menu_new());
g_signal_connect(menu, "selection-done", gtk_widget_destroy, NULL);
get_governors(cf);
group = NULL;
if((cf->governors == NULL) || (!cf->has_cpufreq) || (cf->cur_governor == NULL)){
menuitem = GTK_MENU_ITEM(gtk_menu_item_new_with_label("CPUFreq not supported"));
gtk_menu_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
return menu;
}
if(strcmp(cf->cur_governor, "userspace") == 0){
menuitem = GTK_MENU_ITEM(gtk_menu_item_new_with_label(" Frequency"));
gtk_menu_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
gtk_menu_item_set_submenu(menuitem, frequency_menu(cf));
menuitem = GTK_MENU_ITEM(gtk_separator_menu_item_new());
gtk_menu_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (GTK_WIDGET(menuitem));
}
for( l = cf->governors; l; l = l->next )
{
if(strcmp((char*)l->data, cf->cur_governor) == 0){
sprintf(buff,"> %s", l->data);
menuitem = GTK_MENU_ITEM(gtk_menu_item_new_with_label(strdup(buff)));
}else{
sprintf(buff," %s", l->data);
menuitem = GTK_MENU_ITEM(gtk_menu_item_new_with_label(strdup(buff)));
}
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
param = g_new0(Param, 1);
param->data = l->data;
param->cf = cf;
g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(cpufreq_set_governor), param);
g_object_weak_ref(menuitem, g_free, param);
}
return menu;
}
static gboolean
player_av_button_press (GtkWidget *da, GdkEventButton *event, PlayerAV *self)
{
GdkRectangle rect;
GdkScreen *screen = gdk_screen_get_default ();
gint num = gdk_screen_get_n_monitors (screen);
if (self->priv->monitor >= num) {
self->priv->monitor = num-1;
}
if (event->button == 3) {
GtkWidget *item;
GtkWidget *menu = gtk_menu_new ();
item = gtk_menu_item_new_with_label ("Toggle Fullscreen");
gtk_menu_append (GTK_MENU (menu), item);
g_signal_connect (item, "activate", G_CALLBACK (toggle_fullscreen), self);
gtk_menu_append (GTK_MENU (menu), gtk_separator_menu_item_new ());
GSList *group = NULL;
gint i;
for (i = 0; i < num; i++) {
gdk_screen_get_monitor_geometry (screen, i, &rect);
gchar *str = g_strdup_printf ("%d: %dx%d", i+1, rect.width, rect.height);
item = gtk_radio_menu_item_new_with_label (group, str);
g_free (str);
group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (item));
if (i == self->priv->monitor) {
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), TRUE);
}
gtk_menu_append (GTK_MENU (menu), item);
g_signal_connect (item, "activate", G_CALLBACK (on_pick_screen), self);
}
gtk_menu_append (GTK_MENU (menu), gtk_separator_menu_item_new ());
gtk_widget_show_all (menu);
gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL,
event->button, event->time);
} else if (event->type == GDK_2BUTTON_PRESS) {
toggle_fullscreen (NULL, self);
}
return FALSE;
}
static GtkWidget *
get_config_frame(PurplePlugin *plugin)
{
GtkWidget *ret;
GtkWidget *vbox;
GtkWidget *toggle;
#if 0
GtkWidget *opt;
GtkWidget *menu, *item;
#endif
/* Outside container */
ret = gtk_vbox_new(FALSE, 18);
gtk_container_set_border_width(GTK_CONTAINER(ret), 12);
/* Configuration frame */
vbox = pidgin_make_frame(ret, _("Mouse Gestures Configuration"));
#if 0
/* Mouse button drop-down menu */
menu = gtk_menu_new();
opt = gtk_option_menu_new();
item = gtk_menu_item_new_with_label(_("Middle mouse button"));
g_signal_connect(G_OBJECT(item), "activate",
G_CALLBACK(mouse_button_menu_cb), opt);
gtk_menu_append(menu, item);
item = gtk_menu_item_new_with_label(_("Right mouse button"));
g_signal_connect(G_OBJECT(item), "activate",
G_CALLBACK(mouse_button_menu_cb), opt);
gtk_menu_append(menu, item);
gtk_box_pack_start(GTK_BOX(vbox), opt, FALSE, FALSE, 0);
gtk_option_menu_set_menu(GTK_OPTION_MENU(opt), menu);
gtk_option_menu_set_history(GTK_OPTION_MENU(opt),
gstroke_get_mouse_button() - 2);
#endif
/* "Visual gesture display" checkbox */
toggle = gtk_check_button_new_with_mnemonic(_("_Visual gesture display"));
gtk_box_pack_start(GTK_BOX(vbox), toggle, FALSE, FALSE, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle),
purple_prefs_get_bool("/plugins/gtk/X11/gestures/visual"));
g_signal_connect(G_OBJECT(toggle), "toggled",
G_CALLBACK(toggle_draw_cb), NULL);
gtk_widget_show_all(ret);
return ret;
}
void ptt_menu_update(void) {
DVDResult_t res;
int i;
int num_titles;
int num_ptts;
menu = gtk_menu_new();
res = DVDGetTitles(nav, &num_titles);
if(res != DVD_E_Ok) {
DVDPerror("ptt_menu_update: DVDGetTitles(1)", res);
return;
}
for (i=1; i <= num_titles; i++) {
int j;
GtkWidget *menu_item;
GtkWidget *submenu;
GtkWidget *submenu_item;
char* label;
res = DVDGetNumberOfPTTs(nav, i, &num_ptts);
if(res != DVD_E_Ok) {
DVDPerror("ptt_menu_update: DVDGetNumberOfPTTs(1)", res);
return;
}
submenu = gtk_menu_new ();
label = g_strdup_printf(_("Title %i"), i);
menu_item = gtk_menu_item_new_with_label(label);
g_free(label);
for (j=1; j<=num_ptts; j++) {
label = g_strdup_printf(_("Chapter %i"), j);
submenu_item = gtk_menu_item_new_with_label(label);
g_free(label);
gtk_signal_connect(GTK_OBJECT(submenu_item), "activate",
on_jump_to_ptt_activate, GINT_TO_POINTER(i*256+j));
gtk_menu_append(GTK_MENU(submenu), submenu_item);
}
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_item), submenu);
gtk_menu_append(GTK_MENU(menu), menu_item);
}
gtk_widget_show_all(menu);
}
static void
list_bookmarks (GtkWidget *menu, struct connect_context *cc)
{
struct dirent *de;
char *file;
char path[MAXPATHLEN];
GtkWidget *item;
DIR *dir;
expand_tilde(path, "~/.hx/bookmarks");
dir = opendir(path);
if (!dir)
return;
while ((de = readdir(dir))) {
if (*de->d_name != '.') {
file = xstrdup(de->d_name);
item = gtk_menu_item_new_with_label(file);
gtk_menu_append(GTK_MENU(menu), item);
gtk_object_set_data(GTK_OBJECT(item), "cc", cc);
gtk_signal_connect(GTK_OBJECT(item), "activate",
GTK_SIGNAL_FUNC(open_bookmark), file);
}
}
closedir(dir);
}
// Create a new menu item
rtk_menuitem_t *rtk_menuitem_create(rtk_menu_t *menu,
const char *label, int check)
{
rtk_menuitem_t *item;
item = malloc(sizeof(rtk_menuitem_t));
item->menu = menu;
item->activated = FALSE;
item->checked = FALSE;
item->callback = NULL;
if (check)
{
item->checkitem = 1;
item->item = gtk_check_menu_item_new_with_label(label);
gtk_check_menu_item_set_show_toggle(GTK_CHECK_MENU_ITEM(item->item), 1);
}
else
{
item->checkitem = 0;
item->item = gtk_menu_item_new_with_label(label);
}
gtk_menu_append(GTK_MENU(menu->menu), item->item);
gtk_signal_connect(GTK_OBJECT(item->item), "activate",
GTK_SIGNAL_FUNC(rtk_on_activate), item);
return item;
}
void wxMenu::Init()
{
m_accel = gtk_accel_group_new();
m_menu = gtk_menu_new();
// NB: keep reference to the menu so that it is not destroyed behind
// our back by GTK+ e.g. when it is removed from menubar:
gtk_widget_ref(m_menu);
m_owner = NULL;
// Tearoffs are entries, just like separators. So if we want this
// menu to be a tear-off one, we just append a tearoff entry
// immediately.
if ( m_style & wxMENU_TEAROFF )
{
GtkWidget *tearoff = gtk_tearoff_menu_item_new();
gtk_menu_append(GTK_MENU(m_menu), tearoff);
}
m_prevRadio = NULL;
// append the title as the very first entry if we have it
if ( !m_title.empty() )
{
Append(wxGTK_TITLE_ID, m_title);
AppendSeparator();
}
}
GtkWidget * AddSubMenu( GtkWidget *window1, const char * immagine_xpm, GtkWidget * Menu,const char * label )
{
GtkWidget * Label = NULL;
GtkWidget * Pixmap = NULL;
GtkWidget * hbox = NULL;
GtkWidget * Item = NULL;
GtkWidget * SubItem = NULL;
GdkPixmap * PixmapIcon = NULL;
GdkColor transparent;
GdkBitmap * MaskIcon = NULL;
PixmapIcon = gdk_pixmap_create_from_xpm_d (window1->window, &MaskIcon, &transparent,(gchar **)immagine_xpm);
Pixmap = gtk_pixmap_new (PixmapIcon, MaskIcon);
gdk_pixmap_unref (PixmapIcon);
SubItem=gtk_menu_item_new();
Item=gtk_menu_new();
Label = gtk_label_new (label);
hbox = gtk_hbox_new (FALSE, 8);
gtk_box_pack_start (GTK_BOX (hbox), Pixmap, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), Label, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (SubItem), hbox);
gtk_menu_append( GTK_MENU( Menu ),SubItem );
gtk_menu_item_set_submenu( GTK_MENU_ITEM( SubItem ),Item );
gtk_widget_show_all( SubItem );
return Item;
}
/*
* create_option_menu:
* @ Create option menu widget.
*
* menu_items : Menu entries.
* def_val : Default value.
* func : Callback function for each menu items.
* data : Pointer to user data for callback function.
* Return : Option menu widget.
*/
GtkWidget *
create_option_menu (const gchar **menu_items, gint def_val,
gpointer func, gpointer data)
{
GtkWidget *option_menu;
GtkWidget *menu_item;
GtkWidget *menu;
gint i;
option_menu = gtk_option_menu_new();
gtk_widget_set_name (option_menu, "/ThumbWin/DispModeOptionMenu");
menu = gtk_menu_new();
for (i = 0; menu_items[i]; i++) {
menu_item = gtk_menu_item_new_with_label (_(menu_items[i]));
g_object_set_data (G_OBJECT (menu_item), "num", GINT_TO_POINTER(i));
g_signal_connect(G_OBJECT(menu_item), "activate",
G_CALLBACK(func),
data);
gtk_menu_append (GTK_MENU(menu), menu_item);
gtk_widget_show (menu_item);
}
gtk_option_menu_set_menu (GTK_OPTION_MENU (option_menu), menu);
gtk_option_menu_set_history (GTK_OPTION_MENU (option_menu), def_val);
return option_menu;
}
/*
* create_option_menu_simple:
* @ Create option menu widget. Return val will store to data.
*
* menu_items : Menu entries.
* def_val : Default value.
* data : Pointer to gint for store return value when a menuitem has been
* selected.
* Return : Option menu widget.
*/
GtkWidget *
create_option_menu_simple (const gchar **menu_items, gint def_val, gint *data)
{
GtkWidget *option_menu;
GtkWidget *menu_item;
GtkWidget *menu;
gint i;
option_menu = gtk_option_menu_new();
menu = gtk_menu_new();
for (i = 0; menu_items[i]; i++) {
menu_item = gtk_menu_item_new_with_label (_(menu_items[i]));
g_object_set_data (G_OBJECT (menu_item), "num", GINT_TO_POINTER(i));
g_signal_connect(G_OBJECT(menu_item), "activate",
G_CALLBACK(cb_get_data_from_menuitem),
data);
gtk_menu_append (GTK_MENU(menu), menu_item);
gtk_widget_show (menu_item);
}
gtk_option_menu_set_menu (GTK_OPTION_MENU (option_menu), menu);
gtk_option_menu_set_history (GTK_OPTION_MENU (option_menu), def_val);
return option_menu;
}
static GtkWidget * AddMenuCheckItem(GtkWidget *window1, const char * immagine_xpm, GtkWidget* Menu,const char* label, gboolean state, int Number)
{
GtkWidget * Label = NULL;
GtkWidget * Pixmap = NULL;
GtkWidget * hbox = NULL;
GtkWidget * Item = NULL;
GdkPixmap *PixmapIcon = NULL;
GdkColor transparent;
GdkBitmap *MaskIcon = NULL;
PixmapIcon = gdk_pixmap_create_from_xpm_d (window1->window, &MaskIcon, &transparent,(gchar **)immagine_xpm );
Pixmap = gtk_pixmap_new (PixmapIcon, MaskIcon);
gdk_pixmap_unref (PixmapIcon);
Item=gtk_check_menu_item_new();
Label = gtk_label_new (label);
hbox = gtk_hbox_new (FALSE, 8);
gtk_box_pack_start (GTK_BOX (hbox), Pixmap, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), Label, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (Item), hbox);
gtk_menu_append( GTK_MENU( Menu ),Item );
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(Item),state);
gtk_signal_connect_object( GTK_OBJECT(Item),"activate",
GTK_SIGNAL_FUNC(ActivateMenuItem),(gpointer)Number );
gtk_menu_item_right_justify (GTK_MENU_ITEM (Item));
gtk_widget_show_all(Item);
return Item;
}
static void CreateAndConnect( intf_thread_t *p_intf,
GtkMenu *menu, const char *psz_var,
const char *text, const char *help,
int i_item_type, vlc_object_t *p_obj,
vlc_value_t val, int i_val_type,
bool checked )
{
GtkMenuItem *menu_item =
(GtkMenuItem *)vlc_menu_item_new (p_obj, i_item_type, val, psz_var );
(void)help; (void)i_val_type;
#if GTK_CHECK_VERSION(2,16,0)
gtk_menu_item_set_label (menu_item, text ? text : psz_var);
#else
GtkWidget *accel_label = gtk_accel_label_new(text ? text : psz_var);
gtk_misc_set_alignment(GTK_MISC (accel_label), 0.0, 0.5);
gtk_container_add (GTK_CONTAINER (menu_item), accel_label);
gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (accel_label), GTK_WIDGET(menu_item));
gtk_widget_show (accel_label);
#endif /* GTK_CHECK_VERSION(2,16,0) */
gtk_menu_append( GTK_WIDGET(menu), GTK_WIDGET(menu_item) );
if( i_item_type == ITEM_CHECK || i_item_type == ITEM_RADIO )
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_item), checked);
g_signal_connect( GTK_OBJECT(menu_item), "activate", G_CALLBACK( menu_callback ),
p_intf );
}
