well this makes things fail for people ...
[apps/madmutt.git] / flags.c
1 /*
2  * Copyright notice from original mutt:
3  * Copyright (C) 1996-2000 Michael R. Elkins <me@mutt.org>
4  *
5  * This file is part of mutt-ng, see http://www.muttng.org/.
6  * It's licensed under the GNU General Public License,
7  * please see the file GPL in the top level source directory.
8  */
9
10 #include <lib-lib/lib-lib.h>
11
12 #include <lib-ui/lib-ui.h>
13 #include <lib-ui/menu.h>
14 #include <lib-mx/mx.h>
15 #include <imap/imap.h>
16
17 #include "mutt.h"
18 #include "sort.h"
19
20
21 void _mutt_set_flag (CONTEXT * ctx, HEADER * h, int flag, int bf, int upd_ctx)
22 {
23   int changed = h->changed;
24   int deleted = ctx->deleted;
25   int tagged = ctx->tagged;
26   int flagged = ctx->flagged;
27
28   if (ctx->readonly && flag != M_TAG)
29     return;                     /* don't modify anything if we are read-only */
30
31   switch (flag) {
32   case M_DELETE:
33
34     if (!mx_acl_check (ctx, ACL_DELETE))
35       return;
36
37     if (bf) {
38       if (!h->deleted && !ctx->readonly) {
39         h->deleted = 1;
40         if (upd_ctx)
41           ctx->deleted++;
42         /* deleted messages aren't treated as changed elsewhere so that the
43          * purge-on-sync option works correctly. This isn't applicable here */
44         if (ctx && ctx->magic == M_IMAP) {
45           h->changed = 1;
46           if (upd_ctx)
47             ctx->changed = 1;
48         }
49       }
50     }
51     else if (h->deleted) {
52       h->deleted = 0;
53       if (upd_ctx) {
54         ctx->deleted--;
55         if (h->appended)
56           ctx->appended--;
57       }
58       h->appended = 0;          /* when undeleting, also reset the appended flag */
59       /* see my comment above */
60       if (ctx->magic == M_IMAP) {
61         h->changed = 1;
62         if (upd_ctx)
63           ctx->changed = 1;
64       }
65       /* 
66        * If the user undeletes a message which is marked as
67        * "trash" in the maildir folder on disk, the folder has
68        * been changed, and is marked accordingly.  However, we do
69        * _not_ mark the message itself changed, because trashing
70        * is checked in specific code in the maildir folder
71        * driver. 
72        */
73       if (ctx->magic == M_MAILDIR && upd_ctx && h->trash)
74         ctx->changed = 1;
75     }
76     break;
77
78   case M_APPENDED:
79     if (bf) {
80       if (!h->appended) {
81         h->appended = 1;
82         if (upd_ctx)
83           ctx->appended++;
84       }
85     }
86     break;
87
88   case M_PURGED:
89     if (bf) {
90       if (!h->purged)
91         h->purged = 1;
92     }
93     else if (h->purged)
94       h->purged = 0;
95     break;
96
97   case M_NEW:
98
99     if (!mx_acl_check (ctx, ACL_SEEN))
100       return;
101
102     if (bf) {
103       if (h->read || h->old) {
104         h->old = 0;
105         if (upd_ctx)
106           ctx->new++;
107         if (h->read) {
108           h->read = 0;
109           if (upd_ctx)
110             ctx->unread++;
111         }
112         h->changed = 1;
113         if (upd_ctx)
114           ctx->changed = 1;
115       }
116     }
117     else if (!h->read) {
118       if (!h->old)
119         if (upd_ctx)
120           ctx->new--;
121       h->read = 1;
122       if (upd_ctx)
123         ctx->unread--;
124       h->changed = 1;
125       if (upd_ctx)
126         ctx->changed = 1;
127     }
128     break;
129
130   case M_OLD:
131
132     if (!mx_acl_check (ctx, ACL_SEEN))
133       return;
134
135     if (bf) {
136       if (!h->old) {
137         h->old = 1;
138         if (!h->read)
139           if (upd_ctx)
140             ctx->new--;
141         h->changed = 1;
142         if (upd_ctx)
143           ctx->changed = 1;
144       }
145     }
146     else if (h->old) {
147       h->old = 0;
148       if (!h->read)
149         if (upd_ctx)
150           ctx->new++;
151       h->changed = 1;
152       if (upd_ctx)
153         ctx->changed = 1;
154     }
155     break;
156
157   case M_READ:
158
159     if (!mx_acl_check (ctx, ACL_SEEN))
160       return;
161
162     if (bf) {
163       if (!h->read) {
164         h->read = 1;
165         if (upd_ctx)
166           ctx->unread--;
167         if (!h->old)
168           if (upd_ctx)
169             ctx->new--;
170         h->changed = 1;
171         if (upd_ctx)
172           ctx->changed = 1;
173       }
174     }
175     else if (h->read) {
176       h->read = 0;
177       if (upd_ctx)
178         ctx->unread++;
179       if (!h->old)
180         if (upd_ctx)
181           ctx->new++;
182       h->changed = 1;
183       if (upd_ctx)
184         ctx->changed = 1;
185     }
186     break;
187
188   case M_REPLIED:
189
190     if (!mx_acl_check (ctx, ACL_WRITE))
191       return;
192
193     if (bf) {
194       if (!h->replied) {
195         h->replied = 1;
196         if (!h->read) {
197           h->read = 1;
198           if (upd_ctx)
199             ctx->unread--;
200           if (!h->old)
201             if (upd_ctx)
202               ctx->new--;
203         }
204         h->changed = 1;
205         if (upd_ctx)
206           ctx->changed = 1;
207       }
208     }
209     else if (h->replied) {
210       h->replied = 0;
211       h->changed = 1;
212       if (upd_ctx)
213         ctx->changed = 1;
214     }
215     break;
216
217   case M_FLAG:
218
219     if (!mx_acl_check (ctx, ACL_WRITE))
220       return;
221
222     if (bf) {
223       if (!h->flagged) {
224         h->flagged = bf;
225         if (upd_ctx)
226           ctx->flagged++;
227         h->changed = 1;
228         if (upd_ctx)
229           ctx->changed = 1;
230       }
231     }
232     else if (h->flagged) {
233       h->flagged = 0;
234       if (upd_ctx)
235         ctx->flagged--;
236       h->changed = 1;
237       if (upd_ctx)
238         ctx->changed = 1;
239     }
240     break;
241
242   case M_TAG:
243     if (bf) {
244       if (!h->tagged) {
245         h->tagged = 1;
246         if (upd_ctx)
247           ctx->tagged++;
248       }
249     }
250     else if (h->tagged) {
251       h->tagged = 0;
252       if (upd_ctx)
253         ctx->tagged--;
254     }
255     break;
256   }
257
258   mutt_set_header_color (ctx, h);
259
260   /* if the message status has changed, we need to invalidate the cached
261    * search results so that any future search will match the current status
262    * of this message and not what it was at the time it was last searched.
263    */
264   if (h->searched && (changed != h->changed || deleted != ctx->deleted ||
265                       tagged != ctx->tagged || flagged != ctx->flagged))
266     h->searched = 0;
267   sidebar_draw ();
268 }
269
270 void mutt_tag_set_flag (int flag, int bf)
271 {
272   int j;
273
274   for (j = 0; j < Context->vcount; j++)
275     if (Context->hdrs[Context->v2r[j]]->tagged)
276       mutt_set_flag (Context, Context->hdrs[Context->v2r[j]], flag, bf);
277 }
278 int mutt_thread_set_flag (HEADER * hdr, int flag, int bf, int subthread)
279 {
280   THREAD *start, *cur = hdr->thread;
281
282   if ((Sort & SORT_MASK) != SORT_THREADS) {
283     mutt_error _("Threading is not enabled.");
284
285     return -1;
286   }
287
288   if (!subthread)
289     while (cur->parent)
290       cur = cur->parent;
291   start = cur;
292
293   if (cur->message)
294     mutt_set_flag (Context, cur->message, flag, bf);
295
296   if ((cur = cur->child) == NULL)
297     return 0;
298
299   for (;;) {
300     if (cur->message)
301       mutt_set_flag (Context, cur->message, flag, bf);
302
303     if (cur->child)
304       cur = cur->child;
305     else if (cur->next)
306       cur = cur->next;
307     else {
308       while (!cur->next) {
309         cur = cur->parent;
310         if (cur == start)
311           return 0;
312       }
313       cur = cur->next;
314     }
315   }
316   /* not reached */
317 }
318
319 int mutt_change_flag(HEADER * h, int bf)
320 {
321     char buf[STRING];
322     const char letters[] = "dDnNoOrR*!";
323     static char const actions[] = {
324         ['d'] = M_DELETE,       ['D'] = M_DELETE,
325         ['n'] = M_NEW,          ['N'] = M_NEW,
326         ['o'] = M_OLD,          ['O'] = M_OLD,
327         ['r'] = M_REPLIED,      ['R'] = M_REPLIED,
328         ['*'] = M_TAG,
329         ['!'] = M_FLAG,
330     };
331
332     int c;
333
334     snprintf(buf, sizeof(buf), "%s? (D/N/O/r/*/!): ",
335              bf ? _("Set flag") : _("Clear flag"));
336     c = mutt_multi_choice(buf, letters);
337     if (c <= 0)
338         return -1;
339     c = letters[c - 1];
340     if (actions[c] == M_OLD) {
341         if (h) {
342             mutt_set_flag(Context, h, M_READ, !bf);
343         } else {
344             mutt_tag_set_flag(M_READ, !bf);
345         }
346     }
347
348     if (h) {
349         mutt_set_flag(Context, h, actions[c], bf);
350     } else {
351         mutt_tag_set_flag(actions[c], bf);
352     }
353
354     return 0;
355 }