config BR2_PACKAGE_LIBFM
	bool "libfm"
	depends on BR2_PACKAGE_XORG7
	depends on BR2_USE_WCHAR # libglib2
	depends on BR2_TOOLCHAIN_HAS_THREADS # libglib2
	depends on BR2_USE_MMU # libglib2
	depends on BR2_INSTALL_LIBSTDCPP # libgtk2
	depends on BR2_TOOLCHAIN_HAS_SYNC_4 # libgtk2 -> pango -> harfbuzz
	depends on BR2_TOOLCHAIN_GCC_AT_LEAST_4_8 # libgtk2 -> pango -> harfbuzz
	select BR2_PACKAGE_CAIRO
	select BR2_PACKAGE_LIBGLIB2
	select BR2_PACKAGE_LIBGTK2 if !BR2_PACKAGE_LIBGTK3_X11
	select BR2_PACKAGE_MENU_CACHE
	help
	  A glib/gio-based library providing some file management
	  utilities and related-widgets missing in gtk+/glib. This is
	  the core of PCManFM.  The library is desktop independent
	  (not LXDE specific) and has clean API. It can be used to
	  develop other applications requiring file management
	  functionality. For example, you can create your own file
	  manager with facilities provided by libfm.

	  http://wiki.lxde.org/en/Libfm

comment "libfm needs X.org and a toolchain w/ wchar, threads, C++, gcc >= 4.8"
	depends on BR2_USE_MMU
	depends on BR2_TOOLCHAIN_HAS_SYNC_4
	depends on !BR2_USE_WCHAR || !BR2_INSTALL_LIBSTDCPP || \
		!BR2_TOOLCHAIN_GCC_AT_LEAST_4_8 || \
		!BR2_TOOLCHAIN_HAS_THREADS || !BR2_PACKAGE_XORG7
