static void gom_application_refresh_db_cb (GObject *source, GAsyncResult *res, gpointer user_data) { GomApplication *self; GDBusMethodInvocation *invocation = user_data; GError *error = NULL; self = GOM_APPLICATION (g_application_get_default ()); g_application_release (G_APPLICATION (self)); self->refreshing = FALSE; gom_miner_refresh_db_finish (GOM_MINER (source), res, &error); if (error != NULL) { g_printerr ("Failed to refresh the DB cache: %s\n", error->message); g_dbus_method_invocation_take_error (invocation, error); goto out; } gom_dbus_complete_refresh_db (self->skeleton, invocation); out: g_object_unref (invocation); gom_application_process_queue (self); }
static void gom_application_insert_shared_content_cb (GObject *source, GAsyncResult *res, gpointer user_data) { GomApplication *self; GDBusMethodInvocation *invocation = G_DBUS_METHOD_INVOCATION (user_data); GError *error; self = GOM_APPLICATION (g_application_get_default ()); g_application_release (G_APPLICATION (self)); error = NULL; if (!gom_miner_insert_shared_content_finish (GOM_MINER (source), res, &error)) { g_printerr ("Failed to insert shared content: %s\n", error->message); g_dbus_method_invocation_take_error (invocation, error); goto out; } gom_dbus_complete_insert_shared_content (self->skeleton, invocation); out: g_object_unref (invocation); }
static void photos_search_provider_fetch_ids_executed (GObject *source_object, GAsyncResult *res, gpointer user_data) { GApplication *app; GDBusMethodInvocation *invocation = G_DBUS_METHOD_INVOCATION (user_data); PhotosFetchIdsJob *job = PHOTOS_FETCH_IDS_JOB (source_object); GError *error = NULL; GVariant *parameters; const gchar *const *ids; app = g_application_get_default (); g_application_release (app); ids = photos_fetch_ids_job_finish (job, res, &error); if (error != NULL) { g_dbus_method_invocation_take_error (invocation, error); goto out; } parameters = g_variant_new ("(^as)", ids); g_dbus_method_invocation_return_value (invocation, parameters); out: g_object_unref (invocation); }
static void photos_search_provider_return_metas_from_cache (PhotosSearchProvider *self, const gchar *const *identifiers, GDBusMethodInvocation *invocation) { GApplication *app; GVariantBuilder builder; guint i; g_variant_builder_init (&builder, G_VARIANT_TYPE ("aa{sv}")); for (i = 0; identifiers[i] != NULL; i++) { PhotosFetchMeta *meta; const gchar *id = identifiers[i]; meta = (PhotosFetchMeta *) g_hash_table_lookup (self->cache, id); if (meta == NULL) continue; g_variant_builder_open (&builder, G_VARIANT_TYPE ("a{sv}")); g_variant_builder_add (&builder, "{sv}", "id", g_variant_new_string (meta->id)); g_variant_builder_add (&builder, "{sv}", "name", g_variant_new_string (meta->title)); if (meta->icon != NULL) g_variant_builder_add (&builder, "{sv}", "icon", g_icon_serialize (meta->icon)); g_variant_builder_close (&builder); } app = g_application_get_default (); g_application_release (app); shell_search_provider2_complete_get_result_metas (self->skeleton, invocation, g_variant_builder_end (&builder)); }
static void photos_thumbnailer_handle_generate_thumbnail_generate_thumbnail (GObject *source_object, GAsyncResult *res, gpointer user_data) { PhotosThumbnailer *self = PHOTOS_THUMBNAILER (source_object); g_autoptr (GDBusMethodInvocation) invocation = G_DBUS_METHOD_INVOCATION (user_data); { g_autoptr (GError) error = NULL; if (!photos_thumbnailer_generate_thumbnail_finish (self, res, &error)) { g_dbus_method_invocation_take_error (invocation, g_steal_pointer (&error)); goto out; } } photos_thumbnailer_dbus_complete_generate_thumbnail (self->skeleton, invocation); out: photos_debug (PHOTOS_DEBUG_THUMBNAILER, "Completed GenerateThumbnail"); g_application_release (G_APPLICATION (self)); g_hash_table_remove (self->cancellables, invocation); }
static gboolean session_command_dispatch (EphySession *session) { EphySessionPrivate *priv = session->priv; SessionCommand *cmd; gboolean run_again = TRUE; cmd = g_queue_pop_head (priv->queue); g_assert (cmd != NULL); LOG ("dispatching queue cmd:%d", cmd->command); switch (cmd->command) { case EPHY_SESSION_CMD_RESUME_SESSION: session_command_autoresume (session, cmd->user_time); break; case EPHY_SESSION_CMD_LOAD_SESSION: ephy_session_load (session, cmd->arg, cmd->user_time); break; case EPHY_SESSION_CMD_OPEN_BOOKMARKS_EDITOR: session_command_open_bookmarks_editor (session, cmd->user_time); break; case EPHY_SESSION_CMD_OPEN_URIS: session_command_open_uris (session, cmd->args, cmd->arg, cmd->user_time); break; case EPHY_SESSION_CMD_MAYBE_OPEN_WINDOW: /* FIXME: maybe just check for normal windows? */ if (priv->windows == NULL && priv->tool_windows == NULL) { ephy_shell_new_tab_full (ephy_shell_get_default (), NULL /* window */, NULL /* tab */, NULL /* NetworkRequest */, EPHY_NEW_TAB_IN_NEW_WINDOW | EPHY_NEW_TAB_HOME_PAGE, EPHY_WEB_VIEW_CHROME_ALL, FALSE /* is popup? */, cmd->user_time); } break; default: g_assert_not_reached (); break; } /* Look if there's anything else to dispatch */ if (g_queue_is_empty (priv->queue)) { priv->queue_idle_id = 0; run_again = FALSE; } g_application_release (G_APPLICATION (ephy_shell_get_default ())); /* This unrefs the shell! */ session_command_free (cmd); return run_again; }
static void call_window_destroyed_cb (GtkWidget *window, EmpathyContact *contact) { g_hash_table_remove (call_windows, contact); g_application_release (G_APPLICATION (app)); }
static void release_application (AthenaProgressInfo *info, AthenaProgressUIHandler *self) { AthenaApplication *app; /* release the GApplication hold we acquired */ app = athena_application_get_singleton (); g_application_release (G_APPLICATION (app)); }
static void release_application (NemoProgressInfo *info, NemoProgressUIHandler *self) { NemoApplication *app; /* release the GApplication hold we acquired */ app = nemo_application_get_singleton (); g_application_release (G_APPLICATION (app)); }
static void account_manager_ready_for_accounts_cb (GObject *source_object, GAsyncResult *result, gpointer user_data) { TpAccountManager *manager = TP_ACCOUNT_MANAGER (source_object); GError *error = NULL; GApplication *app = G_APPLICATION (user_data); if (!tp_proxy_prepare_finish (manager, result, &error)) { DEBUG ("Failed to prepare account manager: %s", error->message); g_clear_error (&error); goto out; } if (selected_account_name != NULL) { gchar *account_path; TpAccount *account; /* create and prep the corresponding TpAccount so it's fully ready by the * time we try to select it in the accounts dialog */ if (g_str_has_prefix (selected_account_name, TP_ACCOUNT_OBJECT_PATH_BASE)) account_path = g_strdup (selected_account_name); else account_path = g_strdup_printf ("%s%s", TP_ACCOUNT_OBJECT_PATH_BASE, selected_account_name); account = find_account (manager, account_path); if (account != NULL) { empathy_accounts_show_accounts_ui (manager, account, app); goto out; } else { DEBUG ("Failed to find account with path %s", account_path); g_clear_error (&error); maybe_show_accounts_ui (manager, app); } g_free (account_path); } else { maybe_show_accounts_ui (manager, app); } out: g_application_release (app); }
static void handled_chats_changed_cb (EmpathyChatManager *mgr, guint nb_chats, gpointer user_data) { DEBUG ("New chat count: %u", nb_chats); if (nb_chats == 0) g_application_release (G_APPLICATION (app)); else g_application_hold (G_APPLICATION (app)); }
void ges_validate_handle_request_state_change (GstMessage * message, GApplication * application) { GstState state; gst_message_parse_request_state (message, &state); if (GST_IS_VALIDATE_SCENARIO (GST_MESSAGE_SRC (message)) && state == GST_STATE_NULL) { gst_validate_printf (GST_MESSAGE_SRC (message), "State change request NULL, " "quiting application\n"); g_application_release (application); } }
static void on_run_state_changed (NemoDesktopManager *manager) { g_return_if_fail (NEMO_IS_DESKTOP_MANAGER (manager)); FETCH_PRIV (manager); RunState new_state; DEBUG ("New run state..."); /* If we're already running (showing icons,) there's no * change in behavior, we just keep showing. */ if (priv->current_run_state == RUN_STATE_RUNNING) { return; } new_state = get_run_state (manager); /* If our state is INIT, we're waiting for the proxy to * get picked up (cinnamon starting) and still within our * failsafe timeout, so we just return */ if (new_state == RUN_STATE_INIT) { priv->current_run_state = new_state; return; } /* If our state is STARTUP, RUNNING, or FAILSAFE, we can * cancel our failsafe timer. We've either gotten a proxy * owner, given up waiting, or are now running */ if (new_state > RUN_STATE_INIT) { if (priv->failsafe_timeout_id > 0) { g_source_remove (priv->failsafe_timeout_id); priv->failsafe_timeout_id = 0; } } /* RUNNING or FALLBACK is the final endpoint of the desktop startup * sequence. Either way we trigger the desktop to start and release * our hold on the GApplication (the windows created in layout_changed * will keep the application alive from here on out.) */ if (new_state == RUN_STATE_RUNNING || new_state == RUN_STATE_FALLBACK) { priv->current_run_state = new_state; layout_changed (manager); g_application_release (G_APPLICATION (nemo_application_get_singleton ())); } }
static gboolean query_completed_cb (GcalShellSearchProvider *search_provider, GcalManager *manager) { GcalShellSearchProviderPrivate *priv = search_provider->priv; GList *events, *l; GVariantBuilder builder; time_t current_time_t; g_hash_table_remove_all (priv->events); events = gcal_manager_get_shell_search_events (priv->manager); if (events == NULL) { g_dbus_method_invocation_return_value (priv->pending_search->invocation, g_variant_new ("(as)", NULL)); goto out; } g_variant_builder_init (&builder, G_VARIANT_TYPE ("as")); current_time_t = time (NULL); events = g_list_sort_with_data (events, (GCompareDataFunc) sort_event_data, ¤t_time_t); for (l = events; l != NULL; l = g_list_next (l)) { const gchar *uid; uid = gcal_event_get_uid (l->data); if (g_hash_table_contains (priv->events, uid)) continue; g_variant_builder_add (&builder, "s", uid); g_hash_table_insert (priv->events, g_strdup (uid), l->data); } g_list_free (events); g_dbus_method_invocation_return_value (priv->pending_search->invocation, g_variant_new ("(as)", &builder)); out: g_object_unref (priv->pending_search->invocation); g_strfreev (priv->pending_search->terms); g_clear_pointer (&(priv->pending_search), g_free); g_application_release (g_application_get_default ()); return FALSE; }
static void save_pixbuf_handle_success (ScreenshotApplication *self) { set_recent_entry (self); if (screenshot_config->interactive) { ScreenshotDialog *dialog = self->priv->dialog; save_folder_to_settings (self); gtk_widget_destroy (dialog->dialog); } else { g_application_release (G_APPLICATION (self)); } }
static void schedule_search (GcalShellSearchProvider *search_provider, GDBusMethodInvocation *invocation, gchar **terms) { GcalShellSearchProviderPrivate *priv = search_provider->priv; /* don't attempt searches for a single character */ if (g_strv_length (terms) == 1 && g_utf8_strlen (terms[0], -1) == 1) { g_dbus_method_invocation_return_value (invocation, g_variant_new ("(as)", NULL)); return; } if (priv->pending_search != NULL) { g_object_unref (priv->pending_search->invocation); g_strfreev (priv->pending_search->terms); if (priv->scheduled_search_id == 0) g_application_release (g_application_get_default ()); } else { priv->pending_search = g_new0 (PendingSearch, 1); } if (priv->scheduled_search_id != 0) { g_source_remove (priv->scheduled_search_id); priv->scheduled_search_id = 0; } priv->pending_search->invocation = g_object_ref (invocation); priv->pending_search->terms = g_strdupv (terms); if (!gcal_manager_load_completed (priv->manager)) { priv->scheduled_search_id = g_timeout_add_seconds (1, (GSourceFunc) execute_search, search_provider); return; } execute_search (search_provider); return; }
static gboolean application_service_timeout_cb (gpointer data) { g_autoptr(IdeApplication) self = data; g_assert (IDE_IS_APPLICATION (self)); /* * We have a reference and a hold on the #IdeApplication as we are waiting * for operations to be received via DBus. If we got any requests, for * something like Activate(), we'll already have another hold on the * application for the window. Therefore, all we should need to do is drop * the application hold we took before registering our timeout. */ g_application_release (G_APPLICATION (self)); return G_SOURCE_REMOVE; }
static gboolean photos_thumbnailer_handle_cancel (PhotosThumbnailer *self, GDBusMethodInvocation *invocation, guint serial) { GCancellable *cancellable; GDBusConnection *connection; GDBusMethodInvocation *invocation_ongoing; GHashTableIter iter; g_return_val_if_fail (PHOTOS_IS_THUMBNAILER (self), FALSE); g_return_val_if_fail (G_IS_DBUS_METHOD_INVOCATION (invocation), FALSE); photos_debug (PHOTOS_DEBUG_THUMBNAILER, "Handling Cancel for %u", serial); g_application_hold (G_APPLICATION (self)); connection = g_dbus_method_invocation_get_connection (invocation); g_hash_table_iter_init (&iter, self->cancellables); while (g_hash_table_iter_next (&iter, (gpointer *) &invocation_ongoing, (gpointer *) &cancellable)) { GDBusConnection *connection_ongoing; GDBusMessage *message_ongoing; guint32 serial_ongoing; connection_ongoing = g_dbus_method_invocation_get_connection (invocation_ongoing); message_ongoing = g_dbus_method_invocation_get_message (invocation_ongoing); serial_ongoing = g_dbus_message_get_serial (message_ongoing); if (connection == connection_ongoing && (guint32) serial == serial_ongoing) { g_cancellable_cancel (cancellable); photos_thumbnailer_dbus_complete_cancel (self->skeleton, invocation); goto out; } } g_dbus_method_invocation_return_error_literal (invocation, PHOTOS_ERROR, 0, "Invalid serial"); out: photos_debug (PHOTOS_DEBUG_THUMBNAILER, "Completed Cancel"); g_application_release (G_APPLICATION (self)); return TRUE; }
void sflphone_quit(gboolean force_quit, SFLPhoneClient *client) { if (force_quit || calllist_get_size(current_calls_tab) == 0 || main_window_ask_quit(client)) { dbus_unregister(getpid()); dbus_clean(); account_list_free(); calllist_clean(current_calls_tab); calllist_clean(contacts_tab); calllist_clean(history_tab); free_addressbook(); #if GLIB_CHECK_VERSION(2,32,0) g_application_quit(G_APPLICATION(client)); #else g_application_release(G_APPLICATION(client)); #endif } }
static void rectangle_found_cb (GdkRectangle *rectangle, gpointer user_data) { ScreenshotApplication *self = user_data; if (rectangle != NULL) { finish_prepare_screenshot (self, rectangle); } else { /* user dismissed the area selection, possibly show the dialog again */ g_application_release (G_APPLICATION (self)); if (screenshot_config->interactive) screenshot_show_interactive_dialog (self); } }
static void write_diagnostics_cb (GObject *source, GAsyncResult *result, gpointer user_data) { g_autoptr(GisFinishedPage) self = GIS_FINISHED_PAGE (user_data); GisFinishedPagePrivate *priv = gis_finished_page_get_instance_private (self); g_autoptr(GError) error = NULL; g_autoptr(GFile) output = gis_write_diagnostics_finish (result, &error); g_application_release (G_APPLICATION (GIS_PAGE (self)->driver)); if (output != NULL) { g_autofree gchar *basename_ = g_file_get_basename (output); g_autofree gchar *link = NULL; g_autofree gchar *markup = NULL; if (priv->gedit != NULL) { g_assert (error == NULL); g_autofree gchar *url = g_file_get_uri (output); link = g_markup_printf_escaped ("<a href=\"%s\">%s</a>", url, basename_); } else { link = g_strdup (basename_); } markup = g_strdup_printf (_("A debug log has been saved as %s."), link); gtk_label_set_markup (priv->diagnostics_label, markup); } else if (error != NULL) { g_prefix_error (&error, _("Failed to save debug log: ")); gtk_label_set_text (priv->diagnostics_label, error->message); g_warning ("%s: %s", G_STRFUNC, error->message); } /* else, both possible target directories were NULL */ }
static void ide_application_run_tests_cb (GObject *object, GAsyncResult *result, gpointer user_data) { AsyncTest *test = user_data; GError *error = NULL; gboolean ret; ret = test->test_completion (result, &error); g_assert_no_error (error); g_assert (ret == TRUE); if (test->self->test_funcs) ide_application_run_next_test (test->self); else g_application_release (G_APPLICATION (test->self)); g_clear_pointer (&test->name, g_free); g_clear_object (&test->self); g_slice_free (AsyncTest, test); }
void sflphone_quit(gboolean force_quit, SFLPhoneClient *client) { if (force_quit || calllist_get_size(current_calls_tab) == 0 || main_window_ask_quit(client)) { dbus_unregister(getpid()); dbus_clean(); account_list_free(); calllist_clean(current_calls_tab); calllist_clean(contacts_tab); calllist_clean(history_tab); free_addressbook(); // make sure all open dialogs get a response signal so that they can close GList* top_level_windows = gtk_window_list_toplevels(); g_list_foreach(top_level_windows, (GFunc)send_response_to_dialogs, NULL); #if GLIB_CHECK_VERSION(2,32,0) g_application_quit(G_APPLICATION(client)); #else g_application_release(G_APPLICATION(client)); #endif } }
static gboolean service_timeout_cb (gpointer user_data) { g_application_release (G_APPLICATION (user_data)); return FALSE; }
static void save_pixbuf_handle_error (ScreenshotApplication *self, GError *error) { if (!g_strcmp0 (g_getenv ("XDG_CURRENT_DESKTOP"), "Unity") || screenshot_config->interactive) { ScreenshotDialog *dialog = self->priv->dialog; screenshot_dialog_set_busy (dialog, FALSE); if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_EXISTS) && !self->priv->should_overwrite) { gchar *folder = screenshot_dialog_get_folder (dialog); gchar *folder_uri = g_path_get_basename (folder); gchar *folder_name = g_uri_unescape_string (folder_uri, NULL); gchar *file_name = screenshot_dialog_get_filename (dialog); gchar *detail = g_strdup_printf (_("A file named \"%s\" already exists in \"%s\""), file_name, folder_name); gint response; response = screenshot_show_dialog (GTK_WINDOW (dialog->dialog), GTK_MESSAGE_WARNING, GTK_BUTTONS_YES_NO, _("Overwrite existing file?"), detail); g_free (folder); g_free (folder_name); g_free (folder_uri); g_free (file_name); g_free (detail); if (response == GTK_RESPONSE_YES) { self->priv->should_overwrite = TRUE; screenshot_save_to_file (self); return; } } else { screenshot_show_dialog (GTK_WINDOW (dialog->dialog), GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Unable to capture a screenshot"), _("Error creating file. Please choose another location and retry.")); } gtk_widget_grab_focus (dialog->filename_entry); } else { g_critical ("Unable to save the screenshot: %s", error->message); screenshot_play_sound_effect ("dialog-error", _("Unable to capture a screenshot")); g_application_release (G_APPLICATION (self)); if (screenshot_config->file != NULL) exit (EXIT_FAILURE); } }
int main (int argc, char *argv[]) { GOptionContext *optcontext; GOptionEntry options[] = { { NULL } }; #ifdef ENABLE_DEBUG TpDebugSender *debug_sender; #endif GError *error = NULL; gint retval; /* Init */ g_thread_init (NULL); optcontext = g_option_context_new (N_("- Empathy Audio/Video Client")); g_option_context_add_group (optcontext, gst_init_get_option_group ()); g_option_context_add_group (optcontext, gtk_get_option_group (TRUE)); g_option_context_add_main_entries (optcontext, options, GETTEXT_PACKAGE); if (!g_option_context_parse (optcontext, &argc, &argv, &error)) { g_print ("%s\nRun '%s --help' to see a full list of available command " "line options.\n", error->message, argv[0]); g_warning ("Error in empathy-av init: %s", error->message); return EXIT_FAILURE; } g_option_context_free (optcontext); clutter_gst_init (&argc, &argv); empathy_gtk_init (); g_set_application_name (_("Empathy Audio/Video Client")); g_setenv ("PULSE_PROP_media.role", "phone", TRUE); /* Make empathy and empathy-av appear as the same app in gnome-shell */ gdk_set_program_class ("Empathy"); gtk_window_set_default_icon_name ("empathy"); textdomain (GETTEXT_PACKAGE); app = gtk_application_new (EMPATHY_AV_DBUS_NAME, G_APPLICATION_FLAGS_NONE); g_signal_connect (app, "activate", G_CALLBACK (activate_cb), NULL); #ifdef ENABLE_DEBUG /* Set up debug sender */ debug_sender = tp_debug_sender_dup (); g_log_set_default_handler (tp_debug_sender_log_handler, G_LOG_DOMAIN); #endif if (g_getenv ("EMPATHY_PERSIST") != NULL) { DEBUG ("Disable timer"); use_timer = FALSE; } /* the inactivity timeout can only be set while the application is held */ g_application_hold (G_APPLICATION (app)); g_application_set_inactivity_timeout (G_APPLICATION (app), TIMEOUT * 1000); g_application_release (G_APPLICATION (app)); retval = g_application_run (G_APPLICATION (app), argc, argv); g_object_unref (app); tp_clear_object (&call_factory); #ifdef ENABLE_DEBUG g_object_unref (debug_sender); #endif return retval; }
static void finish_prepare_screenshot (ScreenshotApplication *self, GdkRectangle *rectangle) { GdkPixbuf *screenshot; screenshot = screenshot_get_pixbuf (rectangle); if (screenshot == NULL) { g_critical ("Unable to capture a screenshot of any window"); if (screenshot_config->interactive) screenshot_show_dialog (NULL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Unable to capture a screenshot"), _("All possible methods failed")); else screenshot_play_sound_effect ("dialog-error", _("Unable to capture a screenshot")); g_application_release (G_APPLICATION (self)); if (screenshot_config->file != NULL) exit (EXIT_FAILURE); return; } if (screenshot_config->take_window_shot) { switch (screenshot_config->border_effect[0]) { case 's': /* shadow */ screenshot_add_shadow (&screenshot); break; case 'b': /* border */ screenshot_add_border (&screenshot); break; case 'n': /* none */ default: break; } } self->priv->screenshot = screenshot; if (screenshot_config->copy_to_clipboard) { screenshot_save_to_clipboard (self); screenshot_play_sound_effect ("screen-capture", _("Screenshot taken")); g_application_release (G_APPLICATION (self)); return; } /* FIXME: apply the ICC profile according to the preferences. * org.gnome.ColorManager.GetProfileForWindow() does not exist anymore, * so we probably need to fetch the color profile of the screen where * the area/window was. * * screenshot_ensure_icc_profile (window); */ if (screenshot_config->file != NULL) { self->priv->save_uri = g_file_get_uri (screenshot_config->file); self->priv->should_overwrite = TRUE; screenshot_save_to_file (self); } else screenshot_build_filename_async (screenshot_config->save_dir, NULL, build_filename_ready_cb, self); }
int main (int argc, char *argv[]) { GOptionContext *optcontext; GOptionEntry options[] = { { NULL } }; #ifdef ENABLE_DEBUG TpDebugSender *debug_sender; #endif GError *error = NULL; gint retval; GtkSettings *gtk_settings; /* Init */ g_thread_init (NULL); #ifdef GDK_WINDOWING_X11 /* We can't call clutter_gst_init() before gtk_clutter_init(), so no choice * but to intiialise X11 threading ourself */ XInitThreads (); #endif /* Clutter needs this */ gdk_disable_multidevice (); optcontext = g_option_context_new (N_("- Empathy Audio/Video Client")); g_option_context_add_group (optcontext, gst_init_get_option_group ()); g_option_context_add_group (optcontext, gtk_get_option_group (TRUE)); g_option_context_add_group (optcontext, cogl_get_option_group ()); g_option_context_add_group (optcontext, clutter_get_option_group_without_init ()); g_option_context_add_group (optcontext, gtk_clutter_get_option_group ()); g_option_context_add_main_entries (optcontext, options, GETTEXT_PACKAGE); if (!g_option_context_parse (optcontext, &argc, &argv, &error)) { g_print ("%s\nRun '%s --help' to see a full list of available command " "line options.\n", error->message, argv[0]); g_warning ("Error in empathy-call init: %s", error->message); return EXIT_FAILURE; } g_option_context_free (optcontext); clutter_gst_init (&argc, &argv); empathy_gtk_init (); g_set_application_name (_("Empathy Audio/Video Client")); /* Make empathy and empathy-call appear as the same app in gnome-shell */ gdk_set_program_class ("Empathy"); gtk_window_set_default_icon_name ("empathy"); textdomain (GETTEXT_PACKAGE); gtk_settings = gtk_settings_get_default (); g_object_set (G_OBJECT (gtk_settings), "gtk-application-prefer-dark-theme", TRUE, NULL); app = gtk_application_new (EMPATHY_CALL_DBUS_NAME, G_APPLICATION_FLAGS_NONE); g_signal_connect (app, "activate", G_CALLBACK (activate_cb), NULL); #ifdef ENABLE_DEBUG /* Set up debug sender */ debug_sender = tp_debug_sender_dup (); g_log_set_default_handler (tp_debug_sender_log_handler, G_LOG_DOMAIN); #endif if (g_getenv ("EMPATHY_PERSIST") != NULL) { DEBUG ("Disable timer"); use_timer = FALSE; } call_windows = g_hash_table_new_full (g_direct_hash, g_direct_equal, g_object_unref, NULL); /* the inactivity timeout can only be set while the application is held */ g_application_hold (G_APPLICATION (app)); g_application_set_inactivity_timeout (G_APPLICATION (app), TIMEOUT * 1000); g_application_release (G_APPLICATION (app)); retval = g_application_run (G_APPLICATION (app), argc, argv); g_hash_table_unref (call_windows); g_object_unref (app); tp_clear_object (&call_factory); #ifdef ENABLE_DEBUG g_object_unref (debug_sender); #endif return retval; }
static void build_filename_ready_cb (GObject *source, GAsyncResult *res, gpointer user_data) { ScreenshotApplication *self = user_data; GError *error = NULL; char *save_path; save_path = screenshot_build_filename_finish (res, &error); if (save_path != NULL) { GFile *file; file = g_file_new_for_path (save_path); g_free (save_path); self->priv->save_uri = g_file_get_uri (file); g_object_unref (file); } else self->priv->save_uri = NULL; /* now release the application */ g_application_release (G_APPLICATION (self)); if (error != NULL) { g_critical ("Impossible to find a valid location to save the screenshot: %s", error->message); g_error_free (error); if (screenshot_config->interactive) screenshot_show_dialog (NULL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Unable to capture a screenshot"), _("Error creating file")); else { screenshot_play_sound_effect ("dialog-error", _("Unable to capture a screenshot")); if (screenshot_config->file != NULL) exit (EXIT_FAILURE); } return; } screenshot_play_sound_effect ("screen-capture", _("Screenshot taken")); if (!g_strcmp0 (g_getenv ("XDG_CURRENT_DESKTOP"), "Unity") || screenshot_config->interactive) { self->priv->dialog = screenshot_dialog_new (self->priv->screenshot, self->priv->save_uri); g_signal_connect (self->priv->dialog->dialog, "response", G_CALLBACK (screenshot_dialog_response_cb), self); } else { g_application_hold (G_APPLICATION (self)); screenshot_save_to_file (self); } }
/** * gpk_log_button_close_cb: **/ static void gpk_log_button_close_cb (GtkWidget *widget, GtkApplication *application) { g_application_release (G_APPLICATION (application)); }