Tip:
Highlight text to annotate it
X
Hi, I'm Rob Powers from Clever Machine.
We built our app Scenechronize using the google web toolkit.
Scenechronize is an application designed for a producing team to make a movie or television program.
Let me show you the
application. Scenechronize is an application that's based around a script for a movie or a television production. The
user would first load in a PDF of their script
and we would parse it. We
pull information about the scenes,
the locations, and the speaking characters directly out of the script.
Um,
as you can see on the display here, the script is shown on the left side and
the user can scroll through. As
they scroll, the
page updates to show
various information for the current scene. The
user can also navigate
using the pearls along the top
by just clicking and it will directly go to that scene.
Or also, using the list box along the left side.
Let's go take a look at a scene that has some information in it that
would be typical in a production that's in progress.
In this particular scene, you
can see that on the right, there are a number of
items that are described. These
are the various
pieces for that scene that are going to be needed when shooting occurs.
These would include the characters with speaking parts as well as non-speaking parts,
extras, animals,
picture vehicles,
sound effects that needs
to happen, set information,
and the like.
to add new items into the
scene, you can either
click on part
of the ui on the right, or you can tag. And
tagging is simply a selection in the script itself,
telling it what item category
you're including.
In this case, we have a camera
that's needed for scene 21 and
we already have an existing camera in the system. So
we can select the existing element and
it gets displayed right on the screen.
For more information about any of the items, you can click on them.
And that comes, it will show a list of scenes that that particular item is used in. In this case, we're looking at a character
called David from this movie.
Uh, he's used in, he appears in 73 scenes and there
were a number of actors that were considered for the
role. For the actors, you
can click
onto any of the options that were
considered
and see pictures as well as other biographical data. You
can choose the appropriate actor that's actually going to be used in the movie on this screen.
Um, you can notice that as soon as you select one, if we switch tabs, it will be reflected immediately there.
Any reporting that gets done on the project will
include the latest update as soon as you enter it.
Another use for our application is
for scheduling a production.
The tool that's used in the industry is something called a strip board, and what we have provided is an electronic version of that.
It's basically a list of scenes,
each one as a "strip" that are
broken down by shooting day. Our
application uses a drag and drop interface that
allows the user to pull,
uh, one or more
of these strips
around the stripboard as needed. As
those changes happen, things
like the number of pages that are being shot that day
updates live. The
rich interface that our app provides
allows users to work in an environment that is comfortable to them
while providing a lot of data in a small amount of screen real estate. We
chose to use GWT for our application because it allowed us to write in Java,
which opened up the wide range of tools that are available for Java-based apps.
This allowed us to maintain the app,
refactor the code, and most importantly, debug it
much more easily than if we'd been writing in Javascript directly. We
tried a few of the other Javascript libraries available, and
we found that our code was slower
and more bug-prone than when we were using GWT. One of
the other advantages of GWT is because it is
multi-browser, it supports multiple browsers,
we're able to actually write our app so that it looks the same and works the same
across four major browser types. As
far as the user is concerned,
they don't know that
there's a difference between them,
but uhm, the
code is obviously quite different because of the GWT compiler's output.
We extended the GWT widget library so that we could use a custom MVC layer that we built,
and this allowed us to minimize the
amount of data that needed to be called into the client
and simplified the client coding so that we were less prone to introducting bugs due
to custom data request, uh,
data requests
that we
would need to make.
We utilize the
plug-in architecture of the GWT RPC layer to support the back end of that.
So as a user needs data, we can pull it piecemeal, piece by piece, from the server. And
as they make changes to things, we can push the changes live back to the
server. Overall we've been very happy with our experience with GWT,
and our app has been much better as a result.