static GtkWidget *
create_menu_item (GtkAction* action) {
GtkWidget* menu;
GtkWidget* menu_item;
GList* actions = XDIFF_EXT_SUBMENU_ACTION(action)->actions;
menu = gtk_menu_new ();
while(actions) {
GtkAction* a = GTK_ACTION(actions->data);
if(a != NULL) {
menu_item = gtk_action_create_menu_item(a);
gtk_widget_show(menu_item);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
} else {
GtkWidget* s = gtk_separator_menu_item_new();
gtk_widget_show(s);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), s);
}
actions = g_list_next(actions);
}
gtk_widget_show(menu);
menu_item = GTK_ACTION_CLASS(parent_class)->create_menu_item(action);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_item), menu);
gtk_widget_show(menu_item);
return menu_item;
}
static GtkWidget *browserWindowCreateBackForwardMenu(BrowserWindow *window, GList *list)
{
if (!list)
return NULL;
GtkWidget *menu = gtk_menu_new();
GList *listItem;
for (listItem = list; listItem; listItem = g_list_next(listItem)) {
WebKitBackForwardListItem *item = (WebKitBackForwardListItem *)listItem->data;
const char *uri = webkit_back_forward_list_item_get_uri(item);
const char *title = webkit_back_forward_list_item_get_title(item);
GtkAction *action = gtk_action_new(uri, title, NULL, NULL);
g_object_set_data_full(G_OBJECT(action), "back-forward-list-item", g_object_ref(item), g_object_unref);
g_signal_connect_swapped(action, "activate", G_CALLBACK(browserWindowHistoryItemActivated), window);
GtkWidget *menuItem = gtk_action_create_menu_item(action);
g_signal_connect_swapped(menuItem, "select", G_CALLBACK(browserWindowHistoryItemSelected), window);
g_object_unref(action);
gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), menuItem);
gtk_widget_show(menuItem);
}
g_signal_connect(menu, "hide", G_CALLBACK(resetStatusText), window);
return menu;
}
gboolean
_gtk_tool_item_create_menu_proxy (GtkToolItem *item)
{
GtkWidget *menu_item;
gboolean visible_overflown;
if (item->priv->action)
{
g_object_get (item->priv->action, "visible-overflown", &visible_overflown, NULL);
if (visible_overflown)
{
menu_item = gtk_action_create_menu_item (item->priv->action);
g_object_ref_sink (menu_item);
gtk_tool_item_set_proxy_menu_item (item, "gtk-action-menu-item", menu_item);
g_object_unref (menu_item);
}
else
gtk_tool_item_set_proxy_menu_item (item, "gtk-action-menu-item", NULL);
return TRUE;
}
return FALSE;
}
/*!
\param toolbar object add to it
\param name name of the action and also display it in tooltip
\param icon_path Address of the icon (It can be NULL)
*/
GtkAction*
ijadi_gui_create_action_menu (GtkWidget *menu,const gchar *name)
{
GtkAction *action = gtk_action_new(name, name,name,NULL);
GtkWidget *menuItem = gtk_action_create_menu_item(action);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuItem);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuItem), NULL);
return action;
}
/*
* For application-level menu additions.
*/
void
fm__add_menu_item(GtkAction* action)
{
AyyiFilemanager* fm = file_manager__get();
GtkWidget* menu_item = gtk_action_create_menu_item(action);
gtk_menu_shell_append(GTK_MENU_SHELL(fm->menu), menu_item);
gtk_widget_show(menu_item);
}
int main(int argc, char *argv[])
{
gtk_init(&argc, &argv);
GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(window), 200, 200);
g_signal_connect(window, "destroy", G_CALLBACK(destroy), NULL);
GtkWidget *menubar = gtk_menu_bar_new();
gtk_container_add(GTK_CONTAINER(window), menubar);
GtkActionGroup *actiongroup = gtk_action_group_new("ActionGroup");
GtkAction *action = gtk_action_new("actionFile", "_File", NULL, NULL);
gtk_action_group_add_action(GTK_ACTION_GROUP(actiongroup), action);
GtkWidget *menuitemFile = gtk_action_create_menu_item(GTK_ACTION(action));
gtk_menu_bar_append(GTK_MENU_BAR(menubar), menuitemFile);
GtkWidget *menu = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitemFile), menu);
GtkToggleAction *toggleaction;
toggleaction = gtk_toggle_action_new("actionNew", "_New", "Create a new document", GTK_STOCK_NEW);
gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(toggleaction), TRUE);
gtk_action_group_add_action(GTK_ACTION_GROUP(actiongroup), GTK_ACTION(toggleaction));
GtkWidget *menuitemNew = gtk_action_create_menu_item(GTK_ACTION(toggleaction));
gtk_menu_append(GTK_MENU(menu), menuitemNew);
toggleaction = gtk_toggle_action_new("actionOpen", "_Open", "Open a file", GTK_STOCK_OPEN);
gtk_action_group_add_action(GTK_ACTION_GROUP(actiongroup), GTK_ACTION(toggleaction));
GtkWidget *menuitemOpen = gtk_action_create_menu_item(GTK_ACTION(toggleaction));
gtk_menu_append(GTK_MENU(menu), menuitemOpen);
toggleaction = gtk_toggle_action_new("actionSave", "_Save", "Save a file", GTK_STOCK_SAVE);
gtk_action_group_add_action(GTK_ACTION_GROUP(actiongroup), GTK_ACTION(toggleaction));
GtkWidget *menuitemSave = gtk_action_create_menu_item(GTK_ACTION(toggleaction));
gtk_menu_append(GTK_MENU(menu), menuitemSave);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
void GtkPopupMenu::appendItem(GtkAction* action)
{
GtkWidget* menuItem = gtk_action_create_menu_item(action);
gtk_widget_set_tooltip_text(menuItem, gtk_action_get_tooltip(action));
g_signal_connect(menuItem, "select", G_CALLBACK(GtkPopupMenu::selectItemCallback), this);
gtk_menu_shell_append(GTK_MENU_SHELL(m_popup.get()), menuItem);
if (gtk_action_is_visible(action))
gtk_widget_show(menuItem);
}
static GtkWidget *add_item(GtkWidget *menu, GtkAccelGroup *accelgrp,
GtkActionGroup *actions, const char *name)
{
GtkAction *action;
GtkWidget *item;
action = gtk_action_group_get_action(actions, name);
g_return_val_if_fail(action != NULL, NULL);
gtk_action_set_accel_group(action, accelgrp);
item = gtk_action_create_menu_item(action);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
gtk_widget_show(item);
return item;
}
void WebPopupMenuProxyGtk::populatePopupMenu(const Vector<WebPopupItem>& items)
{
int itemIndex = 0;
for (const auto& item : items) {
if (item.m_type == WebPopupItem::Separator) {
GtkWidget* menuItem = gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(m_popup), menuItem);
gtk_widget_show(menuItem);
} else {
GRefPtr<GtkAction> action = adoptGRef(createGtkActionForMenuItem(item, itemIndex));
GtkWidget* menuItem = gtk_action_create_menu_item(action.get());
gtk_widget_set_tooltip_text(menuItem, gtk_action_get_tooltip(action.get()));
g_signal_connect(menuItem, "select", G_CALLBACK(selectItemCallback), this);
gtk_menu_shell_append(GTK_MENU_SHELL(m_popup), menuItem);
if (gtk_action_is_visible(action.get()))
gtk_widget_show(menuItem);
}
itemIndex++;
}
}
static gboolean
create_popup_menu_item (GeditCollaborationWindowHelper *helper,
GtkMenu *menu,
const gchar *id,
gboolean create_separator)
{
GtkAction *action;
GtkWidget *item;
GtkActionGroup *ac;
action = get_action (helper, id);
g_object_get (action, "action-group", &ac, NULL);
if (!gtk_action_get_sensitive (action) ||
!gtk_action_group_get_sensitive (ac))
{
g_object_unref (ac);
return FALSE;
}
gtk_action_set_accel_group (action,
gtk_ui_manager_get_accel_group (helper->priv->uimanager));
g_object_unref (ac);
if (create_separator)
{
item = gtk_separator_menu_item_new ();
gtk_widget_show (item);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
}
item = gtk_action_create_menu_item (action);
gtk_widget_show (item);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
return TRUE;
}
/*! \brief Translate a resource tree into a menu structure
*
* \param [in] menu The GHidMainMenu widget to be acted on
* \param [in] shall The base menu shell (a menu bar or popup menu)
* \param [in] res The base of the resource tree
* */
void
ghid_main_menu_real_add_resource (GHidMainMenu *menu, GtkMenuShell *shell,
const Resource *res)
{
int i, j;
const Resource *tmp_res;
gchar mnemonic = 0;
for (i = 0; i < res->c; ++i)
{
const gchar *accel = NULL;
char *menu_label;
const char *res_val;
const Resource *sub_res = res->v[i].subres;
GtkAction *action = NULL;
switch (resource_type (res->v[i]))
{
case 101: /* name, subres: passthrough */
ghid_main_menu_real_add_resource (menu, shell, sub_res);
break;
case 1: /* no name, subres */
tmp_res = resource_subres (sub_res, "a"); /* accelerator */
res_val = resource_value (sub_res, "m"); /* mnemonic */
if (res_val)
mnemonic = res_val[0];
/* The accelerator resource will have two values, like
* a={"Ctrl-Q" "Ctrl<Key>q"}
* The first Gtk ignores. The second needs to be translated. */
if (tmp_res)
accel = check_unique_accel
(translate_accelerator (tmp_res->v[1].value));
/* Now look for the first unnamed value (not a subresource) to
* figure out the name of the menu or the menuitem. */
res_val = "button";
for (j = 0; j < sub_res->c; ++j)
if (resource_type (sub_res->v[j]) == 10)
{
res_val = _(sub_res->v[j].value);
break;
}
/* Hack '_' in based on mnemonic value */
if (!mnemonic)
menu_label = g_strdup (res_val);
else
{
char *post_ = strchr (res_val, mnemonic);
if (post_ == NULL)
menu_label = g_strdup (res_val);
else
{
GString *tmp = g_string_new ("");
g_string_append_len (tmp, res_val, post_ - res_val);
g_string_append_c (tmp, '_');
g_string_append (tmp, post_);
menu_label = g_string_free (tmp, FALSE);
}
}
/* If the subresource we're processing also has unnamed
* subresources, it's a submenu, not a regular menuitem. */
if (sub_res->flags & FLAG_S)
{
/* SUBMENU */
GtkWidget *submenu = gtk_menu_new ();
GtkWidget *item = gtk_menu_item_new_with_mnemonic (menu_label);
GtkWidget *tearoff = gtk_tearoff_menu_item_new ();
gtk_menu_shell_append (shell, item);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), submenu);
/* add tearoff to menu */
gtk_menu_shell_append (GTK_MENU_SHELL (submenu), tearoff);
/* recurse on the newly-added submenu */
ghid_main_menu_real_add_resource (menu,
GTK_MENU_SHELL (submenu),
sub_res);
}
else
{
/* NON-SUBMENU: MENU ITEM */
const char *checked = resource_value (sub_res, "checked");
const char *label = resource_value (sub_res, "sensitive");
const char *tip = resource_value (sub_res, "tip");
if (checked)
{
/* TOGGLE ITEM */
gchar *name = g_strdup_printf ("MainMenuAction%d",
action_counter++);
action = GTK_ACTION (gtk_toggle_action_new (name, menu_label,
tip, NULL));
/* checked=foo is a binary flag (checkbox)
* checked=foo,bar is a flag compared to a value (radio) */
gtk_toggle_action_set_draw_as_radio
(GTK_TOGGLE_ACTION (action), !!strchr (checked, ','));
}
else if (label && strcmp (label, "false") == 0)
{
/* INSENSITIVE ITEM */
GtkWidget *item = gtk_menu_item_new_with_label (menu_label);
gtk_widget_set_sensitive (item, FALSE);
gtk_menu_shell_append (shell, item);
}
else
{
/* NORMAL ITEM */
gchar *name = g_strdup_printf ("MainMenuAction%d", action_counter++);
action = gtk_action_new (name, menu_label, tip, NULL);
}
}
/* Connect accelerator, if there is one */
if (action)
{
GtkWidget *item;
gtk_action_set_accel_group (action, menu->accel_group);
gtk_action_group_add_action_with_accel (menu->action_group,
action, accel);
gtk_action_connect_accelerator (action);
g_signal_connect (G_OBJECT (action), "activate", menu->action_cb,
(gpointer) sub_res);
g_object_set_data (G_OBJECT (action), "resource",
(gpointer) sub_res);
item = gtk_action_create_menu_item (action);
gtk_menu_shell_append (shell, item);
menu->actions = g_list_append (menu->actions, action);
menu->special_key_cb (accel, action, sub_res);
}
/* Scan rest of resource in case there is more work */
for (j = 0; j < sub_res->c; j++)
{
const char *res_name;
/* named value = X resource */
if (resource_type (sub_res->v[j]) == 110)
{
res_name = sub_res->v[j].name;
/* translate bg, fg to background, foreground */
if (strcmp (res_name, "fg") == 0) res_name = "foreground";
if (strcmp (res_name, "bg") == 0) res_name = "background";
/* ignore special named values (m, a, sensitive) */
if (strcmp (res_name, "m") == 0
|| strcmp (res_name, "a") == 0
|| strcmp (res_name, "sensitive") == 0
|| strcmp (res_name, "tip") == 0)
break;
/* log checked and active special values */
if (action && strcmp (res_name, "checked") == 0)
g_object_set_data (G_OBJECT (action), "checked-flag",
sub_res->v[j].value);
else if (action && strcmp (res_name, "active") == 0)
g_object_set_data (G_OBJECT (action), "active-flag",
sub_res->v[j].value);
else
/* if we got this far it is supposed to be an X
* resource. For now ignore it and warn the user */
Message (_("The gtk gui currently ignores \"%s\""
"as part of a menuitem resource.\n"
"Feel free to provide patches\n"),
sub_res->v[j].value);
}
}
break;
case 10: /* no name, value */
/* If we get here, the resource is "-" or "@foo" for some foo */
if (res->v[i].value[0] == '@')
{
GList *children;
int pos;
children = gtk_container_get_children (GTK_CONTAINER (shell));
pos = g_list_length (children);
g_list_free (children);
if (strcmp (res->v[i].value, "@layerview") == 0)
{
menu->layer_view_shell = shell;
menu->layer_view_pos = pos;
}
else if (strcmp (res->v[i].value, "@layerpick") == 0)
{
menu->layer_pick_shell = shell;
menu->layer_pick_pos = pos;
}
else if (strcmp (res->v[i].value, "@routestyles") == 0)
{
menu->route_style_shell = shell;
menu->route_style_pos = pos;
}
else
Message (_("GTK GUI currently ignores \"%s\" in the menu\n"
"resource file.\n"), res->v[i].value);
}
else if (strcmp (res->v[i].value, "-") == 0)
{
GtkWidget *item = gtk_separator_menu_item_new ();
gtk_menu_shell_append (shell, item);
}
else if (i > 0)
{
/* This is an action-less menuitem. It is really only useful
* when you're starting to build a new menu and you're looking
* to get the layout right. */
GtkWidget *item
= gtk_menu_item_new_with_label (_(res->v[i].value));
gtk_menu_shell_append (shell, item);
}
break;
}
}
}
int main (int argc, char *argv[])
{
int i;
const char *commandLine_File = NULL;
GtkWidget *pVBox;
GtkWidget *pMenuBar;
GtkWidget *pMenu, *pSubMenu;
GtkWidget *pMenuItem, *pSubMenuItem;
GtkAccelGroup * accel_group;
if(argc == 2) commandLine_File = argv[1];
#ifdef DEBUG
LogStart();
#endif
gtk_init(&argc, &argv);
SDL_Init(SDL_INIT_VIDEO);
desmume_init();
dTools_running = (BOOL*)malloc(sizeof(BOOL) * dTools_list_size);
for(i=0; i<dTools_list_size; i++) dTools_running[i]=FALSE;
CONFIG_FILE = g_build_filename(g_get_home_dir(), ".desmume.ini", NULL);
Read_ConfigFile();
/* Creation de la fenetre */
pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(pWindow), "Desmume");
gtk_window_set_policy (GTK_WINDOW (pWindow), FALSE, FALSE, FALSE);
gtk_window_set_icon(GTK_WINDOW (pWindow), gdk_pixbuf_new_from_xpm_data(DeSmuME_xpm));
g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(G_OBJECT(pWindow), "key_press_event", G_CALLBACK(Key_Press), NULL);
g_signal_connect(G_OBJECT(pWindow), "key_release_event", G_CALLBACK(Key_Release), NULL);
/* Creation de la GtkVBox */
pVBox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(pWindow), pVBox);
accel_group = gtk_accel_group_new();
action_group = gtk_action_group_new("dui");
gtk_action_group_add_actions(action_group, action_entries, sizeof(action_entries) / sizeof(GtkActionEntry), pWindow);
{
GList * list = gtk_action_group_list_actions(action_group);
g_list_foreach(list, dui_set_accel_group, accel_group);
}
gtk_window_add_accel_group(GTK_WINDOW(pWindow), accel_group);
gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "pause"), FALSE);
gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "run"), FALSE);
gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "reset"), FALSE);
gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "printscreen"), FALSE);
/**** Creation du menu ****/
pMenuBar = gtk_menu_bar_new();
/** Menu "Fichier" **/
pMenu = gtk_menu_new();
gtk_container_add(GTK_CONTAINER(pMenu), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "open")));
gtk_container_add(GTK_CONTAINER(pMenu), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "printscreen")));
gtk_container_add(GTK_CONTAINER(pMenu), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "quit")));
pMenuItem = gtk_menu_item_new_with_label("File");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), pMenu);
gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem);
/** Menu "Emulation" **/
GtkWidget *mEmulation;
GtkWidget *mFrameskip;
GtkWidget *mFrameskip_Radio[MAX_FRAMESKIP];
GtkWidget *mGraphics;
GtkWidget *mSize;
GtkWidget *mSize_Radio[MAX_SCREENCOEFF];
GtkWidget *mLayers;
GtkWidget *mLayers_Radio[10];
mEmulation = gtk_menu_new();
pMenuItem = gtk_menu_item_new_with_label("Emulation");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mEmulation);
gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem);
gtk_container_add(GTK_CONTAINER(mEmulation), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "run")));
gtk_container_add(GTK_CONTAINER(mEmulation), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "pause")));
gtk_container_add(GTK_CONTAINER(mEmulation), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "reset")));
mFrameskip = gtk_menu_new();
pMenuItem = gtk_menu_item_new_with_label("Frameskip");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mFrameskip);
gtk_menu_shell_append(GTK_MENU_SHELL(mEmulation), pMenuItem);
for(i = 0; i < MAX_FRAMESKIP; i++) {
char frameskipRadio_buf[16];
sprintf(frameskipRadio_buf, "%d", i);
if(i>0) mFrameskip_Radio[i] = gtk_radio_menu_item_new_with_label_from_widget(GTK_RADIO_MENU_ITEM(mFrameskip_Radio[i-1]), frameskipRadio_buf);
else mFrameskip_Radio[i] = gtk_radio_menu_item_new_with_label(NULL, frameskipRadio_buf);
g_signal_connect(G_OBJECT(mFrameskip_Radio[i]), "activate", G_CALLBACK(Modify_Frameskip), GINT_TO_POINTER(i));
gtk_menu_shell_append(GTK_MENU_SHELL(mFrameskip), mFrameskip_Radio[i]);
}
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mFrameskip_Radio[0]), TRUE);
mGraphics = gtk_menu_new();
pMenuItem = gtk_menu_item_new_with_label("Graphics");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mGraphics);
gtk_menu_shell_append(GTK_MENU_SHELL(mEmulation), pMenuItem);
// TODO: Un jour, peut être... ><
mSize = gtk_menu_new();
pMenuItem = gtk_menu_item_new_with_label("Size");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mSize);
gtk_menu_shell_append(GTK_MENU_SHELL(mGraphics), pMenuItem);
for(i = 1; i < MAX_SCREENCOEFF; i++) {
char sizeRadio_buf[16];
sprintf(sizeRadio_buf, "x%d", i);
if(i>1) mSize_Radio[i] = gtk_radio_menu_item_new_with_label_from_widget(GTK_RADIO_MENU_ITEM(mSize_Radio[i-1]), sizeRadio_buf);
else mSize_Radio[i] = gtk_radio_menu_item_new_with_label(NULL, sizeRadio_buf);
g_signal_connect(G_OBJECT(mSize_Radio[i]), "activate", G_CALLBACK(Modify_ScreenCoeff), GINT_TO_POINTER(i));
gtk_menu_shell_append(GTK_MENU_SHELL(mSize), mSize_Radio[i]);
}
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mFrameskip_Radio[0]), TRUE);
mLayers = gtk_menu_new();
pMenuItem = gtk_menu_item_new_with_label("Layers");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mLayers);
gtk_menu_shell_append(GTK_MENU_SHELL(mGraphics), pMenuItem);
for(i = 0; i < 10; i++) {
mLayers_Radio[i] = gtk_check_menu_item_new_with_label(Layers_Menu[i]);
g_signal_connect(G_OBJECT(mLayers_Radio[i]), "activate", G_CALLBACK(Modify_Layer), (void*)Layers_Menu[i]);
gtk_menu_shell_append(GTK_MENU_SHELL(mLayers), mLayers_Radio[i]);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mLayers_Radio[i]), TRUE);
}
/** Menu "Options" **/
GtkWidget *mConfig = gtk_menu_new();
pMenuItem = gtk_menu_item_new_with_label("Config");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mConfig);
gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem);
pMenuItem = gtk_menu_item_new_with_label("Edit controls");
g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(Edit_Controls), (GtkWidget*) pWindow);
gtk_menu_shell_append(GTK_MENU_SHELL(mConfig), pMenuItem);
#if 0
GtkWidget *mFirmware;
mFirmware = gtk_menu_new();
pMenuItem = gtk_menu_item_new_with_label("Firmware");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mFirmware);
gtk_menu_shell_append(GTK_MENU_SHELL(mConfig), pMenuItem);
pMenuItem = gtk_menu_item_new_with_label("Select...");
g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(SelectFirmwareFile), (gpointer)0);
gtk_menu_shell_append(GTK_MENU_SHELL(mFirmware), pMenuItem);
pMenuItem = gtk_menu_item_new_with_label("Config");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mConfig);
gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem);
#endif
/** Menu "Outils" **/
pMenu = gtk_menu_new();
for(i = 0; i < dTools_list_size; i++)
{
pMenuItem = gtk_menu_item_new_with_label(dTools_list[i]->name);
g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(Start_dTool), GINT_TO_POINTER(i));
gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);
}
pMenuItem = gtk_menu_item_new_with_label("Tools");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), pMenu);
gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem);
/** Menu "?" **/
pMenu = gtk_menu_new();
#if ((GTK_MAJOR_VERSION >= 2) && (GTK_MINOR_VERSION >= 6))
pMenuItem = gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT,NULL);
#else
pMenuItem = gtk_menu_item_new_with_label("About");
#endif
g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(About), (GtkWidget*) pWindow);
gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);
pMenuItem = gtk_menu_item_new_with_label("?");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), pMenu);
gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem);
/* Ajout du menu a la fenetre */
gtk_box_pack_start(GTK_BOX(pVBox), pMenuBar, FALSE, FALSE, 0);
/* Création de la Toolbar */
pToolbar = gtk_toolbar_new();
gtk_box_pack_start(GTK_BOX(pVBox), pToolbar, FALSE, FALSE, 0);
gtk_toolbar_insert(GTK_TOOLBAR(pToolbar), GTK_TOOL_ITEM(gtk_action_create_tool_item(gtk_action_group_get_action(action_group, "open"))), -1);
gtk_toolbar_insert(GTK_TOOLBAR(pToolbar), GTK_TOOL_ITEM(gtk_action_create_tool_item(gtk_action_group_get_action(action_group, "run"))), -1);
gtk_toolbar_insert(GTK_TOOLBAR(pToolbar), GTK_TOOL_ITEM(gtk_action_create_tool_item(gtk_action_group_get_action(action_group, "pause"))), -1);
gtk_toolbar_insert(GTK_TOOLBAR(pToolbar), GTK_TOOL_ITEM(gtk_action_create_tool_item(gtk_action_group_get_action(action_group, "quit"))), -1);
/* Création de l'endroit pour l'affichage des écrans */
pDrawingArea= gtk_drawing_area_new();
gtk_drawing_area_size(GTK_DRAWING_AREA(pDrawingArea), 256, 384);
gtk_widget_set_usize (pDrawingArea, 256, 384);
gtk_widget_set_events(pDrawingArea, GDK_EXPOSURE_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_KEY_PRESS_MASK );
g_signal_connect(G_OBJECT(pDrawingArea), "button_press_event", G_CALLBACK(Stylus_Press), NULL);
g_signal_connect(G_OBJECT(pDrawingArea), "button_release_event", G_CALLBACK(Stylus_Release), NULL);
g_signal_connect(G_OBJECT(pDrawingArea), "motion_notify_event", G_CALLBACK(Stylus_Move), NULL);
g_signal_connect( G_OBJECT(pDrawingArea), "realize", G_CALLBACK(Draw), NULL ) ;
g_signal_connect( G_OBJECT(pDrawingArea), "expose_event", G_CALLBACK(gtkFloatExposeEvent), NULL ) ;
gtk_box_pack_start(GTK_BOX(pVBox), pDrawingArea, FALSE, FALSE, 0);
/* Création de la barre d'état */
pStatusBar = gtk_statusbar_new();
pStatusBar_Ctx = gtk_statusbar_get_context_id(GTK_STATUSBAR(pStatusBar), "Global");
pStatusBar_Change("Desmume");
gtk_box_pack_end(GTK_BOX(pVBox), pStatusBar, FALSE, FALSE, 0);
gtk_widget_show_all(pWindow);
//LoadFirmware("fw.bin");
/* Vérifie la ligne de commandes */
if(commandLine_File)
{
if(Open(commandLine_File) >= 0)
{
Launch();
}
else
{
GtkWidget *pDialog = gtk_message_dialog_new(GTK_WINDOW(pWindow),
GTK_DIALOG_MODAL,
GTK_MESSAGE_INFO,
GTK_BUTTONS_OK,
"Unable to load :\n%s", commandLine_File);
gtk_dialog_run(GTK_DIALOG(pDialog));
gtk_widget_destroy(pDialog);
}
}
/* Boucle principale */
// gtk_idle_add(&EmuLoop, pWindow);
// g_idle_add(&EmuLoop, pWindow);
gtk_main();
desmume_free();
#ifdef DEBUG
LogStop();
#endif
SDL_Quit();
Write_ConfigFile();
return EXIT_SUCCESS;
}
static GtkWidget *
create_send_receive_submenu (EMailShellView *mail_shell_view)
{
EShellView *shell_view;
EShellWindow *shell_window;
EShellBackend *shell_backend;
EMailAccountStore *account_store;
EMailBackend *backend;
EMailSession *session;
GtkWidget *menu;
GtkAccelGroup *accel_group;
GtkUIManager *ui_manager;
GtkAction *action;
GtkTreeModel *model;
GtkTreeIter iter;
SendReceiveData *data;
g_return_val_if_fail (mail_shell_view != NULL, NULL);
shell_view = E_SHELL_VIEW (mail_shell_view);
shell_window = e_shell_view_get_shell_window (shell_view);
shell_backend = e_shell_view_get_shell_backend (shell_view);
backend = E_MAIL_BACKEND (shell_backend);
session = e_mail_backend_get_session (backend);
account_store = e_mail_ui_session_get_account_store (E_MAIL_UI_SESSION (session));
menu = gtk_menu_new ();
ui_manager = e_shell_window_get_ui_manager (shell_window);
accel_group = gtk_ui_manager_get_accel_group (ui_manager);
action = e_shell_window_get_action (shell_window, "mail-send-receive");
gtk_action_set_accel_group (action, accel_group);
gtk_menu_shell_append (
GTK_MENU_SHELL (menu),
gtk_action_create_menu_item (action));
action = e_shell_window_get_action (
shell_window, "mail-send-receive-receive-all");
gtk_action_set_accel_group (action, accel_group);
gtk_menu_shell_append (
GTK_MENU_SHELL (menu),
gtk_action_create_menu_item (action));
action = e_shell_window_get_action (
shell_window, "mail-send-receive-send-all");
gtk_action_set_accel_group (action, accel_group);
gtk_menu_shell_append (
GTK_MENU_SHELL (menu),
gtk_action_create_menu_item (action));
gtk_menu_shell_append (
GTK_MENU_SHELL (menu),
gtk_separator_menu_item_new ());
data = send_receive_data_new (mail_shell_view, menu);
model = GTK_TREE_MODEL (account_store);
if (gtk_tree_model_get_iter_first (model, &iter)) {
CamelService *service;
do {
service = NULL;
gtk_tree_model_get (
model, &iter,
E_MAIL_ACCOUNT_STORE_COLUMN_SERVICE, &service,
-1);
if (send_receive_can_use_service (account_store, service, &iter))
send_receive_add_to_menu (data, service, -1);
if (service)
g_object_unref (service);
} while (gtk_tree_model_iter_next (model, &iter));
}
gtk_widget_show_all (menu);
return menu;
}
int main ( int argc, char **argv )
{
int k;
GtkWidget *window, *child, *box, *menu, *subMenu;
GtkAction *action[2];
GtkUIManager *manager;
gtk_init ( &argc, &argv );
window = gtk_window_new ( GTK_WINDOW_TOPLEVEL );
box = gtk_vbox_new ( 0, 0 );
gtk_container_add ( GTK_CONTAINER ( window ), box );
/*
menuBar = gtk_menu_bar_new();
gtk_container_add( GTK_CONTAINER( box ), menuBar );
menu = gtk_menu_item_new_with_label( "Menu" );
gtk_container_add( GTK_CONTAINER( menuBar ), menu );
subMenu = gtk_menu_new();
gtk_menu_item_set_submenu( menu, subMenu );
*/
{
/*
actionGroup name -entries ... -toggleEntries ... -radioEntries
$name addEntries
$name addToggleEntries
$name addRadioEntries
*/
GtkActionGroup *action_group = gtk_action_group_new ( "MenuActions" );
gtk_action_group_add_actions ( action_group, entries,
G_N_ELEMENTS ( entries ), window );
gtk_action_group_add_toggle_actions ( action_group, toggle_entries,
G_N_ELEMENTS ( toggle_entries ), window );
gtk_action_group_add_radio_actions ( action_group, radio_entries,
G_N_ELEMENTS ( radio_entries ), 0, func1, window );
/*
uiManager addUI ui_description -groups $name
$manager addGroup
*/
manager = gtk_ui_manager_new ();
gtk_ui_manager_insert_action_group ( manager , action_group, 0 );
}
{
/*
$manager setAccelWindow window
*/
GtkAccelGroup *accel_group = gtk_ui_manager_get_accel_group ( manager );
gtk_window_add_accel_group ( GTK_WINDOW ( window ), accel_group );
}
{
/*
$manager setUiDescription xxx
*/
GError *error = NULL;
if ( !gtk_ui_manager_add_ui_from_string ( manager, ui_description, -1, &error ) )
{
g_message ( "building menus failed: %s", error->message );
g_error_free ( error );
exit ( 1 );
}
}
{
/*
$manager getWidget name
*/
GtkWidget *menuBar = gtk_ui_manager_get_widget ( manager, "/MainMenu" );
gtk_box_pack_start ( GTK_BOX ( box ), menuBar, FALSE, FALSE, 0 );
}
gtk_widget_show_all ( window );
/*
action[0] = GTK_ACTION( gtk_action_new( "name", "label", "tooltip", NULL ) );
action[1] = GTK_ACTION( gtk_action_new( "name2", "label2", "tooltip2", "gtk-quit" ) );
g_signal_connect( action[0], "activate", G_CALLBACK( func1 ), NULL);
g_signal_connect( action[1], "activate", G_CALLBACK( func2 ), NULL);
*/
/* accelGroup = gtk_accel_group_new(); */
#if 0
group = gtk_action_group_new ( "global" );
gtk_action_group_add_actions ( group, entries, 1, window );
manager = gtk_ui_manager_new ();
gtk_ui_manager_insert_action_group ( manager, group, 0 );
accelGroup = gtk_ui_manager_get_accel_group ( manager );
gtk_window_add_accel_group ( GTK_WINDOW ( window ), accelGroup );
for ( k = 0; k < 2; ++k )
{
child = gtk_action_create_menu_item ( action[k] );
gtk_container_add ( GTK_CONTAINER ( subMenu ), child );
child = gtk_action_create_tool_item ( action[k] );
gtk_container_add ( GTK_CONTAINER ( box ), child );
}
gtk_action_group_add_action_with_accel ( group, action[0], "<control>w" );
gtk_action_group_add_action_with_accel ( group, action[1], NULL );
#endif
gtk_widget_show_all ( window );
gtk_main();
return 0;
}
static VALUE
rg_create_menu_item(VALUE self)
{
return GOBJ2RVAL(gtk_action_create_menu_item(_SELF(self)));
}
/**
* thunar_dnd_ask:
* @widget : the widget on which the drop was performed.
* @folder : the #ThunarFile to which the @path_list is being dropped.
* @path_list : the #GFile<!---->s of the files being dropped to @file.
* @timestamp : the time of the drop event.
* @actions : the list of actions supported for the drop.
*
* Pops up a menu that asks the user to choose one of the
* @actions or to cancel the drop. If the user chooses a
* valid #GdkDragAction from @actions, then this action is
* returned. Else if the user cancels the drop, 0 will be
* returned.
*
* This method can be used to implement a response to the
* #GDK_ACTION_ASK action on drops.
*
* Return value: the selected #GdkDragAction or 0 to cancel.
**/
GdkDragAction
thunar_dnd_ask (GtkWidget *widget,
ThunarFile *folder,
GList *path_list,
guint timestamp,
GdkDragAction dnd_actions)
{
static const GdkDragAction dnd_action_items[] = { GDK_ACTION_COPY, GDK_ACTION_MOVE, GDK_ACTION_LINK };
static const gchar *dnd_action_names[] = { N_ ("_Copy here"), N_ ("_Move here"), N_ ("_Link here") };
static const gchar *dnd_action_icons[] = { "stock_folder-copy", "stock_folder-move", NULL };
ThunarxProviderFactory *factory;
GdkDragAction dnd_action = 0;
ThunarFile *file;
GtkWidget *window;
GtkWidget *image;
GtkWidget *menu;
GtkWidget *item;
GList *file_list = NULL;
GList *providers = NULL;
GList *actions = NULL;
GList *lp;
guint n;
_thunar_return_val_if_fail (thunar_file_is_directory (folder), 0);
_thunar_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
/* connect to the provider factory */
factory = thunarx_provider_factory_get_default ();
/* prepare the popup menu */
menu = gtk_menu_new ();
/* append the various items */
for (n = 0; n < G_N_ELEMENTS (dnd_action_items); ++n)
if (G_LIKELY ((dnd_actions & dnd_action_items[n]) != 0))
{
item = gtk_image_menu_item_new_with_mnemonic (_(dnd_action_names[n]));
g_object_set_data (G_OBJECT (item), I_("dnd-action"), GUINT_TO_POINTER (dnd_action_items[n]));
g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (dnd_action_selected), &dnd_action);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
/* add image to the menu item */
if (G_LIKELY (dnd_action_icons[n] != NULL))
{
image = gtk_image_new_from_icon_name (dnd_action_icons[n], GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
}
}
/* append the separator */
item = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
/* determine the toplevel window the widget belongs to */
window = gtk_widget_get_toplevel (widget);
if (G_LIKELY (window != NULL && gtk_widget_get_toplevel (window)))
{
/* check if we can resolve all paths */
for (lp = path_list; lp != NULL; lp = lp->next)
{
/* try to resolve this path */
file = thunar_file_cache_lookup (lp->data);
if (G_LIKELY (file != NULL))
file_list = g_list_prepend (file_list, file);
else
break;
}
/* check if we resolved all paths (and have atleast one file) */
if (G_LIKELY (file_list != NULL && lp == NULL))
{
/* load the menu providers from the provider factory */
providers = thunarx_provider_factory_list_providers (factory, THUNARX_TYPE_MENU_PROVIDER);
/* load the dnd actions offered by the menu providers */
for (lp = providers; lp != NULL; lp = lp->next)
{
/* merge the actions from this provider */
actions = g_list_concat (actions, thunarx_menu_provider_get_dnd_actions (lp->data, window, THUNARX_FILE_INFO (folder), file_list));
g_object_unref (G_OBJECT (lp->data));
}
g_list_free (providers);
/* check if we have atleast one action */
if (G_UNLIKELY (actions != NULL))
{
/* add menu items for all actions */
for (lp = actions; lp != NULL; lp = lp->next)
{
/* add a menu item for the action */
item = gtk_action_create_menu_item (lp->data);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
g_object_unref (G_OBJECT (lp->data));
gtk_widget_show (item);
}
g_list_free (actions);
/* append another separator */
item = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
}
}
}
/* append the cancel item */
item = gtk_image_menu_item_new_from_stock (GTK_STOCK_CANCEL, NULL);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
/* run the menu on the widget's screen (takes over the floating reference of menu) */
thunar_gtk_menu_run (GTK_MENU (menu), widget, NULL, NULL, 3, timestamp);
/* cleanup */
g_object_unref (G_OBJECT (factory));
g_list_free_full (file_list, g_object_unref);
return dnd_action;
}
