(12) United States Patent
`Lindhorst et al.
`
`111111111111111111111111111111111111111111111111111111111111111111111111111
`US006268852Bl
`US 6,268,852 Bl
`*Jul. 31, 2001
`
`(10) Patent No.:
`(45) Date of Patent:
`
`(54) SYSTEM AND METHOD FOR
`FACILITATING GENERATION AND
`EDITING OF EVENT HANDLERS
`
`(75)
`
`Inventors: Greg Lindhorst, Woodinville; John
`Buehler, Redmond; Martin Sonntag,
`Kirkland; Randall Lee Kerr, Redmond,
`all of WA (US)
`
`(73) Assignee: Microsoft Corporation, Redmond, WA
`(US)
`
`( *) Notice:
`
`This patent issued on a continued pros(cid:173)
`ecution application filed under 37 CFR
`1.53( d), and is subject to the twenty year
`patent term provisions of 35 U.S.C.
`154(a)(2).
`
`Subject to any disclaimer, the term of this
`patent is extended or adjusted under 35
`U.S.C. 154(b) by 0 days.
`
`(21) Appl. No.: 08/867,011
`
`(22) Filed:
`
`Jun. 2, 1997
`
`(51)
`(52)
`
`(58)
`
`Int. Cl? ................................. G06F 3/14; G06F 9/44
`U.S. Cl. .......................... 345/335; 345/967; 345/346;
`709/315; 709/318; 707/513; 717/2; 717/10
`Field of Search ..................................... 345/335, 966,
`345/967, 970, 346, 348, 333, 334, 356,
`357, 353, 352; 709/303, 302, 328, 329,
`315, 316, 318; 395/703, 702, 710; 707/501,
`513; 717/3, 2, 10
`
`(56)
`
`References Cited
`
`U.S. PATENT DOCUMENTS
`5,206,951 *
`5,438,659 *
`5,713,045 *
`5,717,877 *
`5,760,788
`5,883,623 *
`5,890,170 *
`
`4/1993 Khoyi eta!. ......................... 709/303
`8/1995 Notess et a!. ........................ 345/335
`1!1998 Berdahl ............................ 709/303 X
`2/1998 Orton eta!. ..................... 345/348 X
`6/1998 Chainini et a!. ................. 345/967 X
`3/1999 Cseri .................................... 345/335
`3/1999 Sidana .................................. 707/501
`
`OTHER PUBLICATIONS
`the Internet", Windows
`Bonner, "Visual Basic Meets
`Sources, vol. 4 No. 5, p. 203, May 1996.*
`"Microsoft Intros Web Development Tools", Newsbytes,
`Jun. 10, 1996.*
`"Microsoft Announces Immediate Availability of ActiveX
`Control Pad", The PointCast Network™ , Aug. 21, 1996.
`"ActivatingActiveX", Internet World, Web Page Workshop,
`by Aaron Weiss, Jan. 1997, pp. 108-112.
`"Sample Pages for the Microsoft ActiveX Control Pad and
`HTML Layout Control", Microsoft db Web, http://www.mi(cid:173)
`crosoft.com/ie/controls/layout/samples.htm, Microsoft Cor(cid:173)
`poration, Jun. 7, 1996.
`"ActiveX Control Pad Tutorial", http://www.microsoft.com/
`workshop/author/cpad/tutorial.htm, Microsoft Corporation,
`1996.
`"The Microsoft ActiveX Control Pad", http://www.mi(cid:173)
`crosoft.com/workshop/author/cpad/apad.htm, Microsoft
`Corporation, Jun. 5, 1996.
`"Frequently Asked Questions About Developing Web Pages
`Using ActiveX Controls", http://www.ms.eunet.ro/work(cid:173)
`shop/prog/controls/ctrlfaq.htm, Microsoft Corporation, Jun.
`25, 1996.
`"ActiveX Controls", Microsoft Site Builder Workshop(cid:173)
`Microsoft Internet Explorer, May 24, 1996.
`* cited by examiner
`Primary Examiner-Raymond J. Bayerl
`(74) Attorney, Agent, or Firm-Banner & Witcoff, Ltd.
`(57)
`ABSTRACT
`
`A method and system for creating and editing event handlers
`that link events triggered on one object to actions taken on
`one or more different objects. The method provides a user
`interface having an event pane, action pane and codepane. A
`user selects an event icon in the event pane to link that event
`to a desired action in the action pane. The code that is
`generated in the code pane can be displayed in either a list
`view or a code view. In the list view, the event handler is
`presented to the user in simple, concise statements that are
`easy for the user to understand. In the code view, the actual
`event handler code in either VBScript or JavaScript lan(cid:173)
`guages is presented to the user.
`
`63 Claims, 8 Drawing Sheets
`
`1.SelectanEvent: 32
`EH:l w1ndow
`i~lf""l-­
`/~d 34
`40b 40a~
`
`12
`(
`
`62
`
`20
`
`r'
`
`1::·~ w~:wures ~
`52 [··ill alert
`45
`~clearTimoout
`;::~ ::m~
`f·-[l]fire0nload5Q
`f··fl]fireOnUnload
`1::~ ~:;~ate
`f--W prompt
`!--Ul se!Timeoul
`l--61 d9faultSiatus[w]
`$--!jl document
`Ej:Hi':l
`frames
`54
`S6ijHi:l history
`~'"~""...-!
`$~-(i)~tor
`
`64
`~~~========~~~©\
`~ListV1ew
`~CoOOView ~~~
`30
`
`60a
`
`60b
`
`\
`
`10
`
`BLUE COAT SYSTEMS - Exhibit 1045 Page 1
`
`

`
`U.S. Patent
`
`Jul. 31, 2001
`
`Sheet 1 of 8
`
`US 6,268,852 Bl
`
`2. Insert Actions:
`t=p··fl' Procedures ~
`B··el window
`45
`52 t··OJ alert
`~ clearTimeout
`close~
`f·· OJ confirm
`f·· OJ
`fireOnLoad 50
`f·· OJ
`fireOnUnload
`f·· OJ navigate
`f·· OJ open
`~-· [!J prompt
`f·· [!J setTimeout
`f·· 61 defaultStatus [w]
`~-·lll document
`$··lll frames
`54
`56 ~-· ~ histo~
`~ location__.)
`,
`!name I
`Eil··lll navigator
`J.o.
`
`1. Select an Event: 32
`S··Cl window ._-
`f ... ~nloadl~
`:.( onUnload 34
`
`40b 40a ~
`t
`
`12
`
`62
`
`Sub window onload ( )
`window.name = ''Test Document"
`
`(
`6 4
`
`<II
`
`~
`
`(
`
`/
`30
`
`~
`1-
`
`20
`~
`
`""""
`
`v
`""""
`
`~
`
`1-
`v
`
`I~
`
`Help I
`
`~List View
`\
`
`60a
`
`~Code View I OK
`60b
`
`\
`
`II Cancel
`
`II
`
`\
`
`10
`
`FIG. 1
`
`BLUE COAT SYSTEMS - Exhibit 1045 Page 2
`
`

`
`U.S. Patent
`
`Jul. 31, 2001
`
`Sheet 2 of 8
`
`US 6,268,852 Bl
`
`1. Select an Event
`B-·E:I window
`t·· • lonloadl
`: .•. 0 onUnload
`
`12\...
`
`75
`I
`
`2. Insert Actions:
`r·l!.J (.;0 10 1-'age ...
`f·· e GlobaiVariables
`f·· e Procedures
`~-·E:J window
`f·· [!] fireOnLoad
`f·· [!] fireOnUnload
`f·· i!l defaultStatus [w]
`~-·e document
`$··e frames
`$··e history
`l:il··e tocauon
`f .. Bl name I
`E$Htl navigator
`$··e parent
`$··e self
`f·· i!l status [w]
`Eil··e top
`
`20
`~
`
`L>.
`f-
`
`f-
`
`I-
`
`I-
`v
`
`.--- On window onload Perform the following Actions
`Object
`Action
`window
`Change name to "Test Document•
`
`j
`{o
`
`88b
`84
`88a
`86
`90
`{ l~l {
`Modify Value J
`I Insert Action J I Delete Action
`~UstView ~Code View I OK
`II Cancel
`'
`60a
`60b
`\
`
`\
`
`10
`
`II
`
`Help I
`
`FIG. 2
`
`BLUE COAT SYSTEMS - Exhibit 1045 Page 3
`
`

`
`U.S. Patent
`
`Jul. 31, 2001
`
`Sheet 3 of 8
`
`US 6,268,852 Bl
`
`100 r
`
`124
`
`125
`
`FILTER ACTIONS IN ACTION PANE
`
`126
`
`LIST OBJECTS ON PAGE IN
`ACTION PANE
`
`127
`
`NO
`
`128
`
`110
`
`114
`
`116
`
`120
`
`YES
`
`GENERATE SCRIPT TO LINK EVENTTO ACTION
`
`L....------YES -----~
`
`DISPLAY SCRIPT IN LIST VIEW OR CODE VIEW
`
`140
`
`145
`
`148
`
`NO
`
`REBUILD DOCUMENT FROM MEMORY STORAGES
`
`150
`
`FIG. 3
`
`154
`
`BLUE COAT SYSTEMS - Exhibit 1045 Page 4
`
`

`
`U.S. Patent
`
`Jul. 31, 2001
`
`Sheet 4 of 8
`
`US 6,268,852 Bl
`
`214
`
`240
`
`244
`
`~...--_.....~ EVENTS
`PROPERTIES
`METHODS
`
`CORRELATOR
`
`220
`
`224
`
`PROPERTIES
`\..___-~~METHODS
`PROCESS
`
`12
`
`20
`
`EVENTS
`
`275
`
`PARSERJCONVERTER
`
`SCRIPT TEXT
`
`FIG. 4
`
`BLUE COAT SYSTEMS - Exhibit 1045 Page 5
`
`

`
`U.S. Patent
`
`Jul. 31, 2001
`
`Sheet 5 of 8
`
`US 6,268,852 Bl
`
`110
`
`r
`
`330
`
`MOVE TO OBJECT
`END TAG AND
`CAPTURE TEXT
`
`338
`
`MOVE TO SCRIPT
`END TAG AND
`CAPTURE TEXT
`
`350
`
`MOVE TOHTML
`ENDTAGAND
`CAPTURE TEXT
`
`362
`
`SAVE TEXT
`TO MEMORY
`STORAGE
`
`304
`
`310
`
`320
`
`334
`
`NO
`
`340
`
`YES
`
`NO
`
`NO
`
`NO
`
`324
`
`336
`
`348
`
`SAVE
`LOCATION
`
`YES
`
`YES
`
`YES
`
`YES
`
`SAVE
`LOCATION
`
`SAVE
`LOCATION
`
`344
`
`NO
`
`356
`
`YES
`360~
`
`FIG. 5
`
`BLUE COAT SYSTEMS - Exhibit 1045 Page 6
`
`

`
`U.S. Patent
`
`Jul. 31, 2001
`
`Sheet 6 of 8
`
`US 6,268,852 Bl
`
`140
`(
`
`450
`
`470
`
`402
`
`410 ""
`
`414 ""
`
`418 ""
`
`420
`
`""
`
`YES
`t
`DETERMINE PROPERTY
`TYPE
`
`J
`
`DISPLAY PROPERTY
`INPUT SCREEN
`
`~
`
`RECEIVE
`INPUT
`
`~
`
`GENERATE PROPERTY
`SCRIPT
`I
`
`YES
`
`•
`
`IMPORT CANNED
`ACTION
`
`454"
`
`YES
`
`•
`
`474" CHECK FOR PARAMETERS
`GOING TO METHOD
`
`456" DISPLAY CANNED ACTION
`INPUT SCREEN
`
`480"
`
`DISPLAY METHOD
`INPUT SCREEN
`
`460""
`
`RECEIVE
`INPUT
`
`482"
`
`RECEIVE
`INPUT
`
`NO
`
`464"
`
`GENERATE CANNED
`ACTION SCRIPT
`
`485"
`
`GENERATE METHOD
`SCRIPT
`
`430" SAVE TO SCRIPT MEMORY
`STORAGE
`
`434
`
`END
`)
`FIG. 6
`
`ERROR
`HANDLER
`
`~8
`
`BLUE COAT SYSTEMS - Exhibit 1045 Page 7
`
`

`
`U.S. Patent
`
`Jul. 31, 2001
`
`Sheet 7 of 8
`
`US 6,268,852 Bl
`
`500
`
`504
`
`YES
`
`NO~
`
`YES
`
`GENERATE LIST VIEW HEADER
`TEXT
`
`514
`
`516
`
`NO
`
`510
`
`540
`
`INSERT SCRIPT FROM MEMORY
`STORAGE INTO PANE
`
`520
`
`YES
`
`GENERATE TEXT FOR
`NEXT ACTION
`
`NO
`
`524
`
`530
`
`532
`
`534
`
`FIG. 7
`
`BLUE COAT SYSTEMS - Exhibit 1045 Page 8
`
`

`
`U.S. Patent
`
`Jul. 31, 2001
`
`Sheet 8 of 8
`
`US 6,268,852 Bl
`
`150
`
`!
`
`646
`
`NO
`
`ERROR
`HANDLER
`
`YES
`
`640
`
`602
`
`READ
`NEXT SCRIPT
`
`YES
`
`YES
`
`NO
`
`610
`
`612
`
`616
`
`620
`
`634
`
`INSERT SCRIPT
`INTO DOCUMENT
`AT ORIGINAL
`POSITION
`
`626
`
`YES
`
`NO
`
`628
`
`NO
`
`650
`
`652
`
`654
`
`FIG. 8
`
`BLUE COAT SYSTEMS - Exhibit 1045 Page 9
`
`

`
`US 6,268,852 Bl
`
`1
`SYSTEM AND METHOD FOR
`FACILITATING GENERATION AND
`EDITING OF EVENT HANDLERS
`
`BACKGROUND OF THE INVENTION
`
`2
`method is needed for producing an event handler that links
`an event on one object in an HTML document to an action
`taken by a second object within the HTML document. The
`present invention provides such a solution.
`
`SUMMARY
`
`1. Field of the Invention
`The present invention comprises a software program for
`This invention relates to software tools for facilitating the
`creating and editing event handlers that are linked to objects
`generation and editing of computer programs. Specifically,
`embedded within an HTML or other Internet document.
`this invention relates to software tools for facilitating the 10
`Objects are software programming components such as
`generation and editing of an event handler program that
`Microsoft Object Linking and Embedding (OLE) 2.0
`links an event associated with one object to an action taken
`objects, Corba Objects, Java Beans and OpenDoc objects.
`by another object.
`These software programming components are pre-existing
`2. Description of the Related Art
`modules that do not need to be modified to work within
`In current object-oriented software environments, the 15 embodiments of the invention.
`As used herein, the term Internet document refers to any
`objects themselves include commands for triggering outside
`(event-handling) programs once a pre-determined event is
`document that can be read by Internet browsing software
`triggered. For example, one standard event within the
`such as Netscape Navigator or Microsoft Internet Explorer.
`Microsoft Windows environment is a "mouse click" event.
`Types of Internet documents include HTML and Two
`This. type of event is triggered whenever a user depresses a 20 Dimensional Markup Language (2DML) documents. An
`mouse button while the mouse cursor is on top of the object.
`example of a 2DML document is provided in Microsoft
`As the user depresses the mouse button, an event-handling
`"ALX" files that are produced by the Microsoft ActiveX
`Control Pad. It should also be understood that the term
`program associated with the mouse click event is triggered.
`"Internet document" is intended to encompass any protocols
`Thus, particular event-handling programs can be triggered
`25 or specifications that are adopted in the future to page
`by associating them with a pre-selected event. However,
`layouts that are distributed across wide area networks.
`writing these event-handling programs is a complicated and
`time-consuming task. Normally, only computer program(cid:173)
`However, for simplicity, the following description uses
`mers have the ability to write event-handling software. For
`the terms Internet document and HTML document some(cid:173)
`this reason, many novice computer users cannot take advan-
`what interchangeably. Using the program described herein,
`tage of this powerful technology.
`the user can generate and edit event handling scripts visually
`(via mouse clicks), without typing in or directly editing the
`One of the object-oriented technologies that takes advan(cid:173)
`underlying script code. In addition, the program displays a
`tage of event driven applications is Microsoft's ActiveX
`non-executable "plain English" narrative of the event han-
`technology for the Internet. Users can add ActiveX compo(cid:173)
`35 dler scripts that have been generated.
`nents to their Hypertext Markup Language (HTML) docu(cid:173)
`In one embodiment, the program includes a user interface
`ments so that particular events, such as a mouse click, can
`that can display graphical representations of objects, events
`be used to trigger a particular event-handler. For example, an
`ActiveX object's mouse click event could be linked to an
`and actions. These graphical representations are preferably
`displayed in separate regions or panes within a user interface
`event handler that connects the user to another HTML
`window. The preferable form of the graphical representa(cid:173)
`document. In this manner, the Active X object would act like 40
`tions is a hierarchical tree. The first ("event") pane includes
`a hyperlink to other documents on the World Wide Web.
`a list of objects from the HTML document that have events
`A powerful feature of current Internet technology relates
`which can be triggered. These objects can include ActiveX
`to programs or scripts which run when a user selects a
`objects, scriptable HTML tags, browser window objects and
`particular item within an HTML document. For example, a
`any other component embedded within the Internet docu-
`user might fill in a form on an HTML document and then
`ment.
`depress a "submit" button to send that form to an Internet
`As discussed above, an object's event is triggered when a
`host. When the "submit" button is depressed by a mouse
`particular user action occurs. Thus, the software monitors
`click, a program or script is run instructing the user's
`regions of the user interface for interactions from the user.
`computer to gather data from the form and forward it to a
`Examples of user actions include a mouse click, a mouse
`pre-designated Internet site. Some scripts that are run on 50
`double-click and a SUBMIT button. Once the user performs
`Internet server computers to process forms and the like are
`an action that triggers an event, the corresponding event
`known as Common Gateway Interface (CGI) scripts. Other
`handling software ("event handler") is initiated and run on
`software for producing programs used on the Internet
`the computer system. It should be noted that a user action is
`include the Visual Basic Language, Java Language, Visual
`not necessarily required to trigger an event. For example, a
`Basic script an (VBScript) language from Microsoft Corpo- 55
`timer object may include a timer event that is triggered once.
`ration and the JavaScript language. More information on the
`a pre-determined period of time has elapsed.
`VBScript language can be found in Inside Microsoft Visual
`Basic, Scripting Edition by Scott Hillier (Microsoft Press).
`The second ("action") pane of the user interface includes
`a list of objects from the HTML document that provides
`Unfortunately, implementing these scripts as ActiveX
`60 actions. In this environment, an action can be a property or
`event-handling programs in an HTML document can be
`a method of an object on the HTML document. For example,
`extremely complicated and require a thorough knowledge of
`an action might be the background color property for the
`programming languages and environments. The VBScript
`chosen object.
`and JavaScript languages require extensive programming
`knowledge to implement. Thus, it can be difficult for a
`In response to mouse clicks on the objects within the
`novice computer user to create an HTML document that
`65 event and action panes, the program automatically generates
`includes scripts and programs that provide for a flexible
`a script that link events in the event pane to actions in the
`world-wide web site. For this reason, a simple, convenient
`action pane. For example, a user can link a mouse click
`
`30
`
`45
`
`BLUE COAT SYSTEMS - Exhibit 1045 Page 10
`
`

`
`US 6,268,852 Bl
`
`3
`event for a first object listed in the event pane to a color
`property action for a second object listed in the action pane.
`The program then provides the desired link between the
`event and the action by generating a script in VBScript or.
`JavaScript, and displaying the script in a code pane
`(discussed below). In the example from above, a user could
`cause the second object to change color following a mouse
`click on the first object. Therefore, when this particular
`HTML document is accessed through an Internet browser,
`any consumer that performs a mouse click on the first object 10
`will cause a color change in the second object.
`The third ("code") pane of the user interface displays the
`event handler, which can either be an event handler inter(cid:173)
`actively generated by the user via the event and action panes
`(in the manner described above), or a pre-existing event 15
`handler of the HTML document being edited. From the user
`interface, the user can select between one of two formats for
`viewing the event handler within this pane. In the first
`format, termed herein the "list" view, a plain English
`description of the link established between the first object's 20
`event and the second object's action is displayed. In the
`second format, termed herein the "code" view, the user can
`view and build the actual Visual Basic Script(VBScript) or
`JavaScript code that links the first object's event to the
`second object's action.
`The event handling programs are built by first filtering
`only those actions that are appropriate for script generation.
`In addition, data-type specific dialog boxes are displayed to
`allow the user to set properties associated with the objects.
`For example, if the user chooses to modify an action 30
`corresponding to a color property, the user is presented with
`a Windows color palette to select the proper color.
`Since the event handler scripts are generated automati(cid:173)
`cally in response to selection (via the mouse) of events and
`associated actions, it is not necessary for the user to learn the
`underlying programming language. In addition, since the
`program displays the code in an easy to understand list view,
`the user does not need to be concerned with programming
`syntax to review the links that have been established. With
`this system, even a novice user can add creative scripts that
`link objects to actions.
`
`35
`
`40
`
`4
`oriented environment on a computer. The embodiment of the
`software described herein provides the user with a simple,
`graphical interface to create Visual Basic Script (VBScript)
`and JavaScript event handlers that link events from a first
`object to actions of a second object. Via this interface, the
`user can write event handlers without writing a single line of
`code, and without knowledge of the syntax of the underlying
`programming language. In addition, the user can view the
`event handlers (and event handlers written by prior users) in
`a plain English format that can be understood by a non(cid:173)
`programmer.
`As discussed above, an embodiment of the system and
`method includes software that graphically represents the
`objects, events and actions to be scripted in a user interface
`having three distinct panes: an event pane, an action pane
`and a code pane. The user does not need to learn complicated
`programming languages to create scripts that link an event
`triggered on one object to a resultant action on a second
`object.
`In addition, the user is provided with a list view that
`displays a simple narrative reflecting the linkage generated
`between the event and the action to be taken. Using this
`feature, the user can quickly determine if the generated
`script will perform the desired function. More details on the
`25 *list view are provided below.
`As discussed above, the event pane includes a list of
`objects located on the current document, and the associated
`events that can be triggered from each one of the listed
`objects. In one embodiment, an indicator is displayed along
`with each event so that the user can quickly determine which
`event has an associated script. In the action pane is a list of
`objects on the current page and the associated actions that
`can be taken for each object. For example, an action might
`be the "close" method of a window object on the document.
`To facilitate a complete understanding of the invention,
`the remainder of the detailed description is arranged within
`the following sections and subsections:
`I. Glossary of terms and acronyms
`II. Overview of the system
`A. The event pane
`B. The action pane
`C. The code pane
`D. Process overview
`E. Data structure overview
`III. Parsing documents
`IV. Generating scripts
`V. Displaying scripts in list view or code view
`VI. Rebuilding documents from memory storages
`VII. Other embodiments
`VIII. Conclusion
`I. Glossary of terms and acronyms
`The following terms and acronyms are used throughout
`55 the detailed description:
`Internet. A collection of interconnected (public and
`private) networks that are linked together by a set of
`standard protocols to form a distributed network.
`HyperText Markup Language (HTML). A standard cod(cid:173)
`ing convention and set of codes for attaching presen(cid:173)
`tation and linking attributes to informational content
`within documents. (HTML 2.0 is currently the primary
`standard used for generating Web documents.) During
`a document authoring stage, the HTML codes (referred
`to as "tags") are embedded within the informational
`content of the document. When the Web document (or
`"HTML document") is subsequently transferred from a
`
`BRIEF DESCRIPTION OF THE FIGURES
`FIG. 1 is a screen capture of an embodiment of the present
`invention illustrating an event pane, an action pane and a 45
`code pane. The code pane is illustrated using the code. view
`feature.
`FIG. 2 is a screen capture illustrating an embodiment of
`the list view feature in the embodiment of FIG. 1.
`FIG. 3 is a flow diagram illustrating the overall process of
`opening a document to edit and link events to actions.
`FIG. 4 is a block diagram illustrating the flow of data
`structures in the embodiment of FIG. 1.
`FIG. 5 is a flow diagram illustrating the "parse document
`process" of FIG. 3.
`FIG. 6 is a flow diagram illustrating the "generate script
`to link event to action" process of FIG. 3.
`FIG. 7 is a flow diagram illustrating the "display script in
`list view or code view" process of FIG. 3.
`FIG. 8 is a flow diagram illustrating the "rebuild. docu(cid:173)
`ment from memory storages" process of FIG. 3.
`
`60
`
`50
`
`DETAILED DESCRIPTION OF THE
`PREFERRED EMBODIMENTS
`The present invention comprises a method and system for
`creating and editing event-handling programs in an object
`
`65
`
`BLUE COAT SYSTEMS - Exhibit 1045 Page 11
`
`

`
`US 6,268,852 Bl
`
`6
`
`A. The event pane
`Referring to FIG. 1, an event pane 12 appears in the left
`upper corner of the Script Wizard user interface 10 and
`provides a hierarchical view of all the events which can be
`triggered to fire on the associated HTML document or
`2DML document.
`Objects which appear in the event pane include the follow(cid:173)
`ing:
`1) ActiveX Controls.
`Objects specified with the <OBJECT> HTML tag, which
`provide an object class ID in the "CLASSID="
`attribute, and which provide an "ID=attribute". All
`ActiveX controls are shown, even if they are not
`currently scripted.
`2) Scriptable HTML elements.
`There are also container objects that can be listed within
`the event pane 12. These container objects form a new level
`in the hierarchy. All objects within the container appear in
`the hierarchy under the container. If an object appears
`outside of a container, it is placed at the top level of the
`20 hierarchy. The types of containers that are recognized are
`summarized below in Table 1.
`
`5
`Web server to a Web browser, the codes are interpreted
`by the Web browser and used to parse and display the
`document. In addition to specifying how the Web
`browser is to display the document, HTML tags can be
`used to create links to other websites and other Web
`documents (commonly referred to as "hyper-links").
`For more information on HTML, see Ian S. Graham,
`The HTML Source Book, John Wiley and Sons, Inc.,
`1995 (ISBN 0471-11894-4).
`Two Dimensional Markup Language (2DML). A two 10
`dimensional markup language based on HTML for
`placing objects at specific two dimensional coordinates
`on a computer screen. An example of a 2DML docu(cid:173)
`ment is implemented in Microsoft "ALX" files that are
`read by the Microsoft HTML layout control program. 15
`In addition, 2DML documents can be produced using
`two dimensional layout software such as the Microsoft
`ActiveX control pad program.
`HyperText Transport Protocol (HTTP). The standard
`World Wide Web client-server protocol used for the
`exchange of information (such as HTML documents,
`and client requests for such documents) between a Web
`browser and a Web server. HTTP includes a number of
`different types of messages which can be sent from the
`client to the server to request different types of server 25
`actions. For example, a "GET" message, which has the
`format GET. <URL>, causes the server to return the
`document or file located at the specified Universal
`Resource Locator (URL).
`World Wide Web ("Web"). Used herein to refer generally 30
`to both (1) a distributed collection of interlinked, user(cid:173)
`viewable hypertext documents (commonly referred to
`as "Web documents" or "electronic pages" or "home
`pages") that are accessible via the Internet, and (2) the
`client and server software components which provide 35
`user access to such documents using standardized Inter(cid:173)
`net protocols. Currently, the primary standard protocol
`for allowing applications to locate and acquire Web
`documents is the HyperText Transfer Protocol (HTTP),
`and the electronic pages are encoded using the Hyper- 40
`Text. Markup Language (HTML). However, the terms
`"Web" and "World Wide Web" are intended to encom(cid:173)
`pass future markup languages and transport protocols
`which may be used in place of or in addition to the
`HTML.
`II. Overview of the system
`The preferred embodiment of the invention is a software
`program termed herein the "Script Wizard". The Script
`Wizard program is initialized in a modal window that can be
`incorporated into many types of Internet editing software. 50
`For example, the Script Wizard can be incorporated into
`ActiveX Control Pad software or FrontPage 97 software
`from Microsoft Corporation. Launching of the Script Wizard
`can be handled by the host application editor menus or
`toolbars.
`The Script Wizard software can be run under many
`operating systems, but is preferably run under Microsoft
`Windows 95 or Windows NT. A computer system that
`includes an Intel Pentium processor and sixteen megabytes
`of memory is preferable. However, other types of compat-
`ible computer hardware are contemplated within the spirit of
`the invention.
`FIG. 1 is a printout of a display screen from a computer
`that is running the Script Wizard software. As can be seen,
`the Script Wizard user interface 10 includes an event pane 65
`12, an action pane 20, and a code pane 30; each of which is
`described below.
`
`TABLE 1
`
`Summary of Container Tvoes
`
`Containers
`
`Description
`
`Forms
`ActiveX Layout regions:
`
`Outlined in HrML by <FORM> tags.
`Specified with
`<DlV STYLE ~ "LAYOUT:FIXED" .
`
`Objects are listed within the event pane 12 in alphabetical
`order and in a case insensitive form. Under each object in the
`hierarchy are listed the events that the respective object can
`trigger. For example, in FIG. 1, the event pane 12 lists a
`window object 32 which includes two events, an onLoad
`event 34 and an onUnload event 36. These objects are
`preferably Microsoft OLE 2.0 objects and include sets of
`pre-programmed events and actions.
`Events that have associated actions are indicated in the
`event pane 12 by showing an indicator (solid diamond(cid:173)
`shaped icon) to the user. Events which do not have any
`associated actions are listed in the event pane 12 with a
`hollow diamond-shaped icon. From a quick review of the
`45 events and icons in the event pane 12, the user can determine
`which events have associated actions.
`As illustrated in FIG. 1 a solid diamond-shaped indicator
`40a is associated with the onLoad event 34 to indicate that
`a script is associated with this event.
`Navigation through the hierarchies of the event and action
`panes 12, 20 is identical to that in the Windows 95 Explorer.
`Double clicking with a mouse on an object will expand that
`object's list of methods and properties.
`Another item at the top level of the event pane hierarchy
`55 is the Window object 32 which provides the user with a
`hierarchical list of browser window events that can be
`associated with actions. Although the window object 32 is
`not an object taken from the HTML document, its events can
`be associated with actions in the same manner as any other.
`object. When editing an HTML document, this part of the
`event tree is filled in by the typeinfo for the Microsoft
`Internet Explorer window object, thus listing all events that
`can be fired by the browser itself. When editing a 2DML file,
`the extent of the window object which is exposed is defined
`in the 2D Layout runtime specification.
`To select what code is displayed in the code pane 30, the
`user clicks (single) on an event in the event pane 12. If there
`
`60
`
`BLUE COAT SYSTEMS - Exhibit 1045 Page 12
`
`

`
`US 6,268,852 Bl
`
`8
`defined functions on the HTML document, including
`VBScript event handlers (of the form of the Visual Basic
`command "sub object_event"). Functions are listed alpha(cid:173)
`betically in the action pane 20. If no such functions exist on
`the HTML document, the Procedures object is displayed, but
`has no children in the hierarchical tree.
`When an action listed in the action pane 20 is selected by
`a mouse click, the chosen action is inserted into the code
`pane 30 at the insertion point. Properties and global vari-
`10 ables are inserted as the property name and methods are
`inserted as the method name followed by "( )" (and a
`"CALL" statement for VBScript). In the list view, if the
`method/function takes arguments, the arguments passed into
`the event handler are passed through to the method/function.
`The action pane 20 includes a context menu (not shown)
`that pops up if the user depresses the right mouse button
`while the mouse cursor is positioned within the action pane
`20. The context menu includes the following choices, each
`of which is discussed below:
`New Global Variable
`New Procedure
`Edit
`Delete
`25 New Global Variable
`The new global variable option on the context menu
`allows the user to input a new global variable into the action
`pane 20. Once this option is selected, a dialog box is
`presented requesting the name of the new variable. The
`name of the global variable can then be entered, and the
`following lines are inserted into the beginning of the HTML!
`2DML document:
`
`dim user-supplied-name
`or
`var user-supplied-name
`
`(VBScript)
`
`(JavaScript)
`
`The user may include subscripts or an initial value in the
`proper syntax for the language in use. A check of the syntax
`is performed to ensure that the script being created is legal.
`If the new line of script does not parse properly, the user is
`prompted to change the declaration or to cancel the new
`variable.
`45 New Procedure
`The new procedure option on the context menu causes a
`new, empty, procedure to appear in the code pane with the
`following prototype:
`
`7
`is an event handling code already linked to the chosen event,
`that program is displayed in the code pane 30. If there is no
`program code currently associated with the event, the code
`pane 30 remains empty.
`Whenever an event is selected in the event pane 12, the
`code pane 30 will be updated to display the VBScript or
`1 avaScript program that is associated with the selected.
`event. For example, if the user scrolls up and down through
`a tree of events in the event pane 12, the code pane 30 will
`change to display the currently selected event handler.
`For the Object Linking and Embedding (OLE) based
`objects listed in the event pane 12, all information displayed
`to the user about elements is taken from the user's system
`OLE registry. If the OLE registry does not contain infor(cid:173)
`mation about a particular object, the events, methods and 15
`properties of that object will not appear in the event pane 12
`or action pane 20, although the item itself will be displayed,
`with an indication of its lack of type information.
`If a scriptable HTML element does not have a
`"ENAME=" value, the Script Wizard program uses the 20
`"ID=" value to generate a unique name for the element. IF
`the "ID=" value does not exist, the Script Wizard looks at the
`"VALUE=" for the scriptable HTML element.