Statistics
| Revision:

root / src / headerview.c @ 1

History | View | Annotate | Download (9 KB)

1
/*
2
 * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3
 * Copyright (C) 1999-2003 Hiroyuki Yamamoto
4
 *
5
 * This program is free software; you can redistribute it and/or modify
6
 * it under the terms of the GNU General Public License as published by
7
 * the Free Software Foundation; either version 2 of the License, or
8
 * (at your option) any later version.
9
 *
10
 * This program is distributed in the hope that it will be useful,
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 * GNU General Public License for more details.
14
 *
15
 * You should have received a copy of the GNU General Public License
16
 * along with this program; if not, write to the Free Software
17
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18
 */
19

    
20
#ifdef HAVE_CONFIG_H
21
#  include "config.h"
22
#endif
23

    
24
#include "defs.h"
25

    
26
#include <glib.h>
27
#include <gtk/gtkwidget.h>
28
#include <gtk/gtkstyle.h>
29
#include <gtk/gtkscrolledwindow.h>
30
#include <gtk/gtkhbox.h>
31
#include <gtk/gtkvbox.h>
32
#include <gtk/gtklabel.h>
33
#include <gtk/gtkpixmap.h>
34
#include <stdio.h>
35
#include <string.h>
36
#include <time.h>
37

    
38
#if HAVE_LIBCOMPFACE
39
#  include <compface.h>
40
#endif
41

    
42
#include "intl.h"
43
#include "main.h"
44
#include "headerview.h"
45
#include "prefs_common.h"
46
#include "codeconv.h"
47
#include "gtkutils.h"
48
#include "utils.h"
49

    
50
#define TR(str)        (prefs_common.trans_hdr ? gettext(str) : str)
51

    
52
#if 0
53
        _("From:");
54
        _("To:");
55
        _("Newsgroups:");
56
        _("Subject:");
57
#endif
58

    
59
#if HAVE_LIBCOMPFACE
60
#define XPM_XFACE_HEIGHT        (HEIGHT + 3)  /* 3 = 1 header + 2 colors */
61

    
62
static gchar *xpm_xface[XPM_XFACE_HEIGHT];
63

    
64
static void headerview_show_xface        (HeaderView        *headerview,
65
                                         MsgInfo        *msginfo);
66
static gint create_xpm_from_xface        (gchar                *xpm[],
67
                                         const gchar        *xface);
