subdir('pixops')

# Loader libs
#  - name
#  - sources
#  - conditional, otherwise always built

# We need to disable the in-house loaders for BMP, GIF and ICO
# when native_windows_loaders is true
loaders = [
  [ 'png', [ 'io-png.c' ], enabled_loaders.contains('png') ],
  [ 'bmp', [ 'io-bmp.c' ], not native_windows_loaders ],
  [ 'gif', [ 'io-gif.c', 'io-gif-animation.c' ], not native_windows_loaders ],
  [ 'ico', [ 'io-ico.c' ], not native_windows_loaders ],
  [ 'ani', [ 'io-ani.c', 'io-ani-animation.c' ] ],
  [ 'jpeg', [ 'io-jpeg.c' ], enabled_loaders.contains('jpeg') ],
  [ 'pnm', [ 'io-pnm.c' ] ],
  [ 'tiff', [ 'io-tiff.c' ], enabled_loaders.contains('tiff') ],
  [ 'xpm', [ 'io-xpm.c' ] ],
  [ 'xbm', [ 'io-xbm.c' ] ],
  [ 'tga', [ 'io-tga.c', 'gdk-pixbuf-buffer-queue.c' ] ],
  [ 'icns', [ 'io-icns.c' ] ],
  [ 'jasper', [ 'io-jasper.c' ], enabled_loaders.contains('jasper'), jasper_extra_cflags ],
  [ 'qtif', [ 'io-qtif.c' ] ]
]

gdk_pixbuf_inc = include_directories('.')

gdk_pixbuf_cflags = [
  '-DG_LOG_STRUCTURED=1',
  '-DG_LOG_DOMAIN="GdkPixbuf"',
  '-DGDK_PIXBUF_COMPILATION',
  '-DGDK_PIXBUF_PREFIX="@0@"'.format(gdk_pixbuf_prefix),
  '-DGDK_PIXBUF_LOCALEDIR="@0@"'.format(gdk_pixbuf_localedir),
  '-DGDK_PIXBUF_LIBDIR="@0@"'.format(gdk_pixbuf_libdir),
  '-DGDK_PIXBUF_BINARY_VERSION="@0@"'.format(gdk_pixbuf_binary_version),
  '-DGDK_PIXBUF_ENABLE_BACKEND',
  '-DPIXBUF_LIBDIR="@0@"'.format(gdk_pixbuf_loaderdir),
  '-DBUILT_MODULES_DIR="@0@"'.format(meson.current_build_dir()),
]

gdk_pixbuf_api_path = join_paths(gdk_pixbuf_api_name, 'gdk-pixbuf')

gdkpixbuf_features_conf = configuration_data()
gdkpixbuf_features_conf.set('GDK_PIXBUF_MAJOR', gdk_pixbuf_version_major)
gdkpixbuf_features_conf.set('GDK_PIXBUF_MINOR', gdk_pixbuf_version_minor)
gdkpixbuf_features_conf.set('GDK_PIXBUF_MICRO', gdk_pixbuf_version_micro)
gdkpixbuf_features_conf.set('GDK_PIXBUF_VERSION', meson.project_version())
gdkpixbuf_features_conf.set('GDK_PIXBUF_API_VERSION', gdk_pixbuf_api_version)
gdkpixbuf_features_conf.set('LT_CURRENT_MINUS_AGE', current_minus_age)

gdk_pixbuf_features_h = configure_file(input: 'gdk-pixbuf-features.h.in',
                                       output: 'gdk-pixbuf-features.h',
                                       configuration: gdkpixbuf_features_conf,
                                       install: true,
                                       install_dir: join_paths(gdk_pixbuf_includedir, gdk_pixbuf_api_path))

gdkpixbuf_headers = [
  'gdk-pixbuf.h',
  'gdk-pixbuf-animation.h',
  'gdk-pixbuf-autocleanups.h',
  'gdk-pixbuf-core.h',
  'gdk-pixbuf-io.h',
  'gdk-pixbuf-loader.h',
  'gdk-pixbuf-macros.h',
  'gdk-pixbuf-simple-anim.h',
  'gdk-pixbuf-transform.h',
]

install_headers(gdkpixbuf_headers + [ 'gdk-pixdata.h' ], subdir: gdk_pixbuf_api_path)

gdkpixbuf_sources = [
  'gdk-pixbuf.c',
  'gdk-pixbuf-animation.c',
  'gdk-pixbuf-data.c',
  'gdk-pixbuf-io.c',
  'gdk-pixbuf-loader.c',
  'gdk-pixbuf-scale.c',
  'gdk-pixbuf-simple-anim.c',
  'gdk-pixbuf-scaled-anim.c',
  'gdk-pixbuf-util.c',
  'gdk-pixdata.c',
]

