sanity.c 8.52 KB
Newer Older
1
/* GIMP - The GNU Image Manipulation Program
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 * Copyright (C) 1995 Spencer Kimball and Peter Mattis
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#include "config.h"

21
#include <glib.h>
22
#include <fontconfig/fontconfig.h>
23
#include <pango/pango.h>
24
25
#include <pango/pangoft2.h>

26
#include "libgimpbase/gimpbase.h"
27

28
29
#include "sanity.h"

30
31
#include "gimp-intl.h"

32

33
static gchar * sanity_check_gimp              (void);
34
static gchar * sanity_check_glib              (void);
35
static gchar * sanity_check_pango             (void);
36
37
38
39
static gchar * sanity_check_fontconfig        (void);
static gchar * sanity_check_freetype          (void);
static gchar * sanity_check_filename_encoding (void);

40

41
/*  public functions  */
42

43
const gchar *
44
sanity_check (void)
45
{
46
47
48
49
  gchar *abort_message = sanity_check_gimp ();

  if (! abort_message)
    abort_message = sanity_check_glib ();
50

51
52
53
  if (! abort_message)
    abort_message = sanity_check_pango ();

54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
  if (! abort_message)
    abort_message = sanity_check_fontconfig ();

  if (! abort_message)
    abort_message = sanity_check_freetype ();

  if (! abort_message)
    abort_message = sanity_check_filename_encoding ();

  return abort_message;
}


/*  private functions  */

69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
static gchar *
sanity_check_gimp (void)
{
  if (GIMP_MAJOR_VERSION != gimp_major_version ||
      GIMP_MINOR_VERSION != gimp_minor_version ||
      GIMP_MICRO_VERSION != gimp_micro_version)
    {
      return g_strdup_printf
        ("Libgimp version mismatch!\n\n"
         "The GIMP binary cannot run with a libgimp version\n"
         "other than its own. This is GIMP %d.%d.%d, but the\n"
         "libgimp version is %d.%d.%d.\n\n"
         "Maybe you have GIMP versions in both /usr and /usr/local ?",
         GIMP_MAJOR_VERSION, GIMP_MINOR_VERSION, GIMP_MICRO_VERSION,
         gimp_major_version, gimp_minor_version, gimp_micro_version);
    }

  return NULL;
}

89
90
91
92
static gchar *
sanity_check_glib (void)
{
#define GLIB_REQUIRED_MAJOR 2
Sven Neumann's avatar
Sven Neumann committed
93
#define GLIB_REQUIRED_MINOR 16
94
#define GLIB_REQUIRED_MICRO 1
95

Sven Neumann's avatar
Sven Neumann committed
96
97
98
  const gchar *mismatch = glib_check_version (GLIB_REQUIRED_MAJOR,
                                              GLIB_REQUIRED_MINOR,
                                              GLIB_REQUIRED_MICRO);
99
100
101
102
103

  if (mismatch)
    {
      return g_strdup_printf
        ("%s\n\n"
Sven Neumann's avatar
Sven Neumann committed
104
         "GIMP requires GLib version %d.%d.%d or later.\n"
105
         "Installed GLib version is %d.%d.%d.\n\n"
106
         "Somehow you or your software packager managed\n"
Sven Neumann's avatar
Sven Neumann committed
107
         "to install GIMP with an older GLib version.\n\n"
108
         "Please upgrade to GLib version %d.%d.%d or later.",
109
110
111
112
113
         mismatch,
         GLIB_REQUIRED_MAJOR, GLIB_REQUIRED_MINOR, GLIB_REQUIRED_MICRO,
         glib_major_version, glib_minor_version, glib_micro_version,
         GLIB_REQUIRED_MAJOR, GLIB_REQUIRED_MINOR, GLIB_REQUIRED_MICRO);
    }
114

115
116
117
118
119
120
121
#undef GLIB_REQUIRED_MAJOR
#undef GLIB_REQUIRED_MINOR
#undef GLIB_REQUIRED_MICRO

  return NULL;
}

122
123
124
125
126
127
128
static gchar *
sanity_check_pango (void)
{
#define PANGO_REQUIRED_MAJOR 1
#define PANGO_REQUIRED_MINOR 18
#define PANGO_REQUIRED_MICRO 0

Sven Neumann's avatar
Sven Neumann committed
129
130
131
  const gchar *mismatch = pango_version_check (PANGO_REQUIRED_MAJOR,
                                               PANGO_REQUIRED_MINOR,
                                               PANGO_REQUIRED_MICRO);
132
133
134

  if (mismatch)
    {
Sven Neumann's avatar
Sven Neumann committed
135
136
137
138
      const gint pango_major_version = pango_version () / 100 / 100;
      const gint pango_minor_version = pango_version () / 100 % 100;
      const gint pango_micro_version = pango_version () % 100;

139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
      return g_strdup_printf
        ("%s\n\n"
         "GIMP requires Pango version %d.%d.%d or later.\n"
         "Installed Pango version is %d.%d.%d.\n\n"
         "Somehow you or your software packager managed\n"
         "to install GIMP with an older Pango version.\n\n"
         "Please upgrade to Pango version %d.%d.%d or later.",
         mismatch,
         PANGO_REQUIRED_MAJOR, PANGO_REQUIRED_MINOR, PANGO_REQUIRED_MICRO,
         pango_major_version, pango_minor_version, pango_micro_version,
         PANGO_REQUIRED_MAJOR, PANGO_REQUIRED_MINOR, PANGO_REQUIRED_MICRO);
    }

#undef PANGO_REQUIRED_MAJOR
#undef PANGO_REQUIRED_MINOR
#undef PANGO_REQUIRED_MICRO

  return NULL;
}

