sanity.c 14.1 KB
Newer Older
1
/* GIMP - The GNU Image Manipulation Program
2 3
 * Copyright (C) 1995 Spencer Kimball and Peter Mattis
 *
4
 * This program is free software: you can redistribute it and/or modify
5
 * it under the terms of the GNU General Public License as published by
6
 * the Free Software Foundation; either version 3 of the License, or
7 8 9 10 11 12 13 14
 * (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
15
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
16 17 18 19
 */

#include "config.h"

20
#include <cairo.h>
21
#include <fontconfig/fontconfig.h>
22
#include <pango/pango.h>
23
#include <pango/pangoft2.h>
24
#include <gdk-pixbuf/gdk-pixbuf.h>
25
#include <gegl.h>
26

27
#include "libgimpbase/gimpbase.h"
28

29 30
#include "sanity.h"

31 32
#include "gimp-intl.h"

33

34
static gchar * sanity_check_gimp              (void);
35
static gchar * sanity_check_glib              (void);
36
static gchar * sanity_check_cairo             (void);
37
static gchar * sanity_check_pango             (void);
38 39
static gchar * sanity_check_fontconfig        (void);
static gchar * sanity_check_freetype          (void);
40
static gchar * sanity_check_gdk_pixbuf        (void);
41
static gchar * sanity_check_babl              (void);
42
static gchar * sanity_check_gegl              (void);
43 44
static gchar * sanity_check_filename_encoding (void);

45

46
/*  public functions  */
47

48
const gchar *
49
sanity_check (void)
50
{
51 52 53 54
  gchar *abort_message = sanity_check_gimp ();

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

56 57 58
  if (! abort_message)
    abort_message = sanity_check_cairo ();

59 60 61
  if (! abort_message)
    abort_message = sanity_check_pango ();

62 63 64 65 66 67
  if (! abort_message)
    abort_message = sanity_check_fontconfig ();

  if (! abort_message)
    abort_message = sanity_check_freetype ();

68 69 70
  if (! abort_message)
    abort_message = sanity_check_gdk_pixbuf ();

71 72 73
  if (! abort_message)
    abort_message = sanity_check_babl ();

74 75 76
  if (! abort_message)
    abort_message = sanity_check_gegl ();

77 78 79 80 81 82 83 84 85
  if (! abort_message)
    abort_message = sanity_check_filename_encoding ();

  return abort_message;
}


/*  private functions  */

86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108
static gboolean
sanity_check_version (guint major_version, guint required_major,
                      guint minor_version, guint required_minor,
                      guint micro_version, guint required_micro)
{
  if (major_version > required_major)
    return TRUE;

  if (major_version < required_major)
    return FALSE;

  if (minor_version > required_minor)
    return TRUE;

  if (minor_version < required_minor)
    return FALSE;

  if (micro_version >= required_micro)
    return TRUE;

  return FALSE;
}

109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128
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;
}

129 130 131 132
static gchar *
sanity_check_glib (void)
{
#define GLIB_REQUIRED_MAJOR 2
133 134
#define GLIB_REQUIRED_MINOR 32
#define GLIB_REQUIRED_MICRO 0
135

136 137 138
  const gchar *mismatch = glib_check_version (GLIB_REQUIRED_MAJOR,
                                              GLIB_REQUIRED_MINOR,
                                              GLIB_REQUIRED_MICRO);
139 140 141 142 143

  if (mismatch)
    {
      return g_strdup_printf
        ("%s\n\n"
144
         "GIMP requires GLib version %d.%d.%d or later.\n"
145
         "Installed GLib version is %d.%d.%d.\n\n"
146
         "Somehow you or your software packager managed\n"
147
         "to install GIMP with an older GLib version.\n\n"
148
         "Please upgrade to GLib version %d.%d.%d or later.",
149 150 151 152 153
         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);
    }
154

155 156 157 158 159 160 161
#undef GLIB_REQUIRED_MAJOR
#undef GLIB_REQUIRED_MINOR
#undef GLIB_REQUIRED_MICRO

  return NULL;
}

