This is mechapoint, my simple presentation player written in C++.
Mechapoint uses an XML file format, and displays it's graphics using Evas,
the very funky, optionally OpenGL-accelerated canvas library from the
Enlightenment project.

At the moment it's quite basic, but still capable of handling simple
presentations. There's quite a bit of layout code implemented, so you can
build quite complex pages, but there's no animation or action system in
place yet - for the time being, it's basically a slide-show of static slides.
There's no way (yet) to make pages appear progressively or perform effects.
However, the power of Evas leaves the door wide open for some very powerful
effects :)

Building:

If you want to build mechapoint, you'll need the following libraries:

 * Evas (www.enlightenment.org) - 0.5.0 works for me
 * Ecore (www.enlightenment.org) - 0.0.2 works for me with the included patch
 * libxml2 (www.xmlsoft.org) - 2.4.13 works for me
 * libxslt (www.xmlsoft.org) - 1.0.6 works for me

Once you've got everything installed, a simple "make" should do the trick.

Running:

Run mechapoint like this:
./mechapoint [file]

If you leave the file out, it'll load the default file, "test.xml"

In order to run the demo files, you'll need some MS fonts, namely Arial,
Webdings and Times New Roman. These should go into either the mechapoint
directory, or into the system TrueType font dir, which defaults to
/usr/share/fonts/truetype. If you're on a debian system, simply apt-get
install msttcorefonts and you should be set. If you don't have these fonts,
feel free to edit the demo files :)

Mechapoint also has a few command line switches: -f turns on fullscreen mode,
and -s lets you specify an XSL stylesheet, which will be run over the XML file
you specify before it's presented. Also, you can change the Evas rendering
backend - by default, mechapoint uses software rendering, but you can switch
to basic X acceleration (fast but ugly) with -x, or full OpenGL acceleration
(very fast and pretty on supported hardware) with -g.

Fun with XML:

Using an XML-based file format leads to all sorts of fun and games. For
instance, you can save a lot of work on big presentations by creating
templates for your pages using whatever text templating system you like (eg:
Jakarta Velocity, from http://jakarta.apache.org/velocity/).

In fact, there's a defined standard for transforming XML, called XSL
transforms (or XSLT), which can also be used for tempmlating. Using an XSLT
processor (like xsltproc from the libxslt package) you can write XSL
stylesheets that generate fully formatted mechapoint XML output from simple
input XML files. For an example of this, look at the basic.xsl and foo.xml
files. To generate a formatted mechapoint XML file from foo.xml, try this:

xsltproc basic.xsl foo.xml >formatted-foo.xml

Then load formatted-foo.xml into mechapoint like this:
./mechapoint formatted-foo.xml

In fact, as of 0.0.2, mechapoint has built-in XSL processing. You can skip the
processing step above and simply run mechapoint like this:
./mechapoint -s basic.xsl foo.xml

It's my hope that in the future, people will rarely deal with raw mechapoint
XML files, and will instead use higher level syntaxes based on templates
like this. Then again, the mechapoint XML format is likely to slowly become
nicer to work with, so maybe all this templating won't be necessary :)

FAQ:

Q: Why a presentation program? What's wrong with mgp?
A: Because I wanted to write one :)
Seriously, I was at linux.conf.au and noticed all the different apps that
people used to give presentations. A couple were done in StarOffice, and some
in PowerPoint even, but there were quite a few in mgp. I noticed, however, that
mgp was far from perfect. Upon getting home and playing with it some more, my
suspicions were confirmed. It's old, clunky, and lacks finesse and shinyness.
After watching Raster present a talk about Evas, I thought it'd be a perfect
base to implement all manner of graphical trickery on, and so I began on the
flight home.

Q: Why Evas?
A: It's funky :) It does lots of things for me, looks pretty, and gives me
a lot of scope for writing effects in the future.

Q: Why XML?
A: XML is a godsend for coders the world over. No one in their right mind
wants to write Yet Another Text Parser in C/C++, so being able to use an XML
parser makes reading structured files nice and easy. Also, XML lends itself
to all manner of processing trickery (see above).

Q: Why C++?
A: Why not? I used to be a C coder, and saw C++ as this strange alternate
universe, beyond my grasp and comprehension. Once I had to start coding in
C++ for a uni project, I loved it - having decent OO syntax is nice, but
the real advantages are things like the high-level string class and STL,
which gives you a bunch of standardised container classes (vectors, lists,
hashtables etc.). 

License:

Mechapoint is distributed under the GNU Lesser General Public License (LGPL),
the terms of which can be found in the "COPYING" file. Basically, you can do
whatever you like to my code, including compiling it into an application that
uses a different license (including commercial/proprietary applications), as
long as any modifications/improvements you make to the mechapoint code itself
gets fed back into the community.

Contacting me:

If you feel like contacting me for any reason - a suggestion, bug report,
patch (woo :) ) or just to tell me that i've gone quite mad, drop me an email
at:

lsd@linuxgamers.net

Have fun :)
- lsd