Microsoft Technology Licensing, LLC

Martyn S Lovell

Christopher G Kaler

Elliot H Omiya

Mahesh Prakriya

Stephen C Rowe

Michael Grier

Tassaduq Basu

Steven J Kruy

Wei Zeng

Oliver J Sharp

Lawrence William Osterman

Robert Albert Wlodarczyk

Michael Aksionkin

William J Ferguson

Shakeel Solkar

Neeraj Wadhwa

Jerry Jay Dunietz

Robert S Wahbe

Ales Holecek

Brent Rector

Paul J Kwiatkowski

Bradley Bartz

Harold L Pierson, Iii

Patrick Henri Dussud

Steven E Lucco

Raja Krishnaswamy

Noel Richard Cross

James F Springfield

Shawn A Van Ness

Nikhil Dang

Harold Pierson

Robert J Jarrett

Steve Seixeiro

Benjamin C Constable

Gary Scot Henderson

Sankhyayan Debnath

Derek Edward Hoiem

Yevgeniy Eugene Rozenfeld

Kenneth D Hardy

Billie Sue Chafins

Paul Stephen Gildea

Jay Turney

Peter W Wilson

Robert S Wabbe

Tassaduq H Basu

Steven Edward Lucco

Brent E Rector

Lawrence W Osterman

Various embodiments provide an ability to describe, independent of a programming language, one or more interfaces associated with an operating system. Alternately or additionally, a compiler associated with a specific programming language can be configured to map the independent interface description(s) to the specific programming language. In some embodiments, an application can be configured to programmatically determine one or more interfaces of the operating system.

Runtime system

Information about the operating system application programming interfaces is stored in a known format in a known location. This information fully describes the APIs exposed by the operating system and is stored in API metadata files. A language compiler or interpreter uses this API information to build a natural and familiar representation of the native system API in the target language. The language compiler or interpreter can read the API information at compile time and/or runtime. The metadata is used to allow an application to refer to named elements in the API. Projections are built that use the metadata to map named elements in the API to named elements in the target language, and to define wrappers that marshal data of those elements between the target representation and the native operating system representation.

Projecting native application programming interfaces of an operating system into other programming languages

Various embodiments provide an ability to abstract type resolution between multiple type systems. At least one type can be described in one or more programmatically accessible file(s). In some embodiments, an application using a different type system can programmatically access and resolve a type of the at least one type system without knowledge of a location of where a description of the type resides. Alternately or additionally, type descriptions contained in the one or more programmatically accessible file(s) can be analyzed and restructured into one or more new programmatically accessible file(s) based, at least in part, upon the type descriptions.

Flexible metadata composition

Many computer applications involve event driven programming. Unfortunately, it may be burdensome on application developers to develop event handlers in unmanaged code for all relevant events within their computer application. For example, when using COM objects in connection with event handling, the burden of lifetime management may be placed on the application developer. Accordingly, one or more systems and/or techniques for event handling in unmanaged code are disclosed herein. A delegate comprising a first interface and a second interface is provided. The delegate may receive event data from a software platform connected to the first interface and may notify a function of a process connected to the second interface. The delegate self destructs when both the computing platform and the process have released their connections to the respective interfaces, thus mitigating manual coding of lifetime management functionality within the process.

Event handling for unmanaged code

Many computer applications incorporate and support animation (e.g., interactive user interfaces). Unfortunately, it may be challenging for computer applications and rendering systems to render animation frames at a smooth and consistent rate while conserving system resources. Accordingly, a technique for controlling animation rendering frame rate of an application is disclosed herein. An animation rendering update interval of an animation timer may be adjusted based upon a rendering system state (e.g., a rate of compositing visual layouts from animation frames) of a rendering system and/or an application state (e.g., a rate at which an application renders frames) of an application. Adjusting the animation rendering update interval allows the animation timer to adjust the frequency of performing rendering callback notifications (work requests to an application to render animation frames) to an application based upon rendering system performance and application performance.

Controlling animation frame rate of applications

Various embodiments provide techniques and processes for defining elements of a user interface (UI) using a tree of objects created based on a markup language. In some embodiments, a client application provides markup that defines one or more aspects of a UI to an application programming interface (API). The API parses the markup to determine a namespace and one or more UI elements defined by the namespace. Instances of the UI elements are created, and properties of the UI elements are set on the instances. A user interface may then be displayed that includes the instances of the UI elements.

Object model for a user interface

A software-development system or versioning system has a collection of modules for performing individual development functions such as document editing, keyword processing, and private-copy management. Each module has an interface compatible with that of the others, so that modules can be added to or substituted for the original modules, if the new modules conform to the interface. The architecture of this system supports the performance of development actions such as document merging and keyword expansion at any location within the system. The system operates upon documents and files as objects in an object space, rather than in name spaces.

Extensible architecture for project development systems

A unified user interface includes one or more component tables and a master table. The one or more component tables include resource information for the user interface with respect to a particular component. The master table includes resource information for the application and is merged from the one or more component tables. The component tables may be added or subtracted at any time and the master table is recreated by again merging the remaining or now existing component tables. The master table is used by a host application to build the user interface for a suite application. Components are only loaded and corresponding user interfaces built when appropriate commands are accessed. Thus, applications may be developed and components can be added or modified at a later time without rewriting the shell application or re-releasing a product.

Method and apparatus for a unified user interface

A configuration management system creates () each configuration by assigning a configuration identifier to each configuration. In addition, relational information is computed () that indicates the relationships between the configuration and any configurations upon which it is based. The system then tracks () changes to files of the configuration by storing information associating each new file version with the configuration identifier. The system also tracks () changes to file properties. A configuration is then reconstructed () as of a desired date, by identifying () the file versions and properties associated with that configuration as of the desired date. A determination is made () whether a user that has requested the file versions has access privileges by first checking a security cache () for the user privileges information. If the information is not on the cache, it is computed from a security table () and stored on the cache. The system automatically compresses () and reconstitutes () file versions that are stored in the version store.

Project-based configuration management method and apparatus

In an integrated development environment, there is a tight coupling between a design surface providing a visual representation of the various physical and logical entities in a software model and the underlying code structures that support the entities. The model can include varying combinations of a component model, a high level design whiteboard, or a physical model. Every object defined within the design surface is capable of being mapped directly to an underlying code structure. The model is a graphical representation of the actual code, thus providing two way updating, i.e., the model is updated when the programmer changes the code and vice versa.

Visual programming environment providing synchronization between source code and graphical component objects

Growing community of inventors

Seattle, WA, United States of America

Martyn S Lovell