162 163 164 165
static gchar *
sanity_check_cairo (void)
{
#define CAIRO_REQUIRED_MAJOR 1
166 167
#define CAIRO_REQUIRED_MINOR 10
#define CAIRO_REQUIRED_MICRO 2
168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191

  if (cairo_version () < CAIRO_VERSION_ENCODE (CAIRO_REQUIRED_MAJOR,
                                               CAIRO_REQUIRED_MINOR,
                                               CAIRO_REQUIRED_MICRO))
    {
      return g_strdup_printf
        ("The Cairo version being used is too old!\n\n"
         "GIMP requires Cairo version %d.%d.%d or later.\n"
         "Installed Cairo version is %s.\n\n"
         "Somehow you or your software packager managed\n"
         "to install GIMP with an older Cairo version.\n\n"
         "Please upgrade to Cairo version %d.%d.%d or later.",
         CAIRO_REQUIRED_MAJOR, CAIRO_REQUIRED_MINOR, CAIRO_REQUIRED_MICRO,
         cairo_version_string (),
         CAIRO_REQUIRED_MAJOR, CAIRO_REQUIRED_MINOR, CAIRO_REQUIRED_MICRO);
    }

#undef CAIRO_REQUIRED_MAJOR
#undef CAIRO_REQUIRED_MINOR
#undef CAIRO_REQUIRED_MICRO

  return NULL;
}

192 193 194 195
static gchar *
sanity_check_pango (void)
{
#define PANGO_REQUIRED_MAJOR 1
196 197
#define PANGO_REQUIRED_MINOR 29
#define PANGO_REQUIRED_MICRO 4
198

199 200 201
  const gchar *mismatch = pango_version_check (PANGO_REQUIRED_MAJOR,
                                               PANGO_REQUIRED_MINOR,
                                               PANGO_REQUIRED_MICRO);
202 203 204

  if (mismatch)
    {
205 206 207 208
      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;

209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228
      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;
}

229 230 231
static gchar *
sanity_check_fontconfig (void)
{
232
  const gint fc_version = FcGetVersion ();
233 234 235 236 237

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

238 239 240 241
  if (fc_version < ((FC_REQUIRED_MAJOR * 10000) +
                    (FC_REQUIRED_MINOR *   100) +
                    (FC_REQUIRED_MICRO *     1)))
    {
242 243 244 245
      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;

246
      return g_strdup_printf
247
        ("The Fontconfig version being used is too old!\n\n"
248 249
         "GIMP requires Fontconfig version %d.%d.%d or later.\n"
         "The Fontconfig version loaded by GIMP is %d.%d.%d.\n\n"
250 251 252 253 254 255
         "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);
    }
256 257 258 259

#undef FC_REQUIRED_MAJOR
#undef FC_REQUIRED_MINOR
#undef FC_REQUIRED_MICRO
260

261 262
  return NULL;
}
263

264 265 266 267 268 269 270 271
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;
272 273 274 275 276

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

277 278 279 280 281 282 283
  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);
284

285 286 287 288 289 290 291 292 293 294 295 296 297
  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"
298
         "GIMP requires FreeType version %d.%d.%d or later.\n"
299 300
         "Installed FreeType version is %d.%d.%d.\n\n"
         "Somehow you or your software packager managed\n"
301
         "to install GIMP with an older FreeType version.\n\n"
302 303 304 305 306
         "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);
    }
307 308 309 310 311

#undef FT_REQUIRED_MAJOR
#undef FT_REQUIRED_MINOR
#undef FT_REQUIRED_MICRO

312
  return NULL;
313
}
314

315 316 317 318
static gchar *
sanity_check_gdk_pixbuf (void)
{
#define GDK_PIXBUF_REQUIRED_MAJOR 2
319
#define GDK_PIXBUF_REQUIRED_MINOR 24
320
#define GDK_PIXBUF_REQUIRED_MICRO 1
321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344

  if (! sanity_check_version (gdk_pixbuf_major_version, GDK_PIXBUF_REQUIRED_MAJOR,
                              gdk_pixbuf_minor_version, GDK_PIXBUF_REQUIRED_MINOR,
                              gdk_pixbuf_micro_version, GDK_PIXBUF_REQUIRED_MICRO))
    {
      return g_strdup_printf
        ("GdkPixbuf version too old!\n\n"
         "GIMP requires GdkPixbuf version %d.%d.%d or later.\n"
         "Installed GdkPixbuf version is %d.%d.%d.\n\n"
         "Somehow you or your software packager managed\n"
         "to install GIMP with an older GdkPixbuf version.\n\n"
         "Please upgrade to GdkPixbuf version %d.%d.%d or later.",
         GDK_PIXBUF_REQUIRED_MAJOR, GDK_PIXBUF_REQUIRED_MINOR, GDK_PIXBUF_REQUIRED_MICRO,
         gdk_pixbuf_major_version, gdk_pixbuf_minor_version, gdk_pixbuf_micro_version,
         GDK_PIXBUF_REQUIRED_MAJOR, GDK_PIXBUF_REQUIRED_MINOR, GDK_PIXBUF_REQUIRED_MICRO);
    }

#undef GDK_PIXBUF_REQUIRED_MAJOR
#undef GDK_PIXBUF_REQUIRED_MINOR
#undef GDK_PIXBUF_REQUIRED_MICRO

  return NULL;
}

