United States Patent [19]
`Matheny et al.
`
`I lllll llllllll Ill lllll lllll lllll lllll lllll lllll lllll lllll llllll Ill lllll llll
`US005479601A
`5,479,601
`[11] Patent Number:
`[45] Date of Patent:
`Dec. 26, 1995
`
`[54]
`
`METHOD AND APPARATUS FOR
`PROCESSING COMMANDS GENERATED BY
`USER INTERFACE CONTROLS IN AN
`ATOMIC MANNER
`
`[75]
`
`Inventors: John R. Matheny; Christopher White,
`both of Mountain View; David R.
`Anderson, Cupertino, all of Calif.
`
`[73]
`
`Assignee: Taligent, Inc., Cupertino, Calif.
`
`[21] Appl. No.: 422,677
`Apr. 13, 1995
`
`[22] Filed:
`
`Related U.S. Application Data
`
`[63] Continuation of Ser. No. 996,186, Dec. 23, 1992, aban(cid:173)
`doned.
`........................................................ G06F 3/14
`Int. Cl.6
`[51]
`.............................................................. 395/155
`[52] U.S. CI .
`[58] Field of Search ..................................... 395/155, 161,
`395/159, 157, 133, 375, 650, 51, 62
`
`[56]
`
`References Cited
`
`U.S. PATENT DOCUMENTS
`
`3,658,427
`3,881,605
`4,082,188
`4,635,208
`4,677,576
`4,704,694
`4,742,356
`4,821,220
`4,853,843
`4,868,744
`4,885,717
`4,891,630
`4,939,648
`4,953,080
`5,041,992
`5,050,090
`5,060,276
`5,075,848
`5,093,914
`5,119,475
`5,125,091
`5,133,075
`
`4/1972 De Cou ................................... 356/156
`5/1975 Grossman ........................... 214/1 CM
`411978 Grimmell et al. ........................ 209n3
`111987 Coleby et al ........................... 364/491
`6/1987 Berlin, Jr. et al. ...................... 364/522
`1111987 Czerniejewski ......................... 364/513
`5/1988 Kuipers ................................... 342/448
`4/1989 Duisberg ................................. 364/578
`8/1989 Ecklund .................................. 395/600
`9/1989 Reinsch et al. ......................... 395/575
`1211989 Beck et al. .............................. 364/900
`111990 Friedman et al. ...................... 3401706
`711990 O'Neill et al ........................... 364/422
`8/1990 Dysart et al. ........................... 364/200
`8/1991 Cunningham et al .................. 364/518
`9/1991 Golub et al. ............................ 364/478
`10/1991 Morris et al. ............................... 382/8
`12/1991 Lai et al. ................................ 395/425
`3/1992 Coplien et al. ......................... 3951700
`6/1992 Smith et al. ............................ 395/156
`611992 Staas, Jr. et al. ....................... 395/650
`7/1992 Risch ...................................... 395/800
`
`5,136,705
`5,151,987
`5,163,130
`5,168,441
`5,177,685
`5,181,162
`5,313,629
`5,315,703
`5,367,633
`5,371,886
`5,434,965
`
`8/1992 Stubbs et al. ........................... 395/575
`911992 Abraham et al. ....................... 395/575
`11/1992 Hullot ..................................... 395/148
`12/1992 Onarheim et al ....................... 3641146
`111993 Davis et al.
`............................ 364/443
`1/1993 Smith et al ............................. 364/419
`5/1994 Abraham et al. ....................... 395/600
`5/1994 Matheny et al. ........................ 395/164
`1111994 Matheny et al ......................... 395/164
`12/1994 Britton et al. .......................... 395/600
`7/1995 Matheny et al ......................... 395/159
`
`FOREIGN PATENT DOCUMENTS
`
`0499404
`
`8/1992 European Pat. 0.lf ..
`
`OTHER PUBLICATIONS
`
`4th Annual Symposium on User Interface Software and
`Technology, Nov. 11, 1991, pp. 107-115 "An Event-Object
`Recovery Model for Object-Oriented User Interfaces".
`
`Primary Examiner-Raymond J. Bayerl
`Assistant Examiner-Crescelle N. dela Torre
`Attorney, Agent, or Firm-Keith Stephens
`
`[57]
`
`ABSTRACT
`
`An object-oriented user interface utilizes object-oriented
`controls that operate together as a single, atomic group to
`change data values and are affected as a group by conven(cid:173)
`tional editing "undo" and "redo" actions. In accordance with
`one embodiment, each control in the group generates a
`command which modifies a stored control value when the
`control is manipulated by a user. In response to user acti(cid:173)
`vation, a group acceptance control generates a command
`which causes the data values to be changed to the stored
`control values. In accordance with another embodiment,
`each control in the group generates a command which
`modifies the group acceptance control command. When the
`group acceptance control command is finally activated, the
`modified command causes the data values to be changed.
`The entire control group can also be undone and redone in
`a single atomic operation which is implemented by placing
`a mark on an undo stack when an interface session involving
`a control group is started. When the session ends, all of the
`commands executed since the mark was placed on the undo
`stack are collected together into a single command group
`which can be undone or redone as a unit.
`
`16 Claims, 13 Drawing Sheets
`
`DISPLAY
`ADAPTER
`
`Corel Exhibit 2003
`Microsoft v. Corel
`IPR2016-01083
`
`

