Búsqueda Imágenes Maps Play YouTube Noticias Gmail Drive Más »
Iniciar sesión
Usuarios de lectores de pantalla: deben hacer clic en este enlace para utilizar el modo de accesibilidad. Este modo tiene las mismas funciones esenciales pero funciona mejor con el lector.

Patentes

  1. Búsqueda avanzada de patentes
Número de publicaciónUS6175845 B1
Tipo de publicaciónConcesión
Número de solicitudUS 09/087,778
Fecha de publicación16 Ene 2001
Fecha de presentación29 May 1998
Fecha de prioridad6 Ene 1998
TarifaCaducada
Número de publicación087778, 09087778, US 6175845 B1, US 6175845B1, US-B1-6175845, US6175845 B1, US6175845B1
InventoresAndrew John Smith, David Seager Renshaw
Cesionario originalInternational Business Machines Corporation
Exportar citaBiBTeX, EndNote, RefMan
Enlaces externos: USPTO, Cesión de USPTO, Espacenet
Method and component for presentation of information
US 6175845 B1
Resumen
A method of presenting information via a user interface of a computer system is disclosed. The method is executed by a book component and a renderer component. The book determines page boundaries for pages in which information is to be presented, and communicates the page boundaries to the renderer. The renderer determines a number of pages, constrained by the page boundaries, required to fully render the information, and communicates the number of pages to the book. Responsive to the book providing an input token representing a prominent element of information on a page, the renderer determines a page number for the page containing the element of information represented by the token, and communicates the page number to the book. Responsive to an event requiring the presentation of a page including a prominent element of information, the book communicates the page number to the renderer. The renderer presents the page in a display area and provides an output token to the book representing a prominent element of information on the presented page.
Imágenes(5)
Previous page
Next page
Reclamaciones(9)
What is claimed is:
1. A method of presenting information via a user interface of a computer system, the computer system comprising a book component and a renderer component, comprising the steps of:
said book determining page boundaries for pages in which information is to be presented, and communicating said page boundaries to said renderer;
said renderer determining a number of pages, constrained by said page boundaries, required to fully render said information, and communicating said number of pages to said book;
responsive to said book providing an input token representing a prominent element of information on a page, said renderer determining a current page number for the page containing the element of information represented by said token, and communicating said current page number to said book;
responsive to a reflowing event requiring the presentation of a page including the prominent element of information, said book communicating said current page number to said renderer; and
said renderer presenting said page including the prominent element of information in a display area, wherein the input token ensures the display of the prominent element after said reflowing event.
2. The method as claimed in 1, further comprising the step of said renderer providing an output token to said book representing a prominent element of information on said presented page.
3. The method as claimed in 1, wherein said page boundaries comprise a page size and any restrictive margins on said page.
4. The method as claimed in claim 1, wherein said display area is determined by said book.
5. The method as claimed in 1, further including the step of replacing said input token with said output token.
6. The method as claimed in claim 1, wherein the reflowing event requiring the presentation of the page is a resizing of the display area.
7. The method as claimed in claim 1, wherein the reflowing event requiring the presentation of the page is a change in margins of the display area.
8. A renderer component for a computer system for use in presenting information via a user interface of a computer system, said component comprising:
means adapted to receive page boundaries from a book component;
means responsive to said book component to provide a number of pages required to display said information according to said page boundaries;
means responsive to said book component providing an input token representing a prominent element of information on a page to determine a current page number for the page containing the element of information represented by said token; and
means responsive to said book providing the current page number to present said page containing the prominent element of information in a display area and provide an output token to said book, wherein the input token ensures the display of the prominent element after a reflowing event.
9. A computer program product comprising computer readable program code stored on a computer readable recording medium, the program code comprising a renderer component for use in presenting information via a user interface of a computer system, said renderer component comprising:
means adapted to receive page boundaries from a book component;
means responsive to said book component to provide a number of pages required to display said information according to said page boundaries;
means responsive to said book component providing an input token representing a prominent element of information on a page to determine a current page number for the page containing the element of information represented by said token; and
means responsive to said book providing the current page number to present said page containing the prominent element of information in a display area and provide an output token to said book, wherein the input token ensures the display of the prominent element after a reflowing event.
Descripción
FIELD OF THE INVENTION

The present invention relates to a method and component for presentation of information.

BACKGROUND OF THE INVENTION

