DEFINED_PHASES=compile install postinst postrm unpack
DEPEND=lyx? ( app-office/lyx ) dev-texlive/texlive-latex virtual/latex-base >=sys-apps/texinfo-4.2-r5
DESCRIPTION=LaTeX class for creating presentations using a video projector.
HOMEPAGE=http://latex-beamer.sourceforge.net/
IUSE=doc examples lyx
KEYWORDS=alpha amd64 arm hppa ia64 ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
LICENSE=GPL-2 FDL-1.2 LPPL-1.3c
RDEPEND=>=dev-tex/pgf-1.10 virtual/latex-base
SLOT=0
SRC_URI=mirror://sourceforge/latex-beamer/latex-beamer-3.07.tar.gz
_eclasses_=base	cb7706cadb02c9e611a70f2c38bdb394	eutils	c89e7605f1414fa0f33eae391db1b5d3	latex-package	b72cedae879ef8e8af6524f196fcf449	multilib	d9b509f8ec69d5fd4789bd320d50e6d0	portability	0be430f759a631e692678ed796e09f5c	toolchain-funcs	39ac4a2f99e342286758b5e753f4fb8b
_md5_=f984fd6313c71af33a0aea3ad9eb77fc
