Allow render requests to abort if page not visible

If the distance between the page center and the viewport center is greater than
a certain multiple of the page height, the render request will abort to save
time and memory.

Currently, this does not work in single page mode.
Merge TODO into the README
Make `make clean` less dangerous

Make clean used to mercilessly nuke anything that isn't under version control.
This is dangerous.
PageUp/PageDown now scroll by a viewport height

Previously they went to the previous/next page. This does mean that scrolling
single page mode is completely broken untill implemented properly.
Implement switch between pan and magnifying glass
Draw frame around magnifying glass (requested by Reinhard Kotucha)
Add a drop shadow to the magnifier

Modelled after http://labs.qt.nokia.com/2009/10/07/magnifying-glass
Outsource handling of non-viewer-related links

The viewer cannot make decisions about non-viewer related data, e.g., loading other files, opening URLs, or executing commands. Therefore, these are distributed via signals to the world outside the viewer class.
Generalize view zooming with a zoomBy function

Added the `zoomBy` slot to `PDFDocumentView` which takes a `qreal` argument
representing a zoom factor and applies it to the view.
Implement fit to window and fit to width zooming
Merge pull request #9 from stloeffler/multipage-viewer

Border for magnifier + outsource link handling
Fix masking of magnifier on OS X

Subclasses of QAbstractScrollArea don't mask properly on OS X:

  https://bugreports.qt.nokia.com/browse/QTBUG-7150

The fix is to explicitly set a mask on the `viewport`.
Implement marquee zoom

Couldn't use `QGraphicsView::RubberBandDrag` as there is no way to use the
built-in rubber band selection and keep graphics items from receiving mouse
events (thus triggering links instead of starting a drag).
Prepare for tiling experiments

Simplify some of the display and painting code before experimenting:

  - Magnifier is removed as a possible mouse mode.

  - Page mode is locked to single page.

  - The paint method of page graphics items now makes serialized synchronous
    calls to the renderer. This simplifies things greatly---multi-threaded calls
    will come later.

  - Scene rect massively expanded so that objects outside of the scene can be
    seen.
Implement first cut at a tile map

The tile map is a matrix of QRect objects that is calculated for each zoom
level such that each tile is 1024 pixels square (a pixmap of ~4MB assuming 4
bytes of data per pixel).

Currently no tiles are rendered, their outlines are merely painted over the
document scene.

Lesson learned:

It is not necessary to reset the Painter transform to the identity matrix
before painting page objects---just set the scale components back to 1. This
preserves the translation elements which removes the need to do all
transformations up front, such as casting pixmap origins.
Crop tiles to page boundary

The tile map is now a QVector instead of a QList so that tiles may be added in
a non-linear order.
First cut at tiled rendering

`PDFPageGraphicsItem` now sets the `QGraphicsItem::ItemUsesExtendedStyleOption`
flag. This makes `exposedRect` available during painting operations which
allows us to render and paint only those tiles that are visible. Qt 4.6.0 or
newer is required in order to use this option.

Scrolling and zooming is very choppy as __nothing is cached__ and tiles are
re-rendered during every paint operation. However:

  - The memory use problem has been obliterated. The viewer used to lock up
    gigabytes of RAM at high zoom levels---now it doesn't even register in my
    top 10 memory intensive processes.

  - Rendering for a handful of tiles is much faster than rendering a full page.

TODO:

  - Offload tile rendering to the worker thread. Could probably offload tile
    map management as well. Basic idea of how this could work:

      * Page graphics item sends the exposed rect and desired DPI to the
        rendering thread (or possibly some other object).

      * Object looks the rect up in the tile cache and submits rendering
        requests for each missing tile.

      * Object returns a list of tiles that are the "closest match" for the
        request---or an empty list if no tiles have been created.

      * Page graphics item paints each tile in the list or a white background
        if the list was empty.

  - Implement a tile cache. 1024x1024 makes for tiles that are ~4MB in size
    assuming 4 bytes per pixel. Could use the document-wide `QPixmapCache` or
    implement a custom per-document `QCache`. The per-document cache would have
    the advantage that all tiles belonging to a certain document would be
    destroyed when that document is unloaded. The disadvantage is that it would
    be hard to synchronize the cache limits of each `QCache` such that the
    memory footprint of the entire application is constrained.
Revert "Prepare for tiling experiments"

This reverts commit 82b97790b1888c8442a067d36adbab390f9f966e and restores full
functionality to the viewer. Magnifier works---but is very choppy due to the
lack of threaded rendering and page caching.
Begin frontend/backend split

Start work on splitting the library into a frontend (GUI components:
view/scene/graphics items/etc.) and a backend (page rendering/caching/backend
library API/etc.). This sort of structure will allow the frontend components to
focus on user interaction while the backend handles the details of
communicating with PDF libraries.

This structure should be more maintainable and allow the PDF rendering library
to be swapped without any changes in the GUI code.
Start Poppler backend

All classes defined in `PDFBackend.h` are now Abstract Base Classes.

New Poppler backend containing a concrete implementation of the ABCs defined in
`PDFBackend.h`.

The `numPages` call in the `PDFDocumentScene` initializer now uses an abstract
`Document` class instead of the old `Poppler::Document` class.