About Piccolo
Welcome to Piccolo! A revolutionary way to create robust,
full-featured graphical applications in Java and C#, with
striking visual effects such as zooming, animation and
multiple representations.Piccolo is a toolkit that supports
the development of 2D structured graphics programs, in general, and
Zoomable User Interfaces (ZUIs), in particular. A ZUI is a new kind
of interface that presents a huge canvas of information on a
traditional computer display by letting the user smoothly zoom in,
to get more detailed information, and zoom out for an overview. We
use a "scene-graph" model that is common to 3D environments.
Basically, this means that Piccolo maintains a hierarchal structure
of objects and cameras, allowing the application developer to
orient, group and manipulate objects in meaningful ways.
Why use Piccolo? It will allow you to build structured graphical
applications without worrying so much about the low level details.
The infrastructure provides efficient repainting of the screen,
bounds management, event handling and dispatch, picking (determining
which visual object the mouse is over), animation, layout, and more.
Normally, you would have to write all of this code from scratch.
Additionally, if you want to build an application with zooming,
that’s built right into the framework too.
What exactly is it? Piccolo is a layer built on top of a lower
level graphics API. There are currently three versions of the
toolkit: Piccolo.Java, Piccolo.NET and PocketPiccolo.NET (for the
.NET Compact Framework). The java version is built on Java 2 and
relies on the Java2D API to do its graphics rendering. The .NET
version is built on the .NET Framework and relies on the GDI+ API to
do its graphics rendering. This makes it easy for Java and C#
programmers, even those targeting PDAs, to build their own animated
graphical applications. And best of all, Piccolo is free
and open source!
|
|
How many versions of Piccolo are
there?
There three versions of Piccolo: Piccolo.Java,
Piccolo.NET, and
PocketPiccolo.NET. They contain the same core
functionality with a few differences. We will examine each separately here. For
a detailed comparison, see
Piccolo in Comparison.
- Piccolo.Java
Piccolo.Java is written in 100% java,
and the great thing about Java is that it runs on lots of
machines including Windows, Mac OS X, Linux and Solaris. It is
based on the Java2D API.
- Piccolo.NET
Piccolo.NET is written in 100% C#.
It runs on platforms that support the .NET Framework.
This means mainly Windows machines. Piccolo.NET
provides the same functionality as Piccolo.Java, enabling .NET
users to easily integrate advanced 2D graphics and zooming with
standard Windows application code. It is a deep port of
the Java version. The API is very similar, but there are a
few differences to better support .NET style guidelines and
constructs. Piccolo.NET is based on the GDI+ API.
- PocketPiccolo.NET
PocketPiccolo.NET is also written in
C#. It runs on platforms that support the Compact .NET
Framework. This means mainly PDAs. Current platforms
include Pocket PCs, Pocket PC Phones, Smart Phones, and Windows
CE.NET devices.
What do you mean by "Structured
Graphics"?
Piccolo provides support for developers of 2D (+ zooming)
object-oriented graphics programs in Java and C#. It uses a "scenegraph"
model that is common to 3D environments. Basically, this means that
Piccolo keeps a hierarchal structure of objects and cameras. Each
node in the hierarchy has a general 2D affine transform which allows
every object to be arbitrarily translated, scaled, rotated, and
sheared. In addition, the cameras have affine transforms that
specify their view into the scene.
This simple approach is very powerful because is enables a very
decoupled object oriented approach to graphical applications.
Piccolo defines several visual components, and applications can
readily extend them or define their own. Piccolo supports dynamic
and constrained objects that respond to various kinds of context
(such as the current camera view). And, the camera model supports
multiple views, overviews, and even embedded views (where a camera
looks at another camera within the scene).
What
development directions are you following?
We are continuing to expand and maintain all three versions of
Piccolo. But, internally, most of our new research projects
are being implemented in Piccolo.NET.
How do I get a Piccolo License?
It's free! Piccolo is completely open source. You can download and
use Piccolo however you like. The only restriction is that you must
follow the guidelines set forth in the
BSD
public license. To read more about using the public license,
visit the license page.
Note that you are not obligated to make your applications
open source. You are free to protect your applications in any way
you see fit.
How do I contact the Piccolo team and
Piccolo users?
There are several ways. You can subscribe to the
mailing lists if you would like to ask
technical questions or receive announcements about Piccolo.
You can also contact us
directly if you would prefer to do so. Or, if you find a
problem with Piccolo, you can send us a
bug report.
Where did Piccolo come from?
Ken Perlin
at New York University came up with the initial zoomable surface
concept. He and David Fox implemented the first versions of Pad
(described in the 1993 SIGGRAPH paper available
here).
Perlin and Fox's original work was supported in part originally by
NYNEX, and then NSF.
The next major step was Pad++, designed by Ben Bederson
and Jim Hollan while at Bellcore.
They both moved to the University of New Mexico where they developed
the bulk of Pad++ in collaboration with Jon Meyer and Ken Perlin at
NYU. This was supported largely by a DARPA initiative in HCI.
Then there was Jazz, a rewrite in Java by Ben Bederson and his
team at the University of Maryland. It was a rich toolkit and
supported all kinds of features including embedded Swing widgets and
SVG. However, it grew too big, and more importantly it had a very
general design that actually made it somewhat hard to use
because there were so many objects.
Piccolo, the current incarnation,
is a direct successor to Jazz. Piccolo takes all that we have
learned over the years, and rolls it into a lean and mean tiny
engine that is very easy to understand, use and extend. It was built
by Jesse Grosjean and then ported to .NET by Aaron Clamage under the
direction of Ben Bederson at the University of Maryland.
What happened to Jazz?
Jazz has lived a healthy and prosperous life. It has enabled us
to perform our research on Zoomable User Interfaces, and it has
spawned a new toolkit, Piccolo. Piccolo is now replacing Jazz and
now supports everything Jazz does (except embedded Swing widgets
which we never found to be crucial anyway). Jazz remains open
source, and we will keep it on this website but we are not actively
maintaining it, and are instead focusing all of our current efforts
on Piccolo.
|