159
160
161
static gchar *
sanity_check_fontconfig (void)
{
Sven Neumann's avatar
Sven Neumann committed
162
  const gint fc_version = FcGetVersion ();
163
164
165
166
167

#define FC_REQUIRED_MAJOR 2
#define FC_REQUIRED_MINOR 2
#define FC_REQUIRED_MICRO 0

168
169
170
171
  if (fc_version < ((FC_REQUIRED_MAJOR * 10000) +
                    (FC_REQUIRED_MINOR *   100) +
                    (FC_REQUIRED_MICRO *     1)))
    {
Sven Neumann's avatar
Sven Neumann committed
172
173
174
175
      const gint fc_major_version = fc_version / 100 / 100;
      const gint fc_minor_version = fc_version / 100 % 100;
      const gint fc_micro_version = fc_version % 100;

176
      return g_strdup_printf
177
        ("The Fontconfig version being used is too old!\n\n"
Sven Neumann's avatar
Sven Neumann committed
178
179
         "GIMP requires Fontconfig version %d.%d.%d or later.\n"
         "The Fontconfig version loaded by GIMP is %d.%d.%d.\n\n"
180
181
182
183
184
185
         "This may be caused by another instance of libfontconfig.so.1\n"
         "being installed in the system, probably in /usr/X11R6/lib.\n"
         "Please correct the situation or report it to someone who can.",
         FC_REQUIRED_MAJOR, FC_REQUIRED_MINOR, FC_REQUIRED_MICRO,
         fc_major_version, fc_minor_version, fc_micro_version);
    }
186
187
188
189

#undef FC_REQUIRED_MAJOR
#undef FC_REQUIRED_MINOR
#undef FC_REQUIRED_MICRO
190

191
192
  return NULL;
}
193

194
195
196
197
198
199
200
201
static gchar *
sanity_check_freetype (void)
{
  FT_Library ft_library;
  FT_Int     ft_major_version;
  FT_Int     ft_minor_version;
  FT_Int     ft_micro_version;
  FT_Int     ft_version;
202
203
204
205
206

#define FT_REQUIRED_MAJOR 2
#define FT_REQUIRED_MINOR 1
#define FT_REQUIRED_MICRO 7

207
208
209
210
211
212
213
  if (FT_Init_FreeType (&ft_library) != 0)
    g_error ("FT_Init_FreeType() failed");

  FT_Library_Version (ft_library,
                      &ft_major_version,
                      &ft_minor_version,
                      &ft_micro_version);
214

215
216
217
218
219
220
221
222
223
224
225
226
227
  if (FT_Done_FreeType (ft_library) != 0)
    g_error ("FT_Done_FreeType() failed");

  ft_version = (ft_major_version * 10000 +
                ft_minor_version *   100 +
                ft_micro_version *     1);

  if (ft_version < ((FT_REQUIRED_MAJOR * 10000) +
                    (FT_REQUIRED_MINOR *   100) +
                    (FT_REQUIRED_MICRO *     1)))
    {
      return g_strdup_printf
        ("FreeType version too old!\n\n"
Sven Neumann's avatar
Sven Neumann committed
228
         "GIMP requires FreeType version %d.%d.%d or later.\n"
229
230
         "Installed FreeType version is %d.%d.%d.\n\n"
         "Somehow you or your software packager managed\n"
Sven Neumann's avatar
Sven Neumann committed
231
         "to install GIMP with an older FreeType version.\n\n"
232
233
234
235
236
         "Please upgrade to FreeType version %d.%d.%d or later.",
         FT_REQUIRED_MAJOR, FT_REQUIRED_MINOR, FT_REQUIRED_MICRO,
         ft_major_version, ft_minor_version, ft_micro_version,
         FT_REQUIRED_MAJOR, FT_REQUIRED_MINOR, FT_REQUIRED_MICRO);
    }
237
238
239
240
241

#undef FT_REQUIRED_MAJOR
#undef FT_REQUIRED_MINOR
#undef FT_REQUIRED_MICRO

242
  return NULL;
243
}
244
245
246
247
248
249
250

static gchar *
sanity_check_filename_encoding (void)
{
  gchar  *result;
  GError *error = NULL;

251
  result = g_filename_to_utf8 ("", -1, NULL, NULL, &error);
252

253
  if (! result)
254
    {
255
256
257
258
259
260
261
262
263
      gchar *msg =
        g_strdup_printf
        (_("The configured filename encoding cannot be converted to UTF-8: "
           "%s\n\n"
           "Please check the value of the environment variable "
           "G_FILENAME_ENCODING."),
         error->message);

      g_error_free (error);
264

265
      return msg;
266
    }
267
268
269
270
271
272

  g_free (result);

  result = g_filename_to_utf8 (gimp_directory (), -1, NULL, NULL, &error);

  if (! result)
273
274
275
    {
      gchar *msg =
        g_strdup_printf
276
277
278
        (_("The name of the directory holding the GIMP user configuration "
           "cannot be converted to UTF-8: "
           "%s\n\n"
279
280
           "Your filesystem probably stores files in an encoding "
           "other than UTF-8 and you didn't tell GLib about this. "
281
           "Please set the environment variable G_FILENAME_ENCODING."),
282
283
284
285
286
287
         error->message);

      g_error_free (error);

      return msg;
    }
288
289
290
291

  g_free (result);

  return NULL;
292
}