    Constructor
    -----------

    DONE *. GraphicsContextArray constructor should call the clear() method
            after construction if it allocates the underlying Numeric array.
            If the array is passed in, clear() should not be called.

    clear(), clear_rect(), clear_rects()
    ------------------------------------

    *. Implement a clear_rect that takes a rect argument.  Users can either
       specify an optional alpha value or a full color to be used when
       clearing the rectangle.   If the color is RGB, then alpha is assumed
       to be 1.0.  The default will clear the rect to white with an alpha
       value of 1 (i.e. (1,1,1,1)).  The CTM is used to transform the input
       rects.  Currently, the method will fail if their is any rotation to
       the ctm.
    *. Implement a clear_rects that takes a rect list.  Otherwise, it behaves
       identically to clear_rect.
    *. The clear() method behaves identically to clear_rect, accept you don't
       need to pass in a rectangle.  Instead
       to ?erase()? so that clear can stick with
       the clear_rect semantics.

    path creation methods
    ---------------------

    *. Implement arc and arc_to.

    path rendering
    --------------

    *. Fix fill_path() to handle all the features currently handled in the
       stroke_path() pipeline.
    *. Fix draw_image() to handle all the features currently handled in the
       stroke_path() pipeline.


    Text
    ----

    *. Implement show_text() natively in agg.
       Allow switch between native/freetype on "the fly".
    *. Implement a measure_text() method in the kiva interface that
       returns the height, width, and vertical and horizontal letting
       for a string.  This is returned in user coordinates.

       Do we also have need to return the device coordinates boudning box for
       the text?

    Clipping
    --------

    *. Implement clipping renderer in agg that can work with Dave's
       non-overlapping rectangles calculated in Python code).
    *. Re-implement algorithm for calculating non-overlapping rectangles
       down into kiva-agg C++ code.
    *. API call to get access to the list of rectangles.  Or, and API to
       test whether a rectangle overlaps the list of rectangles.  Dave needs
       this for high level clipping (to determine if a widget needs
       repainting).
    *. Build algorithm to create optimal non-overlapping rectangles set to
       use for rendering.

    Code Reorganization
    -------------------

    *. Reorganize code base so that:
          a. Library is usable from C++
          b. Python interface files are separated out of C++ code.
          c. Organize C++ code so that it is easier to work with.
             Group related methods together and try and work around
             having the graphics_context stuff spread out across 4
             files (.h, .cpp files for graphics_context and
             graphics_context_base)
    *. Make an enthought branch with enable and kiva so that we can port
       the enable to kiva.

    Work on Dependent Libraries
    ---------------------------

    *. Port enable to new kiva backend.
    *. Port chaco to use compiled paths wherever possible.

    Other Features
    --------------
        *. Draft Mode flag
           Not sure if we need this, but it might be nice to set this
           flag and ask kiva to use the fastest possible underlying
           paths at the expense of accuracy.  This might be worth while
           for scroll or drag operations.
        *. Patterns -- repeated images
        *. Transparency layers
        *. Gradients
        *. Shadows
        *. Color spaces
        *. Mask arraays
        *. Arbitrary clip paths
        *. SVG reader/renderer.  This would allow us to use SVG objects
           saved out of Graphics programs instead of bitmaps for our
           buttons/controls/etc.
        *. SSE optimizations.
        *. OpenGL optimizations.
