code cleanup: use the prefix packet_list_ for every function mentioned in packet_list.h
[obnox/wireshark/wip.git] / gtk / font_utils.c
1 /* font_utils.c
2  * Utilities to use for font manipulation
3  *
4  * $Id$
5  *
6  * Ethereal - Network traffic analyzer
7  * By Gerald Combs <gerald@ethereal.com>
8  * Copyright 1998 Gerald Combs
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License
12  * as published by the Free Software Foundation; either version 2
13  * of the License, or (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
23  */
24
25 #ifdef HAVE_CONFIG_H
26 # include "config.h"
27 #endif
28
29 #include <gtk/gtk.h>
30 #include <string.h>
31 #include <stdlib.h>
32 #include <stdio.h>
33
34 #include <epan/packet.h>
35
36 #ifdef _WIN32
37 #include <windows.h>
38 #endif
39
40 #include "main.h"
41 #include "recent.h"
42 #include <epan/prefs.h>
43
44 #include "gtkglobals.h"
45
46 #include "compat_macros.h"
47 #include "font_utils.h"
48 #include "simple_dialog.h"
49
50 #include "packet_list.h"
51 #include "proto_draw.h"
52 #include "follow_dlg.h"
53
54
55
56 #if GTK_MAJOR_VERSION < 2
57 guint        m_font_height, m_font_width;
58 #endif
59 FONT_TYPE *m_r_font, *m_b_font;
60
61
62 /* Get the regular user font.
63  *
64  * @return the regular user font
65  */
66 FONT_TYPE *user_font_get_regular(void)
67 {
68     return m_r_font;
69 }
70
71 /* Get the bold user font.
72  *
73  * @return the bold user font
74  */
75 FONT_TYPE *user_font_get_bold(void)
76 {
77     return m_b_font;
78 }
79
80 #if GTK_MAJOR_VERSION < 2
81 /* Get the regular user font height.
82  *
83  * @return the regular user font height
84  */
85 guint user_font_get_regular_height(void)
86 {
87     return m_font_height;
88 }
89
90 /* Get the regular user font width.
91  *
92  * @return the regular user font width
93  */
94 guint user_font_get_regular_width(void)
95 {
96     return m_font_width;
97 }
98 #endif
99
100
101 static void
102 set_fonts(FONT_TYPE *regular, FONT_TYPE *bold)
103 {
104         /* Yes, assert. The code that loads the font should check
105          * for NULL and provide its own error message. */
106         g_assert(m_r_font && m_b_font);
107         m_r_font = regular;
108         m_b_font = bold;
109
110 #if GTK_MAJOR_VERSION < 2
111         m_font_height = m_r_font->ascent + m_r_font->descent;
112         m_font_width = gdk_string_width(m_r_font, "0");
113 #endif
114 }
115
116 void
117 view_zoom_in_cb(GtkWidget *w _U_, gpointer d _U_)
118 {
119     gint save_gui_zoom_level;
120
121     save_gui_zoom_level = recent.gui_zoom_level;
122     recent.gui_zoom_level++;
123     switch (user_font_apply()) {
124
125     case FA_SUCCESS:
126         break;
127
128     case FA_FONT_NOT_RESIZEABLE:
129         /* "font_apply()" popped up an alert box. */
130         recent.gui_zoom_level = save_gui_zoom_level;    /* undo zoom */
131         break;
132
133     case FA_FONT_NOT_AVAILABLE:
134         /* We assume this means that the specified size isn't available. */
135         simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
136             "Your current font isn't available in the next larger size.\n");
137         recent.gui_zoom_level = save_gui_zoom_level;    /* undo zoom */
138         break;
139     }
140 }
141
142 void
143 view_zoom_out_cb(GtkWidget *w _U_, gpointer d _U_)
144 {
145     gint save_gui_zoom_level;
146
147     save_gui_zoom_level = recent.gui_zoom_level;
148     recent.gui_zoom_level--;
149     switch (user_font_apply()) {
150
151     case FA_SUCCESS:
152         break;
153
154     case FA_FONT_NOT_RESIZEABLE:
155         /* "font_apply()" popped up an alert box. */
156         recent.gui_zoom_level = save_gui_zoom_level;    /* undo zoom */
157         break;
158
159     case FA_FONT_NOT_AVAILABLE:
160         /* We assume this means that the specified size isn't available. */
161         simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
162             "Your current font isn't available in the next smaller size.\n");
163         recent.gui_zoom_level = save_gui_zoom_level;    /* undo zoom */
164         break;
165     }
166 }
167
168 void
169 view_zoom_100_cb(GtkWidget *w _U_, gpointer d _U_)
170 {
171     gint save_gui_zoom_level;
172
173     save_gui_zoom_level = recent.gui_zoom_level;
174     recent.gui_zoom_level = 0;
175     switch (user_font_apply()) {
176
177     case FA_SUCCESS:
178         break;
179
180     case FA_FONT_NOT_RESIZEABLE:
181         /* "font_apply()" popped up an alert box. */
182         recent.gui_zoom_level = save_gui_zoom_level;    /* undo zoom */
183         break;
184
185     case FA_FONT_NOT_AVAILABLE:
186         /* We assume this means that the specified size isn't available.
187            XXX - this "shouldn't happen". */
188         simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
189             "Your current font couldn't be reloaded at the size you selected.\n");
190         recent.gui_zoom_level = save_gui_zoom_level;    /* undo zoom */
191         break;
192     }
193 }
194
195
196 #if GTK_MAJOR_VERSION < 2
197 /* Given a font name, construct the name of the next heavier version of
198    that font. */
199
200 #define XLFD_WEIGHT     3       /* index of the "weight" field */
201
202 /* Map from a given weight to the appropriate weight for the "bold"
203    version of a font.
204    XXX - the XLFD says these strings shouldn't be used for font matching;
205    can we get the weight, as a number, from GDK, and ask GDK to find us
206    a font just like the given font, but with the appropriate higher
207    weight? */
208 static const struct {
209         char    *light;
210         char    *heavier;
211 } weight_map[] = {
212         { "ultralight", "light" },
213         { "extralight", "semilight" },
214         { "light",      "medium" },
215         { "semilight",  "semibold" },
216         { "medium",     "bold" },
217         { "normal",     "bold" },
218         { "semibold",   "extrabold" },
219         { "bold",       "ultrabold" }
220 };
221 #define N_WEIGHTS       (sizeof weight_map / sizeof weight_map[0])
222
223 /* Try to convert a font name to it's bold version.
224  *
225  * @param the font to convert
226  * @return the bold font
227  */
228 static char *
229 user_font_boldify(const char *font_name)
230 {
231         char *bold_font_name;
232         gchar **xlfd_tokens;
233         unsigned int i;
234
235         /* Is this an XLFD font?  If it begins with "-", yes, otherwise no. */
236         if (font_name[0] == '-') {
237                 xlfd_tokens = g_strsplit(font_name, "-", XLFD_WEIGHT+1);
238
239                 /*
240                  * Make sure we *have* a weight (this might not be a valid
241                  * XLFD font name).
242                  */
243                 for (i = 0; i < XLFD_WEIGHT+1; i++) {
244                         if (xlfd_tokens[i] == NULL) {
245                                 /*
246                                  * We don't, so treat this as a non-XLFD
247                                  * font name.
248                                  */
249                                 goto not_xlfd;
250                         }
251                 }
252                 for (i = 0; i < N_WEIGHTS; i++) {
253                         if (strcmp(xlfd_tokens[XLFD_WEIGHT],
254                             weight_map[i].light) == 0) {
255                                 g_free(xlfd_tokens[XLFD_WEIGHT]);
256                                 xlfd_tokens[XLFD_WEIGHT] =
257                                     g_strdup(weight_map[i].heavier);
258                                 break;
259                         }
260                 }
261                 bold_font_name = g_strjoinv("-", xlfd_tokens);
262                 g_strfreev(xlfd_tokens);
263                 return bold_font_name;
264         }
265
266 not_xlfd:
267         /*
268          * This isn't an XLFD font name; just append "bold" to the name
269          * of the font.
270          */
271         bold_font_name = g_strconcat(font_name, "bold", NULL);
272         return bold_font_name;
273 }
274 #endif
275
276
277 gboolean
278 user_font_test(gchar *font_name)
279 {
280 #if GTK_MAJOR_VERSION < 2
281         gchar   *bold_font_name;
282 #endif
283         FONT_TYPE *new_r_font, *new_b_font;
284
285 #if GTK_MAJOR_VERSION < 2
286         /* Get the name that the boldface version of that font would have. */
287         bold_font_name = user_font_boldify(font_name);
288
289         /* Now load those fonts, just to make sure we can. */
290         new_r_font = gdk_font_load(font_name);
291 #else
292         new_r_font = pango_font_description_from_string(font_name);
293 #endif
294         if (new_r_font == NULL) {
295                 /* Oops, that font didn't work.
296                    Tell the user, but don't tear down the font selection
297                    dialog, so that they can try again. */
298                 simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
299                    "The font you selected can't be loaded.");
300
301 #if GTK_MAJOR_VERSION < 2
302                 g_free(bold_font_name);
303 #endif
304                 return FALSE;
305         }
306
307 #if GTK_MAJOR_VERSION < 2
308         new_b_font = gdk_font_load(bold_font_name);
309 #else
310         new_b_font = pango_font_description_copy(new_r_font);
311         pango_font_description_set_weight(new_b_font, PANGO_WEIGHT_BOLD);
312 #endif
313         if (new_b_font == NULL) {
314                 /* Oops, that font didn't work.
315                    Tell the user, but don't tear down the font selection
316                    dialog, so that they can try again. */
317                 simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
318                    "The font you selected doesn't have a boldface version.");
319
320 #if GTK_MAJOR_VERSION < 2
321                 g_free(bold_font_name);
322                 gdk_font_unref(new_r_font);
323 #else
324                 pango_font_description_free(new_r_font);
325 #endif
326                 return FALSE;
327         }
328
329         return TRUE;
330 }
331
332
333
334 /* Given a font name, construct the name of a version of that font with
335    the current zoom factor applied. */
336 static char *
337 font_zoom(char *gui_font_name)
338 {
339     char *new_font_name;
340     char *font_name_dup;
341     char *font_name_p;
342     long font_point_size_l;
343 #if GTK_MAJOR_VERSION < 2
344     int minus_chars;
345     char *font_foundry;
346     char *font_family;
347     char *font_weight;
348     char *font_slant;
349     char *font_set_width;
350     char *font_add_style;
351     char *font_pixel_size;
352     char *font_point_size;
353     char *font_res_x;
354     char *font_res_y;
355     char *font_spacing;
356     char *font_aver_width;
357     char *font_charset_reg;
358     char *font_charset_encoding;
359 #endif
360
361     if (recent.gui_zoom_level == 0) {
362         /* There is no zoom factor - just return the name, so that if
363            this is GTK+ 1.2[.x] and the font name isn't an XLFD font
364            name, we don't fail. */
365         return g_strdup(gui_font_name);
366     }
367
368     font_name_dup = g_strdup(gui_font_name);
369     font_name_p = font_name_dup;
370
371 #if GTK_MAJOR_VERSION >= 2
372     /* find the start of the font_size string */
373     font_name_p = strrchr(font_name_dup, ' ');
374     *font_name_p = '\0';
375     font_name_p++;
376
377     /* calculate the new font size */
378     font_point_size_l = strtol(font_name_p, NULL, 10);
379     font_point_size_l += recent.gui_zoom_level;
380
381     /* build a new font name */
382     new_font_name = g_strdup_printf("%s %ld", font_name_dup, font_point_size_l);
383 #else
384     minus_chars = 0;
385     /* replace all '-' chars by NUL and count them */
386     while ((font_name_p = strchr(font_name_p, '-')) != NULL) {
387         *font_name_p = '\0';
388         font_name_p++;
389         minus_chars++;
390     }
391
392     if (minus_chars != 14) {
393         /*
394          * Not a valid XLFD font name.
395          * XXX - can we try scaling it by looking for a size at the end
396          * and tweaking that?  Unfortunately, some fonts have numbers
397          * at the end that aren't, as far as I know, sizes, e.g. "nil2".
398          */
399         return NULL;
400     }
401
402     /* first element (font name registry) empty */
403     font_name_p = font_name_dup;
404     font_name_p += strlen(font_name_p);
405     font_name_p++;
406
407     /* get pointers to all font name elements */
408     font_foundry = font_name_p;
409     font_name_p += strlen(font_name_p);
410     font_name_p++;
411
412     font_family = font_name_p;
413     font_name_p += strlen(font_name_p);
414     font_name_p++;
415
416     font_weight = font_name_p;
417     font_name_p += strlen(font_name_p);
418     font_name_p++;
419
420     font_slant = font_name_p;
421     font_name_p += strlen(font_name_p);
422     font_name_p++;
423
424     font_set_width = font_name_p;
425     font_name_p += strlen(font_name_p);
426     font_name_p++;
427
428     font_add_style = font_name_p;
429     font_name_p += strlen(font_name_p);
430     font_name_p++;
431
432     font_pixel_size = font_name_p;
433     font_name_p += strlen(font_name_p);
434     font_name_p++;
435
436     font_point_size = font_name_p;
437     font_name_p += strlen(font_name_p);
438     font_name_p++;
439
440     font_res_x = font_name_p;
441     font_name_p += strlen(font_name_p);
442     font_name_p++;
443
444     font_res_y = font_name_p;
445     font_name_p += strlen(font_name_p);
446     font_name_p++;
447
448     font_spacing = font_name_p;
449     font_name_p += strlen(font_name_p);
450     font_name_p++;
451
452     font_aver_width = font_name_p;
453     font_name_p += strlen(font_name_p);
454     font_name_p++;
455
456     font_charset_reg = font_name_p;
457     font_name_p += strlen(font_name_p);
458     font_name_p++;
459
460     font_charset_encoding = font_name_p;
461     font_name_p += strlen(font_name_p);
462     font_name_p++;
463
464     /* calculate the new font size */
465     font_point_size_l = strtol(font_point_size, NULL, 10);
466     font_point_size_l += recent.gui_zoom_level*10;
467     if (font_point_size_l <= 0)
468         font_point_size_l = 10;
469
470     /* build a new font name */
471     new_font_name = g_strdup_printf("-%s-%s-%s-%s-%s-%s-%s-%ld-%s-%s-%s-%s-%s-%s", 
472         font_foundry, font_family, font_weight, font_slant, font_set_width, 
473         font_add_style, font_pixel_size, font_point_size_l, font_res_x,
474         font_res_y, font_spacing, font_aver_width, font_charset_reg,
475         font_charset_encoding);
476 #endif
477
478     g_free(font_name_dup);
479
480     return new_font_name;
481 }
482
483 fa_ret_t
484 user_font_apply(void) {
485     char *gui_font_name;
486 #if GTK_MAJOR_VERSION < 2
487     char *bold_font_name;
488 #endif
489     FONT_TYPE *new_r_font, *new_b_font;
490     FONT_TYPE *old_r_font = NULL, *old_b_font = NULL;
491
492     /* convert font name to reflect the zoom level */
493     gui_font_name = font_zoom(prefs.PREFS_GUI_FONT_NAME);
494     if (gui_font_name == NULL) {
495         /*
496          * This means the font name isn't an XLFD font name.
497          * We just report that for now as a font not available in
498          * multiple sizes.
499          */
500         simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
501             "Your current font isn't available in any other sizes.\n");
502         return FA_FONT_NOT_RESIZEABLE;
503     }
504
505     /* load normal and bold font */
506 #if GTK_MAJOR_VERSION < 2
507     new_r_font = gdk_font_load(gui_font_name);
508     bold_font_name = user_font_boldify(gui_font_name);
509     new_b_font = gdk_font_load(bold_font_name);
510 #else
511     new_r_font = pango_font_description_from_string(gui_font_name);
512     new_b_font = pango_font_description_copy(new_r_font);
513     pango_font_description_set_weight(new_b_font, PANGO_WEIGHT_BOLD);
514 #endif
515
516     if (new_r_font == NULL || new_b_font == NULL) {
517         /* We're no longer using the new fonts; unreference them. */
518 #if GTK_MAJOR_VERSION < 2
519         if (new_r_font != NULL)
520             gdk_font_unref(new_r_font);
521         if (new_b_font != NULL)
522             gdk_font_unref(new_b_font);
523 #else
524         if (new_r_font != NULL)
525             pango_font_description_free(new_r_font);
526         if (new_b_font != NULL)
527             pango_font_description_free(new_b_font);
528 #endif
529         g_free(gui_font_name);
530
531         /* We let our caller pop up a dialog box, as the error message
532            depends on the context (did they zoom in or out, or did they
533            do something else? */
534         return FA_FONT_NOT_AVAILABLE;
535     }
536
537     /* the font(s) seem to be ok */
538     packet_list_set_font(new_r_font);
539     set_ptree_font_all(new_r_font);
540     old_r_font = m_r_font;
541     old_b_font = m_b_font;
542     set_fonts(new_r_font, new_b_font);
543 #if GTK_MAJOR_VERSION < 2
544     g_free(bold_font_name);
545 #endif
546
547     /* Redraw the hex dump windows. */
548     redraw_hex_dump_all();
549
550     /* Redraw the "Follow TCP Stream" windows. */
551     follow_redraw_all();
552
553     /* We're no longer using the old fonts; unreference them. */
554 #if GTK_MAJOR_VERSION < 2
555     if (old_r_font != NULL)
556         gdk_font_unref(old_r_font);
557     if (old_b_font != NULL)
558         gdk_font_unref(old_b_font);
559 #else
560     if (old_r_font != NULL)
561         pango_font_description_free(old_r_font);
562     if (old_b_font != NULL)
563         pango_font_description_free(old_b_font);
564 #endif
565     g_free(gui_font_name);
566
567     return FA_SUCCESS;
568 }
569
570
571 #ifdef _WIN32
572
573 #define NAME_BUFFER_LEN 32
574
575 #if GTK_MAJOR_VERSION < 2
576
577
578 /* The setting of the MS default font for system stuff (menus, dialogs, ...),
579  * coming from: Allin Cottrell, http://www.ecn.wfu.edu/~cottrell/gtk_win32,
580  * Thank you very much for this! */
581 static int get_windows_font_gtk1(char *fontspec, int fontspec_len)
582 {
583     HDC h_dc;
584     HGDIOBJ h_font;
585     TEXTMETRIC tm;
586     char name[NAME_BUFFER_LEN];
587     int len, pix_height;
588
589     h_dc = CreateDC("DISPLAY", NULL, NULL, NULL);
590     if (h_dc == NULL) return 1;
591     h_font = GetStockObject(DEFAULT_GUI_FONT);
592     if (h_font == NULL || !SelectObject(h_dc, h_font)) {
593         DeleteDC(h_dc);
594         return 1;
595     }
596     len = GetTextFace(h_dc, NAME_BUFFER_LEN, name);
597     if (len <= 0) {
598         DeleteDC(h_dc);
599         return 1;
600     }
601     if (!GetTextMetrics(h_dc, &tm)) {
602         DeleteDC(h_dc);
603         return 1;
604     }
605     pix_height = tm.tmHeight;
606     DeleteDC(h_dc);
607     g_snprintf(fontspec, fontspec_len, "-*-%s-*-*-*-*-%i-*-*-*-p-*-iso8859-1", name,
608             pix_height);
609     return 0;
610 }
611
612 void app_font_gtk1_init(GtkWidget *top_level_w)
613 {
614     GtkStyle *style;
615     char winfont[80];
616  
617     style = gtk_widget_get_style(top_level_w);
618     if (get_windows_font_gtk1(winfont, sizeof(winfont)) == 0)
619         style->font = gdk_font_load(winfont);
620     if (style->font) gtk_widget_set_style(top_level_w, style);
621 }
622
623
624 #else /* GTK_MAJOR_VERSION */
625 static char appfontname[128] = "tahoma 8";
626
627 static void
628 set_app_font_gtk2(const char *fontname)
629 {
630     GtkSettings *settings;
631
632     if (fontname != NULL && *fontname == 0) return;
633
634     settings = gtk_settings_get_default();
635
636     if (fontname == NULL) {
637         g_object_set(G_OBJECT(settings), "gtk-font-name", appfontname, NULL);
638     } else {
639         GtkWidget *w;
640         PangoFontDescription *pfd;
641         PangoContext *pc;
642         PangoFont *pfont;
643
644         w = gtk_label_new(NULL);
645         pfd = pango_font_description_from_string(fontname);
646         pc = gtk_widget_get_pango_context(w);
647         pfont = pango_context_load_font(pc, pfd);
648
649         if (pfont != NULL) {
650             strcpy(appfontname, fontname);
651             g_object_set(G_OBJECT(settings), "gtk-font-name", appfontname, NULL);
652         }
653
654         gtk_widget_destroy(w);
655         pango_font_description_free(pfd);
656     }
657 }
658
659 static char *default_windows_menu_fontspec_gtk2(void)
660 {
661     gchar *fontspec = NULL;
662     NONCLIENTMETRICS ncm;
663
664     memset(&ncm, 0, sizeof ncm);
665     ncm.cbSize = sizeof ncm;
666
667     if (SystemParametersInfo(SPI_GETNONCLIENTMETRICS, ncm.cbSize, &ncm, 0)) {
668         HDC screen = GetDC(0);
669         double y_scale = 72.0 / GetDeviceCaps(screen, LOGPIXELSY);
670         int point_size = (int) (ncm.lfMenuFont.lfHeight * y_scale);
671
672         if (point_size < 0) point_size = -point_size;
673         fontspec = g_strdup_printf("%s %d", ncm.lfMenuFont.lfFaceName,
674                                    point_size);
675         ReleaseDC(0, screen);
676     }
677
678     return fontspec;
679 }
680
681 static void try_to_get_windows_font_gtk2(void)
682 {
683     gchar *fontspec;
684
685     fontspec = default_windows_menu_fontspec_gtk2();
686
687     if (fontspec != NULL) {
688         int match = 0;
689         PangoFontDescription *pfd;
690         PangoFont *pfont;
691         PangoContext *pc;
692         GtkWidget *w;
693
694         pfd = pango_font_description_from_string(fontspec);
695
696         w = gtk_label_new(NULL);
697         pc = gtk_widget_get_pango_context(w);
698         pfont = pango_context_load_font(pc, pfd);
699         match = (pfont != NULL);
700
701         pango_font_description_free(pfd);
702         g_object_unref(G_OBJECT(pc));
703         gtk_widget_destroy(w);
704
705         if (match) set_app_font_gtk2(fontspec);
706         g_free(fontspec);
707     }
708 }
709 #endif /* GTK_MAJOR_VERSION */
710
711 #endif /* _WIN32 */
712
713
714 void font_init(gboolean capture_child
715 #ifndef HAVE_LIBPCAP
716         _U_
717 #endif
718 )
719 {
720 #if GTK_MAJOR_VERSION < 2
721   gchar *bold_font_name;
722 #endif
723
724 #ifdef _WIN32
725 #if GTK_MAJOR_VERSION >= 2
726   /* try to load the application font for GTK2 */
727   try_to_get_windows_font_gtk2();
728 #endif
729 #endif
730     
731   /* Try to load the regular and boldface fixed-width fonts */
732 #if GTK_MAJOR_VERSION < 2
733   bold_font_name = user_font_boldify(prefs.gui_font_name1);
734   m_r_font = gdk_font_load(prefs.gui_font_name1);
735   m_b_font = gdk_font_load(bold_font_name);
736   if (m_r_font == NULL || m_b_font == NULL) {
737     /* XXX - pop this up as a dialog box? no */
738     if (m_r_font == NULL) {
739 #ifdef HAVE_LIBPCAP
740       if (!capture_child)
741 #endif
742         fprintf(stderr, "ethereal: Warning: font %s not found - defaulting to 6x13 and 6x13bold\n",
743                 prefs.gui_font_name1);
744     } else {
745       gdk_font_unref(m_r_font);
746     }
747     if (m_b_font == NULL) {
748 #ifdef HAVE_LIBPCAP
749       if (!capture_child)
750 #endif
751         fprintf(stderr, "ethereal: Warning: font %s not found - defaulting to 6x13 and 6x13bold\n",
752                 bold_font_name);
753     } else {
754       gdk_font_unref(m_b_font);
755     }
756     g_free(bold_font_name);
757     if ((m_r_font = gdk_font_load("6x13")) == NULL) {
758       fprintf(stderr, "ethereal: Error: font 6x13 not found\n");
759       exit(1);
760     }
761     if ((m_b_font = gdk_font_load("6x13bold")) == NULL) {
762       fprintf(stderr, "ethereal: Error: font 6x13bold not found\n");
763       exit(1);
764     }
765     g_free(prefs.gui_font_name1);
766     prefs.gui_font_name1 = g_strdup("6x13");
767   }
768 #else /* GTK_MAJOR_VERSION */
769   m_r_font = pango_font_description_from_string(prefs.gui_font_name2);
770   m_b_font = pango_font_description_copy(m_r_font);
771   pango_font_description_set_weight(m_b_font, PANGO_WEIGHT_BOLD);
772   if (m_r_font == NULL || m_b_font == NULL) {
773     /* XXX - pop this up as a dialog box? no */
774     if (m_r_font == NULL) {
775 #ifdef HAVE_LIBPCAP
776       if (!capture_child)
777 #endif
778         fprintf(stderr, "ethereal: Warning: font %s not found - defaulting to Monospace 9\n",
779                 prefs.gui_font_name2);
780     } else {
781       pango_font_description_free(m_r_font);
782     }
783     if (m_b_font == NULL) {
784 #ifdef HAVE_LIBPCAP
785       if (!capture_child)
786 #endif
787         fprintf(stderr, "ethereal: Warning: bold font %s not found - defaulting"
788                         " to Monospace 9\n", prefs.gui_font_name2);
789     } else {
790       pango_font_description_free(m_b_font);
791     }
792     if ((m_r_font = pango_font_description_from_string("Monospace 9")) == NULL)
793     {
794       fprintf(stderr, "ethereal: Error: font Monospace 9 not found\n");
795       exit(1);
796     }
797     if ((m_b_font = pango_font_description_copy(m_r_font)) == NULL) {
798       fprintf(stderr, "ethereal: Error: font Monospace 9 bold not found\n");
799       exit(1);
800     }
801     g_free(prefs.gui_font_name2);
802     pango_font_description_set_weight(m_b_font, PANGO_WEIGHT_BOLD);
803     prefs.gui_font_name2 = g_strdup("Monospace 9");
804   }
805 #endif /* GTK_MAJOR_VERSION */
806
807   /* Call this for the side-effects that set_fonts() produces */
808   set_fonts(m_r_font, m_b_font);
809 }