Pagination of complex information is not a new concept. Word processors and report generators are just two examples where complex information is formatted to display or print over multiple pages. In existing embodiments, the formatting and display of information elements are managed by the same entity. Technologies such as JavaBeans and ActiveX facilitate the containment and arrangement of arbitrary content, but typically a container must define the containment area and implement the arrangement strategy. Complex containers that deal with multi-page presentation are possible, but may need to be extended or re-implemented to deal with new forms of content.

DISCLOSURE OF THE INVENTION

The invention provides a method of presenting information via a user interface of a computer system, the computer system comprising a book component and a renderer component, comprising the steps of: said book determining page boundaries for pages in which information is to be presented, and communicating said page boundaries to said renderer; said renderer determining a number of pages, constrained by said page boundaries, required to fully render said information, and communicating said number of pages to said book; responsive to said book providing an input token representing a prominent element of information on a page, said renderer determining a page number for the page containing the element of information represented by said token, and communicating said page number to said book; responsive to an event requiring the presentation of a page including a prominent element of information, said book communicating said page number to said renderer; and said renderer presenting said page in a display area.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 illustrates the logical association of major components of a book;

FIG. 2 is an example of HTML content to be rendered;

FIG. 3 shows a logical page layout of the HTML content of FIG. 2, rendered for an initial book page size; and

FIG. 4 is a logical rendition of the HTML content of FIG. 2 for a resized book page.

DESCRIPTION OF THE PREFERRED EMBODIMENT

In the present invention, a component that performs containment of information is referred to as a book, whereas a component that performs presentation of information is referred to as a renderer. The book has responsibility for definition of a page area, control of navigation between pages, and communication of which page to present to an associated but discrete renderer. The renderer has responsibility for formatting of information to fit the page, and presentation of the correct information for any given page on demand.

An embodiment of this invention has been implemented using the Java programming language. The contract between a book and a renderer is described using a Java interface definition. This interface definition is described first, followed by a brief description of how a book and a renderer fulfil their respective obligations.

Renderer Interface

Table 1 shows the Java interface definition whose methods are explained below.

setPageBounds ( ) and setMargins ( ) are called when a book first communicates with a renderer. Thereafter, setPageBounds ( ) is called whenever the book's page display area size is modified; and setMargins ( ) is called if a book's margin definitions are modified.

renderpage ( ) is called, providing a java.awt.Graphics object “g”, and a page number “page” to render, whenever page presentation is required. renderPage ( ) returns a token representing a prominent element of information on the presented page. The token is stored by the book, replacing any previously returned token. The returned token may be used subsequently to obtain a new page number for the prominent element after reflowing has occurred. The Graphics class primarily provides an addressable area for the renderer which in turn is mapped onto an area of the screen. The Graphics class also exposes a number of methods for drawing primitives such as lines and circles etc, and these are used by a renderer that performs its own drawing. The renderer may alternatively use standard buttons or controls etc. to help render the content.

getpages ( ) returns the number of pages required to completely render the information content, taking into account the current page and margin sizes, getpage ( ), on the other hand, returns the page number of the page that contains the given content token. getpage ( ) is used to ensure that the same content is displayed after reflowing, caused by changing a page size or its margins. If the token is not found, zero is returned.

Both getpage and getPages are called whenever the book's page display area size or margin definitions are modified, thus allowing the book to maintain an appropriate navigational page number after the renderer has reflowed information content.

Book Implementation

The page area for display of content within a book is implemented by subclassing the standard java.awt.Component class provided with the Java Development Kit. java.awt.Component provides a mapping between software components and an area of the screen. The Java environment defines interfaces that may be implemented by java classes wishing to monitor instances of java.awt.Component for events such as resizing and other user interactions. The function of java.awt.Component may be extended by classes wishing to intercept requests by the environment to repaint areas of the component.

An extract from an example of such a class extending java.awt.Component, PageArea, is given in Table 2 and illustrated in FIG. 1. PageArea first of all instantiates a new renderer, in this case a HTMLRenderer. PageArea must then override the standard “paint” method for the component in order to call the renderers renderpage method. “paint” will be called by the system whenever the page is to be painted or repainted. The redefined paint method asks the renderer to render the current page contents by calling renderpage. A “layout” method is then defined and is called whenever the size of this component is changed due to book resizing etc. Layout finds out which page the key item that was previously in view of the user is now on, by calling “getPage”, and calls “repaint” which in turn calls the redefined paint method to render the page area at this page.

