By the way, while thinking about stickies, I think I've finally thought of a possible animation interface for Inkscape! :D (though really, I'm in no hurry to see it implemented, not before the Inkscape interface is more dynamic)

A long, Long time ago, I tried Flash in Summer Camp, and I'll just say that I didn't like it (though I don't know how it works now).

The approach I'm suggesting is that you add actions to a given object. You basically call up a (big) panel and add actions much as you would a live path effect. When you use the "edit animation" mode, you can turn on the animation "skeleton", which basically makes icons appear next to the object to show if the types of transformations applied to it that frame. From there, the most common parameters can be edited in the toolbar by clicking the action icon of choice: "From" field, "To" field, anchor points, speeds etc.

Types of actions: Move, Rotate, Resize, Opacity, Color, Blur, Stick, Free Transform. People can create their own plug-in effects. The effects can collapsed so that you can easily see the list of effects on that object.

The panel looks a bit like this (> is collapsed, V is open):

Action: [+] Add action -----------------------------------

"Jump:" Move | Start: [ ] | End: []

V "Swing:" Rotate Name: Swing Start: [] Offset: [] End: [] Offset: [] Add trigger: [+] Anchor point: [] Speed: [] Repeat type: [] [] Offset (clicking opens up X and Y values) [] Jitter (clicking opens up X and Y values) -----------------------------------

Major elements:

1. Start and end: Start has 2 possible types: - Date - Trigger - "End" also has duration (which basically is a "+ [value]" figure)

2. Triggers.

The use of triggers is what makes time management easy in this case. You can define Absolute triggers with specific times, or you can create a new one within the object and based upon an action. Basically, in "Hang", clicking on Add Trigger will pop up a panel asking you to: - name the trigger (example: Man.StopSwing) - the condition: either as a proportion of action completed (0%, 50%, 80%, 100%), or a specific parameter (ex.: angle reached 90 degrees)

From then on, this trigger can be called upon in another object and

action. This way, you can specify that as soon as one object is done with an action, the other starts another action. "Offset" can be used too (ex: an object starts moving 20 seconds before another reached the end of a movement path).

I prefer this trigger-centric approach because it makes time management that much easier across multiple objects. Back when I tried that older version of flash, I had to go looking which frames were doing what. :\ Here you can just change the duration of one action, and the rest automatically falls through.

Note: triggers can also be events such as MouseOver, Click, etc.

3. Anchor point. You define anchor points on an object (eventually naming them something other than "Node9011"), and this will be the point of attach of the action. Different actions can have different anchor points.

"Move" also asks you to specify a path.

"Stick" asks you to define a destination point on a destination object: you're sticking one point to another.

4. Parameters: for rotation, you define the rotation speed and/or amplitude, for resize you define the starting and ending sizes. If possible, jitter and offset value options can be added.

Of some interest, the main parameter (rotation, resize etc) could be a custom curve. A straight curve from one value to another is a linear resize for example. But you can also make waves of decreasing amplitude, which in the case of resize/Height only, for example, makes the object look bouncy after say... falling to the ground.

5. Free transform works a bit differently than the rest. My proposed interface is this: this action is applied onto an object with -multiple- layers that count as separate frames (eventually with sub-layers, but it's the first-level layers that are counted as Frames).

So you don't do the transformations within the animation file, but separately, but this should be fine as it makes your CPU life easier. The user basically creates an image, makes several copies on separate layers, makes changes to each, then imports it into the animation file. When applying free transform (or whatever it can be called), the user determines how the image morphs from one frame to another (usually the underlying skeleton moves from one position to another, the user can specify time for each frame as well as relations to trigger events)

An "update" option is quite possible, so you make adjustments to the external files and see them updated directly. En error console pops up if the result is too different. :P

6. Stickies. Stickies are a very important part of this process, because it means a whole lot less of actions!

Example: A man is carrying a box, puts it on a truck, and the truck drives away. Breakdown: - Add Stick action to box, so you don't have to redefine the walking. - Add Move action to man walking. - The Stick action stops when the man arrives at the end of his movement path. - Add Move action from box to truck. - Add stick action from box to truck. - Add move action to truck. The box just follows it because of the stick.

This greatly simplifies things because it avoids having to duplicate paths and values (which can be a whole lot after a while)

Other example: - a Linux penguin walks to a seesaw. Linux penguin jumps onto the seesaw (move action). - the seesaw rotates. Linux penguin also goes down because as we also define a "stick" action to that end of the seesaw. - when that side of the seesaw reaches ground (angle trigger), the object on the other side (a Microsoft logo), that used to be "stuck" on the object until then, gets unstuck and does an arc trajectory into a nearby trash bin. :)

In the meantime you have the grass defined to swing back and forth with no conditions at all, though the penguin stepping on it may "trigger" it to flatten.

7. There should be an automatic summary timeline for each object to show trigger events and actions applied. The timeline keeps it simple, triggers only show their name upon mouse-over (though they may be different colours depending on whether they result from an action underway in this object, in another object, or from clicking something), and tiny action logos appear in the timeline (mouse-over shows the name, type, and highlighted line and triggers to show how long it lasts)

Once the user is happy, he orders Inkscape to calculate the entire output, makes any adjustments necessary before re-calculating, and exports. That's it! :D

I plan to make visual mock-ups, but would there be any problems with this approach? Some people are probably familiar with the Flash way of doing things (whatever it is they are doing now), but I do prefer simply saying "Let's add a simultaneous move and rotation on this or that object. It lasts This long and stops when another object reaches a certain state."

Yay? Nay?

Anyway, users can write up all sorts of fancy effects on their own, like the object getting cut up in all sorts of ways or leaving a temporary ghost trail while resizing. People could download those as extra effects plug-ins.