Changeset Navigation

← Previous Changeset
Next Changeset →

Changeset 573

Timestamp:

07/12/06 21:45:59

Author:

pvanhoof

Message:

Smaller header instances

Files:

trunk/libtinymail-camel/tny-msg-folder.c (modified) (1 diff)
trunk/libtinymail-camel/tny-msg-header-priv.h (modified) (1 diff)
trunk/libtinymail-camel/tny-msg-header.c (modified) (31 diffs)
trunk/libtinymail-camel/tny-msg-header.h (modified) (1 diff)
trunk/libtinymail-camel/tny-msg.c (modified) (1 diff)
trunk/libtinymail/tny-msg-header-iface.c (modified) (1 diff)
trunk/libtinymail/tny-msg-header-iface.h (modified) (2 diffs)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

trunk/libtinymail-camel/tny-msg-folder.c

r548	r573
342	342	TnyMsgFolderPriv *priv = ptr->priv;
343	343	TnyListIface *headers = ptr->headers;
	344	CamelFolder *cfol = _tny_msg_folder_get_camel_folder (self);
344	345
345	346	/* TODO: Proxy instantiation (happens a lot, could use a pool) */
346	347	header = TNY_MSG_HEADER_IFACE (tny_msg_header_new ());
347	348
348		~~tny_msg_header_set_use_summary (TNY_MSG_HEADER (header),~~
349		~~priv->has_summary_cap);~~
350
351	349	tny_msg_header_iface_set_folder (header, self);
352		tny_msg_header_iface_set_uid (header, uid);
	350	_tny_msg_header_set_camel_message_info (header,
	351	camel_folder_get_message_info (cfol, uid));
353	352
354	353	tny_list_iface_prepend (headers, header);

trunk/libtinymail-camel/tny-msg-header-priv.h

r483	r573
27	27	void _tny_msg_header_set_camel_mime_message (TnyMsgHeader self, CamelMimeMessage camel_mime_message);
28	28	CamelMimeMessage* _tny_msg_header_get_camel_mime_message (TnyMsgHeader *self);
29		~~gboolean _tny_msg_header_get_is_pop (TnyMsgHeader *self);~~
30	29
31	30	#endif

trunk/libtinymail-camel/tny-msg-header.c

r570	r573
41	41	static GObjectClass *parent_class = NULL;
42	42
	43	typedef struct _WriteInfo WriteInfo;
	44	struct _WriteInfo
	45	{
	46	CamelMimeMessage *msg;
	47	gchar *mime_from;
	48	};
	49
	50	#pragma pack(1) /* Size will be 21 in stead of 24 */