In the above example it is assumed that the book maintains a reference to the location of information to be presented, local file, URL, etc. and understands which implementation of the Renderer interface is appropriate to format and render that information, “HTMLRenderer”. When a book wishes content to be displayed on its page area(s), an instance of the appropriate Renderer implementation is instantiated and a reference to the information location is passed to it. The renderer's setPageBounds ( ) method is then called to provide the current page display area dimensions. If a book has restrictive margins defined, then the renderer's setMargins ( ) method is also called. Following this, the renderer's getpages ( ) method is called and the returned number of pages stored. This allows the book to understand the limits of pagination for this particular renderer at the current page and margin sizes. Typically, the book then renders the first page of the content by requesting a repaint of the java.awt.Component which represents the page area. The paint ( ) method of the component representing the page area then calls the renderpage ( ) method of the renderer associated with the page, specifying a page number of one. The token returned is saved for later use.

When user interaction events, such as go to start/end of book or to a specified page, interpreted as page navigation requests by the book are received, the book determines the page number required by the user, and calls the renderer's renderpage ( ) method, passing the java.awt.Graphics object associated with the java.awt.Component object representing the page, to request that the required page of information be presented. The returned token is stored in place of any previously stored token. The book does not need to understand or interpret this token, it merely needs to store it for possible subsequent delivery to the renderer's getPage ( ) method.

When user interaction events interpreted as page size or margin definition modifications by the book are received, the book passes on the modified information to the renderer using its setPageBounds ( ) and/or setMargins ( ) methods. It then obtains the number of pages of the new size that the renderer would require to completely present all of its information using the renderer's getpages ( ) method. The book then requests, from the renderer, the page number of the page on which the information element represented by the last stored token would be rendered. This page number is used by the book to reset its internal page location. Finally, the book asks the renderer to render the information for the new current page.

Renderer Implementation

In a preferred embodiment the Renderer understands, and can format and present, HTML (hyper-text mark-up language) information. Such an implementation takes the reference to the information location provided by the book and reads the information. The information read is parsed according to the rules of the HTML specification to extract the information formatting clues provided by HTML tags. When the structure of the information has been ascertained the renderer builds formatting information, font size, type style, etc. to allow the information to be rendered in the space defined by the book via the Renderer interface setPageBounds ( ) and setMargins ( ) calls. In building the formatting information the renderer computes and stores details of the logical page boundaries. Using this page boundary information, the renderer is able to supply information when called via the getPages ( ) and getPage ( ) methods.

The renderer implementation, in parsing the HTML stream, must analyse the data in some detail. Account must be made for the varying types of content within the HTML stream i.e. images, Java applets, etc. and the text flow and alignment in order to assess the space required to render the content. In order to conform to a book model the renderer must position the various elements in order to maintain a consistent view avoiding incomplete images at the foot of a page for example.

To calculate the number of pages required to present an HTML stream, the renderer first logically renders the stream to a page of infinite length but whose boundaries are as defined by the setPageBounds ( ) and setMargins ( ) calls. To accomplish this, the implementation subdivides the available page space into rectangles which contain either a line of text, an image, an applet or some other HTML defined entity. The rectangles are laid out according to the alignment specification defined by the HTML stream with text flowing as required and/or specified. Having laid the data out the renderer can now subdivide the layout in order to create pages of the required length adjusting the layout to avoid page breaks within images etc. Having subdivided the layout the renderer now knows the total number of pages and the identity of the rectangular element at the top of each page. The renderer assigns a token value to the item at the top of each page which is passed to the book on a renderpage ( ) call.

The identifying token is passed by the book to the renderer on a getPage ( ) call to find out the numeric page number on which the item exists. This usually happens after the book has changed it's page shape characteristics (size or margins) and allows the book to request rendering of the page containing the item and thus avoid presenting the wrong information to the user after the page has been resized.

Consider the following example. The book requests the renderer to render page 6 of it's content, due to user pagination requests or some other interaction. The renderer renders the requested page and returns a token, identifying the content element at the top of page 6, a heading perhaps. The user of the book resizes it making the displayed page area larger. The book informs the renderer of the change of page format using a setPageBoundaries ( ) call causing the renderer to recalculate it's formatting data. The book then requests the number of the page that now contains the content item formerly at the top of page 6 using a getpage ( ) call specifying the previously returned token. The renderer uses the token to identify the content element, the heading, and returns the page number of the page it now resides on. The book then requests the renderer to render the returned page number thus ensuring the content the user was seeing before the resize is still visible.

