SMOOTH LAYOUT ANIMATION OF CONTINUOUS AND NON-CONTINUOUS PROPERTIES

• US 20100235769A1
• Filed: 03/16/2009
• Published: 09/16/2010
• Est. Priority Date: 03/16/2009
• Status: Abandoned Application

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Original Assignee: Microsoft Corporation
• Inventors: White, Steven C., Jacob, Kurt B., Young, Kenneth L., Schormann, Christian
• Application Number:
  US12/405,213
• Publication Number:
  US 20100235769A1
• Time in Patent Office: Days
• US Class Current: 715/764
• CPC Class Codes: G06F 9/451 Execution arrangements for user interfaces

Abstract

A layout animation system is described herein that performs smooth transitions for properties of a layout, regardless of whether the layout properties are discrete or automatically calculated. Before a transition is executed, the layout animation system extracts and stores the positioning, sizing, and visibility of participating elements across the layout hierarchy. The system places the affected elements in the same position, size, and visibility as the outgoing state requests and animates the elements to an incoming state. For each element, the system calculates a smooth animation that transforms the element from the outgoing position, size, and visibility to the incoming position, size, and visibility. The system then animates the elements over a desired transition time. Thus, the layout animation system provides the ability to create smooth layout transitions in the presence of automatic layout management for properties of various types.

Claims

1. A computer-implemented method for smoothly animating the transition of a user interface (UI) element from an outgoing state to an incoming state, the method comprising:

taking an outgoing snapshot of the position and other visible properties of a UI element in the outgoing state arranged by a layout manager;

informing the UI element that the layout has changed to the new state so that the UI element updates its positional and layout properties but does not render a transition;

taking an incoming snapshot of the position and other visible properties of the UI element in the incoming state;

comparing the outgoing snapshot and the incoming snapshot to determine whether the UI element moved or changed appearance; and

upon determining that the appearance or position of the UI element changed, animating the transition of the UI element by gradually modifying the values of appearance properties that simulate a change between the outgoing and incoming state to make the change of appearance of the UI element appear smooth to a user,

wherein the preceding steps are performed by at least one processor.

2. The method of claim 1 further comprising performing the method for multiple UI elements in parallel.

3. The method of claim 1 wherein taking a snapshot further comprises storing the UI element'"'"'s effective opacity where effective opacity is visibility times opacity.

4. The method of claim 1 further comprising stopping any previously in progress transition.

5. The method of claim 1 wherein taking a snapshot of the outgoing state comprises taking a snapshot of the UI element in a current position of a previously in progress transition and animating the transition from the UI element'"'"'s current size and position to the UI element'"'"'s new ending size and position based on the incoming state.

6. The method of claim 1 wherein comparing further comprises using a comparison result to create a series of intermediate positions and appearances for the UI element to provide a smooth animation transition from the outgoing state to the incoming state.

7. The method of claim 1 wherein animating the transition comprises determining a number of intermediate appearances based on a specified duration for the transition between states.

8. The method of claim 1 wherein animating the transition comprises determining a property type that changed, and for a color property type animating the red, green, and blue values gradually between a start color and an end color.

9. The method of claim 1 wherein animating the transition comprises determining a property type that changed, and for a layout property change that modifies the UI element'"'"'s position, gradually modifying the coordinates of the UI element to produce smooth movement.

10. The method of claim 1 wherein animating the transition comprises determining a property type that changed, and for a visibility property, gradually modifying an opacity property to create an appearance of smoothly changing visibility.

11. The method of claim 1 further comprising before animating the transition wrapping the UI element in a temporary container that isolates the movement of the UI element during animation from other UI elements, and after animating the transition removing the temporary container from the UI element so that the UI element is placed back into its normal position in the layout hierarchy and so that any modifications to it will once again affect surrounding elements.

12. A computer system for smoothly animating user interface (UI) transitions between states, the system comprising:

a processor and memory configured to execute software instructions;

a state management component configured to store multiple states in which a UI can exist and receive an indication to transition from one state to another;

a determine state delta component configured to compare an ingoing and outgoing state to determine layout properties that change between the states, and corresponding UI elements that will change;

a state snapshot component configured to take a snapshot of an area within which each corresponding UI element of a layout is positioned;

a snapshot comparison component configured to compare snapshots of an incoming state and an outgoing state to determine what UI elements change and identify property values for appearance properties at each state; and

an element animation component configured to animate each element smoothly between the outgoing state and incoming state by displaying one or more intermediate appearances for each element.

13. The system of claim 12 wherein the state management component is further configured to store states in a declarative format that can be edited by a designer without programming experience, wherein the declarative format also contains transition information that includes at least conditions that cause a transition and a duration of the transition.

14. The system of claim 12 wherein at least one property of the layout properties compared by the determine state delta component is selected from the group consisting of a column of a grid layout, a row of a grid layout, a row span of a grid layout, a column span of a grid layout, a top property of a canvas, a left property of a canvas, a visibility property, an orientation of a stack, a docking direction in a dock layout, an expanded property of an expander layout, an orientation of a wrap panel layout, an item width of a wrap panel layout, an item height of a wrap panel layout, a width property, a height property, a minimum width property, a minimum height property, a maximum width property, a maximum height property, a margin property, a padding property, a horizontal alignment property, and a vertical alignment property.

15. The system of claim 12 wherein the determine state delta component is further configured to add parent and sibling elements of each corresponding UI element to a set of UI elements that change.

16. The system of claim 12 wherein the snapshot comparison component is further configured to determine a value of each property that changed between the incoming state and the outgoing state, and to determine an appropriate property for the element animation component to modify to simulate the transition of the property that changed.

17. The system of claim 12 further comprising an element isolation component configured to isolate movement of a UI element from other UI elements during animation.

18. A computer-readable storage medium comprising instructions for controlling a computer system to identify potential target user interface (UI) elements in a layout that may change appearance during a UI state transition, wherein the instructions, when executed, cause a processor to perform actions comprising:

comparing an outgoing state to an incoming state to determine layout-based properties that are different between the outgoing state and the incoming state;

identifying changed layout properties based on the comparison;

storing changed UI elements that have identified changing layout properties in a data structure;

for each UI element identified, adding sibling and parent UI elements to the stored UI elements; and

smoothly animating a transition of each identified UI element between an appearance of the element when the element is in the outgoing state and an appearance of the element when the element is in the incoming state.

19. The medium of claim 18 wherein the method stores at least one UI element that has changing layout properties based on the comparison but that does not change appearance between the outgoing state and the incoming state.

20. The medium of claim 18 further comprising for at least one UI element in the layout not stored in the data structure, animating the transition of the UI element in parallel with layout animations by modifying at least one property of the UI element not based on a geometric position of the UI element.