PATENT DOCUMENT

Publication Number: US-11954322-B2
Application Number: US-202217945962-A
Country: US
Kind Code: B2

Title: Application programming interface for gesture operations

Abstract:
At least certain embodiments of the present disclosure include an environment with a framework of software code interacting with a plurality of applications to provide gesture operations in response to user inputs detected on a display of a device. A method for operating through an application programming interface (API) in this environment includes displaying a user interface that includes a respective view that is associated with a respective application of the plurality of applications. The method includes, while displaying the respective view, detecting, via the software code, a user input within the region of the touch-sensitive surface that corresponds to the respective view, and, in response, in accordance with a determination that the user input is an inadvertent user input, ignoring the user input. The determination that the user input is an inadvertent user input is made based on an inadvertent user input call transferred through the API.

Claims:
What is claimed is: 
     
       1. A non-transitory computer readable storage medium storing executable program instructions that, when executed by an electronic device having a display and an input device, wherein the electronic device includes a framework of software code configured to interact with a plurality of applications and provide the plurality of applications with an application programming interface (API) for performing gesture operations in response to user inputs detected by the input device, cause the electronic device to:
 display, on the display, a user interface that includes a respective view that is associated with a respective application of the plurality of applications, wherein the respective view is a region of the user interface that includes content displayed on the display and the content in the respective view is responsive to inputs detected by the input device that correspond to the respective view; 
 while displaying the respective view on the display, detect, via the software code, a user input that corresponds to the respective view; 
 in response to detecting the user input:
 in accordance with a determination that the user input is an inadvertent user input, wherein the determination that the user input is an inadvertent user input is made based on an inadvertent user input call transferred through the API, ignore the user input; and 
 in accordance with a determination that the user input is not an inadvertent user input, provide the user input to the respective application, including:
 transferring to the respective view a first function call associated with the user input; and 
 after transferring the first function call to the respective view, transfer to the respective view subsequent function calls associated with the user input. 
 
 
 
     
     
       2. The non-transitory computer readable storage medium of  claim 1 , wherein the executable program instructions include instructions that, when executed, cause the electronic device to, in response to providing the user input to the respective application, perform an operation on the respective view. 
     
     
       3. The non-transitory computer readable storage medium of  claim 2 , wherein the operation performed on the respective view is provided to the respective application by the software code. 
     
     
       4. The non-transitory computer readable storage medium of  claim 1 , wherein the executable program instructions include instructions that, when executed, cause the electronic device to, in response to detecting the user input, transfer the inadvertent user input call through the API to determine whether the user input is inadvertent. 
     
     
       5. The non-transitory computer readable storage medium of  claim 1 , wherein the inadvertent user input call is transferred from the respective application through the API. 
     
     
       6. An electronic device, comprising:
 a display; 
 an input device; 
 a processor; and 
 memory storing a plurality of applications and a framework of software code configured to interact with the plurality of applications and provide the plurality of applications with an application programming interface (API) for performing gesture operations in response to user inputs detected by the input device, wherein the memory includes instructions for:
 displaying, on the display, a user interface that includes a respective view that is associated with a respective application of the plurality of applications, wherein the respective view is a region of the user interface that includes content displayed on the display and the content in the respective view is responsive to inputs detected by the input device that correspond to the respective view; 
 while displaying the respective view on the display, detecting, via the software code, a user input that corresponds to the respective view; 
 in response to detecting the user input:
 in accordance with a determination that the user input is an inadvertent user input, wherein the determination that the user input is an inadvertent user input is made based on an inadvertent user input call transferred through the API, ignoring the user input; and 
 in accordance with a determination that the user input is not an inadvertent user input, providing the user input to the respective application, including:
 transferring to the respective view a first function call associated with the user input; and 
 after transferring the first function call to the respective view, transferring to the respective view subsequent function calls associated with the user input. 
 
 
 
 
     
     
       7. The electronic device of  claim 6 , wherein the memory includes instructions for, in response to providing the user input to the respective application, performing an operation on the respective view. 
     
     
       8. The electronic device of  claim 7 , wherein the operation performed on the respective view is provided to the respective application by the software code. 
     
     
       9. The electronic device of  claim 6 , wherein the memory includes instructions for, in response to detecting the user input, transferring the inadvertent user input call through the API to determine whether the user input is inadvertent. 
     
     
       10. The electronic device of  claim 6 , wherein the inadvertent user input call is transferred from the respective application through the API. 
     
     
       11. A method, comprising: 
       at an electronic device with a display and an input device, wherein the electronic device includes a framework of software code configured to interact with a plurality of applications and provide the plurality of applications with an application programming interface (API) for performing gesture operations in response to user inputs detected by the input device:
 displaying, on the display, a user interface that includes a respective view that is associated with a respective application of the plurality of applications, wherein the respective view is a region of the user interface that includes content displayed on the display and the content in the respective view is responsive to inputs detected by the input device that correspond to the respective view; 
 while displaying the respective view on the display, detecting, via the software code, a user input that corresponds to the respective view; 
 in response to detecting the user input:
 in accordance with a determination that the user input is an inadvertent user input, wherein the determination that the user input is an inadvertent user input is made based on an inadvertent user input call transferred through the API, ignoring the user input; and 
 in accordance with a determination that the user input is not an inadvertent user input, providing the user input to the respective application, including:
 transferring to the respective view a first function call associated with the user input; and 
 after transferring the first function call to the respective view, transferring to the respective view subsequent function calls associated with the user input. 
 
 
 
     
     
       12. The method of  claim 11 , including, in response to providing the user input to the respective application, performing an operation on the respective view. 
     
     
       13. The method of  claim 12 , wherein the operation performed on the respective view is provided to the respective application by the software code. 
     
     
       14. The method of  claim 11 , including, in response to detecting the user input, transferring the inadvertent user input call through the API to determine whether the user input is inadvertent. 
     
     
       15. The method of  claim 11 , wherein the inadvertent user input call is transferred from the respective application through the API.