`
`U.S. Patent
`
`Dec. 26, 1995
`
`Sheet 1of13
`
`5,479,601
`
`co
`....-
`
`~
`
`co
`
`C>
`
`e
`
`::i!
`<C
`a:
`
`::i!
`0
`a:
`
`::::>
`a...
`(.)
`
`co
`CW')
`
`(0
`CW')
`
`>-a:
`::i~
`a...a...
`cn<C -o
`Cl<C
`
`wa:
`ow
`<C 1--
`u_a...
`a:<C
`WO
`!z <C
`
`~
`C")
`
`::i!
`::i!
`0
`(.)
`
`C'\I
`C\J
`
`C'\I
`
`<(
`.....
`•
`CJ -u.
`
`co
`C\J
`
`C\J
`C")
`
`

`
`U.S. Patent
`
`Dec. 26, 1995
`
`Sheet 2of13
`
`5,479,601
`
`40
`
`Moue
`
`....... 1 ... 1 ••• l. .. 1 •• l?. •.
`
`t;roUf>
`Un~JfOUf>
`Lock
`Unlock
`Align •••
`
`Rotate
`
`FIG. 18
`
`220
`
`200
`
`~BOLD
`
`210
`
`~
`
`FIG. 2
`
`BOLD
`
`J INTERESTS
`
`300
`
`CONNECTION
`
`310
`
`FIG. 3
`
`320
`
`

`
`U.S. Patent
`
`Dec. 26, 1995
`
`Sheet 3of13
`
`5,479,601
`
`/
`;r BOLD
`
`400
`
`J BOLD
`
`510
`
`VALUE
`
`VALUE
`
`f BOLD
`
`600
`
`NOTIFICATION
`
`FIG. 4
`
`VALUE
`
`FIG. 5
`
`VALUE
`
`610
`
`620
`
`FIG. 6
`
`

`
`U.S. Patent
`
`Dec. 26, 1995
`
`Sheet 4of13
`
`5,479,601
`
`• •
`~BOLD
`
`VALUE
`
`NOTIFICATION
`
`VALUE
`VALUE
`
`FIG. 7
`
`a
`
`SOUND CONTROLLER
`
`800
`
`802
`
`804
`
`806
`
`FIG. 8
`
`RED 0 c:=:=:::lf:===:::::i
`
`GREEN 0 i=====:ll=:::::i
`
`BLUE 0 c:====:::U:::::::::::::::::::::::::::::::::J 255
`
`APPLY
`
`930
`
`920
`
`FIG. 9
`
`

`
`U.S. Patent
`
`Dec. 26, 1995
`
`Sheet 5of13
`
`5,479,601
`
`1000
`
`\
`
`RED 0
`
`1010
`
`\
`
`GREEN 0
`
`BLUE 0
`
`\1020
`
`c::::=::{]~===============:J• 255
`
`TFloatControlCommand
`
`1040
`
`float -------------------------------: . . . ~
`
`i:::==========:::::::::l s:=::::=====i 255 ! TSetColor
`=-------· red
`.
`TFloatControlCommand
`float ---------------------------------------· green ----+·------ ·coLoR·
`c::=====n=========:::=:::i 255 r·-----· blue
`____ ;
`\
`~
`TFloatControlCommand
`float -------------------------------;
`
`1050
`
`FIG. 10
`
`1100 --------
`~ PAPER
`
`~PLASTIC
`1110
`
`FIG. 11
`
`

`
`U.S. Patent
`
`Dec. 26, 1995
`
`Sheet 6of13
`
`5,479,601
`
`START
`
`UPDATE MENU
`
`QUERY OBJECTS
`
`QUERY COMMAND
`
`1240
`
`INVOKE
`ACTION
`
`MODIFY STATE
`
`1200
`
`1210
`
`1220
`
`1230
`
`1260
`
`1270
`
`1280
`
`HIGHLIGHT
`MENU
`
`NOTIFY MENU
`
`..--1290
`
`FIG. 12
`
`

`
`~~Link
`
`HH
`He derTrace
`Hu n Break
`880
`
`D Fill in Free
`D Reuse Blocks
`J > "• 1111Mw a a aw I I FindGarbage I !Heap Slzej jopus Bug I
`
`R Document
`
`~
`
`~ • r:.n. •
`~ a
`
`0
`!'!) r
`N
`.,.I::/\
`
`~
`\C
`\C
`U1
`
`r:.J'1 ;
`~
`'-I
`~
`
`~
`~
`
`FIG. 13
`
`Ul
`,,.
`~
`.......
`,,.
`\C
`
`~ = """"
`
`

`
`U.S. Patent
`
`Dec. 26, 1995
`
`Sheet 8of13
`
`5,479,601
`
`START
`
`1400
`
`ACTIVATE
`DIALOG BOX
`
`MANIPULATE
`CONTROL
`
`CHANGE
`VALUE
`
`RECORD
`COMMAND
`
`RE-RECORD
`COMMAND
`
`1410
`
`1420
`
`1430
`
`1440
`
`NO
`
`1470
`
`FIG. 14
`
`

`
`U.S. Patent
`
`Dec. 26, 1995
`
`Sheet 9of13
`
`5,479,601
`
`START
`
`1500
`
`I NTITIALIZE
`LABEL
`
`DRAW LABEL
`
`TOGGLE LABEL
`
`TOGGLE CONTROL
`
`1510
`
`1520
`
`1530
`
`1540
`
`YES?
`
`NO?
`
`STOP
`
`1560
`
`FIG. 15
`
`

`
`U.S. Patent
`
`Dec. 26, 1995
`
`Sheet 10of13
`
`5,479,601
`
`~~ 1600
`
`~1610
`
`r
`
`START
`
`, ,
`
`INITIALIZE
`TITLE
`
`---
`
`DRAW TITLE
`
`~1620
`
`~1630
`
`TOGGLE TITLE
`
`FIG. 16
`
`

`
`U.S. Patent
`
`Dec. 26, 1995
`
`Sheet 11 of 13
`
`5,479,601
`
`START
`
`1700
`
`1710
`
`1720
`
`1730
`
`1740
`
`YES
`
`BUTTON
`DETECTED
`
`INTERACTOR
`CREATED
`
`INTERACTOR
`STARTED
`
`DELAY
`
`FIG. 17
`
`1760
`
`STOP
`
`NO
`
`

`
`U.S. Patent
`
`Dec. 26, 1995
`
`Sheet 12 of 13
`
`5,479,601
`
`START
`
`1800
`
`CREATE CONNECTION
`
`DEFINE INTERESTS
`
`CONNECT SOURCES
`
`REGISTER CONNECTIONS
`
`AWAIT CHANGE
`
`CHANGE DESCRIPTION
`
`. DISPATCH NOTIFICATION
`
`SEND NOTIFICATION
`
`RECEIVE NOTIFICATON
`
`1810
`
`1820
`
`1830
`
`1840
`
`1845
`
`1850
`
`1860
`
`1870
`
`1880
`
`NO
`
`FIG. 18
`
`

`
`U.S. Patent
`
`Dec. 26, 1995
`
`Sheet 13 of 13
`
`5,479,601
`
`START
`----
`
`H
`
`1900
`
`1 910
`
`REQUEST PRESENTATION
`
`~ r
`
`CREATE PRESENTATION
`
`H
`
`BUILD PRESENTATION
`
`~ 1920
`
`~ 1930
`
`FIG. 19
`
`

`
`5,479,601
`
`1
`METHOD AND APPARATUS FOR
`PROCESSING COMMANDS GENERATED BY
`USER INTERFACE CONTROLS IN AN
`ATOMIC MANNER
`
`This is a continuation of application Ser. No. 07/996,186,
`filed Dec. 23, 1992, now abandoned.
`
`FIELD OF THE INVENTION
`
`This invention generally relates to improvements in dis(cid:173)
`play systems and more particularly to atomic command
`processing in an operating system.
`
`BACKGROUND OF THE INVENTION
`
`5
`
`2
`button's command changes, and the real model data changes
`to match the values contained therein.
`Controls acting independently from one another represent
`actions that can be individually backed out after a control
`panel or dialog session is complete. This is the normal
`behavior of commands once they are executed by controls ..
`Other sets of dialogs are designed to work together and are
`undone and redone as an atomic operation. This processing
`is accomplished by placing a mark on an undo stack when
`the dialog box is started. When processing is completed,
`either by dismissing the control panel or when the user
`presses an OK button, all of the commands executed since
`the mark was placed on the undo stack are collected together
`into a single command group. This group can then be undone
`15 or redone as a single group.
`
`lO
`
`BRIEF DESCRIPTION OF THE DRAWINGS
`
`Among developers of workstation software, it is increas(cid:173)
`ingly important to provide a flexible software environment
`while maintaining consistency in the user's interface. An
`early attempt at providing this type of an operating envi- 20
`ronment is disclosed in U.S. Pat. No. 4,686,522 to Hernan(cid:173)
`dez et al. This patent discusses a combined graphic and text
`processing system in which a user can invoke a dynamic
`command at the location of the cursor and invoke any of a
`variety of functions. This type of natural interaction with a 25
`user improves the user interface and makes the application
`much more intuitive.
`Commands should also reflect a consistent interface with
`the user regardless of what application is currently active.
`None of the prior art references applicant is aware of
`provides the innovative hardware and software system fea(cid:173)
`tures which enable all commands to function in an atomic
`manner.
`
`FIG. lA is a block diagram of a personal computer system
`in accordance with the subject invention;
`FIG. lB is a display in accordance with the subject
`invention;
`FIG. 2 illustrates the tools used to create an application in
`accordance with the subject invention;
`FIG. 3 is a flow diagram of a command process in
`accordance with the subject invention;
`FIG. 4 is a checkbox control in accordance with the
`30 subject invention;
`FIG. 5 is a checkbox control activation in accordance with
`the subject invention;
`FIG. 6 is a checkbox update in accordance with the
`subject invention;
`FIG. 7 is a summary of checkbox control processing in
`accordance with the subject invention;
`FIG. 8 is an illustration of a control panel in accordance
`with the subject invention;
`FIG. 9 is an illustration of a dialog box in accordance with
`the subject invention;
`FIG. 10 is an illustration of a dialog box color controller
`in accordance with the subject invention;
`FIG. 11 is an illustration of a radio button in accordance
`with the subject invention;
`FIG. 12 is a detailed flowchart of menu state processing
`in accordance with the subject invention;
`FIG. 13 is a picture of a display in accordance with the
`subject invention;
`FIG. 14 illustrates the detailed logic of atomic execution
`in accordance with the subject invention;
`FIG. 15 sets forth the detailed logic associated with smart
`label processing in accordance with the subject invention;
`FIG. 16 presents the detailed logic of smart window label
`processing in accordance with the subject invention;
`FIG. 17 illustrates how objects are created and how the
`objects communicate with each other during a typical inter-
`60 action with an object that can be moved and selected in
`accordance with the subject invention;
`FIG. 18 is an object generating notification flowchart for
`a notification source object in accordance with the subject
`invention; and
`FIG. 19 presents a flowchart illustrating the detailed logic
`associated with selecting the proper user interface element in
`accordance with the subject invention.
`
`SUMMARY OF THE INVENTION
`
`35
`
`Accordingly, it is a primary objective of the present
`invention to use atomic commands to coordinate controls
`and have the controls function in a dependent manner. The
`first is whether the controls affect the data immediately, or 40
`whether the user must press OK before the settings take
`effect. The second discerns whether the controls are inde(cid:173)
`pendent from one another, or whether the control settings are
`joined representing an atomic operation.
`Controls are made up of commands which set parameters 45
`in the commands and cause the commands to be executed
`with particular parameters. Commands operate on model
`data specified by a selection. Controls that affect the data
`immediately contain a command that contains a selection
`that specifies real model data. As a user manipulates a 50
`control, the command causes its data to change. As the data
`changes, it sends change notification so that views and
`controls, depending on the state of the data, accurately
`reflect the current state of the data.
`Real model data is not changed until a user performs 55
`another action, such as pressing a button. The following
`logic is employed to facilitate this approach. First, if the
`control contains a selection that specifies the control itself.
`For example, if a user manipulates the control, and the
`command causes the control's value to change, but no other
`model data, then when a user presses OK, a command in the
`OK button changes the real model data to match the values
`in each control the user may have changed. Alternatively, if
`a control contains a selection that specifies a parameter of
`the command contained by the OK button. As the user 65
`manipulates the control, the command causes a button's
`command to change. When the user presses a button, the
`
`

`
`3
`DETAILED DESCRIPTION OF THE
`INVENTION
`
`5,479,601
`
`5
`
`15
`
`25
`
`The invention is preferably practiced in the context of an
`operating system resident on a personal computer such as
`the IBM ® PS/2 ® or Apple ® Macintosh ® computer. A
`representative hardware environment is depicted in.FIG. IA,
`which illustrates a typical hardware configurat1011 of a
`workstation in accordance with the subject invention having
`a central processing unit 10, such as a conventional micro(cid:173)
`processor, and a number of other units interconnected via a 10
`system bus 12. The workstation shown in FIG. lA includes
`a Random Access Memory (RAM) 14, Read Only Memory
`(ROM) 16, an J/O adapter 18 for connecting peripheral
`devices such as disk units 20 to the bus, a user interface
`adapter 22 for connecting a keyboard 24, a mouse 26, a
`speaker 28, a microphone 32, and/or other user interface
`devices such as a touch screen device (not shown) to the bus,
`a communication adapter 34 for connecting the workstation
`to a data processing network and a display adapter 36 for
`connecting the bus to a display device 38. The workstation
`has resident thereon an operating system such as the IBM
`OS/2 ® operating system or the Apple System/7 ® operating
`system.
`The subject invention is a new object-oriented system
`software platform comprised of an operating system and
`development environment designed to revolutionize per(cid:173)
`sonal computing for end-users, developers, and system
`vendors. The system is a complete, standalone, native oper(cid:173)
`ating system and development environment architected from
`the ground up for high-performance personal computing.
`The invention is a fully object-oriented system including a
`wealth of frameworks, class libraries, and a new generation
`object programming environment, intended to improve fun(cid:173)
`damentally the economics of third party application software
`development. The subject invention is a fully portable
`operating system.
`Traditional operating systems provide a set of services
`which software developers can use to create their software.
`Their programs are very loosely integrated into the overall
`operating system environment. For example, DOS applica(cid:173)
`tions take over the entire machine. This means that as far as
`the user is concerned, the application is the operating
`system. In Macintosh® and Windows operating systems,
`applications feel and look similar and they typically support
`cutting and pasting between applications. This commonalty
`makes it easier for users to use multiple applications in a
`single environment. However, because the commonalty is
`not factored into a set of services and frameworks, it is still
`very difficult to develop software.
`In the subject invention, writing an "application" means
`creating a set of objects that integrate into the operating
`system environment. Software developers rely on the oper(cid:173)
`ating system for both a sophisticated set of services and a
`framework to develop software. The frameworks in the
`subject invention provide powerful abstractions which allow
`software developers to concentrate on their problem rather
`than on building up infrastructure. Furthermore, the funda(cid:173)
`mental abstractions for the software developer are very close
`to the fundamental concepts that a user must understand to
`operate her software. This architecture results in easier
`development of sophisticated applications.
`This section describes four steps to writing software
`employing the subject invention. A user contemplating the
`development of an application is typically concerned with
`the following questions:
`What am I modeling?
`
`35
`
`45
`
`30
`
`4
`For a word processor, this is the text I am entering; for a
`spreadsheet, it is the values and formulas in the cells.
`How is the data presented?
`Again, for a word processor, the characters are typically
`displayed in a what-you-see-is-what-you-get (wysiwyg) for(cid:173)
`mat on the screen with appropriate line and page breaks; in
`a spreadsheet it is displayed as a table or a graph; and in a
`structured graphics program (e.g. MacDraw), it is displayed
`as a set of graphics objects.
`What can be selected?
`In a word processing application, a selection is typically
`a range of characters; in a structured graphics program it is
`a set of graphic objects.
`What are the commands that can operate on this selec-
`tion?
`A command in a word processor might be to change the
`style of a set of characters to bold. A command in a
`structured graphic program might be to rotate a graphic
`object. FIG. lB is an illustration of a display in accordance
`20 with the subject invention. A command is illustrated at 41 for
`bringing a picture to the front of a display. A presentation of
`graphic information is illustrated at 40. Finally, a selection
`of a particular graphic object, a circle, is shown at 42.
`A developer must answer the same four questions asked
`by the user. Fortunately, the subject invention provides
`frameworks and services for addressing each of these four
`questions. The first question that must be answered is: What
`am I modeling? In a word processing program, the data
`includes the characters that make up a document. The data
`in a spreadsheet includes the values and formulas in the
`cells. In a calendar program, the data includes the times and
`appointments associated with a given day. The invention
`provides facilities that help to model data There are classes
`for modeling specific data types including: text, structured
`graphics, sound and video. In addition to these specific
`classes, the invention provides a number of other abstrac(cid:173)
`tions that support problem modeling, including: collection
`classes, concurrency control, recovery framework, and the
`40 C++ language. The class that encapsulates the data model
`for a particular data type provides a specific protocol for
`accessing and modifying the data contained in the data
`encapsulator, support for overriding a generic protocol for
`embedding other data encapsulators and for being embedded
`in other data encapsulators, generating notification to all
`registered objects when the data changes, and overriding a
`generic protocol for creating presentations of the data.
`The next question that must be answered is: how is the
`data presented? In a structured graphic program, the set of
`50 graphic objects are typically rendered on a canvas. In a
`spreadsheet, it is typically a table of cells or a graph; and in
`a presentation program it is a set of slides or an outline. The
`subject invention provides a "view" of the data contained in
`a data encapsulator. The view is created using a "view
`55 system" and graphic system calls. However, playing a sound
`or video clip is also considered a presentation of the data
`Next: what can be selected? In a word processing pro(cid:173)
`gram, a selection is a range of characters; in a structured
`graphics program, it is a set of graphics objects; and in a
`60 spreadsheet it is a range of cells. The invention provides
`selection classes for all of the fundamental data types that
`the system supports. The abstract baseclass that represents a
`selection made by a user provides an address space inde(cid:173)
`pendent specification of the data selected. For text, this
`65 would be a numeric range of characters rather than a pair of
`pointers to the characters. This distinction is important
`because selections are exchanged between other machines
`
`

`
`5,479,601
`
`5
`
`10
`
`5
`when collaborating (in real-time) with other users. The
`baseclass also overrides a generic protocol for creating a
`persistent selection corresponding to this selection. Persis(cid:173)
`tent selections are subclasses of an anchor object and may be
`heavier weight than their corresponding ephemeral selec-
`tions because persistent selections must survive editing
`changes. For example, a persistent text selection must adjust
`itself when text is inserted before or after it. Anchors are
`used in the implementation of hypermedia linking, dataflow
`linking and annotations.
`The baseclass also provides an override generic protocol
`for absorbing, embedding and exporting data contained in a
`data encapsulator. Baseclasses are independent of the user
`interface technique used to create them. Selections are
`typically created via direct manipulation by a user (e.g. 15
`tracking out a range of text or cells) but can be created via
`a script or as a result of a command. This orthogonality with
`the user interface is very important. Baseclasses also provide
`specific protocol for accessing the data encapsulator. There
`is a very strong relationship between a particular subclass of 20
`the encapsulator class and its subclass of a model selection
`class.
`Finally: what are the commands that can operate on this
`selection? In a word processing program, a command might
`change the style ·of a selected range of characters and in a 25
`structured graphics program, a command might rotate a
`graphic object. The subject invention provides a large num(cid:173)
`ber of built-in command objects for all of the built-in data
`types as well as providing generic commands for Cut, Copy,
`Paste, Starting HyperMedia Links, Completing Links, Navi- 30
`gating Links, Pushing Data on Links, Pulling Data on Links,
`as well as many user interface commands. The abstract
`baseclass that represents a command made by the user is
`responsible for capturing the semantics of a user action,
`determining if the command can be done, undone, and 35
`redone. Command objects are responsible for encapsulating
`all of the information necessary to undo a command after a
`command is done. Before a command is done, command
`objects are very compact representations of a user action.
`The baseclass is independent of the user interface technique 40
`used to create them. Commands are typically created from
`menus or via direct manipulation by the user (e.g. moving a
`graphic object) but could be created via a script. This
`orthogonality with the user interface is very important.
`
`45
`
`6
`the data in the form of an object. Any-new data type that is
`created behaves exactly like the system-provided data types.
`In addition, the data in the scrapbook is editable since an
`object provides standard protocol for editing data.
`The scrapbook example highlights the advantages of data
`encapsulators. If software is developed such that it can
`handle data encapsulators, an application can be designed to
`simply handle a new data type. A new application can
`display and edit the new kind of data without modification.
`
`Multi-level Undo
`
`The invention is designed to support multi-level undo.
`Implementing this feature, however, requires no extra effort
`on the part of a developer. The system simply remembers all
`the command objects that are created. As long as the
`corresponding command object exist, a user can undo a
`particular change to the data. Because the system takes care
`of saving the commands and deciding which command to
`undo or redo, a user does not implement an undo procedure.
`
`Document Saving, Reliability, and Versioning
`
`A portion of the data encapsulator protocol deals with
`filing the data into a stream and recreating the data at another
`place and/or time. The system uses this protocol to imple(cid:173)
`ment document saving. By default, a user's data objects are
`streamed to a file when saved. When the document is
`opened, the data objects are recreated. The system uses a
`data management framework to ensure the data written to
`disk is in a consistent state. Users tend to save a file often so
`that their data will be preserved on disk if the system
`crashes. The subject invention does not require this type of
`saving, because the system keeps all the command objects.
`The state of the document can be reconstructed by starting
`from the last disk version of the document and replaying the
`command objects since that point in time. For reliability, the
`system automatically logs command objects to the disk as
`they occur, so that if the system crashes the user would not
`lose more than the last command.
`The invention also supports document versioning. A user
`can create a draft from the current state of a document. A
`draft is an immutable "snapshot" of the document at a
`particular point in time. (One reason to create a draft is to
`circulate it to other users for comments.) The system auto(cid:173)
`matically takes care of the details involved with creating a
`new draft.
`
`Collaboration
`
`Benefits of Frameworks
`
`The benefits of plugging into the abstractions in the
`invention are greater than providing a conceptual model.
`Plugging into the framework provides many sophisticated 50
`features architected into the base operating system. This
`means that the framework implements major user features
`by calling relatively small methods. The result is that an
`investment in coding for the framework is leveraged over
`several features.
`
`Multiple Data Types
`
`Once a new kind of data is implemented, the new data
`type becomes a part of the system. Existing software that can
`handle data encapsulators can handle your new data type
`without modification. This differs from current computer
`systems, such as the Macintosh computer system. For
`example, a scrapbook desk accessory can store any kind of
`data, but it can only display data that has a text or quickdraw
`picture component. In contrast, the subject invention's
`scrapbook displays any kind of data, because it deals with
`
`As mentioned above, a document can be reconstructed by
`starting with its state at some past time and applying the
`55 sequence of command objects performed since that time.
`This feature allows users to recover their work in the case of
`a crash, and it can also be used to support real-time col(cid:173)
`laboration. Command objects operate on selections, which
`are address-space independent. Therefore, a selection object
`60 can be sent to a collaborator over the network and used on
`a remote machine. The same is true of command objects. A
`command performed by one collaborator can be sent to the
`others and performed on their machines as well. If the
`collaborators start with identical copies of the data, then
`their copies will be remain "in sync" as they make changes.
`Creating a selection is done using a command object, so that
`all collaborators have the same current selection.
`
`65
`
`

`
`5,479,601
`
`7
`The system uses a feature known as "model based track(cid:173)
`ing" to perform mouse tracking on each collaborator's
`machine. The tracker object created to handle a mouse press
`creates and performs a series of incremental commands as a
`user moves the mouse. These commands are sent to col-
`laborators and performed by each collaborator. The result is
`that each collaborator sees the tracking feedback as it occurs.
`The system also establishes a collaboration policy. A col(cid:173)
`laboration policy decides whether users are forced to take
`turns when changing data or can make changes freely. The 10
`invention handles the mechanics of collaboration which
`removes the responsibility from an application developer.
`
`5
`
`8
`(Creating such a presentation is part of the standard data
`encapsulator protocol.)
`The reviewer can create selections in the document, and
`link posted notes to the selection. The link between the
`posted note and selection allows the system to position the
`posted note "near" the selection to which it refers. The links
`also make the annotation structure explicit, so that the
`system can implement standard commands to manipulate
`annotations. The contents of the posted note can be any data
`type implemented in the system, not simply text or graphics.
`The contents of a note is implemented using a data encap(cid:173)
`sulator, and opening a note results in creating an editable
`presentation on that data.
`
`Scripting
`
`15
`
`Data Representation
`
`Designing a system to manage the sequence of command
`objects also makes it possible to implement a systemwide
`scripting facility. The sequence of command objects is
`equivalent to a script of the local actions. The scripting
`feature simply keeps track of command objects applied to 20
`any document. The scripting facility also uses selection
`objects in scripts. This feature provides customization of a
`script by changing the selection to which the script applies.
`Since command objects include a protocol for indicating
`whether they can apply to a particular selection, the system 25
`ensures that a user's script changes are valid.
`
`Data representation is concerned with answering the
`question of what is the data that I am modeling? The subject
`invention provides facilities that help to model data. There
`are classes for modeling specific data types, including: text,
`structured graphics, sound and video. In addition to these
`specific classes, the invention provides a number of other
`abstractions that help to model a problem: the collection
`classes, the concurrency control and recovery framework,
`and the C++ language itself. In the subject invention, the
`class that encapsulates the data model for a particular data
`type is a subclass of the encapsulator class.
`
`Hypermedia Linking
`
`The Encapsulator Class
`
`Persistent selections, also known as anchors, can be 30
`A developer creates a container for a particular type of
`connected by link objects. A link object contains references
`data representation by creating a derived class of the encap(cid:173)
`sulator class. For each type of data in the system,. (e.g.
`to the two anchors that form its endpoints. To the system, the
`graphic objects, styled text, spreadsheet cells) a different
`link is bidirectional; both ends have equal capabilities.
`Certain higher-level uses oflinks may impose a direction on
`derived class must exist which acts as the container for a
`the link.