68
#endif
69

    
70
HeaderView *headerview_create(void)
71
{
72
        HeaderView *headerview;
73
        GtkWidget *hbox;
74
        GtkWidget *vbox;
75
        GtkWidget *hbox1;
76
        GtkWidget *hbox2;
77
        GtkWidget *from_header_label;
78
        GtkWidget *from_body_label;
79
        GtkWidget *to_header_label;
80
        GtkWidget *to_body_label;
81
        GtkWidget *ng_header_label;
82
        GtkWidget *ng_body_label;
83
        GtkWidget *subject_header_label;
84
        GtkWidget *subject_body_label;
85

    
86
        debug_print(_("Creating header view...\n"));
87
        headerview = g_new0(HeaderView, 1);
88

    
89
        hbox = gtk_hbox_new(FALSE, 0);
90
        gtk_container_set_border_width(GTK_CONTAINER(hbox), 2);
91
        vbox = gtk_vbox_new(FALSE, 0);
92
        gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
93

    
94
        hbox1 = gtk_hbox_new(FALSE, 4);
95
        gtk_box_pack_start(GTK_BOX(vbox), hbox1, FALSE, FALSE, 0);
96
        hbox2 = gtk_hbox_new(FALSE, 4);
97
        gtk_box_pack_start(GTK_BOX(vbox), hbox2, FALSE, FALSE, 0);
98

    
99
        from_header_label    = gtk_label_new(TR("From:"));
100
        from_body_label      = gtk_label_new("");
101
        to_header_label      = gtk_label_new(TR("To:"));
102
        to_body_label        = gtk_label_new("");
103
        ng_header_label      = gtk_label_new(TR("Newsgroups:"));
104
        ng_body_label        = gtk_label_new("");
105
        subject_header_label = gtk_label_new(TR("Subject:"));
106
        subject_body_label   = gtk_label_new("");
107

    
108
        gtk_label_set_selectable(GTK_LABEL(from_body_label), TRUE);
109
        gtk_label_set_selectable(GTK_LABEL(to_body_label), TRUE);
110
        gtk_label_set_selectable(GTK_LABEL(ng_body_label), TRUE);
111
        gtk_label_set_selectable(GTK_LABEL(subject_body_label), TRUE);
112

    
113
        gtk_box_pack_start(GTK_BOX(hbox1), from_header_label, FALSE, FALSE, 0);
114
        gtk_box_pack_start(GTK_BOX(hbox1), from_body_label, FALSE, FALSE, 0);
115
        gtk_box_pack_start(GTK_BOX(hbox1), to_header_label, FALSE, FALSE, 0);
116
        gtk_box_pack_start(GTK_BOX(hbox1), to_body_label, FALSE, FALSE, 0);
117
        gtk_box_pack_start(GTK_BOX(hbox1), ng_header_label, FALSE, FALSE, 0);
118
        gtk_box_pack_start(GTK_BOX(hbox1), ng_body_label, FALSE, FALSE, 0);
119
        gtk_box_pack_start(GTK_BOX(hbox2), subject_header_label, FALSE, FALSE, 0);
120
        gtk_box_pack_start(GTK_BOX(hbox2), subject_body_label, FALSE, FALSE, 0);
121

    
122
        headerview->hbox = hbox;
123
        headerview->from_header_label    = from_header_label;
124
        headerview->from_body_label      = from_body_label;
125
        headerview->to_header_label      = to_header_label;
126
        headerview->to_body_label        = to_body_label;
127
        headerview->ng_header_label      = ng_header_label;
128
        headerview->ng_body_label        = ng_body_label;
129
        headerview->subject_header_label = subject_header_label;
130
        headerview->subject_body_label   = subject_body_label;
131
        headerview->image = NULL;
132

    
133
        gtk_widget_show_all(hbox);
134

    
135
        return headerview;
136
}
137

    
138
void headerview_init(HeaderView *headerview)
139
{
140
        static PangoFontDescription *boldfont = NULL;
141

    
142
        if (!boldfont && prefs_common.boldfont)
143
                boldfont = pango_font_description_from_string
144
                        (prefs_common.boldfont);
145

    
146
#define SET_FONT_STYLE(wid) \
147
{ \
148
        if (boldfont) \
149
                gtk_widget_modify_font(headerview->wid, boldfont); \
150
}
151

    
152
        SET_FONT_STYLE(from_header_label);
153
        SET_FONT_STYLE(to_header_label);
154
        SET_FONT_STYLE(ng_header_label);
155
        SET_FONT_STYLE(subject_header_label);
156

    
157
        headerview_clear(headerview);
158
        headerview_set_visibility(headerview, prefs_common.display_header_pane);
159

    
160
#if HAVE_LIBCOMPFACE
161
        {
162
                gint i;
163

    
164
                for (i = 0; i < XPM_XFACE_HEIGHT; i++) {
165
                        xpm_xface[i] = g_malloc(WIDTH + 1);
166
                        *xpm_xface[i] = '\0';
167
                }
168
        }
169
#endif
170
}
171

    
172
void headerview_show(HeaderView *headerview, MsgInfo *msginfo)
173
{
174
        headerview_clear(headerview);
175

    
176
        gtk_label_set_text(GTK_LABEL(headerview->from_body_label),
177
                           msginfo->from ? msginfo->from : _("(No From)"));
178
        if (msginfo->to) {
179
                gtk_label_set_text(GTK_LABEL(headerview->to_body_label),
180
                                   msginfo->to);
181
                gtk_widget_show(headerview->to_header_label);
182
                gtk_widget_show(headerview->to_body_label);
183
        }
184
        if (msginfo->newsgroups) {
185
                gtk_label_set_text(GTK_LABEL(headerview->ng_body_label),
186
                                   msginfo->newsgroups);
187
                gtk_widget_show(headerview->ng_header_label);
188
                gtk_widget_show(headerview->ng_body_label);
189
        }
190
        gtk_label_set_text(GTK_LABEL(headerview->subject_body_label),
191
                           msginfo->subject ? msginfo->subject
192
                           : _("(No Subject)"));
193

    
194
#if HAVE_LIBCOMPFACE
195
        headerview_show_xface(headerview, msginfo);
196
#endif
197
}
198

    
199
#if HAVE_LIBCOMPFACE
200
static void headerview_show_xface(HeaderView *headerview, MsgInfo *msginfo)
201
{
202
        gchar xface[2048];
203
        GdkPixmap *pixmap;
204
        GdkBitmap *mask;
205
        GtkWidget *hbox = headerview->hbox;
206

    
207
        if (!msginfo->xface || strlen(msginfo->xface) < 5) {
208
                if (headerview->image &&
209
                    GTK_WIDGET_VISIBLE(headerview->image)) {
210
                        gtk_widget_hide(headerview->image);
211
                        gtk_widget_queue_resize(hbox);
212
                }
213
                return;
214
        }
215
        if (!GTK_WIDGET_VISIBLE(headerview->hbox)) return;
216

    
217
        strncpy(xface, msginfo->xface, sizeof(xface));
218

    
219
        if (uncompface(xface) < 0) {
220
                g_warning("uncompface failed\n");
221
                if (headerview->image)
222
                        gtk_widget_hide(headerview->image);
223
                return;
224
        }
225

    
226
        create_xpm_from_xface(xpm_xface, xface);
227

    
228
        pixmap = gdk_pixmap_create_from_xpm_d
229
                (hbox->window, &mask, &hbox->style->white, xpm_xface);
230

    
231
        if (!headerview->image) {
232
                GtkWidget *image;
233

    
234
                image = gtk_image_new_from_pixmap(pixmap, mask);
235
                gtk_box_pack_start(GTK_BOX(hbox), image, FALSE, FALSE, 0);
236
                gtk_widget_show(image);
237
                headerview->image = image;
238
        } else {
239
                gtk_image_set_from_pixmap(GTK_IMAGE(headerview->image),
240
                                          pixmap, mask);
241
                gtk_widget_show(headerview->image);
242
        }
243

    
244
        gdk_pixmap_unref(pixmap);
245
}
246
#endif
247

    
248
void headerview_clear(HeaderView *headerview)
249
{
250
        gtk_label_set_text(GTK_LABEL(headerview->from_body_label), "");
251
        gtk_label_set_text(GTK_LABEL(headerview->to_body_label), "");
252
        gtk_label_set_text(GTK_LABEL(headerview->ng_body_label), "");
253
        gtk_label_set_text(GTK_LABEL(headerview->subject_body_label), "");
254
        gtk_widget_hide(headerview->to_header_label);
255
        gtk_widget_hide(headerview->to_body_label);
256
        gtk_widget_hide(headerview->ng_header_label);
257
        gtk_widget_hide(headerview->ng_body_label);
258

    
259
        if (headerview->image && GTK_WIDGET_VISIBLE(headerview->image)) {
260
                gtk_widget_hide(headerview->image);
261
                gtk_widget_queue_resize(headerview->hbox);
262
        }
263
}
264

    
265
void headerview_set_visibility(HeaderView *headerview, gboolean visibility)
266
{
267
        if (visibility)
268
                gtk_widget_show(headerview->hbox);
269
        else
270
                gtk_widget_hide(headerview->hbox);
271
}
272

    
273
void headerview_destroy(HeaderView *headerview)
274
{
275
        g_free(headerview);
276
}
277

    
278
#if HAVE_LIBCOMPFACE
279
static gint create_xpm_from_xface(gchar *xpm[], const gchar *xface)
280
{
281
        static gchar *bit_pattern[] = {
282
                "....",
283
                "...#",
284
                "..#.",
285
                "..##",
286
                ".#..",
287
                ".#.#",
288
                ".##.",
289
                ".###",
290
                "#...",
291
                "#..#",
292
                "#.#.",
293
                "#.##",
294
                "##..",
295
                "##.#",
296
                "###.",
297
                "####"
298
        };
299

    
300
        static gchar *xface_header = "48 48 2 1";
301
        static gchar *xface_black  = "# c #000000";
302
        static gchar *xface_white  = ". c #ffffff";
303

    
304
        gint i, line = 0;
305
        const guchar *p;
306
        gchar buf[WIDTH * 4 + 1];  /* 4 = strlen("0x0000") */
307

    
308
        p = xface;
309

    
310
        strcpy(xpm[line++], xface_header);
311
        strcpy(xpm[line++], xface_black);
312
        strcpy(xpm[line++], xface_white);
313

    
314
        for (i = 0; i < HEIGHT; i++) {
315
                gint col;
316

    
317
                buf[0] = '\0';
318
     
319
                for (col = 0; col < 3; col++) {
320
                        gint figure;
321

    
322
                        p += 2;  /* skip '0x' */
323

    
324
                        for (figure = 0; figure < 4; figure++) {
325
                                gint n = 0;
326

    
327
                                if ('0' <= *p && *p <= '9') {
328
                                        n = *p - '0';
329
                                } else if ('a' <= *p && *p <= 'f') {
330
                                        n = *p - 'a' + 10;
331
                                } else if ('A' <= *p && *p <= 'F') {
332
                                        n = *p - 'A' + 10;
333
                                }
334

    
335
                                strcat(buf, bit_pattern[n]);
336
                                p++;  /* skip ',' */
337
                        }
338

    
339
                        p++;  /* skip '\n' */
340
                }
341

    
342
                strcpy(xpm[line++], buf);
343
                p++;
344
        }
345

    
346
        return 0;
347
}
348
#endif