## Version Information

Version Information — Variables and functions to check the GTK+ version

## Synopsis

    #include <gtk/gtk.h>

    guint               gtk_get_major_version               (void);
    guint               gtk_get_minor_version               (void);
    guint               gtk_get_micro_version               (void);
    guint               gtk_get_binary_age                  (void);
    guint               gtk_get_interface_age               (void);
    const gchar *       gtk_check_version                   (guint required_major,
                                                             guint required_minor,
                                                             guint required_micro);

    #define             GTK_MAJOR_VERSION
    #define             GTK_MINOR_VERSION
    #define             GTK_MICRO_VERSION
    #define             GTK_BINARY_AGE
    #define             GTK_INTERFACE_AGE
    #define             GTK_CHECK_VERSION                   (major,
                                                             minor,
                                                             micro)

## Description

GTK+ provides version information, primarily useful in configure checks for builds that have a configure script. Applications will not typically use the features described here.

## Details

### gtk_get_major_version ()

    guint               gtk_get_major_version               (void);

Returns the major version number of the GTK+ library. (e.g. in GTK+ version 3.1.5 this is 3.)

This function is in the library, so it represents the GTK+ library your code is running against. Contrast with the GTK_MAJOR_VERSION macro, which represents the major version of the GTK+ headers you have included when compiling your code.

Returns : | the major version number of the GTK+ library

Since 3.0

### gtk_get_minor_version ()

    guint               gtk_get_minor_version               (void);

Returns the minor version number of the GTK+ library. (e.g. in GTK+ version 3.1.5 this is 1.)

This function is in the library, so it represents the GTK+ library your code is are running against. Contrast with the GTK_MINOR_VERSION macro, which represents the minor version of the GTK+ headers you have included when compiling your code.

Returns : | the minor version number of the GTK+ library

Since 3.0

### gtk_get_micro_version ()

    guint               gtk_get_micro_version               (void);

Returns the micro version number of the GTK+ library. (e.g. in GTK+ version 3.1.5 this is 5.)

This function is in the library, so it represents the GTK+ library your code is are running against. Contrast with the GTK_MICRO_VERSION macro, which represents the micro version of the GTK+ headers you have included when compiling your code.

Returns : | the micro version number of the GTK+ library

Since 3.0

### gtk_get_binary_age ()

    guint               gtk_get_binary_age                  (void);

Returns the binary age as passed to libtool when building the GTK+ library the process is running against. If libtool means nothing to you, don't worry about it.

Returns : | the binary age of the GTK+ library

Since 3.0

### gtk_get_interface_age ()

    guint               gtk_get_interface_age               (void);

Returns the interface age as passed to libtool when building the GTK+ library the process is running against. If libtool means nothing to you, don't worry about it.

Returns : | the interface age of the GTK+ library

Since 3.0

### gtk_check_version ()

    const gchar *       gtk_check_version                   (guint required_major,
                                                             guint required_minor,
                                                             guint required_micro);

Checks that the GTK+ library in use is compatible with the given version. Generally you would pass in the constants GTK_MAJOR_VERSION, GTK_MINOR_VERSION, GTK_MICRO_VERSION as the three arguments to this function; that produces a check that the library in use is compatible with the version of GTK+ the application or module was compiled against.

Compatibility is defined by two things: first the version of the running library is newer than the version `required_major.required_minor`.`required_micro`. Second the running library must be binary compatible with the version `required_major.required_minor`.`required_micro` (same major version.)

This function is primarily for GTK+ modules; the module can call this function to check that it wasn't loaded into an incompatible version of GTK+. However, such a check isn't completely reliable, since the module may be linked against an old version of GTK+ and calling the old version of `gtk_check_version()`, but still get loaded into an application using a newer version of GTK+.

`required_major` : | the required major version
`required_minor` : | the required minor version
`required_micro` : | the required micro version
Returns : | `NULL` if the GTK+ library is compatible with the given version, or a string describing the version mismatch. The returned string is owned by GTK+ and should not be modified or freed.

### GTK_MAJOR_VERSION

    #define GTK_MAJOR_VERSION (3)

Like `gtk_get_major_version()`, but from the headers used at application compile time, rather than from the library linked against at application run time.

### GTK_MINOR_VERSION

    #define GTK_MINOR_VERSION (10)

Like `gtk_get_minor_version()`, but from the headers used at application compile time, rather than from the library linked against at application run time.

### GTK_MICRO_VERSION

    #define GTK_MICRO_VERSION (7)

Like `gtk_get_micro_version()`, but from the headers used at application compile time, rather than from the library linked against at application run time.

### GTK_BINARY_AGE

    #define GTK_BINARY_AGE    (1007)

Like `gtk_get_binary_age()`, but from the headers used at application compile time, rather than from the library linked against at application run time.

### GTK_INTERFACE_AGE

    #define GTK_INTERFACE_AGE (7)

Like `gtk_get_interface_age()`, but from the headers used at application compile time, rather than from the library linked against at application run time.

### GTK_CHECK_VERSION()

    #define             GTK_CHECK_VERSION(major,minor,micro)

`major` : | major version (e.g. 1 for version 1.2.5)
`minor` : | minor version (e.g. 2 for version 1.2.5)
`micro` : | micro version (e.g. 5 for version 1.2.5)
Returns : | `TRUE` if the version of the GTK+ header files is the same as or newer than the passed-in version.