libraries/matplotlib: Updated for version 1.4.1.

Signed-off-by: Willy Sudiarto Raharjo <willysr@slackbuilds.org>

1 files changed, 2154 insertions, 0 deletions

diff --git a/libraries/matplotlib/setupext.py b/libraries/matplotlib/setupext.py
new file mode 100644
index 0000000000..c083627811
--- /dev/null
+++ b/libraries/matplotlib/setupext.py
@@ -0,0 +1,2154 @@
+from __future__ import print_function, absolute_import
+
+from distutils import sysconfig
+from distutils import version
+from distutils.core import Extension
+import glob
+import io
+import multiprocessing
+import os
+import re
+import subprocess
+import sys
+import warnings
+from textwrap import fill
+
+
+PY3 = (sys.version_info[0] >= 3)
+
+
+try:
+    from subprocess import check_output
+except ImportError:
+    # check_output is not available in Python 2.6
+    def check_output(*popenargs, **kwargs):
+        """
+        Run command with arguments and return its output as a byte
+        string.
+
+        Backported from Python 2.7 as it's implemented as pure python
+        on stdlib.
+        """
+        process = subprocess.Popen(
+            stdout=subprocess.PIPE, *popenargs, **kwargs)
+        output, unused_err = process.communicate()
+        retcode = process.poll()
+        if retcode:
+            cmd = kwargs.get("args")
+            if cmd is None:
+                cmd = popenargs[0]
+            error = subprocess.CalledProcessError(retcode, cmd)
+            error.output = output
+            raise error
+        return output
+
+
+if sys.platform != 'win32':
+    if sys.version_info[0] < 3:
+        from commands import getstatusoutput
+    else:
+        from subprocess import getstatusoutput
+
+
+if PY3:
+    import configparser
+else:
+    import ConfigParser as configparser
+
+
+# matplotlib build options, which can be altered using setup.cfg
+options = {
+    'display_status': True,
+    'verbose': False,
+    'backend': None,
+    'basedirlist': None
+    }
+
+
+setup_cfg = os.environ.get('MPLSETUPCFG', 'setup.cfg')
+if os.path.exists(setup_cfg):
+    config = configparser.SafeConfigParser()
+    config.read(setup_cfg)
+
+    try:
+        options['display_status'] = not config.getboolean("status", "suppress")
+    except:
+        pass
+
+    try:
+        options['backend'] = config.get("rc_options", "backend")
+    except:
+        pass
+
+    try:
+        options['basedirlist'] = [
+            x.strip() for x in
+            config.get("directories", "basedirlist").split(',')]
+    except:
+        pass
+else:
+    config = None
+
+
+def get_win32_compiler():
+    """
+    Determine the compiler being used on win32.
+    """
+    # Used to determine mingw32 or msvc
+    # This is pretty bad logic, someone know a better way?
+    for v in sys.argv:
+        if 'mingw32' in v:
+            return 'mingw32'
+    return 'msvc'
+win32_compiler = get_win32_compiler()
+
+
+def extract_versions():
+    """
+    Extracts version values from the main matplotlib __init__.py and
+    returns them as a dictionary.
+    """
+    with open('lib/matplotlib/__init__.py') as fd:
+        for line in fd.readlines():
+            if (line.startswith('__version__')):
+                exec(line.strip())
+    return locals()
+
+
+def has_include_file(include_dirs, filename):
+    """
+    Returns `True` if `filename` can be found in one of the
+    directories in `include_dirs`.
+    """
+    if sys.platform == 'win32':
+        include_dirs += os.environ.get('INCLUDE', '.').split(';')
+    for dir in include_dirs:
+        if os.path.exists(os.path.join(dir, filename)):
+            return True
+    return False
+
+
+def check_include_file(include_dirs, filename, package):
+    """
+    Raises an exception if the given include file can not be found.
+    """
+    if not has_include_file(include_dirs, filename):
+        raise CheckFailed(
+            "The C/C++ header for %s (%s) could not be found.  You "
+            "may need to install the development package." %
+            (package, filename))
+
+
+def get_base_dirs():
+    """
+    Returns a list of standard base directories on this platform.
+    """
+    if options['basedirlist']:
+        return options['basedirlist']
+
+    basedir_map = {
+        'win32': ['win32_static',],
+        'darwin': ['/usr/local/', '/usr', '/usr/X11', '/opt/local'],
+        'sunos5': [os.getenv('MPLIB_BASE') or '/usr/local',],
+        'gnu0': ['/usr'],
+        'aix5': ['/usr/local'],
+        }
+    return basedir_map.get(sys.platform, ['/usr/local', '/usr'])
+
+
+def get_include_dirs():
+    """
+    Returns a list of standard include directories on this platform.
+    """
+    return [os.path.join(d, 'include') for d in get_base_dirs()]
+
+
+def is_min_version(found, minversion):
+    """
+    Returns `True` if `found` is at least as high a version as
+    `minversion`.
+    """
+    expected_version = version.LooseVersion(minversion)
+    found_version = version.LooseVersion(found)
+    return found_version >= expected_version
+
+
+# Define the display functions only if display_status is True.
+if options['display_status']:
+    def print_line(char='='):
+        print(char * 76)
+
+    def print_status(package, status):
+        initial_indent = "%22s: " % package
+        indent = ' ' * 24
+        print(fill(str(status), width=76,
+                   initial_indent=initial_indent,
+                   subsequent_indent=indent))
+
+    def print_message(message):
+        indent = ' ' * 24 + "* "
+        print(fill(str(message), width=76,
+                   initial_indent=indent,
+                   subsequent_indent=indent))
+
+    def print_raw(section):
+        print(section)
+else:
+    def print_line(*args, **kwargs):
+        pass
+    print_status = print_message = print_raw = print_line
+
+
+# Remove the -Wstrict-prototypesoption, is it's not valid for C++
+customize_compiler = sysconfig.customize_compiler
+def my_customize_compiler(compiler):
+    retval = customize_compiler(compiler)
+    try:
+        compiler.compiler_so.remove('-Wstrict-prototypes')
+    except (ValueError, AttributeError):
+        pass
+    return retval
+
+sysconfig.customize_compiler = my_customize_compiler
+
+
+def make_extension(name, files, *args, **kwargs):
+    """
+    Make a new extension.  Automatically sets include_dirs and
+    library_dirs to the base directories appropriate for this
+    platform.
+
+    `name` is the name of the extension.
+
+    `files` is a list of source files.
+
+    Any additional arguments are passed to the
+    `distutils.core.Extension` constructor.
+    """
+    ext = DelayedExtension(name, files, *args, **kwargs)
+    for dir in get_base_dirs():
+        include_dir = os.path.join(dir, 'include')
+        if os.path.exists(include_dir):
+            ext.include_dirs.append(include_dir)
+        for lib in ('lib', 'lib64'):
+            lib_dir = os.path.join(dir, lib)
+            if os.path.exists(lib_dir):
+                ext.library_dirs.append(lib_dir)
+    ext.include_dirs.append('.')
+
+    return ext
+
+
+class PkgConfig(object):
+    """
+    This is a class for communicating with pkg-config.
+    """
+    def __init__(self):
+        """
+        Determines whether pkg-config exists on this machine.
+        """
+        if sys.platform == 'win32':
+            self.has_pkgconfig = False
+        else:
+            self.set_pkgconfig_path()
+            status, output = getstatusoutput("pkg-config --help")
+            self.has_pkgconfig = (status == 0)
+            if not self.has_pkgconfig:
+                print("IMPORTANT WARNING:")
+                print(
+                    "    pkg-config is not installed.\n"
+                    "    matplotlib may not be able to find some of its dependencies")
+
+    def set_pkgconfig_path(self):
+        pkgconfig_path = sysconfig.get_config_var('LIBDIR')
+        if pkgconfig_path is None:
+            return
+
+        pkgconfig_path = os.path.join(pkgconfig_path, 'pkgconfig')
+        if not os.path.isdir(pkgconfig_path):
+            return
+
+        try:
+            os.environ['PKG_CONFIG_PATH'] += ':' + pkgconfig_path
+        except KeyError:
+            os.environ['PKG_CONFIG_PATH'] = pkgconfig_path
+
+    def setup_extension(self, ext, package, default_include_dirs=[],
+                        default_library_dirs=[], default_libraries=[],
+                        alt_exec=None):
+        """
+        Add parameters to the given `ext` for the given `package`.
+        """
+        flag_map = {
+            '-I': 'include_dirs', '-L': 'library_dirs', '-l': 'libraries'}
+
+        executable = alt_exec
+        if self.has_pkgconfig:
+            executable = 'pkg-config {0}'.format(package)
+
+        use_defaults = True
+
+        if executable is not None:
+            command = "{0} --libs --cflags ".format(executable)
+
+            try:
+                output = check_output(command, shell=True,
+                                      stderr=subprocess.STDOUT)
+            except subprocess.CalledProcessError:
+                pass
+            else:
+                output = output.decode(sys.getfilesystemencoding())
+                use_defaults = False
+                for token in output.split():
+                    attr = flag_map.get(token[:2])
+                    if attr is not None:
+                        getattr(ext, attr).insert(0, token[2:])
+
+        if use_defaults:
+            basedirs = get_base_dirs()
+            for base in basedirs:
+                for include in default_include_dirs:
+                    dir = os.path.join(base, include)
+                    if os.path.exists(dir):
+                        ext.include_dirs.append(dir)
+                for lib in default_library_dirs:
+                    dir = os.path.join(base, lib)
+                    if os.path.exists(dir):
+                        ext.library_dirs.append(dir)
+            ext.libraries.extend(default_libraries)
+            return True
+
+        return False
+
+    def get_version(self, package):
+        """
+        Get the version of the package from pkg-config.
+        """
+        if not self.has_pkgconfig:
+            return None
+
+        status, output = getstatusoutput(
+            "pkg-config %s --modversion" % (package))
+        if status == 0:
+            return output
+        return None
+
+
+# The PkgConfig class should be used through this singleton
+pkg_config = PkgConfig()
+
+
+class CheckFailed(Exception):
+    """
+    Exception thrown when a `SetupPackage.check` method fails.
+    """
+    pass
+
+
+class SetupPackage(object):
+    optional = False
+
+    def check(self):
+        """
+        Checks whether the dependencies are met.  Should raise a
+        `CheckFailed` exception if the dependency could not be met,
+        otherwise return a string indicating a version number or some
+        other message indicating what was found.
+        """
+        pass
+
+    def get_packages(self):
+        """
+        Get a list of package names to add to the configuration.
+        These are added to the `packages` list passed to
+        `distutils.setup`.
+        """
+        return []
+
+    def get_namespace_packages(self):
+        """
+        Get a list of namespace package names to add to the configuration.
+        These are added to the `namespace_packages` list passed to
+        `distutils.setup`.
+        """
+        return []
+
+
+    def get_py_modules(self):
+        """
+        Get a list of top-level modules to add to the configuration.
+        These are added to the `py_modules` list passed to
+        `distutils.setup`.
+        """
+        return []
+
+    def get_package_data(self):
+        """
+        Get a package data dictionary to add to the configuration.
+        These are merged into to the `package_data` list passed to
+        `distutils.setup`.
+        """
+        return {}
+
+    def get_extension(self):
+        """
+        Get a list of C extensions (`distutils.core.Extension`
+        objects) to add to the configuration.  These are added to the
+        `extensions` list passed to `distutils.setup`.
+        """
+        return None
+
+    def get_install_requires(self):
+        """
+        Get a list of Python packages that we require.
+        pip/easy_install will attempt to download and install this
+        package if it is not installed.
+        """
+        return []
+
+    def get_setup_requires(self):
+        """
+        Get a list of Python packages that we require at build time.
+        pip/easy_install will attempt to download and install this
+        package if it is not installed.
+        """
+        return []
+
+    def _check_for_pkg_config(self, package, include_file, min_version=None,
+                              version=None):
+        """
+        A convenience function for writing checks for a
+        pkg_config-defined dependency.
+
+        `package` is the pkg_config package name.
+
+        `include_file` is a top-level include file we expect to find.
+
+        `min_version` is the minimum version required.
+
+        `version` will override the found version if this package
+        requires an alternate method for that.
+        """
+        if version is None:
+            version = pkg_config.get_version(package)
+
+            if version is None:
+                raise CheckFailed(
+                    "pkg-config information for '%s' could not be found." %
+                    package)
+
+        if min_version == 'PATCH':
+            raise CheckFailed(
+                "Requires patches that have not been merged upstream.")
+
+        if min_version:
+            if (not is_min_version(version, min_version)):
+                raise CheckFailed(
+                    "Requires %s %s or later.  Found %s." %
+                    (package, min_version, version))
+
+        ext = self.get_extension()
+        if ext is None:
+            ext = make_extension('test', [])
+            pkg_config.setup_extension(ext, package)
+
+        check_include_file(ext.include_dirs, include_file, package)
+
+        return 'version %s' % version
+
+
+class OptionalPackage(SetupPackage):
+    optional = True
+    force = False
+    config_category = "packages"
+
+    @classmethod
+    def get_config(cls):
+        """
+        Look at `setup.cfg` and return one of ["auto", True, False] indicating
+        if the package is at default state ("auto"), forced by the user (True)
+        or opted-out (False).
+        """
+        try:
+            return config.getboolean(cls.config_category, cls.name)
+        except:
+            return "auto"
+
+    def check(self):
+        """
+        Do not override this method!
+
+        For custom dependency checks override self.check_requirements().
+        Two things are checked: Configuration file and requirements.
+        """
+        # Check configuration file
+        conf = self.get_config()
+        # Default "auto" state or install forced by user
+        if conf in [True, 'auto']:
+            message = "installing"
+            # Set non-optional if user sets `True` in config
+            if conf is True:
+                self.optional = False
+        # Configuration opt-out by user
+        else:
+            # Some backend extensions (e.g. Agg) need to be built for certain
+            # other GUI backends (e.g. TkAgg) even when manually disabled
+            if self.force is True:
+                message = "installing forced (config override)"
+            else:
+                raise CheckFailed("skipping due to configuration")
+
+        # Check requirements and add extra information (if any) to message.
+        # If requirements are not met a CheckFailed should be raised in there.
+        additional_info = self.check_requirements()
+        if additional_info:
+            message += ", " + additional_info
+
+        # No CheckFailed raised until now, return install message.
+        return message
+
+    def check_requirements(self):
+        """
+        Override this method to do custom dependency checks.
+
+         - Raise CheckFailed() if requirements are not met.
+         - Return message with additional information, or an empty string
+           (or None) for no additional information.
+        """
+        return ""
+
+
+class OptionalBackendPackage(OptionalPackage):
+    config_category = "gui_support"
+
+
+class Platform(SetupPackage):
+    name = "platform"
+
+    def check(self):
+        return sys.platform
+
+
+class Python(SetupPackage):
+    name = "python"
+
+    def check(self):
+        major, minor1, minor2, s, tmp = sys.version_info
+
+        if major < 2:
+            raise CheckFailed(
+                "Requires Python 2.6 or later")
+        elif major == 2 and minor1 < 6:
+            raise CheckFailed(
+                "Requires Python 2.6 or later (in the 2.x series)")
+        elif major == 3 and minor1 < 1:
+            raise CheckFailed(
+                "Requires Python 3.1 or later (in the 3.x series)")
+
+        return sys.version
+
+
+class Matplotlib(SetupPackage):
+    name = "matplotlib"
+
+    def check(self):
+        return extract_versions()['__version__']
+
+    def get_packages(self):
+        return [
+            'matplotlib',
+            'matplotlib.backends',
+            'matplotlib.backends.qt_editor',
+            'matplotlib.compat',
+            'matplotlib.projections',
+            'matplotlib.axes',
+            'matplotlib.sphinxext',
+            'matplotlib.style',
+            'matplotlib.testing',
+            'matplotlib.testing.jpl_units',
+            'matplotlib.tri',
+            ]
+
+    def get_py_modules(self):
+        return ['pylab']
+
+    def get_package_data(self):
+        return {
+            'matplotlib':
+            [
+                'mpl-data/fonts/afm/*.afm',
+                'mpl-data/fonts/pdfcorefonts/*.afm',
+                'mpl-data/fonts/pdfcorefonts/*.txt',
+                'mpl-data/fonts/ttf/*.ttf',
+                'mpl-data/fonts/ttf/LICENSE_STIX',
+                'mpl-data/fonts/ttf/COPYRIGHT.TXT',
+                'mpl-data/fonts/ttf/README.TXT',
+                'mpl-data/fonts/ttf/RELEASENOTES.TXT',
+                'mpl-data/images/*.xpm',
+                'mpl-data/images/*.svg',
+                'mpl-data/images/*.gif',
+                'mpl-data/images/*.png',
+                'mpl-data/images/*.ppm',
+                'mpl-data/example/*.npy',
+                'mpl-data/matplotlibrc',
+                'backends/web_backend/*.*',
+                'backends/web_backend/jquery/js/*',
+                'backends/web_backend/jquery/css/themes/base/*.*',
+                'backends/web_backend/jquery/css/themes/base/images/*',
+                'backends/web_backend/css/*.*',
+                'backends/Matplotlib.nib/*',
+                'mpl-data/stylelib/*.mplstyle',
+             ]}
+
+
+class SampleData(OptionalPackage):
+    """
+    This handles the sample data that ships with matplotlib.  It is
+    technically optional, though most often will be desired.
+    """
+    name = "sample_data"
+
+    def get_package_data(self):
+        return {
+            'matplotlib':
+            [
+                'mpl-data/sample_data/*.*',
+                'mpl-data/sample_data/axes_grid/*.*',
+            ]}
+
+
+class Toolkits(OptionalPackage):
+    name = "toolkits"
+
+    def get_packages(self):
+        return [
+            'mpl_toolkits',
+            'mpl_toolkits.mplot3d',
+            'mpl_toolkits.axes_grid',
+            'mpl_toolkits.axes_grid1',
+            'mpl_toolkits.axisartist',
+            ]
+
+    def get_namespace_packages(self):
+        return ['mpl_toolkits']
+
+
+class Tests(OptionalPackage):
+    name = "tests"
+    nose_min_version = '0.11.1'
+
+    def check(self):
+        super(Tests, self).check()
+
+        msgs = []
+        msg_template = ('{package} is required to run the matplotlib test '
+                        'suite.  pip/easy_install may attempt to install it '
+                        'after matplotlib.')
+
+
+        bad_nose = msg_template.format(
+            package='nose %s or later' % self.nose_min_version
+        )
+        try:
+            import nose
+            if is_min_version(nose.__version__, self.nose_min_version):
+                msgs += ['using nose version %s' % nose.__version__]
+            else:
+                msgs += [bad_nose]
+        except ImportError:
+            msgs += [bad_nose]
+
+
+        if sys.version_info >= (3, 3):
+            msgs += ['using unittest.mock']
+        else:
+            try:
+                import mock
+                msgs += ['using mock %s' % mock.__version__]
+            except ImportError:
+                msgs += [msg_template.format(package='mock')]
+
+        return ' / '.join(msgs)
+
+    def get_packages(self):
+        return [
+            'matplotlib.tests',
+            ]
+
+    def get_package_data(self):
+        baseline_images = [
+            'tests/baseline_images/%s/*' % x
+            for x in os.listdir('lib/matplotlib/tests/baseline_images')]
+
+        return {
+            'matplotlib':
+            baseline_images +
+            [
+                'tests/mpltest.ttf',
+                'tests/test_rcparams.rc'
+            ]}
+
+    def get_install_requires(self):
+        requires = ['nose>=%s' % self.nose_min_version]
+        if not sys.version_info >= (3, 3):
+            requires += ['mock']
+        return requires
+
+class Toolkits_Tests(Tests):
+    name = "toolkits_tests"
+
+    def check_requirements(self):
+        conf = self.get_config()
+        toolkits_conf = Toolkits.get_config()
+        tests_conf = Tests.get_config()
+
+        if conf is True:
+            Tests.force = True
+            Toolkits.force = True
+        elif conf == "auto" and not (toolkits_conf and tests_conf):
+            # Only auto-install if both toolkits and tests are set
+            # to be installed
+            raise CheckFailed("toolkits_tests needs 'toolkits' and 'tests'")
+        return ""
+
+    def get_packages(self):
+        return [
+            'mpl_toolkits.tests',
+            ]
+
+    def get_package_data(self):
+        baseline_images = [
+            'tests/baseline_images/%s/*' % x
+            for x in os.listdir('lib/mpl_toolkits/tests/baseline_images')]
+
+        return {'mpl_toolkits': baseline_images}
+
+    def get_namespace_packages(self):
+        return ['mpl_toolkits']
+
+
+class DelayedExtension(Extension, object):
+    """
+    A distutils Extension subclass where some of its members
+    may have delayed computation until reaching the build phase.
+
+    This is so we can, for example, get the Numpy include dirs
+    after pip has installed Numpy for us if it wasn't already
+    on the system.
+    """
+    def __init__(self, *args, **kwargs):
+        super(DelayedExtension, self).__init__(*args, **kwargs)
+        self._finalized = False
+        self._hooks = {}
+
+    def add_hook(self, member, func):
+        """
+        Add a hook to dynamically compute a member.
+
+        Parameters
+        ----------
+        member : string
+            The name of the member
+
+        func : callable
+            The function to call to get dynamically-computed values
+            for the member.
+        """
+        self._hooks[member] = func
+
+    def finalize(self):
+        self._finalized = True
+
+    class DelayedMember(property):
+        def __init__(self, name):
+            self._name = name
+
+        def __get__(self, obj, objtype=None):
+            result = getattr(obj, '_' + self._name, [])
+
+            if obj._finalized:
+                if self._name in obj._hooks:
+                    result = obj._hooks[self._name]() + result
+
+            return result
+
+        def __set__(self, obj, value):
+            setattr(obj, '_' + self._name, value)
+
+    include_dirs = DelayedMember('include_dirs')
+
+
+class Numpy(SetupPackage):
+    name = "numpy"
+
+    @staticmethod
+    def include_dirs_hook():
+        if sys.version_info[0] >= 3:
+            import builtins
+            if hasattr(builtins, '__NUMPY_SETUP__'):
+                del builtins.__NUMPY_SETUP__
+            import imp
+            import numpy
+            imp.reload(numpy)
+        else:
+            import __builtin__
+            if hasattr(__builtin__, '__NUMPY_SETUP__'):
+                del __builtin__.__NUMPY_SETUP__
+            import numpy
+            reload(numpy)
+
+        ext = Extension('test', [])
+        ext.include_dirs.append(numpy.get_include())
+        if not has_include_file(
+                ext.include_dirs, os.path.join("numpy", "arrayobject.h")):
+            warnings.warn(
+                "The C headers for numpy could not be found. "
+                "You may need to install the development package")
+
+        return [numpy.get_include()]
+
+    def check(self):
+        min_version = extract_versions()['__version__numpy__']
+        try:
+            import numpy
+        except ImportError:
+            raise CheckFailed(
+                    "could not be found" )
+            #return 'not found. pip may install it below.'
+
+        if not is_min_version(numpy.__version__, min_version):
+            raise CheckFailed(
+                "requires numpy %s or later to build; found %s" %
+                (min_version, numpy.__version__))
+
+        return 'version %s' % numpy.__version__
+
+    def add_flags(self, ext):
+        # Ensure that PY_ARRAY_UNIQUE_SYMBOL is uniquely defined for
+        # each extension
+        array_api_name = 'MPL_' + ext.name.replace('.', '_') + '_ARRAY_API'
+
+        ext.define_macros.append(('PY_ARRAY_UNIQUE_SYMBOL', array_api_name))
+        ext.add_hook('include_dirs', self.include_dirs_hook)
+
+    def get_setup_requires(self):
+        return ['numpy>=1.6']
+
+    def get_install_requires(self):
+        return ['numpy>=1.6']
+
+
+class CXX(SetupPackage):
+    name = 'pycxx'
+
+    def check(self):
+        if PY3:
+            # There is no version of PyCXX in the wild that will work
+            # with Python 3.x and matplotlib, since they lack support
+            # for the buffer object.
+            self.__class__.found_external = False
+            return ("Official versions of PyCXX are not compatible "
+                    "with matplotlib on Python 3.x, since they lack "
+                    "support for the buffer object.  Using local "
+                    "copy")
+
+        self.__class__.found_external = True
+        old_stdout = sys.stdout
+        if PY3:
+            sys.stdout = io.StringIO()
+        else:
+            sys.stdout = io.BytesIO()
+
+        try:
+            import CXX
+        except ImportError:
+            self.__class__.found_external = False
+            return "Couldn't import.  Using local copy."
+        finally:
+            sys.stdout = old_stdout
+
+        try:
+            return self._check_for_pkg_config(
+                'PyCXX', 'CXX/Extensions.hxx', min_version='6.2.4')
+        except CheckFailed as e:
+            # It's ok to just proceed here, since the `import CXX`
+            # worked above, and PyCXX (at least upstream) ensures that
+            # its header files are on the default distutils include
+            # path (either in a standard C place such as /usr/include,
+            # or in /usr/include/pythonX.Y.
+            return 'Using system CXX (version unknown, no pkg-config info)'
+
+    def add_flags(self, ext):
+        if self.found_external and not 'sdist' in sys.argv:
+            support_dir = os.path.normpath(
+                   os.path.join(
+                       sys.prefix,
+                       'share',
+                       'python%d.%d' % (
+                           sys.version_info[0], sys.version_info[1]),
+                       'CXX'))
+            if not os.path.exists(support_dir):
+                # On Fedora 17, these files are installed in /usr/share/CXX
+                support_dir = '/usr/src/CXX'
+            ext.sources.extend([
+                os.path.join(support_dir, x) for x in
+                ['cxxsupport.cxx', 'cxx_extensions.cxx',
+                 'IndirectPythonInterface.cxx',
+                 'cxxextensions.c']])
+            pkg_config.setup_extension(ext, 'PyCXX')
+        else:
+            ext.include_dirs.append('extern')
+            ext.sources.extend(glob.glob('extern/CXX/*.cxx'))
+            ext.sources.extend(glob.glob('extern/CXX/*.c'))
+        ext.define_macros.append(('PYCXX_ISO_CPP_LIB', '1'))
+        if PY3:
+            ext.define_macros.append(('PYCXX_PYTHON_2TO3', '1'))
+        if not (sys.platform == 'win32' and win32_compiler == 'msvc'):
+            ext.libraries.append('stdc++')
+            ext.libraries.append('m')
+
+
+class LibAgg(SetupPackage):
+    name = 'libagg'
+
+    def check(self):
+        self.__class__.found_external = True
+        try:
+            return self._check_for_pkg_config(
+                'libagg', 'agg2/agg_basics.h', min_version='PATCH')
+        except CheckFailed as e:
+            self.__class__.found_external = False
+            return str(e) + ' Using local copy.'
+
+    def add_flags(self, ext):
+        if self.found_external:
+            pkg_config.setup_extension(ext, 'libagg')
+        else:
+            ext.include_dirs.append('extern/agg24/include')
+            agg_sources = [
+                'agg_bezier_arc.cpp',
+                'agg_curves.cpp',
+                'agg_image_filters.cpp',
+                'agg_trans_affine.cpp',
+                'agg_vcgen_contour.cpp',
+                'agg_vcgen_dash.cpp',
+                'agg_vcgen_stroke.cpp',
+                'agg_vpgen_segmentator.cpp'
+                ]
+            ext.sources.extend(
+                os.path.join('extern', 'agg24', 'src', x) for x in agg_sources)
+
+
+class FreeType(SetupPackage):
+    name = "freetype"
+
+    def check(self):
+        if sys.platform == 'win32':
+            check_include_file(get_include_dirs(), 'ft2build.h', 'freetype')
+            return 'Using unknown version found on system.'
+
+        status, output = getstatusoutput("freetype-config --ftversion")
+        if status == 0:
+            version = output
+        else:
+            version = None
+
+        # Early versions of freetype grep badly inside freetype-config,
+        # so catch those cases. (tested with 2.5.3).
+        if version is None or 'No such file or directory\ngrep:' in version:
+            version = self.version_from_header()
+
+        return self._check_for_pkg_config(
+            'freetype2', 'ft2build.h',
+            min_version='2.3', version=version)
+
+    def version_from_header(self):
+        version = 'Failed to identify version.'
+        ext = self.get_extension()
+        if ext is None:
+            return version
+        # Return the first version found in the include dirs.
+        for include_dir in ext.include_dirs:
+            header_fname = os.path.join(include_dir, 'freetype.h')
+            if os.path.exists(header_fname):
+                major, minor, patch = 0, 0, 0
+                with open(header_fname, 'r') as fh:
+                    for line in fh:
+                        if line.startswith('#define FREETYPE_'):
+                            value = line.rsplit(' ', 1)[1].strip()
+                            if 'MAJOR' in line:
+                                major = value
+                            elif 'MINOR' in line:
+                                minor = value
+                            else:
+                                patch = value
+                return '.'.join([major, minor, patch])
+
+    def add_flags(self, ext):
+        pkg_config.setup_extension(
+            ext, 'freetype2',
+            default_include_dirs=[
+                'include/freetype2', 'freetype2',
+                'lib/freetype2/include',
+                'lib/freetype2/include/freetype2'],
+            default_library_dirs=[
+                'freetype2/lib'],
+            default_libraries=['freetype', 'z'])
+
+
+
+class FT2Font(SetupPackage):
+    name = 'ft2font'
+
+    def get_extension(self):
+        sources = [
+            'src/ft2font.cpp',
+            'src/mplutils.cpp'
+            ]
+        ext = make_extension('matplotlib.ft2font', sources)
+        FreeType().add_flags(ext)
+        Numpy().add_flags(ext)
+        CXX().add_flags(ext)
+        return ext
+
+
+class Png(SetupPackage):
+    name = "png"
+
+    def check(self):
+        if sys.platform == 'win32':
+            check_include_file(get_include_dirs(), 'png.h', 'png')
+            return 'Using unknown version found on system.'
+
+        status, output = getstatusoutput("libpng-config --version")
+        if status == 0:
+            version = output
+        else:
+            version = None
+
+        try:
+            return self._check_for_pkg_config(
+                'libpng', 'png.h',
+                min_version='1.2', version=version)
+        except CheckFailed as e:
+            if has_include_file(get_include_dirs(), 'png.h'):
+                return str(e) + ' Using unknown version found on system.'
+            raise
+
+    def get_extension(self):
+        sources = [
+            'src/_png.cpp', 'src/mplutils.cpp'
+            ]
+        ext = make_extension('matplotlib._png', sources)
+        pkg_config.setup_extension(
+            ext, 'libpng', default_libraries=['png', 'z'],
+            alt_exec='libpng-config --ldflags')
+        Numpy().add_flags(ext)
+        CXX().add_flags(ext)
+        return ext
+
+
+class Qhull(SetupPackage):
+    name = "qhull"
+
+    def check(self):
+        self.__class__.found_external = True
+        try:
+            return self._check_for_pkg_config(
+                'qhull', 'qhull/qhull_a.h', min_version='2003.1')
+        except CheckFailed as e:
+            self.__class__.found_pkgconfig = False
+            # Qhull may not be in the pkg-config system but may still be
+            # present on this system, so check if the header files can be
+            # found.
+            include_dirs = [
+                os.path.join(x, 'qhull') for x in get_include_dirs()]
+            if has_include_file(include_dirs, 'qhull_a.h'):
+                return 'Using system Qhull (version unknown, no pkg-config info)'
+            else:
+                self.__class__.found_external = False
+                return str(e) + ' Using local copy.'
+
+    def add_flags(self, ext):
+        if self.found_external:
+            pkg_config.setup_extension(ext, 'qhull',
+                                       default_libraries=['qhull'])
+        else:
+            ext.include_dirs.append('extern')
+            ext.sources.extend(glob.glob('extern/qhull/*.c'))
+
+
+class TTConv(SetupPackage):
+    name = "ttconv"
+
+    def get_extension(self):
+        sources = [
+            'src/_ttconv.cpp',
+            'extern/ttconv/pprdrv_tt.cpp',
+            'extern/ttconv/pprdrv_tt2.cpp',
+            'extern/ttconv/ttutil.cpp'
+            ]
+        ext = make_extension('matplotlib.ttconv', sources)
+        Numpy().add_flags(ext)
+        CXX().add_flags(ext)
+        ext.include_dirs.append('extern')
+        return ext
+
+
+class Path(SetupPackage):
+    name = "path"
+
+    def get_extension(self):
+        sources = [
+            'src/_path.cpp',
+            'src/path_cleanup.cpp',
+            'src/agg_py_transforms.cpp'
+            ]
+
+        ext = make_extension('matplotlib._path', sources)
+        Numpy().add_flags(ext)
+        LibAgg().add_flags(ext)
+        CXX().add_flags(ext)
+        return ext
+
+
+class Image(SetupPackage):
+    name = "image"
+
+    def get_extension(self):
+        sources = [
+            'src/_image.cpp', 'src/mplutils.cpp'
+            ]
+        ext = make_extension('matplotlib._image', sources)
+        Numpy().add_flags(ext)
+        LibAgg().add_flags(ext)
+        CXX().add_flags(ext)
+        return ext
+
+
+class Contour(SetupPackage):
+    name = "contour"
+
+    def get_extension(self):
+        sources = [
+            "src/cntr.c"
+            ]
+        ext = make_extension('matplotlib._cntr', sources)
+        Numpy().add_flags(ext)
+        return ext
+
+
+class Delaunay(SetupPackage):
+    name = "delaunay"
+
+    def get_packages(self):
+        return ['matplotlib.delaunay']
+
+    def get_extension(self):
+        sources = ["_delaunay.cpp", "VoronoiDiagramGenerator.cpp",
+                   "delaunay_utils.cpp", "natneighbors.cpp"]
+        sources = [os.path.join('lib/matplotlib/delaunay', s) for s in sources]
+        ext = make_extension('matplotlib._delaunay', sources)
+        Numpy().add_flags(ext)
+        return ext
+
+
+class QhullWrap(SetupPackage):
+    name = "qhull_wrap"
+
+    def get_extension(self):
+        sources = ['src/qhull_wrap.c']
+        ext = make_extension('matplotlib._qhull', sources,
+                             define_macros=[('MPL_DEVNULL', os.devnull)])
+        Numpy().add_flags(ext)
+        Qhull().add_flags(ext)
+        return ext
+
+
+class Tri(SetupPackage):
+    name = "tri"
+
+    def get_extension(self):
+        sources = [
+            "lib/matplotlib/tri/_tri.cpp",
+            "src/mplutils.cpp"
+            ]
+        ext = make_extension('matplotlib._tri', sources)
+        Numpy().add_flags(ext)
+        CXX().add_flags(ext)
+        return ext
+
+
+class Six(SetupPackage):
+    name = "six"
+    min_version = "1.4"
+
+    def check(self):
+        try:
+            import six
+        except ImportError:
+            raise CheckFailed(
+                "could not be found")
+
+        if not is_min_version(six.__version__, self.min_version):
+            raise CheckFailed(
+                "requires six %s or later; found %s" %
+                (self.min_version, six.__version__))
+
+        return "using six version %s" % six.__version__
+
+    def get_install_requires(self):
+        return ['six>={0}'.format(self.min_version)]
+
+
+class Pytz(SetupPackage):
+    name = "pytz"
+
+    def check(self):
+        try:
+            import pytz
+        except ImportError:
+            raise CheckFailed (
+                "could not be found")
+
+        return "using pytz version %s" % pytz.__version__
+
+    def get_install_requires(self):
+        return ['pytz']
+
+
+class Dateutil(SetupPackage):
+    name = "dateutil"
+
+    def __init__(self, version=None):
+        self.version = version
+
+    def check(self):
+        try:
+            import dateutil
+        except ImportError:
+            # dateutil 2.1 has a file encoding bug that breaks installation on
+            # python 3.3
+            # https://github.com/matplotlib/matplotlib/issues/2373
+            # hack around the problem by installing the (working) v2.0
+            #major, minor1, _, _, _ = sys.version_info
+            #if self.version is None and (major, minor1) == (3, 3):
+                #self.version = '!=2.1'
+
+            raise CheckFailed (
+                "could not be found")
+        major, minor1, _, _, _ = sys.version_info
+        if dateutil.__version__ == '2.1' and (major, minor1) == (3, 3):
+            raise CheckFailed (
+                "dateutil v. 2.1 has a bug that breaks installation"
+                "on python 3.3.x, use another dateutil version")
+        return "using dateutil version %s" % dateutil.__version__
+
+    def get_install_requires(self):
+        dateutil = 'python-dateutil'
+        if self.version is not None:
+            dateutil += self.version
+        return [dateutil]
+
+
+class Tornado(SetupPackage):
+    name = "tornado"
+
+    def check(self):
+        try:
+            import tornado
+        except ImportError:
+            raise CheckFailed (
+                "could not be found")
+
+        return "using tornado version %s" % tornado.version
+
+
+class Pyparsing(SetupPackage):
+    name = "pyparsing"
+
+    def is_ok(self):
+        # pyparsing 2.0.0 bug, but it may be patched in distributions
+        try:
+            import pyparsing
+            f = pyparsing.Forward()
+            f <<= pyparsing.Literal('a')
+            return f is not None
+        except (ImportError, TypeError):
+            return False
+
+    def check(self):
+        try:
+            import pyparsing
+        except ImportError:
+            raise CheckFailed (
+                "could not be found")
+
+        required = [1, 5, 6]
+        if [int(x) for x in pyparsing.__version__.split('.')] < required:
+            raise CheckFailed (
+                "matplotlib requires pyparsing >= {0}; yours is ".format(
+                    '.'.join(str(x) for x in required)) + pyparsing.__version__)
+
+        if not self.is_ok():
+            return (
+                "Your pyparsing contains a bug that will be monkey-patched by "
+                "matplotlib.  For best results, upgrade to pyparsing 2.0.1 or "
+                "later.")
+
+        return "using pyparsing version %s" % pyparsing.__version__
+
+    def get_install_requires(self):
+        if self.is_ok():
+            return ['pyparsing>=1.5.6']
+        else:
+            return ['pyparsing>=1.5.6,!=2.0.0']
+
+
+class BackendAgg(OptionalBackendPackage):
+    name = "agg"
+
+    def get_extension(self):
+        sources = [
+            "src/mplutils.cpp",
+            "src/agg_py_transforms.cpp",
+            "src/_backend_agg.cpp"
+            ]
+        ext = make_extension('matplotlib.backends._backend_agg', sources)
+        Numpy().add_flags(ext)
+        LibAgg().add_flags(ext)
+        FreeType().add_flags(ext)
+        CXX().add_flags(ext)
+        return ext
+
+
+class BackendTkAgg(OptionalBackendPackage):
+    name = "tkagg"
+
+    def __init__(self):
+        self.tcl_tk_cache = None
+
+    def check_requirements(self):
+        try:
+            if PY3:
+                import tkinter as Tkinter
+            else:
+                import Tkinter
+        except ImportError:
+            raise CheckFailed('TKAgg requires Tkinter.')
+        except RuntimeError:
+            raise CheckFailed('Tkinter present but import failed.')
+        else:
+            if Tkinter.TkVersion < 8.3:
+                raise CheckFailed("Tcl/Tk v8.3 or later required.")
+
+        ext = self.get_extension()
+        check_include_file(ext.include_dirs, "tk.h", "Tk")
+
+        try:
+            tk_v = Tkinter.__version__.split()[-2]
+        except (AttributeError, IndexError):
+            # Tkinter.__version__ has been removed in python 3
+            tk_v = 'version not identified'
+
+        BackendAgg.force = True
+
+        return "version %s" % tk_v
+
+    def get_extension(self):
+        sources = [
+            'src/agg_py_transforms.cpp',
+            'src/_tkagg.cpp'
+            ]
+
+        ext = make_extension('matplotlib.backends._tkagg', sources)
+        self.add_flags(ext)
+        Numpy().add_flags(ext)
+        LibAgg().add_flags(ext)
+        CXX().add_flags(ext)
+        return ext
+
+    def query_tcltk(self):
+        """
+        Tries to open a Tk window in order to query the Tk object
+        about its library paths.  This should never be called more
+        than once by the same process, as Tk intricacies may cause the
+        Python interpreter to hang. The function also has a workaround
+        if no X server is running (useful for autobuild systems).
+        """
+        # Use cached values if they exist, which ensures this function
+        # only executes once
+        if self.tcl_tk_cache is not None:
+            return self.tcl_tk_cache
+
+        # By this point, we already know that Tkinter imports correctly
+        if PY3:
+            import tkinter as Tkinter
+        else:
+            import Tkinter
+        tcl_lib_dir = ''
+        tk_lib_dir = ''
+        # First try to open a Tk window (requires a running X server)
+        try:
+            tk = Tkinter.Tk()
+        except Tkinter.TclError:
+            # Next, start Tcl interpreter without opening a Tk window
+            # (no need for X server) This feature is available in
+            # python version 2.4 and up
+            try:
+                tcl = Tkinter.Tcl()
+            except AttributeError:    # Python version not high enough
+                pass
+            except Tkinter.TclError:  # Something went wrong while opening Tcl
+                pass
+            else:
+                tcl_lib_dir = str(tcl.getvar('tcl_library'))
+                # Guess Tk location based on Tcl location
+                (head, tail) = os.path.split(tcl_lib_dir)
+                tail = tail.replace('Tcl', 'Tk').replace('tcl', 'tk')
+                tk_lib_dir = os.path.join(head, tail)
+                if not os.path.exists(tk_lib_dir):
+                    tk_lib_dir = tcl_lib_dir.replace(
+                        'Tcl', 'Tk').replace('tcl', 'tk')
+        else:
+            # Obtain Tcl and Tk locations from Tk widget
+            tk.withdraw()
+            tcl_lib_dir = str(tk.getvar('tcl_library'))
+            tk_lib_dir = str(tk.getvar('tk_library'))
+            tk.destroy()
+
+        # Save directories and version string to cache
+        self.tcl_tk_cache = tcl_lib_dir, tk_lib_dir, str(Tkinter.TkVersion)[:3]
+        return self.tcl_tk_cache
+
+    def parse_tcl_config(self, tcl_lib_dir, tk_lib_dir):
+        try:
+            if PY3:
+                import tkinter as Tkinter
+            else:
+                import Tkinter
+        except ImportError:
+            return None
+
+        tcl_poss = [tcl_lib_dir,
+                    os.path.normpath(os.path.join(tcl_lib_dir, '..')),
+                    "/usr/lib/tcl" + str(Tkinter.TclVersion),
+                    "/usr/lib"]
+        tk_poss = [tk_lib_dir,
+                    os.path.normpath(os.path.join(tk_lib_dir, '..')),
+                   "/usr/lib/tk" + str(Tkinter.TkVersion),
+                   "/usr/lib"]
+        for ptcl, ptk in zip(tcl_poss, tk_poss):
+            tcl_config = os.path.join(ptcl, "tclConfig.sh")
+            tk_config = os.path.join(ptk, "tkConfig.sh")
+            if (os.path.exists(tcl_config) and os.path.exists(tk_config)):
+                break
+        if not (os.path.exists(tcl_config) and os.path.exists(tk_config)):
+            return None
+
+        def get_var(file, varname):
+            p = subprocess.Popen(
+                '. %s ; eval echo ${%s}' % (file, varname),
+                shell=True,
+                executable="/bin/sh",
+                stdout=subprocess.PIPE)
+            result = p.communicate()[0]
+            return result.decode('ascii')
+
+        tcl_lib_dir = get_var(
+            tcl_config, 'TCL_LIB_SPEC').split()[0][2:].strip()
+        tcl_inc_dir = get_var(
+            tcl_config, 'TCL_INCLUDE_SPEC')[2:].strip()
+        tcl_lib = get_var(tcl_config, 'TCL_LIB_FLAG')[2:].strip()
+
+        tk_lib_dir = get_var(tk_config, 'TK_LIB_SPEC').split()[0][2:].strip()
+        tk_inc_dir = get_var(tk_config, 'TK_INCLUDE_SPEC').strip()
+        if tk_inc_dir == '':
+            tk_inc_dir = tcl_inc_dir
+        else:
+            tk_inc_dir = tk_inc_dir[2:]
+        tk_lib = get_var(tk_config, 'TK_LIB_FLAG')[2:].strip()
+
+        if not os.path.exists(os.path.join(tk_inc_dir, 'tk.h')):
+            return None
+
+        return (tcl_lib_dir, tcl_inc_dir, tcl_lib,
+                tk_lib_dir, tk_inc_dir, tk_lib)
+
+    def guess_tcl_config(self, tcl_lib_dir, tk_lib_dir, tk_ver):
+        if not (os.path.exists(tcl_lib_dir) and os.path.exists(tk_lib_dir)):
+            return None
+
+        tcl_lib = os.path.normpath(os.path.join(tcl_lib_dir, '../'))
+        tk_lib = os.path.normpath(os.path.join(tk_lib_dir, '../'))
+
+        tcl_inc = os.path.normpath(
+            os.path.join(tcl_lib_dir,
+                         '../../include/tcl' + tk_ver))
+        if not os.path.exists(tcl_inc):
+            tcl_inc = os.path.normpath(
+                os.path.join(tcl_lib_dir,
+                             '../../include'))
+
+        tk_inc = os.path.normpath(os.path.join(
+            tk_lib_dir,
+            '../../include/tk' + tk_ver))
+        if not os.path.exists(tk_inc):
+            tk_inc = os.path.normpath(os.path.join(
+                tk_lib_dir,
+                '../../include'))
+
+        if not os.path.exists(os.path.join(tk_inc, 'tk.h')):
+            tk_inc = tcl_inc
+
+        if not os.path.exists(tcl_inc):
+            # this is a hack for suse linux, which is broken
+            if (sys.platform.startswith('linux') and
+                os.path.exists('/usr/include/tcl.h') and
+                os.path.exists('/usr/include/tk.h')):
+                tcl_inc = '/usr/include'
+                tk_inc = '/usr/include'
+
+        if not os.path.exists(os.path.join(tk_inc, 'tk.h')):
+            return None
+
+        return tcl_lib, tcl_inc, 'tcl' + tk_ver, tk_lib, tk_inc, 'tk' + tk_ver
+
+    def hardcoded_tcl_config(self):
+        tcl_inc = "/usr/local/include"
+        tk_inc = "/usr/local/include"
+        tcl_lib = "/usr/local/lib"
+        tk_lib = "/usr/local/lib"
+        return tcl_lib, tcl_inc, 'tcl', tk_lib, tk_inc, 'tk'
+
+    def add_flags(self, ext):
+        if sys.platform == 'win32':
+            major, minor1, minor2, s, tmp = sys.version_info
+            if sys.version_info[0:2] < (3, 4):
+                ext.include_dirs.extend(['win32_static/include/tcl85'])
+                ext.libraries.extend(['tk85', 'tcl85'])
+            else:
+                ext.include_dirs.extend(['win32_static/include/tcl86'])
+                ext.libraries.extend(['tk86t', 'tcl86t'])
+            ext.library_dirs.extend([os.path.join(sys.prefix, 'dlls')])
+
+        elif sys.platform == 'darwin':
+            # this config section lifted directly from Imaging - thanks to
+            # the effbot!
+
+            # First test for a MacOSX/darwin framework install
+            from os.path import join, exists
+            framework_dirs = [
+                join(os.getenv('HOME'), '/Library/Frameworks'),
+                '/Library/Frameworks',
+                '/System/Library/Frameworks/',
+            ]
+
+            # Find the directory that contains the Tcl.framework and
+            # Tk.framework bundles.
+            tk_framework_found = 0
+            for F in framework_dirs:
+                # both Tcl.framework and Tk.framework should be present
+                for fw in 'Tcl', 'Tk':
+                    if not exists(join(F, fw + '.framework')):
+                        break
+                else:
+                    # ok, F is now directory with both frameworks. Continure
+                    # building
+                    tk_framework_found = 1
+                    break
+            if tk_framework_found:
+                # For 8.4a2, we must add -I options that point inside
+                # the Tcl and Tk frameworks. In later release we
+                # should hopefully be able to pass the -F option to
+                # gcc, which specifies a framework lookup path.
+
+                tk_include_dirs = [
+                    join(F, fw + '.framework', H)
+                    for fw in ('Tcl', 'Tk')
+                    for H in ('Headers', 'Versions/Current/PrivateHeaders')
+                ]
+
+                # For 8.4a2, the X11 headers are not included. Rather
+                # than include a complicated search, this is a
+                # hard-coded path. It could bail out if X11 libs are
+                # not found...
+
+                # tk_include_dirs.append('/usr/X11R6/include')
+                frameworks = ['-framework', 'Tcl', '-framework', 'Tk']
+                ext.include_dirs.extend(tk_include_dirs)
+                ext.extra_link_args.extend(frameworks)
+                ext.extra_compile_args.extend(frameworks)
+
+        # you're still here? ok we'll try it this way...
+        else:
+            # There are 3 methods to try, in decreasing order of "smartness"
+            #
+            #   1. Parse the tclConfig.sh and tkConfig.sh files that have
+            #      all the information we need
+            #
+            #   2. Guess the include and lib dirs based on the location of
+            #      Tkinter's 'tcl_library' and 'tk_library' variables.
+            #
+            #   3. Use some hardcoded locations that seem to work on a lot
+            #      of distros.
+
+            # Query Tcl/Tk system for library paths and version string
+            try:
+                tcl_lib_dir, tk_lib_dir, tk_ver = self.query_tcltk()
+            except:
+                tk_ver = ''
+                result = self.hardcoded_tcl_config()
+            else:
+                result = self.parse_tcl_config(tcl_lib_dir, tk_lib_dir)
+                if result is None:
+                    result = self.guess_tcl_config(
+                        tcl_lib_dir, tk_lib_dir, tk_ver)
+                    if result is None:
+                        result = self.hardcoded_tcl_config()
+
+            # Add final versions of directories and libraries to ext lists
+            (tcl_lib_dir, tcl_inc_dir, tcl_lib,
+             tk_lib_dir, tk_inc_dir, tk_lib) = result
+            ext.include_dirs.extend([tcl_inc_dir, tk_inc_dir])
+            ext.library_dirs.extend([tcl_lib_dir, tk_lib_dir])
+            ext.libraries.extend([tcl_lib, tk_lib])
+
+
+class BackendGtk(OptionalBackendPackage):
+    name = "gtk"
+
+    def check_requirements(self):
+        try:
+            import gtk
+        except ImportError:
+            raise CheckFailed("Requires pygtk")
+        except RuntimeError:
+            raise CheckFailed('pygtk present, but import failed.')
+        else:
+            version = (2, 2, 0)
+            if gtk.pygtk_version < version:
+                raise CheckFailed(
+                    "Requires pygtk %d.%d.%d or later. "
+                    "Found %d.%d.%d" % (version + gtk.pygtk_version))
+
+        ext = self.get_extension()
+        self.add_flags(ext)
+        check_include_file(ext.include_dirs,
+                           os.path.join("gtk", "gtk.h"),
+                           'gtk')
+        check_include_file(ext.include_dirs,
+                           os.path.join("pygtk", "pygtk.h"),
+                           'pygtk')
+
+        return 'Gtk: %s pygtk: %s' % (
+            ".".join(str(x) for x in gtk.gtk_version),
+            ".".join(str(x) for x in gtk.pygtk_version))
+
+    def get_package_data(self):
+        return {'matplotlib': ['mpl-data/*.glade']}
+
+    def get_extension(self):
+        sources = [
+            'src/_backend_gdk.c'
+            ]
+        ext = make_extension('matplotlib.backends._backend_gdk', sources)
+        self.add_flags(ext)
+        Numpy().add_flags(ext)
+        return ext
+
+    def add_flags(self, ext):
+        if sys.platform == 'win32':
+            def getoutput(s):
+                ret = os.popen(s).read().strip()
+                return ret
+
+            if 'PKG_CONFIG_PATH' not in os.environ:
+                # If Gtk+ is installed, pkg-config is required to be installed
+                os.environ['PKG_CONFIG_PATH'] = 'C:\\GTK\\lib\\pkgconfig'
+
+                # popen broken on my win32 plaform so I can't use pkgconfig
+                ext.library_dirs.extend(
+                    ['C:/GTK/bin', 'C:/GTK/lib'])
+
+                ext.include_dirs.extend(
+                    ['win32_static/include/pygtk-2.0',
+                     'C:/GTK/include',
+                     'C:/GTK/include/gobject',
+                     'C:/GTK/include/gext',
+                     'C:/GTK/include/glib',
+                     'C:/GTK/include/pango',
+                     'C:/GTK/include/atk',
+                     'C:/GTK/include/X11',
+                     'C:/GTK/include/cairo',
+                     'C:/GTK/include/gdk',
+                     'C:/GTK/include/gdk-pixbuf',
+                     'C:/GTK/include/gtk',
+                     ])
+
+            pygtkIncludes = getoutput(
+                'pkg-config --cflags-only-I pygtk-2.0').split()
+            gtkIncludes = getoutput(
+                'pkg-config --cflags-only-I gtk+-2.0').split()
+            includes = pygtkIncludes + gtkIncludes
+            ext.include_dirs.extend([include[2:] for include in includes])
+
+            pygtkLinker = getoutput('pkg-config --libs pygtk-2.0').split()
+            gtkLinker = getoutput('pkg-config --libs gtk+-2.0').split()
+            linkerFlags = pygtkLinker + gtkLinker
+
+            ext.libraries.extend(
+                [flag[2:] for flag in linkerFlags if flag.startswith('-l')])
+
+            ext.library_dirs.extend(
+                [flag[2:] for flag in linkerFlags if flag.startswith('-L')])
+
+            ext.extra_link_args.extend(
+                [flag for flag in linkerFlags if not
+                 (flag.startswith('-l') or flag.startswith('-L'))])
+
+            # visual studio doesn't need the math library
+            if (sys.platform == 'win32' and
+                win32_compiler == 'msvc' and
+                'm' in ext.libraries):
+                ext.libraries.remove('m')
+
+        elif sys.platform != 'win32':
+            pkg_config.setup_extension(ext, 'pygtk-2.0')
+            pkg_config.setup_extension(ext, 'gtk+-2.0')
+
+
+class BackendGtkAgg(BackendGtk):
+    name = "gtkagg"
+
+    def check(self):
+        try:
+            return super(BackendGtkAgg, self).check()
+        except:
+            raise
+        else:
+            BackendAgg.force = True
+
+    def get_package_data(self):
+        return {'matplotlib': ['mpl-data/*.glade']}
+
+    def get_extension(self):
+        sources = [
+            'src/agg_py_transforms.cpp',
+            'src/_gtkagg.cpp',
+            'src/mplutils.cpp'
+            ]
+        ext = make_extension('matplotlib.backends._gtkagg', sources)
+        self.add_flags(ext)
+        LibAgg().add_flags(ext)
+        CXX().add_flags(ext)
+        Numpy().add_flags(ext)
+        return ext
+
+
+def backend_gtk3agg_internal_check(x):
+    try:
+        import gi
+    except ImportError:
+        return (False, "Requires pygobject to be installed.")
+
+    try:
+        gi.require_version("Gtk", "3.0")
+    except ValueError:
+        return (False, "Requires gtk3 development files to be installed.")
+    except AttributeError:
+        return (False, "pygobject version too old.")
+
+    try:
+        from gi.repository import Gtk, Gdk, GObject
+    except (ImportError, RuntimeError):
+        return (False, "Requires pygobject to be installed.")
+
+    return (True, "version %s.%s.%s" % (
+        Gtk.get_major_version(),
+        Gtk.get_micro_version(),
+        Gtk.get_minor_version()))
+
+
+class BackendGtk3Agg(OptionalBackendPackage):
+    name = "gtk3agg"
+
+    def check_requirements(self):
+        if 'TRAVIS' in os.environ:
+            raise CheckFailed("Can't build with Travis")
+
+        # This check needs to be performed out-of-process, because
+        # importing gi and then importing regular old pygtk afterward
+        # segfaults the interpreter.
+        try:
+            p = multiprocessing.Pool()
+        except:
+            return "unknown (can not use multiprocessing to determine)"
+        try:
+            success, msg = p.map(backend_gtk3agg_internal_check, [0])[0]
+        except:
+            success = False
+            msg = "Could not determine"
+        finally:
+            p.close()
+            p.join()
+        if success:
+            BackendAgg.force = True
+
+            return msg
+        else:
+            raise CheckFailed(msg)
+
+    def get_package_data(self):
+        return {'matplotlib': ['mpl-data/*.glade']}
+
+
+def backend_gtk3cairo_internal_check(x):
+    try:
+        import cairocffi
+    except ImportError:
+        try:
+            import cairo
+        except ImportError:
+            return (False, "Requires cairocffi or pycairo to be installed.")
+
+    try:
+        import gi
+    except ImportError:
+        return (False, "Requires pygobject to be installed.")
+
+    try:
+        gi.require_version("Gtk", "3.0")
+    except ValueError:
+        return (False, "Requires gtk3 development files to be installed.")
+    except AttributeError:
+        return (False, "pygobject version too old.")
+
+    try:
+        from gi.repository import Gtk, Gdk, GObject
+    except (RuntimeError, ImportError):
+        return (False, "Requires pygobject to be installed.")
+
+    return (True, "version %s.%s.%s" % (
+        Gtk.get_major_version(),
+        Gtk.get_micro_version(),
+        Gtk.get_minor_version()))
+
+
+class BackendGtk3Cairo(OptionalBackendPackage):
+    name = "gtk3cairo"
+
+    def check_requirements(self):
+        if 'TRAVIS' in os.environ:
+            raise CheckFailed("Can't build with Travis")
+
+        # This check needs to be performed out-of-process, because
+        # importing gi and then importing regular old pygtk afterward
+        # segfaults the interpreter.
+        try:
+            p = multiprocessing.Pool()
+        except:
+            return "unknown (can not use multiprocessing to determine)"
+        success, msg = p.map(backend_gtk3cairo_internal_check, [0])[0]
+        p.close()
+        p.join()
+        if success:
+            BackendAgg.force = True
+
+            return msg
+        else:
+            raise CheckFailed(msg)
+
+    def get_package_data(self):
+        return {'matplotlib': ['mpl-data/*.glade']}
+
+
+class BackendWxAgg(OptionalBackendPackage):
+    name = "wxagg"
+
+    def check_requirements(self):
+        try:
+            import wxversion
+        except ImportError:
+            raise CheckFailed("requires wxPython")
+
+        try:
+            _wx_ensure_failed = wxversion.AlreadyImportedError
+        except AttributeError:
+            _wx_ensure_failed = wxversion.VersionError
+
+        try:
+            wxversion.ensureMinimal('2.8')
+        except _wx_ensure_failed:
+            pass
+
+        try:
+            import wx
+            backend_version = wx.VERSION_STRING
+        except ImportError:
+            raise CheckFailed("requires wxPython")
+
+        # Extra version check in case wxversion lacks AlreadyImportedError;
+        # then VersionError might have been raised and ignored when
+        # there really *is* a problem with the version.
+        major, minor = [int(n) for n in backend_version.split('.')[:2]]
+        if major < 2 or (major < 3 and minor < 8):
+            raise CheckFailed(
+                "Requires wxPython 2.8, found %s" % backend_version)
+
+        BackendAgg.force = True
+
+        return "version %s" % backend_version
+
+
+class BackendMacOSX(OptionalBackendPackage):
+    name = 'macosx'
+
+    def check_requirements(self):
+        if sys.platform != 'darwin':
+            raise CheckFailed("Mac OS-X only")
+
+        return 'darwin'
+
+    def get_extension(self):
+        sources = [
+            'src/_macosx.m',
+            'src/agg_py_transforms.cpp',
+            'src/path_cleanup.cpp'
+            ]
+
+        ext = make_extension('matplotlib.backends._macosx', sources)
+        Numpy().add_flags(ext)
+        LibAgg().add_flags(ext)
+        CXX().add_flags(ext)
+        ext.extra_link_args.extend(['-framework', 'Cocoa'])
+        return ext
+
+
+class Windowing(OptionalBackendPackage):
+    """
+    Builds the windowing extension.
+    """
+    name = "windowing"
+
+    def check_requirements(self):
+        if sys.platform != 'win32':
+            raise CheckFailed("Microsoft Windows only")
+        config = self.get_config()
+        if config is False:
+            raise CheckFailed("skipping due to configuration")
+        return "installing"
+
+    def get_extension(self):
+        sources = [
+            "src/_windowing.cpp"
+            ]
+        ext = make_extension('matplotlib._windowing', sources)
+        ext.include_dirs.extend(['C:/include'])
+        ext.libraries.extend(['user32'])
+        ext.library_dirs.extend(['C:/lib'])
+        ext.extra_link_args.append("-mwindows")
+        return ext
+
+
+class BackendQtBase(OptionalBackendPackage):
+
+    def convert_qt_version(self, version):
+        version = '%x' % version
+        temp = []
+        while len(version) > 0:
+            version, chunk = version[:-2], version[-2:]
+            temp.insert(0, str(int(chunk, 16)))
+        return '.'.join(temp)
+
+    def check_requirements(self):
+        '''
+        If PyQt4/PyQt5 is already imported, importing PyQt5/PyQt4 will fail
+        so we need to test in a subprocess (as for Gtk3).
+        '''
+        try:
+            p = multiprocessing.Pool()
+
+        except:
+            # Can't do multiprocessing, fall back to normal approach ( this will fail if importing both PyQt4 and PyQt5 )
+            try:
+                # Try in-process
+                msg = self.callback(self)
+
+            except RuntimeError:
+                raise CheckFailed("Could not import: are PyQt4 & PyQt5 both installed?")
+
+            except:
+                # Raise any other exceptions
+                raise
+
+        else:
+            # Multiprocessing OK
+            try:
+                msg = p.map(self.callback, [self])[0]
+            except:
+                # If we hit an error on multiprocessing raise it
+                raise
+            finally:
+                # Tidy up multiprocessing
+                p.close()
+                p.join()
+
+        return msg
+
+
+def backend_qt4_internal_check(self):
+    try:
+        from PyQt4 import QtCore
+    except ImportError:
+        raise CheckFailed("PyQt4 not found")
+
+    try:
+        qt_version = QtCore.QT_VERSION
+        pyqt_version_str = QtCore.QT_VERSION_STR
+    except AttributeError:
+        raise CheckFailed('PyQt4 not correctly imported')
+    else:
+        BackendAgg.force = True
+        return ("Qt: %s, PyQt: %s" % (self.convert_qt_version(qt_version), pyqt_version_str))
+
+
+class BackendQt4(BackendQtBase):
+    name = "qt4agg"
+
+    def __init__(self, *args, **kwargs):
+        BackendQtBase.__init__(self, *args, **kwargs)
+        self.callback = backend_qt4_internal_check
+
+
+def backend_qt5_internal_check(self):
+    try:
+        from PyQt5 import QtCore
+    except ImportError:
+        raise CheckFailed("PyQt5 not found")
+
+    try:
+        qt_version = QtCore.QT_VERSION
+        pyqt_version_str = QtCore.QT_VERSION_STR
+    except AttributeError:
+        raise CheckFailed('PyQt5 not correctly imported')
+    else:
+        BackendAgg.force = True
+        return ("Qt: %s, PyQt: %s" % (self.convert_qt_version(qt_version), pyqt_version_str))
+
+
+class BackendQt5(BackendQtBase):
+    name = "qt5agg"
+
+    def __init__(self, *args, **kwargs):
+        BackendQtBase.__init__(self, *args, **kwargs)
+        self.callback = backend_qt5_internal_check
+
+
+def backend_pyside_internal_check(self):
+    try:
+        from PySide import __version__
+        from PySide import QtCore
+    except ImportError:
+        raise CheckFailed("PySide not found")
+    else:
+        BackendAgg.force = True
+        return ("Qt: %s, PySide: %s" %
+                (QtCore.__version__, __version__))
+
+
+class BackendPySide(BackendQtBase):
+    name = "pyside"
+
+    def __init__(self, *args, **kwargs):
+        BackendQtBase.__init__(self, *args, **kwargs)
+        self.callback = backend_pyside_internal_check
+
+
+
+class BackendCairo(OptionalBackendPackage):
+    name = "cairo"
+
+    def check_requirements(self):
+        try:
+            import cairocffi
+        except ImportError:
+            try:
+                import cairo
+            except ImportError:
+                raise CheckFailed("cairocffi or pycairo not found")
+            else:
+                return "pycairo version %s" % cairo.version
+        else:
+            return "cairocffi version %s" % cairocffi.version
+
+
+class DviPng(SetupPackage):
+    name = "dvipng"
+    optional = True
+
+    def check(self):
+        try:
+            output = check_output('dvipng -version', shell=True,
+                                  stderr=subprocess.STDOUT)
+            return "version %s" % output.splitlines()[1].decode().split()[-1]
+        except (IndexError, ValueError, subprocess.CalledProcessError):
+            raise CheckFailed()
+
+
+class Ghostscript(SetupPackage):
+    name = "ghostscript"
+    optional = True
+
+    def check(self):
+        try:
+            if sys.platform == 'win32':
+                command = 'gswin32c --version'
+                try:
+                    output = check_output(command, shell=True,
+                                          stderr=subprocess.STDOUT)
+                except subprocess.CalledProcessError:
+                    command = 'gswin64c --version'
+                    output = check_output(command, shell=True,
+                                          stderr=subprocess.STDOUT)
+            else:
+                command = 'gs --version'
+                output = check_output(command, shell=True,
+                                      stderr=subprocess.STDOUT)
+            return "version %s" % output.decode()[:-1]
+        except (IndexError, ValueError, subprocess.CalledProcessError):
+            raise CheckFailed()
+
+
+class LaTeX(SetupPackage):
+    name = "latex"
+    optional = True
+
+    def check(self):
+        try:
+            output = check_output('latex -version', shell=True,
+                                  stderr=subprocess.STDOUT)
+            line = output.splitlines()[0].decode()
+            pattern = '(3\.1\d+)|(MiKTeX \d+.\d+)'
+            match = re.search(pattern, line)
+            return "version %s" % match.group(0)
+        except (IndexError, ValueError, AttributeError, subprocess.CalledProcessError):
+            raise CheckFailed()
+
+
+class PdfToPs(SetupPackage):
+    name = "pdftops"
+    optional = True
+
+    def check(self):
+        try:
+            output = check_output('pdftops -v', shell=True,
+                                  stderr=subprocess.STDOUT)
+            for line in output.splitlines():
+                line = line.decode()
+                if 'version' in line:
+                    return "version %s" % line.split()[2]
+        except (IndexError, ValueError, subprocess.CalledProcessError):
+            pass
+
+        raise CheckFailed()