diff --git a/x11-libs/libXfont/libXfont-1.4.4.ebuild b/x11-libs/libXfont/libXfont-1.4.4.ebuild
new file mode 100644
index 0000000..06437fa
--- /dev/null
+++ b/x11-libs/libXfont/libXfont-1.4.4.ebuild
@@ -0,0 +1,33 @@
+# Copyright 1999-2011 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+# $Header: /var/cvsroot/gentoo-x86/x11-libs/libXfont/libXfont-1.4.4.ebuild,v 1.7 2011/08/15 15:24:56 armin76 Exp $
+
+EAPI=4
+
+XORG_DOC=doc
+inherit xorg-2
+
+DESCRIPTION="X.Org Xfont library"
+
+KEYWORDS="alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x64-freebsd ~x86-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris"
+IUSE="ipv6"
+
+RDEPEND="x11-libs/xtrans
+	x11-libs/libfontenc
+	>=media-libs/freetype-2
+	app-arch/bzip2
+	x11-proto/xproto
+	x11-proto/fontsproto"
+DEPEND="${RDEPEND}"
+
+pkg_setup() {
+	xorg-2_pkg_setup
+	XORG_CONFIGURE_OPTIONS=(
+		$(use_enable ipv6)
+		$(use_enable doc devel-docs)
+		$(use_with doc xmlto)
+		--with-bzip2
+		--without-fop
+		--with-encodingsdir="${EPREFIX}/usr/share/fonts/encodings"
+	)
+}
