static void
browser_tooltips (void)
{
MidoriBrowser* browser;
GtkActionGroup* action_group;
GList* actions;
gchar* toolbar;
guint errors = 0;
browser = midori_browser_new ();
action_group = midori_browser_get_action_group (browser);
actions = gtk_action_group_list_actions (action_group);
toolbar = g_strjoinv (" ", (gchar**)midori_browser_get_toolbar_actions (browser));
while (actions)
{
GtkAction* action = actions->data;
const gchar* name = gtk_action_get_name (action);
if (strstr ("CompactMenu Location Separator", name))
{
actions = g_list_next (actions);
continue;
}
if (strstr (toolbar, name) != NULL)
{
if (!gtk_action_get_tooltip (action))
{
printf ("'%s' can be toolbar item but tooltip is unset\n", name);
errors++;
}
}
else
{
if (gtk_action_get_tooltip (action))
{
printf ("'%s' is no toolbar item but tooltip is set\n", name);
errors++;
}
}
actions = g_list_next (actions);
}
g_free (toolbar);
g_list_free (actions);
gtk_widget_destroy (GTK_WIDGET (browser));
if (errors)
g_error ("Tooltip errors");
}
static void
action_group_mark(void *p)
{
GtkActionGroup *group;
GList *actions, *node;
group = GTK_ACTION_GROUP(p);
actions = gtk_action_group_list_actions(group);
for (node = actions; node; node = g_list_next(node)) {
GtkWidget *action = node->data;
rbgobj_gc_mark_instance(action);
}
g_list_free(actions);
}
void
menus_set_recent (GtkActionGroup *actions)
{
GList *list;
guint id;
const char *recent_path;
if (is_integrated_ui ())
recent_path = INTEGRATED_MENU "/File/FileRecentEnd";
else
recent_path = TOOLBOX_MENU "/File/FileRecentEnd";
if (recent_actions) {
menus_clear_recent ();
}
list = gtk_action_group_list_actions (actions);
g_return_if_fail (list);
/* sort it by the action name to preserve out order */
list = g_list_sort (list, cmp_action_names);
recent_actions = actions;
g_object_ref (G_OBJECT (recent_actions));
gtk_ui_manager_insert_action_group (_ui_manager,
recent_actions,
10 /* insert at back */ );
do {
const gchar* aname = gtk_action_get_name (GTK_ACTION (list->data));
id = gtk_ui_manager_new_merge_id (_ui_manager);
recent_merge_ids = g_slist_prepend (recent_merge_ids, GUINT_TO_POINTER (id));
gtk_ui_manager_add_ui (_ui_manager, id,
recent_path,
aname,
aname,
GTK_UI_MANAGER_AUTO,
TRUE);
} while (NULL != (list = list->next));
}
static void
plugin_add_child (GtkBuildable *buildable,
GtkBuilder *builder,
GObject *child,
const gchar *type)
{
GigglePlugin *plugin = GIGGLE_PLUGIN (buildable);
GigglePluginPriv *priv = GET_PRIV (plugin);
GList *actions;
g_return_if_fail (GTK_IS_ACTION_GROUP (child));
g_ptr_array_add (priv->action_groups, child);
actions = gtk_action_group_list_actions (GTK_ACTION_GROUP (child));
while (actions) {
plugin_connect_action (plugin, actions->data);
actions = g_list_delete_link (actions, actions);
}
}
static void
remove_action_item (GtkAction *action, GtkUIManager *manager)
{
guint menu_merge_id;
GList *actions, *l;
menu_merge_id = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (action), "merge-id"));
gtk_ui_manager_remove_ui (GTK_UI_MANAGER (manager), menu_merge_id);
actions = gtk_action_group_list_actions (devices_action_group);
for (l = actions; l != NULL; l = l->next) {
GtkAction *a = l->data;
/* Don't remove the top-level action straight away */
if (g_str_equal (gtk_action_get_name (a), gtk_action_get_name (action)) != FALSE)
continue;
/* But remove all the sub-actions for it */
if (g_str_has_prefix (gtk_action_get_name (a), gtk_action_get_name (action)) != FALSE)
gtk_action_group_remove_action (devices_action_group, a);
}
g_list_free (actions);
gtk_action_group_remove_action (devices_action_group, action);
}
int
clip_GTK_ACTIONGROUPLISTACTIONS(ClipMachine * ClipMachineMemory)
{
C_object *cagroup = _fetch_co_arg(ClipMachineMemory);
GList *list;
CHECKARG2(1, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCOBJ(cagroup, GTK_IS_ACTION_GROUP(cagroup->object));
list = gtk_action_group_list_actions(GTK_ACTION_GROUP(cagroup->object));
if (list)
{
ClipVar *cv = RETPTR(ClipMachineMemory);
long n = g_list_length(list);
_clip_array(ClipMachineMemory, cv, 1, &n);
for (n = 0; list; list = g_list_next(list))
{
C_object *caction;
GtkAction *action;
action = list->data;
caction = _list_get_cobject(ClipMachineMemory, action);
if (!caction)
caction = _register_object(ClipMachineMemory, action, GTK_TYPE_ACTION, NULL, NULL);
if (caction)
_clip_aset(ClipMachineMemory, cv, &caction->obj, 1, &n);
}
}
return 0;
err:
return 1;
}
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;
}
GtkWidget *
gimp_action_view_new (GimpUIManager *manager,
const gchar *select_action,
gboolean show_shortcuts)
{
GtkTreeView *view;
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
GtkTreeStore *store;
GtkTreeModel *filter;
GtkAccelGroup *accel_group;
GList *list;
GtkTreePath *select_path = NULL;
g_return_val_if_fail (GIMP_IS_UI_MANAGER (manager), NULL);
store = gtk_tree_store_new (GIMP_ACTION_VIEW_N_COLUMNS,
G_TYPE_BOOLEAN, /* COLUMN_VISIBLE */
GTK_TYPE_ACTION, /* COLUMN_ACTION */
G_TYPE_STRING, /* COLUMN_STOCK_ID */
G_TYPE_STRING, /* COLUMN_LABEL */
G_TYPE_STRING, /* COLUMN_LABEL_CASEFOLD */
G_TYPE_STRING, /* COLUMN_NAME */
G_TYPE_UINT, /* COLUMN_ACCEL_KEY */
GDK_TYPE_MODIFIER_TYPE, /* COLUMN_ACCEL_MASK */
G_TYPE_CLOSURE); /* COLUMN_ACCEL_CLOSURE */
accel_group = gtk_ui_manager_get_accel_group (GTK_UI_MANAGER (manager));
for (list = gtk_ui_manager_get_action_groups (GTK_UI_MANAGER (manager));
list;
list = g_list_next (list))
{
GimpActionGroup *group = list->data;
GList *actions;
GList *list2;
GtkTreeIter group_iter;
gtk_tree_store_append (store, &group_iter, NULL);
gtk_tree_store_set (store, &group_iter,
GIMP_ACTION_VIEW_COLUMN_STOCK_ID, group->stock_id,
GIMP_ACTION_VIEW_COLUMN_LABEL, group->label,
-1);
actions = gtk_action_group_list_actions (GTK_ACTION_GROUP (group));
actions = g_list_sort (actions, (GCompareFunc) gimp_action_name_compare);
for (list2 = actions; list2; list2 = g_list_next (list2))
{
GtkAction *action = list2->data;
const gchar *name = gtk_action_get_name (action);
const gchar *stock_id = gtk_action_get_stock_id (action);
gchar *label;
gchar *label_casefold;
guint accel_key = 0;
GdkModifierType accel_mask = 0;
GClosure *accel_closure = NULL;
GtkTreeIter action_iter;
if (strstr (name, "-menu") ||
strstr (name, "-popup") ||
name[0] == '<')
continue;
label = gimp_strip_uline (gtk_action_get_label (action));
if (! (label && strlen (label)))
{
g_free (label);
label = g_strdup (name);
}
label_casefold = g_utf8_casefold (label, -1);
if (show_shortcuts)
{
accel_closure = gtk_action_get_accel_closure (action);
if (accel_closure)
{
GtkAccelKey *key;
key = gtk_accel_group_find (accel_group,
gimp_action_view_accel_find_func,
accel_closure);
if (key &&
key->accel_key &&
key->accel_flags & GTK_ACCEL_VISIBLE)
{
accel_key = key->accel_key;
accel_mask = key->accel_mods;
}
}
}
gtk_tree_store_append (store, &action_iter, &group_iter);
gtk_tree_store_set (store, &action_iter,
GIMP_ACTION_VIEW_COLUMN_VISIBLE, TRUE,
GIMP_ACTION_VIEW_COLUMN_ACTION, action,
GIMP_ACTION_VIEW_COLUMN_STOCK_ID, stock_id,
GIMP_ACTION_VIEW_COLUMN_LABEL, label,
GIMP_ACTION_VIEW_COLUMN_LABEL_CASEFOLD, label_casefold,
GIMP_ACTION_VIEW_COLUMN_NAME, name,
GIMP_ACTION_VIEW_COLUMN_ACCEL_KEY, accel_key,
GIMP_ACTION_VIEW_COLUMN_ACCEL_MASK, accel_mask,
GIMP_ACTION_VIEW_COLUMN_ACCEL_CLOSURE, accel_closure,
-1);
g_free (label);
g_free (label_casefold);
if (select_action && ! strcmp (select_action, name))
{
select_path = gtk_tree_model_get_path (GTK_TREE_MODEL (store),
&action_iter);
}
}
g_list_free (actions);
}
filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (store), NULL);
g_object_unref (store);
view = g_object_new (GIMP_TYPE_ACTION_VIEW,
"model", filter,
"rules-hint", TRUE,
NULL);
g_object_unref (filter);
gtk_tree_model_filter_set_visible_column (GTK_TREE_MODEL_FILTER (filter),
GIMP_ACTION_VIEW_COLUMN_VISIBLE);
GIMP_ACTION_VIEW (view)->manager = g_object_ref (manager);
GIMP_ACTION_VIEW (view)->show_shortcuts = show_shortcuts;
gtk_tree_view_set_search_column (GTK_TREE_VIEW (view),
GIMP_ACTION_VIEW_COLUMN_LABEL);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Action"));
cell = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, cell, FALSE);
gtk_tree_view_column_set_attributes (column, cell,
"stock-id",
GIMP_ACTION_VIEW_COLUMN_STOCK_ID,
NULL);
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_set_attributes (column, cell,
"text",
GIMP_ACTION_VIEW_COLUMN_LABEL,
NULL);
gtk_tree_view_append_column (view, column);
if (show_shortcuts)
{
g_signal_connect (view, "button-press-event",
G_CALLBACK (gimp_action_view_button_press),
NULL);
g_signal_connect (accel_group, "accel-changed",
G_CALLBACK (gimp_action_view_accel_changed),
view);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Shortcut"));
cell = gtk_cell_renderer_accel_new ();
g_object_set (cell,
"mode", GTK_CELL_RENDERER_MODE_EDITABLE,
"editable", TRUE,
NULL);
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_set_attributes (column, cell,
"accel-key",
GIMP_ACTION_VIEW_COLUMN_ACCEL_KEY,
"accel-mods",
GIMP_ACTION_VIEW_COLUMN_ACCEL_MASK,
NULL);
g_signal_connect (cell, "accel-edited",
G_CALLBACK (gimp_action_view_accel_edited),
view);
g_signal_connect (cell, "accel-cleared",
G_CALLBACK (gimp_action_view_accel_cleared),
view);
gtk_tree_view_append_column (view, column);
}
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Name"));
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_set_attributes (column, cell,
"text",
GIMP_ACTION_VIEW_COLUMN_NAME,
NULL);
gtk_tree_view_append_column (view, column);
if (select_path)
{
gimp_action_view_select_path (GIMP_ACTION_VIEW (view), select_path);
gtk_tree_path_free (select_path);
}
return GTK_WIDGET (view);
}
static GtkWidget*
shortcuts_get_preferences_dialog (MidoriExtension* extension)
{
MidoriApp* app;
GtkWidget* browser;
const gchar* dialog_title;
GtkWidget* dialog;
gint width, height;
GtkWidget* xfce_heading;
GtkWidget* hbox;
GtkListStore* liststore;
GtkTreeModel* model;
GtkWidget* treeview;
GtkTreeViewColumn* column;
GtkCellRenderer* renderer;
GtkWidget* scrolled;
GtkActionGroup* action_group;
GList* actions;
guint i;
GtkAction* action;
#if HAVE_OSX
GtkWidget* icon;
#endif
app = midori_extension_get_app (extension);
browser = katze_object_get_object (app, "browser");
dialog_title = _("Customize Keyboard shortcuts");
dialog = gtk_dialog_new_with_buttons (dialog_title, GTK_WINDOW (browser),
GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_NO_SEPARATOR,
#if !HAVE_OSX
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
#endif
NULL);
g_signal_connect (dialog, "destroy",
G_CALLBACK (gtk_widget_destroyed), &dialog);
gtk_window_set_icon_name (GTK_WINDOW (dialog), GTK_STOCK_PROPERTIES);
sokoke_widget_get_text_size (dialog, "M", &width, &height);
gtk_window_set_default_size (GTK_WINDOW (dialog), width * 52, height * 24);
g_signal_connect (dialog, "response",
G_CALLBACK (shortcuts_preferences_response_cb), NULL);
if ((xfce_heading = sokoke_xfce_header_new (
gtk_window_get_icon_name (GTK_WINDOW (dialog)), dialog_title)))
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
xfce_heading, FALSE, FALSE, 0);
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox,
TRUE, TRUE, 12);
liststore = gtk_list_store_new (7,
G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT, G_TYPE_BOOLEAN,
G_TYPE_STRING, GTK_TYPE_ACTION);
model = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (liststore));
treeview = gtk_tree_view_new_with_model (model);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE);
column = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), renderer, "text", 0);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
column = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_accel_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), renderer, "accel-key", 1);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), renderer, "accel-mods", 2);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), renderer, "accel-mode", 3);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), renderer, "sensitive", 4);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), renderer, "editable", 4);
g_signal_connect (renderer, "accel-edited",
G_CALLBACK (shortcuts_accel_edited_cb), model);
g_signal_connect (renderer, "accel-cleared",
G_CALLBACK (shortcuts_accel_cleared_cb), model);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (scrolled), treeview);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled),
GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (hbox), scrolled, TRUE, TRUE, 5);
action_group = midori_browser_get_action_group (MIDORI_BROWSER (browser));
actions = gtk_action_group_list_actions (action_group);
i = 0;
/* FIXME: Catch added and removed actions */
while ((action = g_list_nth_data (actions, i++)))
{
gchar* label = shortcuts_label_for_action (action);
GtkAccelKey key;
gboolean has_hotkey = shortcuts_hotkey_for_action (action, &key);
gtk_list_store_insert_with_values (GTK_LIST_STORE (liststore),
NULL, G_MAXINT, 0, label, 1, key.accel_key, 2, key.accel_mods,
3, GTK_CELL_RENDERER_ACCEL_MODE_OTHER,
4, has_hotkey, 6, action, -1);
g_free (label);
}
g_list_free (actions);
g_object_unref (liststore);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model),
0, GTK_SORT_ASCENDING);
g_object_unref (model);
gtk_widget_show_all (GTK_DIALOG (dialog)->vbox);
g_object_unref (browser);
return dialog;
}
static VALUE
rg_actions(VALUE self)
{
return GLIST2ARYF(gtk_action_group_list_actions(_SELF(self)));
}
static void
seahorse_generate_select_constructed (GObject *obj)
{
SeahorseGenerateSelect *self = SEAHORSE_GENERATE_SELECT (obj);
gchar *text;
GtkCellRenderer *pixcell;
GtkTreeSelection *selection;
GtkTreeIter iter;
GList *actions;
GList *l, *k;
GIcon *icon;
GtkBuilder *builder;
const gchar *path;
GError *error = NULL;
const gchar *icon_name;
GtkAction *action;
G_OBJECT_CLASS (seahorse_generate_select_parent_class)->constructed (obj);
self->store = gtk_list_store_new (COLUMN_N_COLUMNS, G_TYPE_ICON, G_TYPE_STRING, GTK_TYPE_ACTION);
gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (self->store), on_list_sort, NULL, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (self->store), GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING);
self->action_groups = seahorse_registry_object_instances ("generator");
for (l = self->action_groups; l != NULL; l = g_list_next (l)) {
actions = gtk_action_group_list_actions (l->data);
for (k = actions; k != NULL; k = g_list_next (k)) {
action = k->data;
text = g_strdup_printf (TEMPLATE, gtk_action_get_label (action),
gtk_action_get_tooltip (action));
icon = gtk_action_get_gicon (action);
if (icon == NULL) {
icon_name = gtk_action_get_icon_name (action);
if (icon_name)
icon = g_themed_icon_new (icon_name);
gtk_action_get_stock_id (action);
} else {
g_object_ref (icon);
}
gtk_list_store_append (self->store, &iter);
gtk_list_store_set (self->store, &iter,
COLUMN_TEXT, text,
COLUMN_ICON, icon,
COLUMN_ACTION, k->data,
-1);
g_clear_object (&icon);
}
g_list_free (actions);
}
builder = gtk_builder_new ();
path = "/org/gnome/Seahorse/seahorse-generate-select.xml";
gtk_builder_add_from_resource (builder, path, &error);
if (error != NULL) {
g_warning ("couldn't load ui file: %s", path);
g_clear_error (&error);
g_object_unref (builder);
return;
}
/* Setup the dialog */
gtk_window_set_modal (GTK_WINDOW (self), TRUE);
gtk_window_set_default_size (GTK_WINDOW (self), -1, 410);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (self))),
GTK_WIDGET (gtk_builder_get_object (builder, "generate-select")),
TRUE, TRUE, 0);
gtk_dialog_add_buttons (GTK_DIALOG (self),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
_("Continue"), GTK_RESPONSE_OK,
NULL);
/* Hook it into the view */
self->view = GTK_TREE_VIEW (gtk_builder_get_object (builder, "keytype-tree"));
g_object_unref (builder);
pixcell = gtk_cell_renderer_pixbuf_new ();
g_object_set (pixcell, "stock-size", GTK_ICON_SIZE_DND, NULL);
gtk_tree_view_insert_column_with_attributes (self->view, -1, "", pixcell, "gicon", COLUMN_ICON, NULL);
gtk_tree_view_insert_column_with_attributes (self->view, -1, "", gtk_cell_renderer_text_new (), "markup", COLUMN_TEXT, NULL);
gtk_tree_view_set_model (self->view, GTK_TREE_MODEL (self->store));
/* Setup selection, select first item */
selection = gtk_tree_view_get_selection (self->view);
gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
gtk_tree_model_get_iter_first (GTK_TREE_MODEL (self->store), &iter);
gtk_tree_selection_select_iter (selection, &iter);
g_signal_connect (self->view, "row-activated", G_CALLBACK (on_row_activated), self);
g_object_set (self->view, "height-request", 410, NULL);
g_signal_connect (self, "response", G_CALLBACK (on_response), self);
}
gboolean
update(ParasiteActionList *actionlist)
{
GSList *i;
gtk_tree_store_clear(actionlist->priv->model);
for (i = actionlist->priv->uimanagers; i != NULL; i = g_slist_next(i))
{
GtkUIManager *uimanager;
GList *action_groups;
GList *j;
gchar *name;
uimanager = GTK_UI_MANAGER(i->data);
GtkTreeIter i_iter;
gtk_tree_store_append(actionlist->priv->model, &i_iter, NULL);
name = g_strdup_printf("UIManager at %p", uimanager);
gtk_tree_store_set(actionlist->priv->model, &i_iter,
ACTION_LABEL, name,
SORT_NAME, name,
ADDRESS, uimanager,
-1);
g_free(name);
action_groups = gtk_ui_manager_get_action_groups(uimanager);
for (j = action_groups; j != NULL; j = g_list_next(j))
{
GtkActionGroup *action_group;
GtkTreeIter j_iter;
GList *actions;
GList *k;
action_group = GTK_ACTION_GROUP(j->data);
gtk_tree_store_append(actionlist->priv->model, &j_iter, &i_iter);
name = (gchar*) gtk_action_group_get_name(action_group);
gtk_tree_store_set(actionlist->priv->model, &j_iter,
ACTION_LABEL, name,
SORT_NAME, name,
ROW_COLOR, gtk_action_group_get_sensitive(action_group)
? "black" : "grey",
ADDRESS, action_group,
-1);
actions = gtk_action_group_list_actions(action_group);
for (k = actions; k != NULL; k = g_list_next(k))
{
GtkTreeIter k_iter;
GtkAction *action;
gchar *action_label;
gchar *action_name;
gchar *action_stock;
gchar *sort_name;
action = GTK_ACTION(k->data);
g_object_get(action,
"label", &action_label,
"name", &action_name,
"stock-id", &action_stock,
NULL);
sort_name = g_strdup_printf("%s%s", name, action_name);
gtk_tree_store_append(actionlist->priv->model, &k_iter, &j_iter);
// FIXME: format the mnemonic
gtk_tree_store_set(actionlist->priv->model, &k_iter,
ACTION_LABEL, action_label,
ACTION_NAME, action_name,
ACTION_ICON, action_stock,
ROW_COLOR, gtk_action_is_sensitive(action)
? "black" : "grey",
SORT_NAME, sort_name,
ADDRESS, action,
-1);
g_free(sort_name);
g_free(action_stock);
g_free(action_name);
g_free(action_label);
}
}
}
// FIXME: I'm undecided about this, but I also don't really want to try to
// preserve the exsting expansion state of the whole tree.
gtk_tree_view_expand_all(GTK_TREE_VIEW(actionlist));
actionlist->priv->update_timeout = 0;
return FALSE;
}
void
e_task_shell_view_update_search_filter (ETaskShellView *task_shell_view)
{
ETaskShellContent *task_shell_content;
EShellView *shell_view;
EShellWindow *shell_window;
EShellSearchbar *searchbar;
EActionComboBox *combo_box;
GtkActionGroup *action_group;
GtkRadioAction *radio_action;
GList *list, *iter;
GSList *group;
gint ii;
shell_view = E_SHELL_VIEW (task_shell_view);
shell_window = e_shell_view_get_shell_window (shell_view);
action_group = ACTION_GROUP (TASKS_FILTER);
e_action_group_remove_all_actions (action_group);
/* Add the standard filter actions. No callback is needed
* because changes in the EActionComboBox are detected and
* handled by EShellSearchbar. */
gtk_action_group_add_radio_actions (
action_group, task_filter_entries,
G_N_ELEMENTS (task_filter_entries),
TASK_FILTER_ANY_CATEGORY, NULL, NULL);
/* Retrieve the radio group from an action we just added. */
list = gtk_action_group_list_actions (action_group);
radio_action = GTK_RADIO_ACTION (list->data);
group = gtk_radio_action_get_group (radio_action);
g_list_free (list);
/* Build the category actions. */
list = e_util_dup_searchable_categories ();
for (iter = list, ii = 0; iter != NULL; iter = iter->next, ii++) {
const gchar *category_name = iter->data;
gchar *filename;
GtkAction *action;
gchar *action_name;
action_name = g_strdup_printf (
"task-filter-category-%d", ii);
radio_action = gtk_radio_action_new (
action_name, category_name, NULL, NULL, ii);
g_free (action_name);
/* Convert the category icon file to a themed icon name. */
filename = e_categories_dup_icon_file_for (category_name);
if (filename != NULL && *filename != '\0') {
gchar *basename;
gchar *cp;
basename = g_path_get_basename (filename);
/* Lose the file extension. */
if ((cp = strrchr (basename, '.')) != NULL)
*cp = '\0';
g_object_set (
radio_action, "icon-name", basename, NULL);
g_free (basename);
}
g_free (filename);
gtk_radio_action_set_group (radio_action, group);
group = gtk_radio_action_get_group (radio_action);
/* The action group takes ownership of the action. */
action = GTK_ACTION (radio_action);
gtk_action_group_add_action (action_group, action);
g_object_unref (radio_action);
}
g_list_free_full (list, g_free);
task_shell_content = task_shell_view->priv->task_shell_content;
searchbar = e_task_shell_content_get_searchbar (task_shell_content);
combo_box = e_shell_searchbar_get_filter_combo_box (searchbar);
e_shell_view_block_execute_search (shell_view);
/* Use any action in the group; doesn't matter which. */
e_action_combo_box_set_action (combo_box, radio_action);
ii = TASK_FILTER_UNMATCHED;
e_action_combo_box_add_separator_after (combo_box, ii);
ii = TASK_FILTER_TASKS_WITH_ATTACHMENTS;
e_action_combo_box_add_separator_after (combo_box, ii);
e_shell_view_unblock_execute_search (shell_view);
}
static void
update_device_list (GtkTreeIter *parent)
{
GtkUIManager *uimanager;
GtkTreeIter iter;
gboolean cont;
guint num_devices;
GList *actions, *l;
num_devices = 0;
uimanager = GTK_UI_MANAGER (gtk_builder_get_object (xml, "bluetooth-applet-ui-manager"));
if (parent == NULL) {
/* No default adapter? Remove everything */
actions = gtk_action_group_list_actions (devices_action_group);
g_list_foreach (actions, (GFunc) remove_action_item, uimanager);
g_list_free (actions);
goto done;
}
/* Get a list of actions, and we'll remove the ones with a
* device in the list. We remove the submenu items first */
actions = gtk_action_group_list_actions (devices_action_group);
for (l = actions; l != NULL; l = l->next) {
if (bluetooth_verify_address (gtk_action_get_name (l->data)) == FALSE)
l->data = NULL;
}
actions = g_list_remove_all (actions, NULL);
cont = gtk_tree_model_iter_children (devices_model, &iter, parent);
while (cont) {
GHashTable *services;
DBusGProxy *proxy;
char *alias, *address, **uuids, *name;
gboolean is_connected;
BluetoothType type;
GtkAction *action, *status, *oper;
gtk_tree_model_get (devices_model, &iter,
BLUETOOTH_COLUMN_PROXY, &proxy,
BLUETOOTH_COLUMN_ADDRESS, &address,
BLUETOOTH_COLUMN_SERVICES, &services,
BLUETOOTH_COLUMN_ALIAS, &alias,
BLUETOOTH_COLUMN_UUIDS, &uuids,
BLUETOOTH_COLUMN_TYPE, &type,
-1);
if (device_has_submenu ((const char **) uuids, services, type) == FALSE ||
address == NULL || proxy == NULL || alias == NULL) {
if (proxy != NULL)
g_object_unref (proxy);
if (services != NULL)
g_hash_table_unref (services);
g_strfreev (uuids);
g_free (alias);
g_free (address);
cont = gtk_tree_model_iter_next (devices_model, &iter);
continue;
}
action = gtk_action_group_get_action (devices_action_group, address);
oper = NULL;
status = NULL;
if (action) {
char *action_name;
actions = g_list_remove (actions, action);
action_name = g_strdup_printf ("%s-status", address);
status = gtk_action_group_get_action (devices_action_group, action_name);
g_free (action_name);
action_name = g_strdup_printf ("%s-action", address);
oper = gtk_action_group_get_action (devices_action_group, action_name);
g_free (action_name);
}
/* If one service is connected, then we're connected */
is_connected = FALSE;
if (services != NULL) {
GList *list, *l;
list = g_hash_table_get_values (services);
for (l = list; l != NULL; l = l->next) {
BluetoothStatus val = GPOINTER_TO_INT (l->data);
if (val == BLUETOOTH_STATUS_CONNECTED ||
val == BLUETOOTH_STATUS_PLAYING) {
is_connected = TRUE;
break;
}
}
g_list_free (list);
}
name = escape_label_for_action (alias);
if (action == NULL) {
guint menu_merge_id;
char *action_path;
/* The menu item with descendants */
action = gtk_action_new (address, name, NULL, NULL);
gtk_action_group_add_action (devices_action_group, action);
g_object_unref (action);
menu_merge_id = gtk_ui_manager_new_merge_id (uimanager);
gtk_ui_manager_add_ui (uimanager, menu_merge_id,
"/bluetooth-applet-popup/devices-placeholder", address, address,
GTK_UI_MANAGER_MENU, FALSE);
g_object_set_data_full (G_OBJECT (action),
"merge-id", GUINT_TO_POINTER (menu_merge_id), NULL);
/* The status menu item */
status = add_menu_item (address,
"status",
is_connected ? _("Connected") : _("Disconnected"),
uimanager,
menu_merge_id,
NULL);
gtk_action_set_sensitive (status, FALSE);
if (services != NULL) {
action_path = g_strdup_printf ("/bluetooth-applet-popup/devices-placeholder/%s/%s-status",
address, address);
action_set_bold (uimanager, status, action_path);
g_free (action_path);
} else {
gtk_action_set_visible (status, FALSE);
}
/* The connect button */
oper = add_menu_item (address,
"action",
is_connected ? _("Disconnect") : _("Connect"),
uimanager,
menu_merge_id,
G_CALLBACK (on_connect_activate));
if (services == NULL)
gtk_action_set_visible (oper, FALSE);
add_separator_item (address, "connect-sep", uimanager, menu_merge_id);
/* The Send to... button */
if (device_has_uuid ((const char **) uuids, "OBEXObjectPush") != FALSE) {
add_menu_item (address,
"sendto",
_("Send files..."),
uimanager,
menu_merge_id,
G_CALLBACK (sendto_callback));
g_object_set_data_full (G_OBJECT (action),
"alias", g_strdup (alias), g_free);
}
if (device_has_uuid ((const char **) uuids, "OBEXFileTransfer") != FALSE) {
add_menu_item (address,
"browse",
_("Browse files..."),
uimanager,
menu_merge_id,
G_CALLBACK (browse_callback));
}
add_separator_item (address, "files-sep", uimanager, menu_merge_id);
if (type == BLUETOOTH_TYPE_KEYBOARD && program_available (KEYBOARD_PREFS)) {
add_menu_item (address,
"keyboard",
_("Open Keyboard Preferences..."),
uimanager,
menu_merge_id,
G_CALLBACK (keyboard_callback));
}
if (type == BLUETOOTH_TYPE_MOUSE && program_available (MOUSE_PREFS)) {
add_menu_item (address,
"mouse",
_("Open Mouse Preferences..."),
uimanager,
menu_merge_id,
G_CALLBACK (mouse_callback));
}
if ((type == BLUETOOTH_TYPE_HEADSET ||
type == BLUETOOTH_TYPE_HEADPHONES ||
type == BLUETOOTH_TYPE_OTHER_AUDIO) && program_available (SOUND_PREFS)) {
add_menu_item (address,
"sound",
_("Open Sound Preferences..."),
uimanager,
menu_merge_id,
G_CALLBACK (sound_callback));
}
} else {
gtk_action_set_label (action, name);
gtk_action_set_visible (status, services != NULL);
gtk_action_set_visible (oper, services != NULL);
if (services != NULL) {
set_device_status_label (address, is_connected ? CONNECTED : DISCONNECTED);
gtk_action_set_label (oper, is_connected ? _("Disconnect") : _("Connect"));
}
}
g_free (name);
if (oper != NULL) {
g_object_set_data_full (G_OBJECT (oper),
"connected", GINT_TO_POINTER (is_connected ? CONNECTED : DISCONNECTED), NULL);
g_object_set_data_full (G_OBJECT (oper),
"device-path", g_strdup (dbus_g_proxy_get_path (proxy)), g_free);
}
/* And now for the trick of the day */
if (is_connected != FALSE) {
char *path;
path = g_strdup_printf ("/bluetooth-applet-popup/devices-placeholder/%s", address);
action_set_bold (uimanager, action, path);
g_free (path);
}
num_devices++;
if (proxy != NULL)
g_object_unref (proxy);
if (services != NULL)
g_hash_table_unref (services);
g_strfreev (uuids);
g_free (alias);
g_free (address);
cont = gtk_tree_model_iter_next (devices_model, &iter);
}
/* Remove the left-over devices */
g_list_foreach (actions, (GFunc) remove_action_item, uimanager);
g_list_free (actions);
done:
gtk_ui_manager_ensure_update (uimanager);
gtk_action_set_visible (GTK_ACTION (gtk_builder_get_object (xml, "devices-label")),
num_devices > 0);
}
static void
anjuta_docman_update_documents_menu (AnjutaDocman* docman)
{
AnjutaDocmanPriv *priv = docman->priv;
GtkUIManager* ui = GTK_UI_MANAGER (anjuta_shell_get_ui (ANJUTA_PLUGIN (priv->plugin)->shell,
NULL));
GList *actions, *l;
gint n, i;
guint id;
GSList *group = NULL;
g_return_if_fail (priv->documents_action_group != NULL);
if (priv->documents_merge_id != 0)
gtk_ui_manager_remove_ui (ui,
priv->documents_merge_id);
actions = gtk_action_group_list_actions (priv->documents_action_group);
for (l = actions; l != NULL; l = l->next)
{
g_signal_handlers_disconnect_by_func (GTK_ACTION (l->data),
G_CALLBACK (on_document_toggled),
docman);
gtk_action_group_remove_action (priv->documents_action_group,
GTK_ACTION (l->data));
}
g_list_free (actions);
n = gtk_notebook_get_n_pages (GTK_NOTEBOOK (docman));
id = (n > 0) ? gtk_ui_manager_new_merge_id (ui) : 0;
for (i = 0; i < n; i++)
{
AnjutaDocmanPage* page;
GtkRadioAction *action;
gchar *action_name;
const gchar *tab_name;
gchar *accel;
page = anjuta_docman_get_nth_page (docman, i);
/* NOTE: the action is associated to the position of the tab in
* the notebook not to the tab itself! This is needed to work
* around the gtk+ bug #170727: gtk leaves around the accels
* of the action. Since the accel depends on the tab position
* the problem is worked around, action with the same name always
* get the same accel.
*/
action_name = g_strdup_printf ("Tab_%d", i);
tab_name = gtk_label_get_label (GTK_LABEL (page->label));
/* alt + 1, 2, 3... 0 to switch to the first ten tabs */
accel = (i < 10) ? g_strdup_printf ("<alt>%d", (i + 1) % 10) : NULL;
action = gtk_radio_action_new (action_name,
tab_name,
NULL,
NULL,
i);
if (group != NULL)
gtk_radio_action_set_group (action, group);
/* note that group changes each time we add an action, so it must be updated */
group = gtk_radio_action_get_group (action);
gtk_action_group_add_action_with_accel (priv->documents_action_group,
GTK_ACTION (action),
accel);
g_signal_connect (action,
"toggled",
G_CALLBACK (on_document_toggled),
docman);
gtk_ui_manager_add_ui (ui,
id,
MENU_PLACEHOLDER,
action_name, action_name,
GTK_UI_MANAGER_MENUITEM,
FALSE);
if (i == gtk_notebook_get_current_page (GTK_NOTEBOOK (docman)))
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), TRUE);
g_object_unref (action);
g_free (action_name);
g_free (accel);
}
anjuta_docman_update_documents_menu_status (docman);
priv->documents_merge_id = id;
}
static void
update_device_list (BluetoothApplet *applet,
gpointer user_data)
{
GtkUIManager *uimanager;
GList *actions, *devices, *l;
gboolean has_devices = FALSE;
uimanager = GTK_UI_MANAGER (gtk_builder_get_object (xml, "bluetooth-applet-ui-manager"));
devices = bluetooth_applet_get_devices (applet);
if (devices == NULL) {
/* No devices? Remove everything */
actions = gtk_action_group_list_actions (devices_action_group);
g_list_foreach (actions, (GFunc) remove_action_item, uimanager);
g_list_free (actions);
goto done;
}
/* Get a list of actions, and we'll remove the ones with a
* device in the list. We remove the submenu items first */
actions = gtk_action_group_list_actions (devices_action_group);
for (l = actions; l != NULL; l = l->next) {
if (bluetooth_verify_address (gtk_action_get_name (l->data)) == FALSE)
l->data = NULL;
}
actions = g_list_remove_all (actions, NULL);
for (l = devices; l != NULL; l = g_list_next (l)) {
BluetoothSimpleDevice *device = l->data;
GtkAction *action, *status, *oper;
char *name;
if (device_has_submenu (device) == FALSE) {
g_boxed_free (BLUETOOTH_TYPE_SIMPLE_DEVICE, device);
continue;
}
has_devices = TRUE;
action = gtk_action_group_get_action (devices_action_group, device->bdaddr);
oper = NULL;
status = NULL;
if (action) {
char *action_name;
actions = g_list_remove (actions, action);
action_name = g_strdup_printf ("%s-status", device->bdaddr);
status = gtk_action_group_get_action (devices_action_group, action_name);
g_free (action_name);
action_name = g_strdup_printf ("%s-action", device->bdaddr);
oper = gtk_action_group_get_action (devices_action_group, action_name);
g_free (action_name);
}
name = escape_label_for_action (device->alias);
if (action == NULL) {
guint menu_merge_id;
char *action_path;
/* The menu item with descendants */
action = gtk_action_new (device->bdaddr, name, NULL, NULL);
gtk_action_group_add_action (devices_action_group, action);
g_object_unref (action);
menu_merge_id = gtk_ui_manager_new_merge_id (uimanager);
gtk_ui_manager_add_ui (uimanager, menu_merge_id,
"/bluetooth-applet-popup/devices-placeholder", device->bdaddr, device->bdaddr,
GTK_UI_MANAGER_MENU, FALSE);
g_object_set_data_full (G_OBJECT (action),
"merge-id", GUINT_TO_POINTER (menu_merge_id), NULL);
/* The status menu item */
status = add_menu_item (device->bdaddr,
"status",
device->connected ? _("Connected") : _("Disconnected"),
uimanager,
menu_merge_id,
NULL);
gtk_action_set_sensitive (status, FALSE);
if (device->can_connect) {
action_path = g_strdup_printf ("/bluetooth-applet-popup/devices-placeholder/%s/%s-status",
device->bdaddr, device->bdaddr);
action_set_bold (uimanager, status, action_path);
g_free (action_path);
} else {
gtk_action_set_visible (status, FALSE);
}
/* The connect button */
oper = add_menu_item (device->bdaddr,
"action",
device->connected ? _("Disconnect") : _("Connect"),
uimanager,
menu_merge_id,
G_CALLBACK (on_connect_activate));
if (!device->can_connect)
gtk_action_set_visible (oper, FALSE);
add_separator_item (device->bdaddr, "connect-sep", uimanager, menu_merge_id);
/* The Send to... button */
if (device->capabilities & BLUETOOTH_CAPABILITIES_OBEX_PUSH) {
add_menu_item (device->bdaddr,
"sendto",
_("Send files..."),
uimanager,
menu_merge_id,
G_CALLBACK (sendto_callback));
g_object_set_data_full (G_OBJECT (action),
"alias", g_strdup (device->alias), g_free);
}
if (device->capabilities & BLUETOOTH_CAPABILITIES_OBEX_FILE_TRANSFER) {
add_menu_item (device->bdaddr,
"browse",
_("Browse files..."),
uimanager,
menu_merge_id,
G_CALLBACK (browse_callback));
}
add_separator_item (device->bdaddr, "files-sep", uimanager, menu_merge_id);
if (device->type == BLUETOOTH_TYPE_KEYBOARD && program_available (GNOMECC)) {
add_menu_item (device->bdaddr,
"keyboard",
_("Keyboard Settings"),
uimanager,
menu_merge_id,
G_CALLBACK (keyboard_callback));
}
if (device->type == BLUETOOTH_TYPE_MOUSE && program_available (GNOMECC)) {
add_menu_item (device->bdaddr,
"mouse",
_("Mouse and Touchpad Settings"),
uimanager,
menu_merge_id,
G_CALLBACK (mouse_callback));
}
if ((device->type == BLUETOOTH_TYPE_HEADSET ||
device->type == BLUETOOTH_TYPE_HEADPHONES ||
device->type == BLUETOOTH_TYPE_OTHER_AUDIO) && program_available (GNOMECC)) {
add_menu_item (device->bdaddr,
"sound",
_("Sound Settings"),
uimanager,
menu_merge_id,
G_CALLBACK (sound_callback));
}
} else {
gtk_action_set_label (action, name);
if (device->can_connect) {
gtk_action_set_visible (status, TRUE);
gtk_action_set_visible (oper, TRUE);
set_device_status_label (device->bdaddr, device->connected ? CONNECTED : DISCONNECTED);
gtk_action_set_label (oper, device->connected ? _("Disconnect") : _("Connect"));
} else {
gtk_action_set_visible (status, FALSE);
gtk_action_set_visible (oper, FALSE);
}
}
g_free (name);
if (oper != NULL) {
g_object_set_data_full (G_OBJECT (oper),
"connected", GINT_TO_POINTER (device->connected ? CONNECTED : DISCONNECTED), NULL);
g_object_set_data_full (G_OBJECT (oper),
"device-path", g_strdup (device->device_path), g_free);
}
/* And now for the trick of the day */
if (device->connected != FALSE) {
char *path;
path = g_strdup_printf ("/bluetooth-applet-popup/devices-placeholder/%s", device->bdaddr);
action_set_bold (uimanager, action, path);
g_free (path);
}
g_boxed_free (BLUETOOTH_TYPE_SIMPLE_DEVICE, device);
}
/* Remove the left-over devices */
g_list_foreach (actions, (GFunc) remove_action_item, uimanager);
g_list_free (actions);
/* Cleanup */
g_list_free (devices);
done:
gtk_ui_manager_ensure_update (uimanager);
gtk_action_set_visible (GTK_ACTION (gtk_builder_get_object (xml, "devices-label")),
has_devices);
}
void
debug_dump_keyboard_shortcuts_cmd_callback (GtkAction *action,
gpointer data)
{
GimpDisplay *display;
GimpImageWindow *window;
GtkUIManager *manager;
GtkAccelGroup *accel_group;
GList *group_it;
GList *strings = NULL;
return_if_no_display (display, data);
window = gimp_display_shell_get_window (gimp_display_get_shell (display));
manager = GTK_UI_MANAGER (gimp_image_window_get_ui_manager (window));
accel_group = gtk_ui_manager_get_accel_group (manager);
/* Gather formated strings of keyboard shortcuts */
for (group_it = gtk_ui_manager_get_action_groups (manager);
group_it;
group_it = g_list_next (group_it))
{
GimpActionGroup *group = group_it->data;
GList *actions = NULL;
GList *action_it = NULL;
actions = gtk_action_group_list_actions (GTK_ACTION_GROUP (group));
actions = g_list_sort (actions, (GCompareFunc) gimp_action_name_compare);
for (action_it = actions; action_it; action_it = g_list_next (action_it))
{
GtkAction *action = action_it->data;
const gchar *name = gtk_action_get_name (action);
GClosure *accel_closure = NULL;
if (strstr (name, "-menu") ||
strstr (name, "-popup") ||
name[0] == '<')
continue;
accel_closure = gtk_action_get_accel_closure (action);
if (accel_closure)
{
GtkAccelKey *key = gtk_accel_group_find (accel_group,
debug_accel_find_func,
accel_closure);
if (key &&
key->accel_key &&
key->accel_flags & GTK_ACCEL_VISIBLE)
{
const gchar *label_tmp;
gchar *label;
gchar *key_string;
label_tmp = gtk_action_get_label (action);
label = gimp_strip_uline (label_tmp);
key_string = gtk_accelerator_get_label (key->accel_key,
key->accel_mods);
strings = g_list_prepend (strings,
g_strdup_printf ("%-20s %s",
key_string, label));
g_free (key_string);
g_free (label);
}
}
}
g_list_free (actions);
}
/* Sort and prints the strings */
{
GList *string_it = NULL;
strings = g_list_sort (strings, (GCompareFunc) strcmp);
for (string_it = strings; string_it; string_it = g_list_next (string_it))
{
g_print ("%s\n", (gchar *) string_it->data);
g_free (string_it->data);
}
g_list_free (strings);
}
}
void
gtkhtml_editor_update_context (GtkhtmlEditor *editor)
{
GtkHTML *html;
HTMLType type;
HTMLObject *object;
GtkUIManager *manager;
GtkActionGroup *action_group;
GList *list;
gboolean visible;
guint merge_id;
html = gtkhtml_editor_get_html (editor);
manager = gtkhtml_editor_get_ui_manager (editor);
gtk_html_update_styles (html);
/* Update context menu item visibility. */
object = html->engine->cursor->object;
if (object != NULL)
type = HTML_OBJECT_TYPE (object);
else
type = HTML_TYPE_NONE;
visible = (type == HTML_TYPE_IMAGE);
gtk_action_set_visible (ACTION (CONTEXT_PROPERTIES_IMAGE), visible);
visible = (type == HTML_TYPE_LINKTEXT);
gtk_action_set_visible (ACTION (CONTEXT_PROPERTIES_LINK), visible);
visible = (type == HTML_TYPE_RULE);
gtk_action_set_visible (ACTION (CONTEXT_PROPERTIES_RULE), visible);
visible = (type == HTML_TYPE_TEXT);
gtk_action_set_visible (ACTION (CONTEXT_PROPERTIES_TEXT), visible);
visible =
gtk_action_get_visible (ACTION (CONTEXT_PROPERTIES_IMAGE)) ||
gtk_action_get_visible (ACTION (CONTEXT_PROPERTIES_LINK)) ||
gtk_action_get_visible (ACTION (CONTEXT_PROPERTIES_TEXT));
gtk_action_set_visible (ACTION (CONTEXT_PROPERTIES_PARAGRAPH), visible);
/* Set to visible if any of these are true:
* - Selection is active and contains a link.
* - Cursor is on a link.
* - Cursor is on an image that has a URL or target.
*/
visible =
(html_engine_is_selection_active (html->engine) &&
html_engine_selection_contains_link (html->engine)) ||
(type == HTML_TYPE_LINKTEXT) ||
(type == HTML_TYPE_IMAGE &&
(HTML_IMAGE (object)->url != NULL ||
HTML_IMAGE (object)->target != NULL));
gtk_action_set_visible (ACTION (CONTEXT_REMOVE_LINK), visible);
/* Get the parent object. */
object = (object != NULL) ? object->parent : NULL;
/* Get the grandparent object. */
object = (object != NULL) ? object->parent : NULL;
if (object != NULL)
type = HTML_OBJECT_TYPE (object);
else
type = HTML_TYPE_NONE;
visible = (type == HTML_TYPE_TABLECELL);
gtk_action_set_visible (ACTION (CONTEXT_DELETE_CELL), visible);
gtk_action_set_visible (ACTION (CONTEXT_DELETE_COLUMN), visible);
gtk_action_set_visible (ACTION (CONTEXT_DELETE_ROW), visible);
gtk_action_set_visible (ACTION (CONTEXT_DELETE_TABLE), visible);
gtk_action_set_visible (ACTION (CONTEXT_INSERT_COLUMN_AFTER), visible);
gtk_action_set_visible (ACTION (CONTEXT_INSERT_COLUMN_BEFORE), visible);
gtk_action_set_visible (ACTION (CONTEXT_INSERT_ROW_ABOVE), visible);
gtk_action_set_visible (ACTION (CONTEXT_INSERT_ROW_BELOW), visible);
gtk_action_set_visible (ACTION (CONTEXT_INSERT_TABLE), visible);
gtk_action_set_visible (ACTION (CONTEXT_PROPERTIES_CELL), visible);
/* Get the great grandparent object. */
object = (object != NULL) ? object->parent : NULL;
if (object != NULL)
type = HTML_OBJECT_TYPE (object);
else
type = HTML_TYPE_NONE;
/* Note the |= (cursor must be in a table cell). */
visible |= (type == HTML_TYPE_TABLE);
gtk_action_set_visible (ACTION (CONTEXT_PROPERTIES_TABLE), visible);
/********************** Spell Check Suggestions **********************/
object = html->engine->cursor->object;
action_group = editor->priv->suggestion_actions;
/* Remove the old content from the context menu. */
merge_id = editor->priv->spell_suggestions_merge_id;
if (merge_id > 0) {
gtk_ui_manager_remove_ui (manager, merge_id);
editor->priv->spell_suggestions_merge_id = 0;
}
/* Clear the action group for spelling suggestions. */
list = gtk_action_group_list_actions (action_group);
while (list != NULL) {
GtkAction *action = list->data;
gtk_action_group_remove_action (action_group, action);
list = g_list_delete_link (list, list);
}
/* Decide if we should show spell checking items. */
visible =
!html_engine_is_selection_active (html->engine) &&
object != NULL && html_object_is_text (object) &&
!html_engine_spell_word_is_valid (html->engine);
action_group = editor->priv->spell_check_actions;
gtk_action_group_set_visible (action_group, visible);
/* Exit early if spell checking items are invisible. */
if (!visible)
return;
list = editor->priv->active_spell_checkers;
merge_id = gtk_ui_manager_new_merge_id (manager);
editor->priv->spell_suggestions_merge_id = merge_id;
/* Handle a single active language as a special case. */
if (g_list_length (list) == 1) {
editor_inline_spelling_suggestions (editor, list->data);
return;
}
/* Add actions and context menu content for active languages. */
g_list_foreach (list, (GFunc) editor_spell_checkers_foreach, editor);
}