345 346 347 348 349 350 351 352
static gchar *
sanity_check_babl (void)
{
  gint babl_major_version;
  gint babl_minor_version;
  gint babl_micro_version;

#define BABL_REQUIRED_MAJOR 0
353
#define BABL_REQUIRED_MINOR 1
354
#define BABL_REQUIRED_MICRO 11
355 356 357 358 359

  babl_get_version (&babl_major_version,
                    &babl_minor_version,
                    &babl_micro_version);

360 361 362
  if (! sanity_check_version (babl_major_version, BABL_REQUIRED_MAJOR,
                              babl_minor_version, BABL_REQUIRED_MINOR,
                              babl_micro_version, BABL_REQUIRED_MICRO))
363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382
    {
      return g_strdup_printf
        ("BABL version too old!\n\n"
         "GIMP requires BABL version %d.%d.%d or later.\n"
         "Installed BABL version is %d.%d.%d.\n\n"
         "Somehow you or your software packager managed\n"
         "to install GIMP with an older BABL version.\n\n"
         "Please upgrade to BABL version %d.%d.%d or later.",
         BABL_REQUIRED_MAJOR, BABL_REQUIRED_MINOR, BABL_REQUIRED_MICRO,
         babl_major_version, babl_minor_version, babl_micro_version,
         BABL_REQUIRED_MAJOR, BABL_REQUIRED_MINOR, BABL_REQUIRED_MICRO);
    }

#undef BABL_REQUIRED_MAJOR
#undef BABL_REQUIRED_MINOR
#undef BABL_REQUIRED_MICRO

  return NULL;
}

383 384 385 386 387 388 389 390
static gchar *
sanity_check_gegl (void)
{
  gint gegl_major_version;
  gint gegl_minor_version;
  gint gegl_micro_version;

#define GEGL_REQUIRED_MAJOR 0
391
#define GEGL_REQUIRED_MINOR 2
392
#define GEGL_REQUIRED_MICRO 1
393 394 395 396 397

  gegl_get_version (&gegl_major_version,
                    &gegl_minor_version,
                    &gegl_micro_version);

398 399 400
  if (! sanity_check_version (gegl_major_version, GEGL_REQUIRED_MAJOR,
                              gegl_minor_version, GEGL_REQUIRED_MINOR,
                              gegl_micro_version, GEGL_REQUIRED_MICRO))
401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420
    {
      return g_strdup_printf
        ("GEGL version too old!\n\n"
         "GIMP requires GEGL version %d.%d.%d or later.\n"
         "Installed GEGL version is %d.%d.%d.\n\n"
         "Somehow you or your software packager managed\n"
         "to install GIMP with an older GEGL version.\n\n"
         "Please upgrade to GEGL version %d.%d.%d or later.",
         GEGL_REQUIRED_MAJOR, GEGL_REQUIRED_MINOR, GEGL_REQUIRED_MICRO,
         gegl_major_version, gegl_minor_version, gegl_micro_version,
         GEGL_REQUIRED_MAJOR, GEGL_REQUIRED_MINOR, GEGL_REQUIRED_MICRO);
    }

#undef GEGL_REQUIRED_MAJOR
#undef GEGL_REQUIRED_MINOR
#undef GEGL_REQUIRED_MICRO

  return NULL;
}

421 422 423 424 425 426
static gchar *
sanity_check_filename_encoding (void)
{
  gchar  *result;
  GError *error = NULL;

427
  result = g_filename_to_utf8 ("", -1, NULL, NULL, &error);
428

429
  if (! result)
430
    {
431 432 433 434 435 436 437 438 439
      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);
440

441
      return msg;
442
    }
443 444 445 446 447 448

  g_free (result);

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

  if (! result)
449 450 451
    {
      gchar *msg =
        g_strdup_printf
452 453 454
        (_("The name of the directory holding the GIMP user configuration "
           "cannot be converted to UTF-8: "
           "%s\n\n"
455 456
           "Your filesystem probably stores files in an encoding "
           "other than UTF-8 and you didn't tell GLib about this. "
457
           "Please set the environment variable G_FILENAME_ENCODING."),
458 459 460 461 462 463
         error->message);

      g_error_free (error);

      return msg;
    }
464 465 466 467

  g_free (result);

  return NULL;
468
}