G_DEFINE_TYPE (EBookView, e_book_view, G_TYPE_OBJECT);
-#define E_BOOK_VIEW_GET_PRIVATE(o) \
- (G_TYPE_INSTANCE_GET_PRIVATE ((o), E_TYPE_BOOK_VIEW, EBookViewPrivate))
-
struct _EBookViewPrivate {
EGdbusBookView *gdbus_bookview;
EBook *book;
static void
e_book_view_init (EBookView *book_view)
{
- EBookViewPrivate *priv = E_BOOK_VIEW_GET_PRIVATE (book_view);
-
- priv->gdbus_bookview = NULL;
- priv->book = NULL;
- priv->running = FALSE;
-
- book_view->priv = priv;
+ book_view->priv = G_TYPE_INSTANCE_GET_PRIVATE (book_view, E_TYPE_BOOK_VIEW, EBookViewPrivate);
+ book_view->priv->gdbus_bookview = NULL;
+ book_view->priv->book = NULL;
+ book_view->priv->running = FALSE;
}
static void
static gboolean unwrap_gerror (GError *error, GError **client_error);
G_DEFINE_TYPE (EBook, e_book, G_TYPE_OBJECT)
-#define E_BOOK_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), E_TYPE_BOOK, EBookPrivate))
enum {
WRITABLE_STATUS,
static void
e_book_init (EBook *book)
{
- EBookPrivate *priv = E_BOOK_GET_PRIVATE (book);
+ book->priv = G_TYPE_INSTANCE_GET_PRIVATE (book, E_TYPE_BOOK, EBookPrivate);
LOCK_FACTORY ();
active_books++;
UNLOCK_FACTORY ();
- priv->gdbus_book = NULL;
- priv->source = NULL;
- priv->uri = NULL;
- priv->loaded = FALSE;
- priv->writable = FALSE;
- priv->connected = FALSE;
- priv->cap = NULL;
- priv->cap_queried = FALSE;
- book->priv = priv;
+ book->priv->gdbus_book = NULL;
+ book->priv->source = NULL;
+ book->priv->uri = NULL;
+ book->priv->loaded = FALSE;
+ book->priv->writable = FALSE;
+ book->priv->connected = FALSE;
+ book->priv->cap = NULL;
+ book->priv->cap_queried = FALSE;
}
static void
#include "e-book-backend-cache.h"
#include "e-book-backend-sexp.h"
-#define E_BOOK_BACKEND_CACHE_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), E_TYPE_BOOK_BACKEND_CACHE, EBookBackendCachePrivate))
-
struct _EBookBackendCachePrivate {
gint placeholder;
};
static void
e_book_backend_cache_init (EBookBackendCache *cache)
{
- cache->priv = E_BOOK_BACKEND_CACHE_GET_PRIVATE (cache);
+ cache->priv = G_TYPE_INSTANCE_GET_PRIVATE (cache, E_TYPE_BOOK_BACKEND_CACHE, EBookBackendCachePrivate);
}
/**
#include "e-data-book.h"
#include "e-book-backend.h"
-#define E_BOOK_BACKEND_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), E_TYPE_BOOK_BACKEND, EBookBackendPrivate))
-
struct _EBookBackendPrivate {
GMutex *open_mutex;
{
EBookBackendPrivate *priv;
- priv = E_BOOK_BACKEND_GET_PRIVATE (object);
+ priv = E_BOOK_BACKEND (object)->priv;
if (priv->views != NULL) {
g_object_unref (priv->views);
{
EBookBackendPrivate *priv;
- priv = E_BOOK_BACKEND_GET_PRIVATE (object);
+ priv = E_BOOK_BACKEND (object)->priv;
g_list_free (priv->clients);
static void
e_book_backend_init (EBookBackend *backend)
{
- backend->priv = E_BOOK_BACKEND_GET_PRIVATE (backend);
+ backend->priv = G_TYPE_INSTANCE_GET_PRIVATE (backend, E_TYPE_BOOK_BACKEND, EBookBackendPrivate);
backend->priv->views = e_list_new (
(EListCopyFunc) NULL, (EListFreeFunc) NULL, NULL);
G_DEFINE_TYPE (EDataBookFactory, e_data_book_factory, G_TYPE_OBJECT);
-#define E_DATA_BOOK_FACTORY_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), E_TYPE_DATA_BOOK_FACTORY, EDataBookFactoryPrivate))
-
struct _EDataBookFactoryPrivate {
EGdbusBookFactory *gdbus_object;
{
GError *error = NULL;
- factory->priv = E_DATA_BOOK_FACTORY_GET_PRIVATE (factory);
+ factory->priv = G_TYPE_INSTANCE_GET_PRIVATE (factory, E_TYPE_DATA_BOOK_FACTORY, EDataBookFactoryPrivate);
factory->priv->gdbus_object = e_gdbus_book_factory_stub_new ();
g_signal_connect (factory->priv->gdbus_object, "handle-get-book", G_CALLBACK (impl_BookFactory_getBook), factory);
static void ensure_pending_flush_timeout (EDataBookView *view);
G_DEFINE_TYPE (EDataBookView, e_data_book_view, G_TYPE_OBJECT);
-#define E_DATA_BOOK_VIEW_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), E_TYPE_DATA_BOOK_VIEW, EDataBookViewPrivate))
#define THRESHOLD_ITEMS 32 /* how many items can be hold in a cache, before propagated to UI */
#define THRESHOLD_SECONDS 2 /* how long to wait until notifications are propagated to UI; in seconds */
void
e_data_book_view_notify_remove (EDataBookView *book_view, const gchar *id)
{
- EDataBookViewPrivate *priv = E_DATA_BOOK_VIEW_GET_PRIVATE (book_view);
+ EDataBookViewPrivate *priv = book_view->priv;
if (!priv->running)
return;
void
e_data_book_view_notify_status_message (EDataBookView *book_view, const gchar *message)
{
- EDataBookViewPrivate *priv = E_DATA_BOOK_VIEW_GET_PRIVATE (book_view);
+ EDataBookViewPrivate *priv = book_view->priv;
gchar *gdbus_message = NULL;
if (!priv->running)
static void
e_data_book_view_init (EDataBookView *book_view)
{
- EDataBookViewPrivate *priv = E_DATA_BOOK_VIEW_GET_PRIVATE (book_view);
+ EDataBookViewPrivate *priv = G_TYPE_INSTANCE_GET_PRIVATE (book_view, E_TYPE_DATA_BOOK_VIEW, EDataBookViewPrivate);
+
book_view->priv = priv;
priv->gdbus_object = e_gdbus_book_view_stub_new ();
time_t time_start, time_end;
ECalBackendCalDAVPrivate *priv;
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
e_cal_util_get_component_occur_times (comp, &time_start, &time_end,
resolve_tzid, cbdav, icaltimezone_get_utc_timezone (),
{
ECalBackendCalDAVPrivate *priv;
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
*online = FALSE;
ECalBackendCalDAV *cbdav;
cbdav = E_CAL_BACKEND_CALDAV (data);
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
/* do not send same password twice, but keep it for later use */
if (!retrying)
gchar *uri;
const gchar *slash;
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
slash = strrchr (target, '/');
if (slash)
g_return_val_if_fail (cbdav != NULL, FALSE);
g_return_val_if_fail (server_unreachable != NULL, FALSE);
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
/* FIXME: setup text_uri */
g_return_val_if_fail (cbdav != NULL, TRUE);
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
/* no support for 'getctag', thus update cache */
if (!priv->ctag_supported)
xmlNsPtr nscd;
gboolean result;
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
/* Allocate the soup message */
message = soup_message_new ("REPORT", priv->uri);
if (message == NULL)
const gchar *hdr;
gchar *uri;
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
g_assert (object != NULL && object->href != NULL);
e_return_data_cal_error_if_fail (post_fb != NULL, InvalidArg);
e_return_data_cal_error_if_fail (*post_fb != NULL, InvalidArg);
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
message = soup_message_new (SOUP_METHOD_POST, url);
if (message == NULL) {
const gchar *hdr;
gchar *uri;
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
hdr = NULL;
g_assert (object != NULL && object->cdata != NULL);
SoupMessage *message;
gchar *uri;
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
g_assert (object != NULL && object->href != NULL);
g_return_val_if_fail (cbdav != NULL, FALSE);
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
g_return_val_if_fail (priv != NULL, FALSE);
g_return_val_if_fail (priv->schedule_outbox_url == NULL, TRUE);
GSList *l;
struct cache_comp_list *ccl = value;
ECalBackendCalDAV *cbdav = data;
- ECalBackendCalDAVPrivate *priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ ECalBackendCalDAVPrivate *priv = cbdav->priv;
for (l = ccl->slist; l; l = l->next) {
ECalComponent *old_comp = l->data;
return;
}
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
bkend = E_CAL_BACKEND (cbdav);
len = 0;
sobjs = NULL;
gboolean know_unreachable;
cbdav = E_CAL_BACKEND_CALDAV (data);
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
g_mutex_lock (priv->busy_lock);
}
cbdav = E_CAL_BACKEND_CALDAV (backend);
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
if (priv && priv->is_google && priv->username) {
res = maybe_append_email_domain (priv->username, "@gmail.com");
ECalBackendCalDAVPrivate *priv;
cbdav = E_CAL_BACKEND_CALDAV (backend);
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
/* no write support in offline mode yet! */
if (priv->mode == CAL_MODE_LOCAL) {
const gchar *refresh;
const gchar *cache_dir;
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
backend = E_CAL_BACKEND (cbdav);
source = e_cal_backend_get_source (backend);
ECalBackendCalDAVPrivate *priv;
cbdav = E_CAL_BACKEND_CALDAV (backend);
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
g_mutex_lock (priv->busy_lock);
gboolean online;
cbdav = E_CAL_BACKEND_CALDAV (backend);
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
g_mutex_lock (priv->busy_lock);
gboolean online;
cbdav = E_CAL_BACKEND_CALDAV (backend);
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
/* first tell it to die, then wait for its lock */
priv->slave_cmd = SLAVE_SHOULD_DIE;
ECalBackendCalDAVPrivate *priv;
gboolean res = FALSE;
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
if (!rid || !*rid) {
/* get with detached instances */
ECalBackendCalDAVPrivate *priv;
icalcomponent *icalcomp = NULL;
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
if (rid == NULL || !*rid) {
/* get with detached instances */
g_return_if_fail (cbdav != NULL);
g_return_if_fail (uid != NULL);
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
l = e_cal_backend_store_get_components_by_uid (priv->store, uid);
len = g_slist_length (l);
g_slist_foreach (l, (GFunc)g_object_unref, NULL);
g_return_if_fail (vcal_comp != NULL);
g_return_if_fail (icalcomp != NULL);
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
f_data.store = priv->store;
f_data.vcal_comp = vcal_comp;
g_return_val_if_fail (cbdav != NULL, FALSE);
g_return_val_if_fail (uid != NULL, FALSE);
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
g_return_val_if_fail (priv != NULL && priv->store != NULL, FALSE);
comp = e_cal_backend_store_get_component (priv->store, uid, rid);
struct icaltimetype current;
gchar *href = NULL, *etag = NULL;
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
if (new_object)
*new_object = NULL;
gboolean online;
gchar *href = NULL, *etag = NULL;
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
if (object)
*object = NULL;
return FALSE;
}
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
zone = icaltimezone_new ();
for (iter = timezones; iter; iter = iter->next) {
}
#define caldav_busy_stub(_func_name, _params, _call_func, _call_params) \
-static void \
+static void \
_func_name _params \
{ \
ECalBackendCalDAV *cbdav; \
gboolean was_slave_busy; \
\
cbdav = E_CAL_BACKEND_CALDAV (backend); \
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav); \
+ priv = cbdav->priv; \
\
/* this is done before locking */ \
old_slave_cmd = priv->slave_cmd; \
} \
\
g_mutex_lock (priv->busy_lock); \
- _call_func _call_params; \
+ _call_func _call_params; \
\
/* this is done before unlocking */ \
if (was_slave_busy) { \
e_return_data_cal_error_if_fail (E_IS_CAL_BACKEND_CALDAV (cbdav), InvalidArg);
e_return_data_cal_error_if_fail (tzobj != NULL, InvalidArg);
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
tz_comp = icalparser_parse_string (tzobj);
if (!tz_comp) {
e_return_data_cal_error_if_fail (tzobj != NULL, InvalidArg);
cbdav = E_CAL_BACKEND_CALDAV (backend);
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
tz_comp = icalparser_parse_string (tzobj);
if (!tz_comp) {
gboolean prunning_by_time;
cbdav = E_CAL_BACKEND_CALDAV (backend);
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
sexp = e_cal_backend_sexp_new (sexp_string);
time_t occur_start = -1, occur_end = -1;
gboolean prunning_by_time;
cbdav = E_CAL_BACKEND_CALDAV (backend);
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
sexp_string = e_data_cal_view_get_text (query);
sexp = e_cal_backend_sexp_new (sexp_string);
GError *err = NULL;
cbdav = E_CAL_BACKEND_CALDAV (backend);
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
e_return_data_cal_error_if_fail (priv != NULL, InvalidArg);
e_return_data_cal_error_if_fail (users != NULL, InvalidArg);
ECalBackendCalDAVPrivate *priv;
cbdav = E_CAL_BACKEND_CALDAV (backend);
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
return priv->loaded;
}
ECalBackendCalDAVPrivate *priv;
cbdav = E_CAL_BACKEND_CALDAV (backend);
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
return priv->mode;
}
ECalBackendCalDAVPrivate *priv;
cbdav = E_CAL_BACKEND_CALDAV (backend);
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
/*g_mutex_lock (priv->busy_lock);*/
g_return_val_if_fail (E_IS_CAL_BACKEND_CALDAV (backend), NULL);
cbdav = E_CAL_BACKEND_CALDAV (backend);
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
g_return_val_if_fail (priv->default_zone != NULL, NULL);
ECalBackendCalDAVPrivate *priv;
cbdav = E_CAL_BACKEND_CALDAV (backend);
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
zone = NULL;
if (priv->store)
g_return_if_fail (source != NULL);
g_return_if_fail (cbdav != NULL);
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
g_return_if_fail (priv != NULL);
old_slave_cmd = priv->slave_cmd;
ESource *source;
cbdav = E_CAL_BACKEND_CALDAV (object);
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
/* tell the slave to stop before acquiring a lock,
as it can work at the moment, and lock can be locked */
ECalBackendCalDAVPrivate *priv;
cbdav = E_CAL_BACKEND_CALDAV (object);
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ priv = cbdav->priv;
g_mutex_free (priv->busy_lock);
g_cond_free (priv->cond);
static void
e_cal_backend_caldav_init (ECalBackendCalDAV *cbdav)
{
- ECalBackendCalDAVPrivate *priv;
-
- priv = E_CAL_BACKEND_CALDAV_GET_PRIVATE (cbdav);
+ cbdav->priv = G_TYPE_INSTANCE_GET_PRIVATE (cbdav, E_TYPE_CAL_BACKEND_CALDAV, ECalBackendCalDAVPrivate);
- priv->session = soup_session_sync_new ();
- g_object_set (priv->session, SOUP_SESSION_TIMEOUT, 90, NULL);
+ cbdav->priv->session = soup_session_sync_new ();
+ g_object_set (cbdav->priv->session, SOUP_SESSION_TIMEOUT, 90, NULL);
- priv->proxy = e_proxy_new ();
- e_proxy_setup_proxy (priv->proxy);
- g_signal_connect (priv->proxy, "changed", G_CALLBACK (proxy_settings_changed), priv);
+ cbdav->priv->proxy = e_proxy_new ();
+ e_proxy_setup_proxy (cbdav->priv->proxy);
+ g_signal_connect (cbdav->priv->proxy, "changed", G_CALLBACK (proxy_settings_changed), cbdav->priv);
if (G_UNLIKELY (caldav_debug_show (DEBUG_MESSAGE)))
- caldav_debug_setup (priv->session);
+ caldav_debug_setup (cbdav->priv->session);
- priv->default_zone = icaltimezone_get_utc_timezone ();
+ cbdav->priv->default_zone = icaltimezone_get_utc_timezone ();
- priv->disposed = FALSE;
- priv->loaded = FALSE;
- priv->opened = FALSE;
+ cbdav->priv->disposed = FALSE;
+ cbdav->priv->loaded = FALSE;
+ cbdav->priv->opened = FALSE;
/* Thinks the 'getctag' extension is available the first time, but unset it when realizes it isn't. */
- priv->ctag_supported = TRUE;
- priv->ctag_to_store = NULL;
+ cbdav->priv->ctag_supported = TRUE;
+ cbdav->priv->ctag_to_store = NULL;
- priv->schedule_outbox_url = NULL;
+ cbdav->priv->schedule_outbox_url = NULL;
- priv->is_google = FALSE;
+ cbdav->priv->is_google = FALSE;
- priv->busy_lock = g_mutex_new ();
- priv->cond = g_cond_new ();
- priv->slave_gone_cond = g_cond_new ();
+ cbdav->priv->busy_lock = g_mutex_new ();
+ cbdav->priv->cond = g_cond_new ();
+ cbdav->priv->slave_gone_cond = g_cond_new ();
/* Slave control ... */
- priv->slave_cmd = SLAVE_SHOULD_SLEEP;
- priv->slave_busy = FALSE;
- priv->refresh_time.tv_usec = 0;
- priv->refresh_time.tv_sec = DEFAULT_REFRESH_TIME;
+ cbdav->priv->slave_cmd = SLAVE_SHOULD_SLEEP;
+ cbdav->priv->slave_busy = FALSE;
+ cbdav->priv->refresh_time.tv_usec = 0;
+ cbdav->priv->refresh_time.tv_sec = DEFAULT_REFRESH_TIME;
- g_signal_connect (priv->session, "authenticate",
+ g_signal_connect (cbdav->priv->session, "authenticate",
G_CALLBACK (soup_authenticate), cbdav);
e_cal_backend_sync_set_lock (E_CAL_BACKEND_SYNC (cbdav), FALSE);
#define E_CAL_BACKEND_CALDAV_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), E_TYPE_CAL_BACKEND_CALDAV, ECalBackendCalDAVClass))
#define E_IS_CAL_BACKEND_CALDAV(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), E_TYPE_CAL_BACKEND_CALDAV))
#define E_IS_CAL_BACKEND_CALDAV_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), E_TYPE_CAL_BACKEND_CALDAV))
-#define E_CAL_BACKEND_CALDAV_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), E_TYPE_CAL_BACKEND_CALDAV, ECalBackendCalDAVPrivate))
typedef struct _ECalBackendCalDAV ECalBackendCalDAV;
typedef struct _ECalBackendCalDAVClass ECalBackendCalDAVClass;
-
typedef struct _ECalBackendCalDAVPrivate ECalBackendCalDAVPrivate;
struct _ECalBackendCalDAV {
- ECalBackendSync backend;
+ ECalBackendSync backend;
+
+ ECalBackendCalDAVPrivate *priv;
};
struct _ECalBackendCalDAVClass {
- ECalBackendSyncClass parent_class;
+ ECalBackendSyncClass parent_class;
};
GType e_cal_backend_caldav_get_type (void);
#include "e-gdbus-egdbuscalview.h"
G_DEFINE_TYPE (ECalView, e_cal_view, G_TYPE_OBJECT);
-#define E_CAL_VIEW_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), E_TYPE_CAL_VIEW, ECalViewPrivate))
/* Private part of the ECalView structure */
struct _ECalViewPrivate {
static void
e_cal_view_init (ECalView *view)
{
- view->priv = E_CAL_VIEW_GET_PRIVATE (view);
+ view->priv = G_TYPE_INSTANCE_GET_PRIVATE (view, E_TYPE_CAL_VIEW, ECalViewPrivate);
}
static void
ECalViewPrivate *priv;
view = E_CAL_VIEW (object);
- priv = E_CAL_VIEW_GET_PRIVATE (view);
+ priv = view->priv;
switch (property_id) {
case PROP_VIEW:
ECalViewPrivate *priv;
view = E_CAL_VIEW (object);
- priv = E_CAL_VIEW_GET_PRIVATE (view);
+ priv = view->priv;
switch (property_id) {
case PROP_VIEW:
g_return_if_fail (view != NULL);
g_return_if_fail (E_IS_CAL_VIEW (view));
- priv = E_CAL_VIEW_GET_PRIVATE (view);
+ priv = view->priv;
if (priv->gdbus_calview) {
e_gdbus_cal_view_call_start_sync (priv->gdbus_calview, NULL, &error);
g_return_if_fail (view != NULL);
g_return_if_fail (E_IS_CAL_VIEW (view));
- priv = E_CAL_VIEW_GET_PRIVATE (view);
+ priv = view->priv;
if (priv->gdbus_calview) {
e_gdbus_cal_view_call_stop_sync (priv->gdbus_calview, NULL, &error);
#define UNLOCK_CACHE() g_static_rec_mutex_unlock (&priv->cache_lock)
G_DEFINE_TYPE (ECal, e_cal, G_TYPE_OBJECT)
-#define E_CAL_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), E_TYPE_CAL, ECalPrivate))
static gboolean open_calendar (ECal *ecal, gboolean only_if_exists, GError **error,
#ifndef E_CAL_DISABLE_DEPRECATED
active_cals++;
UNLOCK_FACTORY ();
- ecal->priv = priv = E_CAL_GET_PRIVATE (ecal);
+ ecal->priv = priv = G_TYPE_INSTANCE_GET_PRIVATE (ecal, E_TYPE_CAL, ECalPrivate);
priv->load_state = E_CAL_LOAD_NOT_LOADED;
priv->uri = NULL;
#include <libedataserver/e-data-server-util.h>
#include "e-cal-backend-cache.h"
-#define E_CAL_BACKEND_CACHE_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), E_TYPE_CAL_BACKEND_CACHE, ECalBackendCachePrivate))
-
struct _ECalBackendCachePrivate {
GHashTable *timezones;
};
{
ECalBackendCachePrivate *priv;
- priv = E_CAL_BACKEND_CACHE_GET_PRIVATE (object);
+ priv = E_CAL_BACKEND_CACHE (object)->priv;
g_hash_table_destroy (priv->timezones);
static void
e_cal_backend_cache_init (ECalBackendCache *cache)
{
- cache->priv = E_CAL_BACKEND_CACHE_GET_PRIVATE (cache);
+ cache->priv = G_TYPE_INSTANCE_GET_PRIVATE (cache, E_TYPE_CAL_BACKEND_CACHE, ECalBackendCachePrivate);
cache->priv->timezones = g_hash_table_new_full (
g_str_hash, g_str_equal,
#define KEY_FILE_NAME "keys.xml"
#define IDLE_SAVE_TIMEOUT 6000
-#define E_CAL_BACKEND_FILE_STORE_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), E_TYPE_CAL_BACKEND_FILE_STORE, ECalBackendFileStorePrivate))
-
typedef struct {
ECalComponent *comp;
GHashTable *recurrences;
g_return_val_if_fail (comp != NULL, FALSE);
- priv = E_CAL_BACKEND_FILE_STORE_GET_PRIVATE (fstore);
+ priv = fstore->priv;
e_cal_component_get_uid (comp, &uid);
if (uid == NULL) {
gboolean ret_val = TRUE;
gboolean remove_completely = FALSE;
- priv = E_CAL_BACKEND_FILE_STORE_GET_PRIVATE (fstore);
+ priv = fstore->priv;
g_static_rw_lock_writer_lock (&priv->lock);
FullCompObject *obj = NULL;
ECalComponent *comp = NULL;
- priv = E_CAL_BACKEND_FILE_STORE_GET_PRIVATE (fstore);
+ priv = fstore->priv;
g_static_rw_lock_reader_lock (&priv->lock);
gboolean ret_val = FALSE;
FullCompObject *obj = NULL;
- priv = E_CAL_BACKEND_FILE_STORE_GET_PRIVATE (fstore);
+ priv = fstore->priv;
g_static_rw_lock_reader_lock (&priv->lock);
ECalBackendFileStorePrivate *priv;
gboolean ret_val = FALSE;
- priv = E_CAL_BACKEND_FILE_STORE_GET_PRIVATE (fstore);
+ priv = fstore->priv;
ret_val = put_component (fstore, comp);
ECalBackendFileStorePrivate *priv;
gboolean ret_val = FALSE;
- priv = E_CAL_BACKEND_FILE_STORE_GET_PRIVATE (fstore);
+ priv = fstore->priv;
ret_val = remove_component (fstore, uid, rid);
ECalBackendFileStorePrivate *priv;
const icaltimezone *zone = NULL;
- priv = E_CAL_BACKEND_FILE_STORE_GET_PRIVATE (fstore);
+ priv = fstore->priv;
g_static_rw_lock_reader_lock (&priv->lock);
zone = g_hash_table_lookup (priv->timezones, tzid);
gboolean ret_val = FALSE;
icaltimezone *copy;
- priv = E_CAL_BACKEND_FILE_STORE_GET_PRIVATE (fstore);
+ priv = fstore->priv;
g_static_rw_lock_writer_lock (&priv->lock);
copy = copy_timezone ((icaltimezone *) zone);
ECalBackendFileStorePrivate *priv;
gboolean ret_val = FALSE;
- priv = E_CAL_BACKEND_FILE_STORE_GET_PRIVATE (fstore);
+ priv = fstore->priv;
g_static_rw_lock_writer_lock (&priv->lock);
ret_val = g_hash_table_remove (priv->timezones, tzid);
ECalBackendFileStorePrivate *priv;
const gchar *value;
- priv = E_CAL_BACKEND_FILE_STORE_GET_PRIVATE (fstore);
+ priv = fstore->priv;
g_static_rw_lock_reader_lock (&priv->lock);
value = e_file_cache_get_object (priv->keys_cache, key);
ECalBackendFileStorePrivate *priv;
gboolean ret_val = FALSE;
- priv = E_CAL_BACKEND_FILE_STORE_GET_PRIVATE (fstore);
+ priv = fstore->priv;
g_static_rw_lock_writer_lock (&priv->lock);
const gchar *tzid;
const icaltimezone *zone = NULL;
- priv = E_CAL_BACKEND_FILE_STORE_GET_PRIVATE (fstore);
+ priv = fstore->priv;
g_static_rw_lock_reader_lock (&priv->lock);
icaltimezone *copy;
const gchar *key = "default-zone";
- priv = E_CAL_BACKEND_FILE_STORE_GET_PRIVATE (fstore);
+ priv = fstore->priv;
g_static_rw_lock_writer_lock (&priv->lock);
ECalBackendFileStore *fstore = E_CAL_BACKEND_FILE_STORE (store);
ECalBackendFileStorePrivate *priv;
- priv = E_CAL_BACKEND_FILE_STORE_GET_PRIVATE (fstore);
+ priv = fstore->priv;
priv->freeze_changes = FALSE;
ECalBackendFileStore *fstore = E_CAL_BACKEND_FILE_STORE (store);
ECalBackendFileStorePrivate *priv;
- priv = E_CAL_BACKEND_FILE_STORE_GET_PRIVATE (fstore);
+ priv = fstore->priv;
priv->freeze_changes = TRUE;
e_file_cache_freeze_changes (priv->keys_cache);
FullCompObject *obj = NULL;
GSList *comps = NULL;
- priv = E_CAL_BACKEND_FILE_STORE_GET_PRIVATE (fstore);
+ priv = fstore->priv;
g_static_rw_lock_reader_lock (&priv->lock);
ECalBackendFileStorePrivate *priv;
GSList *comps = NULL;
- priv = E_CAL_BACKEND_FILE_STORE_GET_PRIVATE (fstore);
+ priv = fstore->priv;
g_static_rw_lock_reader_lock (&priv->lock);
g_hash_table_foreach (priv->comp_uid_hash, (GHFunc) add_full_comp_to_slist, &comps);
ECalBackendFileStorePrivate *priv;
GSList *comp_ids = NULL;
- priv = E_CAL_BACKEND_FILE_STORE_GET_PRIVATE (fstore);
+ priv = fstore->priv;
g_static_rw_lock_reader_lock (&priv->lock);
g_hash_table_foreach (priv->comp_uid_hash, (GHFunc) add_comp_ids_to_slist, &comp_ids);
icaltimezone *zone;
const gchar *tzid;
- priv = E_CAL_BACKEND_FILE_STORE_GET_PRIVATE (fstore);
+ priv = fstore->priv;
prop = icalcomponent_get_first_property (vtzcomp, ICAL_TZID_PROPERTY);
if (!prop)
ECalBackendFileStorePrivate *priv;
icalcomponent *icalcomp;
- priv = E_CAL_BACKEND_FILE_STORE_GET_PRIVATE (fstore);
+ priv = fstore->priv;
if (!priv->cache_file_name || !priv->key_file_name)
return FALSE;
ECalBackendFileStore *fstore = E_CAL_BACKEND_FILE_STORE (store);
ECalBackendFileStorePrivate *priv;
- priv = E_CAL_BACKEND_FILE_STORE_GET_PRIVATE (fstore);
+ priv = fstore->priv;
/* This will remove all the contents in the directory */
e_file_cache_remove (priv->keys_cache);
ECalBackendFileStore *fstore = E_CAL_BACKEND_FILE_STORE (store);
ECalBackendFileStorePrivate *priv;
- priv = E_CAL_BACKEND_FILE_STORE_GET_PRIVATE (store);
+ priv = fstore->priv;
g_static_rw_lock_writer_lock (&priv->lock);
gsize len, nwrote;
FILE *f;
- priv = E_CAL_BACKEND_FILE_STORE_GET_PRIVATE (fstore);
+ priv = fstore->priv;
g_static_rw_lock_reader_lock (&priv->lock);
{
ECalBackendFileStorePrivate *priv;
- priv = E_CAL_BACKEND_FILE_STORE_GET_PRIVATE (store);
+ priv = store->priv;
if (priv->save_timeout_id) {
g_source_remove (priv->save_timeout_id);
ECalBackendFileStore *fstore = (ECalBackendFileStore *) object;
ECalBackendFileStorePrivate *priv;
- priv = E_CAL_BACKEND_FILE_STORE_GET_PRIVATE (fstore);
+ priv = fstore->priv;
if (priv->save_timeout_id) {
g_source_remove (priv->save_timeout_id);
ECalBackendFileStorePrivate *priv;
const gchar *path;
- priv = E_CAL_BACKEND_FILE_STORE_GET_PRIVATE (object);
+ priv = E_CAL_BACKEND_FILE_STORE (object)->priv;
path = e_cal_backend_store_get_path (E_CAL_BACKEND_STORE (object));
priv->cache_file_name = g_build_filename (path, CACHE_FILE_NAME, NULL);
{
ECalBackendFileStorePrivate *priv;
- priv = E_CAL_BACKEND_FILE_STORE_GET_PRIVATE (store);
+ priv = G_TYPE_INSTANCE_GET_PRIVATE (store, E_TYPE_CAL_BACKEND_FILE_STORE, ECalBackendFileStorePrivate);
store->priv = priv;
G_DEFINE_TYPE (EIntervalTree, e_intervaltree, G_TYPE_OBJECT)
-#define E_INTERVALTREE_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), E_TYPE_INTERVALTREE, EIntervalTreePrivate))
-
typedef struct _EIntervalNode EIntervalNode;
static EIntervalNode*
static void
e_intervaltree_finalize (GObject *object)
{
- EIntervalTreePrivate *priv = E_INTERVALTREE_GET_PRIVATE (object);
+ EIntervalTreePrivate *priv = E_INTERVALTREE (object)->priv;
if (priv->root) {
g_free (priv->root);
EIntervalTreePrivate *priv;
EIntervalNode *root, *nil;
- tree->priv = E_INTERVALTREE_GET_PRIVATE (tree);
+ tree->priv = G_TYPE_INSTANCE_GET_PRIVATE (tree, E_TYPE_INTERVALTREE, EIntervalTreePrivate);
priv = tree->priv;
priv->nil = nil = g_new (EIntervalNode, 1);
#include "e-cal-backend-intervaltree.h"
#include <libedataserver/e-data-server-util.h>
-#define E_CAL_BACKEND_STORE_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), E_TYPE_CAL_BACKEND_STORE, ECalBackendStorePrivate))
-
struct _ECalBackendStorePrivate {
gchar *path;
EIntervalTree *intervaltree;
{
ECalBackendStorePrivate *priv;
- priv = E_CAL_BACKEND_STORE_GET_PRIVATE (object);
+ priv = E_CAL_BACKEND_STORE (object)->priv;
g_free (priv->path);
if (priv->intervaltree) {
static void
e_cal_backend_store_init (ECalBackendStore *store)
{
- ECalBackendStorePrivate *priv;
- priv = E_CAL_BACKEND_STORE_GET_PRIVATE (store);
- store->priv = priv;
- priv->intervaltree = e_intervaltree_new ();
+ store->priv = G_TYPE_INSTANCE_GET_PRIVATE (store, E_TYPE_CAL_BACKEND_STORE, ECalBackendStorePrivate);
+ store->priv->intervaltree = e_intervaltree_new ();
}
/**
g_return_val_if_fail (E_IS_CAL_BACKEND_STORE (store), FALSE);
- priv = E_CAL_BACKEND_STORE_GET_PRIVATE (store);
+ priv = store->priv;
if (priv->loaded)
return TRUE;
e_cal_backend_store_remove (ECalBackendStore *store)
{
ECalBackendStorePrivate *priv;
+
g_return_val_if_fail (E_IS_CAL_BACKEND_STORE (store), FALSE);
- priv = E_CAL_BACKEND_STORE_GET_PRIVATE (store);
+ priv = store->priv;
/* remove interval tree */
e_intervaltree_destroy (priv->intervaltree);
priv->intervaltree = NULL;
e_cal_backend_store_clean (ECalBackendStore *store)
{
ECalBackendStorePrivate *priv;
+
g_return_val_if_fail (E_IS_CAL_BACKEND_STORE (store), FALSE);
- priv = E_CAL_BACKEND_STORE_GET_PRIVATE (store);
+ priv = store->priv;
if (priv->intervaltree) {
e_intervaltree_destroy (priv->intervaltree);
e_cal_backend_store_put_component_with_time_range (ECalBackendStore *store, ECalComponent *comp, time_t occurence_start, time_t occurence_end)
{
ECalBackendStorePrivate *priv;
+
g_return_val_if_fail (E_IS_CAL_BACKEND_STORE (store), FALSE);
g_return_val_if_fail (E_IS_CAL_COMPONENT (comp), FALSE);
- priv = E_CAL_BACKEND_STORE_GET_PRIVATE (store);
+ priv = store->priv;
if ((E_CAL_BACKEND_STORE_GET_CLASS (store))->put_component (store, comp)) {
if (e_intervaltree_insert (priv->intervaltree, occurence_start, occurence_end, comp))
e_cal_backend_store_remove_component (ECalBackendStore *store, const gchar *uid, const gchar *rid)
{
ECalBackendStorePrivate *priv;
+
g_return_val_if_fail (E_IS_CAL_BACKEND_STORE (store), FALSE);
g_return_val_if_fail (uid != NULL, FALSE);
- priv = E_CAL_BACKEND_STORE_GET_PRIVATE (store);
+ priv = store->priv;
if ((E_CAL_BACKEND_STORE_GET_CLASS (store))->remove_component (store, uid, rid)) {
if (e_intervaltree_remove (priv->intervaltree, uid, rid))
g_return_val_if_fail (store != NULL, NULL);
g_return_val_if_fail (E_IS_CAL_BACKEND_STORE (store), NULL);
- priv = E_CAL_BACKEND_STORE_GET_PRIVATE (store);
+ priv = store->priv;
if (!(objects = e_intervaltree_search (priv->intervaltree, start, end)))
return NULL;
e_cal_backend_store_interval_tree_add_comp (ECalBackendStore *store, ECalComponent *comp, time_t occurence_start, time_t occurence_end)
{
ECalBackendStorePrivate *priv;
+
g_return_if_fail (E_IS_CAL_BACKEND_STORE (store));
g_return_if_fail (E_IS_CAL_COMPONENT (comp));
- priv = E_CAL_BACKEND_STORE_GET_PRIVATE (store);
+ priv = store->priv;
e_intervaltree_insert (priv->intervaltree, occurence_start, occurence_end, comp);
}
#include "e-cal-backend.h"
#include "e-cal-backend-cache.h"
-#define E_CAL_BACKEND_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), E_TYPE_CAL_BACKEND, ECalBackendPrivate))
-
/* For convenience */
#define CLASS(backend) (E_CAL_BACKEND_GET_CLASS(backend))
{
ECalBackendPrivate *priv;
- priv = E_CAL_BACKEND_GET_PRIVATE (object);
+ priv = E_CAL_BACKEND (object)->priv;
g_assert (priv->clients == NULL);
static void
e_cal_backend_init (ECalBackend *backend)
{
- backend->priv = E_CAL_BACKEND_GET_PRIVATE (backend);
+ backend->priv = G_TYPE_INSTANCE_GET_PRIVATE (backend, E_TYPE_CAL_BACKEND, ECalBackendPrivate);
backend->priv->clients = NULL;
backend->priv->clients_mutex = g_mutex_new ();
G_DEFINE_TYPE (EDataCalFactory, e_data_cal_factory, G_TYPE_OBJECT);
-#define E_DATA_CAL_FACTORY_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), E_TYPE_DATA_CAL_FACTORY, EDataCalFactoryPrivate))
-
struct _EDataCalFactoryPrivate {
EGdbusCalFactory *gdbus_object;
{
GError *error = NULL;
- factory->priv = E_DATA_CAL_FACTORY_GET_PRIVATE (factory);
+ factory->priv = G_TYPE_INSTANCE_GET_PRIVATE (factory, E_TYPE_DATA_CAL_FACTORY, EDataCalFactoryPrivate);
factory->priv->gdbus_object = e_gdbus_cal_factory_stub_new ();
g_signal_connect (factory->priv->gdbus_object, "handle-get-cal", G_CALLBACK (impl_CalFactory_getCal), factory);
};
G_DEFINE_TYPE (EDataCalView, e_data_cal_view, G_TYPE_OBJECT);
-#define E_DATA_CAL_VIEW_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), E_DATA_CAL_VIEW_TYPE, EDataCalViewPrivate))
static void e_data_cal_view_dispose (GObject *object);
static void e_data_cal_view_finalize (GObject *object);
static void
e_data_cal_view_init (EDataCalView *query)
{
- EDataCalViewPrivate *priv = E_DATA_CAL_VIEW_GET_PRIVATE (query);
+ EDataCalViewPrivate *priv = G_TYPE_INSTANCE_GET_PRIVATE (query, E_DATA_CAL_VIEW_TYPE, EDataCalViewPrivate);
query->priv = priv;
G_DEFINE_TYPE (EDataCal, e_data_cal, G_TYPE_OBJECT);
-#define E_DATA_CAL_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), E_TYPE_DATA_CAL, EDataCalPrivate))
-
#define EDC_ERROR(_code) e_data_cal_create_error (_code, NULL)
#define EDC_ERROR_EX(_code, _msg) e_data_cal_create_error (_code, _msg)
{
EGdbusCal *gdbus_object;
- ecal->priv = E_DATA_CAL_GET_PRIVATE (ecal);
+ ecal->priv = G_TYPE_INSTANCE_GET_PRIVATE (ecal, E_TYPE_DATA_CAL, EDataCalPrivate);
ecal->priv->gdbus_object = e_gdbus_cal_stub_new ();
#define CAMEL_CERTDB_VERSION 0x100
-#define CAMEL_CERTDB_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_CERTDB, CamelCertDBPrivate))
-
struct _CamelCertDBPrivate {
GMutex *db_lock; /* for the db hashtable/array */
GMutex *io_lock; /* load/save lock, for access to saved_count, etc */
CamelCertDB *certdb = CAMEL_CERTDB (object);
CamelCertDBPrivate *priv;
- priv = CAMEL_CERTDB_GET_PRIVATE (object);
+ priv = certdb->priv;
if (certdb->flags & CAMEL_CERTDB_DIRTY)
camel_certdb_save (certdb);
static void
camel_certdb_init (CamelCertDB *certdb)
{
- certdb->priv = CAMEL_CERTDB_GET_PRIVATE (certdb);
-
+ certdb->priv = G_TYPE_INSTANCE_GET_PRIVATE (certdb, CAMEL_TYPE_CERTDB, CamelCertDBPrivate);
certdb->filename = NULL;
certdb->version = CAMEL_CERTDB_VERSION;
certdb->saved_certs = 0;
#define d(x)
-#define CAMEL_CIPHER_CONTEXT_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_CIPHER_CONTEXT, CamelCipherContextPrivate))
-
typedef struct _AsyncContext AsyncContext;
struct _CamelCipherContextPrivate {
{
CamelCipherContextPrivate *priv;
- priv = CAMEL_CIPHER_CONTEXT_GET_PRIVATE (object);
+ priv = CAMEL_CIPHER_CONTEXT (object)->priv;
if (priv->session != NULL) {
g_object_unref (priv->session);
{
CamelCipherContextPrivate *priv;
- priv = CAMEL_CIPHER_CONTEXT_GET_PRIVATE (object);
+ priv = CAMEL_CIPHER_CONTEXT (object)->priv;
g_mutex_free (priv->lock);
static void
camel_cipher_context_init (CamelCipherContext *context)
{
- context->priv = CAMEL_CIPHER_CONTEXT_GET_PRIVATE (context);
+ context->priv = G_TYPE_INSTANCE_GET_PRIVATE (context, CAMEL_TYPE_CIPHER_CONTEXT, CamelCipherContextPrivate);
context->priv->lock = g_mutex_new ();
}
once an hour should be enough */
#define CAMEL_DATA_CACHE_CYCLE_TIME (60*60)
-#define CAMEL_DATA_CACHE_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_DATA_CACHE, CamelDataCachePrivate))
-
struct _CamelDataCachePrivate {
CamelObjectBag *busy_bag;
{
CamelDataCachePrivate *priv;
- priv = CAMEL_DATA_CACHE_GET_PRIVATE (object);
+ priv = CAMEL_DATA_CACHE (object)->priv;
camel_object_bag_destroy (priv->busy_bag);
g_free (priv->path);
(CamelCopyFunc) g_strdup,
(GFreeFunc) g_free);
- data_cache->priv = CAMEL_DATA_CACHE_GET_PRIVATE (data_cache);
+ data_cache->priv = G_TYPE_INSTANCE_GET_PRIVATE (data_cache, CAMEL_TYPE_DATA_CACHE, CamelDataCachePrivate);
data_cache->priv->busy_bag = busy_bag;
data_cache->priv->expire_age = -1;
data_cache->priv->expire_access = -1;
#define d(x)
-#define CAMEL_DATA_WRAPPER_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_DATA_WRAPPER, CamelDataWrapperPrivate))
-
typedef struct _AsyncContext AsyncContext;
struct _CamelDataWrapperPrivate {
static void
camel_data_wrapper_init (CamelDataWrapper *data_wrapper)
{
- data_wrapper->priv = CAMEL_DATA_WRAPPER_GET_PRIVATE (data_wrapper);
+ data_wrapper->priv = G_TYPE_INSTANCE_GET_PRIVATE (data_wrapper, CAMEL_TYPE_DATA_WRAPPER, CamelDataWrapperPrivate);
g_static_mutex_init (&data_wrapper->priv->stream_lock);
#include "camel-disco-store.h"
#include "camel-session.h"
-#define CAMEL_DISCO_FOLDER_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_DISCO_FOLDER, CamelDiscoFolderPrivate))
-
struct _CamelDiscoFolderPrivate {
gboolean offline_sync;
};
static void
camel_disco_folder_init (CamelDiscoFolder *disco_folder)
{
- disco_folder->priv = CAMEL_DISCO_FOLDER_GET_PRIVATE (disco_folder);
+ disco_folder->priv = G_TYPE_INSTANCE_GET_PRIVATE (disco_folder, CAMEL_TYPE_DISCO_FOLDER, CamelDiscoFolderPrivate);
g_signal_connect (
disco_folder, "changed",
/* an invalid pointer */
#define FOLDER_INVALID ((gpointer)~0)
-#define CAMEL_FILTER_DRIVER_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_FILTER_DRIVER, CamelFilterDriverPrivate))
-
/* type of status for a log report */
enum filter_log_t {
FILTER_LOG_NONE,
{
CamelFilterDriverPrivate *priv;
- priv = CAMEL_FILTER_DRIVER_GET_PRIVATE (object);
+ priv = CAMEL_FILTER_DRIVER (object)->priv;
if (priv->defaultfolder != NULL) {
camel_folder_thaw (priv->defaultfolder);
CamelFilterDriverPrivate *priv;
struct _filter_rule *node;
- priv = CAMEL_FILTER_DRIVER_GET_PRIVATE (object);
+ priv = CAMEL_FILTER_DRIVER (object)->priv;
/* close all folders that were opened for appending */
close_folders (CAMEL_FILTER_DRIVER (object));
{
gint ii;
- filter_driver->priv = CAMEL_FILTER_DRIVER_GET_PRIVATE (filter_driver);
+ filter_driver->priv = G_TYPE_INSTANCE_GET_PRIVATE (filter_driver, CAMEL_TYPE_FILTER_DRIVER, CamelFilterDriverPrivate);
camel_dlist_init (&filter_driver->priv->rules);
void
camel_filter_driver_set_folder_func (CamelFilterDriver *d, CamelFilterGetFolderFunc get_folder, gpointer data)
{
- struct _CamelFilterDriverPrivate *p = CAMEL_FILTER_DRIVER_GET_PRIVATE (d);
-
- p->get_folder = get_folder;
- p->data = data;
+ d->priv->get_folder = get_folder;
+ d->priv->data = data;
}
void
camel_filter_driver_set_logfile (CamelFilterDriver *d, FILE *logfile)
{
- struct _CamelFilterDriverPrivate *p = CAMEL_FILTER_DRIVER_GET_PRIVATE (d);
-
- p->logfile = logfile;
+ d->priv->logfile = logfile;
}
void
camel_filter_driver_set_status_func (CamelFilterDriver *d, CamelFilterStatusFunc *func, gpointer data)
{
- struct _CamelFilterDriverPrivate *p = CAMEL_FILTER_DRIVER_GET_PRIVATE (d);
-
- p->statusfunc = func;
- p->statusdata = data;
+ d->priv->statusfunc = func;
+ d->priv->statusdata = data;
}
void
camel_filter_driver_set_shell_func (CamelFilterDriver *d, CamelFilterShellFunc *func, gpointer data)
{
- struct _CamelFilterDriverPrivate *p = CAMEL_FILTER_DRIVER_GET_PRIVATE (d);
-
- p->shellfunc = func;
- p->shelldata = data;
+ d->priv->shellfunc = func;
+ d->priv->shelldata = data;
}
void
camel_filter_driver_set_play_sound_func (CamelFilterDriver *d, CamelFilterPlaySoundFunc *func, gpointer data)
{
- struct _CamelFilterDriverPrivate *p = CAMEL_FILTER_DRIVER_GET_PRIVATE (d);
-
- p->playfunc = func;
- p->playdata = data;
+ d->priv->playfunc = func;
+ d->priv->playdata = data;
}
void
camel_filter_driver_set_system_beep_func (CamelFilterDriver *d, CamelFilterSystemBeepFunc *func, gpointer data)
{
- struct _CamelFilterDriverPrivate *p = CAMEL_FILTER_DRIVER_GET_PRIVATE (d);
-
- p->beep = func;
- p->beepdata = data;
+ d->priv->beep = func;
+ d->priv->beepdata = data;
}
void
camel_filter_driver_set_default_folder (CamelFilterDriver *d, CamelFolder *def)
{
- struct _CamelFilterDriverPrivate *p = CAMEL_FILTER_DRIVER_GET_PRIVATE (d);
-
- if (p->defaultfolder) {
- camel_folder_thaw (p->defaultfolder);
- g_object_unref (p->defaultfolder);
+ if (d->priv->defaultfolder) {
+ camel_folder_thaw (d->priv->defaultfolder);
+ g_object_unref (d->priv->defaultfolder);
}
- p->defaultfolder = def;
+ d->priv->defaultfolder = def;
- if (p->defaultfolder) {
- camel_folder_freeze (p->defaultfolder);
- g_object_ref (p->defaultfolder);
+ if (d->priv->defaultfolder) {
+ camel_folder_freeze (d->priv->defaultfolder);
+ g_object_ref (d->priv->defaultfolder);
}
}
void
camel_filter_driver_add_rule (CamelFilterDriver *d, const gchar *name, const gchar *match, const gchar *action)
{
- struct _CamelFilterDriverPrivate *p = CAMEL_FILTER_DRIVER_GET_PRIVATE (d);
struct _filter_rule *node;
node = g_malloc (sizeof (*node));
node->match = g_strdup (match);
node->action = g_strdup (action);
node->name = g_strdup (name);
- camel_dlist_addtail (&p->rules, (CamelDListNode *)node);
+ camel_dlist_addtail (&d->priv->rules, (CamelDListNode *)node);
}
gint
camel_filter_driver_remove_rule_by_name (CamelFilterDriver *d, const gchar *name)
{
- struct _CamelFilterDriverPrivate *p = CAMEL_FILTER_DRIVER_GET_PRIVATE (d);
struct _filter_rule *node;
- node = (struct _filter_rule *) p->rules.head;
+ node = (struct _filter_rule *) d->priv->rules.head;
while (node->next) {
if (!strcmp (node->name, name)) {
camel_dlist_remove ((CamelDListNode *) node);
report_status (CamelFilterDriver *driver, enum camel_filter_status_t status, gint pc, const gchar *desc, ...)
{
/* call user-defined status report function */
- struct _CamelFilterDriverPrivate *p = CAMEL_FILTER_DRIVER_GET_PRIVATE (driver);
va_list ap;
gchar *str;
- if (p->statusfunc) {
+ if (driver->priv->statusfunc) {
va_start (ap, desc);
str = g_strdup_vprintf (desc, ap);
- p->statusfunc (driver, status, pc, str, p->statusdata);
+ driver->priv->statusfunc (driver, status, pc, str, driver->priv->statusdata);
g_free (str);
}
}
void
camel_filter_driver_set_global (CamelFilterDriver *d, const gchar *name, const gchar *value)
{
- struct _CamelFilterDriverPrivate *p = CAMEL_FILTER_DRIVER_GET_PRIVATE (d);
gchar *oldkey, *oldvalue;
- if (g_hash_table_lookup_extended (p->globals, name, (gpointer)&oldkey, (gpointer)&oldvalue)) {
+ if (g_hash_table_lookup_extended (d->priv->globals, name, (gpointer)&oldkey, (gpointer)&oldvalue)) {
g_free (oldvalue);
- g_hash_table_insert (p->globals, oldkey, g_strdup (value));
+ g_hash_table_insert (d->priv->globals, oldkey, g_strdup (value));
} else {
- g_hash_table_insert (p->globals, g_strdup (name), g_strdup (value));
+ g_hash_table_insert (d->priv->globals, g_strdup (name), g_strdup (value));
}
}
#endif
static ESExpResult *
do_delete (struct _ESExp *f, gint argc, struct _ESExpResult **argv, CamelFilterDriver *driver)
{
- struct _CamelFilterDriverPrivate *p = CAMEL_FILTER_DRIVER_GET_PRIVATE (driver);
-
d(fprintf (stderr, "doing delete\n"));
- p->deleted = TRUE;
+ driver->priv->deleted = TRUE;
camel_filter_driver_log (driver, FILTER_LOG_ACTION, "Delete");
return NULL;
static ESExpResult *
do_forward_to (struct _ESExp *f, gint argc, struct _ESExpResult **argv, CamelFilterDriver *driver)
{
- struct _CamelFilterDriverPrivate *p = CAMEL_FILTER_DRIVER_GET_PRIVATE (driver);
+ CamelFilterDriverPrivate *p = driver->priv;
d(fprintf (stderr, "marking message for forwarding\n"));
static ESExpResult *
do_copy (struct _ESExp *f, gint argc, struct _ESExpResult **argv, CamelFilterDriver *driver)
{
- struct _CamelFilterDriverPrivate *p = CAMEL_FILTER_DRIVER_GET_PRIVATE (driver);
+ CamelFilterDriverPrivate *p = driver->priv;
gint i;
d(fprintf (stderr, "copying message...\n"));
static ESExpResult *
do_move (struct _ESExp *f, gint argc, struct _ESExpResult **argv, CamelFilterDriver *driver)
{
- struct _CamelFilterDriverPrivate *p = CAMEL_FILTER_DRIVER_GET_PRIVATE (driver);
+ CamelFilterDriverPrivate *p = driver->priv;
gint i;
d(fprintf (stderr, "moving message...\n"));
static ESExpResult *
do_stop (struct _ESExp *f, gint argc, struct _ESExpResult **argv, CamelFilterDriver *driver)
{
- struct _CamelFilterDriverPrivate *p = CAMEL_FILTER_DRIVER_GET_PRIVATE (driver);
+ CamelFilterDriverPrivate *p = driver->priv;
camel_filter_driver_log (driver, FILTER_LOG_ACTION, "Stopped processing");
d(fprintf (stderr, "terminating message processing\n"));
static ESExpResult *
do_label (struct _ESExp *f, gint argc, struct _ESExpResult **argv, CamelFilterDriver *driver)
{
- struct _CamelFilterDriverPrivate *p = CAMEL_FILTER_DRIVER_GET_PRIVATE (driver);
+ CamelFilterDriverPrivate *p = driver->priv;
d(fprintf (stderr, "setting label tag\n"));
if (argc > 0 && argv[0]->type == ESEXP_RES_STRING) {
static ESExpResult *
do_color (struct _ESExp *f, gint argc, struct _ESExpResult **argv, CamelFilterDriver *driver)
{
- struct _CamelFilterDriverPrivate *p = CAMEL_FILTER_DRIVER_GET_PRIVATE (driver);
+ CamelFilterDriverPrivate *p = driver->priv;
d(fprintf (stderr, "setting color tag\n"));
if (argc > 0 && argv[0]->type == ESEXP_RES_STRING) {
static ESExpResult *
do_score (struct _ESExp *f, gint argc, struct _ESExpResult **argv, CamelFilterDriver *driver)
{
- struct _CamelFilterDriverPrivate *p = CAMEL_FILTER_DRIVER_GET_PRIVATE (driver);
+ CamelFilterDriverPrivate *p = driver->priv;
d(fprintf (stderr, "setting score tag\n"));
if (argc > 0 && argv[0]->type == ESEXP_RES_INT) {
static ESExpResult *
do_adjust_score (struct _ESExp *f, gint argc, struct _ESExpResult **argv, CamelFilterDriver *driver)
{
- struct _CamelFilterDriverPrivate *p = CAMEL_FILTER_DRIVER_GET_PRIVATE (driver);
+ CamelFilterDriverPrivate *p = driver->priv;
d(fprintf (stderr, "adjusting score tag\n"));
if (argc > 0 && argv[0]->type == ESEXP_RES_INT) {
static ESExpResult *
set_flag (struct _ESExp *f, gint argc, struct _ESExpResult **argv, CamelFilterDriver *driver)
{
- struct _CamelFilterDriverPrivate *p = CAMEL_FILTER_DRIVER_GET_PRIVATE (driver);
+ CamelFilterDriverPrivate *p = driver->priv;
guint32 flags;
d(fprintf (stderr, "setting flag\n"));
static ESExpResult *
unset_flag (struct _ESExp *f, gint argc, struct _ESExpResult **argv, CamelFilterDriver *driver)
{
- struct _CamelFilterDriverPrivate *p = CAMEL_FILTER_DRIVER_GET_PRIVATE (driver);
+ CamelFilterDriverPrivate *p = driver->priv;
guint32 flags;
d(fprintf (stderr, "unsetting flag\n"));
static gint
pipe_to_system (struct _ESExp *f, gint argc, struct _ESExpResult **argv, CamelFilterDriver *driver)
{
- struct _CamelFilterDriverPrivate *p = CAMEL_FILTER_DRIVER_GET_PRIVATE (driver);
+ CamelFilterDriverPrivate *p = driver->priv;
gint i, pipe_to_child, pipe_from_child;
CamelMimeMessage *message = NULL;
CamelMimeParser *parser;
static ESExpResult *
do_shell (struct _ESExp *f, gint argc, struct _ESExpResult **argv, CamelFilterDriver *driver)
{
- struct _CamelFilterDriverPrivate *p = CAMEL_FILTER_DRIVER_GET_PRIVATE (driver);
+ CamelFilterDriverPrivate *p = driver->priv;
GString *command;
GPtrArray *args;
gint i;
static ESExpResult *
do_beep (struct _ESExp *f, gint argc, struct _ESExpResult **argv, CamelFilterDriver *driver)
{
- struct _CamelFilterDriverPrivate *p = CAMEL_FILTER_DRIVER_GET_PRIVATE (driver);
+ CamelFilterDriverPrivate *p = driver->priv;
d(fprintf (stderr, "beep\n"));
static ESExpResult *
play_sound (struct _ESExp *f, gint argc, struct _ESExpResult **argv, CamelFilterDriver *driver)
{
- struct _CamelFilterDriverPrivate *p = CAMEL_FILTER_DRIVER_GET_PRIVATE (driver);
+ CamelFilterDriverPrivate *p = driver->priv;
d(fprintf (stderr, "play sound\n"));
static ESExpResult *
do_only_once (struct _ESExp *f, gint argc, struct _ESExpResult **argv, CamelFilterDriver *driver)
{
- struct _CamelFilterDriverPrivate *p = CAMEL_FILTER_DRIVER_GET_PRIVATE (driver);
+ CamelFilterDriverPrivate *p = driver->priv;
d(fprintf (stderr, "only once\n"));
static CamelFolder *
open_folder (CamelFilterDriver *driver, const gchar *folder_url)
{
- struct _CamelFilterDriverPrivate *p = CAMEL_FILTER_DRIVER_GET_PRIVATE (driver);
+ CamelFilterDriverPrivate *p = driver->priv;
CamelFolder *camelfolder;
/* we have a lookup table of currently open folders */
{
CamelFolder *folder = value;
CamelFilterDriver *driver = data;
- struct _CamelFilterDriverPrivate *p = CAMEL_FILTER_DRIVER_GET_PRIVATE (driver);
+ CamelFilterDriverPrivate *p = driver->priv;
p->closed++;
g_free (key);
static gint
close_folders (CamelFilterDriver *driver)
{
- struct _CamelFilterDriverPrivate *p = CAMEL_FILTER_DRIVER_GET_PRIVATE (driver);
+ CamelFilterDriverPrivate *p = driver->priv;
report_status(driver, CAMEL_FILTER_STATUS_PROGRESS, 0, _("Syncing folders"));
static void
camel_filter_driver_log (CamelFilterDriver *driver, enum filter_log_t status, const gchar *desc, ...)
{
- struct _CamelFilterDriverPrivate *p = CAMEL_FILTER_DRIVER_GET_PRIVATE (driver);
+ CamelFilterDriverPrivate *p = driver->priv;
if (p->logfile) {
gchar *str = NULL;
static gboolean
run_only_once (gpointer key, gchar *action, struct _run_only_once *data)
{
- struct _CamelFilterDriverPrivate *p = CAMEL_FILTER_DRIVER_GET_PRIVATE (data->driver);
+ CamelFilterDriverPrivate *p = data->driver->priv;
ESExpResult *r;
d(printf ("evaluating: %s\n\n", action));
camel_filter_driver_flush (CamelFilterDriver *driver,
GError **error)
{
- struct _CamelFilterDriverPrivate *p = CAMEL_FILTER_DRIVER_GET_PRIVATE (driver);
+ CamelFilterDriverPrivate *p = driver->priv;
struct _run_only_once data;
if (!p->only_once)
GCancellable *cancellable,
GError **error)
{
- struct _CamelFilterDriverPrivate *p = CAMEL_FILTER_DRIVER_GET_PRIVATE (driver);
+ CamelFilterDriverPrivate *p = driver->priv;
CamelMimeParser *mp = NULL;
gchar *source_url = NULL;
gint fd = -1;
GCancellable *cancellable,
GError **error)
{
- struct _CamelFilterDriverPrivate *p = CAMEL_FILTER_DRIVER_GET_PRIVATE (driver);
+ CamelFilterDriverPrivate *p = driver->priv;
gboolean freeuids = FALSE;
CamelMessageInfo *info;
gchar *source_url, *service_url;
GCancellable *cancellable,
GError **error)
{
- struct _CamelFilterDriverPrivate *p = CAMEL_FILTER_DRIVER_GET_PRIVATE (driver);
+ CamelFilterDriverPrivate *p = driver->priv;
struct _filter_rule *node;
gboolean freeinfo = FALSE;
gboolean filtered = FALSE;
#define r(x)
#define dd(x) if (camel_debug("search")) x
-#define CAMEL_FOLDER_SEARCH_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_FOLDER_SEARCH, CamelFolderSearchPrivate))
-
struct _CamelFolderSearchPrivate {
GError **error;
static void
camel_folder_search_init (CamelFolderSearch *search)
{
- search->priv = CAMEL_FOLDER_SEARCH_GET_PRIVATE (search);
+ search->priv = G_TYPE_INSTANCE_GET_PRIVATE (search, CAMEL_TYPE_FOLDER_SEARCH, CamelFolderSearchPrivate);
search->sexp = e_sexp_new ();
}
#include "camel-vtrash-folder.h"
#include "camel-mime-part-utils.h"
-#define CAMEL_FOLDER_SUMMARY_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_FOLDER_SUMMARY, CamelFolderSummaryPrivate))
-
/* Make 5 minutes as default cache drop */
#define SUMMARY_CACHE_DROP 300
#define dd(x) if (camel_debug("sync")) x
{
CamelFolderSummaryPrivate *priv;
- priv = CAMEL_FOLDER_SUMMARY_GET_PRIVATE (object);
+ priv = CAMEL_FOLDER_SUMMARY (object)->priv;
if (priv->filter_index != NULL) {
g_object_unref (priv->filter_index);
static void
camel_folder_summary_init (CamelFolderSummary *summary)
{
- summary->priv = CAMEL_FOLDER_SUMMARY_GET_PRIVATE (summary);
+ summary->priv = G_TYPE_INSTANCE_GET_PRIVATE (summary, CAMEL_TYPE_FOLDER_SUMMARY, CamelFolderSummaryPrivate);
summary->priv->filter_charset = g_hash_table_new (
camel_strcase_hash, camel_strcase_equal);
void
camel_folder_summary_set_index (CamelFolderSummary *s, CamelIndex *index)
{
- struct _CamelFolderSummaryPrivate *p = CAMEL_FOLDER_SUMMARY_GET_PRIVATE (s);
+ struct _CamelFolderSummaryPrivate *p = s->priv;
if (p->index)
g_object_unref (p->index);
cfs_schedule_info_release_timer (s);
- if (CAMEL_FOLDER_SUMMARY_GET_PRIVATE (s)->need_preview) {
+ if (s->priv->need_preview) {
struct _preview_update_msg *m;
m = camel_session_thread_msg_new (((CamelService *)parent_store)->session, &preview_update_ops, sizeof (*m));
camel_folder_summary_add_preview (CamelFolderSummary *s, CamelMessageInfo *info)
{
camel_folder_summary_lock (s, CAMEL_FOLDER_SUMMARY_SUMMARY_LOCK);
- g_hash_table_insert (CAMEL_FOLDER_SUMMARY_GET_PRIVATE (s)->preview_updates, (gchar *)info->uid, ((CamelMessageInfoBase *)info)->preview);
+ g_hash_table_insert (s->priv->preview_updates, (gchar *)info->uid, ((CamelMessageInfoBase *)info)->preview);
camel_folder_summary_unlock (s, CAMEL_FOLDER_SUMMARY_SUMMARY_LOCK);
}
cdb = parent_store->cdb_w;
d(printf ("\ncamel_folder_summary_save_to_db called \n"));
- if (CAMEL_FOLDER_SUMMARY_GET_PRIVATE (s)->need_preview && g_hash_table_size (CAMEL_FOLDER_SUMMARY_GET_PRIVATE (s)->preview_updates)) {
+ if (s->priv->need_preview && g_hash_table_size (s->priv->preview_updates)) {
camel_db_begin_transaction (parent_store->cdb_w, NULL);
camel_folder_summary_lock (s, CAMEL_FOLDER_SUMMARY_SUMMARY_LOCK);
- g_hash_table_foreach (CAMEL_FOLDER_SUMMARY_GET_PRIVATE (s)->preview_updates, (GHFunc)msg_save_preview, s->folder);
- g_hash_table_remove_all (CAMEL_FOLDER_SUMMARY_GET_PRIVATE (s)->preview_updates);
+ g_hash_table_foreach (s->priv->preview_updates, (GHFunc)msg_save_preview, s->folder);
+ g_hash_table_remove_all (s->priv->preview_updates);
camel_folder_summary_unlock (s, CAMEL_FOLDER_SUMMARY_SUMMARY_LOCK);
camel_db_end_transaction (parent_store->cdb_w, NULL);
}
CamelMessageInfo *info = NULL;
gchar *buffer;
gsize len;
- struct _CamelFolderSummaryPrivate *p = CAMEL_FOLDER_SUMMARY_GET_PRIVATE (s);
+ CamelFolderSummaryPrivate *p = s->priv;
goffset start;
CamelIndexName *name = NULL;
camel_folder_summary_info_new_from_message (CamelFolderSummary *s, CamelMimeMessage *msg, const gchar *bodystructure)
{
CamelMessageInfo *info;
- struct _CamelFolderSummaryPrivate *p = CAMEL_FOLDER_SUMMARY_GET_PRIVATE (s);
+ CamelFolderSummaryPrivate *p = s->priv;
CamelIndexName *name = NULL;
info = CAMEL_FOLDER_SUMMARY_GET_CLASS (s)->message_info_new_from_message (s, msg, bodystructure);
CamelMessageContentInfo *info = NULL;
CamelContentType *ct;
gint enc_id = -1, chr_id = -1, html_id = -1, idx_id = -1;
- struct _CamelFolderSummaryPrivate *p = CAMEL_FOLDER_SUMMARY_GET_PRIVATE (s);
+ CamelFolderSummaryPrivate *p = s->priv;
CamelMimeFilter *mfc;
CamelMessageContentInfo *part;
const gchar *calendar_header;
{
CamelDataWrapper *containee;
gint parts, i;
- struct _CamelFolderSummaryPrivate *p = CAMEL_FOLDER_SUMMARY_GET_PRIVATE (s);
+ CamelFolderSummaryPrivate *p = s->priv;
CamelMessageContentInfo *info = NULL, *child;
CamelContentType *ct;
const struct _camel_header_raw *header;
void
camel_folder_summary_set_need_preview (CamelFolderSummary *summary, gboolean preview)
{
- CAMEL_FOLDER_SUMMARY_GET_PRIVATE (summary)->need_preview = preview;
+ summary->priv->need_preview = preview;
}
/**
gboolean
camel_folder_summary_get_need_preview (CamelFolderSummary *summary)
{
- return CAMEL_FOLDER_SUMMARY_GET_PRIVATE (summary)->need_preview;
+ return summary->priv->need_preview;
}
static gboolean
#include "camel-vtrash-folder.h"
#include "camel-string-utils.h"
-#define CAMEL_FOLDER_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_FOLDER, CamelFolderPrivate))
-
#define d(x)
#define w(x)
{
CamelFolderPrivate *priv;
- priv = CAMEL_FOLDER_GET_PRIVATE (object);
+ priv = CAMEL_FOLDER (object)->priv;
g_free (priv->name);
g_free (priv->full_name);
static void
camel_folder_init (CamelFolder *folder)
{
- folder->priv = CAMEL_FOLDER_GET_PRIVATE (folder);
-
+ folder->priv = G_TYPE_INSTANCE_GET_PRIVATE (folder, CAMEL_TYPE_FOLDER, CamelFolderPrivate);
folder->priv->frozen = 0;
folder->priv->changed_frozen = camel_folder_change_info_new ();
static gint logid;
#endif
-#define CAMEL_GPG_CONTEXT_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_GPG_CONTEXT, CamelGpgContextPrivate))
-
struct _CamelGpgContextPrivate {
gboolean always_trust;
};
static void
camel_gpg_context_init (CamelGpgContext *context)
{
- context->priv = CAMEL_GPG_CONTEXT_GET_PRIVATE (context);
+ context->priv = G_TYPE_INSTANCE_GET_PRIVATE (context, CAMEL_TYPE_GPG_CONTEXT, CamelGpgContextPrivate);
}
/**
#define CAMEL_INDEX_VERSION (0x01)
-#define CAMEL_INDEX_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_INDEX, CamelIndexPrivate))
-
struct _CamelIndexPrivate {
gpointer dummy;
};
static void
camel_index_init (CamelIndex *index)
{
- index->priv = CAMEL_INDEX_GET_PRIVATE (index);
+ index->priv = G_TYPE_INSTANCE_GET_PRIVATE (index, CAMEL_TYPE_INDEX, CamelIndexPrivate);
index->version = CAMEL_INDEX_VERSION;
}
#define d(x)
-#define CAMEL_MEDIUM_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_MEDIUM, CamelMediumPrivate))
-
struct _CamelMediumPrivate {
/* The content of the medium, as opposed to our parent
* CamelDataWrapper, which wraps both the headers and
{
CamelMediumPrivate *priv;
- priv = CAMEL_MEDIUM_GET_PRIVATE (object);
+ priv = CAMEL_MEDIUM (object)->priv;
if (priv->content != NULL) {
g_object_unref (priv->content);
static void
camel_medium_init (CamelMedium *medium)
{
- medium->priv = CAMEL_MEDIUM_GET_PRIVATE (medium);
+ medium->priv = G_TYPE_INSTANCE_GET_PRIVATE (medium, CAMEL_TYPE_MEDIUM, CamelMediumPrivate);
}
/**
#include "camel-mime-filter-basic.h"
#include "camel-mime-utils.h"
-#define CAMEL_MIME_FILTER_BASIC_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_MIME_FILTER_BASIC, CamelMimeFilterBasicPrivate))
-
struct _CamelMimeFilterBasicPrivate {
CamelMimeFilterBasicType type;
guchar uubuf[60];
CamelMimeFilterBasicPrivate *priv;
gsize newlen;
- priv = CAMEL_MIME_FILTER_BASIC_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_BASIC (mime_filter)->priv;
switch (priv->type) {
case CAMEL_MIME_FILTER_BASIC_BASE64_ENC:
CamelMimeFilterBasicPrivate *priv;
gsize newlen = 0;
- priv = CAMEL_MIME_FILTER_BASIC_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_BASIC (mime_filter)->priv;
switch (priv->type) {
case CAMEL_MIME_FILTER_BASIC_BASE64_ENC:
{
CamelMimeFilterBasicPrivate *priv;
- priv = CAMEL_MIME_FILTER_BASIC_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_BASIC (mime_filter)->priv;
switch (priv->type) {
case CAMEL_MIME_FILTER_BASIC_QP_ENC:
static void
camel_mime_filter_basic_init (CamelMimeFilterBasic *filter)
{
- filter->priv = CAMEL_MIME_FILTER_BASIC_GET_PRIVATE (filter);
+ filter->priv = G_TYPE_INSTANCE_GET_PRIVATE (filter, CAMEL_TYPE_MIME_FILTER_BASIC, CamelMimeFilterBasicPrivate);
}
/**
#include "camel-mime-filter-bestenc.h"
-#define CAMEL_MIME_FILTER_BESTENC_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_MIME_FILTER_BESTENC, CamelMimeFilterBestencPrivate))
-
struct _CamelMimeFilterBestencPrivate {
guint flags; /* our creation flags */
CamelMimeFilterBestencPrivate *priv;
register guchar *p, *pend;
- priv = CAMEL_MIME_FILTER_BESTENC_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_BESTENC (mime_filter)->priv;
if (len == 0)
goto donothing;
{
CamelMimeFilterBestencPrivate *priv;
- priv = CAMEL_MIME_FILTER_BESTENC_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_BESTENC (mime_filter)->priv;
mime_filter_bestenc_filter (
mime_filter, in, len, prespace, out, outlen, outprespace);
{
CamelMimeFilterBestencPrivate *priv;
- priv = CAMEL_MIME_FILTER_BESTENC_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_BESTENC (mime_filter)->priv;
priv->count0 = 0;
priv->count8 = 0;
static void
camel_mime_filter_bestenc_init (CamelMimeFilterBestenc *filter)
{
- filter->priv = CAMEL_MIME_FILTER_BESTENC_GET_PRIVATE (filter);
+ filter->priv = G_TYPE_INSTANCE_GET_PRIVATE (filter, CAMEL_TYPE_MIME_FILTER_BESTENC, CamelMimeFilterBestencPrivate);
mime_filter_bestenc_reset (CAMEL_MIME_FILTER (filter));
}
CamelTransferEncoding bestenc;
gint istext;
- priv = CAMEL_MIME_FILTER_BESTENC_GET_PRIVATE (filter);
+ priv = filter->priv;
istext = (required & CAMEL_BESTENC_TEXT) ? 1 : 0;
required = required & ~CAMEL_BESTENC_TEXT;
#include "camel-mime-filter-canon.h"
-#define CAMEL_MIME_FILTER_CANON_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_MIME_FILTER_CANON, CamelMimeFilterCanonPrivate))
-
struct _CamelMimeFilterCanonPrivate {
guint32 flags;
};
register gchar *o;
gint lf = 0;
- priv = CAMEL_MIME_FILTER_CANON_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_CANON (mime_filter)->priv;
/* first, work out how much space we need */
inptr = (guchar *)in;
static void
camel_mime_filter_canon_init (CamelMimeFilterCanon *filter)
{
- filter->priv = CAMEL_MIME_FILTER_CANON_GET_PRIVATE (filter);
+ filter->priv = G_TYPE_INSTANCE_GET_PRIVATE (filter, CAMEL_TYPE_MIME_FILTER_CANON, CamelMimeFilterCanonPrivate);
}
/**
#include "camel-iconv.h"
#include "camel-mime-filter-charset.h"
-#define CAMEL_MIME_FILTER_CHARSET_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_MIME_FILTER_CHARSET, CamelMimeFilterCharsetPrivate))
-
#define d(x)
#define w(x)
{
CamelMimeFilterCharsetPrivate *priv;
- priv = CAMEL_MIME_FILTER_CHARSET_GET_PRIVATE (object);
+ priv = CAMEL_MIME_FILTER_CHARSET (object)->priv;
g_free (priv->from);
g_free (priv->to);
const gchar *inbuf;
gchar *outbuf;
- priv = CAMEL_MIME_FILTER_CHARSET_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_CHARSET (mime_filter)->priv;
if (priv->ic == (iconv_t) -1)
goto noop;
const gchar *inbuf;
gchar *outbuf;
- priv = CAMEL_MIME_FILTER_CHARSET_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_CHARSET (mime_filter)->priv;
if (priv->ic == (iconv_t) -1)
goto noop;
gchar *buffer;
gsize outlen = 16;
- priv = CAMEL_MIME_FILTER_CHARSET_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_CHARSET (mime_filter)->priv;
/* what happens with the output bytes if this resets the state? */
if (priv->ic != (iconv_t) -1) {
static void
camel_mime_filter_charset_init (CamelMimeFilterCharset *filter)
{
- filter->priv = CAMEL_MIME_FILTER_CHARSET_GET_PRIVATE (filter);
+ filter->priv = G_TYPE_INSTANCE_GET_PRIVATE (filter, CAMEL_TYPE_MIME_FILTER_CHARSET, CamelMimeFilterCharsetPrivate);
filter->priv->ic = (iconv_t) -1;
}
camel_mime_filter_charset_new (const gchar *from_charset,
const gchar *to_charset)
{
- CamelMimeFilter *new;
+ CamelMimeFilter *res;
CamelMimeFilterCharsetPrivate *priv;
- new = g_object_new (CAMEL_TYPE_MIME_FILTER_CHARSET, NULL);
- priv = CAMEL_MIME_FILTER_CHARSET_GET_PRIVATE (new);
+ res = g_object_new (CAMEL_TYPE_MIME_FILTER_CHARSET, NULL);
+ priv = CAMEL_MIME_FILTER_CHARSET (res)->priv;
priv->ic = camel_iconv_open (to_charset, from_charset);
if (priv->ic == (iconv_t) -1) {
from_charset ? from_charset : "(null)",
to_charset ? to_charset : "(null)",
g_strerror (errno)));
- g_object_unref (new);
- new = NULL;
+ g_object_unref (res);
+ res = NULL;
} else {
priv->from = g_strdup (from_charset);
priv->to = g_strdup (to_charset);
}
- return new;
+ return res;
}
#include "camel-mime-filter-crlf.h"
-#define CAMEL_MIME_FILTER_CRLF_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_MIME_FILTER_CRLF, CamelMimeFilterCRLFPrivate))
-
struct _CamelMimeFilterCRLFPrivate {
CamelMimeFilterCRLFDirection direction;
CamelMimeFilterCRLFMode mode;
gboolean do_dots;
gchar *outptr;
- priv = CAMEL_MIME_FILTER_CRLF_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_CRLF (mime_filter)->priv;
do_dots = priv->mode == CAMEL_MIME_FILTER_CRLF_MODE_CRLF_DOTS;
{
CamelMimeFilterCRLFPrivate *priv;
- priv = CAMEL_MIME_FILTER_CRLF_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_CRLF (mime_filter)->priv;
priv->saw_cr = FALSE;
priv->saw_lf = TRUE;
static void
camel_mime_filter_crlf_init (CamelMimeFilterCRLF *filter)
{
- filter->priv = CAMEL_MIME_FILTER_CRLF_GET_PRIVATE (filter);
+ filter->priv = G_TYPE_INSTANCE_GET_PRIVATE (filter, CAMEL_TYPE_MIME_FILTER_CRLF, CamelMimeFilterCRLFPrivate);
filter->priv->saw_cr = FALSE;
filter->priv->saw_lf = TRUE;
CamelMimeFilterCRLFPrivate *priv;
filter = g_object_new (CAMEL_TYPE_MIME_FILTER_CRLF, NULL);
- priv = CAMEL_MIME_FILTER_CRLF_GET_PRIVATE (filter);
+ priv = CAMEL_MIME_FILTER_CRLF (filter)->priv;
priv->direction = direction;
priv->mode = mode;
#include "camel-mime-filter-enriched.h"
#include "camel-string-utils.h"
-#define CAMEL_MIME_FILTER_ENRICHED_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_MIME_FILTER_ENRICHED, CamelMimeFilterEnrichedPrivate))
-
struct _CamelMimeFilterEnrichedPrivate {
guint32 flags;
gint nofill;
register const gchar *inptr;
register gchar *outptr;
- priv = CAMEL_MIME_FILTER_ENRICHED_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_ENRICHED (mime_filter)->priv;
camel_mime_filter_set_size (mime_filter, inlen * 2 + 6, FALSE);
{
CamelMimeFilterEnrichedPrivate *priv;
- priv = CAMEL_MIME_FILTER_ENRICHED_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_ENRICHED (mime_filter)->priv;
priv->nofill = 0;
}
static void
camel_mime_filter_enriched_init (CamelMimeFilterEnriched *filter)
{
- filter->priv = CAMEL_MIME_FILTER_ENRICHED_GET_PRIVATE (filter);
+ filter->priv = G_TYPE_INSTANCE_GET_PRIVATE (filter, CAMEL_TYPE_MIME_FILTER_ENRICHED, CamelMimeFilterEnrichedPrivate);
}
/**
CamelMimeFilter *
camel_mime_filter_enriched_new (guint32 flags)
{
- CamelMimeFilter *new;
+ CamelMimeFilter *res;
CamelMimeFilterEnrichedPrivate *priv;
- new = g_object_new (CAMEL_TYPE_MIME_FILTER_ENRICHED, NULL);
- priv = CAMEL_MIME_FILTER_ENRICHED_GET_PRIVATE (new);
+ res = g_object_new (CAMEL_TYPE_MIME_FILTER_ENRICHED, NULL);
+ priv = CAMEL_MIME_FILTER_ENRICHED (res)->priv;
priv->flags = flags;
- return new;
+ return res;
}
/**
#include "camel-mime-filter-from.h"
-#define CAMEL_MIME_FILTER_FROM_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_MIME_FILTER_FROM, CamelMimeFilterFromPrivate))
-
#define d(x)
struct _CamelMimeFilterFromPrivate {
struct fromnode *head = NULL, *tail = (struct fromnode *)&head, *node;
gchar *outptr;
- priv = CAMEL_MIME_FILTER_FROM_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_FROM (mime_filter)->priv;
inptr = in;
inend = inptr+len;
static void
camel_mime_filter_from_init (CamelMimeFilterFrom *filter)
{
- filter->priv = CAMEL_MIME_FILTER_FROM_GET_PRIVATE (filter);
+ filter->priv = G_TYPE_INSTANCE_GET_PRIVATE (filter, CAMEL_TYPE_MIME_FILTER_FROM, CamelMimeFilterFromPrivate);
}
/**
#include "camel-mime-filter-gzip.h"
-#define CAMEL_MIME_FILTER_GZIP_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_MIME_FILTER_GZIP, CamelMimeFilterGZipPrivate))
-
/* rfc1952 */
enum {
CamelMimeFilterGZipPrivate *priv;
gint retval;
- priv = CAMEL_MIME_FILTER_GZIP_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_GZIP (mime_filter)->priv;
if (!priv->state.zip.wrote_hdr) {
priv->hdr.v.id1 = 31;
guint16 need, val;
gint retval;
- priv = CAMEL_MIME_FILTER_GZIP_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_GZIP (mime_filter)->priv;
if (!priv->state.unzip.got_hdr) {
if (len < 10) {
{
CamelMimeFilterGZipPrivate *priv;
- priv = CAMEL_MIME_FILTER_GZIP_GET_PRIVATE (object);
+ priv = CAMEL_MIME_FILTER_GZIP (object)->priv;
if (priv->mode == CAMEL_MIME_FILTER_GZIP_MODE_ZIP)
deflateEnd (priv->stream);
{
CamelMimeFilterGZipPrivate *priv;
- priv = CAMEL_MIME_FILTER_GZIP_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_GZIP (mime_filter)->priv;
if (priv->mode == CAMEL_MIME_FILTER_GZIP_MODE_ZIP)
gzip_filter (
{
CamelMimeFilterGZipPrivate *priv;
- priv = CAMEL_MIME_FILTER_GZIP_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_GZIP (mime_filter)->priv;
if (priv->mode == CAMEL_MIME_FILTER_GZIP_MODE_ZIP)
gzip_filter (
{
CamelMimeFilterGZipPrivate *priv;
- priv = CAMEL_MIME_FILTER_GZIP_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_GZIP (mime_filter)->priv;
memset (&priv->state, 0, sizeof (priv->state));
static void
camel_mime_filter_gzip_init (CamelMimeFilterGZip *mime_filter)
{
- mime_filter->priv = CAMEL_MIME_FILTER_GZIP_GET_PRIVATE (mime_filter);
+ mime_filter->priv = G_TYPE_INSTANCE_GET_PRIVATE (mime_filter, CAMEL_TYPE_MIME_FILTER_GZIP, CamelMimeFilterGZipPrivate);
mime_filter->priv->stream = g_new0 (z_stream, 1);
mime_filter->priv->crc32 = crc32 (0, Z_NULL, 0);
}
gint retval;
new = g_object_new (CAMEL_TYPE_MIME_FILTER_GZIP, NULL);
- priv = CAMEL_MIME_FILTER_GZIP_GET_PRIVATE (new);
+ priv = CAMEL_MIME_FILTER_GZIP (new)->priv;
priv->mode = mode;
priv->level = level;
#define d(x)
-#define CAMEL_MIME_FILTER_HTML_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_MIME_FILTER_HTML, CamelMimeFilterHTMLPrivate))
-
struct _CamelMimeFilterHTMLPrivate {
CamelHTMLParser *ctxt;
};
camel_html_parser_t state;
gchar *outp;
- priv = CAMEL_MIME_FILTER_HTML_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_HTML (mime_filter)->priv;
d(printf("converting html:\n%.*s\n", (gint)inlen, in));
{
CamelMimeFilterHTMLPrivate *priv;
- priv = CAMEL_MIME_FILTER_HTML_GET_PRIVATE (object);
+ priv = CAMEL_MIME_FILTER_HTML (object)->priv;
if (priv->ctxt != NULL) {
g_object_unref (priv->ctxt);
{
CamelMimeFilterHTMLPrivate *priv;
- priv = CAMEL_MIME_FILTER_HTML_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_HTML (mime_filter)->priv;
g_object_unref (priv->ctxt);
priv->ctxt = camel_html_parser_new ();
static void
camel_mime_filter_html_init (CamelMimeFilterHTML *mime_filter)
{
- mime_filter->priv = CAMEL_MIME_FILTER_HTML_GET_PRIVATE (mime_filter);
+ mime_filter->priv = G_TYPE_INSTANCE_GET_PRIVATE (mime_filter, CAMEL_TYPE_MIME_FILTER_HTML, CamelMimeFilterHTMLPrivate);
mime_filter->priv->ctxt = camel_html_parser_new ();
}
#include "camel-mime-filter-index.h"
#include "camel-text-index.h"
-#define CAMEL_MIME_FILTER_INDEX_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_MIME_FILTER_INDEX, CamelMimeFilterIndexPrivate))
-
struct _CamelMimeFilterIndexPrivate {
CamelIndex *index;
CamelIndexName *name;
{
CamelMimeFilterIndexPrivate *priv;
- priv = CAMEL_MIME_FILTER_INDEX_GET_PRIVATE (object);
+ priv = CAMEL_MIME_FILTER_INDEX (object)->priv;
if (priv->name != NULL) {
g_object_unref (priv->name);
{
CamelMimeFilterIndexPrivate *priv;
- priv = CAMEL_MIME_FILTER_INDEX_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_INDEX (mime_filter)->priv;
if (priv->index == NULL || priv->name==NULL) {
goto donothing;
{
CamelMimeFilterIndexPrivate *priv;
- priv = CAMEL_MIME_FILTER_INDEX_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_INDEX (mime_filter)->priv;
if (priv->index == NULL || priv->name==NULL) {
goto donothing;
static void
camel_mime_filter_index_init (CamelMimeFilterIndex *filter)
{
- filter->priv = CAMEL_MIME_FILTER_INDEX_GET_PRIVATE (filter);
+ filter->priv = G_TYPE_INSTANCE_GET_PRIVATE (filter, CAMEL_TYPE_MIME_FILTER_INDEX, CamelMimeFilterIndexPrivate);
}
/**
CamelMimeFilter *
camel_mime_filter_index_new (CamelIndex *index)
{
- CamelMimeFilter *new;
+ CamelMimeFilter *res;
CamelMimeFilterIndexPrivate *priv;
- new = g_object_new (CAMEL_TYPE_MIME_FILTER_INDEX, NULL);
+ res = g_object_new (CAMEL_TYPE_MIME_FILTER_INDEX, NULL);
- if (new) {
- priv = CAMEL_MIME_FILTER_INDEX_GET_PRIVATE (new);
- priv->index = index;
- if (index)
- g_object_ref (index);
- }
- return new;
+ priv = CAMEL_MIME_FILTER_INDEX (res)->priv;
+ priv->index = index;
+ if (index)
+ g_object_ref (index);
+
+ return res;
}
/* Set the match name for any indexed words */
#include "camel-mime-filter-linewrap.h"
-#define CAMEL_MIME_FILTER_LINEWRAP_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_MIME_FILTER_LINEWRAP, CamelMimeFilterLinewrapPrivate))
-
struct _CamelMimeFilterLinewrapPrivate {
guint wrap_len;
guint max_len;
const gchar *inend, *p;
gint nchars;
- priv = CAMEL_MIME_FILTER_LINEWRAP_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_LINEWRAP (mime_filter)->priv;
nchars = priv->nchars;
{
CamelMimeFilterLinewrapPrivate *priv;
- priv = CAMEL_MIME_FILTER_LINEWRAP_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_LINEWRAP (mime_filter)->priv;
priv->nchars = 0;
}
static void
camel_mime_filter_linewrap_init (CamelMimeFilterLinewrap *filter)
{
- filter->priv = CAMEL_MIME_FILTER_LINEWRAP_GET_PRIVATE (filter);
+ filter->priv = G_TYPE_INSTANCE_GET_PRIVATE (filter, CAMEL_TYPE_MIME_FILTER_LINEWRAP, CamelMimeFilterLinewrapPrivate);
}
CamelMimeFilter *
CamelMimeFilterLinewrapPrivate *priv;
filter = g_object_new (CAMEL_TYPE_MIME_FILTER_LINEWRAP, NULL);
- priv = CAMEL_MIME_FILTER_LINEWRAP_GET_PRIVATE (filter);
+ priv = CAMEL_MIME_FILTER_LINEWRAP (filter)->priv;
priv->indent = indent_char;
priv->wrap_len = preferred_len;
#include "camel-mime-filter-pgp.h"
-#define CAMEL_MIME_FILTER_PGP_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_MIME_FILTER_PGP, CamelMimeFilterPgpPrivate))
-
#define BEGIN_PGP_SIGNED_MESSAGE "-----BEGIN PGP SIGNED MESSAGE-----"
#define BEGIN_PGP_SIGNATURE "-----BEGIN PGP SIGNATURE-----"
#define END_PGP_SIGNATURE "-----END PGP SIGNATURE-----"
gboolean blank;
gsize len;
- priv = CAMEL_MIME_FILTER_PGP_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_PGP (mime_filter)->priv;
/* only need as much space as the input, we're stripping chars */
camel_mime_filter_set_size (mime_filter, inlen, FALSE);
{
CamelMimeFilterPgpPrivate *priv;
- priv = CAMEL_MIME_FILTER_PGP_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_PGP (mime_filter)->priv;
priv->state = PGP_PREFACE;
}
static void
camel_mime_filter_pgp_init (CamelMimeFilterPgp *filter)
{
- filter->priv = CAMEL_MIME_FILTER_PGP_GET_PRIVATE (filter);
+ filter->priv = G_TYPE_INSTANCE_GET_PRIVATE (filter, CAMEL_TYPE_MIME_FILTER_PGP, CamelMimeFilterPgpPrivate);
}
CamelMimeFilter *
#include "camel-mime-filter-progress.h"
#include "camel-operation.h"
-#define CAMEL_MIME_FILTER_PROGRESS_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_MIME_FILTER_PROGRESS, CamelMimeFilterProgressPrivate))
-
#define d(x)
#define w(x)
{
CamelMimeFilterProgressPrivate *priv;
- priv = CAMEL_MIME_FILTER_PROGRESS_GET_PRIVATE (object);
+ priv = CAMEL_MIME_FILTER_PROGRESS (object)->priv;
if (priv->cancellable != NULL) {
g_object_unref (priv->cancellable);
CamelMimeFilterProgressPrivate *priv;
gdouble percent;
- priv = CAMEL_MIME_FILTER_PROGRESS_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_PROGRESS (mime_filter)->priv;
priv->count += len;
if (priv->count < priv->total)
{
CamelMimeFilterProgressPrivate *priv;
- priv = CAMEL_MIME_FILTER_PROGRESS_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_PROGRESS (mime_filter)->priv;
priv->count = 0;
}
static void
camel_mime_filter_progress_init (CamelMimeFilterProgress *filter)
{
- filter->priv = CAMEL_MIME_FILTER_PROGRESS_GET_PRIVATE (filter);
+ filter->priv = G_TYPE_INSTANCE_GET_PRIVATE (filter, CAMEL_TYPE_MIME_FILTER_PROGRESS, CamelMimeFilterProgressPrivate);
}
/**
CamelMimeFilterProgressPrivate *priv;
filter = g_object_new (CAMEL_TYPE_MIME_FILTER_PROGRESS, NULL);
- priv = CAMEL_MIME_FILTER_PROGRESS_GET_PRIVATE (filter);
+ priv = CAMEL_MIME_FILTER_PROGRESS (filter)->priv;
if (CAMEL_IS_OPERATION (cancellable))
priv->cancellable = g_object_ref (cancellable);
#include "camel-mime-filter-save.h"
#include "camel-stream-mem.h"
-#define CAMEL_MIME_FILTER_SAVE_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_MIME_FILTER_SAVE, CamelMimeFilterSavePrivate))
-
struct _CamelMimeFilterSavePrivate {
CamelStream *stream;
};
{
CamelMimeFilterSavePrivate *priv;
- priv = CAMEL_MIME_FILTER_SAVE_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_SAVE (mime_filter)->priv;
if (priv->stream != NULL)
camel_stream_write (priv->stream, in, len, NULL, NULL);
static void
camel_mime_filter_save_init (CamelMimeFilterSave *filter)
{
- filter->priv = CAMEL_MIME_FILTER_SAVE_GET_PRIVATE (filter);
+ filter->priv = G_TYPE_INSTANCE_GET_PRIVATE (filter, CAMEL_TYPE_MIME_FILTER_SAVE, CamelMimeFilterSavePrivate);
}
/**
g_return_val_if_fail (CAMEL_IS_STREAM (stream), NULL);
filter = g_object_new (CAMEL_TYPE_MIME_FILTER_SAVE, NULL);
- priv = CAMEL_MIME_FILTER_SAVE_GET_PRIVATE (filter);
+ priv = CAMEL_MIME_FILTER_SAVE (filter)->priv;
if (stream != NULL)
priv->stream = g_object_ref (stream);
#include "camel-url-scanner.h"
#include "camel-utf8.h"
-#define CAMEL_MIME_FILTER_TOHTML_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_MIME_FILTER_TOHTML, CamelMimeFilterToHTMLPrivate))
-
struct _CamelMimeFilterToHTMLPrivate {
CamelUrlScanner *scanner;
CamelMimeFilterToHTMLPrivate *priv;
const guchar *inptr = in;
- priv = CAMEL_MIME_FILTER_TOHTML_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_TOHTML (mime_filter)->priv;
while (inptr < inend) {
guint32 u;
const gchar *inend;
gint depth;
- priv = CAMEL_MIME_FILTER_TOHTML_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_TOHTML (mime_filter)->priv;
if (inlen == 0) {
if (priv->pre_open) {
{
CamelMimeFilterToHTMLPrivate *priv;
- priv = CAMEL_MIME_FILTER_TOHTML_GET_PRIVATE (object);
+ priv = CAMEL_MIME_FILTER_TOHTML (object)->priv;
camel_url_scanner_free (priv->scanner);
{
CamelMimeFilterToHTMLPrivate *priv;
- priv = CAMEL_MIME_FILTER_TOHTML_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_TOHTML (mime_filter)->priv;
priv->column = 0;
priv->pre_open = FALSE;
static void
camel_mime_filter_tohtml_init (CamelMimeFilterToHTML *filter)
{
- filter->priv = CAMEL_MIME_FILTER_TOHTML_GET_PRIVATE (filter);
-
+ filter->priv = G_TYPE_INSTANCE_GET_PRIVATE (filter, CAMEL_TYPE_MIME_FILTER_TOHTML, CamelMimeFilterToHTMLPrivate);
filter->priv->scanner = camel_url_scanner_new ();
}
gint i;
filter = g_object_new (CAMEL_TYPE_MIME_FILTER_TOHTML, NULL);
- priv = CAMEL_MIME_FILTER_TOHTML_GET_PRIVATE (filter);
+ priv = CAMEL_MIME_FILTER_TOHTML (filter)->priv;
priv->flags = flags;
priv->color = color;
#include "camel-charset-map.h"
#include "camel-mime-filter-windows.h"
-#define CAMEL_MIME_FILTER_WINDOWS_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_MIME_FILTER_WINDOWS, CamelMimeFilterWindowsPrivate))
-
#define d(x)
#define w(x)
{
CamelMimeFilterWindowsPrivate *priv;
- priv = CAMEL_MIME_FILTER_WINDOWS_GET_PRIVATE (object);
+ priv = CAMEL_MIME_FILTER_WINDOWS (object)->priv;
g_free (priv->claimed_charset);
register guchar *inptr;
guchar *inend;
- priv = CAMEL_MIME_FILTER_WINDOWS_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_WINDOWS (mime_filter)->priv;
if (!priv->is_windows) {
inptr = (guchar *) in;
{
CamelMimeFilterWindowsPrivate *priv;
- priv = CAMEL_MIME_FILTER_WINDOWS_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_WINDOWS (mime_filter)->priv;
priv->is_windows = FALSE;
}
static void
camel_mime_filter_windows_init (CamelMimeFilterWindows *filter)
{
- filter->priv = CAMEL_MIME_FILTER_WINDOWS_GET_PRIVATE (filter);
+ filter->priv = G_TYPE_INSTANCE_GET_PRIVATE (filter, CAMEL_TYPE_MIME_FILTER_WINDOWS, CamelMimeFilterWindowsPrivate);
}
/**
g_return_val_if_fail (claimed_charset != NULL, NULL);
filter = g_object_new (CAMEL_TYPE_MIME_FILTER_WINDOWS, NULL);
- priv = CAMEL_MIME_FILTER_WINDOWS_GET_PRIVATE (filter);
+ priv = CAMEL_MIME_FILTER_WINDOWS (filter)->priv;
priv->claimed_charset = g_strdup (claimed_charset);
#include "camel-mime-filter-yenc.h"
-#define CAMEL_MIME_FILTER_YENC_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_MIME_FILTER_YENC, CamelMimeFilterYencPrivate))
-
struct _CamelMimeFilterYencPrivate {
CamelMimeFilterYencDirection direction;
CamelMimeFilterYencPrivate *priv;
gsize newlen = 0;
- priv = CAMEL_MIME_FILTER_YENC_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_YENC (mime_filter)->priv;
switch (priv->direction) {
case CAMEL_MIME_FILTER_YENC_DIRECTION_ENCODE:
CamelMimeFilterYencPrivate *priv;
gsize newlen = 0;
- priv = CAMEL_MIME_FILTER_YENC_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_YENC (mime_filter)->priv;
switch (priv->direction) {
case CAMEL_MIME_FILTER_YENC_DIRECTION_ENCODE:
{
CamelMimeFilterYencPrivate *priv;
- priv = CAMEL_MIME_FILTER_YENC_GET_PRIVATE (mime_filter);
+ priv = CAMEL_MIME_FILTER_YENC (mime_filter)->priv;
switch (priv->direction) {
case CAMEL_MIME_FILTER_YENC_DIRECTION_ENCODE:
static void
camel_mime_filter_yenc_init (CamelMimeFilterYenc *filter)
{
- filter->priv = CAMEL_MIME_FILTER_YENC_GET_PRIVATE (filter);
+ filter->priv = G_TYPE_INSTANCE_GET_PRIVATE (filter, CAMEL_TYPE_MIME_FILTER_YENC, CamelMimeFilterYencPrivate);
filter->priv->part = 0;
filter->priv->pcrc = CAMEL_MIME_YENCODE_CRC_INIT;
CamelMimeFilterYencPrivate *priv;
filter = g_object_new (CAMEL_TYPE_MIME_FILTER_YENC, NULL);
- priv = CAMEL_MIME_FILTER_YENC_GET_PRIVATE (filter);
+ priv = CAMEL_MIME_FILTER_YENC (filter)->priv;
priv->direction = direction;
#include <mcheck.h>
#endif
-#define CAMEL_MIME_FILTER_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_MIME_FILTER, CamelMimeFilterPrivate))
-
struct _CamelMimeFilterPrivate {
gchar *inbuf;
gsize inlen;
static void
camel_mime_filter_init (CamelMimeFilter *mime_filter)
{
- mime_filter->priv = CAMEL_MIME_FILTER_GET_PRIVATE (mime_filter);
+ mime_filter->priv = G_TYPE_INSTANCE_GET_PRIVATE (mime_filter, CAMEL_TYPE_MIME_FILTER, CamelMimeFilterPrivate);
mime_filter->outreal = NULL;
mime_filter->outbuf = NULL;
struct _CamelMimeFilterPrivate *p;
gint newlen;
- p = CAMEL_MIME_FILTER_GET_PRIVATE (f);
+ p = f->priv;
newlen = len + prespace + f->backlen;
if (p->inlen < newlen) {
#define d(x) /*(printf("%s(%d): ", __FILE__, __LINE__),(x))*/
-#define CAMEL_MIME_PART_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_MIME_PART, CamelMimePartPrivate))
-
typedef struct _AsyncContext AsyncContext;
struct _CamelMimePartPrivate {
{
CamelMimePartPrivate *priv;
- priv = CAMEL_MIME_PART_GET_PRIVATE (object);
+ priv = CAMEL_MIME_PART (object)->priv;
g_free (priv->description);
g_free (priv->content_id);
{
CamelDataWrapper *data_wrapper;
- mime_part->priv = CAMEL_MIME_PART_GET_PRIVATE (mime_part);
+ mime_part->priv = G_TYPE_INSTANCE_GET_PRIVATE (mime_part, CAMEL_TYPE_MIME_PART, CamelMimePartPrivate);
mime_part->priv->encoding = CAMEL_TRANSFER_ENCODING_DEFAULT;
data_wrapper = CAMEL_DATA_WRAPPER (mime_part);
#define d(x)
-#define CAMEL_OBJECT_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_OBJECT, CamelObjectPrivate))
-
struct _CamelObjectPrivate {
gchar *state_filename;
};
{
CamelObjectPrivate *priv;
- priv = CAMEL_OBJECT_GET_PRIVATE (object);
+ priv = CAMEL_OBJECT (object)->priv;
g_free (priv->state_filename);
static void
camel_object_init (CamelObject *object)
{
- object->priv = CAMEL_OBJECT_GET_PRIVATE (object);
+ object->priv = G_TYPE_INSTANCE_GET_PRIVATE (object, CAMEL_TYPE_OBJECT, CamelObjectPrivate);
}
GQuark
#include "camel-session.h"
#include "camel-store.h"
-#define CAMEL_OFFLINE_FOLDER_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_OFFLINE_FOLDER, CamelOfflineFolderPrivate))
-
typedef struct _AsyncContext AsyncContext;
struct _CamelOfflineFolderPrivate {
static void
camel_offline_folder_init (CamelOfflineFolder *folder)
{
- folder->priv = CAMEL_OFFLINE_FOLDER_GET_PRIVATE (folder);
+ folder->priv = G_TYPE_INSTANCE_GET_PRIVATE (folder, CAMEL_TYPE_OFFLINE_FOLDER, CamelOfflineFolderPrivate);
g_signal_connect (
folder, "changed",
#include "camel-offline-store.h"
#include "camel-session.h"
-#define CAMEL_OFFLINE_STORE_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_OFFLINE_STORE, CamelOfflineStorePrivate))
-
struct _CamelOfflineStorePrivate {
gboolean online;
};
static void
camel_offline_store_init (CamelOfflineStore *store)
{
- store->priv = CAMEL_OFFLINE_STORE_GET_PRIVATE (store);
+ store->priv = G_TYPE_INSTANCE_GET_PRIVATE (store, CAMEL_TYPE_OFFLINE_STORE, CamelOfflineStorePrivate);
store->priv->online = TRUE;
}
#include "camel-msgport.h"
#include "camel-operation.h"
-#define CAMEL_OPERATION_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_OPERATION, CamelOperationPrivate))
-
#define PROGRESS_DELAY 250 /* milliseconds */
#define TRANSIENT_DELAY 250 /* milliseconds */
#define POP_MESSAGE_DELAY 999 /* milliseconds */
{
CamelOperationPrivate *priv;
- priv = CAMEL_OPERATION_GET_PRIVATE (object);
+ priv = CAMEL_OPERATION (object)->priv;
LOCK ();
static void
camel_operation_init (CamelOperation *operation)
{
- operation->priv = CAMEL_OPERATION_GET_PRIVATE (operation);
+ operation->priv = G_TYPE_INSTANCE_GET_PRIVATE (operation, CAMEL_TYPE_OPERATION, CamelOperationPrivate);
g_queue_init (&operation->priv->status_stack);
operation->priv->cancel_port = camel_msgport_new ();
#define CAMEL_PARTITION_TABLE_LOCK(kf, lock) (g_static_mutex_lock(&(kf)->priv->lock))
#define CAMEL_PARTITION_TABLE_UNLOCK(kf, lock) (g_static_mutex_unlock(&(kf)->priv->lock))
-#define CAMEL_PARTITION_TABLE_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_PARTITION_TABLE, CamelPartitionTablePrivate))
-
struct _CamelPartitionTablePrivate {
GStaticMutex lock; /* for locking partition */
};
static void
camel_partition_table_init (CamelPartitionTable *cpi)
{
- cpi->priv = CAMEL_PARTITION_TABLE_GET_PRIVATE (cpi);
+ cpi->priv = G_TYPE_INSTANCE_GET_PRIVATE (cpi, CAMEL_TYPE_PARTITION_TABLE, CamelPartitionTablePrivate);
camel_dlist_init (&cpi->partition);
g_static_mutex_init (&cpi->priv->lock);
/* ********************************************************************** */
-#define CAMEL_KEY_TABLE_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_KEY_TABLE, CamelKeyTablePrivate))
-
#define CAMEL_KEY_TABLE_LOCK(kf, lock) (g_static_mutex_lock(&(kf)->priv->lock))
#define CAMEL_KEY_TABLE_UNLOCK(kf, lock) (g_static_mutex_unlock(&(kf)->priv->lock))
static void
camel_key_table_init (CamelKeyTable *table)
{
- table->priv = CAMEL_KEY_TABLE_GET_PRIVATE (table);
+ table->priv = G_TYPE_INSTANCE_GET_PRIVATE (table, CAMEL_TYPE_KEY_TABLE, CamelKeyTablePrivate);
g_static_mutex_init (&table->priv->lock);
}
#include "camel-sasl-cram-md5.h"
#include "camel-service.h"
-#define CAMEL_SASL_CRAM_MD5_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_SASL_CRAM_MD5, CamelSaslCramMd5Private))
-
struct _CamelSaslCramMd5Private {
gint placeholder; /* allow for future expansion */
};
static void
camel_sasl_cram_md5_init (CamelSaslCramMd5 *sasl)
{
- sasl->priv = CAMEL_SASL_CRAM_MD5_GET_PRIVATE (sasl);
+ sasl->priv = G_TYPE_INSTANCE_GET_PRIVATE (sasl, CAMEL_TYPE_SASL_CRAM_MD5, CamelSaslCramMd5Private);
}
#define PARANOID(x) x
-#define CAMEL_SASL_DIGEST_MD5_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_SASL_DIGEST_MD5, CamelSaslDigestMd5Private))
-
/* Implements rfc2831 */
CamelServiceAuthType camel_sasl_digest_md5_authtype = {
static void
camel_sasl_digest_md5_init (CamelSaslDigestMd5 *sasl)
{
- sasl->priv = CAMEL_SASL_DIGEST_MD5_GET_PRIVATE (sasl);
+ sasl->priv = G_TYPE_INSTANCE_GET_PRIVATE (sasl, CAMEL_TYPE_SASL_DIGEST_MD5, CamelSaslDigestMd5Private);
}
#define DBUS_INTERFACE "org.gnome.KrbAuthDialog"
#define DBUS_METHOD "org.gnome.KrbAuthDialog.acquireTgt"
-#define CAMEL_SASL_GSSAPI_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_SASL_GSSAPI, CamelSaslGssapiPrivate))
-
CamelServiceAuthType camel_sasl_gssapi_authtype = {
N_("GSSAPI"),
struct addrinfo *ai, hints;
const gchar *service_name;
- priv = CAMEL_SASL_GSSAPI_GET_PRIVATE (sasl);
+ priv = CAMEL_SASL_GSSAPI (sasl)->priv;
service = camel_sasl_get_service (sasl);
service_name = camel_sasl_get_service_name (sasl);
camel_sasl_gssapi_init (CamelSaslGssapi *sasl)
{
#ifdef HAVE_KRB5
- sasl->priv = CAMEL_SASL_GSSAPI_GET_PRIVATE (sasl);
-
+ sasl->priv = G_TYPE_INSTANCE_GET_PRIVATE (sasl, CAMEL_TYPE_SASL_GSSAPI, CamelSaslGssapiPrivate);
sasl->priv->state = GSSAPI_STATE_INIT;
sasl->priv->ctx = GSS_C_NO_CONTEXT;
sasl->priv->target = GSS_C_NO_NAME;
#include "camel-sasl-login.h"
#include "camel-service.h"
-#define CAMEL_SASL_LOGIN_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_SASL_LOGIN, CamelSaslLoginPrivate))
-
CamelServiceAuthType camel_sasl_login_authtype = {
N_("Login"),
CamelService *service;
CamelURL *url;
- priv = CAMEL_SASL_LOGIN_GET_PRIVATE (sasl);
+ priv = CAMEL_SASL_LOGIN (sasl)->priv;
service = camel_sasl_get_service (sasl);
url = service->url;
static void
camel_sasl_login_init (CamelSaslLogin *sasl)
{
- sasl->priv = CAMEL_SASL_LOGIN_GET_PRIVATE (sasl);
+ sasl->priv = G_TYPE_INSTANCE_GET_PRIVATE (sasl, CAMEL_TYPE_SASL_LOGIN, CamelSaslLoginPrivate);
}
#include "camel-sasl-ntlm.h"
-#define CAMEL_SASL_NTLM_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_SASL_NTLM, CamelSaslNTLMPrivate))
-
struct _CamelSaslNTLMPrivate {
gint placeholder; /* allow for future expansion */
};
static void
camel_sasl_ntlm_init (CamelSaslNTLM *sasl)
{
- sasl->priv = CAMEL_SASL_NTLM_GET_PRIVATE (sasl);
+ sasl->priv = G_TYPE_INSTANCE_GET_PRIVATE (sasl, CAMEL_TYPE_SASL_NTLM, CamelSaslNTLMPrivate);
}
#include "camel-sasl-plain.h"
#include "camel-service.h"
-#define CAMEL_SASL_PLAIN_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_SASL_PLAIN, CamelSaslPlainPrivate))
-
struct _CamelSaslPlainPrivate {
gint placeholder; /* allow for future expansion */
};
static void
camel_sasl_plain_init (CamelSaslPlain *sasl)
{
- sasl->priv = CAMEL_SASL_PLAIN_GET_PRIVATE (sasl);
+ sasl->priv = G_TYPE_INSTANCE_GET_PRIVATE (sasl, CAMEL_TYPE_SASL_PLAIN, CamelSaslPlainPrivate);
}
#include "camel-session.h"
#include "camel-store.h"
-#define CAMEL_SASL_POPB4SMTP_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_SASL_POPB4SMTP, CamelSaslPOPB4SMTPPrivate))
-
struct _CamelSaslPOPB4SMTPPrivate {
gint placeholder; /* allow for future expansion */
};
static void
camel_sasl_popb4smtp_init (CamelSaslPOPB4SMTP *sasl)
{
- sasl->priv = CAMEL_SASL_POPB4SMTP_GET_PRIVATE (sasl);
+ sasl->priv = G_TYPE_INSTANCE_GET_PRIVATE (sasl, CAMEL_TYPE_SASL_POPB4SMTP, CamelSaslPOPB4SMTPPrivate);
}
#define w(x)
-#define CAMEL_SASL_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_SASL, CamelSaslPrivate))
-
typedef struct _AsyncContext AsyncContext;
struct _CamelSaslPrivate {
{
CamelSaslPrivate *priv;
- priv = CAMEL_SASL_GET_PRIVATE (object);
+ priv = CAMEL_SASL (object)->priv;
if (priv->service != NULL) {
g_object_unref (priv->service);
{
CamelSaslPrivate *priv;
- priv = CAMEL_SASL_GET_PRIVATE (object);
+ priv = CAMEL_SASL (object)->priv;
g_free (priv->mechanism);
g_free (priv->service_name);
static void
camel_sasl_init (CamelSasl *sasl)
{
- sasl->priv = CAMEL_SASL_GET_PRIVATE (sasl);
+ sasl->priv = G_TYPE_INSTANCE_GET_PRIVATE (sasl, CAMEL_TYPE_SASL, CamelSaslPrivate);
}
/**
#define d(x)
#define w(x)
-#define CAMEL_SERVICE_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_SERVICE, CamelServicePrivate))
-
struct _CamelServicePrivate {
GStaticRecMutex connect_lock; /* for locking connection operations */
GStaticMutex connect_op_lock; /* for locking the connection_op */
static void
camel_service_init (CamelService *service)
{
- service->priv = CAMEL_SERVICE_GET_PRIVATE (service);
+ service->priv = G_TYPE_INSTANCE_GET_PRIVATE (service, CAMEL_TYPE_SERVICE, CamelServicePrivate);
g_static_rec_mutex_init (&service->priv->connect_lock);
g_static_mutex_init (&service->priv->connect_op_lock);
#define d(x)
-#define CAMEL_SESSION_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_SESSION, CamelSessionPrivate))
-
struct _CamelSessionPrivate {
GMutex *lock; /* for locking everything basically */
GMutex *thread_lock; /* locking threads */
static void
camel_session_init (CamelSession *session)
{
- session->priv = CAMEL_SESSION_GET_PRIVATE (session);
-
+ session->priv = G_TYPE_INSTANCE_GET_PRIVATE (session, CAMEL_TYPE_SESSION, CamelSessionPrivate);
session->priv->lock = g_mutex_new ();
session->priv->thread_lock = g_mutex_new ();
session->priv->thread_id = 1;
#define d(x)
-#define CAMEL_SMIME_CONTEXT_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_SMIME_CONTEXT, CamelSMIMEContextPrivate))
-
struct _CamelSMIMEContextPrivate {
CERTCertDBHandle *certdb;
static void
camel_smime_context_init (CamelSMIMEContext *smime_context)
{
- smime_context->priv = CAMEL_SMIME_CONTEXT_GET_PRIVATE (smime_context);
-
+ smime_context->priv = G_TYPE_INSTANCE_GET_PRIVATE (smime_context, CAMEL_TYPE_SMIME_CONTEXT, CamelSMIMEContextPrivate);
smime_context->priv->certdb = CERT_GetDefaultCertDB ();
smime_context->priv->sign_mode = CAMEL_SMIME_SIGN_CLEARSIGN;
smime_context->priv->password_tries = 0;
/* current version */
#define CAMEL_STORE_SUMMARY_VERSION (2)
-#define CAMEL_STORE_SUMMARY_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_STORE_SUMMARY, CamelStoreSummaryPrivate))
-
struct _CamelStoreSummaryPrivate {
GMutex *summary_lock; /* for the summary hashtable/array */
GMutex *io_lock; /* load/save lock, for access to saved_count, etc */
static void
camel_store_summary_init (CamelStoreSummary *summary)
{
- summary->priv = CAMEL_STORE_SUMMARY_GET_PRIVATE (summary);
-
+ summary->priv = G_TYPE_INSTANCE_GET_PRIVATE (summary, CAMEL_TYPE_STORE_SUMMARY, CamelStoreSummaryPrivate);
summary->store_info_size = sizeof (CamelStoreInfo);
summary->store_info_chunks = NULL;
#define d(x)
#define w(x)
-#define CAMEL_STORE_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_STORE, CamelStorePrivate))
-
typedef struct _AsyncContext AsyncContext;
typedef struct _SignalData SignalData;
static void
camel_store_init (CamelStore *store)
{
- store->priv = CAMEL_STORE_GET_PRIVATE (store);
+ store->priv = G_TYPE_INSTANCE_GET_PRIVATE (store, CAMEL_TYPE_STORE, CamelStorePrivate);
/* set vtrash and vjunk on by default */
store->flags = CAMEL_STORE_VTRASH | CAMEL_STORE_VJUNK;
#include "camel-stream-buffer.h"
-#define CAMEL_STREAM_BUFFER_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_STREAM_BUFFER, CamelStreamBufferPrivate))
-
struct _CamelStreamBufferPrivate {
CamelStream *stream;
{
CamelStreamBufferPrivate *priv;
- priv = CAMEL_STREAM_BUFFER_GET_PRIVATE (stream);
+ priv = CAMEL_STREAM_BUFFER (stream)->priv;
if (priv->buf && !(priv->flags & BUF_USER))
g_free (priv->buf);
{
CamelStreamBufferPrivate *priv;
- priv = CAMEL_STREAM_BUFFER_GET_PRIVATE (object);
+ priv = CAMEL_STREAM_BUFFER (object)->priv;
if (priv->stream != NULL) {
g_object_unref (priv->stream);
{
CamelStreamBufferPrivate *priv;
- priv = CAMEL_STREAM_BUFFER_GET_PRIVATE (object);
+ priv = CAMEL_STREAM_BUFFER (object)->priv;
if (!(priv->flags & BUF_USER))
g_free (priv->buf);
gchar *bptr = buffer;
GError *local_error = NULL;
- priv = CAMEL_STREAM_BUFFER_GET_PRIVATE (stream);
+ priv = CAMEL_STREAM_BUFFER (stream)->priv;
g_return_val_if_fail (
(priv->mode & CAMEL_STREAM_BUFFER_MODE) ==
gssize total = n;
gssize left, todo;
- priv = CAMEL_STREAM_BUFFER_GET_PRIVATE (stream);
+ priv = CAMEL_STREAM_BUFFER (stream)->priv;
g_return_val_if_fail (
(priv->mode & CAMEL_STREAM_BUFFER_MODE) ==
{
CamelStreamBufferPrivate *priv;
- priv = CAMEL_STREAM_BUFFER_GET_PRIVATE (stream);
+ priv = CAMEL_STREAM_BUFFER (stream)->priv;
if ((priv->mode & CAMEL_STREAM_BUFFER_MODE) == CAMEL_STREAM_BUFFER_WRITE) {
gsize len = priv->ptr - priv->buf;
{
CamelStreamBufferPrivate *priv;
- priv = CAMEL_STREAM_BUFFER_GET_PRIVATE (stream);
+ priv = CAMEL_STREAM_BUFFER (stream)->priv;
if (stream_buffer_flush (stream, cancellable, error) == -1)
return -1;
{
CamelStreamBufferPrivate *priv;
- priv = CAMEL_STREAM_BUFFER_GET_PRIVATE (stream);
+ priv = CAMEL_STREAM_BUFFER (stream)->priv;
return camel_stream_eos (priv->stream) && priv->ptr == priv->end;
}
{
CamelStreamBufferPrivate *priv;
- priv = CAMEL_STREAM_BUFFER_GET_PRIVATE (stream);
+ priv = CAMEL_STREAM_BUFFER (stream)->priv;
set_vbuf (stream, buf, mode, size);
static void
camel_stream_buffer_init (CamelStreamBuffer *stream)
{
- stream->priv = CAMEL_STREAM_BUFFER_GET_PRIVATE (stream);
-
+ stream->priv = G_TYPE_INSTANCE_GET_PRIVATE (stream, CAMEL_TYPE_STREAM_BUFFER, CamelStreamBufferPrivate);
stream->priv->flags = 0;
stream->priv->size = BUF_SIZE;
stream->priv->buf = g_malloc (BUF_SIZE);
/*extern void g_check(gpointer mp);*/
#define g_check(x)
-#define CAMEL_STREAM_FILTER_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_STREAM_FILTER, CamelStreamFilterPrivate))
-
struct _filter {
struct _filter *next;
gint id;
gssize size;
struct _filter *f;
- priv = CAMEL_STREAM_FILTER_GET_PRIVATE (stream);
+ priv = CAMEL_STREAM_FILTER (stream)->priv;
priv->last_was_read = TRUE;
gsize presize, len, left = n;
gchar *buffer, realbuffer[READ_SIZE+READ_PAD];
- priv = CAMEL_STREAM_FILTER_GET_PRIVATE (stream);
+ priv = CAMEL_STREAM_FILTER (stream)->priv;
priv->last_was_read = FALSE;
gsize presize;
gsize len;
- priv = CAMEL_STREAM_FILTER_GET_PRIVATE (stream);
+ priv = CAMEL_STREAM_FILTER (stream)->priv;
if (priv->last_was_read)
return 0;
{
CamelStreamFilterPrivate *priv;
- priv = CAMEL_STREAM_FILTER_GET_PRIVATE (stream);
+ priv = CAMEL_STREAM_FILTER (stream)->priv;
/* Ignore errors while flushing. */
if (!priv->last_was_read)
{
CamelStreamFilterPrivate *priv;
- priv = CAMEL_STREAM_FILTER_GET_PRIVATE (stream);
+ priv = CAMEL_STREAM_FILTER (stream)->priv;
if (priv->filteredlen > 0)
return FALSE;
CamelStreamFilterPrivate *priv;
struct _filter *f;
- priv = CAMEL_STREAM_FILTER_GET_PRIVATE (stream);
+ priv = CAMEL_STREAM_FILTER (stream)->priv;
priv->filteredlen = 0;
priv->flushed = FALSE;
static void
camel_stream_filter_init (CamelStreamFilter *stream)
{
- stream->priv = CAMEL_STREAM_FILTER_GET_PRIVATE (stream);
-
+ stream->priv = G_TYPE_INSTANCE_GET_PRIVATE (stream, CAMEL_TYPE_STREAM_FILTER, CamelStreamFilterPrivate);
stream->priv->realbuffer = g_malloc (READ_SIZE + READ_PAD);
stream->priv->buffer = stream->priv->realbuffer + READ_PAD;
stream->priv->last_was_read = TRUE;
g_return_val_if_fail (CAMEL_IS_STREAM (source), NULL);
stream = g_object_new (CAMEL_TYPE_STREAM_FILTER, NULL);
- priv = CAMEL_STREAM_FILTER_GET_PRIVATE (stream);
+ priv = CAMEL_STREAM_FILTER (stream)->priv;
priv->source = g_object_ref (source);
g_return_val_if_fail (CAMEL_IS_STREAM_FILTER (stream), -1);
g_return_val_if_fail (CAMEL_IS_MIME_FILTER (filter), -1);
- priv = CAMEL_STREAM_FILTER_GET_PRIVATE (stream);
+ priv = stream->priv;
fn = g_malloc (sizeof (*fn));
fn->id = priv->filterid++;
g_return_if_fail (CAMEL_IS_STREAM_FILTER (stream));
- priv = CAMEL_STREAM_FILTER_GET_PRIVATE (stream);
+ priv = stream->priv;
f = (struct _filter *)&priv->filters;
while (f && f->next) {
#include "camel-stream-fs.h"
#include "camel-win32.h"
-#define CAMEL_STREAM_FS_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_STREAM_FS, CamelStreamFsPrivate))
-
struct _CamelStreamFsPrivate {
gint fd; /* file descriptor on the underlying file */
};
{
CamelStreamFsPrivate *priv;
- priv = CAMEL_STREAM_FS_GET_PRIVATE (object);
+ priv = CAMEL_STREAM_FS (object)->priv;
if (priv->fd != -1)
close (priv->fd);
CamelStreamFsPrivate *priv;
gssize nread;
- priv = CAMEL_STREAM_FS_GET_PRIVATE (stream);
+ priv = CAMEL_STREAM_FS (stream)->priv;
nread = camel_read (priv->fd, buffer, n, cancellable, error);
{
CamelStreamFsPrivate *priv;
- priv = CAMEL_STREAM_FS_GET_PRIVATE (stream);
+ priv = CAMEL_STREAM_FS (stream)->priv;
return camel_write (priv->fd, buffer, n, cancellable, error);
}
{
CamelStreamFsPrivate *priv;
- priv = CAMEL_STREAM_FS_GET_PRIVATE (stream);
+ priv = CAMEL_STREAM_FS (stream)->priv;
if (g_cancellable_set_error_if_cancelled (cancellable, error))
return -1;
{
CamelStreamFsPrivate *priv;
- priv = CAMEL_STREAM_FS_GET_PRIVATE (stream);
+ priv = CAMEL_STREAM_FS (stream)->priv;
if (g_cancellable_set_error_if_cancelled (cancellable, error))
return -1;
{
CamelStreamFsPrivate *priv;
- priv = CAMEL_STREAM_FS_GET_PRIVATE (seekable);
+ priv = CAMEL_STREAM_FS (seekable)->priv;
return (goffset) lseek (priv->fd, 0, SEEK_CUR);
}
CamelStreamFsPrivate *priv;
goffset real = 0;
- priv = CAMEL_STREAM_FS_GET_PRIVATE (seekable);
+ priv = CAMEL_STREAM_FS (seekable)->priv;
switch (type) {
case G_SEEK_SET:
static void
camel_stream_fs_init (CamelStreamFs *stream)
{
- stream->priv = CAMEL_STREAM_FS_GET_PRIVATE (stream);
+ stream->priv = G_TYPE_INSTANCE_GET_PRIVATE (stream, CAMEL_TYPE_STREAM_FS, CamelStreamFsPrivate);
stream->priv->fd = -1;
}
return NULL;
stream = g_object_new (CAMEL_TYPE_STREAM_FS, NULL);
- priv = CAMEL_STREAM_FS_GET_PRIVATE (stream);
+ priv = CAMEL_STREAM_FS (stream)->priv;
priv->fd = fd;
#include "camel-stream-mem.h"
-#define CAMEL_STREAM_MEM_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_STREAM_MEM, CamelStreamMemPrivate))
-
struct _CamelStreamMemPrivate {
guint owner : 1; /* do we own the buffer? */
guint secure : 1; /* do we clear the buffer on finalize?
{
CamelStreamMemPrivate *priv;
- priv = CAMEL_STREAM_MEM_GET_PRIVATE (object);
+ priv = CAMEL_STREAM_MEM (object)->priv;
if (priv->buffer && priv->owner) {
/* TODO: we need our own bytearray type since we don't know
CamelStreamMemPrivate *priv;
gssize nread;
- priv = CAMEL_STREAM_MEM_GET_PRIVATE (stream);
+ priv = CAMEL_STREAM_MEM (stream)->priv;
nread = MIN (n, priv->buffer->len - priv->position);
if (nread > 0) {
CamelStreamMemPrivate *priv;
gssize nwrite = n;
- priv = CAMEL_STREAM_MEM_GET_PRIVATE (stream);
+ priv = CAMEL_STREAM_MEM (stream)->priv;
/* FIXME: we shouldn't use g_byte_arrays or g_malloc perhaps? */
if (priv->position == priv->buffer->len) {
{
CamelStreamMemPrivate *priv;
- priv = CAMEL_STREAM_MEM_GET_PRIVATE (stream);
+ priv = CAMEL_STREAM_MEM (stream)->priv;
return priv->buffer->len <= priv->position;
}
{
CamelStreamMemPrivate *priv;
- priv = CAMEL_STREAM_MEM_GET_PRIVATE (seekable);
+ priv = CAMEL_STREAM_MEM (seekable)->priv;
return priv->position;
}
CamelStreamMemPrivate *priv;
goffset position;
- priv = CAMEL_STREAM_MEM_GET_PRIVATE (seekable);
+ priv = CAMEL_STREAM_MEM (seekable)->priv;
switch (type) {
case G_SEEK_SET:
static void
camel_stream_mem_init (CamelStreamMem *stream)
{
- stream->priv = CAMEL_STREAM_MEM_GET_PRIVATE (stream);
+ stream->priv = G_TYPE_INSTANCE_GET_PRIVATE (stream, CAMEL_TYPE_STREAM_MEM, CamelStreamMemPrivate);
}
/**
g_return_val_if_fail (buffer != NULL, NULL);
stream = g_object_new (CAMEL_TYPE_STREAM_MEM, NULL);
- priv = CAMEL_STREAM_MEM_GET_PRIVATE (stream);
+ priv = CAMEL_STREAM_MEM (stream)->priv;
priv->buffer = buffer;
priv->owner = TRUE;
priv->sockfd = new_file_desc;
}
-#define CAMEL_TCP_STREAM_RAW_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_TCP_STREAM_RAW, CamelTcpStreamRawPrivate))
-
static void
camel_tcp_stream_raw_class_init (CamelTcpStreamRawClass *class)
{
{
CamelTcpStreamRawPrivate *priv;
- stream->priv = CAMEL_TCP_STREAM_RAW_GET_PRIVATE (stream);
+ stream->priv = G_TYPE_INSTANCE_GET_PRIVATE (stream, CAMEL_TYPE_TCP_STREAM_RAW, CamelTcpStreamRawPrivate);
priv = stream->priv;
priv->sockfd = NULL;
#define IO_TIMEOUT (PR_TicksPerSecond() * 4 * 60)
#define CONNECT_TIMEOUT (PR_TicksPerSecond () * 4 * 60)
-#define CAMEL_TCP_STREAM_SSL_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_TCP_STREAM_SSL, CamelTcpStreamSSLPrivate))
-
struct _CamelTcpStreamSSLPrivate {
CamelSession *session;
gchar *expected_host;
{
CamelTcpStreamSSLPrivate *priv;
- priv = CAMEL_TCP_STREAM_SSL_GET_PRIVATE (object);
+ priv = CAMEL_TCP_STREAM_SSL (object)->priv;
if (priv->session != NULL) {
g_object_unref (priv->session);
{
CamelTcpStreamSSLPrivate *priv;
- priv = CAMEL_TCP_STREAM_SSL_GET_PRIVATE (object);
+ priv = CAMEL_TCP_STREAM_SSL (object)->priv;
g_free (priv->expected_host);
static void
camel_tcp_stream_ssl_init (CamelTcpStreamSSL *stream)
{
- stream->priv = CAMEL_TCP_STREAM_SSL_GET_PRIVATE (stream);
+ stream->priv = G_TYPE_INSTANCE_GET_PRIVATE (stream, CAMEL_TYPE_TCP_STREAM_SSL, CamelTcpStreamSSLPrivate);
}
/**
#define w(x)
-#define CAMEL_TCP_STREAM_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_TCP_STREAM, CamelTcpStreamPrivate))
-
struct _CamelTcpStreamPrivate {
gchar *socks_host;
gint socks_port;
static void
camel_tcp_stream_init (CamelTcpStream *tcp_stream)
{
- tcp_stream->priv = CAMEL_TCP_STREAM_GET_PRIVATE (tcp_stream);
+ tcp_stream->priv = G_TYPE_INSTANCE_GET_PRIVATE (tcp_stream, CAMEL_TYPE_TCP_STREAM, CamelTcpStreamPrivate);
}
/**
/* ********************************************************************** */
-#define CAMEL_TEXT_INDEX_NAME_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_TEXT_INDEX_NAME, CamelTextIndexNamePrivate))
-
struct _CamelTextIndexNamePrivate {
GString *buffer;
camel_key_t nameid;
/* ****************************** */
-#define CAMEL_TEXT_INDEX_CURSOR_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_TEXT_INDEX_CURSOR, CamelTextIndexCursorPrivate))
-
struct _CamelTextIndexCursorPrivate {
camel_block_t first;
camel_block_t next;
/* ****************************** */
-#define CAMEL_TEXT_INDEX_KEY_CURSOR_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_TEXT_INDEX_KEY_CURSOR, CamelTextIndexKeyCursorPrivate))
-
struct _CamelTextIndexKeyCursorPrivate {
CamelKeyTable *table;
#define CAMEL_TEXT_INDEX_VERSION "TEXT.000"
#define CAMEL_TEXT_INDEX_KEY_VERSION "KEYS.000"
-#define CAMEL_TEXT_INDEX_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_TEXT_INDEX, CamelTextIndexPrivate))
-
struct _CamelTextIndexPrivate {
CamelBlockFile *blocks;
CamelKeyFile *links;
{
CamelTextIndexPrivate *priv;
- priv = CAMEL_TEXT_INDEX_GET_PRIVATE (object);
+ priv = CAMEL_TEXT_INDEX (object)->priv;
/* Only run this the first time. */
if (priv->word_index != NULL)
{
CamelTextIndexPrivate *priv;
- priv = CAMEL_TEXT_INDEX_GET_PRIVATE (object);
+ priv = CAMEL_TEXT_INDEX (object)->priv;
g_assert (camel_dlist_empty (&priv->word_cache));
g_assert (g_hash_table_size (priv->words) == 0);
camel_key_t nameid)
{
struct _CamelTextIndexWord *w, *wp, *ww;
- CamelTextIndexPrivate *p = CAMEL_TEXT_INDEX_GET_PRIVATE (idx);
+ CamelTextIndexPrivate *p = CAMEL_TEXT_INDEX (idx)->priv;
camel_key_t wordid;
camel_block_t data;
struct _CamelTextIndexRoot *rb = (struct _CamelTextIndexRoot *)p->blocks->root;
static gint
text_index_sync (CamelIndex *idx)
{
- CamelTextIndexPrivate *p = CAMEL_TEXT_INDEX_GET_PRIVATE (idx);
+ CamelTextIndexPrivate *p = CAMEL_TEXT_INDEX (idx)->priv;
struct _CamelTextIndexWord *ww;
struct _CamelTextIndexRoot *rb;
gint ret = 0, wfrag, nfrag;
if (newidx == NULL)
return -1;
- newp = CAMEL_TEXT_INDEX_GET_PRIVATE (newidx);
- oldp = CAMEL_TEXT_INDEX_GET_PRIVATE (idx);
+ newp = CAMEL_TEXT_INDEX (newidx)->priv;
+ oldp = CAMEL_TEXT_INDEX (idx)->priv;
CAMEL_TEXT_INDEX_LOCK (idx, lock);
static gint
text_index_delete (CamelIndex *idx)
{
- CamelTextIndexPrivate *p = CAMEL_TEXT_INDEX_GET_PRIVATE (idx);
+ CamelTextIndexPrivate *p = CAMEL_TEXT_INDEX (idx)->priv;
gint ret = 0;
if (camel_block_file_delete (p->blocks) == -1)
static gint
text_index_rename (CamelIndex *idx, const gchar *path)
{
- CamelTextIndexPrivate *p = CAMEL_TEXT_INDEX_GET_PRIVATE (idx);
+ CamelTextIndexPrivate *p = CAMEL_TEXT_INDEX (idx)->priv;
gchar *newlink, *newblock;
gint err, ret;
static gint
text_index_has_name (CamelIndex *idx, const gchar *name)
{
- CamelTextIndexPrivate *p = CAMEL_TEXT_INDEX_GET_PRIVATE (idx);
+ CamelTextIndexPrivate *p = CAMEL_TEXT_INDEX (idx)->priv;
return camel_partition_table_lookup (p->name_hash, name) != 0;
}
static CamelIndexName *
text_index_add_name (CamelIndex *idx, const gchar *name)
{
- CamelTextIndexPrivate *p = CAMEL_TEXT_INDEX_GET_PRIVATE (idx);
+ CamelTextIndexPrivate *p = CAMEL_TEXT_INDEX (idx)->priv;
camel_key_t keyid;
CamelIndexName *idn;
struct _CamelTextIndexRoot *rb = (struct _CamelTextIndexRoot *)p->blocks->root;
static void
text_index_delete_name (CamelIndex *idx, const gchar *name)
{
- CamelTextIndexPrivate *p = CAMEL_TEXT_INDEX_GET_PRIVATE (idx);
+ CamelTextIndexPrivate *p = CAMEL_TEXT_INDEX (idx)->priv;
camel_key_t keyid;
struct _CamelTextIndexRoot *rb = (struct _CamelTextIndexRoot *)p->blocks->root;
static CamelIndexCursor *
text_index_find (CamelIndex *idx, const gchar *word)
{
- CamelTextIndexPrivate *p = CAMEL_TEXT_INDEX_GET_PRIVATE (idx);
+ CamelTextIndexPrivate *p = CAMEL_TEXT_INDEX (idx)->priv;
camel_key_t keyid;
camel_block_t data = 0;
guint flags;
static CamelIndexCursor *
text_index_words (CamelIndex *idx)
{
- CamelTextIndexPrivate *p = CAMEL_TEXT_INDEX_GET_PRIVATE (idx);
+ CamelTextIndexPrivate *p = CAMEL_TEXT_INDEX (idx)->priv;
return (CamelIndexCursor *)camel_text_index_key_cursor_new ((CamelTextIndex *)idx, p->word_index);
}
static CamelIndexCursor *
text_index_names (CamelIndex *idx)
{
- CamelTextIndexPrivate *p = CAMEL_TEXT_INDEX_GET_PRIVATE (idx);
+ CamelTextIndexPrivate *p = CAMEL_TEXT_INDEX (idx)->priv;
return (CamelIndexCursor *)camel_text_index_key_cursor_new ((CamelTextIndex *)idx, p->name_index);
}
static void
camel_text_index_init (CamelTextIndex *text_index)
{
- text_index->priv = CAMEL_TEXT_INDEX_GET_PRIVATE (text_index);
+ text_index->priv = G_TYPE_INSTANCE_GET_PRIVATE (text_index, CAMEL_TYPE_TEXT_INDEX, CamelTextIndexPrivate);
camel_dlist_init (&text_index->priv->word_cache);
text_index->priv->words = g_hash_table_new (g_str_hash, g_str_equal);
camel_text_index_new (const gchar *path, gint flags)
{
CamelTextIndex *idx = g_object_new (CAMEL_TYPE_TEXT_INDEX, NULL);
- CamelTextIndexPrivate *p = CAMEL_TEXT_INDEX_GET_PRIVATE (idx);
+ CamelTextIndexPrivate *p = idx->priv;
struct _CamelTextIndexRoot *rb;
gchar *link;
CamelBlock *bl;
void
camel_text_index_info (CamelTextIndex *idx)
{
- CamelTextIndexPrivate *p = CAMEL_TEXT_INDEX_GET_PRIVATE (idx);
+ CamelTextIndexPrivate *p = idx->priv;
struct _CamelTextIndexRoot *rb = (struct _CamelTextIndexRoot *)p->blocks->root;
gint frag;
void
camel_text_index_dump (CamelTextIndex *idx)
{
- CamelTextIndexPrivate *p = CAMEL_TEXT_INDEX_GET_PRIVATE (idx);
+ CamelTextIndexPrivate *p = idx->priv;
#ifndef DUMP_RAW
camel_key_t keyid;
gchar *word;
void
camel_text_index_validate (CamelTextIndex *idx)
{
- CamelTextIndexPrivate *p = CAMEL_TEXT_INDEX_GET_PRIVATE (idx);
+ CamelTextIndexPrivate *p = idx->priv;
camel_key_t keyid;
gchar *word;
const gchar *name;
{
CamelTextIndexNamePrivate *priv;
- priv = CAMEL_TEXT_INDEX_NAME_GET_PRIVATE (object);
+ priv = CAMEL_TEXT_INDEX_NAME (object)->priv;
g_hash_table_destroy (CAMEL_TEXT_INDEX_NAME (object)->parent.words);
static gsize
text_index_name_add_buffer (CamelIndexName *idn, const gchar *buffer, gsize len)
{
- CamelTextIndexNamePrivate *p = CAMEL_TEXT_INDEX_NAME_GET_PRIVATE (idn);
+ CamelTextIndexNamePrivate *p = CAMEL_TEXT_INDEX_NAME (idn)->priv;
const guchar *ptr, *ptrend;
guint32 c;
gchar utf8[8];
static void
camel_text_index_name_init (CamelTextIndexName *text_index_name)
{
- text_index_name->priv =
- CAMEL_TEXT_INDEX_NAME_GET_PRIVATE (text_index_name);
+ text_index_name->priv = G_TYPE_INSTANCE_GET_PRIVATE (text_index_name, CAMEL_TYPE_TEXT_INDEX_NAME, CamelTextIndexNamePrivate);
text_index_name->parent.words = g_hash_table_new (
g_str_hash, g_str_equal);
{
CamelTextIndexName *idn = g_object_new (CAMEL_TYPE_TEXT_INDEX_NAME, NULL);
CamelIndexName *cin = &idn->parent;
- CamelTextIndexNamePrivate *p = CAMEL_TEXT_INDEX_NAME_GET_PRIVATE (idn);
+ CamelTextIndexNamePrivate *p = idn->priv;
cin->index = g_object_ref (idx);
cin->name = camel_mempool_strdup (p->pool, name);
{
CamelTextIndexCursorPrivate *priv;
- priv = CAMEL_TEXT_INDEX_CURSOR_GET_PRIVATE (object);
+ priv = CAMEL_TEXT_INDEX_CURSOR (object)->priv;
g_free (priv->records);
g_free (priv->current);
static const gchar *
text_index_cursor_next (CamelIndexCursor *idc)
{
- CamelTextIndexCursorPrivate *p = CAMEL_TEXT_INDEX_CURSOR_GET_PRIVATE (idc);
- CamelTextIndexPrivate *tip = CAMEL_TEXT_INDEX_GET_PRIVATE (idc->index);
+ CamelTextIndexCursorPrivate *p = CAMEL_TEXT_INDEX_CURSOR (idc)->priv;
+ CamelTextIndexPrivate *tip = CAMEL_TEXT_INDEX (idc->index)->priv;
guint flags;
c (printf ("Going to next cursor for word with data '%08x' next %08x\n", p->first, p->next));
static void
text_index_cursor_reset (CamelIndexCursor *idc)
{
- CamelTextIndexCursorPrivate *p = CAMEL_TEXT_INDEX_CURSOR_GET_PRIVATE (idc);
+ CamelTextIndexCursorPrivate *p = CAMEL_TEXT_INDEX_CURSOR (idc)->priv;
g_free (p->records);
p->records = NULL;
static void
camel_text_index_cursor_init (CamelTextIndexCursor *text_index_cursor)
{
- text_index_cursor->priv =
- CAMEL_TEXT_INDEX_CURSOR_GET_PRIVATE (text_index_cursor);
+ text_index_cursor->priv = G_TYPE_INSTANCE_GET_PRIVATE (text_index_cursor, CAMEL_TYPE_TEXT_INDEX_CURSOR, CamelTextIndexCursorPrivate);
}
CamelTextIndexCursor *
{
CamelTextIndexCursor *idc = g_object_new (CAMEL_TYPE_TEXT_INDEX_CURSOR, NULL);
CamelIndexCursor *cic = &idc->parent;
- CamelTextIndexCursorPrivate *p = CAMEL_TEXT_INDEX_CURSOR_GET_PRIVATE (idc);
+ CamelTextIndexCursorPrivate *p = idc->priv;
cic->index = g_object_ref (idx);
p->first = data;
{
CamelTextIndexKeyCursorPrivate *priv;
- priv = CAMEL_TEXT_INDEX_KEY_CURSOR_GET_PRIVATE (object);
+ priv = CAMEL_TEXT_INDEX_KEY_CURSOR (object)->priv;
if (priv->table != NULL) {
g_object_unref (priv->table);
{
CamelTextIndexKeyCursorPrivate *priv;
- priv = CAMEL_TEXT_INDEX_KEY_CURSOR_GET_PRIVATE (object);
+ priv = CAMEL_TEXT_INDEX_KEY_CURSOR (object)->priv;
g_free (priv->current);
static const gchar *
text_index_key_cursor_next (CamelIndexCursor *idc)
{
- CamelTextIndexKeyCursorPrivate *p = CAMEL_TEXT_INDEX_KEY_CURSOR_GET_PRIVATE (idc);
+ CamelTextIndexKeyCursorPrivate *p = CAMEL_TEXT_INDEX_KEY_CURSOR (idc)->priv;
c (printf ("Going to next cursor for keyid %08x\n", p->keyid));
static void
text_index_key_cursor_reset (CamelIndexCursor *idc)
{
- CamelTextIndexKeyCursorPrivate *p = CAMEL_TEXT_INDEX_KEY_CURSOR_GET_PRIVATE (idc);
+ CamelTextIndexKeyCursorPrivate *p = CAMEL_TEXT_INDEX_KEY_CURSOR (idc)->priv;
p->keyid = 0;
p->flags = 0;
static void
camel_text_index_key_cursor_init (CamelTextIndexKeyCursor *text_index_key_cursor)
{
- text_index_key_cursor->priv =
- CAMEL_TEXT_INDEX_KEY_CURSOR_GET_PRIVATE (text_index_key_cursor);
-
+ text_index_key_cursor->priv = G_TYPE_INSTANCE_GET_PRIVATE (text_index_key_cursor, CAMEL_TYPE_TEXT_INDEX_KEY_CURSOR, CamelTextIndexKeyCursorPrivate);
text_index_key_cursor->priv->keyid = 0;
text_index_key_cursor->priv->flags = 0;
text_index_key_cursor->priv->data = 0;
{
CamelTextIndexKeyCursor *idc = g_object_new (CAMEL_TYPE_TEXT_INDEX_KEY_CURSOR, NULL);
CamelIndexCursor *cic = &idc->parent;
- CamelTextIndexKeyCursorPrivate *p = CAMEL_TEXT_INDEX_KEY_CURSOR_GET_PRIVATE (idc);
+ CamelTextIndexKeyCursorPrivate *p = idc->priv;
cic->index = g_object_ref (idx);
p->table = g_object_ref (table);
#include "camel-mime-message.h"
#include "camel-transport.h"
-#define CAMEL_TRANSPORT_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_TRANSPORT, CamelTransportPrivate))
-
typedef struct _AsyncContext AsyncContext;
struct _CamelTransportPrivate {
{
CamelTransportPrivate *priv;
- priv = CAMEL_TRANSPORT_GET_PRIVATE (object);
+ priv = CAMEL_TRANSPORT (object)->priv;
g_mutex_free (priv->send_lock);
static void
camel_transport_init (CamelTransport *transport)
{
- transport->priv = CAMEL_TRANSPORT_GET_PRIVATE (transport);
+ transport->priv = G_TYPE_INSTANCE_GET_PRIVATE (transport, CAMEL_TYPE_TRANSPORT, CamelTransportPrivate);
transport->priv->send_lock = g_mutex_new ();
}
#define d(x)
#define dd(x) (camel_debug ("vfolder")?(x):0)
-#define CAMEL_VEE_FOLDER_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_VEE_FOLDER, CamelVeeFolderPrivate))
-
struct _CamelVeeFolderPrivate {
gboolean destroyed;
GList *folders; /* lock using subfolder_lock before changing/accessing */
/* Check the folder hasn't beem removed while we weren't watching */
camel_vee_folder_lock (vf, CAMEL_VEE_FOLDER_SUBFOLDER_LOCK);
- if (g_list_find (CAMEL_VEE_FOLDER_GET_PRIVATE (vf)->folders, sub) == NULL) {
+ if (g_list_find (vf->priv->folders, sub) == NULL) {
camel_vee_folder_unlock (vf, CAMEL_VEE_FOLDER_SUBFOLDER_LOCK);
return;
}
guint32 count=0;
gchar *expr = g_strdup_printf ("(and %s %s)", vf->expression ? vf->expression : "", query);
GList *node;
- CamelVeeFolderPrivate *p = CAMEL_VEE_FOLDER_GET_PRIVATE (vf);
+ CamelVeeFolderPrivate *p = vf->priv;
node = p->folders;
while (node) {
CamelFolder *sub,
GCancellable *cancellable)
{
- CamelVeeFolderPrivate *p = CAMEL_VEE_FOLDER_GET_PRIVATE (vf);
+ CamelVeeFolderPrivate *p = vf->priv;
gint i;
CamelVeeFolder *folder_unmatched = vf->parent_vee_store ? vf->parent_vee_store->folder_unmatched : NULL;
camel_vee_folder_unlock (vf, CAMEL_VEE_FOLDER_SUBFOLDER_LOCK);
if (folder_unmatched != NULL) {
- CamelVeeFolderPrivate *up = CAMEL_VEE_FOLDER_GET_PRIVATE (folder_unmatched);
+ CamelVeeFolderPrivate *up = folder_unmatched->priv;
camel_vee_folder_lock (folder_unmatched, CAMEL_VEE_FOLDER_SUBFOLDER_LOCK);
/* if folder deleted, then blow it away from unmatched always, and remove all refs to it */
GPtrArray *matches, *result = g_ptr_array_new ();
gchar *expr;
CamelVeeFolder *vf = (CamelVeeFolder *)folder;
- CamelVeeFolderPrivate *p = CAMEL_VEE_FOLDER_GET_PRIVATE (vf);
+ CamelVeeFolderPrivate *p = vf->priv;
GHashTable *searched = g_hash_table_new (NULL, NULL);
CamelVeeFolder *folder_unmatched = vf->parent_vee_store ? vf->parent_vee_store->folder_unmatched : NULL;
gboolean is_folder_unmatched = vf == folder_unmatched && folder_unmatched;
GPtrArray *folder_uids = g_ptr_array_new ();
gchar *expr;
CamelVeeFolder *vf = (CamelVeeFolder *)folder;
- CamelVeeFolderPrivate *p = CAMEL_VEE_FOLDER_GET_PRIVATE (vf);
+ CamelVeeFolderPrivate *p = vf->priv;
GHashTable *searched = g_hash_table_new (NULL, NULL);
camel_vee_folder_lock (vf, CAMEL_VEE_FOLDER_SUBFOLDER_LOCK);
gchar *expr;
guint32 count = 0;
CamelVeeFolder *vf = (CamelVeeFolder *)folder;
- CamelVeeFolderPrivate *p = CAMEL_VEE_FOLDER_GET_PRIVATE (vf);
+ CamelVeeFolderPrivate *p = vf->priv;
GHashTable *searched = g_hash_table_new (NULL, NULL);
CamelVeeFolder *folder_unmatched = vf->parent_vee_store ? vf->parent_vee_store->folder_unmatched : NULL;
static void
vee_folder_delete (CamelFolder *folder)
{
- CamelVeeFolderPrivate *p = CAMEL_VEE_FOLDER_GET_PRIVATE (folder);
+ CamelVeeFolderPrivate *p = CAMEL_VEE_FOLDER (folder)->priv;
/* NB: this is never called on UNMTACHED */
vee_folder_freeze (CamelFolder *folder)
{
CamelVeeFolder *vfolder = (CamelVeeFolder *)folder;
- CamelVeeFolderPrivate *p = CAMEL_VEE_FOLDER_GET_PRIVATE (vfolder);
+ CamelVeeFolderPrivate *p = vfolder->priv;
GList *node;
camel_vee_folder_lock (vfolder, CAMEL_VEE_FOLDER_SUBFOLDER_LOCK);
vee_folder_thaw (CamelFolder *folder)
{
CamelVeeFolder *vfolder = (CamelVeeFolder *)folder;
- CamelVeeFolderPrivate *p = CAMEL_VEE_FOLDER_GET_PRIVATE (vfolder);
+ CamelVeeFolderPrivate *p = vfolder->priv;
GList *node;
camel_vee_folder_lock (vfolder, CAMEL_VEE_FOLDER_SUBFOLDER_LOCK);
GError **error)
{
CamelVeeFolder *vf = (CamelVeeFolder *)folder;
- CamelVeeFolderPrivate *p = CAMEL_VEE_FOLDER_GET_PRIVATE (vf);
+ CamelVeeFolderPrivate *p = vf->priv;
GList *node, *list;
gboolean success = TRUE;
GError **error)
{
CamelVeeFolder *vf = (CamelVeeFolder *)folder;
- CamelVeeFolderPrivate *p = CAMEL_VEE_FOLDER_GET_PRIVATE (vf);
+ CamelVeeFolderPrivate *p = vf->priv;
GList *node;
if (((CamelVeeSummary *)folder->summary)->fake_visible_count)
vee_folder_set_expression (CamelVeeFolder *vee_folder,
const gchar *query)
{
- CamelVeeFolderPrivate *p = CAMEL_VEE_FOLDER_GET_PRIVATE (vee_folder);
+ CamelVeeFolderPrivate *p = vee_folder->priv;
GList *node;
camel_vee_folder_lock (vee_folder, CAMEL_VEE_FOLDER_SUBFOLDER_LOCK);
/* check if this folder is still to be part of unmatched */
if ((vf->flags & CAMEL_STORE_FOLDER_PRIVATE) == 0 && !killun) {
camel_vee_folder_lock (folder_unmatched, CAMEL_VEE_FOLDER_SUBFOLDER_LOCK);
- still = g_list_find (CAMEL_VEE_FOLDER_GET_PRIVATE (folder_unmatched)->folders, source) != NULL;
+ still = g_list_find (folder_unmatched->priv->folders, source) != NULL;
camel_vee_folder_unlock (folder_unmatched, CAMEL_VEE_FOLDER_SUBFOLDER_LOCK);
camel_vee_folder_hash_folder (source, hash);
}
CamelFolder *sub,
CamelFolderChangeInfo *changes)
{
- CamelVeeFolderPrivate *p = CAMEL_VEE_FOLDER_GET_PRIVATE (vee_folder);
+ CamelVeeFolderPrivate *p = vee_folder->priv;
struct _folder_changed_msg *m;
CamelStore *parent_store;
CamelSession *session;
{
CamelFolder *folder = CAMEL_FOLDER (vee_folder);
- vee_folder->priv = CAMEL_VEE_FOLDER_GET_PRIVATE (vee_folder);
+ vee_folder->priv = G_TYPE_INSTANCE_GET_PRIVATE (vee_folder, CAMEL_TYPE_VEE_FOLDER, CamelVeeFolderPrivate);
folder->folder_flags |= (CAMEL_FOLDER_HAS_SUMMARY_CAPABILITY |
CAMEL_FOLDER_HAS_SEARCH_CAPABILITY);
void
camel_vee_folder_add_folder (CamelVeeFolder *vf, CamelFolder *sub)
{
- CamelVeeFolderPrivate *p = CAMEL_VEE_FOLDER_GET_PRIVATE (vf);
+ CamelVeeFolderPrivate *p = vf->priv;
gint i;
CamelVeeFolder *folder_unmatched = vf->parent_vee_store ? vf->parent_vee_store->folder_unmatched : NULL;
camel_folder_unlock (CAMEL_FOLDER (vf), CAMEL_FOLDER_CHANGE_LOCK);
}
if ((vf->flags & CAMEL_STORE_FOLDER_PRIVATE) == 0 && !CAMEL_IS_VEE_FOLDER (sub) && folder_unmatched != NULL) {
- CamelVeeFolderPrivate *up = CAMEL_VEE_FOLDER_GET_PRIVATE (folder_unmatched);
+ CamelVeeFolderPrivate *up = folder_unmatched->priv;
up->folders = g_list_append (
up->folders, g_object_ref (sub));
camel_vee_folder_remove_folder (CamelVeeFolder *vf,
CamelFolder *sub)
{
- CamelVeeFolderPrivate *p = CAMEL_VEE_FOLDER_GET_PRIVATE (vf);
+ CamelVeeFolderPrivate *p = vf->priv;
gint i;
CamelVeeFolder *folder_unmatched = vf->parent_vee_store ? vf->parent_vee_store->folder_unmatched : NULL;
camel_vee_folder_unlock (vf, CAMEL_VEE_FOLDER_SUBFOLDER_LOCK);
if (folder_unmatched != NULL) {
- CamelVeeFolderPrivate *up = CAMEL_VEE_FOLDER_GET_PRIVATE (folder_unmatched);
+ CamelVeeFolderPrivate *up = folder_unmatched->priv;
camel_vee_folder_lock (folder_unmatched, CAMEL_VEE_FOLDER_SUBFOLDER_LOCK);
/* if folder deleted, then blow it away from unmatched always, and remove all refs to it */
void
camel_vee_folder_set_folders (CamelVeeFolder *vf, GList *folders)
{
- CamelVeeFolderPrivate *p = CAMEL_VEE_FOLDER_GET_PRIVATE (vf);
+ CamelVeeFolderPrivate *p = vf->priv;
GHashTable *remove = g_hash_table_new (NULL, NULL);
GList *l;
CamelFolder *folder;
#define MAX_ATTACHMENT_SIZE 1*1024*1024 /*In bytes*/
#define GROUPWISE_BULK_DELETE_LIMIT 100
-#define CAMEL_GROUPWISE_FOLDER_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_GROUPWISE_FOLDER, CamelGroupwiseFolderPrivate))
-
struct _CamelGroupwiseFolderPrivate {
#ifdef ENABLE_THREADS
{
CamelFolder *folder = CAMEL_FOLDER (gw_folder);
- gw_folder->priv = CAMEL_GROUPWISE_FOLDER_GET_PRIVATE (gw_folder);
+ gw_folder->priv = G_TYPE_INSTANCE_GET_PRIVATE (gw_folder, CAMEL_TYPE_GROUPWISE_FOLDER, CamelGroupwiseFolderPrivate);
folder->permanent_flags = CAMEL_MESSAGE_ANSWERED | CAMEL_MESSAGE_DELETED |
CAMEL_MESSAGE_DRAFT | CAMEL_MESSAGE_FLAGGED | CAMEL_MESSAGE_SEEN;
#define JUNK_ENABLE 1
#define JUNK_PERSISTENCE 14
-#define CAMEL_GROUPWISE_STORE_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_GROUPWISE_STORE, CamelGroupwiseStorePrivate))
-
const gchar * CREATE_CURSOR_VIEW = "peek id default recipient threading hasAttachment subject status priority startDate created delivered size recurrenceKey";
struct _CamelGroupwiseStorePrivate {
static void
camel_groupwise_store_init (CamelGroupwiseStore *groupwise_store)
{
- groupwise_store->priv =
- CAMEL_GROUPWISE_STORE_GET_PRIVATE (groupwise_store);
+ groupwise_store->priv = G_TYPE_INSTANCE_GET_PRIVATE (groupwise_store, CAMEL_TYPE_GROUPWISE_STORE, CamelGroupwiseStorePrivate);
d("in groupwise store init\n");
groupwise_store->priv->server_name = NULL;
* octets) */
#define UID_SET_LIMIT (768)
-#define CAMEL_IMAP_FOLDER_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_IMAP_FOLDER, CamelImapFolderPrivate))
-
/* The custom property ID is a CamelArg artifact.
* It still identifies the property in state files. */
enum {
{
CamelFolder *folder = CAMEL_FOLDER (imap_folder);
- imap_folder->priv = CAMEL_IMAP_FOLDER_GET_PRIVATE (imap_folder);
+ imap_folder->priv = G_TYPE_INSTANCE_GET_PRIVATE (imap_folder, CAMEL_TYPE_IMAP_FOLDER, CamelImapFolderPrivate);
folder->permanent_flags = CAMEL_MESSAGE_ANSWERED | CAMEL_MESSAGE_DELETED |
CAMEL_MESSAGE_DRAFT | CAMEL_MESSAGE_FLAGGED | CAMEL_MESSAGE_SEEN;
#include "camel-imap-folder.h"
#include "camel-imap-wrapper.h"
-#define CAMEL_IMAP_WRAPPER_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_IMAP_WRAPPER, CamelImapWrapperPrivate))
-
struct _CamelImapWrapperPrivate {
GMutex *lock;
};
static void
camel_imap_wrapper_init (CamelImapWrapper *imap_wrapper)
{
- imap_wrapper->priv = CAMEL_IMAP_WRAPPER_GET_PRIVATE (imap_wrapper);
+ imap_wrapper->priv = G_TYPE_INSTANCE_GET_PRIVATE (imap_wrapper, CAMEL_TYPE_IMAP_WRAPPER, CamelImapWrapperPrivate);
imap_wrapper->priv->lock = g_mutex_new ();
}
#define c(...) camel_imapx_debug(conman, __VA_ARGS__)
-#define CAMEL_IMAPX_CONN_MANAGER_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_OBJECT, CamelIMAPXConnManager))
-
#define CON_LOCK(x) (g_static_rec_mutex_lock(&(x)->priv->con_man_lock))
#define CON_UNLOCK(x) (g_static_rec_mutex_unlock(&(x)->priv->con_man_lock))
static void
camel_imapx_conn_manager_init (CamelIMAPXConnManager *con_man)
{
- CamelIMAPXConnManagerPrivate *priv;
-
- priv = g_new0 (CamelIMAPXConnManagerPrivate, 1);
- con_man->priv = priv;
+ con_man->priv = G_TYPE_INSTANCE_GET_PRIVATE (con_man, CAMEL_TYPE_OBJECT, CamelIMAPXConnManagerPrivate);
/* default is 1 connection */
con_man->priv->n_connections = 1;
#define PATH_MAX _POSIX_PATH_MAX
#endif
-#define CAMEL_LOCAL_FOLDER_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_LOCAL_FOLDER, CamelLocalFolderPrivate))
-
/* The custom property ID is a CamelArg artifact.
* It still identifies the property in state files. */
enum {
{
CamelFolder *folder = CAMEL_FOLDER (local_folder);
- local_folder->priv = CAMEL_LOCAL_FOLDER_GET_PRIVATE (local_folder);
+ local_folder->priv = G_TYPE_INSTANCE_GET_PRIVATE (local_folder, CAMEL_TYPE_LOCAL_FOLDER, CamelLocalFolderPrivate);
local_folder->priv->search_lock = g_mutex_new ();
folder->folder_flags |= (CAMEL_FOLDER_HAS_SUMMARY_CAPABILITY |
#define CAMEL_MAILDIR_SUMMARY_VERSION (0x2000)
-#define CAMEL_MAILDIR_SUMMARY_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_MAILDIR_SUMMARY, CamelMaildirSummaryPrivate))
-
static CamelMessageInfo *message_info_migrate (CamelFolderSummary *s, FILE *in);
static CamelMessageInfo *message_info_new_from_header (CamelFolderSummary *, struct _camel_header_raw *);
static void message_info_free (CamelFolderSummary *, CamelMessageInfo *mi);
{
CamelMaildirSummaryPrivate *priv;
- priv = CAMEL_MAILDIR_SUMMARY_GET_PRIVATE (object);
+ priv = CAMEL_MAILDIR_SUMMARY (object)->priv;
g_free (priv->hostname);
g_mutex_free (priv->summary_lock);
folder_summary = CAMEL_FOLDER_SUMMARY (maildir_summary);
- maildir_summary->priv =
- CAMEL_MAILDIR_SUMMARY_GET_PRIVATE (maildir_summary);
+ maildir_summary->priv = G_TYPE_INSTANCE_GET_PRIVATE (maildir_summary, CAMEL_TYPE_MAILDIR_SUMMARY, CamelMaildirSummaryPrivate);
/* set unique file version */
folder_summary->version += CAMEL_MAILDIR_SUMMARY_VERSION;
#define CAMEL_MH_SUMMARY_VERSION (0x2000)
-#define CAMEL_MH_SUMMARY_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_MH_SUMMARY, CamelMhSummaryPrivate))
-
static gint mh_summary_check (CamelLocalSummary *cls, CamelFolderChangeInfo *changeinfo, GCancellable *cancellable, GError **error);
static gint mh_summary_sync (CamelLocalSummary *cls, gboolean expunge, CamelFolderChangeInfo *changeinfo, GCancellable *cancellable, GError **error);
/*static gint mh_summary_add(CamelLocalSummary *cls, CamelMimeMessage *msg, CamelMessageInfo *info, CamelFolderChangeInfo *, GError **error);*/
{
CamelFolderSummary *folder_summary;
- mh_summary->priv = CAMEL_MH_SUMMARY_GET_PRIVATE (mh_summary);
+ mh_summary->priv = G_TYPE_INSTANCE_GET_PRIVATE (mh_summary, CAMEL_TYPE_MH_SUMMARY, CamelMhSummaryPrivate);
folder_summary = CAMEL_FOLDER_SUMMARY (mh_summary);
#include "camel-nntp-store.h"
#include "camel-nntp-summary.h"
-#define CAMEL_NNTP_FOLDER_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_NNTP_FOLDER, CamelNNTPFolderPrivate))
-
G_DEFINE_TYPE (CamelNNTPFolder, camel_nntp_folder, CAMEL_TYPE_DISCO_FOLDER)
static void
static void
camel_nntp_folder_init (CamelNNTPFolder *nntp_folder)
{
- nntp_folder->priv = CAMEL_NNTP_FOLDER_GET_PRIVATE (nntp_folder);
+ nntp_folder->priv = G_TYPE_INSTANCE_GET_PRIVATE (nntp_folder, CAMEL_TYPE_NNTP_FOLDER, CamelNNTPFolderPrivate);
nntp_folder->changes = camel_folder_change_info_new ();
nntp_folder->priv->search_lock = g_mutex_new ();
#define DUMP_EXTENSIONS
-#define CAMEL_NNTP_STORE_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_NNTP_STORE, CamelNNTPStorePrivate))
-
G_DEFINE_TYPE (CamelNNTPStore, camel_nntp_store, CAMEL_TYPE_DISCO_STORE)
static gint
nntp_store->mem = (CamelStreamMem *)camel_stream_mem_new ();
- nntp_store->priv = CAMEL_NNTP_STORE_GET_PRIVATE (nntp_store);
+ nntp_store->priv = G_TYPE_INSTANCE_GET_PRIVATE (nntp_store, CAMEL_TYPE_NNTP_STORE, CamelNNTPStorePrivate);
}
/* Enter owning lock */
#define CAMEL_NNTP_SUMMARY_VERSION (1)
-#define CAMEL_NNTP_SUMMARY_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), CAMEL_TYPE_NNTP_SUMMARY, CamelNNTPSummaryPrivate))
-
struct _CamelNNTPSummaryPrivate {
gchar *uid;
{
CamelFolderSummary *summary = CAMEL_FOLDER_SUMMARY (nntp_summary);
- nntp_summary->priv = CAMEL_NNTP_SUMMARY_GET_PRIVATE (nntp_summary);
+ nntp_summary->priv = G_TYPE_INSTANCE_GET_PRIVATE (nntp_summary, CAMEL_TYPE_NNTP_SUMMARY, CamelNNTPSummaryPrivate);
/* and a unique file version */
summary->version += CAMEL_NNTP_SUMMARY_VERSION;
#define RIGHT_KEY(sufix) (priv->type == PROXY_TYPE_SYSTEM ? KEY_GCONF_SYS_ ## sufix : KEY_GCONF_EVO_ ## sufix)
-#define E_PROXY_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), E_TYPE_PROXY, EProxyPrivate))
-
struct _EProxyPrivate {
SoupURI *uri_http, *uri_https;
guint notify_id_evo, notify_id_sys, notify_id_sys_http; /* conxn id of gconf_client_notify_add */
EProxyPrivate *priv;
GConfClient* client;
- priv = E_PROXY_GET_PRIVATE (object);
+ priv = E_PROXY (object)->priv;
client = gconf_client_get_default ();
static void
e_proxy_init (EProxy *proxy)
{
- proxy->priv = E_PROXY_GET_PRIVATE (proxy);
+ proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, E_TYPE_PROXY, EProxyPrivate);
proxy->priv->type = PROXY_TYPE_SYSTEM;
}
G_DEFINE_TYPE (ESoapMessage, e_soap_message, SOUP_TYPE_MESSAGE)
-typedef struct {
+struct _ESoapMessagePrivate {
/* Serialization fields */
xmlDocPtr doc;
xmlNodePtr last_node;
xmlChar *env_uri;
gboolean body_started;
gchar *action;
-} ESoapMessagePrivate;
-#define E_SOAP_MESSAGE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), E_TYPE_SOAP_MESSAGE, ESoapMessagePrivate))
+};
static void
finalize (GObject *object)
{
- ESoapMessagePrivate *priv = E_SOAP_MESSAGE_GET_PRIVATE (object);
+ ESoapMessagePrivate *priv = E_SOAP_MESSAGE (object)->priv;
if (priv->doc)
xmlFreeDoc (priv->doc);
static void
e_soap_message_init (ESoapMessage *msg)
{
- ESoapMessagePrivate *priv = E_SOAP_MESSAGE_GET_PRIVATE (msg);
+ msg->priv = G_TYPE_INSTANCE_GET_PRIVATE (msg, E_TYPE_SOAP_MESSAGE, ESoapMessagePrivate);
/* initialize XML structures */
- priv->doc = xmlNewDoc ((const xmlChar *)"1.0");
- priv->doc->standalone = FALSE;
- priv->doc->encoding = xmlCharStrdup ("UTF-8");
+ msg->priv->doc = xmlNewDoc ((const xmlChar *)"1.0");
+ msg->priv->doc->standalone = FALSE;
+ msg->priv->doc->encoding = xmlCharStrdup ("UTF-8");
}
static xmlNsPtr
fetch_ns (ESoapMessage *msg, const gchar *prefix, const gchar *ns_uri)
{
- ESoapMessagePrivate *priv = E_SOAP_MESSAGE_GET_PRIVATE (msg);
+ ESoapMessagePrivate *priv = msg->priv;
xmlNsPtr ns = NULL;
if (prefix && ns_uri)
SOUP_MESSAGE_URI, uri,
NULL);
- priv = E_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
priv->doc->standalone = standalone;
ESoapMessagePrivate *priv;
g_return_if_fail (E_IS_SOAP_MESSAGE (msg));
- priv = E_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
priv->last_node = priv->doc->xmlRootNode =
xmlNewDocNode (priv->doc, NULL, (const xmlChar *)"Envelope", NULL);
ESoapMessagePrivate *priv;
g_return_if_fail (E_IS_SOAP_MESSAGE (msg));
- priv = E_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
if (priv->body_started)
return;
ESoapMessagePrivate *priv;
g_return_if_fail (E_IS_SOAP_MESSAGE (msg));
- priv = E_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
priv->last_node = xmlNewChild (priv->last_node, NULL, (const xmlChar *)name, NULL);
ESoapMessagePrivate *priv;
g_return_if_fail (E_IS_SOAP_MESSAGE (msg));
- priv = E_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
priv->last_node = priv->last_node->parent;
}
ESoapMessagePrivate *priv;
g_return_if_fail (E_IS_SOAP_MESSAGE (msg));
- priv = E_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
priv->last_node = xmlNewChild (priv->last_node,
priv->soap_ns,
ESoapMessagePrivate *priv;
g_return_if_fail (E_IS_SOAP_MESSAGE (msg));
- priv = E_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
priv->last_node = xmlNewChild (priv->last_node,
priv->soap_ns,
ESoapMessagePrivate *priv;
g_return_if_fail (E_IS_SOAP_MESSAGE (msg));
- priv = E_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
priv->last_node = xmlNewChild (priv->last_node, priv->soap_ns,
(const xmlChar *)"Header", NULL);
ESoapMessagePrivate *priv;
g_return_if_fail (E_IS_SOAP_MESSAGE (msg));
- priv = E_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
e_soap_message_start_element (msg, name, prefix, ns_uri);
if (actor_uri)
ESoapMessagePrivate *priv;
g_return_if_fail (E_IS_SOAP_MESSAGE (msg));
- priv = E_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
xmlNodeAddContent (priv->last_node, (const xmlChar *)string);
}
ESoapMessagePrivate *priv;
g_return_if_fail (E_IS_SOAP_MESSAGE (msg));
- priv = E_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
xmlNodeAddContentLen (priv->last_node, (const xmlChar *)buffer, len);
}
ESoapMessagePrivate *priv;
g_return_if_fail (E_IS_SOAP_MESSAGE (msg));
- priv = E_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
xmlNewNsProp (priv->last_node, priv->xsi_ns, (const xmlChar *)"type", (const xmlChar *)xsi_type);
}
ESoapMessagePrivate *priv;
g_return_if_fail (E_IS_SOAP_MESSAGE (msg));
- priv = E_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
xmlNewNsProp (priv->last_node, priv->xsi_ns, (const xmlChar *)"null", (const xmlChar *)"1");
}
ESoapMessagePrivate *priv;
g_return_if_fail (E_IS_SOAP_MESSAGE (msg));
- priv = E_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
xmlNewNsProp (priv->last_node,
fetch_ns (msg, prefix, ns_uri),
ESoapMessagePrivate *priv;
g_return_if_fail (E_IS_SOAP_MESSAGE (msg));
- priv = E_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
xmlNewNs (priv->last_node, (const xmlChar *)(ns_uri ? ns_uri : ""), (const xmlChar *)prefix);
}
ESoapMessagePrivate *priv;
g_return_if_fail (E_IS_SOAP_MESSAGE (msg));
- priv = E_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
xmlNewNsProp (priv->last_node, priv->soap_ns, (const xmlChar *)"encodingStyle", (const xmlChar *)enc_style);
}
ESoapMessagePrivate *priv;
g_return_if_fail (E_IS_SOAP_MESSAGE (msg));
- priv = E_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
xmlFreeDoc (priv->doc);
priv->doc = xmlNewDoc ((const xmlChar *)"1.0");
gint len;
g_return_if_fail (E_IS_SOAP_MESSAGE (msg));
- priv = E_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
xmlDocDumpMemory (priv->doc, &body, &len);
xmlNsPtr ns = NULL;
g_return_val_if_fail (E_IS_SOAP_MESSAGE (msg), NULL);
- priv = E_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
g_return_val_if_fail (ns_uri != NULL, NULL);
ns = xmlSearchNsByHref (priv->doc, priv->last_node, (const xmlChar *)ns_uri);
ESoapMessagePrivate *priv;
g_return_val_if_fail (E_IS_SOAP_MESSAGE (msg), NULL);
- priv = E_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
return priv->doc;
}
#define E_IS_SOAP_MESSAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), E_TYPE_SOAP_MESSAGE))
#define E_SOAP_MESSAGE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), E_TYPE_SOAP_MESSAGE, ESoapMessageClass))
+typedef struct _ESoapMessagePrivate ESoapMessagePrivate;
+
typedef struct {
SoupMessage parent;
+ ESoapMessagePrivate *priv;
} ESoapMessage;
typedef struct {
G_DEFINE_TYPE (ESoapResponse, e_soap_response, G_TYPE_OBJECT)
-typedef struct {
+struct _ESoapResponsePrivate {
/* the XML document */
xmlDocPtr xmldoc;
xmlNodePtr xml_root;
xmlNodePtr xml_method;
xmlNodePtr soap_fault;
GList *parameters;
-} ESoapResponsePrivate;
-#define E_SOAP_RESPONSE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), E_TYPE_SOAP_RESPONSE, ESoapResponsePrivate))
+};
static xmlNode *soup_xml_real_node (xmlNode *node);
static void
finalize (GObject *object)
{
- ESoapResponsePrivate *priv = E_SOAP_RESPONSE_GET_PRIVATE (object);
+ ESoapResponsePrivate *priv = E_SOAP_RESPONSE (object)->priv;
if (priv->xmldoc)
xmlFreeDoc (priv->xmldoc);
static void
e_soap_response_init (ESoapResponse *response)
{
- ESoapResponsePrivate *priv = E_SOAP_RESPONSE_GET_PRIVATE (response);
-
- priv->xmldoc = xmlNewDoc ((const xmlChar *)"1.0");
+ response->priv = G_TYPE_INSTANCE_GET_PRIVATE (response, E_TYPE_SOAP_RESPONSE, ESoapResponsePrivate);
+ response->priv->xmldoc = xmlNewDoc ((const xmlChar *)"1.0");
}
/**
xmlNodePtr xml_root, xml_body, xml_method = NULL;
g_return_val_if_fail (E_IS_SOAP_RESPONSE (response), FALSE);
- priv = E_SOAP_RESPONSE_GET_PRIVATE (response);
+ priv = response->priv;
g_return_val_if_fail (xmlstr != NULL, FALSE);
/* clear the previous contents */
ESoapResponsePrivate *priv;
g_return_val_if_fail (E_IS_SOAP_RESPONSE (response), NULL);
- priv = E_SOAP_RESPONSE_GET_PRIVATE (response);
+ priv = response->priv;
g_return_val_if_fail (priv->xml_method != NULL, NULL);
return (const gchar *) priv->xml_method->name;
ESoapResponsePrivate *priv;
g_return_if_fail (E_IS_SOAP_RESPONSE (response));
- priv = E_SOAP_RESPONSE_GET_PRIVATE (response);
+ priv = response->priv;
g_return_if_fail (priv->xml_method != NULL);
g_return_if_fail (method_name != NULL);
ESoapResponsePrivate *priv;
g_return_val_if_fail (E_IS_SOAP_RESPONSE (response), NULL);
- priv = E_SOAP_RESPONSE_GET_PRIVATE (response);
+ priv = response->priv;
return (const GList *) priv->parameters;
}
ESoapResponsePrivate *priv;
g_return_val_if_fail (E_IS_SOAP_RESPONSE (response), NULL);
- priv = E_SOAP_RESPONSE_GET_PRIVATE (response);
+ priv = response->priv;
return priv->parameters ? priv->parameters->data : NULL;
}
GList *l;
g_return_val_if_fail (E_IS_SOAP_RESPONSE (response), NULL);
- priv = E_SOAP_RESPONSE_GET_PRIVATE (response);
+ priv = response->priv;
g_return_val_if_fail (name != NULL, NULL);
for (l = priv->parameters; l != NULL; l = l->next) {
GList *l;
g_return_val_if_fail (E_IS_SOAP_RESPONSE (response), NULL);
- priv = E_SOAP_RESPONSE_GET_PRIVATE (response);
+ priv = response->priv;
g_return_val_if_fail (from != NULL, NULL);
l = g_list_find (priv->parameters, (gconstpointer) from);
xmlChar *xmlbuff;
gint buffersize, ret;
- ESoapResponsePrivate *priv = E_SOAP_RESPONSE_GET_PRIVATE (response);
+ ESoapResponsePrivate *priv = response->priv;
xmlDocDumpFormatMemory (priv->xmldoc, &xmlbuff, &buffersize, 1);
ret = fputs ((gchar *) xmlbuff, buffer);
#define E_IS_SOAP_RESPONSE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), E_TYPE_SOAP_RESPONSE))
#define E_SOAP_RESPONSE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), E_TYPE_SOAP_RESPONSE, ESoapResponseClass))
+typedef struct _ESoapResponsePrivate ESoapResponsePrivate;
+
typedef struct {
GObject parent;
+ ESoapResponsePrivate *priv;
} ESoapResponse;
typedef struct {
#include "e-categories-dialog.h"
#include "e-category-completion.h"
-#define E_CATEGORIES_DIALOG_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), E_TYPE_CATEGORIES_DIALOG, ECategoriesDialogPrivate))
-
G_DEFINE_TYPE (ECategoriesDialog, e_categories_dialog, GTK_TYPE_DIALOG)
struct _ECategoriesDialogPrivate {
{
ECategoriesDialogPrivate *priv;
- priv = E_CATEGORIES_DIALOG_GET_PRIVATE (object);
+ priv = E_CATEGORIES_DIALOG (object)->priv;
g_hash_table_remove_all (priv->selected_categories);
{
ECategoriesDialogPrivate *priv;
- priv = E_CATEGORIES_DIALOG_GET_PRIVATE (object);
+ priv = E_CATEGORIES_DIALOG (object)->priv;
e_categories_unregister_change_listener (
G_CALLBACK (categories_dialog_listener_cb), object);
gtk_label_set_mnemonic_widget (GTK_LABEL (label_header), entry_categories);
gtk_label_set_mnemonic_widget (GTK_LABEL (label2), categories_list);
- dialog->priv = E_CATEGORIES_DIALOG_GET_PRIVATE (dialog);
+ dialog->priv = G_TYPE_INSTANCE_GET_PRIVATE (dialog, E_TYPE_CATEGORIES_DIALOG, ECategoriesDialogPrivate);
dialog->priv->selected_categories = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
dialog->priv->categories_entry = entry_categories;
#include <glib/gi18n-lib.h>
#include <libedataserver/e-categories.h>
-#define E_CATEGORY_COMPLETION_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), E_TYPE_CATEGORY_COMPLETION, ECategoryCompletionPrivate))
-
G_DEFINE_TYPE (ECategoryCompletion, e_category_completion, GTK_TYPE_ENTRY_COMPLETION)
struct _ECategoryCompletionPrivate {
static void
e_category_completion_init (ECategoryCompletion *category_completion)
{
- category_completion->priv =
- E_CATEGORY_COMPLETION_GET_PRIVATE (category_completion);
+ category_completion->priv = G_TYPE_INSTANCE_GET_PRIVATE (category_completion, E_TYPE_CATEGORY_COMPLETION, ECategoryCompletionPrivate);
}
/**
#include <string.h>
#include <glib/gi18n-lib.h>
-#define E_CELL_RENDERER_COLOR_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), E_TYPE_CELL_RENDERER_COLOR, ECellRendererColorPrivate))
-
enum {
PROP_0,
PROP_COLOR
guint xpad;
guint ypad;
- priv = E_CELL_RENDERER_COLOR_GET_PRIVATE (cell);
+ priv = E_CELL_RENDERER_COLOR (cell)->priv;
if (priv->color == NULL)
return;
{
ECellRendererColorPrivate *priv;
- priv = E_CELL_RENDERER_COLOR_GET_PRIVATE (object);
+ priv = E_CELL_RENDERER_COLOR (object)->priv;
switch (property_id) {
case PROP_COLOR:
{
ECellRendererColorPrivate *priv;
- priv = E_CELL_RENDERER_COLOR_GET_PRIVATE (object);
+ priv = E_CELL_RENDERER_COLOR (object)->priv;
switch (property_id) {
case PROP_COLOR:
{
ECellRendererColorPrivate *priv;
- priv = E_CELL_RENDERER_COLOR_GET_PRIVATE (object);
+ priv = E_CELL_RENDERER_COLOR (object)->priv;
if (priv->color != NULL)
gdk_color_free (priv->color);
static void
e_cell_renderer_color_init (ECellRendererColor *cellcolor)
{
- cellcolor->priv = E_CELL_RENDERER_COLOR_GET_PRIVATE (cellcolor);
+ cellcolor->priv = G_TYPE_INSTANCE_GET_PRIVATE (cellcolor, E_TYPE_CELL_RENDERER_COLOR, ECellRendererColorPrivate);
g_object_set (cellcolor, "xpad", 4, NULL);
}
(iter)->user_data = GINT_TO_POINTER (index); \
} G_STMT_END
-#define E_CONTACT_STORE_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), E_TYPE_CONTACT_STORE, EContactStorePrivate))
-
struct _EContactStorePrivate {
gint stamp;
EBookQuery *query;
EContactStorePrivate *priv;
gint ii;
- priv = E_CONTACT_STORE_GET_PRIVATE (object);
+ priv = E_CONTACT_STORE (object)->priv;
/* Free sources and cached contacts */
for (ii = 0; ii < priv->contact_sources->len; ii++) {
{
EContactStorePrivate *priv;
- priv = E_CONTACT_STORE_GET_PRIVATE (object);
+ priv = E_CONTACT_STORE (object)->priv;
g_array_free (priv->contact_sources, TRUE);
contact_sources = g_array_new (FALSE, FALSE, sizeof (ContactSource));
- contact_store->priv = E_CONTACT_STORE_GET_PRIVATE (contact_store);
+ contact_store->priv = G_TYPE_INSTANCE_GET_PRIVATE (contact_store, E_TYPE_CONTACT_STORE, EContactStorePrivate);
contact_store->priv->stamp = g_random_int ();
contact_store->priv->contact_sources = contact_sources;
}
(iter)->user_data = GINT_TO_POINTER (index); \
} G_STMT_END
-#define E_DESTINATION_STORE_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), E_TYPE_DESTINATION_STORE, EDestinationStorePrivate))
-
struct _EDestinationStorePrivate {
GPtrArray *destinations;
gint stamp;
EDestinationStorePrivate *priv;
gint ii;
- priv = E_DESTINATION_STORE_GET_PRIVATE (object);
+ priv = E_DESTINATION_STORE (object)->priv;
for (ii = 0; ii < priv->destinations->len; ii++) {
EDestination *destination;
{
EDestinationStorePrivate *priv;
- priv = E_DESTINATION_STORE_GET_PRIVATE (object);
+ priv = E_DESTINATION_STORE (object)->priv;
g_ptr_array_free (priv->destinations, TRUE);
static void
e_destination_store_init (EDestinationStore *destination_store)
{
- destination_store->priv =
- E_DESTINATION_STORE_GET_PRIVATE (destination_store);
+ destination_store->priv = G_TYPE_INSTANCE_GET_PRIVATE (destination_store, E_TYPE_DESTINATION_STORE, EDestinationStorePrivate);
destination_store->priv->destinations = g_ptr_array_new ();
destination_store->priv->stamp = g_random_int ();
}
#include "e-name-selector-dialog.h"
#include "e-name-selector-entry.h"
-#define E_NAME_SELECTOR_DIALOG_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), E_TYPE_NAME_SELECTOR_DIALOG, ENameSelectorDialogPrivate))
-
typedef struct {
gchar *name;
GtkWidget *status_message;
GtkWidget *source_combo;
- name_selector_dialog->priv =
- E_NAME_SELECTOR_DIALOG_GET_PRIVATE (name_selector_dialog);
+ name_selector_dialog->priv = G_TYPE_INSTANCE_GET_PRIVATE (name_selector_dialog, E_TYPE_NAME_SELECTOR_DIALOG, ENameSelectorDialogPrivate);
name_selector_box = gtk_vbox_new (FALSE, 6);
gtk_widget_show (name_selector_box);
{
ENameSelectorDialogPrivate *priv;
- priv = E_NAME_SELECTOR_DIALOG_GET_PRIVATE (object);
+ priv = E_NAME_SELECTOR_DIALOG (object)->priv;
g_slist_foreach (priv->user_query_fields, (GFunc)g_free, NULL);
g_slist_free (priv->user_query_fields);
g_assert (pretty_name != NULL);
g_assert (E_IS_DESTINATION_STORE (destination_store));
- priv = E_NAME_SELECTOR_DIALOG_GET_PRIVATE (name_selector_dialog);
+ priv = name_selector_dialog->priv;
memset (§ion, 0, sizeof (Section));
static void
search_changed (ENameSelectorDialog *name_selector_dialog)
{
- ENameSelectorDialogPrivate *priv = E_NAME_SELECTOR_DIALOG_GET_PRIVATE (name_selector_dialog);
+ ENameSelectorDialogPrivate *priv = name_selector_dialog->priv;
EContactStore *contact_store;
EBookQuery *book_query;
GtkWidget *combo_box;
#include "e-name-selector-entry.h"
-#define E_NAME_SELECTOR_ENTRY_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), E_TYPE_NAME_SELECTOR_ENTRY, ENameSelectorEntryPrivate))
-
struct _ENameSelectorEntryPrivate {
PangoAttrList *attr_list;
{
ENameSelectorEntryPrivate *priv;
- priv = E_NAME_SELECTOR_ENTRY_GET_PRIVATE (object);
+ priv = E_NAME_SELECTOR_ENTRY (object)->priv;
if (priv->attr_list != NULL) {
pango_attr_list_unref (priv->attr_list);
{
ENameSelectorEntryPrivate *priv;
- priv = E_NAME_SELECTOR_ENTRY_GET_PRIVATE (widget);
+ priv = E_NAME_SELECTOR_ENTRY (widget)->priv;
/* Chain up to parent's realize() method. */
GTK_WIDGET_CLASS (e_name_selector_entry_parent_class)->realize (widget);
gchar *file_as_query_str;
gchar *user_fields_str;
- priv = E_NAME_SELECTOR_ENTRY_GET_PRIVATE (name_selector_entry);
+ priv = name_selector_entry->priv;
if (!name_selector_entry->priv->contact_store)
return;
gchar *temp_str;
ENameSelectorEntryPrivate *priv;
- priv = E_NAME_SELECTOR_ENTRY_GET_PRIVATE (name_selector_entry);
+ priv = name_selector_entry->priv;
cursor_pos = gtk_editable_get_position (GTK_EDITABLE (name_selector_entry));
if (cursor_pos < 0)
{
ENameSelectorEntryPrivate *priv;
- priv = E_NAME_SELECTOR_ENTRY_GET_PRIVATE (name_selector_entry);
+ priv = name_selector_entry->priv;
if (!name_selector_entry->priv->contact_store)
return;
if (cursor_pos < 0)
return;
- priv = E_NAME_SELECTOR_ENTRY_GET_PRIVATE (name_selector_entry);
+ priv = name_selector_entry->priv;
text = gtk_entry_get_text (GTK_ENTRY (name_selector_entry));
if (!get_range_at_position (text, cursor_pos, &range_start, &range_end))
GtkCellRenderer *renderer;
GConfClient *gconf;
- name_selector_entry->priv =
- E_NAME_SELECTOR_ENTRY_GET_PRIVATE (name_selector_entry);
+ name_selector_entry->priv = G_TYPE_INSTANCE_GET_PRIVATE (name_selector_entry, E_TYPE_NAME_SELECTOR_ENTRY, ENameSelectorEntryPrivate);
g_queue_init (&name_selector_entry->priv->cancellables);
#include <libedataserverui/e-name-selector-entry.h>
#include "e-name-selector-list.h"
-#define E_NAME_SELECTOR_LIST_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), E_TYPE_NAME_SELECTOR_LIST, ENameSelectorListPrivate))
-
#define MAX_ROW 10
struct _ENameSelectorListPrivate {
EDestinationStore *store;
GtkEntryCompletion *completion;
- list->priv = E_NAME_SELECTOR_LIST_GET_PRIVATE (list);
-
+ list->priv = G_TYPE_INSTANCE_GET_PRIVATE (list, E_TYPE_NAME_SELECTOR_LIST, ENameSelectorListPrivate);
list->priv->menu = NULL;
entry = E_NAME_SELECTOR_ENTRY (list);
#include <glib/gi18n-lib.h>
#include "e-name-selector-model.h"
-#define E_NAME_SELECTOR_MODEL_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), E_TYPE_NAME_SELECTOR_MODEL, ENameSelectorModelPrivate))
-
typedef struct {
gchar *name;
gchar *pretty_name;
static void
e_name_selector_model_init (ENameSelectorModel *name_selector_model)
{
- name_selector_model->priv =
- E_NAME_SELECTOR_MODEL_GET_PRIVATE (name_selector_model);
+ name_selector_model->priv = G_TYPE_INSTANCE_GET_PRIVATE (name_selector_model, E_TYPE_NAME_SELECTOR_MODEL, ENameSelectorModelPrivate);
name_selector_model->priv->sections = g_array_new (FALSE, FALSE, sizeof (Section));
name_selector_model->priv->contact_store = e_contact_store_new ();
ENameSelectorModelPrivate *priv;
gint i;
- priv = E_NAME_SELECTOR_MODEL_GET_PRIVATE (object);
+ priv = E_NAME_SELECTOR_MODEL (object)->priv;
for (i = 0; i < priv->sections->len; i++)
free_section (E_NAME_SELECTOR_MODEL (object), i);
#include <libedataserverui/e-book-auth-util.h>
#include "e-name-selector.h"
-#define E_NAME_SELECTOR_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), E_TYPE_NAME_SELECTOR, ENameSelectorPrivate))
-
typedef struct {
gchar *name;
ENameSelectorEntry *entry;
g_return_if_fail (E_IS_NAME_SELECTOR (name_selector));
- priv = E_NAME_SELECTOR_GET_PRIVATE (name_selector);
+ priv = name_selector->priv;
for (ii = 0; ii < priv->sections->len; ii++) {
Section *section;
ENameSelectorPrivate *priv;
guint ii;
- priv = E_NAME_SELECTOR_GET_PRIVATE (object);
+ priv = E_NAME_SELECTOR (object)->priv;
if (priv->source_list != NULL) {
g_object_unref (priv->source_list);
{
ENameSelectorPrivate *priv;
- priv = E_NAME_SELECTOR_GET_PRIVATE (object);
+ priv = E_NAME_SELECTOR (object)->priv;
g_array_free (priv->source_books, TRUE);
g_array_free (priv->sections, TRUE);
sections = g_array_new (FALSE, FALSE, sizeof (Section));
source_books = g_array_new (FALSE, FALSE, sizeof (SourceBook));
- name_selector->priv = E_NAME_SELECTOR_GET_PRIVATE (name_selector);
+ name_selector->priv = G_TYPE_INSTANCE_GET_PRIVATE (name_selector, E_TYPE_NAME_SELECTOR, ENameSelectorPrivate);
name_selector->priv->sections = sections;
name_selector->priv->model = e_name_selector_model_new ();
name_selector->priv->source_books = source_books;
g_return_val_if_fail (E_IS_NAME_SELECTOR (name_selector), NULL);
g_return_val_if_fail (name != NULL, NULL);
- priv = E_NAME_SELECTOR_GET_PRIVATE (name_selector);
+ priv = name_selector->priv;
model = e_name_selector_peek_model (name_selector);
if (!e_name_selector_model_peek_section (
g_return_val_if_fail (E_IS_NAME_SELECTOR (name_selector), NULL);
g_return_val_if_fail (name != NULL, NULL);
- priv = E_NAME_SELECTOR_GET_PRIVATE (name_selector);
+ priv = name_selector->priv;
model = e_name_selector_peek_model (name_selector);
if (!e_name_selector_model_peek_section (
#include "e-source-combo-box.h"
#include "e-cell-renderer-color.h"
-#define E_SOURCE_COMBO_BOX_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), E_TYPE_SOURCE_COMBO_BOX, ESourceComboBoxPrivate))
-
G_DEFINE_TYPE (ESourceComboBox, e_source_combo_box, GTK_TYPE_COMBO_BOX)
struct _ESourceComboBoxPrivate {
{
ESourceComboBoxPrivate *priv;
- priv = E_SOURCE_COMBO_BOX_GET_PRIVATE (object);
+ priv = E_SOURCE_COMBO_BOX (object)->priv;
if (priv->source_list != NULL) {
g_signal_handler_disconnect (
{
ESourceComboBoxPrivate *priv;
- priv = E_SOURCE_COMBO_BOX_GET_PRIVATE (object);
+ priv = E_SOURCE_COMBO_BOX (object)->priv;
g_hash_table_destroy (priv->uid_index);
static void
e_source_combo_box_init (ESourceComboBox *source_combo_box)
{
- source_combo_box->priv =
- E_SOURCE_COMBO_BOX_GET_PRIVATE (source_combo_box);
-
+ source_combo_box->priv = G_TYPE_INSTANCE_GET_PRIVATE (source_combo_box, E_TYPE_SOURCE_COMBO_BOX, ESourceComboBoxPrivate);
source_combo_box->priv->uid_index =
g_hash_table_new_full (
g_str_hash, g_str_equal,
#include "e-data-server-ui-marshal.h"
#include "e-source-selector.h"
-#define E_SOURCE_SELECTOR_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), E_TYPE_SOURCE_SELECTOR, ESourceSelectorPrivate))
-
struct _ESourceSelectorPrivate {
ESourceList *list;
GtkTreeModel *model;
GtkTreeIter child_iter;
- priv = E_SOURCE_SELECTOR_GET_PRIVATE (tree_view);
+ priv = E_SOURCE_SELECTOR (tree_view)->priv;
/* Clear this because something else has been clicked on now */
priv->toggled_last = FALSE;
GtkTreePath *child_path;
GtkTreeIter child_iter;
- priv = E_SOURCE_SELECTOR_GET_PRIVATE (tree_view);
+ priv = E_SOURCE_SELECTOR (tree_view)->priv;
if (!priv->saved_primary_selection)
return;
GtkTreeStore *tree_store;
GtkTreeView *tree_view;
- selector->priv = E_SOURCE_SELECTOR_GET_PRIVATE (selector);
+ selector->priv = G_TYPE_INSTANCE_GET_PRIVATE (selector, E_TYPE_SOURCE_SELECTOR, ESourceSelectorPrivate);
priv = selector->priv;
tree_view = GTK_TREE_VIEW (selector);
(iter)->user_data2 = GINT_TO_POINTER (index); \
} G_STMT_END
-#define E_TREE_MODEL_GENERATOR_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), E_TYPE_TREE_MODEL_GENERATOR, ETreeModelGeneratorPrivate))
-
struct _ETreeModelGeneratorPrivate {
GtkTreeModel *child_model;
GArray *root_nodes;
static void
e_tree_model_generator_init (ETreeModelGenerator *tree_model_generator)
{
- tree_model_generator->priv =
- E_TREE_MODEL_GENERATOR_GET_PRIVATE (tree_model_generator);
+ tree_model_generator->priv = G_TYPE_INSTANCE_GET_PRIVATE (tree_model_generator, E_TYPE_TREE_MODEL_GENERATOR, ETreeModelGeneratorPrivate);
tree_model_generator->priv->stamp = g_random_int ();
tree_model_generator->priv->root_nodes = g_array_new (FALSE, FALSE, sizeof (Node));
G_DEFINE_TYPE (SoupSoapMessage, soup_soap_message, SOUP_TYPE_MESSAGE)
-typedef struct {
+struct _SoupSoapMessagePrivate {
/* Serialization fields */
xmlDocPtr doc;
xmlNodePtr last_node;
xmlChar *env_uri;
gboolean body_started;
gchar *action;
-} SoupSoapMessagePrivate;
-#define SOUP_SOAP_MESSAGE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUP_TYPE_SOAP_MESSAGE, SoupSoapMessagePrivate))
+};
static void
finalize (GObject *object)
{
- SoupSoapMessagePrivate *priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (object);
+ SoupSoapMessagePrivate *priv = SOUP_SOAP_MESSAGE (object)->priv;
if (priv->doc)
xmlFreeDoc (priv->doc);
static void
soup_soap_message_init (SoupSoapMessage *msg)
{
- SoupSoapMessagePrivate *priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
+ msg->priv = G_TYPE_INSTANCE_GET_PRIVATE (msg, SOUP_TYPE_SOAP_MESSAGE, SoupSoapMessagePrivate);
/* initialize XML structures */
- priv->doc = xmlNewDoc ((const xmlChar *)"1.0");
- priv->doc->standalone = FALSE;
- priv->doc->encoding = xmlCharStrdup ("UTF-8");
+ msg->priv->doc = xmlNewDoc ((const xmlChar *)"1.0");
+ msg->priv->doc->standalone = FALSE;
+ msg->priv->doc->encoding = xmlCharStrdup ("UTF-8");
}
static xmlNsPtr
fetch_ns (SoupSoapMessage *msg, const gchar *prefix, const gchar *ns_uri)
{
- SoupSoapMessagePrivate *priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
+ SoupSoapMessagePrivate *priv = msg->priv;
xmlNsPtr ns = NULL;
if (prefix && ns_uri)
SOUP_MESSAGE_URI, uri,
NULL);
- priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
priv->doc->standalone = standalone;
SoupSoapMessagePrivate *priv;
g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg));
- priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
priv->last_node = priv->doc->xmlRootNode =
xmlNewDocNode (priv->doc, NULL, (const xmlChar *)"Envelope", NULL);
SoupSoapMessagePrivate *priv;
g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg));
- priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
if (priv->body_started)
return;
SoupSoapMessagePrivate *priv;
g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg));
- priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
priv->last_node = xmlNewChild (priv->last_node, NULL, (const xmlChar *)name, NULL);
SoupSoapMessagePrivate *priv;
g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg));
- priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
priv->last_node = priv->last_node->parent;
}
SoupSoapMessagePrivate *priv;
g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg));
- priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
priv->last_node = xmlNewChild (priv->last_node,
priv->soap_ns,
SoupSoapMessagePrivate *priv;
g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg));
- priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
priv->last_node = xmlNewChild (priv->last_node,
priv->soap_ns,
SoupSoapMessagePrivate *priv;
g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg));
- priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
priv->last_node = xmlNewChild (priv->last_node, priv->soap_ns,
(const xmlChar *)"Header", NULL);
SoupSoapMessagePrivate *priv;
g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg));
- priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
soup_soap_message_start_element (msg, name, prefix, ns_uri);
if (actor_uri)
SoupSoapMessagePrivate *priv;
g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg));
- priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
xmlNodeAddContent (priv->last_node, (const xmlChar *)string);
}
SoupSoapMessagePrivate *priv;
g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg));
- priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
xmlNodeAddContentLen (priv->last_node, (const xmlChar *)buffer, len);
}
SoupSoapMessagePrivate *priv;
g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg));
- priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
xmlNewNsProp (priv->last_node, priv->xsi_ns, (const xmlChar *)"type", (const xmlChar *)xsi_type);
}
SoupSoapMessagePrivate *priv;
g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg));
- priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
xmlNewNsProp (priv->last_node, priv->xsi_ns, (const xmlChar *)"null", (const xmlChar *)"1");
}
SoupSoapMessagePrivate *priv;
g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg));
- priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
xmlNewNsProp (priv->last_node,
fetch_ns (msg, prefix, ns_uri),
SoupSoapMessagePrivate *priv;
g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg));
- priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
xmlNewNs (priv->last_node, (const xmlChar *)(ns_uri ? ns_uri : ""), (const xmlChar *)prefix);
}
SoupSoapMessagePrivate *priv;
g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg));
- priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
xmlNewNsProp (priv->last_node, priv->soap_ns, (const xmlChar *)"encodingStyle", (const xmlChar *)enc_style);
}
SoupSoapMessagePrivate *priv;
g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg));
- priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
xmlFreeDoc (priv->doc);
priv->doc = xmlNewDoc ((const xmlChar *)"1.0");
gint len;
g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg));
- priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
xmlDocDumpMemory (priv->doc, &body, &len);
xmlNsPtr ns = NULL;
g_return_val_if_fail (SOUP_IS_SOAP_MESSAGE (msg), NULL);
- priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
g_return_val_if_fail (ns_uri != NULL, NULL);
ns = xmlSearchNsByHref (priv->doc, priv->last_node, (const xmlChar *)ns_uri);
SoupSoapMessagePrivate *priv;
g_return_val_if_fail (SOUP_IS_SOAP_MESSAGE (msg), NULL);
- priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
+ priv = msg->priv;
return priv->doc;
}
#define SOUP_IS_SOAP_MESSAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SOUP_TYPE_SOAP_MESSAGE))
#define SOUP_SOAP_MESSAGE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_SOAP_MESSAGE, SoupSoapMessageClass))
+typedef struct _SoupSoapMessagePrivate SoupSoapMessagePrivate;
+
typedef struct {
SoupMessage parent;
+ SoupSoapMessagePrivate *priv;
} SoupSoapMessage;
typedef struct {
G_DEFINE_TYPE (SoupSoapResponse, soup_soap_response, G_TYPE_OBJECT)
-typedef struct {
+struct _SoupSoapResponsePrivate {
/* the XML document */
xmlDocPtr xmldoc;
xmlNodePtr xml_root;
xmlNodePtr xml_method;
xmlNodePtr soap_fault;
GList *parameters;
-} SoupSoapResponsePrivate;
-#define SOUP_SOAP_RESPONSE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUP_TYPE_SOAP_RESPONSE, SoupSoapResponsePrivate))
+};
static xmlNode *soup_xml_real_node (xmlNode *node);
static void
finalize (GObject *object)
{
- SoupSoapResponsePrivate *priv = SOUP_SOAP_RESPONSE_GET_PRIVATE (object);
+ SoupSoapResponsePrivate *priv = SOUP_SOAP_RESPONSE (object)->priv;
if (priv->xmldoc)
xmlFreeDoc (priv->xmldoc);
static void
soup_soap_response_init (SoupSoapResponse *response)
{
- SoupSoapResponsePrivate *priv = SOUP_SOAP_RESPONSE_GET_PRIVATE (response);
-
- priv->xmldoc = xmlNewDoc ((const xmlChar *)"1.0");
+ response->priv = G_TYPE_INSTANCE_GET_PRIVATE (response, SOUP_TYPE_SOAP_RESPONSE, SoupSoapResponsePrivate);
+ response->priv->xmldoc = xmlNewDoc ((const xmlChar *)"1.0");
}
/**
xmlNodePtr xml_root, xml_body, xml_method = NULL;
g_return_val_if_fail (SOUP_IS_SOAP_RESPONSE (response), FALSE);
- priv = SOUP_SOAP_RESPONSE_GET_PRIVATE (response);
+ priv = response->priv;
g_return_val_if_fail (xmlstr != NULL, FALSE);
/* clear the previous contents */
SoupSoapResponsePrivate *priv;
g_return_val_if_fail (SOUP_IS_SOAP_RESPONSE (response), NULL);
- priv = SOUP_SOAP_RESPONSE_GET_PRIVATE (response);
+ priv = response->priv;
g_return_val_if_fail (priv->xml_method != NULL, NULL);
return (const gchar *) priv->xml_method->name;
SoupSoapResponsePrivate *priv;
g_return_if_fail (SOUP_IS_SOAP_RESPONSE (response));
- priv = SOUP_SOAP_RESPONSE_GET_PRIVATE (response);
+ priv = response->priv;
g_return_if_fail (priv->xml_method != NULL);
g_return_if_fail (method_name != NULL);
SoupSoapResponsePrivate *priv;
g_return_val_if_fail (SOUP_IS_SOAP_RESPONSE (response), NULL);
- priv = SOUP_SOAP_RESPONSE_GET_PRIVATE (response);
+ priv = response->priv;
return (const GList *) priv->parameters;
}
SoupSoapResponsePrivate *priv;
g_return_val_if_fail (SOUP_IS_SOAP_RESPONSE (response), NULL);
- priv = SOUP_SOAP_RESPONSE_GET_PRIVATE (response);
+ priv = response->priv;
return priv->parameters ? priv->parameters->data : NULL;
}
GList *l;
g_return_val_if_fail (SOUP_IS_SOAP_RESPONSE (response), NULL);
- priv = SOUP_SOAP_RESPONSE_GET_PRIVATE (response);
+ priv = response->priv;
g_return_val_if_fail (name != NULL, NULL);
for (l = priv->parameters; l != NULL; l = l->next) {
GList *l;
g_return_val_if_fail (SOUP_IS_SOAP_RESPONSE (response), NULL);
- priv = SOUP_SOAP_RESPONSE_GET_PRIVATE (response);
+ priv = response->priv;
g_return_val_if_fail (from != NULL, NULL);
l = g_list_find (priv->parameters, (gconstpointer) from);
xmlChar *xmlbuff;
gint buffersize, ret;
- SoupSoapResponsePrivate *priv = SOUP_SOAP_RESPONSE_GET_PRIVATE (response);
+ SoupSoapResponsePrivate *priv = response->priv;
xmlDocDumpFormatMemory (priv->xmldoc, &xmlbuff, &buffersize, 1);
ret = fputs ((gchar *) xmlbuff, buffer);
#define SOUP_IS_SOAP_RESPONSE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SOUP_TYPE_SOAP_RESPONSE))
#define SOUP_SOAP_RESPONSE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_SOAP_RESPONSE, SoupSoapResponseClass))
+typedef struct _SoupSoapResponsePrivate SoupSoapResponsePrivate;
+
typedef struct {
GObject parent;
+ SoupSoapResponsePrivate *priv;
} SoupSoapResponse;
typedef struct {
projects / platform / upstream / evolution-data-server.git / commitdiff