Description:
RELATED APPLICATIONS 
     This application is a continuation of U.S. application Ser. No. 16/840,190, filed Apr. 3, 2020, now U.S. Pat. No. 11,449,217, which is a continuation of U.S. application Ser. No. 16/240,662, filed Jan. 4, 2019, now U.S. Pat. No. 10,613,741, which is a continuation of U.S. application Ser. No. 15/139,260, filed Apr. 26, 2016, now U.S. Pat. No. 10,175,876, which is a continuation of U.S. application Ser. No. 11/620,727, filed Jan. 7, 2007, all of which are incorporated by reference herein in their entireties. 
     This application is related to: (1) U.S. application Ser. No. 13/221,836, filed Aug. 30, 2011, now U.S. Pat. No. 9,665,265; (2) U.S. application Ser. No. 13/221,837, filed Aug. 30, 2011, now abandoned; (3) U.S. application Ser. No. 13/251,121, filed Sep. 30, 2011, now U.S. Pat. No. 9,529,519; (4) U.S. application Ser. No. 13/251,146, filed Sep. 30, 2011, now abandoned; (5) U.S. application Ser. No. 13/251,150, filed Sep. 30, 2011, now U.S. Pat. No. 9,639,260; and (6) U.S. application Ser. No. 13/251,152, filed Sep. 30, 2011, now U.S. Pat. No. 9,575,648, all of which are incorporated herein in their entireties. 
    
    
     FIELD OF THE DISCLOSURE 
     This disclosure relates to application programming interfaces that provide gesture operations. 
     COMPUTER PROGRAM LISTING 
     A portion of the disclosure of this patent document contains material which is subject to copyright protection. The copyright owner has no objection to facsimile reproduction by anyone of the patent document or the patent disclosure, as it appears in the Patent &amp; Trademark Office patent file or records, but otherwise reserves all copyright rights whatsoever. 
     Applicant has submitted herewith Computer Program Listings which are included as Appendix A, attached. 
     BACKGROUND OF THE DISCLOSURE 
     An API is a source code interface that a computer system or program library provides in order to support requests for services from a software application. An API is specified in terms of a programming language that can be interpretative or compiled when an application is built, rather than an explicit low level description of how data is laid out in memory. The software that provides the functionality described by an API is said to be an implementation of the API. 
     Various devices such as electronic devices, computing systems, portable devices, and handheld devices have software applications. The API interfaces between the software applications and user interface software to provide a user of the device with certain features and operations. A user may desire certain operations such as scrolling, selecting, gesturing, and animating operations for a display of the device. 
     Scrolling is the act of sliding a directional (e.g., horizontal or vertical) presentation of content, such as text, drawings, or images, across a screen or display window. In a typical graphical user interface, scrolling is done with the help of a scrollbar or using keyboard shortcuts, often the arrow keys. Gesturing is a type of user input with two or more input points. Animating operations include changing content within a given time period. 
     The various types of devices may have a limited display size, user interface, software, API interface and/or processing capability which limits the ease of use of the devices. User interfaces of devices implement APIs in order to provide requested functionality and features. These user interfaces can have difficulty interpreting the various types of user inputs and providing the intended functionality associated with the user inputs. 
     SUMMARY OF THE DESCRIPTION 
     At least certain embodiments of the present disclosure include one or more application programming interfaces in an environment with user interface software interacting with a software application. Various function calls or messages are transferred via the application programming interfaces between the user interface software and software applications. Example application programming interfaces transfer function calls to implement scrolling, gesturing, and animating operations for a device. 
     At least certain embodiments of the present disclosure include an environment with user interface software interacting with a software application. A method for operating through an application programming interface (API) in this environment includes transferring a set bounce call. The method further includes setting at least one of maximum and minimum bounce values. The set bounce call causes a bounce of a scrolled region in an opposite direction of a scroll based on a region past an edge of the scrolled region being visible in a display region at the end of the scroll. 
     At least certain embodiments of the present disclosure include an environment with user interface software interacting with a software application. A method for operating through an application programming interface (API) in this environment includes transferring a rubberband call. Rubberbanding a scrolled region within a display region occurs by a predetermined maximum displacement when the scrolled region exceeds a display edge. The method further includes transferring an edge rubberband call to set displacement values for at least one edge of the display (e.g., top and bottom edges, left and right edges). 
     At least certain embodiments of the present disclosure include an environment with user interface software interacting with a software application to provide gesture operations for a display of a device. A method for operating through an application programming interface (API) in this environment includes transferring a scaling transform call. The gesture operations include performing a scaling transform such as a zoom in or zoom out in response to a user input having two or more input points. The gesture operations also include performing a rotation transform to rotate an image or view in response to a user input having two or more input points. 
     At least certain embodiments of the present disclosure include a method for performing animations for a display of a device. The method includes starting at least one animation. The method further includes determining the progress of each animation. The method further includes completing each animation based on a single timer. The single timer can be based on a redraw interval of the display hardware. 
     Various devices which perform one or more of the foregoing methods and machine readable media which, when executed by a processing system, cause the processing system to perform these methods, are also described. 
     Other methods, devices and machine readable media are also described. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       The disclosure is described by way of example with reference to the accompanying drawings, wherein: 
         FIG.  1    is flow chart of a method for responding to a user input of a data processing device; 
         FIG.  2    illustrates details of an application programming interface in flow chart form according to certain teachings of the present disclosure; 
         FIG.  3    illustrates details of an application programming interface in flow chart form according to certain teachings of the present disclosure; 
         FIG.  4    is a schematic diagram illustrating an embodiment of user interface of a portable electronic device  400  having a touch-sensitive display  408 ; 
         FIG.  5 A- 5 C  illustrate at least some embodiments of user interface of a portable electronic device  400  having a touch-sensitive display; 
         FIG.  6 A- 6 D  illustrate the scrolling of a list of items to a terminus of the list, at which point an area beyond the terminus is displayed and the list is then scrolled in an opposite direction until the area beyond the terminus is no longer displayed, in accordance with some embodiments; 
         FIG.  7    illustrates details of an application programming interface in flow chart form according to certain teachings of the present disclosure; 
         FIG.  8    illustrates first and second scroll angles for locking a scroll of a display of a device in a horizontal or vertical direction according to certain teachings of the present disclosure; 
         FIG.  9    illustrates details of an application programming interface in flow chart form according to certain teachings of the present disclosure; 
         FIG.  10    illustrates details of an application programming interface in flow chart form according to certain teachings of the present disclosure; 
         FIG.  11    illustrates details of an application programming interface in flow chart form according to certain teachings of the present disclosure; 
         FIG.  12    illustrates details of an application programming interface in flow chart form according to certain teachings of the present disclosure; 
         FIG.  13    illustrates details of an application programming interface in flow chart form according to certain teachings of the present disclosure; 
         FIG.  14    illustrates details of an application programming interface in flow chart form according to certain teachings of the present disclosure; 
         FIG.  15    illustrates a display of a device having a scaling transform of a view; 
         FIGS.  16 A- 16 B  illustrate a display of a device with a view having a first and a second scaling factor, and  FIG.  16 C  illustrates user inputs for changing a scale factor. 
         FIG.  17    illustrates details of an application programming interface in flow chart form according to certain teachings of the present disclosure; 
         FIG.  18    illustrates details of an application programming interface in flow chart form according to certain teachings of the present disclosure; 
         FIG.  19    is flow chart of a method for animating views displayed on a display of a device; 
         FIG.  20    is flow chart of a method for animating views displayed on a display of a device; 
         FIG.  21    illustrates details of an application programming interface in flow chart form according to certain teachings of the present disclosure; 
         FIGS.  22 A and  22 B  illustrate synchronizing the resizing of windows of a display of a device; 
         FIG.  23    illustrates a method for switching ownership of a view of an application displayed on a display of a data processing device; 
         FIG.  24    illustrates a method for memory management of a view of an application displayed on a display of a device; 
         FIGS.  25 A and  25 B  illustrate a data structure having a hierarchy of layers with a layer being associated with a view; 
         FIG.  26    illustrates a method for compositing media and non-media content of user interface for display on a device; 
         FIG.  27    illustrates a data structure or layer tree having a hierarchy of layers; 
         FIG.  28    is a perspective view of a device in accordance with one embodiment of the present disclosure; 
         FIG.  29    is a perspective view of a device in accordance with one embodiment of the present disclosure; 
         FIGS.  30 A and  30 B  are perspective views of a wireless device in accordance with one embodiment of the present disclosure; 
         FIG.  31    is a block diagram of a system in which embodiments of the present disclosure can be implemented; 
         FIG.  32    shows another example of a device in accordance with one embodiment of the present disclosure; 
         FIG.  33 A  is a perspective view of a device in a first configuration (e.g. in a laptop configuration) in accordance with one embodiment of the present disclosure; 
         FIG.  33 B  is a perspective view of the device of  FIG.  33 A  in a second configuration (e.g. a transition configuration) in accordance with one embodiment of the present disclosure; 
         FIG.  33 C  is a perspective view of the device of  FIG.  33 A  in a third configuration (e.g., a tablet configuration) in accordance with one embodiment of the present disclosure; and 
         FIG.  34    illustrates details of an application programming interface in flow chart form according to certain teachings of the present disclosure. 
     
    
    
     DETAILED DESCRIPTION 
     Various embodiments and aspects of the disclosure will be described with reference to details discussed below, and the accompanying drawings will illustrate the various embodiments. The following description and drawings are illustrative of the disclosure and are not to be construed as limiting the disclosure. Numerous specific details are described to provide a thorough understanding of various embodiments of the present disclosure. However, in certain instances, well-known or conventional details are not described in order to provide a concise discussion of embodiments of the present disclosure. 
     Some portions of the detailed descriptions which follow are presented in terms of algorithms which include operations on data stored within a computer memory. An algorithm is generally a self-consistent sequence of operations leading to a desired result. The operations typically require or involve physical manipulations of physical quantities. Usually, though not necessarily, these quantities take the form of electrical or magnetic signals capable of being stored, transferred, combined, compared, and otherwise manipulated. It has proven convenient at times, principally for reasons of common usage, to refer to these signals as bits, values, elements, symbols, characters, terms, numbers, or the like. 
     It should be borne in mind, however, that all of these and similar terms are to be associated with the appropriate physical quantities and are merely convenient labels applied to these quantities. Unless specifically stated otherwise as apparent from the following discussion, it is appreciated that throughout the description, discussions utilizing terms such as “processing” or “computing” or “calculating” or “determining” or “displaying” or the like, can refer to the action and processes of a data processing system, or similar electronic device, that manipulates and transforms data represented as physical (electronic) quantities within the system&#39;s registers and memories into other data similarly represented as physical quantities within the system&#39;s memories or registers or other such information storage, transmission or display devices. 
     The present disclosure can relate to an apparatus for performing one or more of the operations described herein. This apparatus may be specially constructed for the required purposes, or it may comprise a general purpose computer selectively activated or reconfigured by a computer program stored in the computer. Such a computer program may be stored in a machine (e.g. computer) readable storage medium, such as, but is not limited to, any type of disk including floppy disks, optical disks, CD-ROMs, and magnetic-optical disks, read-only memories (ROMs), random access memories (RAMs), erasable programmable ROMs (EPROMs), electrically erasable programmable ROMs (EEPROMs), flash memory, magnetic or optical cards, or any type of media suitable for storing electronic instructions, and each coupled to a bus. 
     A machine-readable medium includes any mechanism for storing or transmitting information in a form readable by a machine (e.g., a computer). For example, a machine-readable medium includes read only memory (“ROM”); random access memory (“RAM”); magnetic disk storage media; optical storage media; flash memory devices; electrical, optical, acoustical or other form of propagated signals (e.g., carrier waves, infrared signals, digital signals, etc.); etc. 
     At least certain embodiments of the present disclosure include one or application programming interfaces in an environment with user interface software interacting with a software application. Various function calls or messages are transferred via the application programming interfaces between the user interface software and software applications. Transferring the function calls or messages may include issuing, initiating, invoking or receiving the function calls or messages. Example application programming interfaces transfer function calls to implement scrolling, gesturing, and animating operations for a device having a display region. An API may also implement functions having parameters, variables, or pointers. An API may receive parameters as disclosed or other combinations of parameters. In addition to the APIs disclosed, other APIs individually or in combination can perform similar functionality as the disclosed APIs. 
     The display region is a form of a window. A window is a display region which may not have a border and may be the entire display region or area of a display. In some embodiments, a display region may have at least one window and/or at least one view (e.g., web, text, or image content). A window may have at least one view. The methods, systems, and apparatuses disclosed can be implemented with display regions, windows, and/or views. 
     At least certain embodiments of the present disclosure include scrolling operations for scrolling a display of a device. The scrolling operations include bouncing a scrolled region in an opposite direction of a scroll when a scroll completes, rubberbanding a scrolled region by a predetermined maximum displacement when the scrolled region exceeds a display edge, and setting a scrolling angle that locks the scroll in a horizontal or vertical direction. 
     At least certain embodiments of the present disclosure include gesture operations for a display of a device. The gesture operations include performing a scaling transform such as a zoom in or zoom out in response to a user input having two or more input points. The gesture operations also include performing a rotation transform to rotate an image or view in response to a user input having two or more input points. 
     At least certain embodiments of the present disclosure include a method for performing animations for a display of a device. The method includes starting at least one animation. The method further includes determining the progress of each animation. The method further includes completing each animation based on a single timer. The single timer can be based on a redraw interval of the display hardware. 
     At least certain embodiments of the disclosure may be part of a digital media player, such as a portable music and/or video media player, which may include a media processing system to present the media, a storage device to store the media and may further include a radio frequency (RF) transceiver (e.g., an RF transceiver for a cellular telephone) coupled with an antenna system and the media processing system. In certain embodiments, media stored on a remote storage device may be transmitted to the media player through the RF transceiver. The media may be, for example, one or more of music or other audio, still pictures, or motion pictures. 
     The portable media player may include a media selection device, such as a click wheel input device on an iPod® or iPod Nano® media player from Apple Computer, Inc. of Cupertino, Calif., a touch screen input device, pushbutton device, movable pointing input device or other input device. The media selection device may be used to select the media stored on the storage device and/or the remote storage device. The portable media player may, in at least certain embodiments, include a display device which is coupled to the media processing system to display titles or other indicators of media being selected through the input device and being presented, either through a speaker or earphone(s), or on the display device, or on both display device and a speaker or earphone(s). In some embodiments, the display device and input device are integrated while in other embodiments the display device and input device are separate devices. Examples of a portable media player are described in U.S. patent application Ser. No. 11/586,862, titled “Automated Response to and Sensing of User Activity in Devices” and published U.S. patent application numbers 2003/0095096 and 2004/0224638 which have been incorporated by reference into the present application. 
     Embodiments of the disclosure described herein may be part of other types of data processing systems, such as, for example, entertainment systems or personal digital assistants (PDAs), or general purpose computer systems, or special purpose computer systems, or an embedded device within another device, or cellular telephones which do not include media players, or multi touch tablet devices, or other multi touch devices, or devices which combine aspects or functions of these devices (e.g., a media player, such as an iPod®, combined with a PDA, an entertainment system, and a cellular telephone in one device). In this disclosure, electronic devices and consumer devices are types of devices. 
       FIG.  1    is flow chart of a method for responding to a user input of a device. The method  100  includes receiving a user input at block  102 . The user input may be in the form of an input key, button, wheel, touch, or other means for interacting with the device. The method  100  further includes creating an event object in response to the user input at block  104 . The method  100  further includes determining whether the event object invokes a scroll or gesture operation at block  106 . For example, a single touch that drags a distance across a display of the device may be interpreted as a scroll operation. In one embodiment, a two or more finger touch of the display may be interpreted as a gesture operation. In certain embodiments, determining whether the event object invokes a scroll or gesture operation is based on receiving a drag user input for a certain time period. The method  100  further includes issuing at least one scroll or gesture call based on invoking the scroll or gesture operation at block  108 . The method  100  further includes responding to at least one scroll call, if issued, by scrolling a window having a view (e.g., web, text, or image content) associated with the event object based on an amount of a scroll with the scroll stopped at a predetermined position in relation to the user input at block  110 . For example, an input may end at a certain position on a display of the device. The scrolling may continue until reaching a predetermined position in relation to the last input received from the user. The method  100  further includes responding to at least one gesture call, if issued, by changing a view associated with the event object based on receiving a plurality of input points in the form of the user input at block  112 . 
     In certain embodiments of the present disclosure, scroll operations include attaching scroll indicators to a content edge of a display. Alternatively, the scroll indicators can be attached to the display edge. In some embodiments, user input in the form of a mouse/finger down causes the scroll indicators to be displayed on the display edge, content edge, or window edge of the scrolled region. If a mouse/finger up is then detected, the scroll indicators are faded out from the display region, content edge, or window edge of the scrolled region. 
     In certain embodiments of the present disclosure, gesture operations include responding to at least one gesture call, if issued, by rotating a view associated with the event object based on receiving a plurality of input points in the form of the user input. Gesture operations may also include scaling a view associated with the event object by zooming in or zooming out based on receiving the user input. 
     In some embodiments, a device includes a display region having multiple views or windows. Each window may have a multiple views including superviews and subviews. It is necessary to determine which window, view, superview, or subview is contacted by a user input in the form of a mouse up, mouse down, or drag, etc. An API can set various modes for making this determination. In one embodiment, a pass mode sends mouse down, mouse up, and drag inputs to the nearest subview. In another embodiment, an intercept on drag mode sends a drag input to the superview while mouse up and down inputs are sent to the subview. In another embodiment, an intercept mode sends all drag, mouse up and down inputs to the superview. The superview may be scroller software operating as a subclass of a view software. The subview may be view software operating as a subclass of the user interface software. 
       FIG.  2    illustrates details of an application programming interface in flow chart form according to certain teachings of the present disclosure. The application programming interface operates in an environment with user interface software interacting with a software application in order to provide a bounce operation. The method  200  for providing a bounce operation includes transferring a set bounce call at block  202 . The method  200  further includes setting at least one of maximum and minimum bounce values at block  204 . The minimum and maximum bounce values may be associated with at least one edge of a window that has received a user input. The method  200  further includes causing a bounce of a scrolled region in an opposite direction of a scroll based on a region past the scrolled region being visible in a display region at the end of the scroll at block  206 . The scrolled region may be a content region. 
     In certain embodiments of the present disclosure, transferring the set bounce call is either one of issuing, initiating, invoking or receiving the set bounce call. 
       FIG.  3    illustrates details of an application programming interface in flow chart form according to certain teachings of the present disclosure. The application programming interface operates in an environment with user interface software interacting with a software application in order to provide a rubberband operation. The method  300  for providing a rubberband operation includes transferring a rubberband call to cause rubberbanding a scrolled region displayed within a display at block  302 . The method  300  further includes transferring an edge rubberband call to set displacement values for at least one edge of the display at block  304 . In some embodiments, the displacement values are set for top and bottom edges, left and right edges, or all edges. 
     Rubberbanding a scrolled region according to the method  300  occurs by a predetermined maximum displacement value when the scrolled region exceeds a display edge of a display of a device based on the scroll. If a user scrolls content of the display making a region past the edge of the content visible in the display, then the displacement value limits the maximum amount for the region outside the content. At the end of the scroll, the content slides back making the region outside of the content no longer visible on the display. 
     In certain embodiments of the present disclosure, transferring the rubberband call is either one of issuing, initiating, invoking or receiving the rubberband call. 
       FIG.  4    is a schematic diagram illustrating an embodiment of user interface of a portable electronic device  400  having a touch-sensitive display  408 . The display  408  may include a window  410 . The window  410  may include one or more displayed objects, such as information objects  412 - 1  to  412 - 4 . In an exemplary embodiment, the information objects  412  may correspond to contact information for one or more individuals in a list of items. The displayed objects may be moved in response to detecting or determining movement  414  of a point of contact with the display, such as that associated with one or more digits  416  of a user (which are not drawn to scale in  FIG.  4   ). In some embodiments, movement of the displayed objects may be accelerated in response to detecting or determining accelerated movement of the point of contact. While embodiment  400  includes one window  410 , in other embodiments there may be two or more display windows. In addition, while embodiment  400  illustrates movement  414  in a particular direction, in other embodiments movement of the displayed objects may be in response to movement  414  in one or more other directions, or in response to a scalar (i.e., a determined or detected movement independent of the direction). 
       FIGS.  5 A- 5 C  illustrate the scrolling of a list of items on a device to a terminus of the list, at which point one or more displayed items at the end of the list smoothly bounce off the end of the display, reverse direction, and then optionally come to a stop.  FIG.  5 A  is a schematic diagram illustrating an embodiment of user interface of a portable electronic device  400  having a touch-sensitive display. One or more displayed objects, such as information object  412 - 1  may be a distance  512 - 1  from a terminus  514  of the list of items which is an edge of a scrolled region and may be moving with a velocity  510 - 1  while the list is being scrolled. Note that the terminus  514  is a virtual boundary associated with the displayed objects, as opposed to a physical boundary associated with the window  410  and/or the display  408 . As illustrated in  FIG.  5 B , when the one or more displayed objects, such as the information object  412 - 1 , reach or intersect with the terminus  514 , the movement corresponding to the scrolling may stop, i.e., the scrolling velocity may be zero at an instant in time. As illustrated in  FIG.  5 C , the one or more displayed objects, such as the information  412 - 1 , may subsequently reverse direction. At a time after the intersection with the terminus  514 , the information object  412 - 1  may have velocity  510 - 2  and may be a distance  512 - 2  from the terminus  514 . In some embodiments, the magnitude of velocity  510 - 2  may be less than the magnitude of velocity  510 - 1  when the distance  512 - 2  equals the distance  512 - 1 , i.e., the motion of the one or more displayed objects is damped after the scrolling list reaches and “bounces” at its terminus. 
     In at least some embodiments of the present disclosure, the method  200  performs the bounce operations described in  FIGS.  5 A- 5 C . The bounce call transferred at block  202  determines whether a bounce operation is enabled. The maximum and minimum bounces values determine the amount of bouncing of the scrolled region in an opposite direction of the scroll. 
       FIGS.  6 A- 6 D  illustrate the scrolling of a list of items to a terminus of the list, at which point an area beyond the terminus is displayed and the list is then scrolled in an opposite direction until the area beyond the terminus is no longer displayed, in accordance with some embodiments. The rubberband operation of method  300  is illustrated in the example of  FIGS.  6 A- 6 D  with the listed items being email messages.  FIGS.  6 A- 6 D  illustrate an exemplary user interface  3500 A for managing an inbox in accordance with some embodiments. An analogous user interface may be used to display and manage other mailboxes (e.g., drafts, sent, trash, personal, etc.). In addition, other types of lists are possible, including but not limited to lists of instant message conversations, favorite phone numbers, contact information, labels, email folders, email addresses, physical addresses, ringtones, or album names. 
     If the list of emails fills more than the allotted screen area, the user may scroll through the emails using vertically upward and/or vertically downward swipe gestures on the touch screen. In the example of  FIG.  6 A , a portion of a list of emails is displayed in the screen area, including a top displayed email  3530  from Bruce Walker and a bottom displayed email  3532  from Kim Brook. A user performs a vertically downward swipe gesture  3514  to scroll toward the top of the list. The vertically downward gesture  3514  need not be exactly vertical; a substantially vertical gesture is sufficient. In some embodiments, a gesture within a predetermined angle of being perfectly vertical results in vertical scrolling. 
     As a result of detecting the vertically downward gesture  3514 , in  FIG.  6 B  the displayed emails have shifted down, such that the previous bottom displayed email  3532  from Kim Brook is no longer displayed, the previous top displayed email  3530  from Bruce Walker is now second from the top, and the email  3534  from Aaron Jones, which was not displayed in  FIG.  6 A , is now displayed at the top of the list. 
     In this example, the email  3534  from Aaron Jones is the first email in the list and thus is the terminus of the list. Upon reaching this email  3534 , in response to continued detection of the vertically downward gesture  3514 , an area  3536  ( FIG.  6 C ) above the first email  3534  (i.e., beyond the terminus of the list) is displayed. In some embodiments, the area displayed beyond the terminus of the list is visually indistinct from the background of the list. In  FIG.  6 C , both the area  3536  and the background of the emails (e.g., emails  3534  and  3530 ) are white and thus are visually indistinct. 
     Once vertically downward gesture  3514  is complete, such that a corresponding object is no longer detected on or near the touch screen display, the list is scrolled in an opposite direction until the area  3536  is no longer displayed.  FIG.  6 D  illustrates the result of this scrolling in the opposite direction, the email  3534  from Aaron Jones is now displayed at the top of the screen area allotted to the list and the area  3536  is not displayed. 
     In the example of  FIGS.  6 A- 6 D , a vertically downward gesture resulted in display of an area beyond the first item in the list. As described in  FIG.  3   , the values for the predetermined maximum displacement (e.g., display of an area beyond the first item in the list) are set at block  304  for top and bottom edges or at block  306  for all edges of the window. 
     Similarly, a vertically upward gesture may result in display of an area beyond the last item of the list, if the vertically upward gesture continues once the list has been scrolled to the last item. The last item may be considered a terminus of the list, similar to the first item. As discussed above, the gesture need not be exactly vertical to result in vertical scrolling; a gesture within a predefined range of angles from perfectly vertical is sufficient. 
       FIG.  7    illustrates details of an application programming interface in flow chart form according to certain teachings of the present disclosure. The application programming interface operates in an environment with user interface software interacting with a software application in order to provide a directional scrolling operation. The method  700  for operating through an application programming interface (API) includes transferring a directional scroll angle call to determine if directional scrolling is enabled at block  702 . The method  700  further includes transferring a directional scroll angle call to set a scroll angle for locking the scrolling in at least one of a vertical or a horizontal direction at block  704 . The method  700  further includes locking the scrolling in the horizontal direction if a user input forms an angle with a horizontal direction that is less than or equal to a first scroll angle at block  706 . The method  700  further includes locking the scrolling in the vertical direction if a user input forms an angle with the vertical direction that is less than or equal to a second scroll angle at block  708 . 
     In certain embodiments, a user input in the form of a drag forms an angle with the horizontal direction that is less than the first scroll angle. In this case, the user presumably intends to scroll in the horizontal direction. The scrolling will be locked in the horizontal direction until the user input exceeds the first scroll angle. A second scroll angle may be used for locking the user input in the vertical direction. The second scroll angle may be set equal to the first scroll angle. 
       FIG.  8    illustrates first and second scroll angles for locking a scroll of a display of a device in a horizontal or vertical direction. The horizontal direction  802  and vertical direction  804  are in reference to a window or a display of a device. As discussed in the method  700 , a user input such as a drag movement forming an angle with the horizontal direction  802  less than or equal to the first scrolling angle  806  or  808  will lock the user input in the horizontal direction. In a similar manner, a user input forming an angle with the vertical direction  804  less than or equal to the second scrolling angle  810  or  812  will lock the user input in the vertical direction. The first and second scrolling angles may be set at the same angle or at different angles as well. For example, the first and second scrolling angles may be set at 25 degrees. A user input less than or equal to 25 degrees with respect to the horizontal or vertical direction will lock the scrolling in the appropriate direction. 
     In some embodiments, the horizontal and vertical locking angles can be determined in part by the aspect of the content. For example, content in the form of a tall page may receive a larger vertical locking angle compared to the horizontal locking angle. 
       FIG.  9    illustrates details of an application programming interface in flow chart form according to certain teachings of the present disclosure. The application programming interface operates in an environment with user interface software interacting with a software application in order to provide a deceleration scroll operation. The method  900  for providing the deceleration scroll operation includes transferring a deceleration scroll call to set a deceleration factor for a drag user input at block  902 . The method  900  further includes slowing the scroll to a stop based on the speed of the drag user input and the deceleration factor at block  904 . 
     In certain embodiments, a user input in the form of a drag invokes a scroll operation for a certain time period. The user input has a certain speed. The scroll of the scrolled region of a window or a display region of a display of a device will be stopped after the user input stops by applying a deceleration factor to the speed of the user input during the drag movement. 
       FIG.  10    illustrates details of an application programming interface in flow chart form according to certain teachings of the present disclosure. The application programming interface operates in an environment with user interface software interacting with a software application in order to provide a scroll hysteresis operation. The method  1000  for providing the scroll hysteresis operation includes transferring a scroll hysteresis call to determine whether a user input invokes a scroll at block  1002 . The method  1000  further includes setting a hysteresis value for determining whether a user input invokes a scroll at block  1004 . 
     In certain embodiments, a user input in the form of a drag over a certain distance across a display or window within a display of a device invokes a scroll operation. The hysteresis value determines the certain distance which the user input must drag across the display or window prior to invoking a scroll operation. A user input that does not drag the certain predetermined distance will not invoke a scroll operation and may be considered a mouse up or down input or other type of input. 
       FIG.  11    illustrates details of an application programming interface in flow chart form according to certain teachings of the present disclosure. The application programming interface operates in an environment with user interface software interacting with a software application in order to attach a scroll indicator to a scroll region edge or a window edge of a device. In some embodiments, the scroll region edge is associated with a content edge. The window or display edge may be associated with the edge of a display region. The method  1100  for providing the scroll indicator includes transferring a scroll indicator call to determine whether at least one scroll indicator attaches to an edge of a scroll region or a window edge at block  1102 . A scroll indicator may be displayed on any display edge, window edge or scroll region edge. The method  1100  further includes optionally attaching at least one scroll indicator to the edge of the scroll region based on the scroll indicator call at block  1104 . Alternatively, the method  1100  further includes optionally attaching at least one scroll indicator to the window edge of the view based on the scroll indicator call at block  1106 . 
     In some embodiments, the operations of method  1100  can be altered, modified, combined, or deleted. For example, block  1104  can be deleted. Likewise, block  1106  can be deleted from the method  1100 . Alternatively, the order of block  1104  and block  1106  can be switched. Other methods having various operations that have been disclosed within the present disclosure can also be altered, modified, rearranged, collapsed, combined, or deleted. 
     In certain embodiments of the present disclosure, transferring the scroll indicator call is either one of issuing, initiating, invoking or receiving the scroll indicator call. For example, the user interface software (e.g., software kit or library) may receive the scroll indicator call from the software application. 
       FIG.  12    illustrates details of an application programming interface in flow chart form according to certain teachings of the present disclosure. The application programming interface operates in an environment with user interface software interacting with a software application in order to determine if an inadvertent user input contacts a view of a display of a device. The method  1200  includes transferring an inadvertent user input call to determine whether the user input was inadvertent at block  1202 . The method  1200  further includes ignoring the inadvertent user input based on the determination of the inadvertent user input call at block  1204 . In one embodiment, the inadvertent user input call comprises a thumb detection call to determine whether the user input was an inadvertent thumb. 
     In certain embodiments of the present disclosure, transferring the inadvertent user input call is either one of issuing, initiating, invoking or receiving the inadvertent user input call. 
     A gesture API provides an interface between an application and user software in order to handle gesturing. Gesturing may include scaling, rotating, or other changes to a view, window, or display. A mask may merely permit certain changes while limiting or not permitting other changes. Events of all kinds come into the application via a graphics framework. They are enqueued, collaleced if necessary and dispatched. If the events are system level events (e.g., application should suspend, device orientation has changed, etc.) they are routed to the application having an instance of a class of the user interface software. If the events are hand events based on a user input, the events are routed to the window they occurred over. The window then routes these events to the appropriate control by calling the instance&#39;s mouse and gesture methods. The control that receives a mouse down or mouse entered function will continue to get all future calls until the hand is lifted. If a second finger is detected, the gesture methods or functions are invoked. These functions may include start, change, and end gesture calls. The control that receives start gesture call will be sent all future change gesture calls until the gesture ends. 
       FIG.  13    illustrates details of an application programming interface in flow chart form according to certain teachings of the present disclosure. The application programming interface operates in an environment with user interface software interacting with a software application in order to provide a gesture operation. The method  1300  for providing the gesture operation includes transferring a handle gesture event call at block  1302 . The method  1300  further includes transferring a gesture change call in response to the handle gesture event call at block  1304 . 
     In certain embodiments, a user input in the form of two or more points is received by a display of a device. A multi-touch driver of the device receives the user input and packages the event into an event object. A window server receives the event object and determines whether the event object is a gesture event object. If the window server determines that a gesture event object has been received, then user interface software issues or transfers the handle gesture call at block  1302  to a software application associated with the view. The software application confirms that a gesture event has been received and passes the handle gesture call to a library of the user interface software. The window server also associates the gesture event object with the view that received the user input. The library responds by transferring a gesture change call in response to the handle gesture event call at block  1304 . 
     In one embodiment, a window or view associated with the user input receives the change call in order to perform the gesture event. The user software that provides the view receives a gesture start event call, a gesture changed event call, a zoom to scale setting for the view, and a gesture end call. The gesture calls receive an input of a gesture event which may be base event having a type such as a hand event, keyboard event, system event, etc. A delegate associated with the application receives a start gesture call, gesture did change call, and gesture did finish call. The user software is dynamically linking into the application during the run time of the gesture process. 
     In some embodiments, the gesture changed function call contains the following information about the gesture:
         the number of fingers currently down;   the number of fingers initially down;   the rotation of the hand;   the scale of the hand;   the translation of the hand;   the position of the inner and outermost fingers; and   the pressure of the first finger.       

     In other embodiments, more information about each finger down may be included as follows:
         the stage of the finger (just touch down, fully pressed, lifting off, etc.);   the position of the finger;   the proximity of the finger (how hard you&#39;re touching);   the orientation of the finger (what angle the ovoid is at);   the length of the major and minor axis;   the velocity of the finger; and   the eccentricity of the finger&#39;s ovoid.       

     A gesture event object may be a chord event object having a chord count (e.g., number of fingers contacted the view or display), a chord start event, a chord change event, and a chord end event. A chord change event may include a scaling or rotation transform. 
       FIG.  14    illustrates details of an application programming interface in flow chart form according to certain teachings of the present disclosure. The application programming interface operates in an environment with user interface software interacting with a software application in order to provide a scaling transform of a display region, window, or view of a display of a device. The method  1400  for providing the scaling transform includes transferring a scaling transform call to determine a scaling transform for a view associated with a user input having a plurality of input points at block  1402 . The method  1400  further includes transferring a scaling gesture start call at block  1404 . The method  1400  further includes transferring a scaling gesture progress call at block  1406 . The method  1200  further includes transferring a scaling gesture end call at block  1408 . 
     In certain embodiments, a user input in the form of two or more input points (e.g., fingers) moves together or apart to invoke a gesture event that performs a scaling transform on the view associated with the user input. A scale transform includes a minimum and maximum scale factor.  FIG.  15    illustrates a display  1502  of a device having a scaling transform of a view. The view  1504  (e.g., web, text, or image content) has a first scale factor. A user input (e.g., two fingers moving apart) associated with the view  1504  is interpreted as a gesture event to zoom out from view  1504  to view  1508  having a second scale factor that exceeds the maximum scale factor of the view  1516 . A snapback flag determines whether the zoom out can proceed past the maximum scale factor to view  1508  prior to snapping back to the maximum scale factor associated with view  1516 . 
       FIG.  16 A  illustrates a display  1604  of a device having a first scaling factor of a view  1616 . A user input (e.g., two fingers  1608  and  1610  moving together) associated with the view  1614  is interpreted as a gesture event to zoom in from view  1614  to view  1664  having a second scale factor as illustrated in  FIG.  16 B . The dashed regions  1602  and  1650  represent the total area of the content with the only content being displayed in the display area  1604  and  1652 . In performing the scaling transform from  FIG.  16 A  to  FIG.  16 B , the center of the gesture event, center  1612  for  FIG.  16 A  and center  1660  for  FIG.  16 B , remains in the same position with respect to the display  1604 . The scroll indicator  1606  shrinks to become scroll indicator  1654  during the transform to indicate that a smaller portion of the total content  1650  is being displayed on display  1604  as a result of the zoom in operation. The dashed region  1650  is larger than the dashed region  1602  to represent that a larger portion of content is not being displayed on display  1652  in  FIG.  16 B  as a result of the zoom in operation. 
     In at least some embodiments of the present disclosure, a user desires to change a view  1670  from a scale factor of 2× to a scale factor of 1×. As illustrated in  FIG.  16 C , a first set of user inputs  1672  and  1674  that move to the second set of user inputs  1676  and  1678  will decrease the scale factor from 2× to 1×. It may be desirable for the user to scale from 2× to 1× without having to move the user inputs a large distance across the view  1670 . In an environment with user interface software interacting with a software application, a gesture scaling transform flag may be set in order to determine a scaling transform for a view associated with a user input having a plurality of input points. The scaling transform flag scales either from a current scale factor to a minimum scale factor or from the current scale factor to a maximum scale factor. For example, a flag may be set at the position associated with a 1.5× scale factor and a third set of user inputs  1680  and  1682 . A user desiring to change the scale factor from 2× to 1× would only have to move his fingers, the user inputs, from the first set  1672  and  1674  to the third set  1680  and  1682  if the gesture scaling transform flag has been set at a scale factor of 1.5×. 
       FIG.  17    illustrates details of an application programming interface in flow chart form according to certain teachings of the present disclosure. The application programming interface operates in an environment with user interface software interacting with a software application in order to provide a rotation transform of a view, window, or display region of a display of a device. The method  1700  for providing the rotation transform includes transferring a rotation transform call to determine a rotation transform for a view associated with a user input having a plurality of input points at block  1702 . The method  1700  further includes transferring a rotation gesture start call at block  1704 . The method  1700  further includes transferring a rotation gesture progress call at block  1706 . The method  1700  further includes transferring a rotation gesture end call at block  1708 . 
     In certain embodiments, a user input in the form of two or more input points rotates to invoke a gesture event that performs a rotation transform on the view associated with the user input. The rotation transform includes a minimum and maximum degree of rotation for associated minimum and maximum rotation views. The user input may temporarily rotate a view past a maximum degree of rotation prior to the view snapping back to the maximum degree of rotation. 
       FIG.  18    illustrates details of an application programming interface in flow chart form according to certain teachings of the present disclosure. The application programming interface operates in an environment with user interface software interacting with a software application in order to notify a delegate of at least one animation associated with a display region, window, or view of a display of a device. A delay in the animation may be specified by the API. Also, multiple animations may be assigned priority by the API. The method  1800  for notifying the delegate includes determining whether any animation occurs at block  1802 . The method  1800  further includes checking the progress of an animation at block  1804 . If progress has occurred, then the next state (e.g., position, opacity, or transform) of the animation can be calculated at block  1806 . If progress has completed at block  1806 , then at block  1808  it is determined whether the view associated with the completed animation is associated with a delegate. If so, a delegate call is transferred to notify the delegate of the animation for the view at block  1810 . The delegate operating under the control of the software application can change other views in response to the view being modified by the animation. 
     In certain embodiments, software invokes an animation that performs a scaling transform on the view associated with the user input. A display may include numerous views. The view being increased in size by the scaling transform may obstruct other views in which case the other views may need to be reduced in size. Alternatively, the view being decreased in size by the scaling transform may create additional area for other views to increase in size. 
       FIG.  19    is flow chart of a method for animating a display region, windows, or views displayed on a display of a device. The method  1900  includes starting at least two animations at block  1902 . The method  1900  further includes determining the progress of each animation at block  1904 . The method  1900  further includes completing each animation based on a single timer at block  1906 . 
     In certain embodiments of the present disclosure, the single timer includes a timer based on a redraw interval which is a time period between the display of a current frame and a next frame of the display of the device. In this case, changes in animation are updated to the display during the redraw interval in order to display the changes during the next frame of the display. The progress of each animation may be calculated periodically or based upon a progress call. 
     The method  1900  may further include determining whether each animation is associated with a delegate. The delegate is then notified of the animation. Other views not associated with an animation may be changed depending on the software application controlling the delegate. 
       FIG.  20    is flow chart of a method for animating a display region, windows, or views displayed on a display of a device. The method  2000  includes providing a single animation timer at block  2002 . The method  2000  further includes animating a plurality of animations with the single animation timer at block  2004 . For example, a single timer may control all animations which occur simultaneously. The animations may include a transform, a frame, and an opacity animation. A animation transform may include a scaling or rotation transform. A frame animation may include resizing of a frame. An opacity animation changes the opacity from opaque to transparent or vice versa. 
       FIG.  21    illustrates details of an application programming interface in flow chart form according to certain teachings of the present disclosure. The application programming interface operates in an environment with user interface software interacting with multiple software applications or processes in order to synchronize animations associated with multiple views or windows of a display of a device. The method  2100  for synchronizing the animations includes setting attributes of views independently with each view being associated with a process at block  2102 . For example, an attribute or property of a view may include a position, size, opacity, etc. An animation alters one or more attributes from a first state to a second state. The method  2100  further includes transferring a synchronization call to synchronize animations for the multiple views of the display at block  2104 . The synchronization call may include input parameters or arguments such as an identification of the synchronization of the processes and a list of the processes that are requesting animation of the multiple views. In one embodiment, the synchronization call includes the identification and the number of processes that are requesting animation. In one embodiment, each application or process sends a synchronization call at different times. The method  2100  further includes transferring a synchronization confirmation message when a synchronization flag is enabled at block  2106 . The synchronization flag can be enabled when the processes to be synchronized have each sent messages to a window server operating the user interface software. The method  2100  further includes updating the attributes of the views from a first state to a second state independently at block  2108 . In one embodiment, the window server receives the updated attributes from each process at different times. The method  2100  further includes transferring a start animation call to draw the requested animations when both processes have updated attributes associated with the second state at block  2110 . 
     In some embodiments, a first data structure or layer tree represents a hierarchy of layers that correspond to the views or windows of the processes. A second data structure or render tree represents a similar copy of the layer tree. However, the render tree is not updated until the independent processes have completed their separate animations. At this time, the render tree updates and redraws the screen with the new animations. 
       FIGS.  22 A and  22 B  illustrate synchronizing the resizing of views or windows of a display of a device. For example, a window  2210  associated with a first process with a size attribute may increase in size by changing from a first state, window  2210  in  FIG.  22 A , to a second state, window  2210  in  FIG.  22 B . At approximately the same time, a second window  2220  may decrease in size in proportion to the increase in size of the first window  2210 . The method  2100  provides synchronization of the resizing of the windows  2210  and  2220  illustrated in  FIGS.  22 A and  22 B . The animations in changing from the first state to the second state may occur incrementally and occur with the synchronization of method  2100 . 
       FIG.  23    illustrates a method for switching ownership of a view of an application displayed on a display of a data processing device. The method  2300  includes constructing a data structure having a hierarchy of layers with a layer being associated with a view and owning the view at block  2302 . The layers may be content, windows, video, images, text, media, or any other type of object for user interface of the application. The method  2300  further includes removing the layer from the data structure at block  2304 . The method  2300  further includes switching ownership of the view from the layer to the view at block  2306 . 
     In some embodiments, each layer from the data structure is associated with a view. The layer associated with the view sends a delegate function call to the view in order to generate content provided by the view. A first pointer reference points from the layer to the view. A second pointer reference points from the view to the layer. The number of references pointing to an object such as the view is defined as the retained count of the object. The view may receive notification that the layer will be removed from the data structure. Removing the layer from the data structure may occur based on the view associated with the layer being removed from the display of the device. When the layer is removed from the data structure or layer tree the pointer from the layer to the view will be removed. The view will have a retained count of zero and be deallocated or removed from memory if the ownership of the view is not reversed. The view will have a retained count of at least one if ownership is reversed. 
       FIG.  24    illustrates a method for memory management of a view of an application displayed on a display of a device. The method  2400  includes constructing a data structure having a hierarchy of layers with at least one layer being associated with the view at block  2402 . The method  2400  further includes storing the data structure in memory at block  2404 . The method  2400  further includes maintaining a retained count of the number of references to the view from other objects at block  2406 . The method  2400  further includes deallocating the view from memory if the retained count is zero at block  2408 . As discussed above, the retained count of the view will be decremented if the layer is removed from the data structure. Removing the layer from the data structure may occur based on the view associated with the layer being removed from the display of the device. 
       FIGS.  25 A and  25 B  illustrate a data structure having a hierarchy of layers with a layer being associated with a view. The data structure includes layers  2502 ,  2504 , and  2506 . Layer  2506  is associated with the view  2510 . The layer  2506  associated with the view  2510  sends a delegate call to the view in order to generate content provided by the view. A first pointer reference  2508  points from the layer  2506  to the view  2510 . A second pointer reference  2512  points from the view  2510  to the layer  2506 . A third pointer reference  2532  may point from user interface (UI) controller  2530  to the view  2510 . The UI controller  2530  may control operations associated with the view  2510  such as scrolling the view  2510  in response to a user input. The view  2510  in  FIG.  25 A  has a retained count of two based on the pointer references  2508  and  2532 . 
     If the layer  2506  is removed from the data structure as illustrated in  FIG.  25 B , then the pointer  2508  is removed. View  2510  will have a lower retained count as illustrated in  FIG.  25 B . If view  2510  has a retained count of zero, then the memory storing the view  2510  will be deallocated. 
       FIG.  26    illustrates a method for compositing media and non-media content of user interface for display on a device. The method  2600  includes constructing a data structure having a hierarchy of layers associated with the user interface of the device at block  2602 . The method  2600  further includes determining whether each layer of the data structure is associated with media or non-media content at block  2604 . The data structure or layer tree is traversed in order to determine whether each of the layers of the data structure is associated with media or non-media content. The method  2600  further includes detaching a layer associated with media content from the data structure at block  2606 . The method  2600  further includes storing media content in a first memory location at block  2606 . The method  2600  further includes storing non-media content in a second memory location at block  2608 . The method  2600  further includes compositing the media and non-media content for display on the device at block  2610 . 
     In some embodiments, compositing the media and non-media content includes retrieving the media content from the first memory location, retrieving the non-media content from the second memory location, and scanning the media and non-media content directly to the display. The memory location can be any type of memory located in cache, main memory, a graphics processing unit, or other location within a device. The media content may include video, video plug-in, audio, image, or other time varying media. The media content may be in the form of a YUV model with the Y representing a luminance component (the brightness) and U and V representing chrominance (color) components. The media content may be scanned to the display at a rate of substantially twenty to forty frames per second. The media content may be scaled prior to being scanned to the display of the device. 
     The non-media content may include content, views, and images that do not require frequent updating. The non-media content may be in the form of a RGB model which is an additive model in which red, green, and blue (often used in additive light models) are combined in various ways to reproduce other colors. The non-media content may be scanned to the display at a slower rate compared to the media content. 
       FIG.  27    illustrates a data structure or layer tree having a hierarchy of layers. The layers can be associated with media and non-media content. For example, layer  2704  is associated with media content  2706  such as a video. Layer  2710  is associated with non-media content  2712  which may be user interface view for the video. Layers  2720 ,  2730 , and  2740  are associated with non-media content  2722 ,  2732 , and  2742 , respectively, that forms the components of the non-media content  2712 . The method  2600  will determine whether each layer of the data structure is associated with media or non-content. Any layers associated with media content such as layer  2704  will be removed from the data structure and processed in a separate memory location. 
     In some embodiments, the methods, systems, and apparatuses of the present disclosure can be implemented in various devices including electronic devices, consumer devices, data processing devices, desktop computers, portable computers, wireless devices, cellular devices, tablet devices, handheld devices, multi touch devices, multi touch data processing devices, any combination of these devices, or other like devices.  FIGS.  4 - 6  and  28 - 33    illustrate examples of a few of these devices. 
       FIG.  28    illustrates a device  2800  according to one embodiment of the disclosure.  FIG.  28    shows a wireless device in a telephone configuration having a “candy-bar” style. In  FIG.  28   , the wireless device  2800  may include a housing  2832 , a display device  2834 , an input device  2836  which may be an alphanumeric keypad, a speaker  2838 , a microphone  2840  and an antenna  2842 . The wireless device  2800  also may include a proximity sensor  2844  and an accelerometer  2846 . It will be appreciated that the embodiment of  FIG.  28    may use more or fewer sensors and may have a different form factor from the form factor shown in  FIG.  28   . 
     The display device  2834  is shown positioned at an upper portion of the housing  2832 , and the input device  2836  is shown positioned at a lower portion of the housing  2832 . The antenna  2842  is shown extending from the housing  2832  at an upper portion of the housing  2832 . The speaker  2838  is also shown at an upper portion of the housing  2832  above the display device  2834 . The microphone  2840  is shown at a lower portion of the housing  2832 , below the input device  3286 . It will be appreciated that the speaker  2838  and microphone  2840  can be positioned at any location on the housing, but are typically positioned in accordance with a user&#39;s ear and mouth, respectively. 
     The display device  2834  may be, for example, a liquid crystal display (LCD) which does not include the ability to accept inputs or a touch input screen which also includes an LCD. The input device  2836  may include, for example, buttons, switches, dials, sliders, keys or keypad, navigation pad, touch pad, touch screen, and the like. Any well-known speaker, microphone and antenna can be used for speaker  2838 , microphone  2840  and antenna  2842 , respectively. 
     The data acquired from the proximity sensor  2844  and the accelerometer  2846  can be combined together, or used alone, to gather information about the user&#39;s activities. The data from the proximity sensor  2844 , the accelerometer  2846  or both can be used, for example, to activate/deactivate a display backlight, initiate commands, make selections, control scrolling, gesturing, animating or other movement in a display, control input device settings, or to make other changes to one or more settings of the device. In certain embodiments of the present disclosure, the device  2800  can be used to implement at least some of the methods discussed in the present disclosure. 
       FIG.  29    shows a device  2950  in accordance with one embodiment of the disclosure. The device  2950  may include a housing  2952 , a display/input device  2954 , a speaker  2956 , a microphone  2958  and an optional antenna  2960  (which may be visible on the exterior of the housing or may be concealed within the housing). The device  2950  also may include a proximity sensor  2962  and an accelerometer  2964 . The device  2950  may be a cellular telephone or a device which is an integrated PDA and a cellular telephone or a device which is an integrated media player and a cellular telephone or a device which is both an entertainment system (e.g. for playing games) and a cellular telephone, or the device  2950  may be other types of devices described herein. In one particular embodiment, the device  2950  may include a cellular telephone and a media player and a PDA, all contained within the housing  2952 . The device  2950  may have a form factor which is small enough that it fits within the hand of a normal adult and is light enough that it can be carried in one hand by an adult. It will be appreciated that the term “portable” means the device can be easily held in an adult user&#39;s hands (one or both); for example, a laptop computer and an iPod are portable devices. 
     In one embodiment, the display/input device  2954  may include a multi-point touch input screen in addition to being a display, such as an LCD. In one embodiment, the multi-point touch screen is a capacitive sensing medium configured to detect multiple touches (e.g., blobs on the display from a user&#39;s face or multiple fingers concurrently touching or nearly touching the display) or near touches (e.g., blobs on the display) that occur at the same time and at distinct locations in the plane of the touch panel and to produce distinct signals representative of the location of the touches on the plane of the touch panel for each of the multiple touches. 
     In certain embodiments of the present disclosure, the device  2800  can be used to implement at least some of the methods discussed in the present disclosure. 
       FIGS.  30 A and  30 B  illustrate a device  3070  according to one embodiment of the disclosure. The device  3070  may be a cellular telephone which includes a hinge  3087  that couples a display housing  3089  to a keypad housing  3091 . The hinge  3087  allows a user to open and close the cellular telephone so that it can be placed in at least one of two different configurations shown in  FIGS.  30 A and  30 B . In one particular embodiment, the hinge  3087  may rotatably couple the display housing to the keypad housing. In particular, a user can open the cellular telephone to place it in the open configuration shown in  FIG.  30 A  and can close the cellular telephone to place it in the closed configuration shown in  FIG.  30 B . The keypad housing  3091  may include a keypad  3095  which receives inputs (e.g. telephone number inputs or other alphanumeric inputs) from a user and a microphone  3097  which receives voice input from the user. The display housing  3089  may include, on its interior surface, a display  3093  (e.g. an LCD) and a speaker  3098  and a proximity sensor  3084 ; on its exterior surface, the display housing  3089  may include a speaker  3096 , a temperature sensor  3094 , a display  3088  (e.g. another LCD), an ambient light sensor  3092 , and a proximity sensor  3084 A. Hence, in this embodiment, the display housing  3089  may include a first proximity sensor on its interior surface and a second proximity sensor on its exterior surface. 
     In at least certain embodiments, the device  3070  may contain components which provide one or more of the functions of a wireless communication device such as a cellular telephone, a media player, an entertainment system, a PDA, or other types of devices described herein. In one implementation of an embodiment, the device  3070  may be a cellular telephone integrated with a media player which plays MP3 files, such as MP3 music files. 
     Each of the devices shown in  FIGS.  4 ,  5 A,  5 B,  5 C,  6 A,  6 B,  6 C,  6 D,  28 ,  29 ,  30 A and  30 B  may be a wireless communication device, such as a cellular telephone, and may include a plurality of components which provide a capability for wireless communication.  FIG.  31    shows an embodiment of a wireless device  3070  which includes the capability for wireless communication. The wireless device  3070  may be included in any one of the devices shown in  FIGS.  4 ,  5 A,  5 B,  5 C,  6 A,  6 B,  6 C,  6 D,  28 ,  29 ,  30 A and  30 B , although alternative embodiments of those devices of  FIGS.  4 ,  5 A,  5 B,  5 C,  6 A,  6 B,  6 C,  6 D,  28 ,  29 ,  30 A and  30 B  may include more or fewer components than the Wireless device  3070 . 
     Wireless device  3070  may include an antenna system  3101 . Wireless device  3070  may also include a digital and/or analog radio frequency (RF) transceiver  3102 , coupled to the antenna system  3101 , to transmit and/or receive voice, digital data and/or media signals through antenna system  3101 . 
     Wireless device  3070  may also include a digital processing system  3103  to control the digital RF transceiver and to manage the voice, digital data and/or media signals. Digital processing system  3103  may be a general purpose processing device, such as a microprocessor or controller for example. Digital processing system  3103  may also be a special purpose processing device, such as an ASIC (application specific integrated circuit), FPGA (field-programmable gate array) or DSP (digital signal processor). Digital processing system  3103  may also include other devices, as are known in the art, to interface with other components of wireless device  3070 . For example, digital processing system  3103  may include analog-to-digital and digital-to-analog converters to interface with other components of wireless device  3070 . Digital processing system  3103  may include a media processing system  3109 , which may also include a general purpose or special purpose processing device to manage media, such as files of audio data. 
     Wireless device  3070  may also include a storage device  3104 , coupled to the digital processing system, to store data and/or operating programs for the Wireless device  3070 . Storage device  3104  may be, for example, any type of solid-state or magnetic memory device. 
     Wireless device  3070  may also include one or more input devices  3105 , coupled to the digital processing system  3103 , to accept user inputs (e.g., telephone numbers, names, addresses, media selections, etc.) Input device  3105  may be, for example, one or more of a keypad, a touchpad, a touch screen, a pointing device in combination with a display device or similar input device. 
     Wireless device  3070  may also include at least one display device  33106 , coupled to the digital processing system  3103 , to display information such as messages, telephone call information, contact information, pictures, movies and/or titles or other indicators of media being selected via the input device  3105 . Display device  3106  may be, for example, an LCD display device. In one embodiment, display device  3106  and input device  3105  may be integrated together in the same device (e.g., a touch screen LCD such as a multi-touch input panel which is integrated with a display device, such as an LCD display device). The display device  3106  may include a backlight  3106 A to illuminate the display device  3106  under certain circumstances. It will be appreciated that the Wireless device  3070  may include multiple displays. 
     Wireless device  3070  may also include a battery  3107  to supply operating power to components of the system including digital RF transceiver  3102 , digital processing system  3103 , storage device  3104 , input device  3105 , microphone  3105 A, audio transducer  3108 , media processing system  3109 , sensor(s)  3110 , and display device  3106 . Battery  3107  may be, for example, a rechargeable or non-rechargeable lithium or nickel metal hydride battery. Wireless device  3070  may also include audio transducers  3108 , which may include one or more speakers, and at least one microphone  3105 A. In certain embodiments of the present disclosure, the wireless device  3070  can be used to implement at least some of the methods discussed in the present disclosure. 
       FIG.  32    shows another example of a device according to an embodiment of the disclosure. This device  3200  may include a processor, such as microprocessor  3202 , and a memory  3204 , which are coupled to each other through a bus  3206 . The device  3200  may optionally include a cache  3208  which is coupled to the microprocessor  3202 . This device may also optionally include a display controller and display device  3210  which is coupled to the other components through the bus  3206 . One or more input/output controllers  3212  are also coupled to the bus  3206  to provide an interface for input/output devices  3214  and to provide an interface for one or more sensors  3216  which are for sensing user activity. The bus  3206  may include one or more buses connected to each other through various bridges, controllers, and/or adapters as is well known in the art. The input/output devices  3214  may include a keypad or keyboard or a cursor control device such as a touch input panel. Furthermore, the input/output devices  3214  may include a network interface which is either for a wired network or a wireless network (e.g. an RF transceiver). The sensors  3216  may be any one of the sensors described herein including, for example, a proximity sensor or an ambient light sensor. In at least certain implementations of the device  3200 , the microprocessor  3202  may receive data from one or more sensors  3216  and may perform the analysis of that data in the manner described herein. For example, the data may be analyzed through an artificial intelligence process or in the other ways described herein. As a result of that analysis, the microprocessor  3202  may then automatically cause an adjustment in one or more settings of the device. 
     In certain embodiments of the present disclosure, the device  3200  can be used to implement at least some of the methods discussed in the present disclosure. 
       FIGS.  33 A-C  show another example of a device according to at least certain embodiments of the disclosure.  FIG.  33 A  illustrates a laptop device  3300  with a keyboard  3302 , a body  3304 , a display frame  3306 , and a display  3308 . The laptop device  3300  can be converted into a tablet device as illustrated in  FIG.  33 B  and  FIG.  33 C .  FIG.  33 B  illustrates the conversion of the laptop device into a tablet device. An edge of a display frame  3356  containing a display  3358  is slide within the body  3354  across the top of a keyboard  3352  until forming a tablet device as illustrated in  FIG.  33 C . The tablet device with a display  2362  and a display frame  3366  rests on top of a body  3360 . 
     In certain embodiments of the present disclosure, the laptop device  3300  can be used to implement at least some of the methods discussed in the present disclosure. 
       FIG.  34    illustrates details of an application programming interface in flow chart form according to certain teachings of the present disclosure. The application programming interface operates in an environment with user interface software interacting with a software application. In some embodiments, a hierarchy of views operates on top of a hierarchy of layers within the user interface software. The API operates as illustrated in method  3400  that includes constructing a hierarchy of views operating on top of a hierarchy of layers at block  3402 . The method  3400  further includes providing access to the hierarchy of views without providing access to the hierarchy of layers at block  3404 . An application may interact with the hierarchy of views via the API without accessing the hierarchy of layers operating below the hierarchy of views. 
     In some embodiments, a platform provides various scrolling, gesturing, and animating operations. The platform includes hardware components and an operating system. The hardware components may include a processing unit coupled to an input panel and a memory coupled to the processor. The operating system includes one or more programs that are stored in the memory and configured to be executed by the processing unit. One or more programs include various instructions for transferring function calls or messages through an application programming interface in order to perform various scrolling, gesturing, and animating operations. 
     In an embodiment, the one or more programs include instructions for transferring a scaling transform call through an API to determine a scaling transform for a view associated with a user input having a plurality of input points. In an embodiment, the one or more programs include instructions for transferring a rubberband call through an API to determine a rotation transform for a view associated with a user input having a plurality of input points. 
     In some embodiments, the platform includes a framework containing a library of software code. The framework interacts with the programs of the platform to provide application programming interfaces for performing various scrolling, gesturing, and animating operations. The framework also includes associated resources (e.g., images, text, etc.) that are stored in a single directory. 
     In an embodiment, the library of the framework provides an API for specifying a scaling transform for a view associated with a user input having a plurality of input points. In an embodiment, the library of the framework provides an API for specifying a scaling transform for a view associated with a user input having a plurality of input points. 
     In the foregoing specification, the disclosure has been described with reference to specific exemplary embodiments thereof. It will be evident that various modifications may be made thereto without departing from the broader spirit and scope of the disclosure as set forth in the following claims. The specification and drawings are, accordingly, to be regarded in an illustrative sense rather than a restrictive sense. 
     
       
         
           
               
             
               
                 APPENDIX A 
               
               
                   
               
               
                 API SOFTWARE CODE 
               
               
                   
               
             
            
               
                   
               
            
           
           
               
               
            
               
                  1 
                 − (AffineTransform)transform; 
               
            
           
           
               
               
               
               
            
               
                  2 
                 − (void)setTransform:(AffineTransform)transform: 
                 // 
                 animatable 
               
            
           
           
               
               
            
               
                  3 
                   
               
               
                  4 
                 @interface UIView(Animation) 
               
               
                  5 
               
            
           
           
               
               
               
               
            
               
                  6 
                 + (void)beginAnimation: (String*)animationIDS; 
                 // 
                 animationID can be nil if 
               
            
           
           
               
               
            
               
                  7 
                 you don&#39;t want to have an identifer for the group 
               
               
                  8 
                 + (void)beginAnimations: (String*)animationID context: (void*) context // additional 
               
               
                  9 
                 context info passed to will start/did stop selectors 
               
               
                  10 
                 +(void)endAnimations; 
               
               
                  11 
               
               
                  12 
                 +(void)setAnimationDelegate:(id)delegate; 
               
               
                  13 
                 +(void)setAnimationDuration:(TimeInterval)duration; 
               
               
                  14 
                 +(void)setAnimationDelay:(TimeInterval)delay; 
               
               
                  15 
                 +(void)setAnimationStartTime:(AbsoluteTime)start; 
               
               
                  16 
                 +(void)setAnimationCurve:(UIViewAnimationCurve)curve; 
               
               
                  17 
               
               
                  18 
                 − (BOOL)handleEvent: (Event)event; 
               
               
                  19 
               
               
                  20 
                 // this is called if the app is going to be suspending back to a previous 
               
               
                  21 
                 application. 
               
               
                  22 
                 // the app should return YES if it is going to perform animation, otherwise it should 
               
               
                  23 
                 // return NO. The startTime argument is a start time for any animations to begin so that 
               
               
                  24 
                 // the animations are synchronized with a window server. If the application&#39;s implementation 
               
               
                  25 
                 // of this method returns YES, it should later call [UIApp 
               
               
                  26 
                 suspendWith ANimation:NO] when 
               
               
                  27 
                 // it is finished animating. 
               
               
                  28 
                 (BOOL)animateSuspensionReturningToLastApp:AbsoluteTime)startTime; 
               
               
                  29 
               
               
                  30 
                 // Set the status bar mode, orientation over duration. If processSynchID is non-zero, 
               
               
                  31 
                 used as sync ID. 
               
               
                  32 
                 − (void) setStatusBarMode: (UIStatusBarMode) mode 
               
               
                  33 
                 orientation: (UIStatusBarOrientation) orientation duration:(float)duration 
               
               
                  34 
                 processSynchID: (int)processSynchID; 
               
               
                  35 
                 // Sets the status bar mode. 0 duration means no animation 
               
               
                  36 
                 − (void) setStatusBarMode: (UIStatusBarMode)mode 
               
               
                  37 
                 orientation: (UIStatusBarOrientation)orientation duration: (float)duration; 
               
               
                  38 
                 − (void) setStatusBarMode: (UIStatusBarMode)mode duration:(float)duration; // 
               
               
                  39 
                 uses the default orientation. 
               
               
                  40 
                 − (UIStatusBarOrientation) statusBarOrientation; 
               
               
                  41 
                 − (UIStatusBarOrientation) statusBarMode; 
               
               
                  42 
                 // Status bar rect in non-rotated window coordinates. 
               
               
                  43 
               
               
                  44 
                 − (void) synchronizedDrawingWithID: (int)processSynchID; // used for status bar 
               
               
                  45 
                 resize 
               
               
                  46 
                 // ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   
               
               
                  47 
                 // Gesture delegate method. event will be nil if gesture was not event-driven (ie 
               
               
                  48 
                 programatically or animation). 
               
               
                  49 
                 @interface Object(UIViewGestureDelegate) 
               
               
                  50 
               
               
                  51 
                 − (void)willStartGestures: (UIView *)view forEvent: (GSEvent)event; 
               
               
                  52 
               
               
                  53 
                 − (void)didFinishGestures: (UIView *)view forEvent: (Event)event; 
               
               
                  54 
               
               
                  55 
                 − (void)willStartGesture: (UIGestureType)type inView: (UIView *) view 
               
               
                  56 
                 forEvent: (Event)event; 
               
               
                  57 
               
               
                  58 
                 − (void)gestureDidChange: (UIGestureType)type inView: (UIView *) view 
               
               
                  59 
                 forEvent: (Event)event; 
               
               
                  60 
               
               
                  61 
                 − (void)didFinishGesture: (UIGestureType)type inView: (UIView *) view 
               
               
                  62 
                 forEvent: (Event)event; 
               
               
                  63 
                 @end 
               
               
                  64 
               
               
                  65 
                 UIGestureAttributeZooms // Number (BOOL) 
               
               
                  66 
               
               
                  67 
                 typedef enum { 
               
            
           
           
               
               
               
               
            
               
                  68 
                  UIScrollerEventModeInterceptOnDrag, 
                 // 
                 send mouseDown / mouseUp to 
               
            
           
           
               
               
            
               
                  69 
                 subviews if not dragged 
               
            
           
           
               
               
               
               
            
               
                  70 
                  UIScrollerEventModePass, 
                 // 
                  send 
               
            
           
           
               
               
            
               
                  71 
                 mouseDown/mouseDrag/mouseUp to subviews 
               
            
           
           
               
               
               
               
            
               
                  72 
                  UIScrollerEventModeIntercept, 
                 // 
                  send mouseDown / mouseUp to subviews 
               
            
           
           
               
               
            
               
                  73 
                 } UIScrollerEventMode; 
               
               
                  74 
                 − (void)setEventMode:(UIScrollerEventMode)mode; 
               
               
                  75 
               
               
                  76 
                 − (void)setDirectionalScrolling:(BOOL)flag; 
               
               
                  77 
               
               
                  78 
                 − (void)setDirectionalScrollingAngle:(float)flag; 
               
               
                  79 
               
               
                  80 
                 − (void)setScrollDecelerationFactor:(float)factor; 
               
               
                  81 
               
               
                  82 
                 − (void)setBounces:(BOOL)bounces; 
               
               
                  83 
               
               
                  84 
                 − (void)setThumbDetectionEnabled:(BOOL)flag; 
               
               
                  85 
               
               
                  86 
                 − (void)setShowScrollerIndicators:(BOOL)flag; 
               
               
                  87 
               
               
                  88 
                 − (void)setScrollerIndicator:(Rect)rect; 
               
               
                  89 
               
               
                  90 
                 − (void)setScrollerIndicatorsPinToContent:(BOOL)flag; 
               
               
                  91 
               
            
           
           
               
               
               
            
               
                  92 
                 − (void)setAllowsRubberBanding:(BOOL)flag; 
                 // Call setRubberBand:forEdges: 
               
            
           
           
               
               
            
               
                  93 
                 with RUBBER_BAND_HEIGHT for the top and bottom edges 
               
               
                  94 
               
            
           
           
               
               
               
            
               
                  95 
                 − (void)setAllowsFourWayRubberBanding:(BOOL)flag; 
                 // Calls 
               
            
           
           
               
               
            
               
                  96 
                 setRubberBand: for Edges: with RUBBER_BAND_HEIGHT for all edges 
               
               
                  97 
               
            
           
           
               
               
               
            
               
                  98 
                 − (void)setRubberBand: (float) value for Edges: 
                 (UIRectEdge) edges: // Default 
               
            
           
           
               
               
            
               
                  99 
                 set for top and bottom edges 
               
               
                 100 
               
               
                 101 
                 − (void)contentMouseUpInView:(UIView*)mouseUpView 
               
            
           
           
               
               
               
            
               
                 102 
                 withEvent:(Event)event; 
                 // default calls -mouseUp; on view 
               
            
           
           
               
               
            
               
                 103 
                   
               
               
                 104 
                 − (Point)scroller:(UIScroller *)scroller 
               
               
                 105 
                 adjustSmoothScrollEnd:(Point)offset velocity:(Size)velocity; 
               
               
                 106 
               
               
                 107 
                 @interfacebject (UIAnimationDelegate) 
               
               
                 108 
                 −(void)animator: (UIAnimator*)animator 
               
               
                 109 
                 startAnimation:(UIAnimation*)animation; 
               
               
                 110 
                 −(void)animator: (UIAnimator*)animator 
               
               
                 111 
                 stopAnimation:(UIAnimation*)animation; 
               
               
                 112 
                 −(void)animator: (UIAnimator*)animator stopAnimation: (UIAnimation*)animation 
               
               
                 113 
                 fraction: (float) fraction; 
               
               
                 114 
                 @end 
               
               
                 115 
                 // ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   
               
            
           
           
               
               
               
               
            
               
                 116 
                 @ interface UITransformAnimation 
                 : 
                 UIAnimation { 
               
            
           
           
               
               
            
               
                 117 
                  @ protected 
               
            
           
           
               
               
               
               
            
               
                 118 
                   
                 AffineTransform 
                 _startTransform; 
               
               
                 119 
                   
                 AffineTransform 
                 _endTransform; 
               
            
           
           
               
               
            
               
                 120 
                 } 
               
               
                 121 
                 −(void)setStartTransform: (AffineTransform)start; 
               
               
                 122 
                 −(void)setEndTransform: (AffineTransform)end; 
               
               
                 123 
                 − (AffineTransform)transformForFraction: (float) fraction; 
               
               
                 124 
                 @end 
               
               
                 125 
                 // ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   ——   
               
            
           
           
               
               
               
               
            
               
                 126 
                 @ interface UIFrameAnimation 
                 : 
                 UIAnimation { 
               
            
           
           
               
               
               
            
               
                 127 
                   
                 Rect _startFrame; 
               
               
                 128 
                   
                 Rect _endFrame; 
               
            
           
           
               
               
            
               
                 129 
                 UIRectFields _fieldsToChange; 
               
               
                 130 
                 } 
               
               
                 131 
                 − (void) setStartFrame: (Rect)start; 
               
               
                 132 
                 − (void) setEndFrame: (Rect)end; 
               
               
                 133 
                 − (void) setSignificantRectFields: (UIRectFields)fields; 
               
               
                 134 
               
               
                 135 
                 −(Rect)endFrame; 
               
               
                 136 
               
               
                 137 
                 @end 
               
               
                 138 
               
            
           
           
               
               
               
            
               
                 139 
                 @interface UIAlphaAnimation : UIAnimation 
                 { 
               
            
           
           
               
               
            
               
                 140 
                  @protected 
               
            
           
           
               
               
               
               
            
               
                 141 
                   
                 float 
                 _startAlpha; 
               
               
                 142 
                   
                 float 
                 _endAlpha; 
               
            
           
           
               
               
            
               
                 143 
                 } 
               
               
                 144 
                 − (void)setStartAlpha: (float)start; 
               
               
                 145 
                 − (void)setEndAlpha: (float)end; 
               
               
                 146 
                 − (void)alphaForFraction: (float)fraction; 
               
               
                 147 
               
               
                 148 
                 @end 
               
               
                 149 
               
            
           
           
               
               
               
               
               
            
               
                 150 
                 @interface UIRotationAnimation 
                 : 
                 UIAnimation 
                  { 
               
            
           
           
               
               
               
            
               
                 151 
                  float 
                 _startAngle; 
               
               
                 152 
                  float 
                 _endAngle; 
               
            
           
           
               
               
            
               
                 153 
                 − (void)setStartRotationAngle: (float)degrees; 
               
               
                 154 
                 − (void)setEndRotationAngle: (float) degrees;

Metadata:
Filing Date: 20220915
Publication Date: 20240409
Grant Date: 20240409
Priority Date: 20070107
Inventors: BLUMENBERG, CHRISTOPHER
Assignee: APPLE INC
CPC Classifications: [{"code": "G06F3/0488", "inventive": true, "first": true, "tree": "[]"}, {"code": "G06F3/0481", "inventive": true, "first": false, "tree": "[]"}, {"code": "G06F3/04845", "inventive": true, "first": false, "tree": "[]"}, {"code": "G06F3/0485", "inventive": true, "first": false, "tree": "[]"}, {"code": "G06F3/04883", "inventive": true, "first": false, "tree": "[]"}, {"code": "G06F9/451", "inventive": true, "first": false, "tree": "[]"}, {"code": "G06T13/80", "inventive": true, "first": false, "tree": "[]"}, {"code": "G06F2203/04104", "inventive": false, "first": false, "tree": "[]"}, {"code": "G06F2203/04105", "inventive": false, "first": false, "tree": "[]"}, {"code": "G06F2203/04806", "inventive": false, "first": false, "tree": "[]"}, {"code": "G06F3/0488", "inventive": true, "first": true, "tree": "[]"}, {"code": "G06F3/0488", "inventive": true, "first": true, "tree": "[]"}, {"code": "G06F3/04845", "inventive": true, "first": false, "tree": "[]"}, {"code": "G06F2203/04806", "inventive": false, "first": false, "tree": "[]"}, {"code": "G06F9/451", "inventive": true, "first": false, "tree": "[]"}, {"code": "G06F3/04883", "inventive": true, "first": false, "tree": "[]"}, {"code": "G06F3/04845", "inventive": true, "first": false, "tree": "[]"}, {"code": "G06F2203/04806", "inventive": false, "first": false, "tree": "[]"}, {"code": "G06F9/451", "inventive": true, "first": false, "tree": "[]"}, {"code": "G06F3/04883", "inventive": true, "first": false, "tree": "[]"}, {"code": "G06F3/0481", "inventive": true, "first": false, "tree": "[]"}, {"code": "G06F3/0485", "inventive": true, "first": false, "tree": "[]"}, {"code": "G06F2203/04104", "inventive": false, "first": false, "tree": "[]"}, {"code": "G06F2203/04105", "inventive": false, "first": false, "tree": "[]"}, {"code": "G06T13/80", "inventive": true, "first": false, "tree": "[]"}]
Family ID: 39272573