gdkpixbuf_marshals = gnome.genmarshal('gdk-pixbuf-marshal',
                                      sources: 'gdk-pixbuf-marshal.list',
                                      prefix: '_gdk_pixbuf_marshal',
                                      install_header: true,
                                      install_dir: join_paths(gdk_pixbuf_includedir, gdk_pixbuf_api_path))

gdkpixbuf_enums = gnome.mkenums('gdk-pixbuf-enum-types',
                                sources: gdkpixbuf_headers,
                                c_template: 'gdk-pixbuf-enum-types.c.template',
                                h_template: 'gdk-pixbuf-enum-types.h.template',
                                install_header: true,
                                install_dir: join_paths(gdk_pixbuf_includedir, gdk_pixbuf_api_path))
gdkpixbuf_enum_h = gdkpixbuf_enums[1]

if host_system == 'windows'
  gdk_pixbuf_win_rc = configure_file(
    input: 'gdk_pixbuf.rc.in',
    output: 'gdk_pixbuf.rc',
    configuration: gdkpixbuf_features_conf,
  )
  gdk_pixbuf_win_res = import('windows').compile_resources(gdk_pixbuf_win_rc)
  gdkpixbuf_sources += gdk_pixbuf_win_res
endif

# Check if we need to build loaders as built-in functionality
included_loaders_cflags = []
included_loaders_deps = []

foreach l: loaders
  name = l[0]
  sources = l[1]
  cond = l.get(2, true)
  cflags = l.get(3, [])

  if cond and (builtin_loaders.contains(name) or builtin_all_loaders)
    cflag_for_included_loader = ['-DINCLUDE_@0@'.format(name)]
    included_loaders_cflags += cflag_for_included_loader

    mod = static_library('staticpixbufloader-@0@'.format(name),
                         sources,
                         dependencies: loaders_deps + gdk_pixbuf_deps,
                         include_directories: [ root_inc, gdk_pixbuf_inc ],
                         c_args: common_cflags + gdk_pixbuf_cflags + cflags + cflag_for_included_loader)

    included_loaders_deps += declare_dependency(link_with: mod)
  endif
endforeach

# List of formats supported by the native Windows components-based loader(s)
windows_native_loader_formats = [ 'bmp', 'emf', 'gif', 'ico', 'jpeg', 'tiff', 'wmf' ]
windows_base_loader_sources = [ 'io-gdip-utils.c', 'io-gdip-animation.c' ]

# Build the loaders using native Windows components as static modules, if requested
if native_windows_loaders
  if builtin_loaders.contains('windows') or builtin_all_loaders
    cflag_for_included_loader = ['-DINCLUDE_gdiplus']
    included_loaders_cflags += cflag_for_included_loader
    win_loader_sources = windows_base_loader_sources
    foreach loader: windows_native_loader_formats
      win_loader_sources += 'io-gdip-@0@.c'.format(loader)
    endforeach

    mod = static_library('staticpixbufloader-gdiplus',
                         win_loader_sources,
                         dependencies: loaders_deps + gdk_pixbuf_deps,
                         include_directories: [ root_inc, gdk_pixbuf_inc ],
                         c_args: common_cflags + gdk_pixbuf_cflags + cflag_for_included_loader)

    included_loaders_deps += declare_dependency(link_with: mod)
  endif
endif

# The main gdk-pixbuf shared library
gdkpixbuf = library('gdk_pixbuf-2.0',
                    gdkpixbuf_sources + pixops_sources + gdkpixbuf_enums + gdkpixbuf_marshals,
                    soversion: soversion,
                    version: libversion,
                    c_args: common_cflags + gdk_pixbuf_cflags + included_loaders_cflags,
                    link_args: common_ldflags,
                    include_directories: [
                      root_inc,
                      include_directories('pixops'),
                    ],
                    dependencies: gdk_pixbuf_deps + included_loaders_deps,
                    install: true)

gdkpixbuf_dep = declare_dependency(link_with: gdkpixbuf,
                                   include_directories: root_inc,
                                   dependencies: gdk_pixbuf_deps,
                                   sources: gdkpixbuf_enum_h)

# Now check if we are building loaders as installed shared modules
# We do this here because shared modules depend on libgdk-pixbuf
dynamic_loaders = []

