void MainWindow::createSystemTray()
{
#ifdef UBUNTU_UNITY
AppIndicator *indicator = app_indicator_new("Shadowsocks-Qt5", "shadowsocks-qt5", APP_INDICATOR_CATEGORY_OTHER);
GtkWidget *menu = gtk_menu_new();
showItem = gtk_check_menu_item_new_with_label(tr("Show").toLocal8Bit().constData());
gtk_check_menu_item_set_active((GtkCheckMenuItem*)showItem, true);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), showItem);
g_signal_connect(showItem, "toggled", G_CALLBACK(onShow), qApp);
gtk_widget_show(showItem);
GtkWidget *exitItem = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), exitItem);
g_signal_connect(exitItem, "activate", G_CALLBACK(onQuit), qApp);
gtk_widget_show(exitItem);
app_indicator_set_status(indicator, APP_INDICATOR_STATUS_ACTIVE);
app_indicator_set_menu(indicator, GTK_MENU(menu));
#else
//desktop systray
systrayMenu = new QMenu(this);
systrayMenu->addAction(tr("Show"), this, SLOT(showWindow()));
systrayMenu->addAction(QIcon::fromTheme("application-exit", QIcon::fromTheme("exit")), tr("Quit"), qApp, SLOT(exit()));
systray->setIcon(QIcon(":/icons/icons/shadowsocks-qt5.png"));
systray->setToolTip(QString("Shadowsocks-Qt5"));
systray->setContextMenu(systrayMenu);
connect(systray, &QSystemTrayIcon::activated, this, &MainWindow::onSystrayActivated);
systray->show();
#endif
}
void viewer_add_renderer (Viewer *self, Renderer *renderer, int priority)
{
renderer->priority = priority;
renderer->cmi = gtk_check_menu_item_new_with_label (renderer->name);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (renderer->cmi), renderer->enabled);
g_object_set_data (G_OBJECT (renderer->cmi), "Viewer:plugin", renderer);
g_signal_connect (G_OBJECT (renderer->cmi), "toggled",
G_CALLBACK (on_renderer_enabled_toggled), self);
g_ptr_array_add(self->renderers, renderer);
g_ptr_array_add(self->renderers_sorted, renderer);
g_ptr_array_sort(self->renderers_sorted, renderer_name_compare_function);
// What position in the sorted array is this item?
unsigned int menu_idx = g_ptr_array_find_index(self->renderers_sorted, renderer);
// add the menu item, accounting for the tear-off tab at index 0
gtk_menu_shell_insert (GTK_MENU_SHELL (self->renderers_menu), renderer->cmi, menu_idx + 1);
gtk_widget_show (renderer->cmi);
// create a control widget
if (renderer->widget) {
g_ptr_array_add(self->renderers_sorted_with_controls, renderer);
g_ptr_array_sort(self->renderers_sorted_with_controls, renderer_name_compare_function);
unsigned int control_idx = g_ptr_array_find_index(self->renderers_sorted_with_controls, renderer);
renderer->expander = gtk_expander_new (renderer->name);
gtk_expander_set_expanded (GTK_EXPANDER (renderer->expander), TRUE);
renderer->control_frame = gtk_frame_new (NULL);
if (renderer->enabled) {
gtk_widget_show (renderer->control_frame);
} else {
gtk_widget_hide (renderer->control_frame);
}
gtk_frame_set_label_widget (GTK_FRAME (renderer->control_frame), renderer->expander);
gtk_container_add (GTK_CONTAINER (renderer->control_frame), renderer->widget);
gtk_box_pack_start (GTK_BOX (self->controls_box), renderer->control_frame,
FALSE, TRUE, 0);
gtk_box_reorder_child (GTK_BOX (self->controls_box), renderer->control_frame, control_idx);
gtk_widget_show (renderer->expander);
gtk_widget_show (renderer->widget);
g_signal_connect (G_OBJECT (renderer->expander), "notify::expanded",
G_CALLBACK (on_renderer_widget_expander_notify), self);
g_object_set_data (G_OBJECT (renderer->expander),
"Viewer:plugin", renderer);
g_object_set_data (G_OBJECT (renderer->widget),
"Viewer:expander", renderer->expander);
g_object_set_data (G_OBJECT (renderer->widget),
"Viewer:frame", renderer->control_frame);
}
g_ptr_array_sort(self->renderers, sort_renderers_priority_decreasing);
}
int add_menu_items(char **items) {
int idx,
count = 0,
loc = 7;
GtkWidget *item;
for (idx = 0; items[idx] != NULL; idx++) {
++count;
}
user_menu_items = malloc(sizeof(GtkWidget*) * (count + 2));
user_menu_items[count + 1] = NULL;
for (idx = 0; idx < count; idx++) {
item = gtk_check_menu_item_new_with_label(items[idx]);
user_menu_items[idx] = item;
g_signal_connect(item, "activate", G_CALLBACK(activate_user), NULL);
gtk_menu_shell_insert((GtkMenuShell *)umenu_Indicator_Menu, item, loc);
++loc;
}
if (idx > 0) {
item = gtk_separator_menu_item_new();
g_object_ref((GObject*)item);
gtk_menu_shell_insert((GtkMenuShell *)umenu_Indicator_Menu, item, loc);
user_menu_items[count] = item;
g_object_unref((GObject*)item);
}
return idx;
}
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;
}
void MainWindowToolbarMenu::addToolbarMenuEntry(ToolbarData* d, GtkMenuShell* menubar, int& menuPos)
{
XOJ_CHECK_TYPE(MainWindowToolbarMenu);
GtkWidget* item = gtk_check_menu_item_new_with_label(d->getName().c_str());
gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM(item), true);
gtk_widget_show(item);
gtk_menu_shell_insert(menubar, item, menuPos);
menuitems.push_back(item);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), d == selectedToolbar);
MenuSelectToolbarData* data = new MenuSelectToolbarData(this, item, d, toolbarMenuData.size());
toolbarMenuData.push_back(data);
g_signal_connect(item, "toggled", G_CALLBACK(tbSelectMenuitemActivated), data);
if (inPredefinedSection && !d->isPredefined())
{
GtkWidget* separator = gtk_separator_menu_item_new();
gtk_widget_show(separator);
gtk_menu_shell_insert(menubar, separator, menuPos++);
inPredefinedSection = false;
menuitems.push_back(separator);
}
}
::GtkMenuItem* GtkMenuItem::CreateNative(bool registerNative)
{
::GtkMenuItem* newNativeItem;
if (this->IsSeparator()) {
return (::GtkMenuItem*) gtk_separator_menu_item_new();
} else if (this->IsCheck()) {
newNativeItem = (::GtkMenuItem*) gtk_check_menu_item_new_with_label(label.c_str());
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(newNativeItem), this->state);
} else if (this->iconPath.empty()) {
newNativeItem = (::GtkMenuItem*) gtk_menu_item_new_with_label(label.c_str());
} else {
newNativeItem = (::GtkMenuItem*) gtk_image_menu_item_new_with_label(label.c_str());
GtkWidget* image = gtk_image_new_from_file(this->iconPath.c_str());
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(newNativeItem), image);
}
gtk_widget_set_sensitive(GTK_WIDGET(newNativeItem), this->enabled);
this->SetNativeItemSubmenu(newNativeItem, this->submenu);
g_signal_connect(G_OBJECT(newNativeItem),
"activate", G_CALLBACK(GtkMenus::MenuCallback), this);
if (registerNative)
this->nativeItems.push_back(newNativeItem);
return newNativeItem;
}
// 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;
}
JNIEXPORT jlong JNICALL
Java_org_gnome_gtk_GtkCheckMenuItem_gtk_1check_1menu_1item_1new_1with_1label
(
JNIEnv* env,
jclass cls,
jstring _label
)
{
GtkWidget* result;
jlong _result;
const gchar* label;
// convert parameter label
label = (const gchar*) bindings_java_getString(env, _label);
if (label == NULL) {
return 0L; // Java Exception already thrown
}
// call function
result = gtk_check_menu_item_new_with_label(label);
// cleanup parameter label
bindings_java_releaseString(label);
// translate return value to JNI type
_result = (jlong) result;
// cleanup return value
if (result != NULL) {
bindings_java_memory_cleanup((GObject*)result, TRUE);
}
// and finally
return _result;
}
static void on_show_history_menu(GtkMenuToolButton* btn, FmMainWin* win)
{
GtkMenuShell* menu = (GtkMenuShell*)gtk_menu_tool_button_get_menu(btn);
GList* l;
GList* cur = fm_nav_history_get_cur_link(win->nav_history);
/* delete old items */
gtk_container_foreach(GTK_CONTAINER(menu), (GtkCallback)gtk_widget_destroy, NULL);
for(l = fm_nav_history_list(win->nav_history); l; l=l->next)
{
const FmNavHistoryItem* item = (FmNavHistoryItem*)l->data;
FmPath* path = item->path;
char* str = fm_path_display_name(path, TRUE);
GtkMenuItem* mi;
if( l == cur )
{
mi = gtk_check_menu_item_new_with_label(str);
gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM(mi), TRUE);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mi), TRUE);
}
else
mi = gtk_menu_item_new_with_label(str);
g_free(str);
g_object_set_qdata_full(G_OBJECT(mi), fm_qdata_id, l, NULL);
g_signal_connect(mi, "activate", G_CALLBACK(on_history_item), win);
gtk_menu_shell_append(menu, mi);
}
gtk_widget_show_all( GTK_WIDGET(menu) );
}
GtkWidget *create_tray_menu(MITEM *mitems)
{
GtkWidget *menu = gtk_menu_new ();
int i;
for(i=0; mitems[i].cb; i++) {
GtkWidget *item;
if (!mitems[i].name)
continue;
if (mitems[i].stock_id) {
item = gtk_image_menu_item_new_with_label (_(mitems[i].name));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), gtk_image_new_from_stock(mitems[i].stock_id, GTK_ICON_SIZE_MENU));
}
else
if (mitems[i].check_dat) {
item = gtk_check_menu_item_new_with_label (_(mitems[i].name));
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), *mitems[i].check_dat);
} else
item = gtk_menu_item_new_with_label (_(mitems[i].name));
mitems[i].handler = g_signal_connect (G_OBJECT (item), "activate",
G_CALLBACK (mitems[i].cb), NULL);
gtk_widget_show(item);
mitems[i].item = item;
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
}
return menu;
}
static int gtkItemMapMethod(Ihandle* ih)
{
int pos;
if (!ih->parent)
return IUP_ERROR;
#ifndef HILDON
if (iupMenuIsMenuBar(ih->parent))
ih->handle = gtk_menu_item_new_with_label("");
else
#endif
{
if (iupAttribGet(ih, "IMAGE")||iupAttribGet(ih, "TITLEIMAGE"))
ih->handle = gtk_image_menu_item_new_with_label("");
else if (iupAttribGetBoolean(ih->parent, "RADIO"))
{
GtkRadioMenuItem* last_tg = (GtkRadioMenuItem*)iupAttribGet(ih->parent, "_IUPGTK_LASTRADIOITEM");
if (last_tg)
ih->handle = gtk_radio_menu_item_new_with_label_from_widget(last_tg, "");
else
ih->handle = gtk_radio_menu_item_new_with_label(NULL, "");
iupAttribSetStr(ih->parent, "_IUPGTK_LASTRADIOITEM", (char*)ih->handle);
}
else
{
char* hidemark = iupAttribGetStr(ih, "HIDEMARK");
if (!hidemark && gtk_check_version(2, 14, 0) == NULL)
{
/* force HIDEMARK if VALUE is defined before Map, after GTK 2.14 */
if (!iupAttribGet(ih, "VALUE"))
hidemark = "YES";
}
if (iupStrBoolean(hidemark))
ih->handle = gtk_menu_item_new_with_label("");
else
ih->handle = gtk_check_menu_item_new_with_label("");
}
}
if (!ih->handle)
return IUP_ERROR;
ih->serial = iupMenuGetChildId(ih);
g_signal_connect(G_OBJECT(ih->handle), "select", G_CALLBACK(gtkItemSelect), ih);
g_signal_connect(G_OBJECT(ih->handle), "activate", G_CALLBACK(gtkItemActivate), ih);
pos = IupGetChildPos(ih->parent, ih);
gtk_menu_shell_insert((GtkMenuShell*)ih->parent->handle, ih->handle, pos);
gtk_widget_show(ih->handle);
iupUpdateStandardFontAttrib(ih);
return IUP_NOERROR;
}
static void menu_init ()
{
Menu = gtk_menu_new ();
gchar *xdg_music_path = (gchar*)g_get_user_special_dir (G_USER_DIRECTORY_MUSIC);
if (!xdg_music_path)
return;
GtkWidget* item = path_to_menu (xdg_music_path);
gtk_menu_append (Menu, item);
gtk_widget_show_all (item);
/* Line */
item = gtk_separator_menu_item_new ();
gtk_menu_append (Menu, item);
gtk_widget_show_all (item);
/* Shuffle */
item = gtk_check_menu_item_new_with_label ("Shuffle");
gtk_menu_append (Menu, item);
g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (call_shuffle), NULL);
gtk_widget_show_all (item);
/* Play/pause */
item = gtk_menu_item_new_with_label ("Play/Pause");
gtk_menu_append (Menu, item);
g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (play_or_pause), NULL);
gtk_widget_show_all (item);
/* Stop */
item = gtk_menu_item_new_with_label ("Stop");
gtk_menu_append (Menu, item);
g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (stop), NULL);
gtk_widget_show_all (item);
/* Previous */
item = gtk_menu_item_new_with_label ("Prev track");
gtk_menu_append (Menu, item);
g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (prev_track), NULL);
gtk_widget_show_all (item);
/* Next */
item = gtk_menu_item_new_with_label ("Next track");
gtk_menu_append (Menu, item);
g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (next_track), NULL);
gtk_widget_show_all (item);
/* Quit */
item = gtk_menu_item_new_with_label ("Quit");
gtk_menu_append (Menu, item);
g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (quit), NULL);
gtk_widget_show_all (item);
app_indicator_set_menu (Indicator, GTK_MENU (Menu));
}
static gboolean
goio_console_populate_device_menu (GtkWidget *menu, GObject *interface)
{
GtkWidget *sub_menu;
GtkWidget *menu_item;
GList *devices = NULL;
GList *iter;
gboolean bNone = TRUE;
GValue gvalpointer = {G_TYPE_INVALID};
g_value_init (&gvalpointer, G_TYPE_POINTER);
g_object_get_property (interface, "devices", &gvalpointer);
devices = (GList*) g_value_get_pointer (&gvalpointer);
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));
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 = devices; iter; iter = g_list_next (iter))
{
GValue gval = {G_TYPE_INVALID};
g_value_init (&gval, G_TYPE_STRING);
g_object_get_property (iter->data, "display-name", &gval);
bNone = FALSE;
menu_item = gtk_check_menu_item_new_with_label (g_value_get_string (&gval));
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item), ngi_device_connected (NGI_DEVICE (iter->data)));
gtk_menu_shell_append (GTK_MENU_SHELL (sub_menu), menu_item);
g_signal_connect (G_OBJECT (menu_item), "activate",
G_CALLBACK (goio_console_device_selected),
iter->data);
gtk_widget_show (menu_item);
}
if (bNone)
{
menu_item = gtk_menu_item_new_with_label ("none");
gtk_menu_shell_append (GTK_MENU_SHELL (sub_menu), menu_item);
gtk_widget_show (menu_item);
}
return TRUE;
}
static void
view_popup_menu(GtkButton * button, GdkEventButton * event,
GtkTreeViewColumn * column)
{
GtkWidget *tv = gtk_tree_view_column_get_tree_view(column);
TrgTreeViewPrivate *priv = TRG_TREE_VIEW_GET_PRIVATE(tv);
GtkWidget *menu, *menuitem;
trg_column_description *desc;
guint n_showing = 0;
GList *li;
menu = gtk_menu_new();
desc = g_object_get_data(G_OBJECT(column), GDATA_KEY_COLUMN_DESC);
for (li = priv->columns; li; li = g_list_next(li)) {
trg_column_description *desc = (trg_column_description *) li->data;
if (!(desc->flags & TRG_COLUMN_SHOWING)) {
menuitem = gtk_check_menu_item_new_with_label(desc->header);
g_object_set_data(G_OBJECT(menuitem), "parent-col", column);
g_signal_connect(menuitem, "activate",
G_CALLBACK(trg_tree_view_user_add_column_cb),
desc);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
} else {
n_showing++;
}
}
menuitem = gtk_check_menu_item_new_with_label(desc->header);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem), TRUE);
g_signal_connect(menuitem, "activate",
G_CALLBACK(trg_tree_view_hide_column), column);
gtk_widget_set_sensitive(menuitem,
!(desc->flags & TRG_COLUMN_UNREMOVABLE) && n_showing > 1);
gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), menuitem);
gtk_widget_show_all(menu);
gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL,
(event != NULL) ? event->button : 0,
gdk_event_get_time((GdkEvent *) event));
}
void mssh_terminal_init_session(MSSHTerminal *terminal, char *hostname)
{
terminal->hostname = hostname;
terminal->menu_item = gtk_check_menu_item_new_with_label(
terminal->hostname);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(
terminal->menu_item), TRUE);
}
int main (int argc, char *argv[]) {
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *menubar;
GtkWidget *viewmenu;
GtkWidget *view;
GtkWidget *tog_stat;
GtkWidget *statusbar;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_default_size(GTK_WINDOW(window), 250, 200);
gtk_window_set_title(GTK_WINDOW(window), "view statusbar");
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), vbox);
menubar = gtk_menu_bar_new();
viewmenu = gtk_menu_new();
view = gtk_menu_item_new_with_label("View");
// check menu item
tog_stat = gtk_check_menu_item_new_with_label ("View Statusbar");
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(tog_stat), TRUE);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(view), viewmenu);
gtk_menu_shell_append(GTK_MENU_SHELL(viewmenu), tog_stat);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), view);
gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 3);
statusbar = gtk_statusbar_new();
gtk_box_pack_end(GTK_BOX(vbox), statusbar, FALSE, TRUE, 1);
g_signal_connect_swapped(G_OBJECT(window), "destroy",
G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(G_OBJECT(tog_stat), "activate",
G_CALLBACK(toggle_statusbar), statusbar);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
// runs in main thread, should always return FALSE to prevent gtk to execute it again
gboolean do_add_or_update_menu_item(gpointer data) {
MenuItemInfo *mii = (MenuItemInfo*)data;
GList* it;
for(it = global_menu_items; it != NULL; it = it->next) {
MenuItemNode* item = (MenuItemNode*)(it->data);
if(item->menu_id == mii->menu_id){
gtk_menu_item_set_label(GTK_MENU_ITEM(item->menu_item), mii->title);
if(mii->checkable == 1) {
gtk_check_menu_item_set_active((GtkCheckMenuItem*)(item->menu_item), mii->checked == 1);
}
break;
}
}
// menu id doesn't exist, add new item
if(it == NULL) {
GtkWidget *menu_item;
int *id = malloc(sizeof(int));
*id = mii->menu_id;
if(mii->checkable) {
menu_item = gtk_check_menu_item_new_with_label(mii->title);
gtk_check_menu_item_set_active((GtkCheckMenuItem*)(menu_item), mii->checked == 1);
g_signal_connect_swapped(G_OBJECT(menu_item), "toggled", G_CALLBACK(_systray_menu_item_changed), id);
} else {
menu_item = gtk_menu_item_new_with_label(mii->title);
g_signal_connect_swapped(G_OBJECT(menu_item), "activate", G_CALLBACK(_systray_menu_item_selected), id);
}
gtk_menu_shell_append(GTK_MENU_SHELL(global_tray_menu), menu_item);
MenuItemNode* new_item = malloc(sizeof(MenuItemNode));
new_item->menu_id = mii->menu_id;
new_item->menu_item = menu_item;
GList* new_node = malloc(sizeof(GList));
new_node->data = new_item;
new_node->next = global_menu_items;
if(global_menu_items != NULL) {
global_menu_items->prev = new_node;
}
global_menu_items = new_node;
it = new_node;
}
GtkWidget * menu_item = GTK_WIDGET(((MenuItemNode*)(it->data))->menu_item);
gtk_widget_set_sensitive(menu_item, mii->disabled == 1 ? FALSE : TRUE);
gtk_widget_show(menu_item);
free(mii->title);
free(mii->tooltip);
free(mii);
return FALSE;
}
static GtkWidget *build_roll_menu(void)
{
GtkWidget *menu;
gint i;
gchar buffer[128];
MapTheme *theme = theme_get_current();
THEME_COLOR tcolor;
GdkColor *color;
GtkWidget *item;
GtkWidget *label;
menu = gtk_menu_new();
for (i = 2; i <= 12; i++) {
if (i == 7)
continue;
tcolor = (i == 6 || i == 8) ? TC_CHIP_H_FG : TC_CHIP_FG;
color = &theme->colors[tcolor].color;
sprintf(buffer,
"<span foreground=\"#%04x%04x%04x\">%d</span>",
color->red, color->green, color->blue, i);
item = gtk_check_menu_item_new();
label = gtk_label_new("");
gtk_label_set_markup(GTK_LABEL(label), buffer);
gtk_container_add(GTK_CONTAINER(item), label);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
g_signal_connect(G_OBJECT(item), "toggled",
G_CALLBACK(select_roll_cb),
GINT_TO_POINTER(i));
gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM
(item), TRUE);
roll_numbers[i] = item;
}
gtk_menu_shell_append(GTK_MENU_SHELL(menu),
gtk_separator_menu_item_new());
/* Menu item */
item = gtk_check_menu_item_new_with_label(_("Shuffle"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
g_signal_connect(G_OBJECT(item), "toggled",
G_CALLBACK(select_shuffle_cb), NULL);
shuffle_tile = GTK_CHECK_MENU_ITEM(item);
gtk_widget_show_all(menu);
return menu;
}
GtkWidget *
menu_toggle_item (char *label, GtkWidget *menu, void *callback, void *userdata,
int state)
{
GtkWidget *item;
item = gtk_check_menu_item_new_with_label (label);
gtk_check_menu_item_set_active ((GtkCheckMenuItem*)item, state);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
g_signal_connect (G_OBJECT (item), "activate",
G_CALLBACK (callback), userdata);
gtk_widget_show (item);
return item;
}
static void
seach_entry_populate_popup (GtkEntry *entry, PraghaPreferences *preferences)
{
GtkWidget *popup_menu, *item;
gboolean instant_search, approximate_search;
popup_menu = gtk_menu_new ();
/* Instant search. */
item = gtk_check_menu_item_new_with_label (_("Refine the search while writing"));
gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), item);
instant_search = pragha_preferences_get_instant_search(preferences);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), instant_search);
g_signal_connect (G_OBJECT (item), "toggled",
G_CALLBACK (search_entry_instant_option_toggled), preferences);
gtk_widget_show (item);
/* Aproximate search. */
item = gtk_check_menu_item_new_with_label (_("Search approximate words"));
gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), item);
approximate_search = pragha_preferences_get_approximate_search(preferences);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), approximate_search);
g_signal_connect (G_OBJECT (item), "toggled",
G_CALLBACK (search_entry_approximate_option_toggled), preferences);
gtk_widget_show (item);
gtk_menu_attach_to_widget(GTK_MENU(popup_menu), GTK_WIDGET(entry), NULL);
gtk_menu_popup(GTK_MENU(popup_menu), NULL, NULL,
(GtkMenuPositionFunc) menu_position, entry,
0, gtk_get_current_event_time());
}
GtkWidget *
add_menu_check_button (GtkWidget * menu,
gchar * label,
gboolean state, GtkSignalFunc func, gpointer data)
{
GtkWidget *check;
check = gtk_check_menu_item_new_with_label (label);
gtk_signal_connect (GTK_OBJECT (check), "activate", func, data);
gtk_menu_append (GTK_MENU (menu), check);
gtk_check_menu_item_set_state (GTK_CHECK_MENU_ITEM (check), state);
gtk_check_menu_item_set_show_toggle (GTK_CHECK_MENU_ITEM (check), TRUE);
gtk_widget_show (check);
return check;
}
/*
* Create the menu items needed for the main view.
* This needs to be implemented properly.
*/
static void create_menu(HildonWindow * main_window)
{
/* Create needed variables */
GtkWidget *main_menu;
GtkWidget *menu_others;
GtkWidget *item_others;
GtkWidget *item_radio1;
GtkWidget *item_radio2;
GtkWidget *item_check;
GtkWidget *item_close;
GtkWidget *item_separator;
/* Create new main menu */
main_menu = gtk_menu_new();
/* Create new submenu for "Others" */
menu_others = gtk_menu_new();
/* Create menu items */
item_others = gtk_menu_item_new_with_label("Others");
item_radio1 = gtk_radio_menu_item_new_with_label(NULL, "Radio1");
item_radio2 =
gtk_radio_menu_item_new_with_label_from_widget(GTK_RADIO_MENU_ITEM
(item_radio1),
"Radio2");
item_check = gtk_check_menu_item_new_with_label("Check");
item_close = gtk_menu_item_new_with_label("Close");
item_separator = gtk_separator_menu_item_new();
/* Add menu items to right menus */
gtk_menu_append(main_menu, item_others);
gtk_menu_append(menu_others, item_radio1);
gtk_menu_append(menu_others, item_radio2);
gtk_menu_append(menu_others, item_separator);
gtk_menu_append(menu_others, item_check);
gtk_menu_append(main_menu, item_close);
/* Add others submenu to the "Others" item */
hildon_window_set_menu(HILDON_WINDOW(main_window), GTK_MENU(main_menu));
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_others), menu_others);
/* Attach the callback functions to the activate signal */
g_signal_connect(G_OBJECT(item_close), "activate",
GTK_SIGNAL_FUNC(item_close_cb), NULL);
/* Make all menu widgets visible */
gtk_widget_show_all(GTK_WIDGET(main_menu));
}
static GtkWidget *build_port_menu(void)
{
gint i;
GtkWidget *item;
GdkPixmap *pixmap;
GtkWidget *image;
GtkWidget *menu;
MapTheme *theme = theme_get_current();
menu = gtk_menu_new();
for (i = 0; i <= ANY_RESOURCE; i++) {
item =
gtk_image_menu_item_new_with_mnemonic(gettext
(port_names[i]));
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
g_signal_connect(G_OBJECT(item), "activate",
G_CALLBACK(select_port_resource_cb),
GINT_TO_POINTER(i));
pixmap = theme->port_tiles[i];
if (i >= NO_RESOURCE || pixmap == NULL)
continue;
image = gtk_image_new_from_pixmap(pixmap, NULL);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item),
image);
}
gtk_menu_shell_append(GTK_MENU_SHELL(menu),
gtk_separator_menu_item_new());
for (i = 0; i < 6; i++) {
item =
gtk_check_menu_item_new_with_label(Q_
(port_direction_names
[i]));
gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM
(item), TRUE);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
g_signal_connect(G_OBJECT(item), "toggled",
G_CALLBACK(select_port_direction_cb),
GINT_TO_POINTER(i));
port_directions[i] = item;
}
gtk_widget_show_all(menu);
return menu;
}
static
GtkWidget *
convert_menu(const struct PP_Flash_Menu *pp_menu)
{
GtkWidget *menu = gtk_menu_new();
for (uintptr_t k = 0; k < pp_menu->count; k ++) {
const struct PP_Flash_MenuItem pp_mi = pp_menu->items[k];
GtkWidget *mi = NULL;
switch (pp_mi.type) {
case PP_FLASH_MENUITEM_TYPE_NORMAL:
mi = gtk_menu_item_new_with_label(pp_mi.name);
break;
case PP_FLASH_MENUITEM_TYPE_CHECKBOX:
mi = gtk_check_menu_item_new_with_label(pp_mi.name);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mi), pp_mi.checked != PP_FALSE);
break;
case PP_FLASH_MENUITEM_TYPE_SEPARATOR:
mi = gtk_separator_menu_item_new();
break;
case PP_FLASH_MENUITEM_TYPE_SUBMENU:
mi = gtk_menu_item_new_with_label(pp_mi.name);
break;
}
if (!mi)
continue;
gtk_widget_set_sensitive(mi, pp_mi.enabled != PP_FALSE);
gtk_widget_show(mi);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);
if (pp_mi.type == PP_FLASH_MENUITEM_TYPE_SUBMENU) {
gtk_menu_item_set_submenu(GTK_MENU_ITEM(mi), convert_menu(pp_mi.submenu));
} else {
// each menu item have specific id associated
g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menu_item_activated),
(void*)(size_t)pp_mi.id);
// connect "button-press-event" to workaround submenu "activate" signal missing issue
g_signal_connect(G_OBJECT(mi), "button-press-event", G_CALLBACK(menu_item_button_press),
(void*)(size_t)pp_mi.id);
}
}
return menu;
}
int main(int argc, char *argv[])
{
QwertickleGUI* gui = g_new0(QwertickleGUI, 1);
gst_init(NULL, NULL);
gtk_init(&argc, &argv);
gui->statusicon = gtk_status_icon_new_from_file(DATADIR"/qwertickle.png");
gtk_status_icon_set_visible(gui->statusicon, TRUE);
gui->mainmenu = GTK_MENU(gtk_menu_new());
gui->play = GTK_MENU_ITEM(gtk_menu_item_new());
gui->sep = GTK_SEPARATOR_MENU_ITEM(gtk_separator_menu_item_new());
gui->quit =
GTK_IMAGE_MENU_ITEM(gtk_image_menu_item_new_from_stock("gtk-quit", NULL));
gui->about =
GTK_IMAGE_MENU_ITEM(gtk_image_menu_item_new_from_stock("gtk-about", NULL));
gui->enable =
GTK_CHECK_MENU_ITEM(gtk_check_menu_item_new_with_label("Enable"));
gtk_menu_shell_append(GTK_MENU_SHELL(gui->mainmenu), GTK_WIDGET(gui->enable));
gtk_menu_shell_append(GTK_MENU_SHELL(gui->mainmenu), GTK_WIDGET(gui->about));
gtk_menu_shell_append(GTK_MENU_SHELL(gui->mainmenu), GTK_WIDGET(gui->sep));
gtk_menu_shell_append(GTK_MENU_SHELL(gui->mainmenu), GTK_WIDGET(gui->quit));
/* initialize widgets */
gtk_check_menu_item_set_active(gui->enable, TRUE);
/* connect signals */
g_signal_connect(gui->statusicon, "popup-menu", G_CALLBACK(on_menu_pop), gui);
g_signal_connect(gui->enable, "toggled", G_CALLBACK(on_enable_toggled), gui);
g_signal_connect(gui->quit, "activate", G_CALLBACK(on_quit_activate), gui);
g_signal_connect(gui->about, "activate", G_CALLBACK(on_about_activate), gui);
g_signal_connect(gui->play, "activate", G_CALLBACK(on_play_activate), NULL);
gtk_widget_show_all(GTK_WIDGET(gui->mainmenu));
/* Fix freezing bug? close stdout and stdin so Xorg won't have to process
* the input to stdout when program exit*/
close(0);
close(1);
pthread_create(&thread, NULL, intercept_key_thread, gui->play);
gtk_main();
return 0;
}
GtkWidget *CreateMenuCheck (GtkWidget *menu,
char *szName,
GtkSignalFunc func,
gpointer data)
{
GtkWidget *menuitem;
menuitem = gtk_check_menu_item_new_with_label (szName);
gtk_menu_append (GTK_MENU (menu), menuitem);
gtk_widget_show (menuitem);
gtk_signal_connect (GTK_OBJECT (menuitem), "toggled",
GTK_SIGNAL_FUNC(func), data);
return (menuitem);
}
static void
remmina_icon_populate_additional_menu_item (GtkWidget *menu)
{
GtkWidget *menuitem;
menuitem = gtk_image_menu_item_new_with_label (_("Open Main Window"));
gtk_widget_show (menuitem);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem),
gtk_image_new_from_icon_name ("remmina", GTK_ICON_SIZE_MENU));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK (remmina_icon_main), NULL);
menuitem = gtk_image_menu_item_new_from_stock (GTK_STOCK_PREFERENCES, NULL);
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK (remmina_icon_preferences), NULL);
menuitem = gtk_image_menu_item_new_from_stock (GTK_STOCK_ABOUT, NULL);
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK (remmina_icon_about), NULL);
menuitem = gtk_separator_menu_item_new ();
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
#ifdef HAVE_LIBAVAHI_CLIENT
menuitem = gtk_check_menu_item_new_with_label (_("Enable Service Discovery"));
if (remmina_pref.applet_enable_avahi)
{
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menuitem), TRUE);
}
gtk_widget_show (menuitem);
g_signal_connect (G_OBJECT (menuitem), "toggled", G_CALLBACK (remmina_icon_enable_avahi), NULL);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
#endif
menuitem = gtk_separator_menu_item_new ();
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
menuitem = gtk_image_menu_item_new_from_stock (GTK_STOCK_QUIT, NULL);
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK (remmina_icon_destroy), NULL);
}
static void
overview_ui_add_menu_item (void)
{
static const gchar *view_menu_name = "menu_view1_menu";
static const gchar *prev_item_name = "menu_show_sidebar1";
GtkWidget *main_window = geany_data->main_widgets->window;
GtkWidget *view_menu;
GtkWidget *prev_item;
gint item_pos;
gboolean visible = FALSE;
view_menu = ui_lookup_widget (main_window, view_menu_name);
if (! GTK_IS_MENU (view_menu))
{
g_critical ("failed to locate the View menu (%s) in Geany's main menu",
view_menu_name);
return;
}
overview_ui_menu_item = gtk_check_menu_item_new_with_label (_("Show Overview"));
prev_item = ui_lookup_widget (main_window, prev_item_name);
if (! GTK_IS_MENU_ITEM (prev_item))
{
g_critical ("failed to locate the Show Sidebar menu item (%s) in Geany's UI",
prev_item_name);
overview_ui_menu_sep = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL (view_menu), overview_ui_menu_sep);
gtk_menu_shell_append (GTK_MENU_SHELL (view_menu), overview_ui_menu_item);
gtk_widget_show (overview_ui_menu_sep);
}
else
{
item_pos = overview_ui_get_menu_item_pos (view_menu, prev_item);
overview_ui_menu_sep = NULL;
gtk_menu_shell_insert (GTK_MENU_SHELL (view_menu), overview_ui_menu_item, item_pos);
}
g_object_get (overview_ui_prefs, "visible", &visible, NULL);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (overview_ui_menu_item), visible);
g_object_bind_property (overview_ui_menu_item, "active",
overview_ui_prefs, "visible",
G_BINDING_DEFAULT);
gtk_widget_show (overview_ui_menu_item);
}
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GtkCheckboxMenuItemPeer_create
(JNIEnv *env, jobject obj, jstring label)
{
GtkWidget *widget;
const char *str;
str = (*env)->GetStringUTFChars (env, label, NULL);
gdk_threads_enter ();
widget = gtk_check_menu_item_new_with_label (str);
gtk_check_menu_item_set_show_toggle (GTK_CHECK_MENU_ITEM (widget), 1);
gtk_widget_show (widget);
gdk_threads_leave ();
(*env)->ReleaseStringUTFChars (env, label, str);
NSA_SET_PTR (env, obj, widget);
}
GtkWidget *
empathy_contact_favourite_menu_item_new (EmpathyContact *contact)
{
GtkWidget *item;
EmpathyContactManager *manager;
item = gtk_check_menu_item_new_with_label (_("Favorite"));
manager = empathy_contact_manager_dup_singleton ();
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item),
empathy_contact_list_is_favourite (EMPATHY_CONTACT_LIST (manager),
contact));
g_signal_connect (item, "toggled",
G_CALLBACK (favourite_menu_item_toggled_cb),
contact);
g_object_unref (manager);
return item;
}
