Microsoft Technology Licensing, LLC

Jeffrey E Stall

Christopher N Raubacher

Bret P Anderson

Eric Norman Badger

Jonathon Michael Stall

Alex G Snitkovskiy

Gerardo Bermudez

Andrew Douglas Peterson

Anna Marion Pfoertsch

Clinton Edward Rutkas

Gerald P Shea

Evan Russell Koschik

Karina Jennifer Chang

Geoffrey Tyler Trousdale

Minmin Gong

Anthony R Young

Harneet Singh Sidhana

Lindsay Ann Kubasik

Nathan P Pollock

Kelly Marie Renner

Luciano Baretta Mandryk

Simeon John Cran

Mark Aldham

Peter Auerhann Beissinger

Anthony Tunjen Hsieh

Danielle Renee Neuberger

Nick Alexander Eubanks

The present disclosure provides techniques for management of user interface elements based on historical configuration data. Use of historical configuration data to render user interface elements improves usability of graphical user interfaces by maintaining a consistent user experience. The states of user interface objects in a hosting environment are retained as historical configuration data and linked to a hosting environment profile. When the same or similar hosting environment is detected, the user interface elements are rendered based on the historical configuration data. For example, the last positions of windows in a particular monitor topology are stored as historical configuration data linked to that monitor topology. The windows are returned to their previous positions when a computing device is next configured with the same or similar monitor topology.

Management of user interface elements based on historical configuration data

The described embodiments allow for the association of an interaction with a target in a display. One embodiment includes detecting an interaction with an area associated with a graphical element in a display, detecting a later interaction displaced from the area, and associating the later interaction with a target in the display based at least on the time between the interaction with the area and the later interaction. User interactions with one or more displayed hit targets are based on corresponding time-varying hit zones. In response to unlimited user interaction with a hit target, subsequent user selections are validated based on a time-varying hit zone that is typically extended with respect to the previously selected hit target. The extended selection zone can overlap one or more other hit targets to favor re-selection of the individually selected hit target. The extended selection zone generally decreases as a function of time from prior selections of a hit zone.

Distance-time based hit-testing for displayed target graphical elements

Object sets are often organized and traversed in a hierarchical manner according to ownership, wherein a subset of contained objects are processed before or after a containing object that contains the contained objects. Such object sets may also be presented as a scene, which may involve traversing the object set in a drawing order, such as a descending distance order that renders objects in a back-to-front manner. It may be difficult to reconcile these distinct traversal techniques, particularly if different portions of the object set utilize a different traversal order. Presented herein are hybrid traversal techniques in which a selected subset of related objects is identified and traversed in a drawing order, and the remainder of the object set is traversed in an ownership order, in furtherance of various tasks that involve hybrid traversal orders and/or to facilitate the traversal of different types of object subsets within the object set.

Hybrid traversal of object sets

Virtual environments may be presented to a user with an inclusion of one or more applications, but many such techniques for integrating the applications with the virtual environment may exhibit disadvantages. For example, a two-dimensional 'flat' rendering of the application may require a loss of visual depth, and/or may appear inconsistent; an immersive presentation that is mutually exclusive with the presentation of the virtual environment may achieve very limited integration; and a holographic presentation may appear incongruous. Such techniques may also increase presentation latency, with noticeable and significant consequences. Instead, the virtual environment may define an application region, and may notify the application of the application region and a perspective of the user within the virtual environment. The application may present an application view that reflects the perspective of the user, and the virtual environment may present the application view within the application region of the virtual environment.

Presenting applications within virtual environments

A scene may be rendered as objects that are lit by various light sources. A scene designer may arrange the scene to create particular lighting effects when viewed from an initial perspective, such as gloss, translucency, and iridescence, and may choose lighting effects to create a desired aesthetic tone and/or highlighting within the scene. However, rendering the scene from a different perspective may alter the lighting effects (e.g., losing or misplacing desired lighting effects, and/or creating new and undesirable lighting effects, such as glare). Instead, when the scene is rendered from the initial perspective, the lighting effects created therein may be stored with the scene representation of the scene. A second rendering of the scene from a different perspective may reapply the stored lighting effects to the lit objects, thereby maintaining the lighting effects and the intent of the designer in the presentation of the scene from a different perspective.

Preserving scene lighting effects across viewing perspectives

