/* Forward Declarations */
static void e_book_backend_file_initable_init
- (GInitableIface *interface);
+ (GInitableIface *iface);
G_DEFINE_TYPE_WITH_CODE (
EBookBackendFile,
}
static void
-e_book_backend_file_initable_init (GInitableIface *interface)
+e_book_backend_file_initable_init (GInitableIface *iface)
{
- interface->init = book_backend_file_initable_init;
+ iface->init = book_backend_file_initable_init;
}
static void
/* Forward Declarations */
static void e_book_backend_google_source_authenticator_init
- (ESourceAuthenticatorInterface *interface);
+ (ESourceAuthenticatorInterface *iface);
G_DEFINE_TYPE_WITH_CODE (
EBookBackendGoogle,
}
static void
-e_book_backend_google_source_authenticator_init (ESourceAuthenticatorInterface *interface)
+e_book_backend_google_source_authenticator_init (ESourceAuthenticatorInterface *iface)
{
- interface->try_password_sync = book_backend_google_try_password_sync;
+ iface->try_password_sync = book_backend_google_try_password_sync;
}
static void
/* Forward Declarations */
static void e_gdata_oauth2_authorizer_interface_init
- (GDataAuthorizerInterface *interface);
+ (GDataAuthorizerInterface *iface);
G_DEFINE_TYPE_WITH_CODE (
EGDataOAuth2Authorizer,
}
static void
-e_gdata_oauth2_authorizer_interface_init (GDataAuthorizerInterface *interface)
+e_gdata_oauth2_authorizer_interface_init (GDataAuthorizerInterface *iface)
{
- interface->process_request =
+ iface->process_request =
gdata_oauth2_authorizer_process_request;
- interface->is_authorized_for_domain =
+ iface->is_authorized_for_domain =
gdata_oauth2_authorizer_is_authorized_for_domain;
- interface->refresh_authorization =
+ iface->refresh_authorization =
gdata_oauth2_authorizer_refresh_authorization;
}
#undef LDAP_DEBUG
#endif
#else
-#define interface windows_interface
#include <windows.h>
-#undef interface
#include <winldap.h>
#define LDAP_RES_RENAME LDAP_RES_MODRDN
#include <winber.h>
/* Forward Declarations */
static void e_book_backend_ldap_source_authenticator_init
- (ESourceAuthenticatorInterface *interface);
+ (ESourceAuthenticatorInterface *iface);
G_DEFINE_TYPE_WITH_CODE (
EBookBackendLDAP,
}
static void
-e_book_backend_ldap_source_authenticator_init (ESourceAuthenticatorInterface *interface)
+e_book_backend_ldap_source_authenticator_init (ESourceAuthenticatorInterface *iface)
{
- interface->try_password_sync = book_backend_ldap_try_password_sync;
+ iface->try_password_sync = book_backend_ldap_try_password_sync;
}
static void
/* Forward Declarations */
static void e_book_backend_webdav_source_authenticator_init
- (ESourceAuthenticatorInterface *interface);
+ (ESourceAuthenticatorInterface *iface);
G_DEFINE_TYPE_WITH_CODE (
EBookBackendWebdav,
}
static void
-e_book_backend_webdav_source_authenticator_init (ESourceAuthenticatorInterface *interface)
+e_book_backend_webdav_source_authenticator_init (ESourceAuthenticatorInterface *iface)
{
- interface->try_password_sync = book_backend_webdav_try_password_sync;
+ iface->try_password_sync = book_backend_webdav_try_password_sync;
}
static void
GParamSpec *pspec);
/* GInitable */
-static void e_book_client_cursor_initable_init (GInitableIface *interface);
+static void e_book_client_cursor_initable_init (GInitableIface *iface);
static gboolean book_client_cursor_initable_init (GInitable *initable,
GCancellable *cancellable,
GError **error);
* GInitable *
****************************************************/
static void
-e_book_client_cursor_initable_init (GInitableIface *interface)
+e_book_client_cursor_initable_init (GInitableIface *iface)
{
- interface->init = book_client_cursor_initable_init;
+ iface->init = book_client_cursor_initable_init;
}
static gboolean
/* Forward Declarations */
static void e_book_client_view_initable_init
- (GInitableIface *interface);
+ (GInitableIface *iface);
static guint signals[LAST_SIGNAL];
}
static void
-e_book_client_view_initable_init (GInitableIface *interface)
+e_book_client_view_initable_init (GInitableIface *iface)
{
- interface->init = book_client_view_initable_init;
+ iface->init = book_client_view_initable_init;
}
static void
/* Forward Declarations */
static void e_book_client_initable_init
- (GInitableIface *interface);
+ (GInitableIface *iface);
static void e_book_client_async_initable_init
- (GAsyncInitableIface *interface);
+ (GAsyncInitableIface *iface);
static void book_client_set_locale (EBookClient *client,
const gchar *locale);
}
static void
-e_book_client_initable_init (GInitableIface *interface)
+e_book_client_initable_init (GInitableIface *iface)
{
- interface->init = book_client_initable_init;
+ iface->init = book_client_initable_init;
}
static void
-e_book_client_async_initable_init (GAsyncInitableIface *interface)
+e_book_client_async_initable_init (GAsyncInitableIface *iface)
{
- interface->init_async = book_client_initable_init_async;
- interface->init_finish = book_client_initable_init_finish;
+ iface->init_async = book_client_initable_init_async;
+ iface->init_finish = book_client_initable_init_finish;
}
static void
static guint signals[LAST_SIGNAL];
-static void e_book_initable_init (GInitableIface *interface);
+static void e_book_initable_init (GInitableIface *iface);
G_DEFINE_TYPE_WITH_CODE (
EBook, e_book, G_TYPE_OBJECT,
}
static void
-e_book_initable_init (GInitableIface *interface)
+e_book_initable_init (GInitableIface *iface)
{
- interface->init = book_initable_init;
+ iface->init = book_initable_init;
}
static void
/* Forward Declarations */
static void e_data_book_factory_initable_init
- (GInitableIface *interface);
+ (GInitableIface *iface);
G_DEFINE_TYPE_WITH_CODE (
EDataBookFactory,
}
static gboolean
-data_book_factory_handle_open_address_book_cb (EDBusAddressBookFactory *interface,
+data_book_factory_handle_open_address_book_cb (EDBusAddressBookFactory *iface,
GDBusMethodInvocation *invocation,
const gchar *uid,
EDataBookFactory *factory)
if (object_path != NULL) {
e_dbus_address_book_factory_complete_open_address_book (
- interface, invocation, object_path);
+ iface, invocation, object_path);
g_free (object_path);
} else {
g_return_val_if_fail (error != NULL, FALSE);
}
static void
-e_data_book_factory_initable_init (GInitableIface *interface)
+e_data_book_factory_initable_init (GInitableIface *iface)
{
- interface->init = data_book_factory_initable_init;
+ iface->init = data_book_factory_initable_init;
}
static void
};
/* Forward Declarations */
-static void e_data_book_view_initable_init (GInitableIface *interface);
+static void e_data_book_view_initable_init (GInitableIface *iface);
G_DEFINE_TYPE_WITH_CODE (
EDataBookView,
}
static void
-e_data_book_view_initable_init (GInitableIface *interface)
+e_data_book_view_initable_init (GInitableIface *iface)
{
- interface->init = data_book_view_initable_init;
+ iface->init = data_book_view_initable_init;
}
static void
struct _AsyncContext {
EDataBook *data_book;
- EDBusAddressBook *interface;
+ EDBusAddressBook *dbus_interface;
GDBusMethodInvocation *invocation;
GCancellable *cancellable;
guint watcher_id;
};
/* Forward Declarations */
-static void e_data_book_initable_init (GInitableIface *interface);
+static void e_data_book_initable_init (GInitableIface *iface);
G_DEFINE_TYPE_WITH_CODE (
EDataBook,
GDBusMethodInvocation *invocation)
{
AsyncContext *async_context;
- EDBusAddressBook *interface;
+ EDBusAddressBook *dbus_interface;
- interface = data_book->priv->dbus_interface;
+ dbus_interface = data_book->priv->dbus_interface;
async_context = g_slice_new0 (AsyncContext);
async_context->data_book = g_object_ref (data_book);
- async_context->interface = g_object_ref (interface);
+ async_context->dbus_interface = g_object_ref (dbus_interface);
async_context->invocation = g_object_ref (invocation);
async_context->cancellable = g_cancellable_new ();
async_context->cancellable);
g_clear_object (&async_context->data_book);
- g_clear_object (&async_context->interface);
+ g_clear_object (&async_context->dbus_interface);
g_clear_object (&async_context->invocation);
g_clear_object (&async_context->cancellable);
if (error == NULL) {
e_dbus_address_book_complete_open (
- async_context->interface,
+ async_context->dbus_interface,
async_context->invocation);
} else {
data_book_convert_to_client_error (error);
}
static gboolean
-data_book_handle_open_cb (EDBusAddressBook *interface,
+data_book_handle_open_cb (EDBusAddressBook *dbus_interface,
GDBusMethodInvocation *invocation,
EDataBook *data_book)
{
if (error == NULL) {
e_dbus_address_book_complete_refresh (
- async_context->interface,
+ async_context->dbus_interface,
async_context->invocation);
} else {
data_book_convert_to_client_error (error);
}
static gboolean
-data_book_handle_refresh_cb (EDBusAddressBook *interface,
+data_book_handle_refresh_cb (EDBusAddressBook *dbus_interface,
GDBusMethodInvocation *invocation,
EDataBook *data_book)
{
EVC_FORMAT_VCARD_30);
utf8_vcard = e_util_utf8_make_valid (vcard);
e_dbus_address_book_complete_get_contact (
- async_context->interface,
+ async_context->dbus_interface,
async_context->invocation,
utf8_vcard);
g_free (utf8_vcard);
}
static gboolean
-data_book_handle_get_contact_cb (EDBusAddressBook *interface,
+data_book_handle_get_contact_cb (EDBusAddressBook *dbus_interface,
GDBusMethodInvocation *invocation,
const gchar *in_uid,
EDataBook *data_book)
}
e_dbus_address_book_complete_get_contact_list (
- async_context->interface,
+ async_context->dbus_interface,
async_context->invocation,
(const gchar * const *) strv);
}
static gboolean
-data_book_handle_get_contact_list_cb (EDBusAddressBook *interface,
+data_book_handle_get_contact_list_cb (EDBusAddressBook *dbus_interface,
GDBusMethodInvocation *invocation,
const gchar *in_query,
EDataBook *data_book)
}
e_dbus_address_book_complete_get_contact_list_uids (
- async_context->interface,
+ async_context->dbus_interface,
async_context->invocation,
(const gchar * const *) strv);
}
static gboolean
-data_book_handle_get_contact_list_uids_cb (EDBusAddressBook *interface,
+data_book_handle_get_contact_list_uids_cb (EDBusAddressBook *dbus_interface,
GDBusMethodInvocation *invocation,
const gchar *in_query,
EDataBook *data_book)
}
e_dbus_address_book_complete_create_contacts (
- async_context->interface,
+ async_context->dbus_interface,
async_context->invocation,
(const gchar * const *) strv);
}
static gboolean
-data_book_handle_create_contacts_cb (EDBusAddressBook *interface,
+data_book_handle_create_contacts_cb (EDBusAddressBook *dbus_interface,
GDBusMethodInvocation *invocation,
const gchar * const *in_vcards,
EDataBook *data_book)
if (error == NULL) {
e_dbus_address_book_complete_modify_contacts (
- async_context->interface,
+ async_context->dbus_interface,
async_context->invocation);
} else {
data_book_convert_to_client_error (error);
}
static gboolean
-data_book_handle_modify_contacts_cb (EDBusAddressBook *interface,
+data_book_handle_modify_contacts_cb (EDBusAddressBook *dbus_interface,
GDBusMethodInvocation *invocation,
const gchar * const *in_vcards,
EDataBook *data_book)
if (error == NULL) {
e_dbus_address_book_complete_remove_contacts (
- async_context->interface,
+ async_context->dbus_interface,
async_context->invocation);
} else {
data_book_convert_to_client_error (error);
}
static gboolean
-data_book_handle_remove_contacts_cb (EDBusAddressBook *interface,
+data_book_handle_remove_contacts_cb (EDBusAddressBook *dbus_interface,
GDBusMethodInvocation *invocation,
const gchar * const *in_uids,
EDataBook *data_book)
}
static gboolean
-data_book_handle_get_view_cb (EDBusAddressBook *interface,
+data_book_handle_get_view_cb (EDBusAddressBook *dbus_interface,
GDBusMethodInvocation *invocation,
const gchar *in_query,
EDataBook *data_book)
if (view != NULL) {
e_dbus_address_book_complete_get_view (
- interface, invocation, object_path);
+ dbus_interface, invocation, object_path);
e_book_backend_add_view (backend, view);
g_object_unref (view);
} else {
}
static gboolean
-data_book_handle_get_cursor_cb (EDBusAddressBook *interface,
+data_book_handle_get_cursor_cb (EDBusAddressBook *dbus_interface,
GDBusMethodInvocation *invocation,
const gchar *in_query,
const gchar * const *in_sort_keys,
* All is good in the hood, complete the method call
*/
e_dbus_address_book_complete_get_cursor (
- interface, invocation, object_path);
+ dbus_interface, invocation, object_path);
g_free (object_path);
g_object_unref (backend);
return TRUE;
}
static gboolean
-data_book_handle_close_cb (EDBusAddressBook *interface,
+data_book_handle_close_cb (EDBusAddressBook *dbus_interface,
GDBusMethodInvocation *invocation,
EDataBook *data_book)
{
/* G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED should be set on
* the GDBusMessage, but we complete the invocation anyway
* and let the D-Bus machinery suppress the reply. */
- e_dbus_address_book_complete_close (interface, invocation);
+ e_dbus_address_book_complete_close (dbus_interface, invocation);
backend = e_data_book_ref_backend (data_book);
g_return_val_if_fail (backend != NULL, FALSE);
}
static void
-e_data_book_initable_init (GInitableIface *interface)
+e_data_book_initable_init (GInitableIface *iface)
{
- interface->init = data_book_initable_init;
+ iface->init = data_book_initable_init;
}
static void
/* Forward Declarations */
static void caldav_source_authenticator_init
- (ESourceAuthenticatorInterface *interface);
+ (ESourceAuthenticatorInterface *iface);
G_DEFINE_TYPE_WITH_CODE (
ECalBackendCalDAV,
}
static void
-caldav_source_authenticator_init (ESourceAuthenticatorInterface *interface)
+caldav_source_authenticator_init (ESourceAuthenticatorInterface *iface)
{
- interface->try_password_sync = caldav_try_password_sync;
+ iface->try_password_sync = caldav_try_password_sync;
}
/* ************************************************************************* */
static void bump_revision (ECalBackendFile *cbfile);
static void e_cal_backend_file_timezone_cache_init
- (ETimezoneCacheInterface *interface);
+ (ETimezoneCacheInterface *iface);
static ETimezoneCacheInterface *parent_timezone_cache_interface;
}
static void
-e_cal_backend_file_timezone_cache_init (ETimezoneCacheInterface *interface)
+e_cal_backend_file_timezone_cache_init (ETimezoneCacheInterface *iface)
{
- parent_timezone_cache_interface =
- g_type_interface_peek_parent (interface);
+ parent_timezone_cache_interface = g_type_interface_peek_parent (iface);
- interface->add_timezone = cal_backend_file_add_cached_timezone;
- interface->get_timezone = cal_backend_file_get_cached_timezone;
- interface->list_timezones = cal_backend_file_list_cached_timezones;
+ iface->add_timezone = cal_backend_file_add_cached_timezone;
+ iface->get_timezone = cal_backend_file_get_cached_timezone;
+ iface->list_timezones = cal_backend_file_list_cached_timezones;
}
static void
/* Forward Declarations */
static void e_cal_backend_http_source_authenticator_init
- (ESourceAuthenticatorInterface *interface);
+ (ESourceAuthenticatorInterface *iface);
G_DEFINE_TYPE_WITH_CODE (
ECalBackendHttp,
}
static void
-e_cal_backend_http_source_authenticator_init (ESourceAuthenticatorInterface *interface)
+e_cal_backend_http_source_authenticator_init (ESourceAuthenticatorInterface *iface)
{
- interface->try_password_sync = cal_backend_http_try_password_sync;
+ iface->try_password_sync = cal_backend_http_try_password_sync;
}
};
/* Forward Declarations */
-static void e_cal_client_view_initable_init (GInitableIface *interface);
+static void e_cal_client_view_initable_init (GInitableIface *iface);
static guint signals[LAST_SIGNAL];
}
static void
-e_cal_client_view_initable_init (GInitableIface *interface)
+e_cal_client_view_initable_init (GInitableIface *iface)
{
- interface->init = cal_client_view_initable_init;
+ iface->init = cal_client_view_initable_init;
}
static void
/* Forward Declarations */
static void e_cal_client_initable_init
- (GInitableIface *interface);
+ (GInitableIface *iface);
static void e_cal_client_async_initable_init
- (GAsyncInitableIface *interface);
+ (GAsyncInitableIface *iface);
static void e_cal_client_timezone_cache_init
- (ETimezoneCacheInterface *interface);
+ (ETimezoneCacheInterface *iface);
static guint signals[LAST_SIGNAL];
}
static void
-e_cal_client_initable_init (GInitableIface *interface)
+e_cal_client_initable_init (GInitableIface *iface)
{
- interface->init = cal_client_initable_init;
+ iface->init = cal_client_initable_init;
}
static void
-e_cal_client_async_initable_init (GAsyncInitableIface *interface)
+e_cal_client_async_initable_init (GAsyncInitableIface *iface)
{
- interface->init_async = cal_client_initable_init_async;
- interface->init_finish = cal_client_initable_init_finish;
+ iface->init_async = cal_client_initable_init_async;
+ iface->init_finish = cal_client_initable_init_finish;
}
static void
-e_cal_client_timezone_cache_init (ETimezoneCacheInterface *interface)
+e_cal_client_timezone_cache_init (ETimezoneCacheInterface *iface)
{
- interface->add_timezone = cal_client_add_cached_timezone;
- interface->get_timezone = cal_client_get_cached_timezone;
- interface->list_timezones = cal_client_list_cached_timezones;
+ iface->add_timezone = cal_client_add_cached_timezone;
+ iface->get_timezone = cal_client_get_cached_timezone;
+ iface->list_timezones = cal_client_list_cached_timezones;
}
static void
static guint signals[LAST_SIGNAL];
-static void e_cal_initable_init (GInitableIface *interface);
+static void e_cal_initable_init (GInitableIface *iface);
G_DEFINE_TYPE_WITH_CODE (
ECal, e_cal, G_TYPE_OBJECT,
}
static void
-e_cal_initable_init (GInitableIface *interface)
+e_cal_initable_init (GInitableIface *iface)
{
- interface->init = cal_initable_init;
+ iface->init = cal_initable_init;
}
static void
G_TYPE_OBJECT)
static void
-e_timezone_cache_default_init (ETimezoneCacheInterface *interface)
+e_timezone_cache_default_init (ETimezoneCacheInterface *iface)
{
/**
* ETimezoneCache::timezone-added:
**/
g_signal_new (
"timezone-added",
- G_OBJECT_CLASS_TYPE (interface),
+ G_OBJECT_CLASS_TYPE (iface),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (ETimezoneCacheInterface, timezone_added),
NULL, NULL, NULL,
e_timezone_cache_add_timezone (ETimezoneCache *cache,
icaltimezone *zone)
{
- ETimezoneCacheInterface *interface;
+ ETimezoneCacheInterface *iface;
g_return_if_fail (E_IS_TIMEZONE_CACHE (cache));
g_return_if_fail (zone != NULL);
- interface = E_TIMEZONE_CACHE_GET_INTERFACE (cache);
- g_return_if_fail (interface->add_timezone != NULL);
+ iface = E_TIMEZONE_CACHE_GET_INTERFACE (cache);
+ g_return_if_fail (iface->add_timezone != NULL);
- interface->add_timezone (cache, zone);
+ iface->add_timezone (cache, zone);
}
/**
e_timezone_cache_get_timezone (ETimezoneCache *cache,
const gchar *tzid)
{
- ETimezoneCacheInterface *interface;
+ ETimezoneCacheInterface *iface;
g_return_val_if_fail (E_IS_TIMEZONE_CACHE (cache), NULL);
g_return_val_if_fail (tzid != NULL, NULL);
- interface = E_TIMEZONE_CACHE_GET_INTERFACE (cache);
- g_return_val_if_fail (interface->get_timezone != NULL, NULL);
+ iface = E_TIMEZONE_CACHE_GET_INTERFACE (cache);
+ g_return_val_if_fail (iface->get_timezone != NULL, NULL);
- return interface->get_timezone (cache, tzid);
+ return iface->get_timezone (cache, tzid);
}
/**
GList *
e_timezone_cache_list_timezones (ETimezoneCache *cache)
{
- ETimezoneCacheInterface *interface;
+ ETimezoneCacheInterface *iface;
g_return_val_if_fail (E_IS_TIMEZONE_CACHE (cache), NULL);
- interface = E_TIMEZONE_CACHE_GET_INTERFACE (cache);
- g_return_val_if_fail (interface->list_timezones != NULL, NULL);
+ iface = E_TIMEZONE_CACHE_GET_INTERFACE (cache);
+ g_return_val_if_fail (iface->list_timezones != NULL, NULL);
- return interface->list_timezones (cache);
+ return iface->list_timezones (cache);
}
/* Forward Declarations */
static void e_cal_backend_timezone_cache_init
- (ETimezoneCacheInterface *interface);
+ (ETimezoneCacheInterface *iface);
G_DEFINE_TYPE_WITH_CODE (
ECalBackend,
}
static void
-e_cal_backend_timezone_cache_init (ETimezoneCacheInterface *interface)
+e_cal_backend_timezone_cache_init (ETimezoneCacheInterface *iface)
{
- interface->add_timezone = cal_backend_add_cached_timezone;
- interface->get_timezone = cal_backend_get_cached_timezone;
- interface->list_timezones = cal_backend_list_cached_timezones;
+ iface->add_timezone = cal_backend_add_cached_timezone;
+ iface->get_timezone = cal_backend_get_cached_timezone;
+ iface->list_timezones = cal_backend_list_cached_timezones;
}
static void
/* Forward Declarations */
static void e_data_cal_factory_initable_init
- (GInitableIface *interface);
+ (GInitableIface *iface);
G_DEFINE_TYPE_WITH_CODE (
EDataCalFactory,
}
static gboolean
-data_cal_factory_handle_open_calendar_cb (EDBusCalendarFactory *interface,
+data_cal_factory_handle_open_calendar_cb (EDBusCalendarFactory *dbus_interface,
GDBusMethodInvocation *invocation,
const gchar *uid,
EDataCalFactory *factory)
if (object_path != NULL) {
e_dbus_calendar_factory_complete_open_calendar (
- interface, invocation, object_path);
+ dbus_interface, invocation, object_path);
g_free (object_path);
} else {
g_return_val_if_fail (error != NULL, FALSE);
}
static gboolean
-data_cal_factory_handle_open_task_list_cb (EDBusCalendarFactory *interface,
+data_cal_factory_handle_open_task_list_cb (EDBusCalendarFactory *dbus_interface,
GDBusMethodInvocation *invocation,
const gchar *uid,
EDataCalFactory *factory)
if (object_path != NULL) {
e_dbus_calendar_factory_complete_open_task_list (
- interface, invocation, object_path);
+ dbus_interface, invocation, object_path);
g_free (object_path);
} else {
g_return_val_if_fail (error != NULL, FALSE);
}
static gboolean
-data_cal_factory_handle_open_memo_list_cb (EDBusCalendarFactory *interface,
+data_cal_factory_handle_open_memo_list_cb (EDBusCalendarFactory *dbus_interface,
GDBusMethodInvocation *invocation,
const gchar *uid,
EDataCalFactory *factory)
if (object_path != NULL) {
e_dbus_calendar_factory_complete_open_memo_list (
- interface, invocation, object_path);
+ dbus_interface, invocation, object_path);
g_free (object_path);
} else {
g_return_val_if_fail (error != NULL, FALSE);
}
static void
-e_data_cal_factory_initable_init (GInitableIface *interface)
+e_data_cal_factory_initable_init (GInitableIface *iface)
{
- interface->init = data_cal_factory_initable_init;
+ iface->init = data_cal_factory_initable_init;
}
static void
};
/* Forward Declarations */
-static void e_data_cal_view_initable_init (GInitableIface *interface);
+static void e_data_cal_view_initable_init (GInitableIface *iface);
G_DEFINE_TYPE_WITH_CODE (
EDataCalView,
}
static void
-e_data_cal_view_initable_init (GInitableIface *interface)
+e_data_cal_view_initable_init (GInitableIface *iface)
{
- interface->init = data_cal_view_initable_init;
+ iface->init = data_cal_view_initable_init;
}
static void
struct _AsyncContext {
EDataCal *data_cal;
- EDBusCalendar *interface;
+ EDBusCalendar *dbus_interface;
GDBusMethodInvocation *invocation;
GCancellable *cancellable;
guint watcher_id;
};
/* Forward Declarations */
-static void e_data_cal_initable_init (GInitableIface *interface);
+static void e_data_cal_initable_init (GInitableIface *iface);
G_DEFINE_TYPE_WITH_CODE (
EDataCal,
GDBusMethodInvocation *invocation)
{
AsyncContext *async_context;
- EDBusCalendar *interface;
+ EDBusCalendar *dbus_interface;
- interface = data_cal->priv->dbus_interface;
+ dbus_interface = data_cal->priv->dbus_interface;
async_context = g_slice_new0 (AsyncContext);
async_context->data_cal = g_object_ref (data_cal);
- async_context->interface = g_object_ref (interface);
+ async_context->dbus_interface = g_object_ref (dbus_interface);
async_context->invocation = g_object_ref (invocation);
async_context->cancellable = g_cancellable_new ();
async_context->cancellable);
g_clear_object (&async_context->data_cal);
- g_clear_object (&async_context->interface);
+ g_clear_object (&async_context->dbus_interface);
g_clear_object (&async_context->invocation);
g_clear_object (&async_context->cancellable);
if (error == NULL) {
e_dbus_calendar_complete_open (
- async_context->interface,
+ async_context->dbus_interface,
async_context->invocation);
} else {
data_cal_convert_to_client_error (error);
}
static gboolean
-data_cal_handle_open_cb (EDBusCalendar *interface,
+data_cal_handle_open_cb (EDBusCalendar *dbus_interface,
GDBusMethodInvocation *invocation,
EDataCal *data_cal)
{
if (error == NULL) {
e_dbus_calendar_complete_refresh (
- async_context->interface,
+ async_context->dbus_interface,
async_context->invocation);
} else {
data_cal_convert_to_client_error (error);
}
static gboolean
-data_cal_handle_refresh_cb (EDBusCalendar *interface,
+data_cal_handle_refresh_cb (EDBusCalendar *dbus_interface,
GDBusMethodInvocation *invocation,
EDataCal *data_cal)
{
utf8_calobj = e_util_utf8_make_valid (calobj);
e_dbus_calendar_complete_get_object (
- async_context->interface,
+ async_context->dbus_interface,
async_context->invocation,
utf8_calobj);
}
static gboolean
-data_cal_handle_get_object_cb (EDBusCalendar *interface,
+data_cal_handle_get_object_cb (EDBusCalendar *dbus_interface,
GDBusMethodInvocation *invocation,
const gchar *in_uid,
const gchar *in_rid,
}
e_dbus_calendar_complete_get_object_list (
- async_context->interface,
+ async_context->dbus_interface,
async_context->invocation,
(const gchar * const *) strv);
}
static gboolean
-data_cal_handle_get_object_list_cb (EDBusCalendar *interface,
+data_cal_handle_get_object_list_cb (EDBusCalendar *dbus_interface,
GDBusMethodInvocation *invocation,
const gchar *in_query,
EDataCal *data_cal)
if (error == NULL) {
e_dbus_calendar_complete_get_free_busy (
- async_context->interface,
+ async_context->dbus_interface,
async_context->invocation);
} else {
data_cal_convert_to_client_error (error);
}
static gboolean
-data_cal_handle_get_free_busy_cb (EDBusCalendar *interface,
+data_cal_handle_get_free_busy_cb (EDBusCalendar *dbus_interface,
GDBusMethodInvocation *invocation,
gint64 in_start,
gint64 in_end,
}
e_dbus_calendar_complete_create_objects (
- async_context->interface,
+ async_context->dbus_interface,
async_context->invocation,
(const gchar * const *) strv);
}
static gboolean
-data_cal_handle_create_objects_cb (EDBusCalendar *interface,
+data_cal_handle_create_objects_cb (EDBusCalendar *dbus_interface,
GDBusMethodInvocation *invocation,
const gchar * const *in_calobjs,
EDataCal *data_cal)
if (error == NULL) {
e_dbus_calendar_complete_modify_objects (
- async_context->interface,
+ async_context->dbus_interface,
async_context->invocation);
} else {
data_cal_convert_to_client_error (error);
}
static gboolean
-data_cal_handle_modify_objects_cb (EDBusCalendar *interface,
+data_cal_handle_modify_objects_cb (EDBusCalendar *dbus_interface,
GDBusMethodInvocation *invocation,
const gchar * const *in_ics_objects,
const gchar *in_mod_type,
if (error == NULL) {
e_dbus_calendar_complete_remove_objects (
- async_context->interface,
+ async_context->dbus_interface,
async_context->invocation);
} else {
data_cal_convert_to_client_error (error);
}
static gboolean
-data_cal_handle_remove_objects_cb (EDBusCalendar *interface,
+data_cal_handle_remove_objects_cb (EDBusCalendar *dbus_interface,
GDBusMethodInvocation *invocation,
GVariant *in_uid_rid_array,
const gchar *in_mod_type,
if (error == NULL) {
e_dbus_calendar_complete_receive_objects (
- async_context->interface,
+ async_context->dbus_interface,
async_context->invocation);
} else {
data_cal_convert_to_client_error (error);
}
static gboolean
-data_cal_handle_receive_objects_cb (EDBusCalendar *interface,
+data_cal_handle_receive_objects_cb (EDBusCalendar *dbus_interface,
GDBusMethodInvocation *invocation,
const gchar *in_calobj,
EDataCal *data_cal)
utf8_calobj = e_util_utf8_make_valid (calobj);
e_dbus_calendar_complete_send_objects (
- async_context->interface,
+ async_context->dbus_interface,
async_context->invocation,
(const gchar * const *) strv,
utf8_calobj);
}
static gboolean
-data_cal_handle_send_objects_cb (EDBusCalendar *interface,
+data_cal_handle_send_objects_cb (EDBusCalendar *dbus_interface,
GDBusMethodInvocation *invocation,
const gchar *in_calobj,
EDataCal *data_cal)
}
e_dbus_calendar_complete_get_attachment_uris (
- async_context->interface,
+ async_context->dbus_interface,
async_context->invocation,
(const gchar * const *) strv);
}
static gboolean
-data_cal_handle_get_attachment_uris_cb (EDBusCalendar *interface,
+data_cal_handle_get_attachment_uris_cb (EDBusCalendar *dbus_interface,
GDBusMethodInvocation *invocation,
const gchar *in_uid,
const gchar *in_rid,
if (error == NULL) {
e_dbus_calendar_complete_discard_alarm (
- async_context->interface,
+ async_context->dbus_interface,
async_context->invocation);
} else {
data_cal_convert_to_client_error (error);
}
static gboolean
-data_cal_handle_discard_alarm_cb (EDBusCalendar *interface,
+data_cal_handle_discard_alarm_cb (EDBusCalendar *dbus_interface,
GDBusMethodInvocation *invocation,
const gchar *in_uid,
const gchar *in_rid,
}
static gboolean
-data_cal_handle_get_view_cb (EDBusCalendar *interface,
+data_cal_handle_get_view_cb (EDBusCalendar *dbus_interface,
GDBusMethodInvocation *invocation,
const gchar *in_query,
EDataCal *data_cal)
if (view != NULL) {
e_dbus_calendar_complete_get_view (
- interface, invocation, object_path);
+ dbus_interface, invocation, object_path);
e_cal_backend_add_view (backend, view);
g_object_unref (view);
} else {
if (tzobject != NULL) {
e_dbus_calendar_complete_get_timezone (
- async_context->interface,
+ async_context->dbus_interface,
async_context->invocation,
tzobject);
}
static gboolean
-data_cal_handle_get_timezone_cb (EDBusCalendar *interface,
+data_cal_handle_get_timezone_cb (EDBusCalendar *dbus_interface,
GDBusMethodInvocation *invocation,
const gchar *in_tzid,
EDataCal *data_cal)
if (error == NULL) {
e_dbus_calendar_complete_add_timezone (
- async_context->interface,
+ async_context->dbus_interface,
async_context->invocation);
} else {
data_cal_convert_to_client_error (error);
}
static gboolean
-data_cal_handle_add_timezone_cb (EDBusCalendar *interface,
+data_cal_handle_add_timezone_cb (EDBusCalendar *dbus_interface,
GDBusMethodInvocation *invocation,
const gchar *in_tzobject,
EDataCal *data_cal)
}
static gboolean
-data_cal_handle_close_cb (EDBusCalendar *interface,
+data_cal_handle_close_cb (EDBusCalendar *dbus_interface,
GDBusMethodInvocation *invocation,
EDataCal *data_cal)
{
/* G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED should be set on
* the GDBusMessage, but we complete the invocation anyway
* and let the D-Bus machinery suppress the reply. */
- e_dbus_calendar_complete_close (interface, invocation);
+ e_dbus_calendar_complete_close (dbus_interface, invocation);
backend = e_data_cal_ref_backend (data_cal);
g_return_val_if_fail (backend != NULL, FALSE);
}
static void
-e_data_cal_initable_init (GInitableIface *interface)
+e_data_cal_initable_init (GInitableIface *iface)
{
- interface->init = data_cal_initable_init;
+ iface->init = data_cal_initable_init;
}
static void
G_DEFINE_INTERFACE (CamelJunkFilter, camel_junk_filter, G_TYPE_OBJECT)
static void
-camel_junk_filter_default_init (CamelJunkFilterInterface *interface)
+camel_junk_filter_default_init (CamelJunkFilterInterface *iface)
{
}
GCancellable *cancellable,
GError **error)
{
- CamelJunkFilterInterface *interface;
+ CamelJunkFilterInterface *iface;
g_return_val_if_fail (CAMEL_IS_JUNK_FILTER (junk_filter), 0);
g_return_val_if_fail (CAMEL_IS_MIME_MESSAGE (message), 0);
- interface = CAMEL_JUNK_FILTER_GET_INTERFACE (junk_filter);
- g_return_val_if_fail (interface->classify != NULL, 0);
+ iface = CAMEL_JUNK_FILTER_GET_INTERFACE (junk_filter);
+ g_return_val_if_fail (iface->classify != NULL, 0);
- return interface->classify (
+ return iface->classify (
junk_filter, message, cancellable, error);
}
GCancellable *cancellable,
GError **error)
{
- CamelJunkFilterInterface *interface;
+ CamelJunkFilterInterface *iface;
g_return_val_if_fail (CAMEL_IS_JUNK_FILTER (junk_filter), FALSE);
g_return_val_if_fail (CAMEL_IS_MIME_MESSAGE (message), FALSE);
- interface = CAMEL_JUNK_FILTER_GET_INTERFACE (junk_filter);
- g_return_val_if_fail (interface->learn_junk != NULL, FALSE);
+ iface = CAMEL_JUNK_FILTER_GET_INTERFACE (junk_filter);
+ g_return_val_if_fail (iface->learn_junk != NULL, FALSE);
- return interface->learn_junk (
+ return iface->learn_junk (
junk_filter, message, cancellable, error);
}
GCancellable *cancellable,
GError **error)
{
- CamelJunkFilterInterface *interface;
+ CamelJunkFilterInterface *iface;
g_return_val_if_fail (CAMEL_IS_JUNK_FILTER (junk_filter), FALSE);
g_return_val_if_fail (CAMEL_IS_MIME_MESSAGE (message), FALSE);
- interface = CAMEL_JUNK_FILTER_GET_INTERFACE (junk_filter);
- g_return_val_if_fail (interface->learn_not_junk != NULL, FALSE);
+ iface = CAMEL_JUNK_FILTER_GET_INTERFACE (junk_filter);
+ g_return_val_if_fail (iface->learn_not_junk != NULL, FALSE);
- return interface->learn_not_junk (
+ return iface->learn_not_junk (
junk_filter, message, cancellable, error);
}
GCancellable *cancellable,
GError **error)
{
- CamelJunkFilterInterface *interface;
+ CamelJunkFilterInterface *iface;
gboolean success = TRUE;
g_return_val_if_fail (CAMEL_IS_JUNK_FILTER (junk_filter), FALSE);
/* This method is optional. */
- interface = CAMEL_JUNK_FILTER_GET_INTERFACE (junk_filter);
+ iface = CAMEL_JUNK_FILTER_GET_INTERFACE (junk_filter);
- if (interface->synchronize != NULL) {
+ if (iface->synchronize != NULL) {
camel_operation_push_message (
cancellable, _("Synchronizing junk database"));
- success = interface->synchronize (
+ success = iface->synchronize (
junk_filter, cancellable, error);
camel_operation_pop_message (cancellable);
}
static void
-camel_network_service_default_init (CamelNetworkServiceInterface *interface)
+camel_network_service_default_init (CamelNetworkServiceInterface *iface)
{
- interface->connect_sync = network_service_connect_sync;
- interface->new_connectable = network_service_new_connectable;
+ iface->connect_sync = network_service_connect_sync;
+ iface->new_connectable = network_service_new_connectable;
g_object_interface_install_property (
- interface,
+ iface,
g_param_spec_object (
"connectable",
"Connectable",
G_PARAM_STATIC_STRINGS));
g_object_interface_install_property (
- interface,
+ iface,
g_param_spec_boolean (
"host-reachable",
"Host Reachable",
camel_network_service_get_service_name (CamelNetworkService *service,
CamelNetworkSecurityMethod method)
{
- CamelNetworkServiceInterface *interface;
+ CamelNetworkServiceInterface *iface;
const gchar *service_name = NULL;
g_return_val_if_fail (CAMEL_IS_NETWORK_SERVICE (service), NULL);
- interface = CAMEL_NETWORK_SERVICE_GET_INTERFACE (service);
+ iface = CAMEL_NETWORK_SERVICE_GET_INTERFACE (service);
- if (interface->get_service_name != NULL)
- service_name = interface->get_service_name (service, method);
+ if (iface->get_service_name != NULL)
+ service_name = iface->get_service_name (service, method);
return service_name;
}
camel_network_service_get_default_port (CamelNetworkService *service,
CamelNetworkSecurityMethod method)
{
- CamelNetworkServiceInterface *interface;
+ CamelNetworkServiceInterface *iface;
guint16 default_port = 0;
g_return_val_if_fail (CAMEL_IS_NETWORK_SERVICE (service), 0);
- interface = CAMEL_NETWORK_SERVICE_GET_INTERFACE (service);
+ iface = CAMEL_NETWORK_SERVICE_GET_INTERFACE (service);
- if (interface->get_default_port != NULL)
- default_port = interface->get_default_port (service, method);
+ if (iface->get_default_port != NULL)
+ default_port = iface->get_default_port (service, method);
return default_port;
}
camel_network_service_set_connectable (CamelNetworkService *service,
GSocketConnectable *connectable)
{
- CamelNetworkServiceInterface *interface;
+ CamelNetworkServiceInterface *iface;
CamelNetworkServicePrivate *priv;
g_return_if_fail (CAMEL_IS_NETWORK_SERVICE (service));
- interface = CAMEL_NETWORK_SERVICE_GET_INTERFACE (service);
- g_return_if_fail (interface->new_connectable != NULL);
+ iface = CAMEL_NETWORK_SERVICE_GET_INTERFACE (service);
+ g_return_if_fail (iface->new_connectable != NULL);
priv = CAMEL_NETWORK_SERVICE_GET_PRIVATE (service);
g_return_if_fail (priv != NULL);
} else {
/* This may return NULL if we don't have valid network
* settings from which to create a GSocketConnectable. */
- connectable = interface->new_connectable (service);
+ connectable = iface->new_connectable (service);
}
g_mutex_lock (&priv->property_lock);
GCancellable *cancellable,
GError **error)
{
- CamelNetworkServiceInterface *interface;
+ CamelNetworkServiceInterface *iface;
g_return_val_if_fail (CAMEL_IS_NETWORK_SERVICE (service), NULL);
- interface = CAMEL_NETWORK_SERVICE_GET_INTERFACE (service);
- g_return_val_if_fail (interface->connect_sync != NULL, NULL);
+ iface = CAMEL_NETWORK_SERVICE_GET_INTERFACE (service);
+ g_return_val_if_fail (iface->connect_sync != NULL, NULL);
- return interface->connect_sync (service, cancellable, error);
+ return iface->connect_sync (service, cancellable, error);
}
/**
CAMEL_TYPE_SETTINGS)
static void
-camel_network_settings_default_init (CamelNetworkSettingsInterface *interface)
+camel_network_settings_default_init (CamelNetworkSettingsInterface *iface)
{
g_object_interface_install_property (
- interface,
+ iface,
g_param_spec_string (
"auth-mechanism",
"Auth Mechanism",
G_PARAM_STATIC_STRINGS));
g_object_interface_install_property (
- interface,
+ iface,
g_param_spec_string (
"host",
"Host",
G_PARAM_STATIC_STRINGS));
g_object_interface_install_property (
- interface,
+ iface,
g_param_spec_uint (
"port",
"Port",
G_PARAM_STATIC_STRINGS));
g_object_interface_install_property (
- interface,
+ iface,
g_param_spec_enum (
"security-method",
"Security Method",
G_PARAM_STATIC_STRINGS));
g_object_interface_install_property (
- interface,
+ iface,
g_param_spec_string (
"user",
"User",
/* Forward Declarations */
void camel_network_service_init (CamelNetworkService *service);
-static void camel_service_initable_init (GInitableIface *interface);
+static void camel_service_initable_init (GInitableIface *iface);
static void service_task_dispatch (CamelService *service,
GTask *task);
}
static void
-camel_service_initable_init (GInitableIface *interface)
+camel_service_initable_init (GInitableIface *iface)
{
- interface->init = service_initable_init;
+ iface->init = service_initable_init;
}
static void
static GInitableIface *parent_initable_interface;
/* Forward Declarations */
-static void camel_store_initable_init (GInitableIface *interface);
+static void camel_store_initable_init (GInitableIface *iface);
G_DEFINE_ABSTRACT_TYPE_WITH_CODE (
CamelStore, camel_store, CAMEL_TYPE_SERVICE,
}
static void
-camel_store_initable_init (GInitableIface *interface)
+camel_store_initable_init (GInitableIface *iface)
{
- parent_initable_interface = g_type_interface_peek_parent (interface);
+ parent_initable_interface = g_type_interface_peek_parent (iface);
- interface->init = store_initable_init;
+ iface->init = store_initable_init;
}
static void
#define READ_PAD (128) /* bytes padded before buffer */
#define READ_SIZE (4096)
-static void camel_stream_filter_seekable_init (GSeekableIface *interface);
+static void camel_stream_filter_seekable_init (GSeekableIface *iface);
G_DEFINE_TYPE_WITH_CODE (CamelStreamFilter, camel_stream_filter, CAMEL_TYPE_STREAM,
G_IMPLEMENT_INTERFACE (G_TYPE_SEEKABLE, camel_stream_filter_seekable_init))
}
static void
-camel_stream_filter_seekable_init (GSeekableIface *interface)
+camel_stream_filter_seekable_init (GSeekableIface *iface)
{
- interface->tell = stream_filter_tell;
- interface->can_seek = stream_filter_can_seek;
- interface->seek = stream_filter_seek;
- interface->can_truncate = stream_filter_can_truncate;
- interface->truncate_fn = stream_filter_truncate_fn;
+ iface->tell = stream_filter_tell;
+ iface->can_seek = stream_filter_can_seek;
+ iface->seek = stream_filter_seek;
+ iface->can_truncate = stream_filter_can_truncate;
+ iface->truncate_fn = stream_filter_truncate_fn;
}
static void
};
/* Forward Declarations */
-static void camel_stream_fs_seekable_init (GSeekableIface *interface);
+static void camel_stream_fs_seekable_init (GSeekableIface *iface);
G_DEFINE_TYPE_WITH_CODE (
CamelStreamFs, camel_stream_fs, CAMEL_TYPE_STREAM,
}
static void
-camel_stream_fs_seekable_init (GSeekableIface *interface)
+camel_stream_fs_seekable_init (GSeekableIface *iface)
{
- interface->tell = stream_fs_tell;
- interface->can_seek = stream_fs_can_seek;
- interface->seek = stream_fs_seek;
- interface->can_truncate = stream_fs_can_truncate;
- interface->truncate_fn = stream_fs_truncate_fn;
+ iface->tell = stream_fs_tell;
+ iface->can_seek = stream_fs_can_seek;
+ iface->seek = stream_fs_seek;
+ iface->can_truncate = stream_fs_can_truncate;
+ iface->truncate_fn = stream_fs_truncate_fn;
}
static void
};
/* Forward Declarations */
-static void camel_stream_mem_seekable_init (GSeekableIface *interface);
+static void camel_stream_mem_seekable_init (GSeekableIface *iface);
G_DEFINE_TYPE_WITH_CODE (
CamelStreamMem, camel_stream_mem, CAMEL_TYPE_STREAM,
}
static void
-camel_stream_mem_seekable_init (GSeekableIface *interface)
+camel_stream_mem_seekable_init (GSeekableIface *iface)
{
- interface->tell = stream_mem_tell;
- interface->can_seek = stream_mem_can_seek;
- interface->seek = stream_mem_seek;
- interface->can_truncate = stream_mem_can_truncate;
- interface->truncate_fn = stream_mem_truncate_fn;
+ iface->tell = stream_mem_tell;
+ iface->can_seek = stream_mem_can_seek;
+ iface->seek = stream_mem_seek;
+ iface->can_truncate = stream_mem_can_truncate;
+ iface->truncate_fn = stream_mem_truncate_fn;
}
static void
#include "camel-stream-null.h"
-static void camel_stream_null_seekable_init (GSeekableIface *interface);
+static void camel_stream_null_seekable_init (GSeekableIface *iface);
G_DEFINE_TYPE_WITH_CODE (CamelStreamNull, camel_stream_null, CAMEL_TYPE_STREAM,
G_IMPLEMENT_INTERFACE (G_TYPE_SEEKABLE, camel_stream_null_seekable_init))
}
static void
-camel_stream_null_seekable_init (GSeekableIface *interface)
+camel_stream_null_seekable_init (GSeekableIface *iface)
{
- interface->tell = stream_null_tell;
- interface->can_seek = stream_null_can_seek;
- interface->seek = stream_null_seek;
- interface->can_truncate = stream_null_can_truncate;
- interface->truncate_fn = stream_null_truncate_fn;
+ iface->tell = stream_null_tell;
+ iface->can_seek = stream_null_can_seek;
+ iface->seek = stream_null_seek;
+ iface->can_truncate = stream_null_can_truncate;
+ iface->truncate_fn = stream_null_truncate_fn;
}
static void
};
/* Forward Declarations */
-static void camel_stream_seekable_init (GSeekableIface *interface);
+static void camel_stream_seekable_init (GSeekableIface *iface);
G_DEFINE_TYPE_WITH_CODE (
CamelStream,
}
static void
-camel_stream_seekable_init (GSeekableIface *interface)
+camel_stream_seekable_init (GSeekableIface *iface)
{
- interface->tell = stream_tell;
- interface->can_seek = stream_can_seek;
- interface->seek = stream_seek;
- interface->can_truncate = stream_can_truncate;
- interface->truncate_fn = stream_truncate;
+ iface->tell = stream_tell;
+ iface->can_seek = stream_can_seek;
+ iface->seek = stream_seek;
+ iface->can_truncate = stream_can_truncate;
+ iface->truncate_fn = stream_truncate;
}
static void
}
static void
-camel_subscribable_default_init (CamelSubscribableInterface *interface)
+camel_subscribable_default_init (CamelSubscribableInterface *iface)
{
signals[FOLDER_SUBSCRIBED] = g_signal_new (
"folder-subscribed",
- G_OBJECT_CLASS_TYPE (interface),
+ G_OBJECT_CLASS_TYPE (iface),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (
CamelSubscribableInterface,
signals[FOLDER_UNSUBSCRIBED] = g_signal_new (
"folder-unsubscribed",
- G_OBJECT_CLASS_TYPE (interface),
+ G_OBJECT_CLASS_TYPE (iface),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (
CamelSubscribableInterface,
camel_subscribable_folder_is_subscribed (CamelSubscribable *subscribable,
const gchar *folder_name)
{
- CamelSubscribableInterface *interface;
+ CamelSubscribableInterface *iface;
g_return_val_if_fail (CAMEL_IS_SUBSCRIBABLE (subscribable), FALSE);
g_return_val_if_fail (folder_name != NULL, FALSE);
- interface = CAMEL_SUBSCRIBABLE_GET_INTERFACE (subscribable);
- g_return_val_if_fail (interface->folder_is_subscribed != NULL, FALSE);
+ iface = CAMEL_SUBSCRIBABLE_GET_INTERFACE (subscribable);
+ g_return_val_if_fail (iface->folder_is_subscribed != NULL, FALSE);
- return interface->folder_is_subscribed (subscribable, folder_name);
+ return iface->folder_is_subscribed (subscribable, folder_name);
}
/**
GCancellable *cancellable)
{
CamelSubscribable *subscribable;
- CamelSubscribableInterface *interface;
+ CamelSubscribableInterface *iface;
const gchar *folder_name;
const gchar *message;
gboolean success;
folder_name = async_context->folder_name;
- interface = CAMEL_SUBSCRIBABLE_GET_INTERFACE (subscribable);
- g_return_if_fail (interface->subscribe_folder_sync != NULL);
+ iface = CAMEL_SUBSCRIBABLE_GET_INTERFACE (subscribable);
+ g_return_if_fail (iface->subscribe_folder_sync != NULL);
/* Need to establish a connection before subscribing. */
camel_service_connect_sync (
message = _("Subscribing to folder '%s'");
camel_operation_push_message (cancellable, message, folder_name);
- success = interface->subscribe_folder_sync (
+ success = iface->subscribe_folder_sync (
subscribable, folder_name, cancellable, &local_error);
CAMEL_CHECK_LOCAL_GERROR (
subscribable, subscribe_folder_sync, success, local_error);
GCancellable *cancellable)
{
CamelSubscribable *subscribable;
- CamelSubscribableInterface *interface;
+ CamelSubscribableInterface *iface;
const gchar *folder_name;
const gchar *message;
gboolean success;
folder_name = async_context->folder_name;
- interface = CAMEL_SUBSCRIBABLE_GET_INTERFACE (subscribable);
- g_return_if_fail (interface->unsubscribe_folder_sync != NULL);
+ iface = CAMEL_SUBSCRIBABLE_GET_INTERFACE (subscribable);
+ g_return_if_fail (iface->unsubscribe_folder_sync != NULL);
/* Need to establish a connection before unsubscribing. */
camel_service_connect_sync (
message = _("Unsubscribing from folder '%s'");
camel_operation_push_message (cancellable, message, folder_name);
- success = interface->unsubscribe_folder_sync (
+ success = iface->unsubscribe_folder_sync (
subscribable, folder_name, cancellable, &local_error);
CAMEL_CHECK_LOCAL_GERROR (
subscribable, unsubscribe_folder_sync, success, local_error);
/* Forward Declarations */
static void camel_imapx_input_stream_pollable_init
- (GPollableInputStreamInterface *interface);
+ (GPollableInputStreamInterface *iface);
G_DEFINE_TYPE_WITH_CODE (
CamelIMAPXInputStream,
}
static void
-camel_imapx_input_stream_pollable_init (GPollableInputStreamInterface *interface)
+camel_imapx_input_stream_pollable_init (GPollableInputStreamInterface *iface)
{
- interface->can_poll = imapx_input_stream_can_poll;
- interface->is_readable = imapx_input_stream_is_readable;
- interface->create_source = imapx_input_stream_create_source;
- interface->read_nonblocking = imapx_input_stream_read_nonblocking;
+ iface->can_poll = imapx_input_stream_can_poll;
+ iface->is_readable = imapx_input_stream_is_readable;
+ iface->create_source = imapx_input_stream_create_source;
+ iface->read_nonblocking = imapx_input_stream_read_nonblocking;
}
static void
/* Forward Declarations */
static void camel_imapx_logger_interface_init
- (GConverterIface *interface);
+ (GConverterIface *iface);
G_DEFINE_TYPE_WITH_CODE (
CamelIMAPXLogger,
}
static void
-camel_imapx_logger_interface_init (GConverterIface *interface)
+camel_imapx_logger_interface_init (GConverterIface *iface)
{
- interface->convert = imapx_logger_convert;
- interface->reset = imapx_logger_reset;
+ iface->convert = imapx_logger_convert;
+ iface->reset = imapx_logger_reset;
}
static void
static GInitableIface *parent_initable_interface;
/* Forward Declarations */
-static void camel_imapx_store_initable_init (GInitableIface *interface);
-static void camel_network_service_init (CamelNetworkServiceInterface *interface);
-static void camel_subscribable_init (CamelSubscribableInterface *interface);
+static void camel_imapx_store_initable_init (GInitableIface *iface);
+static void camel_network_service_init (CamelNetworkServiceInterface *iface);
+static void camel_subscribable_init (CamelSubscribableInterface *iface);
G_DEFINE_TYPE_WITH_CODE (
CamelIMAPXStore,
}
static void
-camel_imapx_store_initable_init (GInitableIface *interface)
+camel_imapx_store_initable_init (GInitableIface *iface)
{
- parent_initable_interface = g_type_interface_peek_parent (interface);
+ parent_initable_interface = g_type_interface_peek_parent (iface);
- interface->init = imapx_store_initable_init;
+ iface->init = imapx_store_initable_init;
}
static void
-camel_network_service_init (CamelNetworkServiceInterface *interface)
+camel_network_service_init (CamelNetworkServiceInterface *iface)
{
- interface->get_service_name = imapx_store_get_service_name;
- interface->get_default_port = imapx_store_get_default_port;
+ iface->get_service_name = imapx_store_get_service_name;
+ iface->get_default_port = imapx_store_get_default_port;
}
static void
-camel_subscribable_init (CamelSubscribableInterface *interface)
+camel_subscribable_init (CamelSubscribableInterface *iface)
{
- interface->folder_is_subscribed = imapx_store_folder_is_subscribed;
- interface->subscribe_folder_sync = imapx_store_subscribe_folder_sync;
- interface->unsubscribe_folder_sync = imapx_store_unsubscribe_folder_sync;
+ iface->folder_is_subscribed = imapx_store_folder_is_subscribed;
+ iface->subscribe_folder_sync = imapx_store_subscribe_folder_sync;
+ iface->unsubscribe_folder_sync = imapx_store_unsubscribe_folder_sync;
}
static void
static GInitableIface *parent_initable_interface;
/* Forward Declarations */
-static void camel_nntp_store_initable_init (GInitableIface *interface);
-static void camel_network_service_init (CamelNetworkServiceInterface *interface);
-static void camel_subscribable_init (CamelSubscribableInterface *interface);
+static void camel_nntp_store_initable_init (GInitableIface *iface);
+static void camel_network_service_init (CamelNetworkServiceInterface *iface);
+static void camel_subscribable_init (CamelSubscribableInterface *iface);
G_DEFINE_TYPE_WITH_CODE (
CamelNNTPStore,
GError **error)
{
CamelSubscribable *subscribable;
- CamelSubscribableInterface *interface;
+ CamelSubscribableInterface *iface;
subscribable = CAMEL_SUBSCRIBABLE (store);
- interface = CAMEL_SUBSCRIBABLE_GET_INTERFACE (subscribable);
+ iface = CAMEL_SUBSCRIBABLE_GET_INTERFACE (subscribable);
- interface->unsubscribe_folder_sync (
+ iface->unsubscribe_folder_sync (
subscribable, folder_name, cancellable, NULL);
g_set_error (
}
static void
-camel_nntp_store_initable_init (GInitableIface *interface)
+camel_nntp_store_initable_init (GInitableIface *iface)
{
- parent_initable_interface = g_type_interface_peek_parent (interface);
+ parent_initable_interface = g_type_interface_peek_parent (iface);
- interface->init = nntp_store_initable_init;
+ iface->init = nntp_store_initable_init;
}
static void
-camel_network_service_init (CamelNetworkServiceInterface *interface)
+camel_network_service_init (CamelNetworkServiceInterface *iface)
{
- interface->get_service_name = nntp_store_get_service_name;
- interface->get_default_port = nntp_store_get_default_port;
+ iface->get_service_name = nntp_store_get_service_name;
+ iface->get_default_port = nntp_store_get_default_port;
}
static void
-camel_subscribable_init (CamelSubscribableInterface *interface)
+camel_subscribable_init (CamelSubscribableInterface *iface)
{
- interface->folder_is_subscribed = nntp_store_folder_is_subscribed;
- interface->subscribe_folder_sync = nntp_store_subscribe_folder_sync;
- interface->unsubscribe_folder_sync = nntp_store_unsubscribe_folder_sync;
+ iface->folder_is_subscribed = nntp_store_folder_is_subscribed;
+ iface->subscribe_folder_sync = nntp_store_subscribe_folder_sync;
+ iface->unsubscribe_folder_sync = nntp_store_unsubscribe_folder_sync;
}
static void
extern CamelServiceAuthType camel_pop3_apop_authtype;
/* Forward Declarations */
-static void camel_network_service_init (CamelNetworkServiceInterface *interface);
+static void camel_network_service_init (CamelNetworkServiceInterface *iface);
G_DEFINE_TYPE_WITH_CODE (
CamelPOP3Store,
}
static void
-camel_network_service_init (CamelNetworkServiceInterface *interface)
+camel_network_service_init (CamelNetworkServiceInterface *iface)
{
- interface->get_service_name = pop3_store_get_service_name;
- interface->get_default_port = pop3_store_get_default_port;
+ iface->get_service_name = pop3_store_get_service_name;
+ iface->get_default_port = pop3_store_get_default_port;
}
static void
GError **error);
/* Forward Declarations */
-static void camel_network_service_init (CamelNetworkServiceInterface *interface);
+static void camel_network_service_init (CamelNetworkServiceInterface *iface);
G_DEFINE_TYPE_WITH_CODE (
CamelSmtpTransport,
}
static void
-camel_network_service_init (CamelNetworkServiceInterface *interface)
+camel_network_service_init (CamelNetworkServiceInterface *iface)
{
- interface->get_service_name = smtp_transport_get_service_name;
- interface->get_default_port = smtp_transport_get_default_port;
+ iface->get_service_name = smtp_transport_get_service_name;
+ iface->get_default_port = smtp_transport_get_default_port;
}
static void
struct _EAuthenticationMediatorPrivate {
GDBusConnection *connection;
- EDBusAuthenticator *interface;
+ EDBusAuthenticator *dbus_interface;
GcrSecretExchange *secret_exchange;
gchar *object_path;
gchar *sender;
/* Forward Declarations */
static void e_authentication_mediator_initable_init
- (GInitableIface *interface);
+ (GInitableIface *iface);
static void e_authentication_mediator_interface_init
- (ESourceAuthenticatorInterface *interface);
+ (ESourceAuthenticatorInterface *iface);
G_DEFINE_TYPE_WITH_CODE (
EAuthenticationMediator,
}
static gboolean
-authentication_mediator_handle_ready (EDBusAuthenticator *interface,
+authentication_mediator_handle_ready (EDBusAuthenticator *dbus_interface,
GDBusMethodInvocation *invocation,
const gchar *encrypted_key,
ThreadClosure *closure)
g_mutex_unlock (&mediator->priv->shared_data_lock);
- e_dbus_authenticator_complete_ready (interface, invocation);
+ e_dbus_authenticator_complete_ready (dbus_interface, invocation);
g_object_unref (mediator);
}
static gboolean
-authentication_mediator_handle_cancel (EDBusAuthenticator *interface,
+authentication_mediator_handle_cancel (EDBusAuthenticator *dbus_interface,
GDBusMethodInvocation *invocation,
ThreadClosure *closure)
{
g_mutex_unlock (&mediator->priv->shared_data_lock);
- e_dbus_authenticator_complete_cancel (interface, invocation);
+ e_dbus_authenticator_complete_cancel (dbus_interface, invocation);
g_object_unref (mediator);
}
static gboolean
-authentication_mediator_handle_accepted (EDBusAuthenticator *interface,
+authentication_mediator_handle_accepted (EDBusAuthenticator *dbus_interface,
GDBusMethodInvocation *invocation,
ThreadClosure *closure)
{
g_mutex_unlock (&mediator->priv->shared_data_lock);
- e_dbus_authenticator_complete_accepted (interface, invocation);
+ e_dbus_authenticator_complete_accepted (dbus_interface, invocation);
g_object_unref (mediator);
}
static gboolean
-authentication_mediator_handle_rejected (EDBusAuthenticator *interface,
+authentication_mediator_handle_rejected (EDBusAuthenticator *dbus_interface,
GDBusMethodInvocation *invocation,
ThreadClosure *closure)
{
g_mutex_unlock (&mediator->priv->shared_data_lock);
- e_dbus_authenticator_complete_rejected (interface, invocation);
+ e_dbus_authenticator_complete_rejected (dbus_interface, invocation);
g_object_unref (mediator);
authentication_mediator_authenticator_thread (gpointer data)
{
EAuthenticationMediator *mediator;
- GDBusInterfaceSkeleton *interface;
+ GDBusInterfaceSkeleton *dbus_interface;
GDBusConnection *connection;
ThreadClosure *closure = data;
GSource *idle_source;
/* Keep our own reference to the GDBusInterfaceSkeleton so
* we can clean up signals after the mediator is disposed. */
- interface = g_object_ref (mediator->priv->interface);
+ dbus_interface = g_object_ref (mediator->priv->dbus_interface);
connection = e_authentication_mediator_get_connection (mediator);
object_path = e_authentication_mediator_get_object_path (mediator);
/* Listen for method invocations. */
handle_ready_id = g_signal_connect_data (
- interface, "handle-ready",
+ dbus_interface, "handle-ready",
G_CALLBACK (authentication_mediator_handle_ready),
thread_closure_ref (closure),
(GClosureNotify) thread_closure_unref, 0);
handle_cancel_id = g_signal_connect_data (
- interface, "handle-cancel",
+ dbus_interface, "handle-cancel",
G_CALLBACK (authentication_mediator_handle_cancel),
thread_closure_ref (closure),
(GClosureNotify) thread_closure_unref, 0);
handle_accepted_id = g_signal_connect_data (
- interface, "handle-accepted",
+ dbus_interface, "handle-accepted",
G_CALLBACK (authentication_mediator_handle_accepted),
thread_closure_ref (closure),
(GClosureNotify) thread_closure_unref, 0);
handle_rejected_id = g_signal_connect_data (
- interface, "handle-rejected",
+ dbus_interface, "handle-rejected",
G_CALLBACK (authentication_mediator_handle_rejected),
thread_closure_ref (closure),
(GClosureNotify) thread_closure_unref, 0);
/* Export the Authenticator interface. */
g_dbus_interface_skeleton_export (
- interface, connection, object_path, &closure->export_error);
+ dbus_interface, connection, object_path, &closure->export_error);
/* Schedule a one-time idle callback to broadcast through a
* condition variable that our main loop is up and running. */
/* Clean up and exit. */
- g_signal_handler_disconnect (interface, handle_ready_id);
- g_signal_handler_disconnect (interface, handle_cancel_id);
- g_signal_handler_disconnect (interface, handle_accepted_id);
- g_signal_handler_disconnect (interface, handle_rejected_id);
+ g_signal_handler_disconnect (dbus_interface, handle_ready_id);
+ g_signal_handler_disconnect (dbus_interface, handle_cancel_id);
+ g_signal_handler_disconnect (dbus_interface, handle_accepted_id);
+ g_signal_handler_disconnect (dbus_interface, handle_rejected_id);
g_main_context_pop_thread_default (closure->main_context);
- g_object_unref (interface);
+ g_object_unref (dbus_interface);
thread_closure_unref (closure);
priv->connection = NULL;
}
- if (priv->interface != NULL) {
- g_object_unref (priv->interface);
- priv->interface = NULL;
+ if (priv->dbus_interface != NULL) {
+ g_object_unref (priv->dbus_interface);
+ priv->dbus_interface = NULL;
}
if (priv->secret_exchange != NULL) {
mediator = E_AUTHENTICATION_MEDIATOR (auth);
- return e_dbus_authenticator_get_without_password (mediator->priv->interface);
+ return e_dbus_authenticator_get_without_password (mediator->priv->dbus_interface);
}
static ESourceAuthenticationResult
mediator->priv->secret_exchange, password->str, -1);
e_dbus_authenticator_emit_authenticate (
- mediator->priv->interface, encrypted_secret);
+ mediator->priv->dbus_interface, encrypted_secret);
g_free (encrypted_secret);
}
}
static void
-e_authentication_mediator_initable_init (GInitableIface *interface)
+e_authentication_mediator_initable_init (GInitableIface *iface)
{
- interface->init = authentication_mediator_initable_init;
+ iface->init = authentication_mediator_initable_init;
}
static void
-e_authentication_mediator_interface_init (ESourceAuthenticatorInterface *interface)
+e_authentication_mediator_interface_init (ESourceAuthenticatorInterface *iface)
{
- interface->get_without_password =
+ iface->get_without_password =
authentication_mediator_get_without_password;
- interface->try_password_sync =
+ iface->try_password_sync =
authentication_mediator_try_password_sync;
- interface->try_password =
+ iface->try_password =
authentication_mediator_try_password;
- interface->try_password_finish =
+ iface->try_password_finish =
authentication_mediator_try_password_finish;
}
{
mediator->priv = E_AUTHENTICATION_MEDIATOR_GET_PRIVATE (mediator);
- mediator->priv->interface = e_dbus_authenticator_skeleton_new ();
+ mediator->priv->dbus_interface = e_dbus_authenticator_skeleton_new ();
mediator->priv->secret_exchange = gcr_secret_exchange_new (NULL);
g_mutex_init (&mediator->priv->shared_data_lock);
{
g_return_if_fail (E_IS_AUTHENTICATION_MEDIATOR (mediator));
- e_dbus_authenticator_emit_dismissed (mediator->priv->interface);
+ e_dbus_authenticator_emit_dismissed (mediator->priv->dbus_interface);
}
/**
name = g_dbus_error_encode_gerror (error);
g_return_if_fail (name != NULL);
- e_dbus_authenticator_emit_server_error (mediator->priv->interface, name, error->message);
+ e_dbus_authenticator_emit_server_error (mediator->priv->dbus_interface, name, error->message);
g_free (name);
}
}
static void
-e_extensible_default_init (EExtensibleInterface *interface)
+e_extensible_default_init (EExtensibleInterface *iface)
{
extensible_quark = g_quark_from_static_string ("e-extensible-quark");
}
}
static void
-e_oauth2_support_default_init (EOAuth2SupportInterface *interface)
+e_oauth2_support_default_init (EOAuth2SupportInterface *iface)
{
- interface->get_access_token =
+ iface->get_access_token =
oauth2_support_get_access_token;
- interface->get_access_token_finish =
+ iface->get_access_token_finish =
oauth2_support_get_access_token_finish;
}
gint *out_expires_in,
GError **error)
{
- EOAuth2SupportInterface *interface;
+ EOAuth2SupportInterface *iface;
g_return_val_if_fail (E_IS_OAUTH2_SUPPORT (support), FALSE);
g_return_val_if_fail (E_IS_SOURCE (source), FALSE);
- interface = E_OAUTH2_SUPPORT_GET_INTERFACE (support);
- g_return_val_if_fail (interface->get_access_token_sync != NULL, FALSE);
+ iface = E_OAUTH2_SUPPORT_GET_INTERFACE (support);
+ g_return_val_if_fail (iface->get_access_token_sync != NULL, FALSE);
- return interface->get_access_token_sync (
+ return iface->get_access_token_sync (
support, source, cancellable,
out_access_token, out_expires_in, error);
}
GAsyncReadyCallback callback,
gpointer user_data)
{
- EOAuth2SupportInterface *interface;
+ EOAuth2SupportInterface *iface;
g_return_if_fail (E_IS_OAUTH2_SUPPORT (support));
g_return_if_fail (E_IS_SOURCE (source));
- interface = E_OAUTH2_SUPPORT_GET_INTERFACE (support);
- g_return_if_fail (interface->get_access_token != NULL);
+ iface = E_OAUTH2_SUPPORT_GET_INTERFACE (support);
+ g_return_if_fail (iface->get_access_token != NULL);
- return interface->get_access_token (
+ return iface->get_access_token (
support, source, cancellable, callback, user_data);
}
gint *out_expires_in,
GError **error)
{
- EOAuth2SupportInterface *interface;
+ EOAuth2SupportInterface *iface;
g_return_val_if_fail (E_IS_OAUTH2_SUPPORT (support), FALSE);
g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
- interface = E_OAUTH2_SUPPORT_GET_INTERFACE (support);
- g_return_val_if_fail (interface->get_access_token_finish != NULL, FALSE);
+ iface = E_OAUTH2_SUPPORT_GET_INTERFACE (support);
+ g_return_val_if_fail (iface->get_access_token_finish != NULL, FALSE);
- return interface->get_access_token_finish (
+ return iface->get_access_token_finish (
support, result, out_access_token, out_expires_in, error);
}
/* Forward Declarations */
static void e_server_side_source_initable_init
- (GInitableIface *interface);
+ (GInitableIface *iface);
G_DEFINE_TYPE_WITH_CODE (
EServerSideSource,
}
static gboolean
-server_side_source_allow_auth_prompt_cb (EDBusSource *interface,
+server_side_source_allow_auth_prompt_cb (EDBusSource *dbus_interface,
GDBusMethodInvocation *invocation,
EServerSideSource *source)
{
e_server_side_source_set_allow_auth_prompt (source, TRUE);
- e_dbus_source_complete_allow_auth_prompt (interface, invocation);
+ e_dbus_source_complete_allow_auth_prompt (dbus_interface, invocation);
return TRUE;
}
static gboolean
-server_side_source_remove_cb (EDBusSourceRemovable *interface,
+server_side_source_remove_cb (EDBusSourceRemovable *dbus_interface,
GDBusMethodInvocation *invocation,
EServerSideSource *source)
{
g_dbus_method_invocation_take_error (invocation, error);
else
e_dbus_source_removable_complete_remove (
- interface, invocation);
+ dbus_interface, invocation);
return TRUE;
}
static gboolean
-server_side_source_write_cb (EDBusSourceWritable *interface,
+server_side_source_write_cb (EDBusSourceWritable *dbus_interface,
GDBusMethodInvocation *invocation,
const gchar *data,
ESource *source)
g_dbus_method_invocation_take_error (invocation, error);
else
e_dbus_source_writable_complete_write (
- interface, invocation);
+ dbus_interface, invocation);
g_object_unref (dbus_source);
g_object_unref (dbus_object);
}
static gboolean
-server_side_source_remote_create_cb (EDBusSourceRemoteCreatable *interface,
+server_side_source_remote_create_cb (EDBusSourceRemoteCreatable *dbus_interface,
GDBusMethodInvocation *invocation,
const gchar *uid,
const gchar *data,
g_object_unref (dbus_source);
async_context = g_slice_new0 (AsyncContext);
- async_context->remote_creatable = g_object_ref (interface);
+ async_context->remote_creatable = g_object_ref (dbus_interface);
async_context->invocation = g_object_ref (invocation);
e_source_remote_create (
}
static gboolean
-server_side_source_remote_delete_cb (EDBusSourceRemoteDeletable *interface,
+server_side_source_remote_delete_cb (EDBusSourceRemoteDeletable *dbus_interface,
GDBusMethodInvocation *invocation,
ESource *source)
{
AsyncContext *async_context;
async_context = g_slice_new0 (AsyncContext);
- async_context->remote_deletable = g_object_ref (interface);
+ async_context->remote_deletable = g_object_ref (dbus_interface);
async_context->invocation = g_object_ref (invocation);
e_source_remote_delete (
}
static gboolean
-server_side_source_get_access_token_cb (EDBusSourceOAuth2Support *interface,
+server_side_source_get_access_token_cb (EDBusSourceOAuth2Support *dbus_interface,
GDBusMethodInvocation *invocation,
ESource *source)
{
AsyncContext *async_context;
async_context = g_slice_new0 (AsyncContext);
- async_context->oauth2_support = g_object_ref (interface);
+ async_context->oauth2_support = g_object_ref (dbus_interface);
async_context->invocation = g_object_ref (invocation);
e_source_get_oauth2_access_token (
}
static void
-e_server_side_source_initable_init (GInitableIface *interface)
+e_server_side_source_initable_init (GInitableIface *iface)
{
- initable_parent_interface = g_type_interface_peek_parent (interface);
+ initable_parent_interface = g_type_interface_peek_parent (iface);
- interface->init = server_side_source_initable_init;
+ iface->init = server_side_source_initable_init;
}
static void
}
static gboolean
-source_registry_server_allow_auth_prompt_all_cb (EDBusSourceManager *interface,
+source_registry_server_allow_auth_prompt_all_cb (EDBusSourceManager *dbus_interface,
GDBusMethodInvocation *invocation,
ESourceRegistryServer *server)
{
g_list_free_full (list, (GDestroyNotify) g_object_unref);
e_dbus_source_manager_complete_allow_auth_prompt_all (
- interface, invocation);
+ dbus_interface, invocation);
return TRUE;
}
static gboolean
-source_registry_server_authenticate_cb (EDBusSourceManager *interface,
+source_registry_server_authenticate_cb (EDBusSourceManager *dbus_interface,
GDBusMethodInvocation *invocation,
const gchar *source_uid,
const gchar *prompt_title,
g_object_ref (session));
e_dbus_source_manager_complete_authenticate (
- interface, invocation, auth_object_path);
+ dbus_interface, invocation, auth_object_path);
g_object_unref (authenticator);
g_object_unref (session);
}
static gboolean
-source_registry_server_create_sources_cb (EDBusSourceManager *interface,
+source_registry_server_create_sources_cb (EDBusSourceManager *dbus_interface,
GDBusMethodInvocation *invocation,
GVariant *array,
ESourceRegistryServer *server)
g_dbus_method_invocation_take_error (invocation, error);
else
e_dbus_source_manager_complete_create_sources (
- interface, invocation);
+ dbus_interface, invocation);
return TRUE;
}
static gboolean
-source_registry_server_reload_cb (EDBusSourceManager *interface,
+source_registry_server_reload_cb (EDBusSourceManager *dbus_interface,
GDBusMethodInvocation *invocation,
ESourceRegistryServer *server)
{
E_DBUS_SERVER (server),
E_DBUS_SERVER_EXIT_RELOAD);
- e_dbus_source_manager_complete_reload (interface, invocation);
+ e_dbus_source_manager_complete_reload (dbus_interface, invocation);
return TRUE;
}
}
static void
-e_source_authenticator_default_init (ESourceAuthenticatorInterface *interface)
+e_source_authenticator_default_init (ESourceAuthenticatorInterface *iface)
{
- interface->get_prompt_strings = source_authenticator_get_prompt_strings;
- interface->get_without_password = source_authenticator_get_without_password;
- interface->try_password = source_authenticator_try_password;
- interface->try_password_finish = source_authenticator_try_password_finish;
+ iface->get_prompt_strings = source_authenticator_get_prompt_strings;
+ iface->get_without_password = source_authenticator_get_without_password;
+ iface->try_password = source_authenticator_try_password;
+ iface->try_password_finish = source_authenticator_try_password_finish;
}
/**
gchar **prompt_message,
gchar **prompt_description)
{
- ESourceAuthenticatorInterface *interface;
+ ESourceAuthenticatorInterface *iface;
g_return_if_fail (E_IS_SOURCE_AUTHENTICATOR (auth));
g_return_if_fail (E_IS_SOURCE (source));
g_return_if_fail (prompt_message != NULL);
g_return_if_fail (prompt_description != NULL);
- interface = E_SOURCE_AUTHENTICATOR_GET_INTERFACE (auth);
- g_return_if_fail (interface->get_prompt_strings);
+ iface = E_SOURCE_AUTHENTICATOR_GET_INTERFACE (auth);
+ g_return_if_fail (iface->get_prompt_strings);
- interface->get_prompt_strings (
+ iface->get_prompt_strings (
auth, source,
prompt_title,
prompt_message,
gboolean
e_source_authenticator_get_without_password (ESourceAuthenticator *auth)
{
- ESourceAuthenticatorInterface *interface;
+ ESourceAuthenticatorInterface *iface;
g_return_val_if_fail (E_IS_SOURCE_AUTHENTICATOR (auth), FALSE);
- interface = E_SOURCE_AUTHENTICATOR_GET_INTERFACE (auth);
- g_return_val_if_fail (interface->get_without_password, FALSE);
+ iface = E_SOURCE_AUTHENTICATOR_GET_INTERFACE (auth);
+ g_return_val_if_fail (iface->get_without_password, FALSE);
- return interface->get_without_password (auth);
+ return iface->get_without_password (auth);
}
/**
GCancellable *cancellable,
GError **error)
{
- ESourceAuthenticatorInterface *interface;
+ ESourceAuthenticatorInterface *iface;
g_return_val_if_fail (
E_IS_SOURCE_AUTHENTICATOR (auth),
password != NULL,
E_SOURCE_AUTHENTICATION_REJECTED);
- interface = E_SOURCE_AUTHENTICATOR_GET_INTERFACE (auth);
+ iface = E_SOURCE_AUTHENTICATOR_GET_INTERFACE (auth);
g_return_val_if_fail (
- interface->try_password_sync != NULL,
+ iface->try_password_sync != NULL,
E_SOURCE_AUTHENTICATION_REJECTED);
- return interface->try_password_sync (
+ return iface->try_password_sync (
auth, password, cancellable, error);
}
GAsyncReadyCallback callback,
gpointer user_data)
{
- ESourceAuthenticatorInterface *interface;
+ ESourceAuthenticatorInterface *iface;
g_return_if_fail (E_IS_SOURCE_AUTHENTICATOR (auth));
g_return_if_fail (password != NULL);
- interface = E_SOURCE_AUTHENTICATOR_GET_INTERFACE (auth);
- g_return_if_fail (interface->try_password != NULL);
+ iface = E_SOURCE_AUTHENTICATOR_GET_INTERFACE (auth);
+ g_return_if_fail (iface->try_password != NULL);
- interface->try_password (
+ iface->try_password (
auth, password, cancellable, callback, user_data);
}
GAsyncResult *result,
GError **error)
{
- ESourceAuthenticatorInterface *interface;
+ ESourceAuthenticatorInterface *iface;
g_return_val_if_fail (
E_IS_SOURCE_AUTHENTICATOR (auth),
G_IS_ASYNC_RESULT (result),
E_SOURCE_AUTHENTICATION_REJECTED);
- interface = E_SOURCE_AUTHENTICATOR_GET_INTERFACE (auth);
+ iface = E_SOURCE_AUTHENTICATOR_GET_INTERFACE (auth);
g_return_val_if_fail (
- interface->try_password_finish != NULL,
+ iface->try_password_finish != NULL,
E_SOURCE_AUTHENTICATION_REJECTED);
- return interface->try_password_finish (auth, result, error);
+ return iface->try_password_finish (auth, result, error);
}
/* Forward Declarations */
static void source_registry_add_source (ESourceRegistry *registry,
ESource *source);
-static void e_source_registry_initable_init (GInitableIface *interface);
+static void e_source_registry_initable_init (GInitableIface *iface);
/* Private ESource function, for our use only. */
void __e_source_private_replace_dbus_object
}
static void
-e_source_registry_initable_init (GInitableIface *interface)
+e_source_registry_initable_init (GInitableIface *iface)
{
- interface->init = source_registry_initable_init;
+ iface->init = source_registry_initable_init;
}
static void
static guint signals[LAST_SIGNAL];
/* Forward Declarations */
-static void e_source_initable_init (GInitableIface *interface);
+static void e_source_initable_init (GInitableIface *iface);
static void e_source_proxy_resolver_init
- (GProxyResolverInterface *interface);
+ (GProxyResolverInterface *iface);
/* Private function shared only with ESourceRegistry. */
void __e_source_private_replace_dbus_object
}
static void
-e_source_initable_init (GInitableIface *interface)
+e_source_initable_init (GInitableIface *iface)
{
- interface->init = source_initable_init;
+ iface->init = source_initable_init;
}
static void
-e_source_proxy_resolver_init (GProxyResolverInterface *interface)
+e_source_proxy_resolver_init (GProxyResolverInterface *iface)
{
- interface->is_supported = source_proxy_resolver_is_supported;
- interface->lookup = source_proxy_resolver_lookup;
- interface->lookup_async = source_proxy_resolver_lookup_async;
- interface->lookup_finish = source_proxy_resolver_lookup_finish;
+ iface->is_supported = source_proxy_resolver_is_supported;
+ iface->lookup = source_proxy_resolver_lookup;
+ iface->lookup_async = source_proxy_resolver_lookup_async;
+ iface->lookup_finish = source_proxy_resolver_lookup_finish;
}
static void
static guint signals[LAST_SIGNAL];
/* Forward Declarations */
-static void e_goa_client_interface_init (GInitableIface *interface);
+static void e_goa_client_interface_init (GInitableIface *iface);
/* By default, the GAsyncInitable interface calls GInitable.init()
* from a separate thread, so we only have to override GInitable. */
}
static void
-e_goa_client_interface_init (GInitableIface *interface)
+e_goa_client_interface_init (GInitableIface *iface)
{
- interface->init = e_goa_client_initable_init;
+ iface->init = e_goa_client_initable_init;
}
static void
/* Forward Declarations */
GType e_gnome_online_accounts_get_type (void);
static void e_gnome_online_accounts_oauth2_support_init
- (EOAuth2SupportInterface *interface);
+ (EOAuth2SupportInterface *iface);
G_DEFINE_DYNAMIC_TYPE_EXTENDED (
EGnomeOnlineAccounts,
}
static void
-e_gnome_online_accounts_oauth2_support_init (EOAuth2SupportInterface *interface)
+e_gnome_online_accounts_oauth2_support_init (EOAuth2SupportInterface *iface)
{
- interface->get_access_token_sync =
+ iface->get_access_token_sync =
gnome_online_accounts_get_access_token_sync;
}
GType e_owncloud_authenticator_get_type
(void) G_GNUC_CONST;
static void e_owncloud_authenticator_authenticator_init
- (ESourceAuthenticatorInterface *interface);
+ (ESourceAuthenticatorInterface *iface);
G_DEFINE_TYPE_EXTENDED (
EOwncloudAuthenticator,
}
static void
-e_owncloud_authenticator_authenticator_init (ESourceAuthenticatorInterface *interface)
+e_owncloud_authenticator_authenticator_init (ESourceAuthenticatorInterface *iface)
{
- interface->try_password_sync = owncloud_authenticator_try_password_sync;
+ iface->try_password_sync = owncloud_authenticator_try_password_sync;
}
static void
/* Forward Declarations */
GType e_ubuntu_online_accounts_get_type (void);
static void e_ubuntu_online_accounts_oauth2_support_init
- (EOAuth2SupportInterface *interface);
+ (EOAuth2SupportInterface *iface);
G_DEFINE_DYNAMIC_TYPE_EXTENDED (
EUbuntuOnlineAccounts,
}
static void
-e_ubuntu_online_accounts_oauth2_support_init (EOAuth2SupportInterface *interface)
+e_ubuntu_online_accounts_oauth2_support_init (EOAuth2SupportInterface *iface)
{
- interface->get_access_token_sync = ubuntu_online_accounts_get_access_token_sync;
- interface->get_access_token = ubuntu_online_accounts_get_access_token;
- interface->get_access_token_finish = ubuntu_online_accounts_get_access_token_finish;
+ iface->get_access_token_sync = ubuntu_online_accounts_get_access_token_sync;
+ iface->get_access_token = ubuntu_online_accounts_get_access_token;
+ iface->get_access_token_finish = ubuntu_online_accounts_get_access_token_finish;
}
static void