z
`"' 0
`\{) "'
`i'.=
`~ <(
`~ u
`u::
`:>
`~ (/)
`.ijj
`(/)
`:5
`.. 0
`~
`"'
`"' w
`::::>
`':¥} .
`(/)
`!Q
`
`(.)
`
`i .,
`'
`
`PATENT NUMBER
`
`. 6731309
`111mm~m11~1111111111111111111
`
`6731 309
`
`U.S. UTILITY PATENT APPLICATION ·
`1 u~
`PATENT DATE
`.. MAY O 4· 20 ,
`
`SECTOR
`
`SUBCLASS
`
`ill!Ul•llllli~'T'U
`
`J. O:FlcHE:
`
`(Arlaone<S in pocket on right""""' flap)
`
`·NOV 09 2004
`of Correction
`
`I•
`
`i'
`
`P-REPARED AND APPROVED FOR ISSUE.
`...
`~ISSUING 1
`CLASSIFiCATION
`. SUBCLASS (ONE SUBCLASS PER BLOCK)
`..
`CROSS REFERENCE(S)
`:,:;; -ti.Ass
`·L,~ 7RR
`522.. 'sz..to
`·701
`. '1 \ S.
`5 l·::t-
`
`..
`.,
`
`. ,
`
`:"' _·\
`
`..
`
`ORIGl~At:
`
`... ...
`..
`- ·
`CLASS .' I
`SUBCLASS .
`)~C1 I . 1e6
`
`r:.:. (' g r;
`
`J
`
`.
`
`INTERNATION AL CLASSIFICATl9N
`5/00
`I
`I
`I
`I
`
`'
`
`...
`
`0 Continued on Issue Slip Inside File Jacket
`
`DRAWINGS
`
`CLAIMS ALLOWED
`
`Sheets Drwg.
`
`' h
`
`'./"
`
`6' ~ · .,
`_·:....:.; A:..!.J'hu...c5~~~,,._._,H'--4'--il......;U::....__!pt//J3, J----------------1
`
`· Figs. Orwg.
`
`Print Fig ..
`
`·3Q '
`
`Total Claims•
`
`P~nt Claim for O.G.
`.i
`
`..
`
`NOTICE OF ALLOWA NCE MAILED
`
`(Assistari• Examiner)
`
`• (Oate)
`
`·.· ......
`
`D TERMINAL
`
`DISCLAIMER
`
`(date)
`
`O· a) The lerm 'or this patent
`subseQlient to
`has be~n disclainioct
`0 b) The !erm or this pat~nt Shall
`not extend biiyon.d the expiration date
`of U.S Patent. No:.
`
`. '
`
`0 c) The terminal _
`months of
`. this paten! have been disclaimed.
`
`Amount Due
`
`ISSUE BATCH N
`
`.
`
`WARNING:
`The information disclosuC: i'.erein may be restrtcted. Unauthorized disclosure ~ay be prohibtted by the Uniled Slates Code Tille 35, Sec1ionS 122, 181 snd 368.
`Pos..,ssion outside tM u.:l. Paten! & Trademarlc Office Is restricted to au1horized employees .and contractors only.
`
`fonn PT0-436A
`(Rov. 10197)
`
`ISSUE FEE IN FtLE
`
`(LABEL AREA)
`
`·"
`
`Corel Exhibit 2004
`Microsoft v. Corel
`IPR2016-01084
`
`

`
`,;..:· ..... .
`
`..... -
`
`PATENT APPUCAnON $ElUAL NO . - - - - - - - -
`.. ··
`U.S. DEPARTMENT OF COMMERCE
`PAlENT AND TRADEMARK OFFICE
`FEE RECORI> SHEET
`
`Wo.41199& lARllS . 00000027 091411J2
`m:~:
`.. ,. 00 IJI
`......
`
`01 f'C:101
`02 rt:102
`03 rt:10J
`
`PT0-1556
`(5/87)
`
`•.
`
`Corel Exhibit 2004, Page 2
`
`
`
`

`
`--u. ·
`=n HAYES,
`c:>~UI
`~=0: SOLOWAY,
`~-~ HENNESSEY,
`~-!'I GROSSMAN
`<D= & HAGE, P.C.
`- ~l
`
`:=....0
`
`175 CANAt STREET
`MANCHESTER, NH
`03101-2335 U.S.A.
`TEl 603-668-1400
`FAX 603-668-8567
`. f AX 603-668-0104
`
`BOX PATENT APPLICATION
`COMMISSIONER OF PATENTS & TRADEMARKS
`WASHINGTON, D.C. 20231
`
`Dear Sir:
`
`<
`Transmitted herewith for filing is the patent application of:
`
`Docket No.: GSH 08-879283
`Date:
`August 28, 1998
`
`Kevin C • . Unbedacht; Bruce G. Woodward, Eric D. Johnson
`Inventor:
`For:
`Real Time Preview
`
`Enclosed are the following:
`
`( ] Letter: SUBMISSION OF INCOMPLETE APPLICATION
`[x) Specification .1Q_ pages; Claims .J.L pages; Abstract _I page
`l XJ Declaration and Power of Attorney
`[X ) sheet(s) of drawings __ 6 _pages
`[X] An assignment of the invention to: Corel Corporation
`[ ] A verified statement to establish small entity status
`[ ] A certified copy.of
`application No.
`(X) Prior Art Disclosure Statement
`[ ) Preliminary Amendment
`
`filed __ ___ _ _
`
`Priority is hereby claimed under 35 USC 119 by way of _____ patent application
`No.
`filed __ . _______ _
`
`Benefit is hereby claimed under Title 35, United. States Code I 19(e) of United States provisional application
`No. ·
`filed _____ _ _
`
`The filing fee has been calculated as shown below:
`
`BASIC FEE:
`TOTAL CLAJMS:
`TNDEPENDENT CLAIMS:
`MULT. DEPEND. CLAIMS:
`TOTAL:
`
`40 - 20 = 20
`-3 = 3
`6
`
`SMALL ENTITY
`$ 395.00
`
`x II =
`x41=
`+ 135 =
`
`$
`
`LARGE ENTITY
`$ 790.00
`x22 = 440.00
`x 82 = 246.00
`+270=
`-0-
`$1475. 00
`
`[X] A check in the amount of$ 1516 • 00 is enclosed to cover the fees.
`[X ]'($40.00 Assignment recordal fee is included)
`
`The Commissioner is hereby authorized to charge any additional filing fees required under 37 CFR 1.16
`or credit any overpayment to Deposit Account No. 08-1391.
`
`Reg. No. 4,315
`
`"Express Mail" Mailing Label No.
`
`EM15544 7294US
`
`Date ofDeposit --=Au"'g..,u .. s.,.t_..2B.., . ._..!..._9~9B~
`
`I hereby certify that this paper and the papers listed thereon are being deposited with the United States
`Postal Service "Express Ma.ii Post Office to Addressee" service under 37 CFR 1.10 on the date indicated above,
`and is addressed to BOX PATENT APPLICATION, Commissioner of Patents, US Patent and Trademark Office,
`Incoming Mailroom, IBOI Crystal Plaza 2, 2021 Jefferson Davis Highway, Arlington, VA 22202-3602.
`Signature of person mailing: ----~¥<"'=:::.LA.,u_==;::_:,-.5{""""~"'°'""""~'---------
`Name of person mailing: ______ ....:;.K.::.,ri:::.:' s::,:t;;,;:i;.!'nc:::e--"-St,,.,e::.cv""e""n"'s_· - - - - - - -
`
`Corel Exhibit 2004, Page 3
`
`
`
`

`
`. •
`
`.• ~.l .....
`
`.
`
`.
`
`- 1 -
`
`The present invention relates generally to the manner in which computer
`
`software applications execute User commands, and more specifically, to providing a
`
`preview of identified User commands. '
`
`5
`
`Background of the Invention
`
`Most computer software application programs require interaction with the
`
`User in which t~e User may select commands from a variety of options. In document
`
`and graphic editing programs, for example, command options are available which
`
`alter the appearance of a User document. Generally, the process of executing
`
`10
`
`commands consists of a User scanning through a large list of menu or toolbar
`
`options, often in a multi-level hierarchy, to select and then execute a desired
`
`command: The execution of the selected command usual.ly consists of striking a
`
`<Return> key, an <Enter> key, clicking on an <Okay> icon, or responding positively
`
`to a query such as Confirm? (Y or N). ·The executed command then modifies the
`
`15
`
`application document and closes the menu·, and the User can see the impact of the
`
`command on the active document If the U_ser i~_ not happy with the result, the menu
`
`options must be scanned again, and another command selected and executed. This
`~
`process is slow and requires multiple keystrokes by the User, and may have to be
`
`repeated several times before the User obtains the desired result.
`
`20
`
`The same problems arise in text editing programs, graphic editing programs,
`
`and in software in general.
`
`To expedite the process of command selection, there are a number of
`
`methods of previewing how a proposed change will im~act a document. A technique
`
`common to text editing programs, is to provide a small dialogue window in a What-
`
`25
`
`you-see-is-what-you-get (WYSIWYG) format. These windows provide the User with
`
`a small sa'mple.of how the change will impact the text in the document, and are
`
`commonly used, for example, for font face and size. There are .two common
`
`implementations which are set out herein.
`The first implementation is to execute the format code on a generic text
`
`30'
`
`listing, for example, the uppercase and lowercase letters of ttie alphabet, or a string
`
`such as "The quick brown fox jumps over the lazy dog." Although such an
`
`implementation presents text in the format being considered, it may not show the
`
`imp.act on the particularcharacters the User is using. As well, because the preview
`
`/
`
`Corel Exhibit 2004, Page 4
`
`
`
`

`
`l
`
`'
`
`,
`
`I
`
`-2-
`
`window only presents a small sample, there is no indication of how the change might
`
`impact an entire document.
`
`The second implementation is to execute the format code on the first 20 or so
`
`characters of t~e selected text being modified. In this case, the text being modified
`
`5·
`
`comes from the us·er's actual text, so the preview window does provide the User with
`
`more information on how the change will affect the active document, but again, it is
`
`just a small sample. In the example of a font change, there is no ·indication of how
`
`th.e layout of the text in the document may be changed. Unexpected changes may
`
`o.ccur such ·as text wraRping unexpectedly, or a graphic being pushed to an
`
`~o
`
`unwa.nted location in the active document. The User only finds out how the
`
`document is changed by executing the command, tlien closing the menu window and
`. '·
`studying the document.
`
`There are also a number of commands in text editors for which no preview is
`
`given at all. With preview limited to a small sample window, there is no point in
`
`15
`
`providing the User with a preview of guideline or margin changes, for example.
`
`There is a need for such a preview as a User may wish to adjust the tab guidelines in
`
`a tabl·e so that the columns appear balanced. or change the margins so that the
`
`document does not exceed a certain number of pages.
`
`Generally margins and guidelines are.modified by the User grabbing them
`
`20
`
`with a curscr, that is, by positioning a cursor over the margin or guideline and holding
`
`a mouse click button down, then relocating the margin or guideline to a new location
`
`and releasing the click button on the mouse. While the line is being relocated, an·
`
`outline qr shadow of the .line appears in the document w indow, but the document
`
`itself is not updated until the mouse click is released, so there is no way to.dete'rmine
`
`25
`
`the impact on the document until the click is released.
`
`Graphic editing programs are commonly used to prepare brochures, tables.
`
`schedules. flow cha.rts. schematic diagrams. and many other such documents.
`
`Agafn. text preview w.indows are only appropriate for changes to the font size and
`
`type, so n.o preview is available for most other commands.
`
`30
`
`Some graphic ~diting .programs provide the User with outlines or shadows of
`
`graphic figures as they are being moved or modified, but such outlines do not reflect
`
`the actual change to the document. The User must execute the change to see the
`
`complete impact.
`
`Corel Exhibit 2004, Page 5
`
`
`
`

`
`..
`
`- 3 -
`
`.
`
`Commands may be selected from toolbar menus, toolbar combo-boxes,
`
`· toolbar grid-pickers and dialogue boxes, using a mouse. trackball, directional arrows,
`ALT key~ or Function keys . . As noted above, execution may be affected by striking a
`<Return> key, an <Enter> key, clicking on an <Okay> icon, or responding positively
`
`5
`
`to a query such as Confirm? (Y or N).
`
`There is therefore a need for a method of allowing a User to preview the.
`
`impact of commands on an active document, or in general, to execute c;ommands in
`
`an efficient and effective manner.
`
`10
`
`15
`
`20
`
`Summary of the Invention
`It is ·the~efo.re an object of the invention to provide a method and system of
`efficiehtly and effectively previewing User commands. ihe method executes User
`
`commands on the active·document as they are identified, providing the User with the
`
`actual impact of the command on the entire document in real time.
`
`Accordingly, an aspect of the invention is broadly defined as a method of
`
`pr_oviding real time preview of commands in a comput~r system having means for
`
`. displaying commands on a display screen, comprising the step of responding to one
`
`of the commands being identified by executing computer code corresponding to the
`
`identified command.
`
`Brief Description of the Drawings
`
`These and other features of the invention will become more apparent from
`
`the following description in which reference is made to the appended drawings in
`
`whieh .. :
`
`25
`
`;c{gure 1a presents a flow chart of a computer software routine for performing real
`
`~ :--.
`
`i~
`
`/
`
`I
`
`/
`1 30
`
`-
`
`time preview of commands in an embodiment of the invention, witti a
`
`cancellation option,
`
`.
`
`Figure 1 b presents a flow chart of a computer software routine for performing real
`
`time preview of commands in an embodiment of the invention, with a
`
`confirmation option;
`
`Figure 2 presents a flow chart of a computer software routine for performing real
`
`time preview of text docume·nt commands in an embodiment of the invention;
`
`Corel Exhibit 2004, Page 6
`
`
`
`

`
`.;,.; ·
`
`- 4 -
`
`Figure 3a presents a flow chart of a computer software routine for performing real
`
`time preview of margin or guideline commands in an embodiment of the
`
`invention; and
`
`Figure 3b presents a flow chart of a computer software rout.ine for cancelling
`
`5
`
`previewed margin or guideline .commands in an embodiment of the invention;
`
`and
`
`Figure 4 presents a flow chart of a computer software routine for performing real
`
`time preview of object movements in an embodiment of the invention.
`
`10
`
`Detailed Description of Preferred Embodiments of the Invention
`
`The invention is broa.dly defined as a method of providing real time preview of
`
`commands in a computer system having means for disp.laying commands on a
`
`display screen, comprising the step of r~sponding to one of the commands being
`
`identified by executing computer code corresponding to the ·identified command.
`
`15
`
`The primary distinction between this method and ihat of the prior art is that
`
`commands need only be identified by the User, and the identified command will be
`
`executed on the active document and the menu left open. Generally in the prior art,
`
`a command 111ust be selected and then executed by the User, before the menu will
`
`be closed and the document will be updated.
`
`20
`
`Becau.se the invention executes the identified command on the entire active
`
`\ . document when it is identified, the User is able to see ttie full impact of the
`
`command on the document. Because the menu has been left open, the User has
`
`the option of selecting a new command which will replace the identified command,
`
`confirming that the identified command is desired, or cancelling the identified
`
`25
`
`command.
`
`·Whether the menu should be left open or not depends on the nature of the ·
`
`. command being issued. When selecting a font face for example; ii is probably
`
`desirable to leave the menu op.en, wbile in executing a file save command, it
`
`probably is not desirable. Such a decision may be left to the programmer, who may
`
`30
`
`allow the User the option in a Preference selection. Implementation of such options
`
`would be well known to one skilled in the art.
`
`The software subroutines required to perform the method of the invention do
`
`not vary greatly from those subroutines known in the art. The order in which those
`
`subroutines are executed is important to the invention.
`
`Corel Exhibit 2004, Page 7
`
`
`
`

`
`_,_, .
`
`'
`
`'
`
`- 5 -
`
`Such methods will now be described with respect to the general application
`
`an,d then with respect to several preferred embodiments. As well, additional options
`
`arid advqntageous implementations will also be described.
`
`Figure 1a presents a flow c.hart of a co111puter softwarE') routine for performing
`
`5
`
`real time preview of commands in an embodiment of the invention, with a
`
`cancellation option. This routine is generally being run as part of a larger application
`
`program, and is integrated into that application program. The details necessary to
`
`implement the invention in different operating system environments, requi~ng sµch
`
`steps as polling or accepting interrupt requests from a keyboard are not described
`
`10
`
`herein. Such details would be known by one skilled in the art.
`At step 1 o· the· software application program notes that a menu or toolbar
`option has been identified. As described above, available.commands may be
`
`presented arid selected from menus and toolbars which may be set up as pull down
`
`·menus, dropdown cpntrols, toolbar combo-boxes, toolbar grid-pickers and dif!logue
`
`15
`
`boxes. Other implementations would also be known to one skilled in the art.
`
`These commands may be identified by the User in a number of manners,
`
`including use of a mouse and cursor, trackball, character keys, identifying the
`
`location of a cursor, mouse, arrow keys, ALT+ character commands, space bar
`
`location, voice commands, function keys or direction arrows on a keyboard. The
`
`20
`
`identified command may be emphasized using reverse video or a colour which
`
`contrasts the b'ackground and other commands. Such implementations and the
`
`software routines used to handle User inputs would be known to one skilled in the
`
`art.
`
`In an embodiment of the invention, it is envisioned that real time preview of a
`
`25
`
`command be optional, so the identified menu or toolbar option must be enabled by
`
`the User to allow real time preview. This can be done in a number of ways,
`. .
`.
`appropriate to the application or the programmer's preference. Preferably,
`
`commands for which real time preview is to be inade available, will be selectable,
`
`either individually or in groups, within a User's preference window. This would give
`
`30
`
`the User the option of disabling the real time preview feature if desired, and also to
`
`change the length of time required to execute certain options of the real time preview
`
`invention. More details are given regarding the timeout options in the following text.
`
`Once a command has been identified, the application p~ogram executes the
`
`command at step 12. The manner in which this execution is realized would depend
`
`I o
`
`Corel Exhibit 2004, Page 8
`
`
`
`

`
`-6-
`
`on the nature of the command and the application program, and would be known to
`
`one skilled in the art. · In a word processor, for example, this execution would
`
`generally comprise inserting a code corresponding to the identified option into the
`
`memory medium storing the active document. In the case of a file save command,
`
`5
`
`common to many software applications, this would comprise executing the
`
`appropriate software subroutine to effect storage of the active file.
`
`After the identified command has been executed, it would generally be
`
`saved in an Undo Stack at s!ep 14 so that the change can be undone if necessary.
`
`The document display window is then updated or refreshed, at step 16, if
`
`10
`
`changes.have been made to the window and if updating is necessary. Some
`
`programs may automatically update the window when new code is added to it in
`
`which·case updafing.does not appear as a discrete step in.the program. Other
`
`programs may not require refreshing, if the change in command code does not
`
`cause the window to be cluttered with impertinent or spurious data. Some real time
`
`15
`
`preview commands may not change the appearance of an open document, so of
`
`course. they would not require the display window to be updated either. Again, an
`
`example of this would be a file save command.
`
`Figure 1 a has included an optional cancellation feature at step 18. At this
`
`point, the command has been executed, and the User has been advised of the result
`
`20
`
`of the command execution. If the User wishes to cancel the command, it may be
`
`cancelled at this point by entering the appropriate instruction. Several commonly
`
`ysed cancellation commands are the <Escape>, <Backspace> or <Delete> keys.
`
`Clearly_ any key could be used, though it is best to be consistent with common
`
`conventions.
`
`25
`
`If the User selects the cancellation command. the document and ·Undo Stack
`
`are returned to their original state at step 20, and the document window refreshed at
`
`step 22. The identified and executed command is simply removed from the Undo
`Stack and used to direct the program as to how the document is to be modified to
`
`return the document to its original state. Software routines to effect such operations
`
`30
`
`are well known in the art.
`
`With regard to step 22, as described above, the windo_w may not require
`
`refreshing. Whether such a command is issued O( not will depend on the
`
`implementation.
`
`-1
`
`Corel Exhibit 2004, Page 9
`
`
`
`

`
`! •
`
`F ; , ,
`
`;=
`
`.··
`
`.:..:
`
`- 7 -
`
`Figure 1b presents a flow chart of a computer software routine for performing
`
`real time preview of commands in an embodiment of the invention, with a
`
`"confirmation" option, rather than the "cancellation" option described with respect to
`
`steps ~8. 20 and 22 of Figure 1a. Either method may be used, though as described
`
`5
`
`following, some applications are better suited to u11e ur other of these two options.
`
`As well, Figure 1b demonstrates in general terms how new commands may be
`
`identified and their impact viewed by the Us~r without having to close and re-open
`
`the menu window.
`
`In Figur.e 1 a it was noted that. because the menu has b.een left open, the
`
`10
`
`User has the option of either selecting a new command which will replace the current
`
`command, or cancelling the ·current command. In the embodiment of Figure 1 b, the
`
`User has the option of either selecting a new command or. ~onfirming the
`
`acceptability of the existing command.
`
`The function blocks of the Figure 1 b method are very similar to those of
`
`15
`
`Figure 1a. Initially, a command is be identified by the User, as per step 24. This is
`
`done in the same manner as described with respect to step 10 above. Once the
`
`command is identified, the corresponding application subroutine is executed at step
`
`26 and may introduce corresponding code to the active document. This step is done
`
`in the same manner as step 12 of Figure 1 a.
`
`20
`
`At this point, the method changes slightly from Figure 1a. Because this
`
`routine requires a command to be confirmed, it does not presuppose that the
`identified command was desired as in Figure 1a. Therefore, the document display .
`
`window is updated at step 28. but preferably the corresponding code will not be
`
`pushed onto the Undo Stack until step 30, at which point the User has confirmed that
`
`25
`
`this is the desired command.
`
`Alternatively, the command code could be pushed onto the Undo Stack
`
`immediately following step 28. This would result in the Undo Stack containing
`
`unconfirmed commi;mds which is generally not desirable. However, a User may
`
`prefer such. an option, and it could be maqe available. via a preferences selection.
`
`30
`
`If the User identifies a new co.mmand from the same menu window before
`
`confirming the previous command, at step 32. it may be executed in the same loop
`
`as steps 26 and 28. In some cases, further functionality will be required to remove
`
`e;isting code from the active document if it contains contrasting or contradicting
`
`Corel Exhibit 2004, Page 10
`
`
`
`

`
`- 8 -
`
`.
`.
`. .
`information. Such codes are described as matching codes and will be described in
`
`greater detail with respect to the preferred embodiments.
`
`Repeating this identification process· and updating the document will allow the
`
`User to put the active document.into the form desired and then confirm that the
`
`5 ·
`
`executed command is desin::d at :;tep 34. Confirming the identified command allows
`
`it to be pushed onto the Undo Stack at step 30 and the routine is complete.
`
`If the User is not satisfied with the impact of the identified command, the
`
`command is not confirmed a~ step 34, causing the document to be returned to the
`
`original state by executing an Undo operation at step 36, and updating the document
`
`10
`
`display window at step 38. Such steps are well known in the art. At this point the
`
`routine is complete.'·
`· Either of the methods described with respect to Figures 1 a or 1 b enable the
`Us~r· to _see the complete impact of any commands on the active document, while
`lea'i'ing the current menu open: In this way the commands can be executed much
`
`15
`
`more quickly and with fewer keystrokes than the methods known-in the art.
`
`;
`
`.
`
`Either of these methods may be easily implemented by one skilled in the art,
`
`.because generally speaking .. no new software routines are required. The method of
`
`'the invention consists generally of the same routines as known in the art, but
`. -
`ei<'ecuted in a different order. The task of implementing the invention is therefore
`
`20 .· :· .. dne of re-arra~ging existing routines to execute in the new order, and verifying and
`
`modifying if necessary the routines to maintain the coordination of variable
`
`declarations, assignments and calls. ·
`
`This method may be applied to a large variety of implementations.
`
`Examples described below include text editors, margin or guidelines, and graphic
`
`25
`
`editors. It would be clear to one skilled in the art however, how to apply the invention
`
`to other sottWare applications, such as spreadsheets and database management
`
`programs.
`
`The invention will now be described with' respect to a text editor which may
`
`be incorporated into a word processing package, graphic editor, spreadsheet or
`
`30
`
`other such software application.
`
`Generally speaking, such a routine may be implemented on a computer
`
`system having means for operating a document editing program and means for
`
`storing an active document in a memory medium. Such an application may also
`
`.•
`
`generally have a means for displaying menu options in a menu or toolbar option list.
`
`q
`
`Corel Exhibit 2004, Page 11
`
`
`
`

`
`. .:..l
`
`- 9 -
`
`The method itself comprises responding to one of the menu options in the menu or
`
`. too'lbar option list being identified by inserting code corresponding to the identified
`
`menu option into the memory medium storing the active document.
`
`This is in contrast to the method of the prior art described above, in which
`
`5
`
`commands must first be selected, then executed, at which time the menu Is closed
`
`and the document updated. The invention therefore requires less time and fewer
`
`keystrokes to be entered by the User to see the resulting change on the active
`
`document:
`
`Figure 2 presents· a flowchart of a computer software routine for performing
`
`10
`
`such a real time preview of text editing commands in an embodiment of the
`
`invention. This method can 'typically be incorporated into a standard text editing
`
`application program, by altering the order of the existing sqftware subroutines.
`
`At step 40, a command is identified by a cursor hovering over a menu or
`
`toolbar option. As described above, commands may be presented by the application
`
`15
`
`program in a number of manners including pull down menus and dialogue boxes.
`
`The User may select from the menus using a mouse, trackball, etc. Cursors are
`
`commonly controlled with mouses and software drivers incorporated into operating
`
`systems. Some software programs identify commands by inverting the video. The
`
`cursor being positioned above a command is generally described as hovering, and is
`
`20
`
`used to identify commands.
`
`Preferably, the identification of the command can be contingent upon the
`
`cursor hovering over the command for a predetermined period of time. This would
`
`allow the User to scan through a list of commands without each successive
`
`comriand being identified, and hence executed. The length of time re·quired for this
`
`25
`
`timeout could be established by the User in the Preferences of the Operating
`
`System, or in the Preferences of the particular application program. A single timeout
`
`could be used, or groups of commands could have different timeouts a.ssigned by
`
`the User.
`
`Until the User identifies a command, the routine remains at step 40. The flow
`
`· 30
`
`chart is shown in this manner for simplification. One skilled in the art.would be
`
`aware of the necessary interrupts, operating system calls or polling required to
`
`implement such a step.
`
`Once a command has been identified, the software routine corresponding to
`
`the identified command is executed, and it checks whether the identified command is
`
`Corel Exhibit 2004, Page 12
`
`
`
`

`
`- 10 -
`
`enabled for the real time preview at_step 42. A straightforward implementation of
`
`such a featu re would be to control operability of the real time preview in the Users
`
`Preferences, eitf:ler in the application program or operating system preferences. ·
`
`These Preferences would then set a global boolean flag as to whether real time
`
`5
`
`preview is enabled or not. and each related command subroutine would check
`
`whether the flag is set or not. If the flag is not set to enable the real time preview for
`
`the identified command, then the program would continue to execute the. command
`
`in the normal manner, shown as step 44 in Figure 2.
`
`Of course, the invention does require that such an enablement check be
`
`10
`
`performed, and there are also many other ways in which such an enablement check
`
`could be implemente,d. The.given implementation has the advantage of being easily
`
`implemented. It only requires .a single additional line of co.de to the execution
`
`subroutine of each of the· pertinent commands.
`
`If the identified command is enabled for real time preview, the execution
`
`15
`
`continues with step 46, which investigates whether there is a matching code already
`
`in the User document. A matching code is typically one which effects the same text
`
`block and in the same manner as the identified command, but yields a different
`
`appearance. Different font sizes, for example, would yield matching codes. If a
`
`·sele.cted block of text has a font size of 10, and the identified command is to change
`
`20
`
`the font size of the same block of text to font size 12, then the routine will find the
`
`font size 10 matching codes, remove them at step 48 and insert the code for the font
`
`size 12 into the document at step 50.
`
`If no matching code exists, the program continues directly to insert the code
`
`corresponding to the identifie~ command at step 50. In general, commands which
`
`25
`
`do not directly impact the appearance of a document will not have codes stored with
`
`. a document, so no such matching codes will exist. File management commands
`
`such as Save, Open and Close are examples of such commands.
`
`Also, application programs do not generally have a discrete mapping
`
`between commands and code to be inserted into the document. Rather a command
`will invoke .a softw~re subroutine that performs numerous tests and checks, and may
`
`30
`
`ultimately result in code being added to the active. document. The operation of such
`
`subroutines themselves is not the subject of this invention and are not included
`
`herein for simplicity. The implementation of such routine would be well known fo one
`
`skilled in the art.
`
`{
`
`Corel Exhibit 2004, Page 13
`
`
`
`

`
`- 11 -
`
`It is not the intent of the invention to alter how codes are stored in a
`
`document. The invention may be implemented in existing application programs by
`
`using the existing subroutines to insert code, identify matching codes and replace
`
`them. Such program.s may als? exec.ute steps 48 and 50 in a different order, in less
`
`5
`
`clearly defined steps, or by storing code in different riarts of the active document.
`
`The User may have a default text font and font size stored in a document header,
`
`and only alter the code in part of the document. The manner in which a given
`
`application program would implement such steps would be known in the art.
`
`At this point, the User docum_ent contains the code corresponding to the
`
`10
`
`identified command. If the document display window requires updating to present a
`
`clear image to the_ U~er, it is done at step. 52. As described above, whether such a
`
`step is required will depend on the application program. Generally, applications
`
`which require such refreshing or updating, will already contain the necessary
`
`15
`
`20
`
`I
`
`•
`
`0
`00
`1\1
`OJ
`\0 co
`
`-subroutines to perform such operations.
`
`In a preferred embodiment of the invention for text editing routines, it is
`
`intended that the User confirm or accept the identified command, shown as step 54'.
`
`Such a query to the User may be provided as a dialogue box in a command window,
`
`or by similar means.
`
`If the User confirms the identified command, then the program need only
`
`push the identified command urito the Undo Stack at step 56, which contains a listing
`
`of the executed commands in sequential order, and close the menu or toolbar at step
`
`58. Again, implementation of such subroutines are known in the art and are
`
`· generally already available in most application programs if they are required.
`
`Some application programs do not allow the User to undo executed
`
`25
`
`commands. so do not have an Undo Stack. Other programs which provide means
`
`for storing commands on an Unao Stack, or a similar means of storing executed
`
`commands allowing them to be undone, may only provide the Undo feature for
`
`certain commands. Clearly, implementation of step 56 is therefore at the discretion
`
`of the programmer.
`
`30
`
`Some menus and toolbars are always dispiayed to the User and clearly
`
`would not have to be closed per step 58.
`
`If the User does not confirm the identified command at step 54, either the
`
`menu or toolbar may be closed, or a new command identified which returns the
`
`program to step 40. When th