static void
introduce_view (GtkMvcController* controller,
GtkMvcView * view)
{
if (PRIV (controller)->view == view)
{
/* FIXME: test this */
return;
}
if (PRIV (controller)->view)
{
g_object_weak_unref (G_OBJECT (PRIV (controller)->view),
detach_view,
controller);
PRIV (controller)->view = NULL;
}
if (view)
{
PRIV (controller)->view = view;
g_object_weak_ref (G_OBJECT (view), detach_view, controller);
}
}
static void
gail_notebook_real_initialize (AtkObject *obj,
gpointer data)
{
GailNotebook *notebook;
GtkNotebook *gtk_notebook;
gint i;
ATK_OBJECT_CLASS (gail_notebook_parent_class)->initialize (obj, data);
notebook = GAIL_NOTEBOOK (obj);
gtk_notebook = GTK_NOTEBOOK (data);
for (i = 0; i < g_list_length (gtk_notebook->children); i++)
{
create_notebook_page_accessible (notebook, gtk_notebook, i, FALSE, NULL);
}
notebook->page_count = i;
notebook->selected_page = gtk_notebook_get_current_page (gtk_notebook);
if (gtk_notebook->focus_tab && gtk_notebook->focus_tab->data)
{
notebook->focus_tab_page = g_list_index (gtk_notebook->children, gtk_notebook->focus_tab->data);
}
g_signal_connect (gtk_notebook,
"focus",
G_CALLBACK (gail_notebook_focus_cb),
NULL);
g_signal_connect (gtk_notebook,
"page-added",
G_CALLBACK (gail_notebook_page_added),
NULL);
g_object_weak_ref (G_OBJECT(gtk_notebook),
(GWeakNotify) gail_notebook_destroyed,
obj);
obj->role = ATK_ROLE_PAGE_TAB_LIST;
}
static void
watch_smartcards_from_driver_async (GsdSmartcardManager *self,
SECMODModule *driver,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GsdSmartcardManagerPrivate *priv = self->priv;
GTask *task;
WatchSmartcardsOperation *operation;
operation = g_new0 (WatchSmartcardsOperation, 1);
operation->driver = SECMOD_ReferenceModule (driver);
operation->smartcards = g_hash_table_new_full (g_direct_hash,
g_direct_equal,
NULL,
(GDestroyNotify) PK11_FreeSlot);
task = g_task_new (self, cancellable, callback, user_data);
g_task_set_task_data (task,
operation,
(GDestroyNotify) destroy_watch_smartcards_operation);
G_LOCK (gsd_smartcards_watch_tasks);
priv->smartcards_watch_tasks = g_list_prepend (priv->smartcards_watch_tasks,
task);
g_object_weak_ref (G_OBJECT (task),
(GWeakNotify) on_smartcards_watch_task_destroyed,
self);
G_UNLOCK (gsd_smartcards_watch_tasks);
sync_initial_tokens_from_driver (self, driver, operation->smartcards, cancellable);
g_task_run_in_thread (task, (GTaskThreadFunc) watch_smartcards_from_driver);
}
static gboolean
ide_editor_view__focus_in_event (IdeEditorView *self,
GdkEvent *event,
IdeSourceView *source_view)
{
g_assert (IDE_IS_EDITOR_VIEW (self));
g_assert (IDE_IS_SOURCE_VIEW (source_view));
if (self->last_focused_frame && self->last_focused_frame->source_view == source_view)
return FALSE;
if (self->frame2 && self->frame2->source_view == source_view)
{
self->last_focused_frame = self->frame2;
g_object_weak_ref (G_OBJECT (self->frame2), ide_editor_view__focused_frame_weak_notify, self);
}
else
{
g_object_weak_unref (G_OBJECT (self->frame2), ide_editor_view__focused_frame_weak_notify, self);
self->last_focused_frame = self->frame1;
}
return FALSE;
}
void
adb_register_start(EinaAdb *self, LomoPlayer *lomo)
{
g_return_if_fail(EINA_IS_ADB(self));
g_return_if_fail(LOMO_IS_PLAYER(lomo));
g_return_if_fail(eina_adb_upgrade_schema(self, "register", upgrade_funcs, NULL));
g_object_ref(lomo);
g_object_weak_ref((GObject *) lomo, adb_register_weak_ref_cb, NULL);
GList *iter = (GList *) lomo_player_get_playlist(lomo);
while (iter)
{
eina_adb_lomo_stream_attach_sid(self, LOMO_STREAM(iter->data));
iter = iter->next;
}
lomo_player_hook_add(lomo, (LomoPlayerHook) lomo_insert_hook, self);
gint i;
for (i = 0; __signal_table[i].signal != NULL; i++)
g_signal_connect(lomo, __signal_table[i].signal, (GCallback) __signal_table[i].handler, self);
}
/**
* atk_gobject_accessible_for_object:
* @obj: a #GObject
*
* Gets the accessible object for the specified @obj.
*
* Returns: (transfer none): a #AtkObject which is the accessible object for
* the @obj
**/
AtkObject*
atk_gobject_accessible_for_object (GObject *obj)
{
AtkObject* accessible;
g_return_val_if_fail (G_IS_OBJECT (obj), NULL);
/* See if we have a cached accessible for this object */
accessible = g_object_get_qdata (obj,
quark_accessible_object);
if (!accessible)
{
AtkObjectFactory *factory;
AtkRegistry *default_registry;
default_registry = atk_get_default_registry ();
factory = atk_registry_get_factory (default_registry,
G_OBJECT_TYPE (obj));
accessible = atk_object_factory_create_accessible (factory,
obj);
if (!ATK_IS_GOBJECT_ACCESSIBLE (accessible))
{
/*
* The AtkObject which was created was not a AtkGObjectAccessible
*/
g_object_weak_ref (obj,
(GWeakNotify) g_object_unref,
accessible);
if (!quark_accessible_object)
quark_accessible_object = g_quark_from_static_string ("accessible-object");
}
g_object_set_qdata (obj, quark_accessible_object, accessible);
}
return accessible;
}
void
rbgobj_gobject_initialize(VALUE obj, gpointer cobj)
{
gobj_holder* holder = g_object_get_qdata((GObject*)cobj, RUBY_GOBJECT_OBJ_KEY);
if (holder)
rb_raise(rb_eRuntimeError, "ruby wrapper for this GObject* already exists.");
Data_Get_Struct(obj, gobj_holder, holder);
holder->cinfo = RVAL2CINFO(obj);
holder->gobj = (GObject*)cobj;
holder->destroyed = FALSE;
g_object_set_qdata((GObject*)cobj, RUBY_GOBJECT_OBJ_KEY, (gpointer)holder);
g_object_weak_ref((GObject*)cobj, (GWeakNotify)weak_notify, holder);
{
GType t1 = G_TYPE_FROM_INSTANCE(cobj);
GType t2 = CLASS2GTYPE(CLASS_OF(obj));
if (t1 != t2) {
if (!g_type_is_a(t1, t2))
rb_raise(rb_eTypeError, "%s is not subtype of %s",
g_type_name(t1), g_type_name(t2));
}
}
}
void
egg_state_machine_add_style (EggStateMachine *self,
const gchar *state,
GtkWidget *widget,
const gchar *style)
{
EggStateMachinePrivate *priv = egg_state_machine_get_instance_private (self);
EggState *state_obj;
EggStateStyle *style_obj;
g_return_if_fail (EGG_IS_STATE_MACHINE (self));
g_return_if_fail (state != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (style != NULL);
state_obj = egg_state_machine_get_state_obj (self, state);
style_obj = g_slice_new0 (EggStateStyle);
style_obj->state_machine = self;
style_obj->name = g_strdup (style);
style_obj->widget = widget;
g_object_weak_ref (G_OBJECT (widget),
egg_state_machine__style_object_weak_notify,
style_obj);
g_ptr_array_add (state_obj->styles, style_obj);
if (g_strcmp0 (state, priv->state) == 0)
{
GtkStyleContext *style_context;
style_context = gtk_widget_get_style_context (widget);
gtk_style_context_add_class (style_context, style);
}
}
void
edit_bookmarks_dialog_set_signals (GObject *undo_manager_source)
{
g_signal_handler_disconnect (jump_button,
jump_button_signal_id);
g_signal_handler_disconnect (sort_button,
sort_button_signal_id);
g_signal_handler_disconnect (bookmark_list_widget,
row_activated_signal_id);
jump_button_signal_id =
g_signal_connect (jump_button, "clicked",
G_CALLBACK (on_jump_button_clicked), undo_manager_source);
sort_button_signal_id =
g_signal_connect (sort_button, "clicked",
G_CALLBACK (on_sort_button_clicked), NULL);
row_activated_signal_id =
g_signal_connect (bookmark_list_widget, "row_activated",
G_CALLBACK (on_row_activated), undo_manager_source);
g_object_weak_ref (G_OBJECT (undo_manager_source), edit_bookmarks_dialog_reset_signals,
undo_manager_source);
}
GtkWidget *
pgd_find_create_widget (PopplerDocument *document)
{
PgdFindDemo *demo;
GtkWidget *vbox, *hbox;
GtkWidget *button;
GtkWidget *swindow;
GtkWidget *checkbutton;
GtkTreeModel *model;
GtkWidget *treeview;
GtkCellRenderer *renderer;
GtkWidget *hpaned;
GtkTreeSelection *selection;
demo = g_new0 (PgdFindDemo, 1);
demo->doc = g_object_ref (document);
demo->n_pages = poppler_document_get_n_pages (document);
demo->selected_page = -1;
demo->options = POPPLER_FIND_DEFAULT;
hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_paned_set_position (GTK_PANED (hpaned), 300);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
demo->entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (hbox), demo->entry, FALSE, TRUE, 0);
gtk_widget_show (demo->entry);
demo->progress = gtk_progress_bar_new ();
gtk_progress_bar_set_ellipsize (GTK_PROGRESS_BAR (demo->progress),
PANGO_ELLIPSIZE_END);
gtk_box_pack_start (GTK_BOX (hbox), demo->progress, TRUE, TRUE, 0);
gtk_widget_show (demo->progress);
button = gtk_button_new_with_label ("Find");
gtk_widget_set_sensitive (button, FALSE);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (pgd_find_button_clicked),
(gpointer)demo);
g_signal_connect_swapped (G_OBJECT (demo->entry), "changed",
G_CALLBACK (pgd_find_button_sensitivity_cb),
(gpointer)button);
gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 6);
gtk_widget_show (hbox);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
checkbutton = gtk_check_button_new_with_label ("Case sensitive");
g_signal_connect (checkbutton, "toggled",
G_CALLBACK (pgd_find_case_sensitive_toggled),
demo);
gtk_box_pack_start (GTK_BOX (hbox), checkbutton, FALSE, FALSE, 0);
gtk_widget_show (checkbutton);
checkbutton = gtk_check_button_new_with_label ("Backwards");
g_signal_connect (checkbutton, "toggled",
G_CALLBACK (pgd_find_backwards_toggled),
demo);
gtk_box_pack_start (GTK_BOX (hbox), checkbutton, FALSE, FALSE, 0);
gtk_widget_show (checkbutton);
checkbutton = gtk_check_button_new_with_label ("Whole words only");
g_signal_connect (checkbutton, "toggled",
G_CALLBACK (pgd_find_whole_words_toggled),
demo);
gtk_box_pack_start (GTK_BOX (hbox), checkbutton, FALSE, FALSE, 0);
gtk_widget_show (checkbutton);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
model = pgd_find_create_model ();
treeview = gtk_tree_view_new_with_model (model);
g_object_unref (model);
demo->treeview = treeview;
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview), TRUE);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
g_signal_connect (selection, "changed",
G_CALLBACK (pgd_find_selection_changed),
demo);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
TITLE_COLUMN, "Matches",
renderer,
"text", TITLE_COLUMN,
NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
X1_COLUMN, "X1",
renderer,
"text", X1_COLUMN,
"visible", VISIBLE_COLUMN,
NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
Y1_COLUMN, "Y1",
renderer,
"text", Y1_COLUMN,
"visible", VISIBLE_COLUMN,
NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
X2_COLUMN, "X2",
renderer,
"text", X2_COLUMN,
"visible", VISIBLE_COLUMN,
NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
Y2_COLUMN, "Y2",
renderer,
"text", Y2_COLUMN,
"visible", VISIBLE_COLUMN,
NULL);
gtk_container_add (GTK_CONTAINER (swindow), treeview);
gtk_widget_show (treeview);
gtk_paned_add1 (GTK_PANED (hpaned), swindow);
gtk_widget_show (swindow);
demo->darea = gtk_drawing_area_new ();
g_signal_connect (demo->darea, "draw",
G_CALLBACK (pgd_find_viewer_drawing_area_draw),
demo);
swindow = gtk_scrolled_window_new (NULL, NULL);
#if GTK_CHECK_VERSION(3, 7, 8)
gtk_container_add(GTK_CONTAINER(swindow), demo->darea);
#else
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (swindow), demo->darea);
#endif
gtk_widget_show (demo->darea);
gtk_paned_add2 (GTK_PANED (hpaned), swindow);
gtk_widget_show (swindow);
gtk_box_pack_start (GTK_BOX (vbox), hpaned, TRUE, TRUE, 0);
gtk_widget_show (hpaned);
g_object_weak_ref (G_OBJECT (vbox),
(GWeakNotify)pgd_find_free,
(gpointer)demo);
return vbox;
}
BonoboControl *
eab_vcard_control_new (void)
{
BonoboControl *control;
BonoboPersistStream *stream;
GtkWidget *display;
GtkWidget *button1, *button2;
GtkWidget *bbox;
GtkWidget *vbox;
EABVCardControl *vcard_control = g_new (EABVCardControl, 1);
vcard_control->card_list = NULL;
vcard_control->display = NULL;
vcard_control->label = NULL;
vcard_control->render_mode = EAB_CONTACT_DISPLAY_RENDER_COMPACT;
/* Create the control. */
display = eab_contact_display_new ();
vcard_control->display = EAB_CONTACT_DISPLAY (display);
bbox = gtk_hbutton_box_new ();
gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_START);
gtk_box_set_spacing (GTK_BOX (bbox), 12);
button1 = gtk_button_new_with_label(_("Show Full vCard"));
g_signal_connect (button1, "clicked",
G_CALLBACK (toggle_full_vcard), vcard_control);
gtk_box_pack_start (GTK_BOX (bbox), button1, FALSE, FALSE, 0);
button2 = gtk_button_new_with_label(_("Save in addressbook"));
g_signal_connect (button2, "clicked",
G_CALLBACK (save_in_addressbook), vcard_control);
gtk_box_pack_start (GTK_BOX (bbox), button2, FALSE, FALSE, 0);
/* This is intentionally not shown. */
vcard_control->label = gtk_label_new ("");
vbox = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), bbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), display, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), vcard_control->label, TRUE, TRUE, 0);
gtk_widget_show_all (bbox);
gtk_widget_show (display);
gtk_widget_show (vbox);
control = bonobo_control_new (vbox);
g_object_weak_ref (G_OBJECT (control), free_struct, vcard_control);
stream = bonobo_persist_stream_new (pstream_load, pstream_save,
pstream_get_content_types,
VCARD_CONTROL_ID,
vcard_control);
if (stream == NULL) {
bonobo_object_unref (BONOBO_OBJECT (control));
return NULL;
}
bonobo_object_add_interface (BONOBO_OBJECT (control),
BONOBO_OBJECT (stream));
return control;
}
int
main (int argc, char **argv)
{
DBusGConnection *session_bus;
GError *error = NULL;
RBShell *rb_shell;
gboolean activated;
gboolean autostarted;
char *accel_map_file = NULL;
char *desktop_file_path;
GOptionContext *context;
static const GOptionEntry options [] = {
{ "debug", 'd', 0, G_OPTION_ARG_NONE, &debug, N_("Enable debug output"), NULL },
{ "debug-match", 'D', 0, G_OPTION_ARG_STRING, &debug_match, N_("Enable debug output matching a specified string"), NULL },
{ "no-update", 0, 0, G_OPTION_ARG_NONE, &no_update, N_("Do not update the library with file changes"), NULL },
{ "no-registration", 'n', 0, G_OPTION_ARG_NONE, &no_registration, N_("Do not register the shell"), NULL },
{ "dry-run", 0, 0, G_OPTION_ARG_NONE, &dry_run, N_("Don't save any data permanently (implies --no-registration)"), NULL },
{ "disable-plugins", 0, 0, G_OPTION_ARG_NONE, &disable_plugins, N_("Disable loading of plugins"), NULL },
{ "rhythmdb-file", 0, 0, G_OPTION_ARG_STRING, &rhythmdb_file, N_("Path for database file to use"), NULL },
{ "playlists-file", 0, 0, G_OPTION_ARG_STRING, &playlists_file, N_("Path for playlists file to use"), NULL },
{ "quit", 'q', 0, G_OPTION_ARG_NONE, &quit, N_("Quit Rhythmbox"), NULL },
{ G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_STRING_ARRAY, &remaining_args, NULL, N_("[URI...]") },
{ NULL }
};
g_thread_init (NULL);
rb_profile_start ("starting rhythmbox");
autostarted = (g_getenv ("DESKTOP_AUTOSTART_ID") != NULL);
#ifdef USE_UNINSTALLED_DIRS
desktop_file_path = g_build_filename (SHARE_UNINSTALLED_BUILDDIR, "rhythmbox.desktop", NULL);
g_setenv ("GSETTINGS_SCHEMA_DIR", SHARE_UNINSTALLED_BUILDDIR, TRUE);
#else
desktop_file_path = g_build_filename (DATADIR, "applications", "rhythmbox.desktop", NULL);
#endif
egg_set_desktop_file (desktop_file_path);
g_free (desktop_file_path);
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, options, GETTEXT_PACKAGE);
rb_profile_start ("initializing gstreamer");
g_option_context_add_group (context, gst_init_get_option_group ());
rb_profile_end ("initializing gstreamer");
g_option_context_add_group (context, egg_sm_client_get_option_group ());
g_option_context_add_group (context, gtk_get_option_group (TRUE));
setlocale (LC_ALL, NULL);
rb_profile_start ("parsing command line options");
if (g_option_context_parse (context, &argc, &argv, &error) == FALSE) {
g_print (_("%s\nRun '%s --help' to see a full list of available command line options.\n"),
error->message, argv[0]);
g_error_free (error);
g_option_context_free (context);
exit (1);
}
g_option_context_free (context);
rb_profile_end ("parsing command line options");
g_random_set_seed (time (0));
#ifdef ENABLE_NLS
/* initialize i18n */
bindtextdomain (GETTEXT_PACKAGE, GNOMELOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
/* ask for utf-8 message text from GStreamer too,
* since it doesn't do that itself.
*/
bind_textdomain_codeset ("gstreamer-0.10", "UTF-8");
textdomain (GETTEXT_PACKAGE);
#endif
if (!debug && debug_match)
rb_debug_init_match (debug_match);
else
rb_debug_init (debug);
rb_debug ("initializing Rhythmbox %s", VERSION);
#if defined(USE_UNINSTALLED_DIRS)
g_irepository_prepend_search_path (SHARE_UNINSTALLED_BUILDDIR "/../bindings/gi");
#endif
/* TODO: kill this function */
rb_threads_init ();
gdk_threads_enter ();
activated = FALSE;
rb_debug ("going to create DBus object");
dbus_g_thread_init ();
session_bus = dbus_g_bus_get (DBUS_BUS_SESSION, &error);
if (session_bus == NULL) {
g_warning ("couldn't connect to session bus: %s", (error) ? error->message : "(null)");
g_clear_error (&error);
} else if (!no_registration) {
guint request_name_reply;
int flags;
#ifndef DBUS_NAME_FLAG_DO_NOT_QUEUE
flags = DBUS_NAME_FLAG_PROHIBIT_REPLACEMENT;
#else
flags = DBUS_NAME_FLAG_DO_NOT_QUEUE;
#endif
DBusGProxy *bus_proxy;
bus_proxy = dbus_g_proxy_new_for_name (session_bus,
"org.freedesktop.DBus",
"/org/freedesktop/DBus",
"org.freedesktop.DBus");
if (!dbus_g_proxy_call (bus_proxy,
"RequestName",
&error,
G_TYPE_STRING,
"org.gnome.Rhythmbox",
G_TYPE_UINT,
flags,
G_TYPE_INVALID,
G_TYPE_UINT,
&request_name_reply,
G_TYPE_INVALID)) {
g_warning ("Failed to invoke RequestName: %s",
error->message);
}
g_object_unref (bus_proxy);
if (request_name_reply == DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER
|| request_name_reply == DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER)
activated = FALSE;
else if (request_name_reply == DBUS_REQUEST_NAME_REPLY_EXISTS
|| request_name_reply == DBUS_REQUEST_NAME_REPLY_IN_QUEUE)
activated = TRUE;
else {
g_warning ("Got unhandled reply %u from RequestName",
request_name_reply);
activated = FALSE;
}
}
if (!activated) {
if (quit) {
rb_debug ("was asked to quit, but no instance was running");
gdk_notify_startup_complete ();
exit (0);
}
#ifdef WITH_RHYTHMDB_GDA
gda_init (PACKAGE, VERSION, argc, argv);
#endif
rb_refstring_system_init ();
#ifdef USE_UNINSTALLED_DIRS
rb_file_helpers_init (TRUE);
#else
rb_file_helpers_init (FALSE);
#endif
/* XXX not sure what to do with this. should we move it to
* the config dir, or leave it where it is?
*/
accel_map_file = g_build_filename (g_get_home_dir (),
".gnome2",
"accels",
"rhythmbox",
NULL);
gtk_accel_map_load (accel_map_file);
rb_debug ("Going to create a new shell");
rb_stock_icons_init ();
g_setenv ("PULSE_PROP_media.role", "music", TRUE);
rb_shell = rb_shell_new (no_registration, no_update, dry_run, autostarted, disable_plugins, rhythmdb_file, playlists_file);
g_object_weak_ref (G_OBJECT (rb_shell), main_shell_weak_ref_cb, NULL);
if (!no_registration && session_bus != NULL) {
dbus_g_object_type_install_info (RB_TYPE_SHELL, &dbus_glib_rb_shell_object_info);
dbus_g_connection_register_g_object (session_bus, "/org/gnome/Rhythmbox/Shell", G_OBJECT (rb_shell));
g_signal_connect (G_OBJECT (rb_shell),
"database-load-complete",
G_CALLBACK (database_load_complete),
NULL);
}
} else if (!no_registration && session_bus != NULL) {
DBusGProxy *shell_proxy;
guint32 current_time;
current_time = gdk_x11_display_get_user_time (gdk_display_get_default ());
shell_proxy = dbus_g_proxy_new_for_name_owner (session_bus,
"org.gnome.Rhythmbox",
"/org/gnome/Rhythmbox/Shell",
"org.gnome.Rhythmbox.Shell",
&error);
if (!shell_proxy) {
g_warning ("Couldn't create proxy for Rhythmbox shell: %s",
error->message);
} else {
if (quit) {
dbus_g_proxy_call_no_reply (shell_proxy, "quit",
G_TYPE_INVALID);
} else {
load_uri_args ((const char **) remaining_args, (GFunc) dbus_load_uri, shell_proxy);
dbus_g_proxy_call_no_reply (shell_proxy, "present",
G_TYPE_UINT, current_time,
G_TYPE_INVALID);
}
g_object_unref (G_OBJECT (shell_proxy));
}
}
if (activated) {
gdk_notify_startup_complete ();
} else {
rb_profile_start ("mainloop");
#ifdef ENABLE_PYTHON
if (rb_python_init_successful ()) {
pyg_begin_allow_threads;
gtk_main ();
pyg_end_allow_threads;
} else {
gtk_main ();
}
#else
gtk_main ();
#endif
rb_profile_end ("mainloop");
rb_debug ("out of toplevel loop");
rb_file_helpers_shutdown ();
rb_stock_icons_shutdown ();
rb_refstring_system_shutdown ();
}
gst_deinit ();
rb_debug ("THE END");
rb_profile_end ("starting rhythmbox");
if (accel_map_file != NULL) {
gtk_accel_map_save (accel_map_file);
}
gdk_threads_leave ();
exit (0);
}
/**
* signon_identity_create_session:
* @self: the #SignonIdentity.
* @method: method.
* @error: pointer to a location which will receive the error, if any.
*
* Creates an authentication session for this identity.
*
* Returns: (transfer full): a new #SignonAuthSession.
*/
SignonAuthSession *
signon_identity_create_session(SignonIdentity *self,
const gchar *method,
GError **error)
{
g_return_val_if_fail (SIGNON_IS_IDENTITY (self), NULL);
SignonIdentityPrivate *priv = self->priv;
g_return_val_if_fail (priv != NULL, NULL);
DEBUG ("%s %d", G_STRFUNC, __LINE__);
if (method == NULL)
{
DEBUG ("NULL method as input. Aborting.");
g_set_error(error,
signon_error_quark(),
SIGNON_ERROR_UNKNOWN,
"NULL input method.");
return NULL;
}
GSList *list = priv->sessions;
while (list)
{
SignonAuthSession *session = SIGNON_AUTH_SESSION (priv->sessions->data);
const gchar *sessionMethod = signon_auth_session_get_method (session);
if (g_strcmp0(sessionMethod, method) == 0)
{
DEBUG ("Auth Session with method `%s` already created.", method);
g_set_error (error,
signon_error_quark(),
SIGNON_ERROR_METHOD_NOT_AVAILABLE,
"Authentication session for this method already requested.");
return NULL;
}
list = list->next;
}
SignonAuthSession *session = signon_auth_session_new (priv->id,
method,
error);
if (session)
{
DEBUG ("%s %d", G_STRFUNC, __LINE__);
priv->sessions = g_slist_append(priv->sessions, session);
g_object_weak_ref (G_OBJECT(session),
identity_session_object_destroyed_cb,
self);
/*
* if you want to delete the identity
* you MUST delete all authsessions
* first
* */
g_object_ref (self);
priv->signed_out = FALSE;
}
return session;
}
static GObject *
wnck_action_menu_constructor (GType type,
guint n_construct_properties,
GObjectConstructParam *construct_properties)
{
GObject *obj;
WnckActionMenu *menu;
WnckActionMenuPrivate *priv;
GtkWidget *submenu;
GtkWidget *separator;
GSList *pin_group;
WnckScreen *screen;
obj = G_OBJECT_CLASS (wnck_action_menu_parent_class)->constructor (type,
n_construct_properties,
construct_properties);
menu = WNCK_ACTION_MENU (obj);
priv = menu->priv;
if (priv->window == NULL)
{
g_warning ("No window specified during creation of the action menu");
return obj;
}
g_object_weak_ref (G_OBJECT (priv->window), window_weak_notify, menu);
g_object_weak_ref (G_OBJECT (menu), object_weak_notify, priv->window);
priv->minimize_item = make_menu_item (MINIMIZE);
gtk_menu_shell_append (GTK_MENU_SHELL (menu),
priv->minimize_item);
priv->maximize_item = make_menu_item (MAXIMIZE);
gtk_menu_shell_append (GTK_MENU_SHELL (menu),
priv->maximize_item);
priv->move_item = make_menu_item (MOVE);
gtk_menu_shell_append (GTK_MENU_SHELL (menu),
priv->move_item);
set_item_text (priv->move_item, _("_Move"));
set_item_stock (priv->move_item, NULL);
priv->resize_item = make_menu_item (RESIZE);
gtk_menu_shell_append (GTK_MENU_SHELL (menu),
priv->resize_item);
set_item_text (priv->resize_item, _("_Resize"));
set_item_stock (priv->move_item, NULL);
priv->workspace_separator = separator = gtk_separator_menu_item_new ();
gtk_widget_show (separator);
gtk_menu_shell_append (GTK_MENU_SHELL (menu),
separator);
priv->above_item = make_check_menu_item (ABOVE,
_("Always On _Top"));
gtk_menu_shell_append (GTK_MENU_SHELL (menu),
priv->above_item);
pin_group = NULL;
priv->pin_item = make_radio_menu_item (PIN, &pin_group,
_("_Always on Visible Workspace"));
gtk_menu_shell_append (GTK_MENU_SHELL (menu),
priv->pin_item);
priv->unpin_item = make_radio_menu_item (UNPIN, &pin_group,
_("_Only on This Workspace"));
gtk_menu_shell_append (GTK_MENU_SHELL (menu),
priv->unpin_item);
priv->left_item = make_menu_item (LEFT);
gtk_menu_shell_append (GTK_MENU_SHELL (menu),
priv->left_item);
set_item_text (priv->left_item, _("Move to Workspace _Left"));
set_item_stock (priv->left_item, NULL);
priv->right_item = make_menu_item (RIGHT);
gtk_menu_shell_append (GTK_MENU_SHELL (menu),
priv->right_item);
set_item_text (priv->right_item, _("Move to Workspace R_ight"));
set_item_stock (priv->right_item, NULL);
priv->up_item = make_menu_item (UP);
gtk_menu_shell_append (GTK_MENU_SHELL (menu),
priv->up_item);
set_item_text (priv->up_item, _("Move to Workspace _Up"));
set_item_stock (priv->up_item, NULL);
priv->down_item = make_menu_item (DOWN);
gtk_menu_shell_append (GTK_MENU_SHELL (menu),
priv->down_item);
set_item_text (priv->down_item, _("Move to Workspace _Down"));
set_item_stock (priv->down_item, NULL);
priv->workspace_item = gtk_menu_item_new_with_mnemonic (_("Move to Another _Workspace"));
gtk_widget_show (priv->workspace_item);
submenu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (priv->workspace_item),
submenu);
gtk_menu_shell_append (GTK_MENU_SHELL (menu),
priv->workspace_item);
separator = gtk_separator_menu_item_new ();
gtk_widget_show (separator);
gtk_menu_shell_append (GTK_MENU_SHELL (menu),
separator);
priv->close_item = make_menu_item (CLOSE);
gtk_menu_shell_append (GTK_MENU_SHELL (menu),
priv->close_item);
set_item_text (priv->close_item, _("_Close"));
set_item_stock (priv->close_item, WNCK_STOCK_DELETE);
g_signal_connect_object (G_OBJECT (priv->window),
"state_changed",
G_CALLBACK (state_changed_callback),
G_OBJECT (menu),
0);
g_signal_connect_object (G_OBJECT (priv->window),
"actions_changed",
G_CALLBACK (actions_changed_callback),
G_OBJECT (menu),
0);
g_signal_connect_object (G_OBJECT (priv->window),
"workspace_changed",
G_CALLBACK (workspace_changed_callback),
G_OBJECT (menu),
0);
screen = wnck_window_get_screen (priv->window);
g_signal_connect_object (G_OBJECT (screen),
"workspace_created",
G_CALLBACK (screen_workspace_callback),
G_OBJECT (menu),
0);
g_signal_connect_object (G_OBJECT (screen),
"workspace_destroyed",
G_CALLBACK (screen_workspace_callback),
G_OBJECT (menu),
0);
g_signal_connect_object (G_OBJECT (screen),
"viewports_changed",
G_CALLBACK (viewports_changed_callback),
G_OBJECT (menu),
0);
update_menu_state (menu);
return obj;
}
void
exchange_delegates (ExchangeAccount *account,
GtkWidget *parent)
{
GtkWidget *dialog_vbox1;
GtkWidget *vbox2;
GtkWidget *label3;
GtkWidget *delegate_hbox;
GtkWidget *delegates_table;
GtkWidget *vbuttonbox1;
GtkWidget *add_button;
GtkWidget *edit_button;
GtkWidget *remove_button;
ExchangeDelegates *delegates;
ExchangeDelegatesUser *user;
GtkTreeViewColumn *column;
GtkTreeIter iter;
gint i;
g_return_if_fail (GTK_IS_WIDGET (parent));
g_return_if_fail (EXCHANGE_IS_ACCOUNT (account));
delegates = g_new0 (ExchangeDelegates, 1);
delegates->account = g_object_ref (account);
delegates->dialog = gtk_dialog_new_with_buttons (
_("Delegates"),
NULL,
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
dialog_vbox1 = gtk_dialog_get_content_area (GTK_DIALOG (delegates->dialog));
gtk_widget_show (dialog_vbox1);
vbox2 = gtk_vbox_new (FALSE, 6);
gtk_widget_show (vbox2);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox2, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox2), 6);
label3 = gtk_label_new (_("These users will be able to send mail on your behalf\nand access your folders with the permissions you give them."));
gtk_widget_show (label3);
gtk_box_pack_start (GTK_BOX (vbox2), label3, FALSE, FALSE, 0);
delegate_hbox = gtk_hbox_new (FALSE, 6);
gtk_widget_show (delegate_hbox);
gtk_box_pack_start (GTK_BOX (vbox2), delegate_hbox, TRUE, TRUE, 0);
delegates_table = gtk_tree_view_new ();
gtk_widget_show (delegates_table);
gtk_box_pack_start (GTK_BOX (delegate_hbox), delegates_table, TRUE, TRUE, 0);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (delegates_table), FALSE);
vbuttonbox1 = gtk_vbutton_box_new ();
gtk_widget_show (vbuttonbox1);
gtk_box_pack_end (GTK_BOX (delegate_hbox), vbuttonbox1, FALSE, TRUE, 0);
gtk_button_box_set_layout (GTK_BUTTON_BOX (vbuttonbox1), GTK_BUTTONBOX_START);
gtk_box_set_spacing (GTK_BOX (vbuttonbox1), 6);
add_button = gtk_button_new_from_stock ("gtk-add");
gtk_widget_show (add_button);
gtk_container_add (GTK_CONTAINER (vbuttonbox1), add_button);
gtk_widget_set_can_default (add_button, TRUE);
edit_button = gtk_button_new_with_mnemonic (_("_Edit"));
gtk_widget_show (edit_button);
gtk_container_add (GTK_CONTAINER (vbuttonbox1), edit_button);
gtk_widget_set_can_default (edit_button, TRUE);
remove_button = gtk_button_new_from_stock ("gtk-remove");
gtk_widget_show (remove_button);
gtk_container_add (GTK_CONTAINER (vbuttonbox1), remove_button);
gtk_widget_set_can_default (remove_button, TRUE);
g_signal_connect (delegates->dialog, "response",
G_CALLBACK (dialog_response), delegates);
if (parent)
gtk_window_set_transient_for (GTK_WINDOW (delegates->dialog), GTK_WINDOW (parent));
delegates->parent = parent;
g_object_weak_ref (G_OBJECT (parent), parent_destroyed, delegates);
/* Set up the buttons */
g_signal_connect (add_button, "clicked",
G_CALLBACK (add_button_clicked_cb), delegates);
g_signal_connect (edit_button, "clicked",
G_CALLBACK (edit_button_clicked_cb), delegates);
g_signal_connect (remove_button, "clicked",
G_CALLBACK (remove_button_clicked_cb), delegates);
/* Set up the table */
delegates->model = gtk_list_store_new (1, G_TYPE_STRING);
delegates->table = delegates_table;
column = gtk_tree_view_column_new_with_attributes (
_("Name"), gtk_cell_renderer_text_new (), "text", 0, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (delegates->table),
column);
gtk_tree_view_set_model (GTK_TREE_VIEW (delegates->table),
GTK_TREE_MODEL (delegates->model));
/* Get list of delegate users */
if (get_user_list (delegates)) {
for (i = 0; i < delegates->users->len; i++) {
user = delegates->users->pdata[i];
gtk_list_store_append (delegates->model, &iter);
gtk_list_store_set (delegates->model, &iter,
0, user->display_name,
-1);
}
g_signal_connect (delegates->table,
"button_press_event",
G_CALLBACK (table_click_cb), delegates);
} else {
gtk_widget_set_sensitive (add_button, FALSE);
gtk_widget_set_sensitive (edit_button, FALSE);
gtk_widget_set_sensitive (remove_button, FALSE);
gtk_list_store_append (delegates->model, &iter);
gtk_list_store_set (delegates->model, &iter,
0, _("Error reading delegates list."),
-1);
}
gtk_widget_show (delegates->dialog);
}
soyatomsAxis* soy_joints_universal_get_axis2 (soyjointsUniversal* self) {
soyatomsAxis* result;
dxVector3* _tmp0_;
dxVector3* v;
struct dxJoint* _tmp1_;
dxVector3* _tmp2_;
soyatomsAxis* _tmp3_;
soyatomsAxis* _tmp4_;
soyatomsAxis* value;
gboolean _tmp5_ = FALSE;
gboolean _tmp6_ = FALSE;
gboolean _tmp7_ = FALSE;
soyatomsAxis* _tmp8_;
gboolean _tmp14_;
gboolean _tmp20_;
gboolean _tmp26_;
g_return_val_if_fail (self != NULL, NULL);
_tmp0_ = dvector3_new ();
v = _tmp0_;
_tmp1_ = ((soyjointsJoint*) self)->joint;
_tmp2_ = v;
dJointGetUniversalAxis2 ((struct dxJoint*) _tmp1_, _tmp2_);
_tmp3_ = self->priv->_axis2_obj;
_tmp4_ = _g_object_ref0 (_tmp3_);
value = _tmp4_;
_tmp8_ = value;
if (_tmp8_ == NULL) {
_tmp7_ = TRUE;
} else {
dxVector3* _tmp9_;
dReal _tmp10_;
soyatomsAxis* _tmp11_;
gfloat _tmp12_;
gfloat _tmp13_;
_tmp9_ = v;
_tmp10_ = _tmp9_->x;
_tmp11_ = value;
_tmp12_ = soy_atoms_axis_get_x (_tmp11_);
_tmp13_ = _tmp12_;
_tmp7_ = ((gfloat) _tmp10_) != _tmp13_;
}
_tmp14_ = _tmp7_;
if (_tmp14_) {
_tmp6_ = TRUE;
} else {
dxVector3* _tmp15_;
dReal _tmp16_;
soyatomsAxis* _tmp17_;
gfloat _tmp18_;
gfloat _tmp19_;
_tmp15_ = v;
_tmp16_ = _tmp15_->y;
_tmp17_ = value;
_tmp18_ = soy_atoms_axis_get_y (_tmp17_);
_tmp19_ = _tmp18_;
_tmp6_ = ((gfloat) _tmp16_) != _tmp19_;
}
_tmp20_ = _tmp6_;
if (_tmp20_) {
_tmp5_ = TRUE;
} else {
dxVector3* _tmp21_;
dReal _tmp22_;
soyatomsAxis* _tmp23_;
gfloat _tmp24_;
gfloat _tmp25_;
_tmp21_ = v;
_tmp22_ = _tmp21_->z;
_tmp23_ = value;
_tmp24_ = soy_atoms_axis_get_z (_tmp23_);
_tmp25_ = _tmp24_;
_tmp5_ = ((gfloat) _tmp22_) != _tmp25_;
}
_tmp26_ = _tmp5_;
if (_tmp26_) {
soyatomsAxis* _tmp27_;
dxVector3* _tmp31_;
dReal _tmp32_;
dxVector3* _tmp33_;
dReal _tmp34_;
dxVector3* _tmp35_;
dReal _tmp36_;
soyatomsAxis* _tmp37_;
soyatomsAxis* _tmp38_;
soyatomsAxis* _tmp39_;
soyatomsAxis* _tmp40_;
_tmp27_ = value;
if (_tmp27_ != NULL) {
soyatomsAxis* _tmp28_;
guint _tmp29_ = 0U;
soyatomsAxis* _tmp30_;
_tmp28_ = self->priv->_axis2_obj;
g_signal_parse_name ("on-set", SOY_ATOMS_TYPE_AXIS, &_tmp29_, NULL, FALSE);
g_signal_handlers_disconnect_matched (_tmp28_, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp29_, 0, NULL, (GCallback) __soy_joints_universal_axis2_set_soy_atoms_axis_on_set, self);
_tmp30_ = self->priv->_axis2_obj;
g_object_weak_unref ((GObject*) _tmp30_, __soy_joints_universal_axis2_weak_gweak_notify, self);
}
_tmp31_ = v;
_tmp32_ = _tmp31_->x;
_tmp33_ = v;
_tmp34_ = _tmp33_->y;
_tmp35_ = v;
_tmp36_ = _tmp35_->z;
_tmp37_ = soy_atoms_axis_new ((gfloat) _tmp32_, (gfloat) _tmp34_, (gfloat) _tmp36_);
_g_object_unref0 (value);
value = _tmp37_;
_tmp38_ = value;
g_signal_connect_object (_tmp38_, "on-set", (GCallback) __soy_joints_universal_axis2_set_soy_atoms_axis_on_set, self, 0);
_tmp39_ = value;
g_object_weak_ref ((GObject*) _tmp39_, __soy_joints_universal_axis2_weak_gweak_notify, self);
_tmp40_ = value;
self->priv->_axis2_obj = _tmp40_;
}
result = value;
_dvector3_free0 (v);
return result;
}
/*
* Description URL downloaded.
*/
static void
got_description_url (G_GNUC_UNUSED SoupSession *session,
SoupMessage *msg,
GetDescriptionURLData *data)
{
GUPnPXMLDoc *doc;
if (msg->status_code == SOUP_STATUS_CANCELLED)
return;
/* Now, make sure again this document is not already cached. If it is,
* we re-use the cached one. */
doc = g_hash_table_lookup (data->control_point->priv->doc_cache,
data->description_url);
if (doc) {
/* Doc was cached */
description_loaded (data->control_point,
doc,
data->udn,
data->service_type,
data->description_url);
get_description_url_data_free (data);
return;
}
/* Not cached */
if (SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
xmlDoc *xml_doc;
/* Parse response */
xml_doc = xmlRecoverMemory (msg->response_body->data,
msg->response_body->length);
if (xml_doc) {
doc = gupnp_xml_doc_new (xml_doc);
description_loaded (data->control_point,
doc,
data->udn,
data->service_type,
data->description_url);
/* Insert into document cache */
g_hash_table_insert
(data->control_point->priv->doc_cache,
g_strdup (data->description_url),
doc);
/* Make sure the document is removed from the cache
* once finalized. */
g_object_weak_ref (G_OBJECT (doc),
doc_finalized,
data->control_point);
/* If no proxy was created, make sure doc is freed. */
g_object_unref (doc);
} else
g_warning ("Failed to parse %s", data->description_url);
} else
g_warning ("Failed to GET %s: %s",
data->description_url,
msg->reason_phrase);
get_description_url_data_free (data);
}
VectorsOptionsDialog *
vectors_options_dialog_new (GimpImage *image,
GimpVectors *vectors,
GimpContext *context,
GtkWidget *parent,
const gchar *vectors_name,
const gchar *title,
const gchar *role,
const gchar *icon_name,
const gchar *desc,
const gchar *help_id)
{
VectorsOptionsDialog *options;
GimpViewable *viewable;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *table;
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
g_return_val_if_fail (vectors == NULL || GIMP_IS_VECTORS (vectors), NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
g_return_val_if_fail (GTK_IS_WIDGET (parent), NULL);
g_return_val_if_fail (title != NULL, NULL);
g_return_val_if_fail (role != NULL, NULL);
g_return_val_if_fail (icon_name != NULL, NULL);
g_return_val_if_fail (desc != NULL, NULL);
g_return_val_if_fail (help_id != NULL, NULL);
options = g_slice_new0 (VectorsOptionsDialog);
options->image = image;
options->vectors = vectors;
if (vectors)
viewable = GIMP_VIEWABLE (vectors);
else
viewable = GIMP_VIEWABLE (image);
options->dialog =
gimp_viewable_dialog_new (viewable, context,
title, role, icon_name, desc,
parent,
gimp_standard_help_func,
help_id,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (options->dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
g_object_weak_ref (G_OBJECT (options->dialog),
(GWeakNotify) vectors_options_dialog_free, options);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 12);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (options->dialog))),
hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
table = gtk_table_new (1, 2, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
gtk_widget_show (table);
options->name_entry = gtk_entry_new ();
gtk_widget_set_size_request (options->name_entry, 150, -1);
gtk_entry_set_activates_default (GTK_ENTRY (options->name_entry), TRUE);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
_("Path name:"), 0.0, 0.5,
options->name_entry, 1, FALSE);
gtk_entry_set_text (GTK_ENTRY (options->name_entry), vectors_name);
return options;
}
static void
subversion_commit_dialog (GtkAction* action, Subversion* plugin,
gchar *filename)
{
GtkBuilder* bxml = gtk_builder_new ();
GtkWidget* dialog;
GtkWidget *logtext;
GtkWidget *commit_select_all_button;
GtkWidget *commit_clear_button;
GtkWidget *commit_status_view;
GtkWidget *commit_status_progress_bar;
GtkWidget *commit_prev_msg_enable;
GtkWidget *commit_prev_msg_combo;
GtkCellRenderer *cell;
GtkListStore *store;
SvnStatusCommand *status_command;
SubversionData* data;
GError* error = NULL;
if (!gtk_builder_add_from_file (bxml, GLADE_FILE, &error))
{
g_warning ("Couldn't load builder file: %s", error->message);
g_error_free (error);
}
dialog = GTK_WIDGET (gtk_builder_get_object (bxml, "subversion_commit"));
commit_select_all_button = GTK_WIDGET (gtk_builder_get_object (bxml,
"commit_select_all_button"));
commit_clear_button = GTK_WIDGET (gtk_builder_get_object (bxml,
"commit_clear_button"));
commit_status_view = GTK_WIDGET (gtk_builder_get_object (bxml, "commit_status_view"));
commit_status_progress_bar = GTK_WIDGET (gtk_builder_get_object (bxml,
"commit_status_progress_bar"));
logtext = GTK_WIDGET (gtk_builder_get_object (bxml, "subversion_log_view"));
status_command = svn_status_command_new (plugin->project_root_dir,
TRUE, TRUE);
commit_prev_msg_enable = GTK_WIDGET (gtk_builder_get_object (bxml,
"commit_prev_msg_enable"));
commit_prev_msg_combo = GTK_WIDGET (gtk_builder_get_object (bxml,
"commit_prev_msg_combo"));
g_signal_connect (G_OBJECT (commit_select_all_button), "clicked",
G_CALLBACK (select_all_status_items),
commit_status_view);
g_signal_connect (G_OBJECT (commit_clear_button), "clicked",
G_CALLBACK (clear_all_status_selections),
commit_status_view);
g_signal_connect (G_OBJECT (status_command), "command-finished",
G_CALLBACK (select_all_files),
commit_status_view);
g_signal_connect(G_OBJECT (commit_prev_msg_enable), "toggled",
G_CALLBACK(on_prev_message_enable_clicked),
logtext);
pulse_progress_bar (GTK_PROGRESS_BAR (commit_status_progress_bar));
g_signal_connect (G_OBJECT (status_command), "command-finished",
G_CALLBACK (cancel_data_arrived_signal_disconnect),
commit_status_view);
g_signal_connect (G_OBJECT (status_command), "command-finished",
G_CALLBACK (hide_pulse_progress_bar),
commit_status_progress_bar);
g_signal_connect (G_OBJECT (status_command), "command-finished",
G_CALLBACK (on_status_command_finished),
NULL);
g_signal_connect (G_OBJECT (status_command), "data-arrived",
G_CALLBACK (on_status_command_data_arrived),
commit_status_view);
g_object_weak_ref (G_OBJECT (commit_status_view),
(GWeakNotify) disconnect_data_arrived_signals,
status_command);
anjuta_command_start (ANJUTA_COMMAND (status_command));
data = subversion_data_new(plugin, bxml);
g_signal_connect(G_OBJECT(dialog), "response",
G_CALLBACK(on_subversion_commit_response), data);
store = gtk_list_store_new (1, G_TYPE_STRING);
cell = gtk_cell_renderer_text_new ();
gtk_cell_layout_clear(GTK_CELL_LAYOUT(commit_prev_msg_combo));
gtk_combo_box_set_model(GTK_COMBO_BOX(commit_prev_msg_combo), NULL);
gtk_combo_box_set_model(GTK_COMBO_BOX(commit_prev_msg_combo), GTK_TREE_MODEL(store));
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (commit_prev_msg_combo), cell, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (commit_prev_msg_combo), cell,
"text", 0,
NULL);
g_object_unref (store);
gtk_widget_show_all (dialog);
g_list_foreach(plugin->svn_commit_logs, subversion_commit_dialog_populate_logs, commit_prev_msg_combo);
gtk_combo_box_set_active(GTK_COMBO_BOX(commit_prev_msg_combo), 0);
}
static void
tp_contact_factory_add_contact (EmpathyTpContactFactory *tp_factory,
EmpathyContact *contact)
{
EmpathyTpContactFactoryPriv *priv = GET_PRIV (tp_factory);
TpHandle self_handle;
TpHandle handle;
GArray handles = {(gchar *) &handle, 1};
EmpathyCapabilities caps;
/* Keep a weak ref to that contact */
g_object_weak_ref (G_OBJECT (contact),
tp_contact_factory_weak_notify,
tp_factory);
priv->contacts = g_list_prepend (priv->contacts, contact);
/* The contact keeps a ref to its factory */
g_object_set_data_full (G_OBJECT (contact), "empathy-factory",
g_object_ref (tp_factory),
g_object_unref);
caps = empathy_contact_get_capabilities (contact);
/* Set the FT capability */
if (!priv->contact_caps_supported) {
/* ContactCapabilities is not supported; assume all contacts can do file
* transfer if it's implemented in the CM */
if (priv->can_request_ft) {
caps |= EMPATHY_CAPABILITIES_FT;
}
/* Set the Stream Tube capability */
if (priv->can_request_st) {
caps |= EMPATHY_CAPABILITIES_STREAM_TUBE;
}
}
empathy_contact_set_capabilities (contact, caps);
/* Set is-user property. Note that it could still be the handle is
* different from the connection's self handle, in the case the handle
* comes from a group interface. */
self_handle = tp_connection_get_self_handle (priv->connection);
handle = empathy_contact_get_handle (contact);
empathy_contact_set_is_user (contact, self_handle == handle);
/* FIXME: This should be done by TpContact */
if (tp_proxy_has_interface_by_id (priv->connection,
TP_IFACE_QUARK_CONNECTION_INTERFACE_AVATARS)) {
tp_cli_connection_interface_avatars_call_get_known_avatar_tokens (
priv->connection, -1, &handles,
tp_contact_factory_got_known_avatar_tokens, NULL, NULL,
G_OBJECT (tp_factory));
}
if (priv->contact_caps_supported) {
tp_cli_connection_interface_contact_capabilities_call_get_contact_capabilities (
priv->connection, -1, &handles,
tp_contact_factory_got_contact_capabilities, NULL, NULL,
G_OBJECT (tp_factory));
}
else if (tp_proxy_has_interface_by_id (priv->connection,
TP_IFACE_QUARK_CONNECTION_INTERFACE_CAPABILITIES)) {
tp_cli_connection_interface_capabilities_call_get_capabilities (
priv->connection, -1, &handles,
tp_contact_factory_got_capabilities, NULL, NULL,
G_OBJECT (tp_factory));
}
DEBUG ("Contact added: %s (%d)",
empathy_contact_get_id (contact),
empathy_contact_get_handle (contact));
}
static void
glade_sheet_editor_load (GladeEditable *editable, GladeWidget *widget)
{
GladeSheetEditor *view_editor = GLADE_SHEET_EDITOR (editable);
GladeWidget *model_widget;
/* Since we watch the project*/
if (view_editor->loaded_widget)
{
g_signal_handlers_disconnect_by_func (G_OBJECT (view_editor->loaded_widget->project),
G_CALLBACK (project_changed), view_editor);
/* The widget could die unexpectedly... */
g_object_weak_unref (G_OBJECT (view_editor->loaded_widget->project),
(GWeakNotify)project_finalized,
view_editor);
}
/* Mark our widget... */
view_editor->loaded_widget = widget;
if (view_editor->loaded_widget)
{
/* This fires for undo/redo */
g_signal_connect (G_OBJECT (view_editor->loaded_widget->project), "changed",
G_CALLBACK (project_changed), view_editor);
/* The widget/project could die unexpectedly... */
g_object_weak_ref (G_OBJECT (view_editor->loaded_widget->project),
(GWeakNotify) project_finalized,
view_editor);
}
/* load the embedded editable... */
if (view_editor->embed)
glade_editable_load (GLADE_EDITABLE (view_editor->embed), widget);
if (view_editor->embed_list_store && view_editor->embed_tree_store)
{
gtk_widget_hide (view_editor->no_model_message);
gtk_widget_hide (view_editor->embed_list_store);
gtk_widget_hide (view_editor->embed_tree_store);
glade_editable_load (GLADE_EDITABLE (view_editor->embed_list_store), NULL);
glade_editable_load (GLADE_EDITABLE (view_editor->embed_tree_store), NULL);
/* Finalize safe code here... */
if (widget && (model_widget = get_model_widget (widget)))
{
if (GTK_IS_LIST_STORE (model_widget->object))
{
gtk_widget_show (view_editor->embed_list_store);
glade_editable_load (GLADE_EDITABLE (view_editor->embed_list_store), model_widget);
}
else if (GTK_IS_TREE_STORE (model_widget->object))
{
gtk_widget_show (view_editor->embed_tree_store);
glade_editable_load (GLADE_EDITABLE (view_editor->embed_tree_store), model_widget);
}
else
gtk_widget_show (view_editor->no_model_message);
}
else
gtk_widget_show (view_editor->no_model_message);
}
}
static void init_model()
{
if(G_UNLIKELY(!model))
{
GtkTreeIter it;
PlaceItem* item;
GList *vols, *l;
GIcon* gicon;
FmIcon* icon;
GFile* gf;
GdkPixbuf* pix;
theme_change_handler = g_signal_connect(gtk_icon_theme_get_default(), "changed",
G_CALLBACK(update_icons), NULL);
use_trash_change_handler = g_signal_connect(fm_config, "changed::use_trash",
G_CALLBACK(on_use_trash_changed), NULL);
pane_icon_size_change_handler = g_signal_connect(fm_config, "changed::pane_icon_size",
G_CALLBACK(on_pane_icon_size_changed), NULL);
model = gtk_list_store_new(N_COLS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_POINTER);
g_object_weak_ref(G_OBJECT(model), on_model_destroy, NULL);
item = g_slice_new0(PlaceItem);
item->type = PLACE_PATH;
item->path = fm_path_ref(fm_path_get_home());
item->icon = fm_icon_from_name("user-home");
gtk_list_store_append(model, &it);
pix = fm_icon_get_pixbuf(item->icon, fm_config->pane_icon_size);
gtk_list_store_set(model, &it, COL_ICON, pix, COL_LABEL, item->path->name, COL_INFO, item, -1);
g_object_unref(pix);
/* Only show desktop in side pane when the user has a desktop dir. */
if(g_file_test(g_get_user_special_dir(G_USER_DIRECTORY_DESKTOP), G_FILE_TEST_IS_DIR))
{
item = g_slice_new0(PlaceItem);
item->type = PLACE_PATH;
item->path = fm_path_ref(fm_path_get_desktop());
item->icon = fm_icon_from_name("user-desktop");
gtk_list_store_append(model, &it);
pix = fm_icon_get_pixbuf(item->icon, fm_config->pane_icon_size);
gtk_list_store_set(model, &it, COL_ICON, pix, COL_LABEL, _("Desktop"), COL_INFO, item, -1);
g_object_unref(pix);
}
if(fm_config->use_trash)
create_trash();
item = g_slice_new0(PlaceItem);
item->type = PLACE_PATH;
item->path = fm_path_ref(fm_path_get_apps_menu());
item->icon = fm_icon_from_name("system-software-install");
gtk_list_store_append(model, &it);
pix = fm_icon_get_pixbuf(item->icon, fm_config->pane_icon_size);
gtk_list_store_set(model, &it, COL_ICON, pix, COL_LABEL, _("Applications"), COL_INFO, item, -1);
g_object_unref(pix);
/* volumes */
vol_mon = g_volume_monitor_get();
g_signal_connect(vol_mon, "volume-added", G_CALLBACK(on_vol_added), NULL);
g_signal_connect(vol_mon, "volume-removed", G_CALLBACK(on_vol_removed), NULL);
g_signal_connect(vol_mon, "volume-changed", G_CALLBACK(on_vol_changed), NULL);
/* separator */
gtk_list_store_append(model, &sep_it);
vols = g_volume_monitor_get_volumes(vol_mon);
for(l=vols;l;l=l->next)
{
GVolume* vol = G_VOLUME(l->data);
add_vol(vol);
g_object_unref(vol);
}
g_list_free(vols);
bookmarks = fm_bookmarks_get(); /* bookmarks */
g_signal_connect(bookmarks, "changed", G_CALLBACK(on_bookmarks_changed), NULL);
add_bookmarks();
}
else
g_object_ref(model);
}
void
setup_input_tabs (GtkBuilder *builder,
GisKeyboardPage *page)
{
GtkWidget *treeview;
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
GtkListStore *store;
GtkTreeSelection *selection;
/* set up the list of active inputs */
treeview = WID("active_input_sources");
column = gtk_tree_view_column_new ();
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_add_attribute (column, cell, "text", NAME_COLUMN);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
store = gtk_list_store_new (N_COLUMNS,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_DESKTOP_APP_INFO);
gtk_tree_view_set_model (GTK_TREE_VIEW (treeview), GTK_TREE_MODEL (store));
input_sources_settings = g_settings_new (GNOME_DESKTOP_INPUT_SOURCES_DIR);
g_settings_delay (input_sources_settings);
g_object_weak_ref (G_OBJECT (builder), (GWeakNotify) g_object_unref, input_sources_settings);
if (!xkb_info)
xkb_info = gnome_xkb_info_new ();
#ifdef HAVE_IBUS
ibus_init ();
if (!ibus)
{
ibus = ibus_bus_new_async ();
if (ibus_bus_is_connected (ibus))
fetch_ibus_engines (builder);
else
g_signal_connect_swapped (ibus, "connected",
G_CALLBACK (fetch_ibus_engines), builder);
g_object_weak_ref (G_OBJECT (builder), (GWeakNotify) clear_ibus, NULL);
}
maybe_start_ibus ();
#endif
populate_with_active_sources (store);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
g_signal_connect_swapped (selection, "changed",
G_CALLBACK (update_button_sensitivity), builder);
/* set up the buttons */
g_signal_connect (WID("input_source_add"), "clicked",
G_CALLBACK (add_input), builder);
g_signal_connect (WID("input_source_remove"), "clicked",
G_CALLBACK (remove_selected_input), builder);
g_signal_connect (WID("input_source_move_up"), "clicked",
G_CALLBACK (move_selected_input_up), builder);
g_signal_connect (WID("input_source_move_down"), "clicked",
G_CALLBACK (move_selected_input_down), builder);
g_signal_connect (WID("input_source_show"), "clicked",
G_CALLBACK (show_selected_layout), builder);
g_signal_connect (WID("input_source_settings"), "clicked",
G_CALLBACK (show_selected_settings), builder);
/* use an em dash is no shortcut */
update_shortcuts (builder);
/* g_signal_connect (WID("jump-to-shortcuts"), "activate-link",
G_CALLBACK (go_to_shortcuts), page);*/
g_signal_connect (G_OBJECT (input_sources_settings),
"changed::" KEY_INPUT_SOURCES,
G_CALLBACK (input_sources_changed),
builder);
}
GtkWidget* place_item_get_menu(PlaceItem* item)
{
GtkWidget* menu = NULL;
FmFileMenu* file_menu;
GtkUIManager* ui = gtk_ui_manager_new();
GtkActionGroup* act_grp = act_grp = gtk_action_group_new("Popup");
gtk_action_group_set_translation_domain(act_grp, GETTEXT_PACKAGE);
/* FIXME: merge with FmFileMenu when possible */
if(item->type == PLACE_PATH)
{
if(item->bm_item)
{
gtk_action_group_add_actions(act_grp, bm_menu_actions, G_N_ELEMENTS(bm_menu_actions), item);
gtk_ui_manager_add_ui_from_string(ui, bookmark_menu_xml, -1, NULL);
}
else if(fm_path_is_trash_root(item->path))
{
gtk_action_group_add_actions(act_grp, trash_menu_actions, G_N_ELEMENTS(trash_menu_actions), item);
gtk_ui_manager_add_ui_from_string(ui, trash_menu_xml, -1, NULL);
}
}
else if(item->type == PLACE_VOL)
{
GtkAction* act;
GMount* mnt;
gtk_action_group_add_actions(act_grp, vol_menu_actions, G_N_ELEMENTS(vol_menu_actions), item);
gtk_ui_manager_add_ui_from_string(ui, vol_menu_xml, -1, NULL);
mnt = g_volume_get_mount(item->vol);
if(mnt) /* mounted */
{
g_object_unref(mnt);
act = gtk_action_group_get_action(act_grp, "Mount");
gtk_action_set_sensitive(act, FALSE);
}
else /* not mounted */
{
act = gtk_action_group_get_action(act_grp, "Unmount");
gtk_action_set_sensitive(act, FALSE);
}
if(g_volume_can_eject(item->vol))
act = gtk_action_group_get_action(act_grp, "Unmount");
else
act = gtk_action_group_get_action(act_grp, "Eject");
gtk_action_set_visible(act, FALSE);
}
else
goto _out;
gtk_ui_manager_insert_action_group(ui, act_grp, 0);
menu = gtk_ui_manager_get_widget(ui, "/popup");
if(menu)
{
g_signal_connect(menu, "selection-done", G_CALLBACK(gtk_widget_destroy), NULL);
g_object_weak_ref(G_OBJECT(menu), g_object_unref, g_object_ref(ui));
}
_out:
g_object_unref(act_grp);
g_object_unref(ui);
return menu;
}
void _g_object_weak_ref(GObject* object, gint64 data) {
gint64* intdata = (gint64*)malloc(sizeof(gint64));
*intdata = data;
g_object_weak_ref(object, weak_ref_callback, (gpointer)intdata);
}
/*< private >
* clutter_input_device_set_actor:
* @device: a #ClutterInputDevice
* @actor: a #ClutterActor
* @emit_crossing: %TRUE to emit crossing events
*
* Sets the actor under the pointer coordinates of @device
*
* This function is called by _clutter_input_device_update()
* and it will:
*
* - queue a %CLUTTER_LEAVE event on the previous pointer actor
* of @device, if any
* - set to %FALSE the :has-pointer property of the previous
* pointer actor of @device, if any
* - queue a %CLUTTER_ENTER event on the new pointer actor
* - set to %TRUE the :has-pointer property of the new pointer
* actor
*/
void
_clutter_input_device_set_actor (ClutterInputDevice *device,
ClutterActor *actor,
gboolean emit_crossing)
{
ClutterActor *old_actor;
if (device->cursor_actor == actor)
return;
old_actor = device->cursor_actor;
if (old_actor != NULL)
{
if (emit_crossing)
{
ClutterEvent *event;
event = clutter_event_new (CLUTTER_LEAVE);
event->crossing.time = device->current_time;
event->crossing.flags = 0;
event->crossing.stage = device->stage;
event->crossing.source = device->cursor_actor;
event->crossing.x = device->current_x;
event->crossing.y = device->current_y;
event->crossing.related = actor;
clutter_event_set_device (event, device);
/* we need to make sure that this event is processed
* before any other event we might have queued up until
* now, so we go on, and synthesize the event emission
* ourselves
*/
_clutter_process_event (event);
clutter_event_free (event);
}
/* processing the event might have destroyed the actor */
if (device->cursor_actor != NULL)
{
_clutter_actor_set_has_pointer (device->cursor_actor, FALSE);
g_object_weak_unref (G_OBJECT (device->cursor_actor),
cursor_weak_unref,
device);
device->cursor_actor = NULL;
}
}
if (actor != NULL)
{
if (emit_crossing)
{
ClutterEvent *event;
event = clutter_event_new (CLUTTER_ENTER);
event->crossing.time = device->current_time;
event->crossing.flags = 0;
event->crossing.stage = device->stage;
event->crossing.x = device->current_x;
event->crossing.y = device->current_y;
event->crossing.source = actor;
event->crossing.related = old_actor;
clutter_event_set_device (event, device);
/* see above */
_clutter_process_event (event);
clutter_event_free (event);
}
}
device->cursor_actor = actor;
if (device->cursor_actor != NULL)
{
g_object_weak_ref (G_OBJECT (device->cursor_actor),
cursor_weak_unref,
device);
_clutter_actor_set_has_pointer (device->cursor_actor, TRUE);
}
}
/*
* _clutter_input_device_set_actor:
* @device: a #ClutterInputDevice
* @actor: a #ClutterActor
*
* Sets the actor under the pointer coordinates of @device
*
* This function is called by _clutter_input_device_update()
* and it will:
*
* - queue a %CLUTTER_LEAVE event on the previous pointer actor
* of @device, if any
* - set to %FALSE the :has-pointer property of the previous
* pointer actor of @device, if any
* - queue a %CLUTTER_ENTER event on the new pointer actor
* - set to %TRUE the :has-pointer property of the new pointer
* actor
*/
void
_clutter_input_device_set_actor (ClutterInputDevice *device,
ClutterActor *actor)
{
ClutterActor *old_actor;
ClutterEvent cev;
g_return_if_fail (CLUTTER_IS_INPUT_DEVICE (device));
if (actor == device->cursor_actor)
return;
old_actor = device->cursor_actor;
if (old_actor != NULL)
{
cev.crossing.type = CLUTTER_LEAVE;
cev.crossing.time = device->current_time;
cev.crossing.flags = 0;
cev.crossing.stage = device->stage;
cev.crossing.source = device->cursor_actor;
cev.crossing.x = device->current_x;
cev.crossing.y = device->current_y;
cev.crossing.device = device;
cev.crossing.related = actor;
/* we need to make sure that this event is processed before
* any other event we might have queued up until now, so we
* go on and synthesize the event emission
*/
_clutter_process_event (&cev);
_clutter_actor_set_has_pointer (device->cursor_actor, FALSE);
g_object_weak_unref (G_OBJECT (device->cursor_actor),
cursor_weak_unref,
device);
device->cursor_actor = NULL;
}
if (actor != NULL)
{
cev.crossing.type = CLUTTER_ENTER;
cev.crossing.time = device->current_time;
cev.crossing.flags = 0;
cev.crossing.stage = device->stage;
cev.crossing.x = device->current_x;
cev.crossing.y = device->current_y;
cev.crossing.device = device;
CLUTTER_NOTE (EVENT, "Device '%s' entering '%s' at %d, %d",
device->device_name,
clutter_actor_get_name (actor) != NULL
? clutter_actor_get_name (actor)
: G_OBJECT_TYPE_NAME (actor),
device->current_x,
device->current_y);
/* if there is an actor overlapping the Stage boundary and we
* don't do this check then we'll emit an ENTER event only on
* the actor instead of emitting it on the Stage *and* the
* actor
*/
if (old_actor == NULL && actor != CLUTTER_ACTOR (device->stage))
{
cev.crossing.source = CLUTTER_ACTOR (device->stage);
cev.crossing.related = NULL;
CLUTTER_NOTE (EVENT, "Adding Crossing[Enter] event for Stage");
_clutter_process_event (&cev);
cev.crossing.source = actor;
cev.crossing.related = CLUTTER_ACTOR (device->stage);
}
else
{
cev.crossing.source = actor;
cev.crossing.related = old_actor;
}
/* as above: we need to make sure that this event is processed
* before any other event we might have queued up until now, so
* we go on and synthesize the event emission
*/
_clutter_process_event (&cev);
}
device->cursor_actor = actor;
if (device->cursor_actor != NULL)
{
g_object_weak_ref (G_OBJECT (device->cursor_actor),
cursor_weak_unref,
device);
_clutter_actor_set_has_pointer (device->cursor_actor, TRUE);
}
}
GeditAutomaticSpellChecker *
gedit_automatic_spell_checker_new (GeditDocument *doc,
GeditSpellChecker *checker)
{
GeditAutomaticSpellChecker *spell;
GtkTextTagTable *tag_table;
GtkTextIter start, end;
g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), NULL);
g_return_val_if_fail (GEDIT_IS_SPELL_CHECKER (checker), NULL);
g_return_val_if_fail ((spell = gedit_automatic_spell_checker_get_from_document (doc)) == NULL,
spell);
/* attach to the widget */
spell = g_new0 (GeditAutomaticSpellChecker, 1);
spell->doc = doc;
spell->spell_checker = g_object_ref (checker);
if (automatic_spell_checker_id == 0)
{
automatic_spell_checker_id =
g_quark_from_string ("GeditAutomaticSpellCheckerID");
}
if (suggestion_id == 0)
{
suggestion_id = g_quark_from_string ("GeditAutoSuggestionID");
}
g_object_set_qdata_full (G_OBJECT (doc),
automatic_spell_checker_id,
spell,
(GDestroyNotify)gedit_automatic_spell_checker_free_internal);
g_signal_connect (doc,
"insert-text",
G_CALLBACK (insert_text_before),
spell);
g_signal_connect_after (doc,
"insert-text",
G_CALLBACK (insert_text_after),
spell);
g_signal_connect_after (doc,
"delete-range",
G_CALLBACK (delete_range_after),
spell);
g_signal_connect (doc,
"mark-set",
G_CALLBACK (mark_set),
spell);
g_signal_connect (doc,
"highlight-updated",
G_CALLBACK (highlight_updated),
spell);
g_signal_connect (spell->spell_checker,
"add_word_to_session",
G_CALLBACK (add_word_signal_cb),
spell);
g_signal_connect (spell->spell_checker,
"add_word_to_personal",
G_CALLBACK (add_word_signal_cb),
spell);
g_signal_connect (spell->spell_checker,
"clear_session",
G_CALLBACK (clear_session_cb),
spell);
g_signal_connect (spell->spell_checker,
"set_language",
G_CALLBACK (set_language_cb),
spell);
spell->tag_highlight = gtk_text_buffer_create_tag (
GTK_TEXT_BUFFER (doc),
"gtkspell-misspelled",
"underline", PANGO_UNDERLINE_ERROR,
NULL);
g_object_weak_ref (G_OBJECT (spell->tag_highlight),
(GWeakNotify)spell_tag_destroyed,
spell);
tag_table = gtk_text_buffer_get_tag_table (GTK_TEXT_BUFFER (doc));
gtk_text_tag_set_priority (spell->tag_highlight,
gtk_text_tag_table_get_size (tag_table) - 1);
g_signal_connect (tag_table,
"tag-added",
G_CALLBACK (tag_added_or_removed),
spell);
g_signal_connect (tag_table,
"tag-removed",
G_CALLBACK (tag_added_or_removed),
spell);
g_signal_connect (tag_table,
"tag-changed",
G_CALLBACK (tag_changed),
spell);
/* we create the mark here, but we don't use it until text is
* inserted, so we don't really care where iter points. */
gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER (doc), &start, &end);
spell->mark_insert_start = gtk_text_buffer_get_mark (GTK_TEXT_BUFFER (doc),
"gedit-automatic-spell-checker-insert-start");
if (spell->mark_insert_start == NULL)
{
spell->mark_insert_start =
gtk_text_buffer_create_mark (GTK_TEXT_BUFFER (doc),
"gedit-automatic-spell-checker-insert-start",
&start,
TRUE);
}
else
{
gtk_text_buffer_move_mark (GTK_TEXT_BUFFER (doc),
spell->mark_insert_start,
&start);
}
spell->mark_insert_end = gtk_text_buffer_get_mark (GTK_TEXT_BUFFER (doc),
"gedit-automatic-spell-checker-insert-end");
if (spell->mark_insert_end == NULL)
{
spell->mark_insert_end =
gtk_text_buffer_create_mark (GTK_TEXT_BUFFER (doc),
"gedit-automatic-spell-checker-insert-end",
&start,
TRUE);
}
else
{
gtk_text_buffer_move_mark (GTK_TEXT_BUFFER (doc),
spell->mark_insert_end,
&start);
}
spell->mark_click = gtk_text_buffer_get_mark (GTK_TEXT_BUFFER (doc),
"gedit-automatic-spell-checker-click");
if (spell->mark_click == NULL)
{
spell->mark_click =
gtk_text_buffer_create_mark (GTK_TEXT_BUFFER (doc),
"gedit-automatic-spell-checker-click",
&start,
TRUE);
}
else
{
gtk_text_buffer_move_mark (GTK_TEXT_BUFFER (doc),
spell->mark_click,
&start);
}
spell->deferred_check = FALSE;
return spell;
}
static gboolean
pgd_find_find_text (PgdFindDemo *demo)
{
PopplerPage *page;
GList *matches;
GTimer *timer;
GtkTreeModel *model;
page = poppler_document_get_page (demo->doc, demo->page_index);
if (!page) {
demo->page_index++;
return demo->page_index < demo->n_pages;
}
model = gtk_tree_view_get_model (GTK_TREE_VIEW (demo->treeview));
timer = g_timer_new ();
matches = poppler_page_find_text_with_options (page, gtk_entry_get_text (GTK_ENTRY (demo->entry)), demo->options);
g_timer_stop (timer);
if (matches) {
GtkTreeIter iter;
gchar *str;
GList *l;
gdouble height;
gint n_match = 0;
str = g_strdup_printf ("%d matches found on page %d in %.4f seconds",
g_list_length (matches), demo->page_index + 1,
g_timer_elapsed (timer, NULL));
gtk_tree_store_append (GTK_TREE_STORE (model), &iter, NULL);
gtk_tree_store_set (GTK_TREE_STORE (model), &iter,
TITLE_COLUMN, str,
VISIBLE_COLUMN, FALSE,
PAGE_COLUMN, demo->page_index,
-1);
g_free (str);
poppler_page_get_size (page, NULL, &height);
for (l = matches; l && l->data; l = g_list_next (l)) {
PopplerRectangle *rect = (PopplerRectangle *)l->data;
GtkTreeIter iter_child;
gchar *x1, *y1, *x2, *y2;
gdouble tmp;
str = g_strdup_printf ("Match %d", ++n_match);
x1 = g_strdup_printf ("%.2f", rect->x1);
y1 = g_strdup_printf ("%.2f", rect->y1);
x2 = g_strdup_printf ("%.2f", rect->x2);
y2 = g_strdup_printf ("%.2f", rect->y2);
tmp = rect->y1;
rect->y1 = height - rect->y2;
rect->y2 = height - tmp;
gtk_tree_store_append (GTK_TREE_STORE (model), &iter_child, &iter);
gtk_tree_store_set (GTK_TREE_STORE (model), &iter_child,
TITLE_COLUMN, str,
X1_COLUMN, x1,
Y1_COLUMN, y1,
X2_COLUMN, x2,
Y2_COLUMN, y2,
VISIBLE_COLUMN, TRUE,
PAGE_COLUMN, demo->page_index,
PAGE_RECT, rect,
-1);
g_free (str);
g_free (x1);
g_free (y1);
g_free (x2);
g_free (y2);
g_object_weak_ref (G_OBJECT (model),
(GWeakNotify)poppler_rectangle_free,
rect);
}
g_list_free (matches);
}
g_timer_destroy (timer);
g_object_unref (page);
demo->page_index++;
pgd_find_update_progress (demo, demo->page_index);
return demo->page_index < demo->n_pages;
}
static GtkTreeModel*
gwy_grain_value_tree_model_new(gboolean show_id)
{
GrainValueStorePrivate *priv;
GwyInventory *inventory;
GtkTreeStore *store;
GtkTreeIter siter, iter;
GwyGrainValue *gvalue;
GwyGrainValueGroup group, lastgroup;
guint i, j, n;
if (!priv_quark)
priv_quark = g_quark_from_static_string("gwy-grain-value-chooser-data");
priv = g_new0(GrainValueStorePrivate, 1);
store = gtk_tree_store_new(3,
GWY_TYPE_GRAIN_VALUE,
GWY_TYPE_GRAIN_VALUE_GROUP,
G_TYPE_BOOLEAN);
g_object_set_qdata_full(G_OBJECT(store), priv_quark, priv, g_free);
inventory = gwy_grain_values();
n = gwy_inventory_get_n_items(inventory);
lastgroup = -1;
for (i = j = 0; i < n; i++) {
gvalue = gwy_inventory_get_nth_item(inventory, i);
group = gwy_grain_value_get_group(gvalue);
if (!show_id && group == GWY_GRAIN_VALUE_GROUP_ID)
continue;
if (group != lastgroup) {
gtk_tree_store_insert_after(store, &siter, NULL,
lastgroup != (GwyGrainValueGroup)-1
? &siter
: NULL);
gtk_tree_store_set(store, &siter,
GWY_GRAIN_VALUE_STORE_COLUMN_GROUP, group,
-1);
if (group == GWY_GRAIN_VALUE_GROUP_USER) {
priv->user_group_iter = siter;
priv->user_start_pos = i;
}
lastgroup = group;
j = 0;
}
gtk_tree_store_insert_after(store, &iter, &siter, j ? &iter : NULL);
gtk_tree_store_set(store, &iter,
GWY_GRAIN_VALUE_STORE_COLUMN_ITEM, gvalue,
GWY_GRAIN_VALUE_STORE_COLUMN_GROUP, group,
-1);
j++;
}
/* Ensure User branch is present, even if empty */
if (lastgroup != GWY_GRAIN_VALUE_GROUP_USER) {
group = GWY_GRAIN_VALUE_GROUP_USER;
gtk_tree_store_insert_after(store, &siter, NULL, i ? &siter : NULL);
gtk_tree_store_set(store, &siter,
GWY_GRAIN_VALUE_STORE_COLUMN_GROUP, group,
-1);
priv->user_group_iter = siter;
priv->user_start_pos = i;
}
g_signal_connect(inventory, "item-updated",
G_CALLBACK(inventory_item_updated), store);
g_signal_connect(inventory, "item-inserted",
G_CALLBACK(inventory_item_inserted), store);
g_signal_connect(inventory, "item-deleted",
G_CALLBACK(inventory_item_deleted), store);
g_object_weak_ref(G_OBJECT(store), grain_value_store_finalized, inventory);
return GTK_TREE_MODEL(store);
}