The renderer need only parse the HTML information stream once but may have to compute the page boundary and formatting information multiple times. Whenever the book calls the setPageBoundaries ( ) or setMargins ( ) methods, indicating that the display area has changed size or characteristics, the formatting and boundary information must be recalculated.

Consider the example of HTML content shown in FIG. 2. The HTML is presented as a stream of data to an HTML renderer implementation running within a book. The book has a set page size and margins and thus the renderer parses the HTML stream and logically renders the HTML to a page of the correct width and of infinite length. Having completed this operation the renderer may now locate the logical page boundaries necessary to permit the content to be reasonably presented. The renderer now knows where each page begins and the total number of pages required to render the whole of the content.

The book requests the rendering of a particular page, for instance page 2, in response to some user interaction such as scrolling. In response the renderer returns a token which allows it to identify some piece of content on the page it has just rendered. In the example this token might identify the second level heading “Rendering Information”, FIG. 3. The book does not need to understand the format of the content or what it identifies.

The first logical page break occurs just prior to the second level heading “Rendering Information”, determined by the width of the page and any in-built rules of the renderer such as avoiding widowed headings.

If the user now resizes the book such that the page width is increased the book notifies it's page renderers. In response the renderers must again logically render the content to discover the layout of each page and the total number of pages. The book then presents the token it received earlier to the renderer via the getPage ( ) method to find out which page the content item represented by the token now exists on.

FIG. 4 shows the logical page layout for the new book page size and we can see the second level heading resides on page one. Thus the render returns “1” on the getpage ( ) request. The book then requests the renderer to render page 1 and thus the second level heading remains visible to the user even after the book has been resized.

The renderer may use any number of strategies for predicting what is the most notable and thus the item most expected by the user to remain in view. The simplest of these is simply to ensure the item at the top of the page is visible but one can envisage strategies that use images, figures, tables, headings, etc.

It will be seen that other renderer implementations can be provided to render and calculate pagination information for content in any number of formats, for example, ASCII, RTF, Postscript, Bookmaster script etc. Depending on the format of the data the renderer may provide more or less sophisticated mechanisms for determining the key element in view by the user. For simple data streams such as ASCII it may be just a particular word or line whereas for richer content types it may follow the example of the HTML implementation described here.

  public interface Renderer {
  public void setPageBounds(Rectangle pageBounds);
  public void setMargins(int top, int bottom, int
left, int right);
  public int getPages();
  public int getPage(Object token);
  public Object renderPage(Graphics g, int page); }

TABLE 2
Example page area implementation
public class PageArea extends java.awt.Component {
. . .
Object pageToken;
int pages = 1;
int currentPage = ;
Renderer renderer = new HTMLRenderer(this);
. . .
public void paint(Graphics g) {
. . .
pageToken = renderer.renderPage(g, currentPage);
. . .
}
void layout(Rectangle bounds) {
renderer.setPageBounds(bounds);
pages = renderer.getPages();
currentPage = renderer.getPage(pageToken);
repaint();
}
}

