Microsoft Technology Licensing, LLC

Jerry Jay Dunietz

Oliver H Foehr

David Ornstein

Andrey Shur

Daniel Emerson

Sarjana Sheth

Josh Pollock

Jesse D McGatha

Ahmet Gurcan

Jean Paoli

Bruce A MacKenzie

Mike Hillberg

Brian M Jones

Khaled Salah Sedky

Wei Zhu

Ming Gang Liu

Sriram Subramanian

Eric Stanfield Leese

Joe King

Rodrigo Lopez

Martyn S Lovell

Mahesh Prakriya

Elliot H Omiya

Stephen C Rowe

Ales Holecek

Tassaduq Basu

Brent Rector

Young Gah Kim

Robert A Relyea

David C Brown

Mikhail V Leonov

Jason Hills

Wei Zeng

Patrick Henri Dussud

Steven E Lucco

Raja Krishnaswamy

Michael John Hillberg

John L Beezer

Joseph Ternasky

Lawrence William Osterman

Charles P Jazdzewski

David M Silver

Robert Albert Wlodarczyk

Joshua Michael Pollock

Isaac E Nichols

Noel Richard Cross

Michael Aksionkin

James F Springfield

Jean-Marie H Larcheveque

Shakeel Solkar

Neeraj Wadhwa

Justin A Slone

Jeffrey G Brown

Arindam Basak

Harold Pierson

Leroy B Keely

Robert Andrew Little

Joseph Spencer King

Marco A Demello

Michael J Duggan

William Hill

Greg D Schechter

Charles Patrick Thacker

Nathan T Lewis

Andrew Layman

Geraldine G Wade

Christopher L Anderson

Christopher Lee Fraley

Christopher A Zimmerman

Arthur Charles Leonard

Vikram Madan

Charles Scott Walker

Harvinder Pal Singh

Zhenbin Xu

Gunnar Mein

Kirk Shoop

Feng Yuan

Anthony L Willie

Kevin J Boske

Simon J Daniels

Rob Relyea

Jason D Farnsworth

Alexei Vopilov

Charels S Walker

Matthew E Loar

Igor Belianski

Tassaduq H Basu

Steven Edward Lucco

Brent E Rector

Lawrence W Osterman

Daniel F Microsoft Corporation Emerson

Bruce Allan Mackenzie

Jean D Paoli

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

Various embodiments provide an ability to load documents and access page content associated with documents while the documents are still being loaded. In at least some embodiments, while a document's structure is being processed in the background, individual pages can be requested. The same can be said for individual documents that comprise a part of a package that contains multiple documents. In at least some embodiments, multiple threads are utilized to enable a document's structure to be built and to enable a user to access portions of the document while the document is being built or loaded.

Progressive page loading

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

This document describes tools capable of validating and enabling validation of a package's structure. To do so, constraint grammar is provided that is capable of enabling a person to build a set of machine-readable constraints for a package's structure. Based on this set of constraints, a package validator module may accurately and automatically validate that a package's structure meets these constraints.

Validating and enabling validation of package structures

Modular content framework and document format methods and systems are described. The described framework and format define a set of building blocks for composing, packaging, distributing, and rendering document-centered content. These building blocks define a platform-independent framework for document formats that enable software and hardware systems to generate, exchange, and display documents reliably and consistently. The framework and format have been designed in a flexible and extensible fashion. In addition to this general framework and format, a particular format, known as the reach package format, is defined using the general framework. The reach package format is a format for storing paginated documents. The contents of a reach package can be displayed or printed with full fidelity among devices and applications in a wide range of environments and across a wide range of scenarios.

Method and apparatus for document processing

Various embodiments can be used to process packages or documents that contain markup language describing one or more documents. Markup language descriptions can be processed to identify certain objects that reoccur or are repeated in the markup language description. If a re-occurring or repeating object is encountered in the markup language description, a resource dictionary can be used to catalog such objects and, an associated object model can include, from the resource dictionary, references to a re-occurring or repeating object. By using the resource dictionary as such, memory resources can be conserved when an in-memory representation of the object model is built.

Load-time memory optimization

A relationship data structure associated with a source resource enables methods to discover and describe relationships between the source resource and a plurality of target resources. The relationships are stored in a format independent of the encoding of the source resource. Each relationship between the source resource and the plurality of target resources is stored in a content-neutral format, and the relationship data structure stores, a location of each target resource, a type of relationship with each target resource and an identifier to uniquely identify each relationship between the source resource and each target resource. Accordingly, the relationship data structure allows a decoder to directly discover the relationships between the source resource and the plurality of target resources without decoding the source resource or target resources.

Efficiently describing relationships between resources

Packages that contain pre-paginated documents

Content is described having native and export portions. In an implementation, one or more computer-readable media includes instructions that are executable on a computing device to store content in a content container as a native portion and an export portion. The native portion is native to an application that originated the content and the export portion is to provide a published view of the content when the native portion is not supported.

Content having native and export portions

Semantic objects are created that provide a structure for markup language representations of documents. The semantic objects include text runs that are produced from the markup language representation and that are placed into semantic blocks that group text runs according to how text is logically structured in the document being represented. The text runs of each semantic block are ordered to correspond to the logical order of the document being represented. The semantic blocks corresponding to each page of the document being represented are ordered to correspond to the logical order of the document being represented. The ordered semantic blocks including the ordered text runs are saved as a semantic object which can they be utilized to make use of the logical structure of the document being represented by the markup language.

Creation of semantic objects for providing logical structure to markup language representations of documents

Various technologies and techniques detect lists in vector graphics based documents and use them in meaningful ways. The system detects at least one list in a vector graphics based document using a set of rules. Pattern detection logic identifies characters, symbols, numbers, letters, and/or images that may start a list. Additional pattern detection logic determines if a list exists. The system can identify and parse bulleted lists, numbered or lettered lists, and nested lists that are any combination of both. Once identified, the content is translated into a modified format. The content can be output to a destination application in the modified format that is more suitable for output or use by the destination application.

Detection of lists in vector graphics documents

Method and apparatus for maintaining relationships between parts in a package

A markup language document, such as an e-book, having a general format is converted into a simplified hierarchy of linked files. During this process, the file is pre-computed and encoded to accelerate run-time search operations and to minimize the computational requirements for run-time parsing and other forms of processing. The resulting e-book content is organized in a simplified file format hierarchy. The e-book file format hierarchy includes a root directory containing all of the files for a particular e-book. The root directory contains a content subdirectory linked to the root directory. The content subdirectory has nested therein at least one linked content file providing content information relating to the electronic book. The content file is pre-computed and encoded to minimize run-time processing.

Pre-computing and encoding techniques for an electronic document to improve run-time processing

Growing community of inventors

Seattle, WA, United States of America

Jerry Jay Dunietz