U.S. patent application number 10/801658 was filed with the patent office on 2004-09-09 for method and apparatus for selecting and viewing portions of web pages.
Invention is credited to Tsimelzon, Mark JR..
Application Number | 20040177148 10/801658 |
Document ID | / |
Family ID | 32681769 |
Filed Date | 2004-09-09 |
United States Patent
Application |
20040177148 |
Kind Code |
A1 |
Tsimelzon, Mark JR. |
September 9, 2004 |
Method and apparatus for selecting and viewing portions of web
pages
Abstract
A method for creating a modified web page based on an original
web page includes retrieving a current version of the original web
page. The current version of the web page is divided into a
plurality of blocks. User-selection information is added to each of
the plurality of blocks, the user-selection information including a
select and a non-select user option. The user selects ones of the
plurality of blocks by exercising a select user option from the
user-selection information associated with each of the plurality of
blocks. The user non-selects others of the plurality of blocks by
exercising a non-select user option from the user-selection
information associated with each of the plurality of blocks. Only
the user selected ones of the plurality of blocks are stored. A
modified web page is created based only on the stored ones of the
plurality of blocks.
Inventors: |
Tsimelzon, Mark JR.;
(Sunnyvale, CA) |
Correspondence
Address: |
LOCKE LIDDELL & SAPP LLP
ATTN: SUE COTT
2200 ROSS AVENUE
SUITE 2200
DALLAS
TX
75201-6776
US
|
Family ID: |
32681769 |
Appl. No.: |
10/801658 |
Filed: |
March 17, 2004 |
Related U.S. Patent Documents
|
|
|
|
|
|
Application
Number |
Filing Date |
Patent Number |
|
|
10801658 |
Mar 17, 2004 |
|
|
|
09371161 |
Aug 10, 1999 |
|
|
|
6763388 |
|
|
|
|
Current U.S.
Class: |
709/227 ;
707/E17.116; 707/E17.121; 715/205; 715/234 |
Current CPC
Class: |
G06F 16/9577 20190101;
G06F 16/958 20190101 |
Class at
Publication: |
709/227 ;
715/501.1 |
International
Class: |
G06F 015/16 |
Claims
What is claimed:
1. A method for creating a modified web page based on an original
web page, comprising: retrieving a current version of the original
web page; dividing the current version of the web page into a
plurality of blocks; adding user-selection information to each of
the plurality of blocks, the user-selection information including a
select and a non-select user option; allowing a user to select ones
of the plurality of blocks by exercising a select user option from
the user-selection information associated with each of the
plurality of blocks; allowing a user to non-select others of the
plurality of blocks by exercising a non-select user option from the
user-selection information associated with each of the plurality of
blocks; storing only the user selected ones of the plurality of
blocks; and creating a modified web page based only on the stored
ones of the plurality of blocks.
2. The method of claim 1 and further including displaying the
modified page on a client system.
3 The method of claim 2 wherein the client system includes a
personal computer.
4. The method of claim 2 wherein the client system includes a
personal digital assistant device.
5. The method of claim 2 wherein the client system includes a
web-enabled telephone including a display.
6. The method of claim 2 wherein the client system includes an
alpha-numeric paging device.
7. The method of claim 2 wherein the client system includes a
web-enable device.
8. The method of claim 2 wherein the client system includes a
device using a WAP protocol.
9. The method of claim 1 wherein the original web page is retrieved
from a worldwide web page.
10. The method of claim 1 wherein the original web page is
specified in a hypertext markup language.
11. An apparatus for creating a modified web page based on an
original web page, comprising: a software portion configured to
retrieve a current version of the original web page; a software
portion configured to divide the current web page into a plurality
of blocks; a software portion configured to add user-selection
information to each of the plurality of blocks, the user-selection
information including a select and a non-select user option; a
software portion configured to allow a user to select ones of the
plurality of blocks by exercising a select user option from the
user-selection information associated with each of the plurality of
blocks; a software portion configured to allow a user to non-select
others of the plurality of blocks by exercising a non-select user
option from the user-selection information associated with each of
the plurality of blocks; a software portion configured to store
only the user selected ones of the plurality of blocks; and a
software portion configured to create a modified web page based
only on the stored ones of the plurality of blocks.
12. The apparatus of claim 11 wherein the software portions are
stored in a web-enabled device.
13. The apparatus of claim 11 and further including a software
portion configured to receive the modified web page via a WAP
protocol.
Description
RELATED APPLICATIONS
[0001] This application is a continuation of U.S. application Ser.
No. 09/371,161 entitled "Method and Apparatus for Selecting and
Viewing Portions of Web Pages", filed Aug. 10, 1999 and now U.S.
Pat. No. ______ issued ______.
[0002] This application is also related to the following U.S.
patent applications, which are herein incorporated by
reference.
[0003] 1) U.S. application Ser. No. 09/372,410 of M. Tsimelzon
entitled "Method and Apparatus for Combining Parts of Different Web
Pages", filed Aug. 10, 1999.
[0004] 2) U.S. application Ser. No. 09/371,402 of M. Tsimelzon
entitled "Method and Apparatus for Notifying a User of Changes to
Certain Parts of Web Pages", filed Aug. 10, 1999 and now U.S. Pat.
No. ______ issued ______.
[0005] This application includes subject matter protected by
copyright.
BACKGROUND OF THE INVENTION
[0006] The present invention relates generally to computer networks
and, specifically, to a method and apparatus that allow users to
select certain portions of web pages to form "short" web pages.
[0007] The expanded popularity of the World Wide Web ("the web")
has brought new problems for web users. As users obtain more and
more information from the web, they must visit greater numbers of
different web pages to obtain the information. This information is
often contained on several separate web pages or web sites.
Alternately, a user may wish to see only a small piece of
information that is contained in a very large and complex page or
site. The user must search through the pages in which he is not
interested to reach the information that he wishes to see.
[0008] Many users visit the same sequence of web pages or sites on
a daily or a regular basis. For example, some users might check the
weather or their stock portfolio on a daily basis. Even though a
user may visit the same web pages and/or sites regularly, the user
must still take individual actions to visit each of his regularly
visited web pages or sites. For example, the user may have to enter
the web addresses of each page or click on each page in a list of
saved addresses in his browser. This repeated entry of web
addresses is time consuming and involves un-needed repetitive
action by the user.
[0009] What is needed is a way to avoid regularly re-entering the
same multiplicity of web addresses and a way to avoid having to
navigate through multi-level web sites to reach desired
information.
SUMMARY OF THE INVENTION
[0010] A described embodiment of the present invention allows users
to select certain sub-elements of web pages for later viewing. The
user can use any of a wide variety of client devices to view the
web page, such as a computer, a handheld device, or a cell phone.
When the user views the shortened web page at a later time, only
the sub-elements of the web page selected by the user are
displayed. Thus, the user views only preselected sub-elements of
the web page.
[0011] Multiple users can share a short page. Such a shared
shortpage is called a shared portal. For example, multiple users
can place information on a short page. Alternately, multiple users
can view a shortpage created by a third party or third parties.
[0012] In accordance with the purpose of the invention, as embodied
and broadly described herein, the invention is a method for
creating a short web page, comprising: allowing a user to choose a
subset of elements that appear on an original web page; saving the
user's choices; and creating a short web page that is based on the
original web page, and includes the elements chosen by the user in
accordance with the user's saved choices.
[0013] In further accordance with the purpose of the invention, as
embodied and broadly described herein, the invention is a method
for creating a short web page, comprising: storing in a memory
selection information specifying the elements on a short web page,
the short web page being based on an original web page; retrieving
the original web page upon which the short web page is based; and
creating the short web page from elements on the original web page
in accordance with the selection information.
[0014] In further accordance with the purpose of the invention, as
embodied and broadly described herein, the invention is a
computer-implemented method performed by a server data processing
system, comprising: receiving, from a client, a request for a web
page; retrieving the requested web page; sending the requested web
page to the client; receiving, from the client, selection
information for the requested web page, the selection information
indicating a subset of the information of the web page that is
smaller than the set of all information on the web page; and
storing the selection information in the server data processing
system.
[0015] In further accordance with the purpose of the invention, as
embodied and broadly described herein, the invention is a
computer-implemented method performed by a server data processing
system, comprising: receiving, from a client, a request for a
user's short page; retrieving a web page on which the user's short
page is based; selecting sub-elements of the retrieved web page, in
accordance with selection information of the user stored in the
server data processing; and sending the user's short page,
containing the selected sub-elements of the retrieved web page to
the user.
[0016] In further accordance with the purpose of the invention, as
embodied and broadly described herein, the invention is a
computer-implemented method performed by a client data processing
system, comprising: sending, by a client, a request for a web page;
receiving the requested web page; allowing the user to select
sub-elements of the received web page as being hidden or shown, the
hidden sub-elements being indicated by selection information; and
sending, to a server, the selection information for the web
page.
[0017] In further accordance with the purpose of the invention, as
embodied and broadly described herein, the invention is an
apparatus to create a short web page, comprising: a software
portion configured to allow a user to choose a subset of elements
that appear on an original web page; a software portion configured
to save the user's choices; and a software portion configured to
create a short web page that is based on the original web page, and
that includes the elements chosen by the user in accordance with
the user's saved choices.
[0018] In further accordance with the purpose of the invention, as
embodied and broadly described herein, the invention is an
apparatus for creating a short web page, comprising: a software
portion configured to store in a memory selection information
specifying the elements on a short web page, the short web page
being based on an original web page; a software portion configured
to retrieve the original web page upon which the short web page is
based; and a software portion configured to create the short web
page from elements on the original web page in accordance with the
selection information.
[0019] Advantages of the invention will be set forth in part in the
description which follows and in part will be obvious from the
description or may be learned by practice of the invention. The
objects and advantages of the invention will be realized and
attained by means of the elements and combinations particularly
pointed out in the appended claims and equivalents.
BRIEF DESCRIPTION OF THE DRAWINGS
[0020] The accompanying drawings, which are incorporated in and
constitute a part of this specification, illustrate several
embodiments of the invention and, together with the description,
serve to explain the principles of the invention.
[0021] FIG. 1 is a block diagram of data processing elements in
accordance with a preferred embodiment of the present
invention.
[0022] FIGS. 2(a) and 2(b) are block diagrams showing an
information flow in a preferred embodiment of the present
invention.
[0023] FIG. 3(a) shows a display of a startpage that allows a user
to create and edit shortpages.
[0024] FIGS. 3(b)-3(e) show the HTML source for a startpage.
[0025] FIGS. 4(a)-4(c) are flow charts showing how a client and a
server interact to perform shortpage operations, such as create,
edit, delete, and view.
[0026] FIG. 5(a) shows a display of an exemplary web page.
[0027] FIGS. 5(b) and 5(c) show the web page of FIG. 5(a) displayed
along with selection-enabling information.
[0028] FIG. 5(d) shows the web page of FIG. 5(b) with a different
level of block detail.
[0029] FIG. 5(e) shows a web page that allows the user to view/edit
shortpage properties.
[0030] FIG. 6 is a flow chart showing how the client and the server
interact to allow the to create/edit a shortpage.
[0031] FIG. 7 shows an example of HTML parsing used to create/edit
shortpages.
[0032] FIG. 8 shows an example of a split page method used to
create/edit shortpages.
[0033] FIG. 9 is a flow chart of how to determine a display level
when creating shortpages.
[0034] FIG. 10 shows the startpage of FIG. 3(a) after a shortpage
has been created based on the web page of FIG. 5(a).
[0035] FIG. 11 shows the shortpage created from the web page of
FIG. 5(a).
[0036] FIG. 12 shows a fullpage corresponding to the web page of
FIG. 5(a).
[0037] FIG. 13 is a flow chart showing how the client and server
interact to allow the user to view a shortpage.
[0038] FIG. 14 is a flow chart showing details of determining
whether a URL is the URL of a shortpage.
[0039] FIG. 15 is a flow chart for viewing a shortpage when the
client is a personal digital assistant.
[0040] FIG. 16 is a block diagram of data flow when a shortpage is
viewed on a personal digital assistant.
[0041] FIG. 17 is a display of a shared portal shortpage.
DETAILED DESCRIPTION OF EMBODIMENTS
[0042] Reference will now be made in detail to several embodiments
of the present invention, examples of which are illustrated in the
accompanying drawings. Wherever practicable, the same reference
numbers will be used throughout the drawings to refer to the same
or like parts.
[0043] I. General Discussion
[0044] A described embodiment of the present invention allows users
to select certain sub-elements of one or more web pages as a
shortpage. The user selects certain sub-elements of an original web
page to create a shortpage. The user's selection information is
saved and, when the user views the shortpage at a later time, only
the sub-elements of the web page indicated by the user are
displayed for viewing by the user. Thus, the user views only
preselected sub-elements of the web page. This section discusses an
exemplary data processing system used to implement a preferred
embodiment of the present invention.
[0045] FIG. 1 is a block diagram of data processing elements in
accordance with a preferred embodiment of the present invention.
FIG. 1 includes a server data processing system 120 communicating
with one or more client data processing systems. These client data
processing systems include, but are not limited to, a desktop
personal computer (PC) 102, a laptop computer 104, a palm computer
(personal computer/assistant or handheld device) 106, a pager 108
(such as an alphanumeric pager), a web-enabled telephone or a cell
phone 110, or some other appropriate web-enabled device or
appliance 111. A web-enabled telephone or device could use, for
example, the WAP (Wireless Application Protocol) or any other
appropriate protocol. It should be understood that the client data
processing systems shown in FIG. 1 are shown for purposes of
example only and are not to be construed in a limiting sense. Any
other appropriate type of client can be used in conjunction with
the present invention. FIG. 1 also includes a plurality of web page
servers 132, 134, 136. Each web page server communicates with
server 120 and stores one or more web sites or web pages. Server
120 stores selection information 122 for each user and further
stores selection-enabling information 124 that is added to a web
page to enable a user to make selections from a web page.
Communication can be over a network, such as the internet, an
intranet, a wireless network, or in any other appropriate
manner.
[0046] FIG. 2(a) shows an overview of creation of a shortpage. As
shown in FIG. 2(a), during operation, a client 202 sends a request
to server 120 for a web page. Server 120 retrieves the web page
from an appropriate one of web sites 132-136. The server 120 adds
selection-enabling information to the retrieved web-page and sends
the web page to the client. The client selects sub-elements of the
web page and sends that selection information to server 120. Server
120 stores selection information 122 describing the shortpages
defined by a user.
[0047] FIG. 2(b) shows an overview of viewing a shortpage. The
client sends a request for a shortpage to server 120. Server 120
determines the page or pages needed to view the shortpage in
accordance with the stored selection information and retrieves the
page or pages from the web site 132. Server 120 shortens the
retrieved web page in accordance with the selection information to
form a shortpage and sends the shortpage to the client.
[0048] It should be understood that each of the clients, servers,
and web servers in the described embodiment preferably includes a
processor and a memory. The memory includes instructions capable of
being executed by the processor to perform the functions described
below. A client and/or a server can also include a computer
readable medium for storing the instructions. Server 120
communicates with the clients and the web page servers via any
appropriate communication mechanism, including but not limited to a
network, an intranet, the internet, wireless communications,
telecommunications, cable modems, and satellite communications.
[0049] A client may include browser software suitable for viewing
web pages. The browser software can be standalone or integrated
within other software products. The functionality can be stored,
for example, as a link, a JavaScript, or as a Java applet. Handheld
clients contain a specialized browser that receive "snipped"
sub-elements of web pages for viewing on a handheld client. Other
clients (such as cell phones) do not necessarily contain a browser.
It should be understood that references herein to "HTML" can be
understood to refer to any appropriate page specification language,
such as a hypertext language or a proprietary language.
[0050] The following paragraphs describe an example of how a user
makes a shortpage. This example is provided for exemplary purposes
only and is not to be interpreted in a limiting sense.
[0051] FIG. 3(a) shows a display of a "startpage" on a browser in a
client. The startpage allows a user to create and edit shortpages
and displays existing shortpages. Each user has his own startpage.
The information needed to make a startpage is preferably stores in
server 120. FIG. 3(a) shows a URL 310 of the exemplary startpage
for user John Smith
(http://www.shortware.com:9999/UserName=Jsmith&ProcName=StartPage).
[0052] The startpage of FIG. 3(a) includes a link to a
Notifications page 312, a link to an Edit profile page 314, and a
link to a Help page 316. The startpage of FIG. 3(a) allows a user
to create, edit, delete, and view shortpages and their options. To
create a shortpage, in the described embodiment, the user enters a
URL of a page into area 318 and selects "Create Shortpage" button
320. After a shortpage is created, its name will be displayed in
Shortpages column 332. An existing shortpage can be viewed ("Go"),
edited, options edited, or deleted by selecting the corresponding
action in action box 330 and selecting a name of an existing
shortpage.
[0053] FIGS. 3(b)-3(e) are an example of the HTML source code for
an exemplary shortpage, similar to the StartPage of FIG. 3(a). This
source code is included for the purpose of example and is not to be
taken in a limiting sense.
[0054] FIGS. 4(a)-4(c) are flow charts showing how a client and a
server interact to perform shortpage operations, such as create,
edit, delete, and view. FIGS. 4(a) and 4(b) show a method performed
by the client. In the described embodiment, the functionality of
FIGS. 4(a) and 4(b) are implemented via a Java Script executed by
the client browser, although any appropriate implementation can be
used. FIG. 4(c) shows a method performed by server 120.
[0055] In FIGS. 4(a) and 4(b), the client receives the user's
actions (e.g., entering the URL of a web page and clicking "Create
shortpage") and determines whether the user wants to create a
shortpage (element 410), edit a shortpage (element 420), view a
shortpage (element 430), delete a shortpage (element 440), or edit
an option (element 450).
[0056] If the user wants to create a new shortpage (element 410),
the client sends the URL of the page to shorten and a request to
create a shortpage to server 120 (element 412). The client receives
a page created from the requested page and from selection-enabling
information (element 414). In the example, the selection-enabling
information allows the user to indicate that sub-elements of the
page are shown or hidden. The client then displays the page
(element 416), and allows the user to create a shortpage as
described below. The resulting selection information is sent to
server 120. In the described embodiment, selection information is
sent to the server each time a page element is marked as "shown" or
"hidden." In return, a new preview of the shortpage is sent from
the server to the client, so that the preview view of the shortpage
reflects the currently shown/hidden element. The server adds the
name of the shortpage to the list of shortpages 332 on the
page.
[0057] If the user wants to edit a shortpage (element 420), the
client sends the URL of the shortpage to edit and a request to edit
a shortpage to server 120 (element 422). The client receives a
shortpage created from the original fullpage including
selection-enabling information (element 424). The selection
enabling information includes show/hide buttons and header links.
The client then displays the page (element 426) upon which the
shortpage is based, including the selection-enabling information,
and allows the user to edit the shortpage as described below. The
resulting selection information is sent to server 120. Note that
the show/hide buttons can instead be implemented as a one-button
user interface, or by using some other appropriate type of user
interface that allows the user to choose a subset of the web page
elements.
[0058] If the user wants to view a shortpage (element 430), the
client sends the URL of the shortpage to view and a request to view
a shortpage to server 120 (element 432). The client receives the
shortpage from server 120 (element 434). The shortpage to be viewed
does not include any selection-enabling information. The client
then displays the shortpage (element 436).
[0059] If the user wants to delete a shortpage (element 440), the
client sends the URL of the shortpage to delete and a request to
delete a shortpage to server 120 (element 442). Server 120 deletes
the shortpage and returns an indication to the client that the
shortpage has been deleted (element 444). The server removes the
name of the shortpage form its list of shortpages 332.
[0060] If the client wants to edit options for a shortpage (element
450), the client send the URL of the shortpage and a request to
edit the options of the shortpage. The client receives the edit
page from server and displays it (element 452). The user then edits
the options and sends the edits to the server (element 454).
[0061] FIG. 4(c) shows an overview of an exemplary shortpage method
on the server side. When the server receives a request form the
client's browser to create, edit, delete, or view a shortpage or
option (element 456), the server translates the request into the
appropriate request(s) to the web server(s) (element 458) and
retrieves the requested web page(s) or site(s) from the server(s)
(element 460). In the described embodiment, these requests are HTTP
requests and the web pages are written in HTML or a similar
hypertext language. The server does the user-specified action (such
as adding selection-enabling information when a shortpage is to be
created or edited) or selecting the relevant parts of the web page
(when a shortpage is to be viewed) (element 462). For example, the
server adds the selection-enabling information to the retrieved web
page and send the resulting page to the client's browser element
464). Table 1 shows an example of Web Procedure Calls (WPCs) used
to communicate between the client and the server. The WPC is part
of the URL sent by the client and has the format:
[0062]
/UserName=<username>&ProcName=<procname>{&arg1=val1}
{&arg2=val2} . . . {&arg last=vallast}
[0063] where a string in pointed brackets "<" ">" indicates a
type of data and a string in curly brackets "{" "}" indicates
optional arguments.
[0064] II. Creating/Editing a Shortpage
[0065] The following paragraphs provide exemplary details of how to
create/edit a shortpage. The example shown is based on an exemplary
web page shown in FIG. 5(a). The web page shown has a URL of
http://abc.gov. In the example, a user visits this web site
frequently and desires to select sub-elements of the web site to be
placed on a shortpage. If the user desires to create a shortpage
based on the web page of FIG. 5(a), he enters the URL of the web
page into address 318 of FIG. 3 and selects "Create Shortpage"
button 320. The server will retrieve the requested web page and add
selection-enabling information to the page.
[0066] FIGS. 5(b) and 5(c) show the web page of FIG. 5(a) displayed
along with selection-enabling information. The server has broken
the web page into blocks, 502, 503, 504 and 505, each block having
selection-enabling information. In the described embodiment, the
selection-enabling information is a pair of show/hide boxes, having
a check mark and an "X" respectively. The check mark indicates that
the corresponding block will be shown in the shortpage. The "X"
indicates that the corresponding block will be hidden (not shown)
in the shortpage. FIG. 5(b) shows an editing area 510 and a preview
area 520. Each of these areas can be sized and scrolled by the
user. Initially all blocks in the page are marked as "hide." The
example of FIG. 5(b) shows all blocks marked as "show." Therefore,
in the example, preview area 520 shows all blocks in the page. In
contrast, in FIG. 5(c), the user has clicked on the "X" box 505,
causing the corresponding block 504 to be hidden in the shortpage.
Note that the block 504 is not shown in the preview area 520 of
FIG. 5(c).
[0067] FIG. 5(d) shows the web page of FIG. 5(a) with a different
level of block detail. When the user clicks "more details" link 561
of FIG. 5(c), a command is sent to the server and the server
re-determines the blocks of the page using a higher level of detail
than previously used. (A similar "less detail" button 561' is
displayed on the web page of FIG. 5(d)). A method of determining
blocks on a page in accordance with a current level of detail is
described below in connection with FIG. 9. In FIG. 5(d), for
example, the page is broken into fewer blocks 502. For example,
block 504 does not exist in editing area 510.
[0068] FIG. 5(e) shows a web page that allows the user to view/edit
shortpage properties. The web page of FIG. 5(e) is requested when
the user clicks on "Next" link 560, as shown in FIGS. 5(b)-5(d).
This page allows the user to enter properties of a shortpage. The
user can change the name associated with the shortpage (for
example, the name shown in area 332 of FIG. 3) by entering a new
name in area 570. The user can enter comments in area 572. The user
can indicate that the shortpage does not show the page background
in area 574. The user can indicate that changes since the last time
the shortpage was viewed should be highlighted on the shortpage in
area 576. The user can indicate that the shortpage should be used
for similar pages and all URLs starting with a specified string
(areas 578 and 580). Other properties could be included or certain
properties shown in the figure excluded without departing from the
spirit or scope of the invention. When the user clicks a "Done"
button 582, the client sends the entered information to server 120,
which stores the entered information in connection with the
shortpage.
[0069] FIG. 6 is a flow chart showing how the client and the server
interact to allow the user to create/edit a shortpage. Each element
of the flow chart has a notation next to it indicating whether it
is preferably performed by the client, server, or a combination. In
element 602, after the server has retrieved a page from a web
server, the server needs to break the page down into blocks and to
add selection-enabling information to the page of reach block. The
server uses the SplitPage method (FIG. 8) and the Level of Detail
method (FIG. 9) to break the page into blocks. In element 604, the
server adds selection-enabling information to the retrieved web
page. Specifically, the server adds a "Show" button and a "Hide"
button next to the block and puts a border (<table>) around
it. The client's browser, thus, displays the web page along with
the selection-enabling information for each block.
[0070] In element 606, when the user selects "Show" or "Hide," an
HTTP request that uniquely identifies the button is sent to the
server (see Table 1). In element 608, the server marks the
corresponding block as either "shown" or "hidden" in the
representation tree (RepTree) for the shortpage. This information
is a part of the selection information stores on the server. In
element 610, the server returns a preview of the resulting
shortpage to the user, which is displayed in a separate frame
(preview area 520). The marked-up RepTree is stored as the template
for future references to this shortpage in element 612. Thus, the
RepTree forms at least part of the selection information. It will
be understood that, although the example shows certain action being
performed by the client or the server, other embodiments may
implement the client or server to perform actions not shown as
being performed by them. For example, the selection information
could be stored on the client side.
[0071] FIG. 7 shows an example of parsing used by the server to
create and edit shortpages. This figure shows the Split Page
method. In the example, the page is represented by an HTML file.
The HTML is parsed in a manner known to persons of ordinary skill
in the art to yield a Representation Tree. The Representation Tree
has complex/multipart tags (e.g., <ul>), simple tags (e.g.,
<image src=1 mg.gif>), and text nodes (e.g., item 1). A
simple tag is defined as a tag that has no children and a complex
tag is defined as a tag that has children. Server 120 parses the
HTML file into a RepTree and iterates down the tree in a
depth-first way to mark each node in the tree according to whether
it is a single block. The RepTree includes a flag for each block
indicating whether it is shown or hidden. A detailed example of the
format of a RepTree is shown in Table 2. This format is not to be
taken in a limiting sense.
[0072] FIG. 8 shows an example of a split page method used to
create/edit shortpages. As shown in FIG. 8 after start iterating
(element 800), node type is determined (element 802), if a node
corresponds to a simple tag that is an image, input, iframe, or
object, it is marked as a single block (element 804). If a node
corresponds to a complex tag of type <tr> and there are more
than two rows or columns in the table, mark the node (element 806).
If a node corresponds to a complex tag of type <form>, do not
mark the node (element 806). If a node corresponds to a complex tag
of other types, mark the node if it has any text (element 806). For
other types of nodes, continue traversing the RepTree (element
808). For each complex node, walk down the list of its children
(element 810). Any nodes between two single blocks become one
complex block. To avoid crating extra blocks, if a node has only
one child block, give the block status to the parent node instead
(element 812).
[0073] FIG. 9 is a flow chart of how to determine a display level
when creating shortpages. In the described embodiment, the level of
detail is used to decrease the number of blocks displayed at a
given time. This flow chart demonstrates how to work with two
levels (high and low), but any number of levels can be supported.
If the level of detail is low, determined at element 902, element
904 determines whether the block's parent has less than L nodes
below its children. L can be, for example, 5. If the block's parent
has less than L nodes below its children, the block is shown as a
separate block when the user creates or edits a shortpage.
Otherwise, the block is not shown as a separate block. If the level
of detail is high, determined at element 902, element 906
determines whether the block has more than K nodes below its
children. K can be, for example, 1. If the block has more than K
nodes below its children, the block is shown a as a separate block
when the user creates a shortpage. Otherwise, the block is not
shown as a separate block.
[0074] FIG. 10 shows the startpage of FIG. 3 after a shortpage has
been created based on the web page of FIG. 5(a). Server 120
indicates to the client that a shortpage has been created and adds
the name of the shortpage to area 332 of the user's startpage. The
startpage having the name of the new shortpage is sent to the
browser, where it is displayed.
[0075] FIG. 11 shows the shortpage created from the web page of
FIG. 5(a). In the example, the user selected certain sub-elements
of the page. Specifically, the user indicated that all but a
leftmost block of the page is marked as hidden. Thus, the shortpage
shows only the non-hidden block. The shortpage also includes a link
to the user's startpage 1102, a link to a notification page 1104, a
link to a help page 1106, a link to a page that allows the user to
edit a shortpage 1105 and a link to the fullpage 1103 upon which
the shortpage is based. Note that the user has indicated that the
background of the original page is not to be shown in this
shortpage (see FIG. 5(e)).
[0076] FIG. 12 shows a fullpage corresponding to the web page of
FIG. 11. The fullpage is displayed when the user clicks on the
fullpage link of 1103 FIG. 11. In contrast to the shortpage, the
original page's background is shown, since it is part of the page.
Even though all blocks of the fullpage are shown, the full page is
fetched via server 120 and not directly from the web page server.
This is shown by the URL 1202 of the fullpage:
http://shortwave.com:9999/UserName=JSmith/ProcName=B
GetPage&purpose=7&textURL=ht tp://www.abc.gov.
[0077] In this example, the user is "JSmith". The action is to
get/fetch a page. "Purpose=7" indicates that a full page should be
fetched. The URL of the full page is http://www.abc.gov. Further
examples of parameters used to communicate between the client and
the server are described in Table 1.
[0078] III. Viewing a ShortPage
[0079] FIG. 13 is a flow chart showing how the client and server
interact to allow the user to view a shortpage. In the described
embodiment, the user has selected a name of a shortpage in area 332
and selected "go" in area 330. It should be remembered that,
although a shortpage may be used on a particular web page, that web
page may have changed since the shortpage was crated, either
because content may have been changed, added, or deleted. It is
necessary to parse the web page on which the shortpage is based
(the target) and determine whether the blocks marked "show" in the
template are still present in the target (element 1302). The target
page on which the shortpage is based is retrieved and parsed into a
RepTree by the server. Each shortpage has a RepTree associated with
it.
[0080] In element 1304, the server performs a "double traverse"
method, recursively traversing down both the template and the
target RepTrees, trying to match the nodes. If two nodes match by
type and tag, assign the "Show" or "Hide" flags of the template
node to the target node (element 1306). If there is no match, start
to look for the closest match. If, for example we are currently on
nodes Temp[I], Targ[J], then we are looking for matching Temp[K]
and Targ[L] such that, for K and L, K-I+L-J is the smallest
possible value (element 1308).
[0081] After element 1308, any template nodes that are not matched
were the nodes that have disappeared from the page (element 1310).
Any target nodes that were not matched were the nodes that have
been added to the page. All target nodes with "Show" flags (i.e.,
all target blocks that matched a block in the template) are part of
the shortpage (element 1312). These blocks are sent to the
requesting client. Other appropriate matching methods can also be
used.
[0082] In the described embodiment, the user can enter the address
of a web page to be shortened. For example, the user can enter a
URL in area 318 and click on button 340. If the user has previously
defined a shortpage for this URL or for a URL on this web site, the
shortpage is displayed. Similarly, if a page has a link to another
page within it and the link is selected, server 120 will check the
new link to determine whether it is a shortpage.
[0083] FIG. 14 is a flow chart showing details of determining
whether a URL is the URL of a shortpage. As described in element
1402, this method will be used when, instead of requesting a
specific shortpage, the user enters or browses to a particular URL.
In element 1404, for each shortpage that the user has, server 120
compares the URL, host name, document name, and CGI argument lists.
The server does this for both a shortpage requested address and for
the actual address. The requested address and the actual address
may be different because of HTTP redirection.
[0084] If, in element 1406, the host name, document, name, and CGI
parameter names match, it is a "clear match." If a clear match
occurs, use this shortpage for customizing the request (element
1408). If a clear match does not occur, control passes to element
1410. In element 1410, for each "approximate match" (which is
defined as host name and document name match), calculate "match
ranking." Step 1412 calculates match ranking as follows. For each
matching RepNode of RepTree, add (1/(Node depth)) to the rank. For
each mismatch, subtract the same amount. In step 1414, select the
shortpage with the highest matching rank for customizing this
request. If no match occurs, then show the full page.
[0085] IV. Handheld Client
[0086] As discussed in connection with FIG. 1, the present
invention can be implemented for a wide variety of clients. FIG. 16
is a block diagram of data flow when a shortpage is viewed on a
personal digital assistant, such as a Palm VII Personal Digital
Assistant available from 3Com Corporation) or a similar handheld
device. PDAs often use a "web clipping" system to view web pages.
The PDA views predefined web clippings by sending a request for the
clipped pages to a proxy server.
[0087] Initially, a "web clipping" application, which contains a
single link to the user's startpage is created and downloaded into
the user's handheld device. The user creates his shortpages as
described above. Preferably, these shortpages are created on the
user's PC, although other embodiments may allow the user to create
them on the handheld.
[0088] To view a shortpage, the user simply goes to his startpage
"web clipping" in the handheld and selects a link to the shortpage.
As shown in FIG. 16, this action causes a request to be sent to the
proxy server 1604, which passes the request to the shortpage server
1606, which forwards the request to the web site 1608 hosting the
full page. The web site returns the requested page(s) to the
shortpage server 1606, which creates a shortpage as described above
and which then passes the created shortpage to the proxy server
1604. The proxy server sends the shortpage to the handheld client
1602.
[0089] FIG. 15 is a flow chart for viewing a shortpage when the
client is a personal digital assistant. In element 1502, a web
clipping short page application, which contains a single link to
the user's startpage is created and downloaded into the user's PDA.
In element 1504, the user creates his shortpage as before, using
his PC or similar device. In element 1506, to view a shortpage, the
user simply goes to his startpage "web clipping" and selects a link
to the shortpage. In element 1508, the request goes through a proxy
server (such as palm.net of 3Com) and is forwarded to the site
hosting the page or pages. In element 1510, the response from the
web server is customized by the Shortpage server and goes back to
the user.
[0090] In the described embodiment, the shortpage server creates a
modified version of a shortpage when it knows that the client is a
handheld device. For example, the shortpage server removes large
graphic files and Java Script code. Other embodiments may make
other modifications or no modifications, depending on the nature
and capabilities of the handheld client. In the described
embodiment, the proxy server also modifies the page somewhat before
sending the page to the handheld client.
[0091] V. Shared Portal
[0092] FIG. 17 is a display of a shared portal shortpage
application. A shared portal is created by one or more persons and
is viewable by multiple persons. Different users may have different
access permissions stored within the server. For example, in one
embodiment, a single user has permissions to create folders (such
as folder 1702), but any user can add shortpages within folders
(link 1704 is a link to a page titled "Bay Area News"). As another
example, only a single user can add folders and links, but any user
can access the shortpages. In a shared portal, whenever a user
attempts to edit or create a shortpage, the server first checks the
permissions of the user. The user may be required to enter a
password and/or to Log on from an approved machine. Similarly,
whenever a user attempts to access a shortpage, the server checks
the permissions of the user to determine whether the user is
authorized to access the page he has requested. A shared portals
may be open to all users or may be restricted to certain groups,
such as families, employees of a company, employees of a
department, or clubs.
[0093] VI. Cluster Implementation
[0094] In one embodiment of the present invention, server 120
resides on a number of nodes, which are dual-Pentium Windows NT
PCs. In this implementation, data is stored in a shared RAID file
server. A hardware load-balancer, such as a Big/IP load balancer
from FS Networks, Inc. of Seattle, Wash. is used to route user
requests to the least busy node. Such an implementation uses
persistent connections with, for example, a ten minute timeout to
ensure that the requests from the same address get to the same
server. When the first request for the given user comes to the
given server, the user's data is read from the file server. If
there is no activity for the time Q (for example, Q>T, 12
minutes), the data for the user is cleared from memory.
[0095] While the invention has been described in conjunction with a
specific embodiment, it is evident that many alternatives,
modifications and variations will be apparent to those skilled in
the art in light of the foregoing description. For example, ill one
embodiment, shortpages are pre-created and offered to third persons
who want specialized information or who want shorter web pages.
Accordingly, it is intended to embrace all such alternatives,
modifications and variations as fall within the spirit and scope of
the appended claims and equivalents.
1TABLE 1 WPCs - Web Procedure Call list All WPCs take a username.
// The WPC consists of: (without "<" or ">") //
/Username=<username>&ProcName=<procname-
>&arg1=val1&arg2=val2&...&argLast= valLast //
(The number of args is variable, and the "last" arg is optional).
// New user registration and user login. NewUserLogin - Allows the
user to enter registration information RegisterUser - Submits
username, full name, password, email, and other info for a new
user. LoginUser - login user. Takes username and password // Wizard
Action WizardAction - takes object (shortpage, notification, or
combopage) id Edit - start editing the object Props - Displays
properties of the object CreateShortpage - creates a shortpage
CreateNotification - creates a notification CreateCombopage -
creates a combopage Browse - browse to the given URL Go - go to the
given shortpage/combopage Delete - delete given object Next -
present logically the next screen in the wizard Done - done with
the editing Cancel - cancel editing B_GetPage - Get a page. Takes a
URL B_GetPageS - Same, but the request came through a script, URL
needs some massaging. Takes a URL and a base URL for the page to be
appended to it. StartPage - show Start Page for the user NotifPage
- Show notification page for the user U_DeleteNotifs - delete
certain notification messages. Takes message ids. P_SelectionFrame
- Displays the selection frame (upper frame) for the shortpage
creation P_DoCommand - do editing command, such as "Show" block, or
"Hide" block. Takes block id as a parameter, and command id
("Show", "Hide", "Notify", etc.) ProfileMgrAction - Edit profile
settings
[0096]
2TABLE 2 typedef CArray<CRepNode*, CRepNode*> CRepNodeArray;
class CRepNode { friend class CRepBuilder; public:
CRepNode(CRepNode *pParent=NULL, int iIndex=0); virtual
.about.CRepNode( ); void AddChild(CRepNode *pChild); void
InsertChild(CRepNode *pChild, int iIndex); void
Serialize(CMyArchive& ar); enum Type{ NONE, TEXT, SIMPLE_TAG,
CONTAINER_TAG, COMMENT, BADTAG, // bad closing tag. SCRIPT, //
script node contains both <SCRIPT> and </SCRIPT>
WHITESPACE,// whatever "trims" to an empty string. BAD_CLOSING };
Type m_Type; #define FLG_BLOCK_BEGIN 0x1 #define FLG_BLOCK_END 0x2
#define FLG_BLOCK_MASK (FLG_BLOCK_BEGIN .vertline. FLG_BLOCK_END)
#define FLG_HIDE 0x10 // hide this node. #define FLG_CHANGED 0x20
// node has changed #define FLG_NOMATCH 0x40 // couldn't match this
node. #define FLG_SHOW 0x80 // show the node and subnodes. #define
FLG_NOTIFY 0x100 // Notify on this node. #define FLG_BADLY_CLOSED
0x200 // This node is incorrectly nested. #define FLG_TEMP 0xf000
// The mask for temp bits used by stuff // here and there for a
short time. ULONG m_Flags; CNodeInfo *m_pInfo; // any data can be
stored here. // not saved to the disk! CNotifyInfo *m_pNotify; //
Notification info on this node. // must be serialized. // has
either the text, or a simple tag or // the full tag with params,
but without nested tags.. Example: // "<TD WIDTH=117 VALIGN=TOP
ALIGN=LEFT>" CString m_Text; // Children of a complex tag.
CRepNodeArray m_aKids; // the following two fields are redundant
for all known (to our // program) tags. TAG m_Tag; // The tag
without params and < or >, like "TD" // Note that there is
never a closing tag, like </TD> in the representation. // If
the type of the node is CONTAINER_TAG, then it is assumed that //
there is a closing tag after all m_aKids. CString m_TagName;
CString m_NodeHeader; CRepNode *GetParent( ) { return m_pParent; }
int GetIndex( ) {return m_Index; } CRepNode *m_pParent; // root
object has this NULL int m_Index; // index into the array of the
parent node. #if DEBUG void AssertValid( ); // CObject-like
validation function. #endif };
* * * * *
References