Advice on implementing a zooming interface?

[chombee]

         I thought this list might be a good place to ask for advice.
                                                      
 I have tested a paper + card version of a prototype story writing tool
    with children, and now need to implement a computer version of the
prototype. I don't have my interface mockups handy, but it is card-based
    story writing. Imagine looking down at a set of 10, 20 or 30 or so
                                                 "story
     cards" on a table, you write a bit of the story on each card. The
 interface needs to be able to provide a zoomed-out overview of all the
   cards, and to zoom-in on each individual card, and the cards need to
                                                   have
text entry widgets on them for the user to input their story (they also
                                need text labels and images).
                                                      
I initially envisioned the 2D cards existing in a 3D scene with proper,
  animated, continuous zooming. This isn't really necessary though, the
                                                   zoom
   is rather used to connect a fixed number of discrete screens, so it
                                                  could
    be implemented more like in Sugar, where you don't actually see an
                              animation of the zoom happening.
                                                      
   Initially I thought to use pygame for the implementation as I knew I
                                                  could
use this on an XO. But I have looked around, and the GUI toolkits I can
find for pygame seem a bit limited. A text input area widget is missing
   from pgu, for example. And I'm not sure I would be able to place GUI
  widgets onto sprites (the cards) with any of the toolkits I saw, they
                                                   all
 seem to allow a 2D interface to be overlayed on the game scene but not
   integrated *into* the scene, whereas I have been imagining my story
                                                  cards
     as sprites in a game scene and the GUI widgets being on the cards
                                             themselves.
                                                      
 The most promising, in fact the only workable option I've found, seems
                                                    to
 be the 3D game engine Panda3D, and its DirectGUI library. I believe it
  would allow the cards to be implemented as flat objects in a 3D scene
                                                   and
  allow GUI widgets to be placed onto these objects in the scene. But a
                                                   full
                                  3D engine may be overkill.
                                                      
Does anyone have any advice on how I could implement this, and hopefully
      make it OLPC compatible, either using pygame or something else?
                                                      
                                                 Thanks