Objects in a computing environment are often utilized by threads through an object lifecycle, and are destroyed at the end of the object lifecycle to reclaim the computing resources used by the object. In some cases, a thread that initiates an object destruction of an object may be unable to complete the destruction (e.g., a second thread may hold a synchronization lock over an object resource of the object). An object destruction workflow initiates the destruction of an object on behalf of a thread. If the object destruction workflow encounters a failure to complete the object destruction, a new reference to the object is inserted into an object destruction list, as the last reference to the object. A second thread discovers and releases the last reference in the object destruction list, prompting the object destruction workflow to resume the attempt to destroy the object on behalf of the second thread.

Workflow-based object destruction

Animations are displayed on a user interface (UI) of a computing device using one of multiple different animation system modes, each animation system mode operating in a different manner to determine how to change the display for an animation. The animation can be on a particular object that is displayed by the computing device (e.g., scrolling a list, moving an icon or character from one location to another) and/or can be on the display as a whole (e.g., panning or scrolling a view of the whole display). The multi-mode animation system operates to select an animation system mode on a frame by frame basis. For each frame of content being displayed on the display device, the multi-mode animation system selects an appropriate one of the animation system modes to use for generating the content of that frame.

Multi-mode animation system

Interface optimization is provided using a closed system in which all the individual software components in the system are known to the compiler at a single point in time. This knowledge enables significant opportunities to optimize the implementation of interfaces on a set of implemented objects. When code is compiled, because the compiler knows the full list of interfaces and the objects which implement the interfaces, it can improve execution and working set (i.e., recently referenced pages in a program's virtual address space) when implementing the interfaces on objects. This improvement may be realized by reducing the size of interface lookup tables which map each interface to the object types which implement that particular interface.

Interface optimization in a closed system

The present invention extends to methods, systems, and computer program products for simulating stepping through interpreted code. Embodiments of the present invention facilitate debugging interpreted code. Thus, existing debugger technologies (e.g., those configured for use with compiled code) can be utilized to debug interpreted code. More specifically, existing debugger technologies can be used to step through interpreted code, without stepping into the code of interpreter itself. Accordingly, users developing interpreted code can be provided a stepping experience of relatively the same quality provided to developers developing compiled code, without having to reengineer debuggers to compensate for interpreted code.

Simulating stepping through interpreted code

A method and apparatus for adapting and hosting legacy user interface controls is provided. Legacy user interface controls are exposed within a new window manager as native user interface objects. A bridge between a hosted legacy user interface control and the legacy window manager intercepts messages intended for the hosted user interface control. The messages are filtered to determine if they should be passed to the new window manager. If a message is to be forwarded, the message is forwarded to a root Visual Gadget in the new window manager. The message is processed and routed down the window tree to an adapter control for hosting the legacy user interface control. The adapter control processes the message and routes the message to any listener objects attached to the adapter. If the message has not been completely handled, the message is 'bubbled' up the window tree for additional processing.

Method and apparatus for adapting and hosting legacy user interface controls

A method and apparatus is provided for providing and integrating high-performance message queues. 'Contexts' are provided that allow independent worlds to be created and execute in parallel. A context is created with one or more threads. Each object is created with context affinity, allowing any thread inside the context to modify the object or process pending messages. Threads in a different context are unable to modify the object or process pending messages for that context. To help achieve scalability and context affinity, both global and thread-local data is often moved into the context. Remaining global data has independent locks, providing synchronized access for multiple contexts. Each context has multiple message queues to create a priority queue. There are default queues for sent messages and posted messages, carry-overs from legacy window managers, with the ability to add new queues on demand. A queue bridge is also provided for actually processing the messages.

Method and apparatus for providing and integrating high-performance message queues in a user interface environment

A method and apparatus for adapting and hosting legacy user interface controls is provided. Legacy user interface controls are exposed within a new window manager as native user interface objects. A bridge between a hosted legacy user interface control and the legacy window manager intercepts messages intended for the hosted user interface control. The messages are filtered to determine if they should be passed to the new window manager. If a message is to be forwarded, the message is forwarded to a root Visual Gadget in the new window manager. The message is processed and routed down the window tree to an adapter control for hosting the legacy user interface control. The adapter control processes the message and routes the message to any listener objects attached to the adapter. If the message has not been completely handled, the message is 'bubbled' up the window tree to the parent objects of the adapter control for additional processing.

Growing community of inventors

Redmond, WA, United States of America

Jeffrey E Stall