foreach l: loaders
  name = l[0]
  sources = l[1]
  cond = l.get(2, true)
  cflags = l.get(3, [])

  if cond and not (builtin_loaders.contains(name) or builtin_all_loaders)
    mod = shared_module('pixbufloader-@0@'.format(name),
                        sources,
                        dependencies: loaders_deps + gdk_pixbuf_deps + [ gdkpixbuf_dep ],
                        include_directories: [ root_inc, gdk_pixbuf_inc ],
                        c_args: common_cflags + gdk_pixbuf_cflags + cflags,
                        install: true,
                        install_dir: gdk_pixbuf_loaderdir)

    # We need the path to build loaders.cache for tests
    dynamic_loaders += mod.full_path()
  endif
endforeach

# Build the loaders using native Windows components as dynamic modules, if requested
if native_windows_loaders
  if not (builtin_loaders.contains('windows') or builtin_all_loaders)
    foreach loader: windows_native_loader_formats
      loader_sources = windows_base_loader_sources + [ 'io-gdip-@0@.c'.format(loader) ]

      mod = shared_module('pixbufloader-gdip-@0@'.format(loader),
                          loader_sources,
                          dependencies: loaders_deps + gdk_pixbuf_deps + [ gdkpixbuf_dep ],
                          include_directories: [ root_inc, gdk_pixbuf_inc ],
                          c_args: common_cflags + gdk_pixbuf_cflags + cflags,
                          install: true,
                          install_dir: gdk_pixbuf_loaderdir)
      dynamic_loaders += mod.full_path()
    endforeach
  endif
endif

gdkpixbuf_bin = [
  [ 'gdk-pixbuf-csource' ],
  [ 'gdk-pixbuf-pixdata' ],
  [ 'gdk-pixbuf-query-loaders', [ 'queryloaders.c' ] ],
]

foreach bin: gdkpixbuf_bin
  bin_name = bin[0]
  bin_source = bin.get(1, bin_name + '.c')

  bin = executable(bin_name, bin_source,
                   dependencies: gdk_pixbuf_deps + [ gdkpixbuf_dep ],
                   include_directories: [ root_inc, gdk_pixbuf_inc ],
                   c_args: common_cflags + gdk_pixbuf_cflags,
                   install: true)

  # Used in tests
  set_variable(bin_name.underscorify(), bin)
endforeach

# The 'loaders.cache' used for testing, so we don't accidentally
# load the installed cache; we always build it by default
loaders_cache = custom_target('loaders.cache',
                              output: 'loaders.cache',
                              capture: true,
                              command: [
                                gdk_pixbuf_query_loaders,
                                dynamic_loaders,
                              ],
                              build_by_default: true)
loaders_dep = declare_dependency(sources: [ loaders_cache ])

build_gir = get_option('gir')
if build_gir
  gir_args = [
    '--quiet',
    '-DGDK_PIXBUF_COMPILATION',
  ]

  gdkpixbuf_gir = gnome.generate_gir(
    gdkpixbuf,
    sources: gdkpixbuf_sources + gdkpixbuf_headers + gdkpixbuf_enums + [
      gdk_pixbuf_features_h,
      'gdk-pixdata.h',
    ],
    namespace: 'GdkPixbuf',
    nsversion: gdk_pixbuf_api_version,
    identifier_prefix: 'Gdk',
    symbol_prefix: 'gdk',
    export_packages: 'gdk-pixbuf-2.0',
    includes: [ 'GModule-2.0', 'Gio-2.0', ],
    header: 'gdk-pixbuf/gdk-pixbuf.h',
    install: true,
    extra_args: gir_args,
  )
endif

pkgconfig = import('pkgconfig')
pkgconfig.generate(
  name: 'GdkPixbuf',
  description: 'Image loading and scaling',
  version: meson.project_version(),
  variables: [
    'gdk_pixbuf_binary_version=@0@'.format(gdk_pixbuf_binary_version),
    'gdk_pixbuf_binarydir=${libdir}/@0@/@1@'.format(gdk_pixbuf_api_name, gdk_pixbuf_binary_version),
    'gdk_pixbuf_moduledir=${gdk_pixbuf_binarydir}/loaders',
    'gdk_pixbuf_cache_file=${gdk_pixbuf_binarydir}/loaders.cache',
  ],
  libraries: gdkpixbuf,
  requires: 'gobject-2.0',
  subdirs: gdk_pixbuf_api_name,
  filebase: gdk_pixbuf_api_name,
  install_dir: join_paths(gdk_pixbuf_libdir, 'pkgconfig'),
)