43	51	struct _TnyMsgHeader
44	52	{
45	53	GObject parent;
46
47		gchar *uid;
	54	void *info;
	55
48	56	TnyMsgFolderIface *folder;
49		gboolean use_summary;
50		GMutex *hdr_lock;
51		CamelMessageInfo *message_info;
52		CamelMimeMessage *mime_message;
53		gchar *mime_from;
54		const gchar *invalid;
55		gboolean uncachable;
	57	guchar write:1;
56	58	};
57	59
…	…
61	63	};
62	64
63		gboolean
64		_tny_msg_header_get_is_pop (TnyMsgHeader *self)
65		{
66		/* All summary types aren't pop atm ;-) */
67		return (!self->use_summary);
68		}
69
70		void
71		_tny_msg_header_set_not_uncachable (TnyMsgHeader *self)
72		{
73		self->uncachable = FALSE;
74		return;
75		}
76
77		static void
78		unload_msg_header (TnyMsgHeader *self)
79		{
80		if (G_UNLIKELY (!self->uncachable))
81		return;
82
83		if (G_LIKELY (self->mime_from))
84		{
85		g_free (self->mime_from);
86		self->mime_from = NULL;
87		}
88		if (G_LIKELY (self->use_summary))
89		{
90		if (G_LIKELY (self->message_info))
91		{
92		/* It looks like this conflicts with freeing the folder
93		camel_message_info_free (self->message_info);
94		self->message_info = NULL; */
95		}
96		} else {
97		if (G_LIKELY (self->mime_message) && G_LIKELY (CAMEL_IS_OBJECT (self->mime_message)))
98		camel_object_unref (CAMEL_OBJECT (self->mime_message));
99		self->mime_message = NULL;
100		}
101
102		return;
103		}
104
105		/**
106		* tny_msg_header_set_use_summary:
107		* @self: The #TnyMsgHeader instance
108		* @val: Whether or not to use summary capabilities
109		*
110		**/
111		void
112		tny_msg_header_set_use_summary (TnyMsgHeader *self, gboolean val)
113		{
114		g_mutex_lock (self->hdr_lock);
115		unload_msg_header (self);
116		self->use_summary = val;
117		g_mutex_unlock (self->hdr_lock);
118
119		return;
120		}
121
122		static void
123		load_msg_header (TnyMsgHeader *self)
124		{
125
126		if (G_UNLIKELY (!self->uncachable))
127		return;
128
129		if (G_LIKELY (self->use_summary))
130		{
131		if (G_LIKELY (!self->message_info) && G_LIKELY (self->folder) && G_LIKELY (self->uid))
132		{
133		CamelFolder *folder = _tny_msg_folder_get_camel_folder (self->folder);
134		CamelMessageInfo *msginfo;
135
136		if (folder)
137		{
138		msginfo = camel_folder_get_message_info (folder, self->uid);
139		_tny_msg_header_set_camel_message_info (self, msginfo);
140		}
141		}
142		} else {
143		if (G_LIKELY (!self->mime_message) && G_LIKELY (self->folder) && G_LIKELY (self->uid))
144		{
145		CamelFolder *folder = _tny_msg_folder_get_camel_folder (self->folder);
146		CamelException ex = CAMEL_EXCEPTION_INITIALISER;
147
148		if (folder)
149		{
150		self->mime_message = camel_folder_get_message
151		(folder, self->uid, &ex);
152		}
153		}
154		}
155
156		return;
	65	static const gchar *invalid = "Invalid";
	66
	67	static void
	68	destroy_write (TnyMsgHeader *self)
	69	{
	70	if (((WriteInfo*)self->info)->msg)
	71	camel_object_unref (CAMEL_OBJECT (((WriteInfo*)self->info)->msg));
	72
	73	if (((WriteInfo*)self->info)->mime_from)
	74	g_free (((WriteInfo*)self->info)->mime_from);
	75
	76	g_free (self->info);
157	77	}
158	78
…	…
160	80	prepare_for_write (TnyMsgHeader *self)
161	81	{
162		unload_msg_header (self);
163
164		self->use_summary = FALSE;
165
166		if (G_LIKELY (!self->mime_message))
167		self->mime_message = camel_mime_message_new ();
168
169		_tny_msg_header_set_not_uncachable (self);
	82	if (!self->write)
	83	{
	84	self->info = g_new0 (WriteInfo, 1);
	85	((WriteInfo*)self->info)->msg = camel_mime_message_new ();
	86	((WriteInfo*)self->info)->mime_from = NULL;
	87	self->write = 1;
	88	}
170	89
171	90	return;
…	…
175	94	_tny_msg_header_set_camel_message_info (TnyMsgHeader self, CamelMessageInfo camel_message_info)
176	95	{
177
178		if (G_UNLIKELY (self->message_info))
	96	if (G_UNLIKELY (self->info))
179	97	g_warning ("Strange behaviour: Overwriting existing message info");
180	98
181		self->message_info = camel_message_info;
	99	if (self->write)
	100	destroy_write (self);
	101
	102	self->info = camel_message_info;
	103	self->write = 0;
182	104
183	105	return;
…	…
187	109	_tny_msg_header_get_camel_mime_message (TnyMsgHeader *self)
188	110	{
189		CamelMimeMessage *retval;
190
191		retval = self->mime_message;
192
193		return retval;
	111
	112	if (G_UNLIKELY (self->write == 0))
	113	{
	114	g_warning ("Strange behaviour: the header was not written");
	115	return NULL;
	116	}
	117
	118	return ((WriteInfo*)self->info)->msg;
	119
194	120	}
195	121
…	…
198	124	{
199	125
200		if (G_UNLIKELY (self->~~mime_message~~))
	126	if (G_UNLIKELY (self->info))
201	127	g_warning (_("Strange behaviour: Overwriting existing MIME message"));
202	128
203		self->mime_message = camel_mime_message;
204
205		return;
206		}
207
208		const TnyMsgFolderIface*
209		tny_msg_header_get_folder (TnyMsgHeaderIface *self)
210		{
211		TnyMsgHeader *me = TNY_MSG_HEADER (self);
212		const TnyMsgFolderIface *retval;
213
214		g_mutex_lock (me->hdr_lock);
215		retval = me->folder;
216		g_mutex_unlock (me->hdr_lock);
217
218		return retval;
219		}
220
221
222		void
223		tny_msg_header_set_folder (TnyMsgHeaderIface self, const TnyMsgFolderIface folder)
224		{
225		TnyMsgHeader *me = TNY_MSG_HEADER (self);
226
227		if (G_UNLIKELY (me->folder))
228		g_warning (_("Strange behaviour: Overwriting existing folder"));
229
230		g_mutex_lock (me->hdr_lock);
231		me->folder = (TnyMsgFolderIface*)folder;
232		g_mutex_unlock (me->hdr_lock);
233
234		return;
235		}
	129	if (self->write)
	130	destroy_write (self);
	131
	132	self->info = g_new0 (WriteInfo, 1);
	133	((WriteInfo*)self->info)->msg = camel_mime_message;
	134	((WriteInfo*)self->info)->mime_from = NULL;\
	135	self->write = 1;
	136
	137	return;
	138	}
	139
236	140
237	141
…	…
240	144	{
241	145	TnyMsgHeader *me = TNY_MSG_HEADER (self);
242		const gchar *retval=NULL;
243
244		g_mutex_lock (me->hdr_lock);
245		load_msg_header (me);
	146	const gchar *retval = NULL;
	147
246	148	/* TODO get_replyto */
247		~~g_mutex_unlock (me->hdr_lock);~~
248	149
249	150	return retval;
…	…
258	159	CamelInternetAddress *addr = camel_internet_address_new ();
259	160
260		~~g_mutex_lock (me->hdr_lock);~~
261
262	161	_foreach_email_add_to_inet_addr (bcc, addr);
263	162
264	163	prepare_for_write (me);
265	164
266		camel_mime_message_set_recipients (~~me->mime_message~~,
	165	camel_mime_message_set_recipients (((WriteInfo*)me->info)->msg,
267	166	CAMEL_RECIPIENT_TYPE_BCC, addr);
268	167
269	168	camel_object_unref (CAMEL_OBJECT (addr));
270	169
271		~~g_mutex_unlock (me->hdr_lock);~~
272
273	170	return;
274	171	}
…	…
280	177	CamelInternetAddress *addr = camel_internet_address_new ();
281	178
282		~~g_mutex_lock (me->hdr_lock);~~
283
284	179	_foreach_email_add_to_inet_addr (cc, addr);
285	180
286	181	prepare_for_write (me);
287	182
288		camel_mime_message_set_recipients (~~me->mime_message~~,
	183	camel_mime_message_set_recipients (((WriteInfo*)me->info)->msg,
289	184	CAMEL_RECIPIENT_TYPE_CC, addr);
290
291	185	camel_object_unref (CAMEL_OBJECT (addr));
292
293		~~g_mutex_unlock (me->hdr_lock);~~
294	186
295	187	return;
…	…
302	194	CamelInternetAddress *addr = camel_internet_address_new ();
303	195	gchar *dup;
304
305		~~g_mutex_lock (me->hdr_lock);~~
306	196
307	197	dup = g_strdup (from);
…	…
311	201	prepare_for_write (me);
312	202
313		camel_mime_message_set_from (~~me->mime_message~~, addr);
	203	camel_mime_message_set_from (((WriteInfo*)me->info)->msg, addr);
314	204	camel_object_unref (CAMEL_OBJECT (addr));
315	205
316		~~g_mutex_unlock (me->hdr_lock);~~
317
318	206	return;
319	207	}
…	…
324	212	TnyMsgHeader *me = TNY_MSG_HEADER (self);
325	213
326		~~g_mutex_lock (me->hdr_lock);~~
327
328	214	prepare_for_write (me);
329
330		camel_mime_message_set_subject (me->mime_message, subject);
331
332		g_mutex_unlock (me->hdr_lock);
	215	camel_mime_message_set_subject (((WriteInfo*)me->info)->msg, subject);
333	216
334	217	return;
…	…
342	225	gchar *dup;
343	226
344		~~g_mutex_lock (me->hdr_lock);~~
345
346	227	dup = g_strdup (to);
347
348	228	_foreach_email_add_to_inet_addr (dup, addr);
349
350	229	g_free (dup);
351	230
352	231	prepare_for_write (me);
353	232
354		camel_mime_message_set_recipients (~~me->mime_message~~,
	233	camel_mime_message_set_recipients ((CamelMimeMessage*)me->info,
355	234	CAMEL_RECIPIENT_TYPE_TO, addr);
356	235
357	236	camel_object_unref (CAMEL_OBJECT (addr));
358	237
359		~~g_mutex_unlock (me->hdr_lock);~~
360
361	238	return;
362	239	}
…	…
368	245	TnyMsgHeader *me = TNY_MSG_HEADER (self);
369	246
370		~~g_mutex_lock (me->hdr_lock);~~
371		~~prepare_for_write (me);~~
372	247	/* TODO set replyto */
373		~~g_mutex_unlock (me->hdr_lock);~~
374	248
375	249	return;
…	…
381	255	{
382	256	TnyMsgHeader *me = TNY_MSG_HEADER (self);
383
384		const gchar *retval=NULL;
385
386		g_mutex_lock (me->hdr_lock);
387
388		load_msg_header (me);
389
390		if (G_LIKELY (me->use_summary) && G_LIKELY (me->message_info))
391		retval = camel_message_info_cc (me->message_info);
392		else if (G_LIKELY (me->mime_message))
393		retval = camel_medium_get_header (CAMEL_MEDIUM (me->mime_message), "cc");
394
395		if (G_UNLIKELY (!retval))
396		retval = me->invalid;
397
398		g_mutex_unlock (me->hdr_lock);
	257	const gchar *retval;
	258
	259	if (G_UNLIKELY (!me->info))
	260	return invalid;
	261
	262	if (G_UNLIKELY (me->write))
	263	retval = camel_medium_get_header (CAMEL_MEDIUM (((WriteInfo*)me->info)->msg), "cc");
	264	else
	265	retval = camel_message_info_cc ((CamelMessageInfo*)me->info);
399	266
400	267	return retval;
…	…
405	272	{
406	273	TnyMsgHeader *me = TNY_MSG_HEADER (self);
407
408		static const gchar *retval=NULL;
409
410		g_mutex_lock (me->hdr_lock);
411
412		load_msg_header (me);
413
414		if (G_LIKELY (me->use_summary)) /* TODO get_bcc */
415		retval = me->invalid;
416		else if (G_LIKELY (me->mime_message))
417		retval = camel_medium_get_header (CAMEL_MEDIUM (me->mime_message), "bcc");
418
419		if (G_UNLIKELY (!retval))
420		retval = me->invalid;
421
422		g_mutex_unlock (me->hdr_lock);
	274	const gchar *retval;
	275
	276	if (G_UNLIKELY (!me->info))
	277	return invalid;
	278
	279	if (G_UNLIKELY (me->write))
	280	retval = camel_medium_get_header (CAMEL_MEDIUM (((WriteInfo*)me->info)->msg), "bcc");
	281	else
	282	retval = invalid;
423	283
424	284	return retval;
…	…
429	289	{
430	290	TnyMsgHeader *me = TNY_MSG_HEADER (self);
431
432	291	TnyMsgHeaderFlags retval;
433	292
434		g_mutex_lock (me->hdr_lock);
435
436		load_msg_header (me);
437
438		if (G_LIKELY (me->use_summary) && G_LIKELY (me->message_info))
439		retval = camel_message_info_flags (me->message_info);
440
441		g_mutex_unlock (me->hdr_lock);
442
443		return (TnyMsgHeaderFlags)retval;
	293	if (me->write)
	294	{
	295	g_warning ("tny_msg_header_get_flags: This is a header for a new message!\n");
	296	return retval;
	297	}
	298
	299	retval = camel_message_info_flags ((CamelMessageInfo*)me->info);
	300
	301	return retval;
444	302	}
445	303
…	…
449	307	TnyMsgHeader *me = TNY_MSG_HEADER (self);
450	308
451		g_mutex_lock (me->hdr_lock);
452
453		prepare_for_write (me);
454
455		if (G_LIKELY (me->use_summary) && G_LIKELY (me->message_info))
456		camel_message_info_set_flags (me->message_info, mask, ~0);
457
458		g_mutex_unlock (me->hdr_lock);
	309	if (me->write)
	310	{
	311	g_warning ("tny_msg_header_get_flags: This is a header for a new message!\n");
	312	return;
	313	}
	314
	315	camel_message_info_set_flags ((CamelMessageInfo*)me->info, mask, ~0);
	316
	317	return;
459	318	}
460	319
…	…
464	323	TnyMsgHeader *me = TNY_MSG_HEADER (self);
465	324
466		g_mutex_lock (me->hdr_lock);
467
468		prepare_for_write (me);
469
470		if (G_LIKELY (me->use_summary) && G_LIKELY (me->message_info))
471		camel_message_info_set_flags (me->message_info, mask, 0);
472
473		g_mutex_unlock (me->hdr_lock);
	325	if (me->write)
	326	{
	327	g_warning ("tny_msg_header_get_flags: This is a header for a new message!\n");
	328	return;
	329	}
	330
	331	camel_message_info_set_flags ((CamelMessageInfo*)me->info, mask, 0);
	332
	333	return;
474	334	}
475	335
…	…
481	341	time_t retval;
482	342
483		g_mutex_lock (me->hdr_lock);
484
485		load_msg_header (me);
486
487		if (G_LIKELY (me->use_summary) && G_LIKELY (me->message_info))
488		retval = camel_message_info_date_received (me->message_info);
489		else if (G_LIKELY (me->mime_message))
490		retval = camel_mime_message_get_date_received (me->mime_message, NULL);
491
492		g_mutex_unlock (me->hdr_lock);
	343	if (G_UNLIKELY (!me->info))
	344	return retval;
	345
	346	if (G_UNLIKELY (me->write))
	347	retval = camel_mime_message_get_date_received (((WriteInfo*)me->info)->msg, NULL);
	348	else
	349	retval = camel_message_info_date_received ((CamelMessageInfo*)me->info);
493	350
494	351	return retval;
…	…
502	359	time_t retval;
503	360
504		g_mutex_lock (me->hdr_lock);
505
506		load_msg_header (me);
507
508		if (G_LIKELY (me->use_summary) && G_LIKELY (me->message_info))
509		retval = camel_message_info_date_sent (me->message_info);
510		else {
511		/* TODO: write case get_date_sent */
512		}
513
514		g_mutex_unlock (me->hdr_lock);
	361	if (G_UNLIKELY (!me->info) \|\| G_UNLIKELY (me->write))
	362	return retval;
	363
	364	retval = camel_message_info_date_received ((CamelMessageInfo*)me->info);
515	365
516	366	return retval;
…	…
522	372	TnyMsgHeader *me = TNY_MSG_HEADER (self);
523	373
524		const gchar *retval=NULL;
525
526		g_mutex_lock (me->hdr_lock);
527
528		load_msg_header (me);
529
530		if (G_LIKELY (me->use_summary) && G_LIKELY (me->message_info))
531		retval = camel_message_info_from (me->message_info);
532		else
533		{
534		if (G_LIKELY (!me->mime_from) && G_LIKELY (me->mime_message))
	374	const gchar *retval;
	375
	376	if (G_UNLIKELY (!me->info))
	377	return invalid;
	378
	379	if (G_UNLIKELY (me->write))
	380	{
	381	if (G_LIKELY (!((WriteInfo*)me->info)->mime_from))
535	382	{
536	383	CamelInternetAddress addr = (CamelInternetAddress)
537		camel_mime_message_get_from (me->mime_message);
538		me->mime_from = camel_address_format (CAMEL_ADDRESS (addr));
539		/* camel_object_unref (CAMEL_OBJECT (addr)); */
	384	camel_mime_message_get_from (((WriteInfo*)me->info)->msg);
	385	((WriteInfo*)me->info)->mime_from = camel_address_format (CAMEL_ADDRESS (addr));
540	386	}
541	387
542		retval = (const gchar*)me->mime_from;
543		}
544
545		if (G_UNLIKELY (!retval))
546		retval = me->invalid;
547
548		g_mutex_unlock (me->hdr_lock);
	388	retval = (const gchar)((WriteInfo)me->info)->mime_from;
	389	} else
	390	retval = camel_message_info_from ((CamelMimeMessage*)me->info);
549	391
550	392	return retval;
…	…
555	397	{
556	398	TnyMsgHeader *me = TNY_MSG_HEADER (self);
557		const gchar *retval=NULL;
558
559		g_mutex_lock (me->hdr_lock);
560
561		load_msg_header (me);
562
563		if (G_LIKELY (me->use_summary) && G_LIKELY (me->message_info))
564		retval = camel_message_info_subject (me->message_info);
565		else if (G_LIKELY (me->mime_message))
566		retval = camel_mime_message_get_subject (me->mime_message);
567
568		if (G_UNLIKELY (!retval))
569		retval = me->invalid;
570
571		g_mutex_unlock (me->hdr_lock);
	399	const gchar *retval;
	400
	401	if (G_UNLIKELY (!me->info))
	402	return invalid;
	403
	404	if (G_UNLIKELY (me->write))
	405	retval = camel_mime_message_get_subject (((WriteInfo*)me->info)->msg);
	406	else
	407	retval = camel_message_info_subject ((CamelMessageInfo*)me->info);
572	408
573	409	return retval;
…	…
579	415	{
580	416	TnyMsgHeader *me = TNY_MSG_HEADER (self);
581
582		const gchar *retval=NULL;
583
584		g_mutex_lock (me->hdr_lock);
585
586		load_msg_header (me);
587
588		if (G_LIKELY (me->use_summary) && G_LIKELY (me->message_info))
589		retval = camel_message_info_to (me->message_info);
590		else if (G_LIKELY (me->mime_message))
591		retval = camel_medium_get_header (CAMEL_MEDIUM (me->mime_message), "to");
592
593		if (G_UNLIKELY (!retval))
594		retval = me->invalid;
595
596		g_mutex_unlock (me->hdr_lock);
597
598		return retval;
	417	gchar *retval;
	418
	419	if (G_UNLIKELY (!me->info))
	420	return invalid;
	421
	422	if (G_UNLIKELY (me->write))
	423	retval = (gchar) camel_medium_get_header (CAMEL_MEDIUM (((WriteInfo)me->info)->msg), "to");
	424	else
	425	retval = (gchar) camel_message_info_to ((CamelMessageInfo)me->info);
	426
	427	return (const gchar*)retval;
599	428	}
600	429
…	…
603	432	{
604	433	TnyMsgHeader *me = TNY_MSG_HEADER (self);
605
606		const gchar *retval=NULL;
607
608		g_mutex_lock (me->hdr_lock);
609
610		load_msg_header (me);
611
612		if (G_LIKELY (me->use_summary) && G_LIKELY (me->message_info))
613		retval = (const gchar*)camel_message_info_message_id (me->message_info);
614		else if (G_LIKELY (me->mime_message))
615		retval = camel_mime_message_get_message_id (me->mime_message);
616
617		if (G_UNLIKELY (!retval))
618		retval = me->invalid;
619
620		g_mutex_unlock (me->hdr_lock);
621
622		return retval;
	434	gchar *retval;
	435
	436	if (G_UNLIKELY (!me->info))
	437	return invalid;
	438
	439	if (G_UNLIKELY (me->write))
	440	retval = (gchar) camel_mime_message_get_message_id (((WriteInfo)me->info)->msg);
	441	else
	442	retval = (gchar) camel_message_info_message_id ((CamelMessageInfo)me->info);
	443
	444	return (const gchar*)retval;
	445
623	446
624	447	}
…	…
629	452	{
630	453	TnyMsgHeader *me = TNY_MSG_HEADER (self);
631
632	454	const gchar *retval;
633	455
634		g_mutex_lock (me->hdr_lock);
635
636		load_msg_header (me);
637
638		if (G_LIKELY (me->use_summary) && G_LIKELY (me->message_info))
639		retval = camel_message_info_uid (me->message_info);
640		else /* Bleh solution ... */
641		retval = me->uid;
642
643		g_mutex_unlock (me->hdr_lock);
644
645		return retval;
646		}
647
648		static void
649		tny_msg_header_set_uid (TnyMsgHeaderIface self, const gchar uid)
650		{
651		TnyMsgHeader *me = TNY_MSG_HEADER (self);
652
653		g_mutex_lock (me->hdr_lock);
654
655		unload_msg_header (me);
656
657		/* Speedup trick, also check tny-msg-folder.c */
658		/* if (priv->uid)
659		g_free (priv->uid);
660		priv->uid = g_strdup (uid); */
661
662		/* Yes I know what I'm doing, also check tny-msg-folder.c */
663
664		if (G_LIKELY (me->use_summary))
665		me->uid = (gchar*)uid;
666		else {
667		/* NEED TO INVESTIGATE THIS
668		For some reason the trick doesn't work if you don't
669		have support for summaries */
670		if (me->uid)
671		g_free (me->uid);
672		me->uid = g_strdup (uid);
673		/* TODO: And if I AM going to do it this way, I need to lock
674		priv->uid */
675		}
676
677		g_mutex_unlock (me->hdr_lock);
678
679		return;
	456	if (G_UNLIKELY (!me->info) \|\| G_UNLIKELY (me->write))
	457	return invalid;
	458
	459	retval = camel_message_info_uid ((CamelMessageInfo*)me->info);
680	460	}
681	461
…	…
685	465	{
686	466	TnyMsgHeader *me = TNY_MSG_HEADER (self);
687
688		gboolean retval;
689
690		g_mutex_lock (me->hdr_lock);
691
692		if (G_LIKELY (me->use_summary))
693		retval = (me->message_info != NULL);
694		else
695		retval = (me->mime_message != NULL);
696
697		g_mutex_unlock (me->hdr_lock);
698
699		return retval;
	467	return (me->info != NULL);
700	468	}
701	469
…	…
703	471	tny_msg_header_uncache (TnyMsgHeaderIface *self)
704	472	{
705		~~TnyMsgHeader *me = TNY_MSG_HEADER (self);~~
706
707		~~g_mutex_lock (me->hdr_lock);~~
708
709		~~if (G_LIKELY (me->use_summary) && G_LIKELY (me->message_info))~~
710		~~unload_msg_header (me);~~
711
712		~~if (G_UNLIKELY (!me->use_summary) && G_LIKELY (me->mime_message))~~
713		~~unload_msg_header (me);~~
714
715		~~g_mutex_unlock (me->hdr_lock);~~
716
717	473	return;
718	474	}
…	…
723	479	TnyMsgHeader self = (TnyMsgHeader) object;
724	480
725		g_mutex_lock (self->hdr_lock);
726
727		/* Instance is going to dissapear, set uncachable as we
728		reuse the functionality */
729		self->uncachable = TRUE;
730
731		if (G_LIKELY (self->use_summary) && G_LIKELY (self->message_info))
732		unload_msg_header (self);
733
734		if (G_UNLIKELY (!self->use_summary) && G_LIKELY (self->mime_message))
735		unload_msg_header (self);
736
737		/* Indeed, check the speedup trick above */
738		if (G_LIKELY (self->uid) && G_UNLIKELY (!self->use_summary))
739		g_free (self->uid); /* Also check above */
740
741		g_mutex_unlock (self->hdr_lock);
742
743		g_mutex_free (self->hdr_lock);
	481	if (G_UNLIKELY (self->write))
	482	{
	483	destroy_write (self);
	484	}
744	485
745	486	(*parent_class->finalize) (object);
…	…
758	499	{
759	500	TnyMsgHeader *self = g_object_new (TNY_TYPE_MSG_HEADER, NULL);
760		static const gchar *inv = "Invalid";
761
762		self->uncachable = TRUE;
763		self->invalid = inv;
764		self->mime_message = NULL;
765		self->message_info = NULL;
766		self->mime_from = NULL;
767
768		/* Second allocation :-( */
769		self->hdr_lock = g_mutex_new ();
	501
	502	self->info = NULL;
	503	self->write = 0;
770	504
771	505	return self;
772	506	}
773	507
	508	static void
	509	tny_msg_header_set_folder (TnyMsgHeaderIface self, const TnyMsgFolderIface folder)
	510	{
	511	TnyMsgHeader *me = TNY_MSG_HEADER (self);
	512	me->folder = (TnyMsgFolderIface*)folder;
	513	return;
	514	}
	515
	516	static const TnyMsgFolderIface*
	517	tny_msg_header_get_folder (TnyMsgHeaderIface *self)
	518	{
	519	TnyMsgHeader *me = TNY_MSG_HEADER (self);
	520	return (const TnyMsgFolderIface*)me->folder;
	521	}
774	522
775	523	static void
…	…
788	536	klass->get_replyto_func = tny_msg_header_get_replyto;
789	537	klass->get_uid_func = tny_msg_header_get_uid;
790		~~klass->set_uid_func = tny_msg_header_set_uid;~~
791	538	klass->set_folder_func = tny_msg_header_set_folder;
792	539	klass->get_folder_func = tny_msg_header_get_folder;

trunk/libtinymail-camel/tny-msg-header.h

r376 r573

44 44
45 45
46 ~~void tny_msg_header_set_use_summary (TnyMsgHeader *self, gboolean val);~~
47
48 46 G_END_DECLS
49 47

trunk/libtinymail-camel/tny-msg.c

r552	r573
332	332	message = _tny_msg_header_get_camel_mime_message (TNY_MSG_HEADER (priv->header));
333	333
334		~~if (G_UNLIKELY (message))~~
335		~~_tny_msg_set_camel_mime_message (TNY_MSG (self), message,~~
336		~~_tny_msg_header_get_is_pop (TNY_MSG_HEADER (priv->header)));~~
337
338	334	g_mutex_unlock (priv->header_lock);
339	335

trunk/libtinymail/tny-msg-header-iface.c

r570	r573
436	436	}
437	437
438		/**
439		* tny_msg_header_iface_set_message_id:
440		* @self: a #TnyMsgHeaderIface object
441		* @id: an unique follow-up uid
442		*
443		*
444		**/
445		~~void~~
446		~~tny_msg_header_iface_set_uid (TnyMsgHeaderIface self, const gchar id)~~
447		{
448		~~#ifdef DEBUG~~
449		~~if (!TNY_MSG_HEADER_IFACE_GET_CLASS (self)->set_uid_func)~~
450		~~g_critical ("You must implement tny_msg_header_iface_set_uid\n");~~
451		~~#endif~~
452
453		~~TNY_MSG_HEADER_IFACE_GET_CLASS (self)->set_uid_func (self, id);~~
454		~~return;~~
455		}
456
457	438
458	439	/**

trunk/libtinymail/tny-msg-header-iface.h

r570	r573
79	79	time_t (get_date_sent_func) (TnyMsgHeaderIface self);
80	80
81		~~void (set_uid_func) (TnyMsgHeaderIface self, const gchar *uid);~~
82	81	void (set_bcc_func) (TnyMsgHeaderIface self, const gchar *bcc);
83	82	void (set_cc_func) (TnyMsgHeaderIface self, const gchar *cc);
…	…
102	101	GType tny_msg_header_iface_get_type (void);
103	102
104		~~void tny_msg_header_iface_set_uid (TnyMsgHeaderIface self, const gchar uid);~~
105	103	const gchar* tny_msg_header_iface_get_uid (TnyMsgHeaderIface *self);
106	104

Download in other formats: