Voice recognition for animated agent-based navigation

Abstract

A method of operation of a computer system for processing an arbitrary document such as a World Wide Web page to provide additional information not immediately available from the raw, unprocessed document. This additional information allows a user to navigate and control the content of the document using, in some embodiments, voice commands and/or an agent-based user interface. The present disclosure provides both a visual display of previously invisible links embedded in a web page image and an audible indication of the presence of such links. The present invention further comprises a scripting language that allows the rapid creation of executable computer instructions (or scripts) for controlling the behaviors and functionality of the agent-based interface. Such scripts enable the creation of a friendlier, easy to use interface to the navigation and control features. The present invention also comprises the ability to read the contents of an arbitrary web page aloud, including the names of embedded hypertext links, thus facilitating web surfing by the sightless.

Description

A portion of the disclosure of this patent document contains material which is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure, as it appears in the Patent and Trademark Office patent file or records, but otherwise reserves all copyright rights whatsoever.

BACKGROUND OF THE INVENTION

1. Field of the Invention

The present invention relates to user interfaces for computer systems and more particularly to voice activated, agent-based user interface systems.

2. Description of the Related Art

Computer systems are routinely used to interface with the content of various computer-realized documents, i.e., documents stored in or displayed on those systems. Such systems are often difficult to use, requiring extensive training and user experience before one can enjoy anything approximating ease of use. Historically, interfaces have required user input in the form of typing at a keyboard or pointing and clicking using a mouse or similar pointing device. Recently, software agents, i.e., software programs that present a more accessible, easy to operate interface to the user, have become available. Software agents are executable programs that interface with other programs and with the user. Agents are typically used to provide enhanced user-computer interaction and a more “user friendly” computing experience. Agents generally respond to user commands to invoke other programs or program functions. Agents also translate user input into the form required by other programs. Smart agents, in particular, are agents that are capable of making decisions based on a pattern of user inputs, rather than basing their decisions on explicit user commands.

Agents are more fully described in Fah-chun Cheong, Internet Agents (1996) (hereinafter Cheong), incorporated herein in its entirety by reference. Additional information may be found in “ActiveX™ Technology for Interactive Software Agents” furnished as Appendix B to this disclosure. Additional documentation on the Microsoft® ActiveX Technology may be found on the Internet at:

www.Microsoft.com/workshop/imedia/agent/documentation.asp

Such agents are typically implemented in software to run on user command. User input comes from a keyboard or a pointing device, such as a mouse or trackball well known in the art. Some computer systems can also accept limited voice input, which is then passed as software messages to the agent program. Such systems are referred to as “voice-enabled”.

The advantage of agent technology, in theory, is that it enables easy user interface without extensive user skill. It has to date been limited in its application because the agent software must be written with a specific set of potential action choices or commands in mind.

Programming an agent-based application typically requires careful construction of a program architecture, logical flowchart, and highly detailed code modules. Extensive testing and debugging are often necessitated by the complexity of the programming language used. Even the so-called high level languages such as C and C++ require extensive programmer training and a high level of skill in order to successfully program agent behaviors and functionality. The C language is described in “The C Programming Language” by Brian W. Kernighan and Dennis M. Ritchie (Prentice Hall, Englewood Cliffs, N.J. 1988 (2d Ed.)), incorporated herein by reference in its entirety. The C++ language is described in “Programming in C++” by Stephen C. Dewhurst and Kathy T. Stark (Prentice Hall, Englewood Cliffs, N.J. 1989), also incorporated herein by reference in its entirety.

Thus a shortcoming of the current state of the art is the difficulty in programming the software to control the behavior of an agent. In typical systems, detailed programming in a specialized computer language is required, such as C or object oriented variants thereof or even assembly code. Using these programming languages requires a high level of skill and training in the programmer. Intricate and precisely detailed procedures for creating the code, compiling it, and preparing a machine readable version are also required. In order to make an agent-based system more readily useable and adaptable, it is necessary to be able to create control software with a minimal amount of programmer sophistication. Prior art software programming techniques additionally require a great deal of time to produce working, operational executable code from the programmer's typed inputs.

As a further drawback, prior art agents can only execute commands available within the application running the agent; they cannot perform actions such as following a hyperlink that are dynamically created by or embedded in an arbitrary document. This latter shortcoming is becoming especially acute as the popularity of the Internet and the World Wide Web (web) continues to increase. Web pages, written in, for example, Hypertext Markup Language (HTML) or a variant thereof, in particular present dynamic links to other pages and new types of content. HTML is described in Ian S. Graham, “The HTML Sourcebook” (1995), incorporated herein by reference in its entirety.

Prior art agent-based interface technology is unable to deal with the dynamic content of web pages and web links (hyperlinks) embedded in other documents because such interface software is unable to understand the contents of the documents. This has the effect of making web navigation and control substantially more frustrating for the inexperienced user, even with a prior art agent-based interface.

The above shortcomings in the prior art are amplified in the case of sightless or seeing-impaired users. While computer systems exist to read plain text aloud, such systems are ineffective on web pages containing objects other than text. One particularly troublesome non-text object is an image map. An image map typically consists of a graphic image that contains regions that are themselves links to different web pages, rather than explicit links. Image maps may consist of icons alone, photographs, or a mixture of text captions and graphic images. However, image maps are downloaded to the browser client in the form of a single graphic image, rather than computer-readable text. As such, text-to-speech programs are unable to sound (read) them to the user.

What is needed is a method of interfacing with an application on a computer system that is friendly and easy to use. What is also needed is a simple and fast method of customizing the behavior of the user interface, to enable rapid prototyping and development. Furthermore, an interface is needed that provides an audible means for interacting with the content of an arbitrary document, such as a web page. The interface needs to provide the ability to navigate hyperlinks embedded in such documents using the user's voice in addition to standard input means well known in the art.

SUMMARY

Presently disclosed is a method of operation of a computer system for processing a document to provide additional information to a user not immediately available from the raw, unprocessed document. This additional information allows a user to navigate and control the content of an arbitrary computer document such as a World Wide Web page using (in one embodiment) voice commands. In one embodiment of the present invention, an agent-based user interface provides both a visual display of previously invisible links embedded in a web page image and an audible indication of the presence of such links. The present invention also provides the ability, in one embodiment, to read the contents of an arbitrary web page document aloud, including the names of embedded hypertext links, thus facilitating web surfing by the sightless.

Furthermore, the present disclosure includes, in one embodiment, a scripting language that allows the rapid creation of executable computer instructions (scripts) for controlling the behaviors and functionality of an agent-based interface. These scripts can be prepared by one of minimal skill in programming and without reference to complex languages such as C or C++, thereby aiding the creation of a friendlier, easy to use interface to the navigation and control features of the present invention.

BRIEF DESCRIPTION OF THE DRAWINGS

The present invention may be better understood, and its numerous objects, features, and advantages made apparent to those skilled in the art, by referencing the accompanying drawings.

FIG. 1 is a schematic view of a computer system known in the art.

FIG. 2 is a view of a computer display according to one embodiment of the present invention.

FIG. 3 is a schematic diagram of the communications paths between an agent and a browser application according to one embodiment of the present invention.

FIG. 4 is a flowchart of the process for performing processing, navigation, and control of an arbitrary document, according to one embodiment of the present invention.

FIG. 5 is a flowchart of the detail steps within Parse Page step 450 of FIG. 4 .

FIG. 6 is a flowchart of the detail steps within Dynamically Modify Page Content step 460 of FIG. 5 .

FIG. 7 is a prior art image map as it appears to a user.

FIG. 8 is a segment of prior art HTML, code defining the image map of FIG. 7 .

FIG. 9 is a representative prior art web page as it appears to a user.

FIG. 10 is a segment of prior art HTML, code defining the web page of FIG. 9 .

FIG. 11 is the dynamically modified web page of FIG. 9 according to one embodiment of the present invention, showing the inserted voice-enabled tags.

FIG. 12 is a segment of the HTML code defining the dynamically modified web page of FIG. 11 .

FIG. 13 is a flow diagram of script language processing according to one embodiment of the present invention.

The use of the same reference symbols in different drawings indicates similar or identical items.

DETAILED DESCRIPTION

Introduction

The present disclosure is a method of operating a computer system to process an arbitrary document and provide a navigation and control interface to a user.

In the context of this disclosure, “navigation” refers to the user-directed viewing of or scrolling through a document on a computer. Such documents are those that are stored, manipulated, or displayed with the aid of a computer system and may consist of a wide variety of content, such as text or graphic images. Navigation also includes viewing or playing embedded animation (a sequence of timed and optionally branched frames, each frame composed of one or more static images), audio, or video clips. Furthermore, navigation includes the activation of hypertext links within a document and following those links to a new document. All of the above navigable elements are generally referred to in the art as “content.”

The term “control” refers generally to opening, speaking (i.e., causing the computer system to sound or read aloud, using a voice synthesizer or similar means, selected text content of a document) editing, or saving a document and its content, e.g., audio and video clips, text, hypertext, etc. These methods of control, known in the art, are typically provided by application and/or operating system software.

The term “page” or “web page” used in this disclosure refers to more than a single page in long document or a single page as known in the context of the World Wide Web. Rather, “page” includes any screen display of information in any form. Furthermore, although the Internet and in particular the World Wide Web, are described, those skilled in the art will realize that networks other than the Internet or the web can be used. One of ordinary skill in the art will appreciate that intranets, extranets, private LAN/WAN spaces, and generally any form of cyberspace construct may be used. Accordingly, the invention is not limited to documents presented on any particular type of network.

FIG. 1 is a computer system well known in the prior art. Computer system 10 comprises central processing unit (CPU) 20 , display 30 , keyboard 40 , mouse pointing device 50 , speakers 60 , and microphone 70 . A person of ordinary skill in the art will recognize that alternatives to input devices keyboard 40 and mouse 50 are readily available; accordingly, the present invention is not limited to computer systems having keyboard and mouse input devices only. Systems utilizing trackballs, eye-movement pointers, touch screens, and the like are also within the scope of the present invention.

Although a desktop personal computer is described, those skilled in the art will realize that computer systems other than a desktop personal computer can be used, such as embedded controllers, thin client network computers, television set-top boxes, telephones, pagers, or other advanced personal digital assistant (PDA) devices. Accordingly, the invention is not limited to any particular type of computer system.

The user interface according to one embodiment of the present invention is shown in FIG. 2 , which is a view of display 30 . Display 30 includes on it a conventional web browser window 210 , presenting a web page in text and graphic form to the user. Agent character 220 appears alongside window 210 . As will be discussed below, in addition to acting out animations and lip-syncing spoken text, aglent character 220 also presents a pop-up command menu 230 . Pop-up command menus are well known in the art.

One embodiment of the present disclosure includes the following basic navigation and control commands in pop-up command menu 230 :

Open/Go to {Link/Picture}: Saying “Open/Go to linkname” (linkname could be any link on HTML pages, includes dynamically modified pictures as well.) This is the same as clicking on linkname.

Go to Favorites: Goes to the designated favorites directory in the computer system. The agent will use the folder contents to build a new menu so that the user an also voice navigate contents of the favorites folder. It can drill down to a file and execute that file.

Read Page: Starts reading the text on the current page. Pauses after reading a paragraph or when the user hits the Scroll Lock key on the keyboard and asks if lie should continue or stop.

Read Selection: Starts reading the selected text within the current page. If no text is selected, the Agent will ask the user to make selection first.

Go Back—Goes back to the last page (same as clicking the back button on the toolbar)

Go Forward—Goes to the next page (same as clicking the forward button on the toolbar)

Stop—Stops the browser from completing the task (same as clicking the stop button)

Scroll Up—Same as Page up

Scroll Down—Continuously scroll down page

Scroll Left—Same as Page Left

Scroll Right—Same as Page Right

The agent interface program (or “agent”) that displays agent character 220 , in one embodiment of the present invention, operates “between” the user of the computer system and the target application program that the user wants executed. The agent responds to user inputs; such inputs may include commands to control the agent's own operation, e.g. quit, start speaking, stop speaking. Inputs may also include commands to be passed to the target application (represented by window 210 ), such as close application or, in the case of a web browser application, navigate to the page defined by a particular hypertext link.

The agent communicates with both the user and the target application. FIG. 3 shows the communication paths between agent control task 310 and browser application task 320 (also referred to as browser task, browser application, or simply browser) according to one embodiment of the present invention.

Browser task 320 is a program running on the computer system of FIG. 1 , displaying a set of windows to a user. In the embodiment of FIG. 3 , task 320 is a web browser application, though the present invention is not limited to web browsers. One window, launch pad window 322 , enables the user to start up agent control task 310 , among other browser application control functions. As with all windows on a modern computer, the window itself is merely the display manifestation of a software process or task executing in the computer's CPU, such as the display of a document. Here, launch pad window 322 is a manifestation of the launch pad subtask, executing as part of browser application task 320 .

Another subtask within browser application task 320 is messaging control task 324 , which is responsible for communicating between the launch pad browser, and agent control tasks.

The launch pad task also communicates, via messaging control task 324 , with other subtasks and applications, such as browser task 320 for web page navigation. Web browser window 210 , in one embodiment, is the displayed manifestation of the target web page (itself a document) presented by browser application task 320 .

In a typical interaction, browser task 320 is responsible for presenting web browser window 210 to the user. Browser task 320 sends a navigation event complete message 330 to agent control task 310 to indicate that the browser has completed loading the page. Agent control task 310 then executes script 340 , which may effect the presentation of browser window 210 or launch pad window 322 . Scripted operations may also include playing animations, speaking, and/or playing sounds, all of which may be manifested in agent display window 220 and through speakers 60 (shown in FIG. 1 ). Sound output, as called for in execute script 340 , is produced by speakers 60 in response to commands from agent control task 310 sent through sound control unit 370 . This sound control method is accomplished by conventional means well known in the art.

Processing Functions

FIG. 4 depicts the method employed by the agent-based interface in accordance with one embodiment of the present invention to navigate and control a document, including but not limited to a web page. The process begins at step 410 with initializing the agent software module. Sample C code used to initialize the agent in one embodiment of the present invention is as follows. While C and C++ are the languages used in the sample code snippets below, one skilled in the art recognizes that programming is not limited to these languages alone. Accordingly, the present invention is not limited to code written in the C or C++ language.

1) :

2) :

3) GetOptionsFromRegistry( );

4) m_pCWebBrowser2 = (CWebBrowser2 *)pCWebBrowser2;

5) m_pCWebBrowser2Nag = (CWebBrowser2 *)pCWebBrowser2Nag;

6) m_pCScopeDlg = (CDialog *)pCScopeDlg;

7)

8) m_pCAgentCtl = new CAgentCtl( );

9) ASSERT (m_pCAgentCtl);

10) m_pCAgentCtl->Create(NULL, WS_VISIBLE, CRect( ), (CWnd

*)this, ID_AGENT_CONTROL);

11) m_pIAgentCtlCharacters = new IAgentCtlCharacters(

m_pCAgentCtl->GetCharacters( ) );

12) m_varBstr.bstrVal =

GetCurrentCharacter( ).AllocSysString( );

13) m_pIAgentCtlCharacters->Load( (const char *)&lAgentID,

m_varBstr);

14) m_pICharacterAgent = new IAgentCtlCharacter(

m_pIAgentCtlCharacters->GetItem( (const char

*) &lAgentID) );

15)

16) keybd_event( GetAgentHotKey( ), 0×45,

KEYEVENTF_EXTENDEDKEY |0, 0 );

17) keybd_event( GetAgentHotKey( ), 0×45,

KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, 0);

18)

19) m_pIAgentCommands = new IAgentCtlCommands(

m_pICharacterAgent->GetCommands( ) );

20) m_pIAgentCommands->SetCaption( “Vaio Guide Commands”

);

21) m_pIAgentCommands->SetVoice( “Vaio Guide Commands”.);

22) m_pIAgentCommands->SetVisible(TRUE);

23) m_pIAgentCtlCommandsWindow = new

IAgentCtlCommandsWindow( m_pCAgentCtl-

>GetCommandsWindow( ) );

24)

25)

26) / / create event sink

27) m_pBrowserSink = new CBrowserSink;

28) ASSERT (m_pBrowserSink);

29) m_pBrowserSink->m_pParent = this;

30) LPUNKNOWN pUnkSink = m_pBrowserSink-

>GetControllingUnknown( );

31) ASSERT (pUnkSink);

32) IUnknown * pUnkSrc;

33) pUnkSrc = m_pCWebBrowser 2->GetControlUnknown( );

34) / / hook up sink with connection point

35) VERIFY (AfxConnectionAdvise(pUnkSrc, IID IBrowserSink,

pUnkSink, FALSE, &m_dwCookie) );

36)

37) GetVaioSpaceCommands( );

38) if (m_bShowCommandWnd) {

39) m_bShowCommandWnd = FALSE;

40) UpdatePage( );

41) m_bShowCommandWnd = TRUE;

42) } else

43) UpdatePage( );

44) RECT rect;

45) m_pCWebBrowser2Nag->GetWindowRect(&rect);

46) MoveAgentTo(rect.left- 30 , rect.bottom- 100 );

47) m_pICharacterAgent->Show(m_varFalse);

48) AgentIntroduction( );

49) :

50) :

In lines 8-14, the agent is created and the default agent character (in one embodiment, the Sony® VAIOMan) is loaded. Lines 16-17 allow the agent menu to be shown by simulating a keyboard key press. Lines 18-22 create, initialize, and load the agent commands window. Lines 23-32 create the event sink for the browser application so that the agent will know when the browser fires an event. Lines 33-43 identify default browser and agent interface commands. Lines 44-46 move the agent to its default location, make the agent visible, and execute the Agent Introduction function.

In step 412 , the agent software then displays the current page of the document to the user. Next, the agent dynamically modifies its pop-up menu options 415 for display to the user 418 to reflect the menu selections appropriate to the context in which the displayed page is presented, as identified in lines 33-37 of the code sample immediately above. Such dynamic modification includes, for instance, showing options for document saving, printing, or formatting; for navigating forward and back amongst previously displayed pages; and any other command unique to the application in which the page is presented.

In one embodiment, the Sony VAIO® Space II user interface, the agent begins operation with a default set of menu choices, representing a base set of features in the VAIO Space interface. These features, which are actually categories of responses to user selections, are as follows:

Software Center

Applications

Accessories

Audio/Video Center

Video

Audio

DVD

Online Center

Easy Internet

VAIO® Direct

Club VAIO®

Image Station

Internet

VAIO® Center

Desktop

Web Links

Tool Center

Tools

Options

Help Center

Sample code for implementing dynamic menu modification step 415 of the process, which is triggered when a page has been completely loaded into the navigation window, is as follows:

1) IShellFolderViewDual pShView( m_pcwebBrowser2-

>GetDocument( ) );

2) Folder pFolder(pShView.GetFolder( ) );

3) FolderItems pFolderItems(pFolder.Items( ) );

4) FolderItem pFolderItem;

5)

6) VARIANT varindex;

7) VariantInit(&varIndex);

8) V_VT(&varIndex) = VT_I4;

9) VARIANT varVerb;

10) VariantInit(&varVerb);

11) char szCommandName[INTERNET_MAX_URL_LENGTH];

12)

13) for(int i =0; i<pFolderItems.GetCount( ); i++) {

14) V_I4 (&varIndex) = i;

15) pFolderItem = FolderItem(pFolderItems.Item(varIndex)

);

16) sprintf(szCommandName, “2-I%d”, i);

17) AddInvisibleCommand( szCommandName,

pFolderItem.GetName( ), pFolderItem.GetName( ) );

Once the menu content is modified by the agent software, the menu is displayed to the user, 418 . The following snippet is sample code for displaying the commands in a popup window:

1) if(m_bShowCommandWnd) {

2) POINT oldCursorPoint;

3) GetCursorPos(&oldCursorPoint);

4)

5) SetCursorPos( m_pICharacterAgent->GetLeft( ) +

m_pICharacterAgent->GetWidth( ) /2, m_pICharacterAgent-

>GetTop( ) + m_pICharacterAgent->GetHeight( ) /2 );

6) mouse_event( MOUSEEVENTF_RIGHTDOWN, 0, 0, WHEEL_DELTA,

0);

7) mouse_event( MOUSEEVENTF_RIGHTUP, 0, 0, WHEEL_DELTA,

0);

8) SetCursorPos( oldCursorPoint.x, oldCursorPoint.y);

9)

At this point the process enters wait loop 420 , waiting on user input. In one embodiment, shown below, the agent waits for spoken (verbal) commands for a few seconds.

1) if(m_bAutoListen) {

2) keybd_event( GetAgentHotKey( ), 0×45,

KEYEVENTF_EXTENDEDKEY |0, 0 );

3) SetTimer (ID_LISTEN_TIMER, 5000 , NULL);

4) }

5)

6) OnTimer function

7) void OnTimer( (UINT nIDEvent)

8) {

9) if (nIDEvent == ID_LISTEN_TIMER)

10) {

11) keybd_event( GetAgentHotKey( ), 0×45,

KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, 0);

12) StopListenTimer( );

13) }

14)

15) COleControl: :OnTimer(nIDEvent);

16) }

Referring to FIG. 1 , among possible user inputs are the traditional methods of interacting with a computer such as using a keyboard 40 , mouse 50 , touch screen, trackball or other pointing device, as well as using voice input. Voice input in this context refers to speaking into a microphone 70 or other sound capturing device and having the computer system process that sound and recognize its command content.

The next step in the process of FIG. 4 is a test to see if voice input has been supplied to the computer, 425 . If there is no voice input, i.e., input is from hardware, 428 , such as keyboard 40 , mouse 50 , or other device, execution then proceeds to testing whether or not the user input is a navigation command, 435 .

If the user has spoken to the computer, that is to say given a voice command, the software processes the voice input 422 using conventional means. After this point processing behaves the same whether the input was through hardware means or via voice, execution proceeds to testing the input for a navigation command, step 435 .

If the user has chosen a command that does not require navigation through the document, i.e., does not call for moving forward or back a page or scrolling up and down within the current page or document, then the software executes the command chosen 440 by conventional means and loops back to waiting for user input, 420 . Such a non-navigating command includes, for example, Print, Save, Quit, and other commands well-known in the computing arts. It also includes commands to cause the agent to speak, i.e., to read selected text back to the user. In one embodiment of the present invention, when a Read Selection command is triggered, the agent starts reading the selected area. If no area is selected, the agent tells the user to select some text before issuing that command. Below is part of that code.

1) void ReadSelection( )

2) {

3) IHTMLDocument2 dIHTMLDocument2;

4) IHTMLSelectionObject dIHTMLSelectionObject;

5) IHTMLTxtRangedIHTMLTxtRange;

6) CString szSelectedText;

7) IHTMLFramesCollection2 dIHTMLFramesCollection2;

8)

9) dIHTMLDocument2 = m_pCWebBrowser2->GetDocument( );

10) dIHTMLFramesCollection2 = dIHTMLDocument2.GetFrames( );

11) if(dIHTMLFramesCollection2.GetLength( ) >0) {

12) IHTMLWindow2 dIHTMLWindow2;

13) IHTMLTxtRange dIHTMLTxtRange;

14) VARIANT varT;

15) VariantInit(&varT);

16) VARIANT varindex;

17) VariantInit(&varIndex);

18) V_VT(&varIndex) = VT_I4;

19)

20) for(int i=0 ; i<dIHTMLFramesCollection2.GetLength( );

i++) {

21) V_I4(&varIndex) =i;

22) varT = dIHTMLFramesCollection2.item(&varIndex);

23) dIHTMLWindow2 = varT.pdispVal ;

24) dIHTMLDocument2 = dIHTMLWindow2.GetDocument( );

25) dIHTMLSelectionObject =

dIHTMLDocument2.GetSelection( );

26) dIHTMLTxtRange =

dIHTMLSelectionobject.createRange( );

27) szSelectedText += dIHTMLTxtRange.GetText( );

28) }

29) else {

30) dIHTMLSelectionObject =

dIHTMLDocument2.GetSelection( );

31) dIHTMLTxtRange =

dIHTMLSelectionObject.createRange( );

32) szSelectedText = dIHTMLTxtRange.GetText( );

33) }

34)

35) if(szSelectedText.IsEmpty( ) )

36) szSelectedText=“Please use mouse to mark your

selection first!”;

37) m_pICharacterAgent->Speak( (char

*)LPCTSTR(szSelectedText) );

Web Page Navigation

On the other hand, if the user has chosen a navigation command then the software must open the selected web page or document in step 430 . In the context of a web page, this step comprises following a link to a new page, downloading that page's HTML codes, and processing those codes (within the browser application) into a screen display. In applications other than a web browser, a new document or a new window may be opened or displayed. Such navigation commands may also include scrolling up or down within the currently open document.

In one embodiment of the present invention, the scrolling function is implemented in the following) code snippet. When a Scroll Down command is issued, a scroll timer is set. Every 500 milliseconds, the display moves down (scrolls down) the web page by 20 pixels until the bottom of the page is reached or a stop scrolling command is issued. Although a fixed-speed scrolling embodiment is described, those skilled in the will art realize that scrolling at other than a fixed speed can be readily implemented. Accordingly, the invention is not limited to any particular scrolling speed.

1) void WebPageScrollDown( )

2) {

3) IHTMLDocument2dIHTMLDocument2( m_pCWebBrowser2- >GetDocument( ) );

4) IHTMLWindow2 dIHTMLWindow2 =

dIHTMLDocument2.GetParentWindow( );

5) IHTMLTextContainer dIHTMLTextContainer =

dIHTMLDocument2.GetBody( );

6) IHTMLControlElement dIHTMLControlElement =

dIHTMLDocument2.GetBody( );

7)

8) if( dIHTMLTextContainer.GetScrollTop( ) !=

dIHTMLTextContainer.GetScrollHeight( )−20 ) {

9) dIHTMLWindow2.scroll(dIHTMLTextContainer.GetScrollLe

ft( ) , dIHTMLTextContainer.GetScrollTop( )+20 );

10) SetTimer (ID_SCROLL_TIMER, 500 , NULL);

11) gbScrollTimerOn = TRUE;

12)

13) AddCommand(“2−Y”, “Stop scrolling”, L“Stop scrolling”, L“Stop [scrolling]”);

Web Page Parsing

Once the new page is opened by the process, the agent must parse the page, 450 , to identify its content, voice enabled features, and any commands specific to the context in which the page is displayed. FIG. 5 describes the process of parsing a web page in greater detail.

First, the process checks to see if the page opened is a system directory, such as a framed directory to VAIO Space features 451 in FIG. 5 . The process then searches 453 for the presence of image maps or untagged links within the page currently displayed (step Get HTML, Link Collection 453 ). An image map, in the web art, refers to a graphic image in which various regions of the figure, or the figure in its entirety, represent links to other documents or pages. FIG. 7 is an example of an image map within a web page displayed in browser window 210 , as it appears to a user. In typical use, image map 700 is not necessarily labeled (when presented to the user) as pointing towards other pages or documents. However, within the image map's HTML codes (shown in FIG. 8 ) are the necessary instructions to redirect the browser application to particular page, depending on the region within the image map selected by the user.

If collection 453 ( FIG. 5 ) finds that there are image maps or untagged links, i.e., links that do not have a voice enabled or readable text tag (such as the HTML “ALT” tag 810 in FIG. 8 ) associated with them, the process then dynamically modifies the page, (step 460 of FIG. 5 , further described in FIG. 6 ), to place voice enabled tags on all links within image maps and on the untagged links. Tagged links (those with an ALT tag 810 specified) are given the name defined by the ALT tag, steps 462 - 464 in FIG. 6 . These modifications are made to the page content prior to displaying the page to the user, step 412 of FIG. 4 .

FIG. 9 shows one example of a web page containing simple images maps. FIG. 10 is the HTML code that is used to present the page of FIG. 9 to the user.

FIG. 11 shows the web page of FIG. 9 after the dynamic page modification step 460 (referring to FIG. 5 ). Tags 710 , 711 , and 712 have been added to show the hyperlinks embedded in the page. Tag 720 shows the result of finding an embedded ALT tag in the HTML code of FIG. 10 .

Also depicted in FIG. 11 is the agent's ability to speak the text of the page, here the tag associated with hypertext link 720 . as depicted by word balloon 730 coming from Agent 220 . The modified HTML codes for the page are shown in FIG. 12 .

Appendix A contains an example of a C language program that can implement the dynamic page modification step 460 , according to one embodiment of the present invention. One of ordinary skill in the art will of course realize that other software languages and codings can be used to implement this function. Accordingly, the present invention is not limited to any particular language or coding or the particular program listing example of Appendix A.

If there are no image maps or other requirements to dynamically modify the page, the page is immediately displayed 412 to the user. At this point the entire process loops again through dynamic menu modification 415 and display menus 418 and enters the wait loop for user input 420 .

Referring to FIG. 3 , step 450 of the process shown in FIGS. 4-6 is performed by agent control task 310 . Agent control task 310 also identifies context-unique menu options specific to the chosen page, if any (steps 415 and 418 of FIG. 4 ). This latter function corresponds to get commands 350 .

Those skilled in the art will realize that the particular order of the operations depicted in FIG. 4 is purely illustrative. In fact, these operations can be performed in any order that does not violate the data dependencies described herein.

Scripting Language

In one embodiment of the present invention, the agent-based user interface is controlled by a high-level computer scripting language to better enable rapid, simplified creation of interface behaviors.

A script language (also referred to as a markup language) is a predefined set of commands and an associated command syntax that is interpreted by a script-executing program. Script-driven program operation is not new to the art; most modern compiler and communications programs arc driven by some form of script language. The result of the script interpretation is a longer list of computer instructions to be executed by another, separate program. Scripts are further detailed in Cheong, discussed above. Unlike many other computer languages, a script is a macro language consisting of short, relatively simple directives that in turn automatically cause a series of more complex computer instructions to execute.

The scripting embodiment of the present invention provides a rapid and easy to use means for customizing the user experience. The script itself is a text file formatted according to a particular syntax, disclosed herein. One example of a script in accordance with the present invention is the tour program created to introduce a user to the VAIO Space browser program and its agent-based interface.

The tour script is executed by agent control task 310 (FIG. 3 ). The tour script controls the behavior of the VAIOman character by controlling agent control task 310 . Agent control task 310 in turn controls agent display window 220 , passes messages to browser application task 320 via messaging control task 324 (execute script 340 ), and sends sounds and control signals to sound control unit 370 .

One of ordinary skill in the art will recognize that script language uses other than tour programs (themselves well known in the art) readily exist. Accordingly, the present invention is not limited to any particular use of the script language disclosed. Rather, the present invention encompasses within its scope any programming use that the script language may be adapted to by a programmer.

Script Language Syntax

A script file according to the present invention is written according to a predefined syntax and format. The script file consists of one or more sections separated by blank lines. Each section begins with a name token of the form:

[Section Tag]

where Section Tag is the name of the section. The square brackets denote the line as a section tag. For clarity, sections may be broken into subsections by inserting blank lines. A section consists of all lines between one section tag and the next.

Each non-blank line in a section represents a particular operation and is in the form

Operator: Operand

where Operator is the command token and Operand is the specific argument to be used by the command. The operand must be defined when the script is written as a data value of the correct type, e.g. a character string or an integer variables as operations are not supported; there is no user interaction with the script file content other than script execution.

In the VAIO Space scripting embodiment there are only seven operators. These operators and their corresponding operands are:

NavigateToPage: URL

MoveTo: x, y

GestureAt: x, y

LoopAnimation: Animation_name, duration

PlayAnimation: Animation_name2

SpeakText: Speak_Text

SpeakWav: Speak_Wav

wherein each operand refers to the following:

URL—Uniform Resource Locator (URL), as used in the World Wide Web/Internet art, of the particular page to show in the VAIO Space navigation section.

x, y—Location on the screen relative to the origin that the character moves to (MoveTo operator) or gestures toward (GestureAt operator).

Animation_name—File name for the special looping animations that the character plays for the specified duration. An animation is defined generally as a sequences of timed and optionally branched frames, each frame composed of one or more static images. These animations are, for example, Processing, Searching, Writing, etc. These animations require user intervention to stop and prevent the character from doing anything else while playing the animation. This is essentially why duration needs to be specified. Looping stops after the specified time has elapsed.

Animation_name2—This is a one-shot, non-looping animation for the character to play. This animation is a standard animation and requires no user intervention to stop it. If SpeakText is specified, the character speaks while displaying this animation.

Speak_Text—This is the text the character will speak. The text appears in the word balloon of the character while it speaks. If a Speak_Wav is given, this text is shown in the balloon while the character is playing the recorded file; in such case the character appears to be lip-synching.

Speak_Wav—A Wav file or linguistically formatted file (.lpv) that the character will play. If SpeakText is provided then Speak_Text appears in the character's balloon while the recording is being played. If no SpeakText is provided, the balloon is empty and invisible (such as when a Wav file is specified) or the text associated in the linguistically formatted .lpv file is used.

In an alternate embodiment of the present script language, multiple operations are present in a single line of the script file, separated by a delimiter character. The delimiter may be a single character, such as the tab character, or a character string, such as “++”.

Sample Script

The following is an example of a script language code snippet used to describe the “Software Center” aspect of VAIO Space. This description is accomplished by presenting to the user an auditory and visual depiction of the function of the “Software Center.”

1) [SOFTWARE CENTER]

2) MoveTo: 160 , 150

3) LoopAnimation: Processing, 5

4) GestureAt: 200 , 300

5) SpeakText: This is the software center of VAIO Space

2.0.

6)

7) PlayAnimation: GestureLeft

8) SpeakText: You store your software in here.

9)

10) MoveTo: 300 , 40

11) PlayAnimation: GestureUp

12) SpeakWav: C:\wavfiles\softwarecenter.wav

13)

14) [New Section Tag]

15) :

16) :

In this instance, the [Software Center] section denotes the part of the script that activates in response to user selection of the “Software Center” category as a destination in the VAIO Space tour. In response to the user's choice, the character moves to location 160 , 150 on the screen, displays the “Processin” animation for 5 seconds, gestures toward location 200 , 300 on screen and says “This is the software center of VAIO Space 2.0” while still gesturing. Then it gestures left and says “You store your software in here.” Finally, it moves to location 300 , 40 on the screen and, while gesturing up, plays the “softwarecenter.wav” file and lip-syncs as the recording is playing. The word balloon is not displayed during the Wav file playback.

VAIO Space Tour Example

The interactive VAIO Space tour program is designed to help the user become familiar with VAIO Space. The tour provides a user friendly, interactive presentation instead of the usual canned (pre-recorded, non-interactive) tour seen in the prior art. In the tour program, the actions and behaviors of the agent are controlled by the tour script. Sections of the tour script file are read and executed by the tour program in response to user inputs and actions.

When the tour program starts up, the VAIOman character 220 ( FIG. 2 ) is created and displayed in its own window. A popup menu 230 showing the different command options presently available is displayed. Among the command options are a list of topics or categories representing major subdivisions of the tour. Applying the metaphor of a walking tour, the categories present virtual “places” from which to begin. (One example of a starting place is the Software Center discussed above.) The user then simply tells the program, either via speech or mouse, from which category to start the tour. The script for that category (and subsequent categories) is read as needed by the tour program; the character performs the actions specified by the script.

Referring to FIG. 3 , the tour program communicates with the VAIO Space browser program (or task) 320 by means of a registry and messages well known in the programming art. This registry and message interface is represented by messaging control task 324 . The VAIO Space browser task 320 handles navigation and synchronization. The following code snippet shows how messages are passed.

1) m_VaioProfiler.SetValueString (“Page”, NavPage, 255);

2) m_DoneNavigating = FALSE;

3)

4) / / Send scope to navigate that Page

5) : :SendMessage(m_hVaioWnd, WM_NAVIGATE_PAGE, 0,

(LPARAM) m_hWnd);

During the tour, the program can be interrupted by either clicking on or double clicking on the agent character, or by hiding the character. When the tour is asked to continue, it can continue from where it stopped or it can start from the beginning. One can also quit the tour by choosing the Quit command from the agent character's popup menu 230 (FIG. 2 ).

When a specific category is chosen from the character's menu (or recognized as spoken input), the tour program interprets the selected category name as the section tag and executes the corresponding section of the script. The character then performs the actions specified. The tour program accesses the script file section for a particular category only once for the lifetime of the tour program.

A linked list (an agent program-defined structure) is maintained and used to store the category names and the script section corresponding to each category. Below is a sample structure:

1) typedef struct tagScript{

2) int moveTo[2];

3) int gestureAt[2];

4) CString playAnimation;

5) CString loopAnimation;

6) int loopAnimationPlayLength;

7) CString speakText;

8) CString speakWav;

9) CString navigatePage;

10) struct tagScript *next;

11) }SCRIPT, *LPSCRIPT;

12)

13) typedef struct tagCategories {

14) CString CategoryName;

15) LPSCRIPT CategoryScript;

16) struct tagCategories *next;

17) } CATEGORIES, *LPCATEGORIES;

The initial menu in the VAIO Space tour consists of the following category choices and commands:

Introduction

Start from Software Center

Start from AV Center

Start from Online Center

Start from Tool Center

Start from Help Center

Start from Continue Tour

Start from Restart Tour

Quit Tour

Although the initial menu specific to the VAIO Space T our is described, those skilled in the will art realize that menus other than this example can be used. Accordingly, the invention is not limited to any particular menu configuration as an initial starting presentation to the user.

Script Execution

The order of the actions followed by the agent in executing a particular category script is as shown in FIG. 13 .

Script execution begins by causing the browser application to open the page specified by the NavigateTo URL, 1310 , if specified. The agent display window 220 (FIG. 2 ), i.e., the agent's physical manifestation on the computer display, then moves to the specified x, y screen location, 1320 . If a looping animation file is specified, it is played for the time given by duration, 1330 .

Once any looping animation concludes, or if no looping animation is specified, the agent display will gesture towards the display location x, y specified, 1340 . Note that, as with the looping animation, the GestureAt step may be omitted.

After gesturing, the regular or one-shot animation, if any, is played, 1350 .

Agent speech begins at step 1360 . While the agent speaks (lip-syncs) the specified text, a word balloon 730 ( FIG. 11 ) appears above its head. The word balloon feature may be enabled and disabled by the user. In the event that a recorded file is specified without speech, the file (Wav or .lpv) is output through the computer's sound subsystem; the agent does not lip-sync nor is the word balloon displayed.

Other than looping animations, which require user intervention to stop (hence the duration requirement), other animations and gesture-at actions are played while the character speaks.

If any operation is omitted the script does not perform it. Every script section has at a minimum one operation, but no operation is mandatory.

If the tour program is interrupted, the character is put into an idling state or hidden, at the user's option. The user can restart the tour, go to the same or different category, or quit. While the character is in an idling state (or hidden), the user can continue working with the VAIO Space browser or another application and return to the tour later.

If at any time in the tour the agent interface program is shut down (i.e., agent control task 310 terminates), the tour quits. If the VAIO Space browser program 320 is not running, the tour will not start. When a particular tour guide character 220 is created at tour program initialization, any agent character(s) previously created are temporarily hidden and not shown until the tour ends.

When the user elects to start the tour from one of the VAIO Space categories, the tour is set on a timer and the synchronization between navigation in VAIO Space and the agent script is set up. A new page cannot be navigated (or a new tour section run) unless the previous script has finished execution. Below is the part of the code that handles this synchronization.

1) BOOL found = FALSE;

2) AgentStopAll ( );

3)

4) BeginTour( );

5)

6) while(!found && m_pCurrentCategory)

7) {

8) if (m_pCurrentcategory->CategoryName == cmdName)

9) {

10) found = TRUE;

11) break;

12) }

13) m_pCurrentCategory =m_pCurrentCategory->next;

14) }

15)

16) if(found)

17) {

18) BOOL scriptFound = FALSE;

19) CString sectionName;

20) if (cmdName == “Introduction”)

21) {

22) sectionName = m_pCurrentCategory->CategoryName;

23) if(m_pCurrentCategory->CategoryScript == NULL)

24) {

25) sectionName.MakeUpper( );

26) scriptFound = GetScript(CString(“[” + sectionName +

“]”) );

27) }

28) if(scriptFound)

29) {

30) m_pScriptReader = 0 m_pCurrentCategory->CategoryScript;

31) ReadIntroduction( );

32) }

33) }

34) else

35) {

36) if(!m_bTimerSet)

37) {

38) m_bTimerSet = TRUE;

39) SetTimer(TOUR_EVENT_ID, 2000 , NULL);

40) ReadNextScript( );

41) }

42) }

43) }

44) else

45) {

46) CString csSpeak = CString(“Could not find the selected

section −”) + cmdName;

47) AgentSpeak(csSpeak, “”);

48) }

49)

50) if(!m_pCurrentCategory)TourOver( );

The part of the synchronization code residing within the timer handler function is as follows:

1) if(nIDEvent == TOUR_EVENT_ID)

2) {

3) if(m_bScriptFinished && m_bDoneNavigating)

4) {

5) m_bScriptFinished = FALSE;

6) if(m_pCurrentCategory)

7) {

8) ContinueTour( );

9) m_pCurrentCategory = m_pCurrentCategory->next;

10) }

11) }

12) else

13)

14) if(m_bDoneNavigating && m_bSpeechEnded)

ReadNextScript( );

CONCLUSION

Thus, as shown and disclosed herein, the present invention enables navigation and control of an arbitrary computer realized document, using in some embodiments voice recognition and/or an agent-based user interface. The present invention addresses shortcomings in the prior art relating to web pages with embedded image maps and untagged links, sightless users, and the complexity and inflexibility of prior art agent software. By presenting a voice enabled interface to the user, tailored to both document/web page content and applications, the present invention improves upon the current state of the art. Furthermore, the present invention facilitates computer use, especially web surfing, by the sightless via its capacity to read back the content of any document or web page, including context sensitive menu options and embedded hypertext links common to web pages.

Furthermore, the present invention enables the rapid creation of executable code for controlling the behaviors and functionality of a software agent operating in conjunction with an agent-based navigation system. Using the present invention, a programmer can rapidly prepare an executable agent script that can immediately be performed by an agent in response to a user input or external stimulus, such as receipt of a message or an application program event. The present invention also provides added utility by virtue of its simplicity. Agent scripts can be prepared by one of minimal skill in programming and without reference to complex languages such as C or C++.

Sony® and VAIO® are registered trademarks and VAIOMan and VAIO Space II are trademarks of Sony Corp. of America, San Jose, Calif. Microsoft® is a registered trademark and ActiveX is a trademark of Microsoft Corp., Redmond, Wash.

While particular embodiments of the present invention have been shown and described, it will be obvious to those skilled in the art that changes and modifications may be made without departing from this invention in its broader aspects and, therefore, the appended claims are to encompass within their scope all such changes and modifications as fall within the true spirit and scope of this invention.

APPENDIX A
Sample C Language Program Listing: Dynamic Page Modification function
The following code excerpt is © 1999 Sony Corp. of America.
void CVaioAgentCtrl::UpdateLinks( )
{
IHTMLWindow2           dIHTMLWindow2;
IHTMLFramesCollection2 dIHTMLFramesCollection2;
IHTMLDocument2         dIHTMLDocument2;
IHTMLBodyElement       dIHTMLBodyElement;
IHTMLTxtRange          dIHTMLTxtRange;
IHTMLFrameBase         dIHTMLFrameBase;
VARIANT varT;
VariantInit(&varT);
VARIANT varIndex;
VariantInit(&varIndex);
V_VT(&varIndex) = VT_I4;
iLinkNumber = 0;
iImageLinkNumber = 0;
lReadingTextPoint = 0;
TRY{
dIHTMLDocument2 = m_pCWebBrowser2−>GetDocument( );
CString szTitle = “You are at ” +
dIHTMLDocument2.GetTitle( );
m_pICharacterAgent−>Speak((char *)LPCTSTR(szTitle)
);
m_pCWebBrowser2−>SetForegroundWindow( );
szTitle = dIHTMLDocument2.GetUrl( );
if(szTitle.Find(“C:/SonySys/Vaio2.0/Panels/”) != −1
){ // Sony customerized page
IHTMLElementCollection dIHTMLElementCollection =
dIHTMLDocument2.GetAll( );
IHTMLElement dIHTMLElement;
IHTMLFrameElement dIHTMLFrameElement;
for(int i=0;
i<dIHTMLElementCollection.GetLength( ); i++) {
V_I4(&varIndex) = i;
dIHTMLElement          =
dIHTMLElementCollection.item(varIndex, varIndex);
TRACE(“Tag is %s\n”,
dIHTMLElement.GetTagName( ));
//make sure it is VaioSpace customerized page,
check ID in html tag
if( dIHTMLElement.GetTagName( ) == “HTML” )
if( dIHTMLElement.GetId( ) != “VaioSpace
HTML” )
break;
if( dIHTMLElement.GetTagName( ) == “FRAME” &&
dIHTMLElement.GetId( ) == “VaioSpace Folder” ) {
dIHTMLFrameElement =
dIHTMLElementCollection.item(varIndex, varIndex);
IWebBrowser2
dIWebBrowser2(dIHTMLFrameElement);
TRACE(“GetLocationURL( ) is %s\n”,
dIWebBrowser2.GetLocationURL( ) );
LPDISPATCH lpDisp =
dIWebBrowser2.GetDocument( );
if(!lpDisp) {
m_pICharacterAgent−>Speak(“NULL
Pointer!”);
return;
}
IShellFolderViewDual pShView( lpDisp );
Folder pFolder(pShView.GetFolder( ));
FolderItems pFolderItems(pFolder.Items( ));
FolderItem pFolderItem;
char
szCommandName[INTERNET_MAX_URL_LENGTH];
if( !AddDefaultBrowserCommand(TRUE) )
return;
for(int j=0; j<pFolderItems.GetCount( );
j++) {
V_I4(&varIndex) = j;
pFolderItem =
FolderItem(pFolderItems.Item(varIndex) );
sprintf(szCommandName, “2−i%d”, j);
AddInvisibleCommand( szCommandName,
pFolderItem.GetName( ), pFolderItem.GetName( ));
//AddCommand( szCommandName,
pFolderItem.GetName( ), pFolderItem.GetName( ));
}
return
}
}
}
if( !AddDefaultBrowserCommand( ) ) return;
// enum the frames
dIHTMLFramesCollection2 =
dIHTMLDocument2.GetFrames( );
if(dIHTMLFramesCollection2.GetLength( ) > 0) {
TRACE(“we have %d frames\n”,
dIHTMLFramesCollection2.GetLength( ) );
szReadingText = “ ”;
for(int i=0;
i<dIHTMLFramesCollection2.GetLength( ); i++) {
V_I4(&varIndex) = i;
varT =
dIHTMLFramesCollection2.item(&varIndex);
dIHTMLWindow2 = varT.pdispVal;
dIHTMLDocument2 = dIHTMLWindow2.GetDocument( );
dIHTMLBodyElement = dIHTMLDocument2.GetBody( );
dIHTMLTxtRange =
dIHTMLBodyElement.createTextRange( );
szReadingText += dIHTMLTxtRange.GetText( );
AddLinksFromDocument (dIHTMLDocument2);
}
}
else {
dIHTMLBodyElement = dIHTMLDocument2.GetBody( );
dIHTMLxtRange =
dIHTMLBodyElement.createTextRange( );
szReadingText = dIHTMLTxtRange.GetText( );
AddLinksFromDocument(dIHTMLDocument2);
}
}
CATCH_ALL(e)//catch(CException* excp)
{
e−>Delete( );
m_pICharacterAgent−>Speak(“I have some problem to
retrieve information about this page! Sorry for that!” );
}
END_CATCH_ALL
}
void CVaioAgentCtrl::AddLinksFromDocument(IHTMLDocument2
dIHTMLDocument2)
{
IHTMLElementCollection dIHTMLElementCollection;
IHTMLElement           dIHTMLElement;
IHTMLElementCollection dChildIHTMLElementCollection;
IHTMLElement           dChildIHTMLElement;
IHTMLImgElement        dChildIHTMLImgElement;
IHTMLAnchorElement     dIHTMLAnchorElement;
VARIANT varName, varIndex;
VariantInit(&varName);
VariantInit(&varIndex);
V_VT(&varName) = VT_ERROR;
V_ERROR(&varName) = DISP_E_PARAMNOTFOUND;
V_VT(&varIndex) = VT_I4;
// for image tag inside of a link
VARIANT varChildIndex;
VariantInit(&varChildIndex);
V_VT(&varChildIndex) = VT_I4;
char szPictureNumber[20];
char szCommandName[INTERNET_MAX_URL_LENGTH];
CString szVoice;
CString szCaption;
CString szTemp;
CString szAltText;
dIHTMLElementCollection = dIHTMLDocument2.GetLinks( );
for(int i=0; i<dIHTMLElementCollection.GetLength( );
i++) {
V_I4(&varIndex) = i;
dIHTMLAnchorElement =
dIHTMLElementCollection.item(varIndex, varName);
dIHTMLElement          =
dIHTMLElementCollection.item(varIndex, varName);
sprintf(szCommandName, “2-N%d”, iLinkNumber++);
if (dIHTMLElement.GetInnerText( ) == “ ” ∥
dIHTMLElement.GetInnerText( ) ==“ ”)
{
if(dIHTMLElement.GetTagName( ) == “A”){ // should
be a image link
dChildIHTMLElementCollection =
dIHTMLElement.GetChildren( );
for(int j=0;
j<dChildIHTMLElementCollection.GetLength( ); j++) {
V_I4(&varChildIndex) = j;
dChildIHTMLElement =
dChildIHTMLElementCollection.item(varChildIndex,
varName);
if( dChildIHTMLElement.GetTagName( ) ==
“IMG” ) {
dChildIHTMLImgElement =
dChildIHTMLElementCollection.item(varChildIndex,
varName);
szCaption =
dChildIHTMLImgElement.GetAlt( );
}
}
if (szCaption== “ ” ∥ szCaption == “ ”)
{
sprintf(szPictureNumber, “ %d”,
iImageLinkNumber);
szCaption = (CString) “picture” +
szPictureNumber;
iImageLinkNumber++;
}
szTemp = “<br>” + szCaption;
dIHTMLElement.insertAdjacentHTML(“BeforeEnd”,
(LPCTSTR)szTemp);
}
else
szCaption = “Area Link”;
} else {
szCaption = dIHTMLElement.GetInnerText( );
}
if( szCaption != “Area Link”) // will not add area
links
//AddCommand( szCommandName,
dIHTMLAnchorElement.GetHref( ), szCaption);
AddInvisibleCommand( szCommandName,
dIHTMLAnchorElement.GetHref( ), szCaption);
}
}

Claims

1. A method of processing a document with a computer system, the method comprising:the computer system reading a code for a non-textual visual feature in the document; and the computer system generating a signal informing a user of the non-textual visual feature, said signal comprising an audio signal and a textual tag created in response to said code; wherein the non-textual visual feature is associated with one or more hyperlinks and said signal informs the user that the non-textual visual feature is associated with said hyperlinks.

2. The method of claim 1 wherein generating said signal comprises the computer system speaking all or part of said document while scrolling said document in synchronization with said speaking.

3. The method of claim 2 wherein said scrolling has a variable speed selected by the user.

4. A computer system comprising computer instructions for:reading a code for a non-textual visual feature in a document; and generating a signal informing a user of the non-textual visual feature, said signal comprising an audio signal and a textual tag created in response to said code; wherein the non-textual visual feature is associated with one or more hyperlinks and said signal informs the user that the non-textual visual feature is associated with said hyperlinks.

5. The computer system of claim 4 wherein generating said signal comprises the computer system speaking all or part of said document while scrolling said document in synchronization with said speaking.

6. The computer system of claim 5 wherein said scrolling has a variable speed selected by the user.

7. The computer system of claim 4 wherein said computer instructions are created by:a computer system reading a computer program written in a scripting language, said scripting language including a plurality of operations which do not specify for each operation how the operation is to be implemented by the computer system, said operations each comprising an operator having, optionally, one or more operands; executing said computer program, wherein said executing comprises: parsing each line of said computer program written in said scripting language into one of said plurality of operations, decomposing each of said operations into said operator and said optional operand or operands, performing the function of said operator using said operand or operands, when present, by translating said scripting languagre operation into one or more program instructions recognizable by said computer system that together implement said operation; and displaying the results of said performance to a user; wherein said computer system comprises computer instructions for providing an agent-based user interface.

8. The computer system of claim 7, wherein said scripting language further comprises a plurality of category types each identified by a unique category name, wherein said category name denotes a group of said operations, and wherein reading said group is accomplished in response to a user input to said computer system.

9. The computer system of claim 7, wherein said scripting language further comprises pairs of said operators and said optional operands written as one pair per line of said computer program.

10. The computer system of claim 7, wherein said scripting language further comprises pairs of said operators and said optional operands written as a plurality of pairs per line of said computer program each separated by a delimiter symbol, said delimiter symbol comprising one or more characters.

11. The computer system of claim 7 wherein said computer system comprises at least computer instructions for executing an agent-driven application.

12. A computer readable storage medium comprising computer instructions for:reading a code for a non-textual visual feature in a document; and the computer system generating a signal informing a user of the non-textual visual feature, said signal comprising an audio signal and a textual tag created in response to said code; wherein the non-textual visual feature is associated with one or more hyperlinks and said signal informs the user that the non-textual visual feature is associated with said hyperlinks.

13. The computer readable storage medium of claim 12 wherein generating said signal comprises the computer system speaking all or part of said document while scrolling said document in synchronization with said speaking.

14. The computer readable storage medium of claim 13 wherein said scrolling has a variable speed selected by the user.

15. The computer readable storage medium of claim 12 wherein said computer instructions are created by:a computer system reading a computer program written in a scripting language, said scripting language including a plurality of operations which do not specify for each operation how the operation is to be implemented by the computer system, said operations each comprising an operator having, optionally, one or more operands; and said computer system generating one or more instructions that together perform said operations; wherein said computer system comprises computer instructions for providing an agent based interface.

16. The computer readable storage medium of claim 15, wherein said scripting language further comprises a plurality of category types each identified by a unique category name, wherein said category name denotes a group of said operations, and wherein reading said group is accomplished in response to a user input to said computer system.

17. The computer readable storage medium of claim 15, wherein said scripting language further comprises pairs of said operators and said optional operands written as one pair per line of said computer program.

18. The computer readable storage medium of claim 15, wherein said scripting language further comprises pairs of said operators and said optional operands written as a plurality of pairs per line of said computer program each separated by a delimiter symbol, said delimiter symbol comprising one or more characters.

19. The computer readable storage medium of claim 15 wherein said computer system comprises at least computer instructions for executing an agent-driven application.

20. A computer data signal embodied in a carrier wave, the computer data signal comprising computer instructions for:reading a code for a non-textual visual feature in a document; and the computer system generating a signal informing a user of the non-textual visual feature, said signal comprising an audio signal and a textual tag created in response to said code; wherein the non-textual visual feature is associated with one or more hyperlinks and said signal informs the user that the non-textual visual feature is associated with said hyperlinks.

21. The computer data signal of claim 20 wherein generating said signal comprises the computer system speaking all or part of said document while scrolling said document in synchronization with said speaking.

22. The computer data signal of claim 21 wherein said scrolling has a variable speed selected by the user.

23. The computer data signal of claim 20 wherein said computer instructions are created by:a computer system reading a computer program written in a scripting language, said scripting language including a plurality of operations which do not specify for each operation how the operation is to be implemented by the computer system, said operations each comprising an operator having, optionally, one or more operands; and said computer system generating one or more instructions that together perform said operations; wherein said computer system comprises computer instructions for providing an agent based interface.

24. The computer data signal of claim 23, wherein said scripting language further comprises a plurality of category types each identified by a unique category name, wherein said category name denotes a group of said operations, and wherein reading said group is accomplished in response to a user input to said computer system.

25. The computer data signal of claim 23, wherein said scripting language further comprises pairs of said operators and said optional operands written as one pair per line of said computer program.

26. The computer data signal of claim 23, wherein said scripting language further comprises pairs of said operators and said optional operands written as a plurality of pairs per line of said computer program each separated by a delimiter symbol, said delimiter symbol comprising one or more characters.

27. The computer data signal of claim 23 wherein said computer system comprises at least computer instructions for executing an agent-driven application.