Citas de patentes
Patente citada Fecha de presentación Fecha de publicación Solicitante Título
US4709348 *13 Jun 198624 Nov 1987International Business Machines CorporationInteractive page length adjustment with automatic pagination
US4723209 *30 Ago 19842 Feb 1988International Business Machines Corp.Flow attribute for text objects
US4951233 *3 Ago 198821 Ago 1990Hitachi, Ltd.Document producing apparatus having in-document layout display
US4998832 *24 Mar 198912 Mar 1991Brother Kogyo Kabushiki KaishaDocumentation system having page format function
US5140676 *7 May 199018 Ago 1992Oce-Nederland B.V.Desktop publishing system and method of making up documents
US5208905 *22 Oct 19914 May 1993Canon Kabushiki KaishaDocument processing apparatus
US5278952 *1 Feb 199111 Ene 1994Brother Kogyo Kabushiki KaishaDocument processing apparatus having layout display control system
US5623681 *19 Nov 199322 Abr 1997Waverley Holdings, Inc.Method and apparatus for synchronizing, displaying and manipulating text and image documents
US5784487 *23 May 199621 Jul 1998Xerox CorporationSystem for document layout analysis
US5911146 *3 May 19968 Jun 1999Mitsubishi Electric Information Technology Center America, Inc. (Ita)Apparatus and method for automatic yellow pages pagination and layout
Otras citas
Referencia
1 *Gruman, "QuarkXPress versus PageMaker", MacWorld, v14, n12, p. 86(7), ISSN: 0741-8647, Dec. 1997.
2 *Sellers, "UniQorn 1.0 puts new twists on DTP with good GX tools", MacWeek, v10, n18, p. 37(2), ISSN: 0892-8118, May 1996.
3 *Somogyi, "Inside Acrobat Amber: more than PostScript on the Web", Digital Media, v5, n7-8, p. 15(4), ISSN: 1056-7038, Dec. 1995.
4 *Tribute et al, "Dainippon Screen: venerable company heads in a new direction", Seybold Report on Publishing Systems, v22, n14, p. 3(12), ISSN: 0736-7260, May 1993.
Citada por
Patente citante Fecha de presentación Fecha de publicación Solicitante Título
US6694485 *27 Jul 199917 Feb 2004International Business Machines CorporationEnhanced viewing of hypertext markup language file
US670151427 Mar 20002 Mar 2004Accenture LlpSystem, method, and article of manufacture for test maintenance in an automated scripting framework
US6789229 *19 Abr 20007 Sep 2004Microsoft CorporationDocument pagination based on hard breaks and active formatting tags
US690754627 Mar 200014 Jun 2005Accenture LlpLanguage-driven interface for an automated testing framework
US6986101 *6 May 199910 Ene 2006International Business Machines CorporationMethod and apparatus for converting programs and source code files written in a programming language to equivalent markup language files
US7028258 *1 Oct 199911 Abr 2006Microsoft CorporationDynamic pagination of text and resizing of image to fit in a document
US719139028 Mar 200313 Mar 2007Adobe Systems IncorporatedAutomated paragraph layout
US719139628 Mar 200313 Mar 2007Adobe Systems IncorporatedAutomated paragraph layout
US719769522 Dic 200027 Mar 2007Adobe Systems IncorporatedAutomated paragraph layout
US72132032 Mar 20041 May 2007Microsoft CorporationDocument pagination based on hard breaks and active formatting tags
US7350143 *1 Oct 200425 Mar 2008Sandisk CorporationMethod for page translation
US73669827 Sep 200529 Abr 2008Microsoft CorporationPackages that contain pre-paginated documents
US7383500 *30 Abr 20043 Jun 2008Microsoft CorporationMethods and systems for building packages that contain pre-paginated documents
US73835027 Sep 20053 Jun 2008Microsoft CorporationPackages that contain pre-paginated documents
US7412646 *23 Oct 200312 Ago 2008Microsoft CorporationSystems and methods for pagination and co-pagination
US741865230 Abr 200426 Ago 2008Microsoft CorporationMethod and apparatus for interleaving parts of a document
US746433020 Dic 20049 Dic 2008Microsoft CorporationContext-free document portions with alternate formats
US751287830 Abr 200431 Mar 2009Microsoft CorporationModular document format
US7512879 *11 May 200131 Mar 2009Microsoft CorporationIntelligent virtual paging paradigm
US754911830 Abr 200416 Jun 2009Microsoft CorporationMethods and systems for defining documents with selectable and/or sequenceable parts
US758117619 Dic 200225 Ago 2009Eric Cameron WilsonDocument display system and method
US76068197 Oct 200220 Oct 2009Maya-Systems Inc.Multi-dimensional locating system and method
US761400020 Dic 20043 Nov 2009Microsoft CorporationFile formats, methods, and computer program products for representing presentations
US761722920 Dic 200410 Nov 2009Microsoft CorporationManagement and use of data in a computer-generated document
US761744420 Dic 200410 Nov 2009Microsoft CorporationFile formats, methods, and computer program products for representing workbooks
US76174479 Dic 200310 Nov 2009Microsoft CorporationContext free document portions
US761745030 Sep 200410 Nov 2009Microsoft CorporationMethod, system, and computer-readable medium for creating, inserting, and reusing document parts in an electronic document
US76174515 Abr 200610 Nov 2009Microsoft CorporationStructuring data for word processing documents
US762088920 Dic 200417 Nov 2009Microsoft CorporationMethod and system for linking data ranges of a computer-generated document with associated extensible markup language elements
US76732354 Mar 20052 Mar 2010Microsoft CorporationMethod and apparatus for utilizing an object model to manage document parts for use in an electronic document
US768081729 Mar 200716 Mar 2010Maya-Systems Inc.Multi-dimensional locating system and method
US775263221 Dic 20046 Jul 2010Microsoft CorporationMethod and system for exposing nested data in a computer-generated document in a transparent manner
US777018010 May 20063 Ago 2010Microsoft CorporationExposing embedded data in a computer-generated document
US779762421 Mar 200714 Sep 2010Adobe Systems IncorporatedAutomated paragraph layout
US781440819 Abr 200012 Oct 2010Microsoft CorporationPre-computing and encoding techniques for an electronic document to improve run-time processing
US806940413 Sep 200729 Nov 2011Maya-Systems Inc.Method of managing expected documents and system providing same
US807896621 Nov 200713 Dic 2011Maya-Systems Inc.Method and system for managing musical files
US812235021 Mar 200821 Feb 2012Microsoft CorporationPackages that contain pre-paginated documents
US813603020 Feb 200813 Mar 2012Maya-Systems Inc.Method and system for managing music files
US8145996 *30 Jun 200827 Mar 2012Microsoft CorporationSystems and methods for pagination and co-pagination
US81511858 Ene 20083 Abr 2012Maya-Systems Inc.Multimedia interface
US830698224 Ago 20116 Nov 2012Maya-Systems Inc.Method for associating and manipulating documents with an object
US831630627 Mar 200720 Nov 2012Maya-Systems Inc.Method and system for sequentially navigating axes of elements
US860139222 May 20083 Dic 20139224-5489 Quebec Inc.Timeline for presenting information
US860715514 Sep 200910 Dic 20139224-5489 Quebec Inc.Method of managing groups of arrays of documents
US864582618 Ago 20114 Feb 2014Apple Inc.Graphical multidimensional file management system and method
US866133230 Abr 200425 Feb 2014Microsoft CorporationMethod and apparatus for document processing
US87010395 Jul 200815 Abr 20149224-5489 Quebec Inc.Method and system for discriminating axes of user-selectable elements
US87390509 Mar 200927 May 20149224-5489 Quebec Inc.Documents discrimination system and method thereof
US878893721 Nov 200722 Jul 20149224-5489 Quebec Inc.Method and tool for classifying documents to allow a multi-dimensional graphical representation
US882612325 May 20072 Sep 20149224-5489 Quebec Inc.Timescale for presenting information
US889304627 Jun 200918 Nov 2014Apple Inc.Method of managing user-selectable elements in a plurality of directions
US890428119 Ene 20082 Dic 2014Apple Inc.Method and system for managing multi-user user-selectable elements
US89548476 Dic 201110 Feb 2015Apple Inc.Displays of user select icons with an axes-based multimedia interface
US898441720 Jun 201217 Mar 20159224-5489 Quebec Inc.Method of associating attributes with documents
US905809325 Sep 201116 Jun 20159224-5489 Quebec Inc.Active element
US912237425 Sep 20111 Sep 20159224-5489 Quebec Inc.Expandable and collapsible arrays of documents
US918912925 Sep 201117 Nov 20159224-5489 Quebec Inc.Non-homogeneous objects magnification and reduction
US92237578 Feb 200729 Dic 2015Adobe Systems IncorporatedAutomated paragraph layout
US925164327 Dic 20112 Feb 2016Apple Inc.Multimedia interface progression bar
US926238113 Mar 201316 Feb 20169224-5489 Quebec Inc.Array of documents with past, present and future portions thereof
US934880027 Feb 201424 May 20169224-5489 Quebec Inc.Method of managing arrays of documents
US9443441 *29 Oct 201013 Sep 2016Amazon Technologies, Inc.View port resolution independent network pages
US945452924 Nov 201127 Sep 2016Apple Inc.Method of improving a search
US951969314 Mar 201313 Dic 20169224-5489 Quebec Inc.Method and apparatus for displaying data element axes
US952949513 Mar 201327 Dic 20169224-5489 Quebec Inc.Static and dynamic information elements selection
US958864613 Mar 20137 Mar 20179224-5489 Quebec Inc.Selection and operations on axes of computer-readable files and groups of axes thereof
US961316725 Sep 20124 Abr 20179224-5489 Quebec Inc.Method of inserting and removing information elements in ordered information element arrays
US964608015 Mar 20139 May 20179224-5489 Quebec Inc.Multi-functions axis-based interface
US965243814 Abr 201416 May 20179224-5489 Quebec Inc.Method of distinguishing documents
US96904602 May 201427 Jun 20179224-5489 Quebec Inc.Method and apparatus for identifying user-selectable elements having a commonality thereof
US973380117 Jul 201515 Ago 20179224-5489 Quebec Inc.Expandable and collapsible arrays of aligned documents
US20030055851 *22 Dic 200020 Mar 2003Williamson David E.Automated paragraph layout
US20030167448 *28 Mar 20034 Sep 2003Adobe Systems Incorporated, A Delaware CorporationAutomated paragraph layout
US20030192011 *28 Mar 20039 Oct 2003Adobe Systems Incorporated, A Delaware CorporationAutomated paragraph layout
US20040168126 *2 Mar 200426 Ago 2004Microsoft CorporationDocument pagination based on hard breaks and active formatting tags
US20040205623 *11 May 200114 Oct 2004Steven WeilIntelligent virtual paging paradigm
US20050080682 *10 Dic 200214 Abr 2005Eric WilsonSystem for secure distribution of electronic content and collection of fees
US20050091585 *23 Oct 200328 Abr 2005Microsoft CorporationSystems and methods for pagination and co-pagination
US20050097458 *19 Dic 20025 May 2005Eric WilsonDocument display system and method
US20050138551 *1 Oct 200423 Jun 2005Gidon ElazarMethod for page translation
US20050149861 *20 Dic 20047 Jul 2005Microsoft CorporationContext-free document portions with alternate formats
US20050235293 *14 Abr 200420 Oct 2005Microsoft CorporationMethods and systems for framework layout editing operations
US20050251735 *30 Abr 200410 Nov 2005Microsoft CorporationMethod and apparatus for document processing
US20050251739 *30 Abr 200410 Nov 2005Andrey ShurMethods and systems for defining documents with selectable and/or sequenceable parts
US20050251740 *30 Abr 200410 Nov 2005Microsoft CorporationMethods and systems for building packages that contain pre-paginated documents
US20050262441 *19 May 200524 Nov 2005Samsung Electronics Co., Ltd.Method and apparatus for printing web pages
US20050268221 *30 Abr 20041 Dic 2005Microsoft CorporationModular document format
US20050273701 *30 Abr 20048 Dic 2005Emerson Daniel FDocument mark up methods and systems
US20050273704 *18 Nov 20048 Dic 2005Microsoft CorporationMethod and apparatus for document processing
US20060010371 *7 Sep 200512 Ene 2006Microsoft CorporationPackages that contain pre-paginated documents
US20060031758 *7 Sep 20059 Feb 2006Microsoft CorporationPackages that contain pre-paginated documents
US20060069983 *4 Mar 200530 Mar 2006Microsoft CorporationMethod and apparatus for utilizing an extensible markup language schema to define document parts for use in an electronic document
US20060136477 *20 Dic 200422 Jun 2006Microsoft CorporationManagement and use of data in a computer-generated document
US20060136553 *21 Dic 200422 Jun 2006Microsoft CorporationMethod and system for exposing nested data in a computer-generated document in a transparent manner
US20060136816 *20 Dic 200422 Jun 2006Microsoft CorporationFile formats, methods, and computer program products for representing documents
US20060190815 *5 Abr 200624 Ago 2006Microsoft CorporationStructuring data for word processing documents
US20060271574 *10 May 200630 Nov 2006Microsoft CorporationExposing embedded data in a computer-generated document
US20060277452 *2 Jun 20067 Dic 2006Microsoft CorporationStructuring data for presentation documents
US20070022128 *24 Mar 200625 Ene 2007Microsoft CorporationStructuring data for spreadsheet documents
US20070043671 *17 Ago 200522 Feb 2007Kurzweil Educational Systems, Inc.Protected viewing of digital files
US20070186155 *21 Mar 20079 Ago 2007Adobe Systems IncorporatedAutomated Paragraph Layout
US20070214169 *7 Oct 200213 Sep 2007Mathieu AudetMulti-dimensional locating system and method
US20070216694 *29 Mar 200720 Sep 2007Mathieu AudetMulti-Dimensional Locating System and Method
US20080058106 *7 Nov 20076 Mar 2008Maya-Systems Inc.Multi-dimensional locating game system and method
US20080071822 *21 Nov 200720 Mar 2008Mathieu AudetBrowser for managing documents
US20080072169 *21 Nov 200720 Mar 2008Mathieu AudetDocument interfaces
US20080092038 *21 Nov 200717 Abr 2008Mahieu AudetDocument vectors
US20080134013 *8 Ene 20085 Jun 2008Mathieu AudetMultimedia interface
US20080134022 *19 Ene 20085 Jun 2008Mathieu AudetDocument attributes
US20080141115 *20 Feb 200812 Jun 2008Mathieu AudetMulti-dimensional document locating system and method
US20080168342 *21 Mar 200810 Jul 2008Microsoft CorporationPackages that Contain Pre-Paginated Documents
US20080270893 *30 Jun 200830 Oct 2008Microsoft CorporationSystems and Methods for Pagination and Co-Pagination
US20080282149 *8 Feb 200713 Nov 2008Adobe Systems IncorporatedAutomated Paragraph Layout
US20080295016 *25 May 200727 Nov 2008Mathieu AudetTimescale for representing information
US20090019371 *27 Mar 200715 Ene 2009Mathieu AudetMulti-dimensional locating system and method
US20090055726 *13 Sep 200726 Feb 2009Mathieu AudetInformation elements locating system and method
US20090055763 *22 May 200826 Feb 2009Mathieu AudetTimeline for presenting information
US20090055776 *15 Ago 200826 Feb 2009Mathieu AudetPosition based multi-dimensional locating system and method
US20090228788 *9 Mar 200910 Sep 2009Mathieu AudetDocuments discrimination system and method thereof
US20090288006 *27 Jun 200919 Nov 2009Mathieu AudetMulti-dimensional documents locating system and method
US20100169823 *14 Sep 20091 Jul 2010Mathieu AudetMethod of Managing Groups of Arrays of Documents
US20100229083 *10 Ago 20099 Sep 2010Mitsubishi ElectricScreen display program generating apparatus, screen display system, computer readable storage medium having stored therein a computer program causing a computer to function as the screen display program generating apparatus, and screen display program generating method
EP1605366A1 *3 Mar 200414 Dic 2005Sharp CorporationData processing apparatus, data processing method, data processing program, and recording medium having recorded therein that program
EP1605366A4 *3 Mar 20047 Jul 2010Sharp KkData processing apparatus, data processing method, data processing program, and recording medium having recorded therein that program
WO2001082105A2 *5 Abr 20011 Nov 2001Microsoft CorporationDocument pagination based on hard breaks and active formatting tags
WO2001082105A3 *5 Abr 200124 Ene 2002Microsoft CorpDocument pagination based on hard breaks and active formatting tags
WO2002042929A1 *22 Dic 200030 May 2002Adobe Systems IncorporatedAutomated paragraph layout
Clasificaciones
Clasificación de EE.UU.715/210
Clasificación internacionalG06F17/21
Clasificación cooperativaG06F17/21
Clasificación europeaG06F17/21
Eventos legales
FechaCódigoEventoDescripción
29 May 1998ASAssignment
Owner name: INTERNATIONAL BUSINESS MACHINES CORPORATION, NEW Y
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:SMITH, ANDREW J.;RENSHAW, DAVID S.;REEL/FRAME:009217/0438;SIGNING DATES FROM 19980320 TO 19980325
28 Jun 2004FPAYFee payment
Year of fee payment: 4
4 Ago 2004REMIMaintenance fee reminder mailed
9 Ago 2007ASAssignment
Owner name: SCIENCE INCORPORATED, MINNESOTA
Free format text: RELEASE OF SECURITY AGREEMENT;ASSIGNORS:OKABENA PARTNERSIP V-8 BY OKABENA INVESTMENT SERVICES, INC.MANAGER;WINSTON R. WALLIN/WALLIN FAMILY FOUNDATION;WILLIAM F. FARLEY D/B/A LIVINGSTON CAPITAL;AND OTHERS;REEL/FRAME:019704/0733
Effective date: 20070628
28 Jul 2008REMIMaintenance fee reminder mailed
16 Ene 2009LAPSLapse for failure to pay maintenance fees
10 Mar 2009FPExpired due to failure to pay maintenance fee
Effective date: 20090116