http://www.freepatentsonline.com/6558431.html

 

Storing valid and invalid markup language in strict and relaxed tables respectively

Document Type and Number:

United States Patent 6558431


Abstract:

The inventive editor allows web authors to edit HTML visually while preserving the HTML source document. The editor preserves the structure and format of the HTML, and permits simultaneous modeless visual and source document editing. When an edit is made with the invention, only the HTML source around that edit is updated, rather than rewriting the whole HTML source document. Furthermore, when an edit is made, the new HTML source code is outputted in a format that is specified by the user. In order to preserve the format of the document, format information is stored in the parsed tree. The format of the node is preserved when its source is regenerated; edits to the node will reformat it according to user preferences. In order to preserve the structure of the document, invalid HTML structures are maintained and not corrected. The invention will either support the invalid structure by reflecting such structure in the parsed tree, and thus allow for editing of the structure, or the invention will not support such a structure, and represent such structures as invalid nodes. Moreover, the invention also maintains structure while editing, as the structure and format of the document is only minimally modified during editing, i.e. only the nodes affected by the edits are restructured and reformatted, and the remainder of the document is unmodified.

 

Representative Image:

Storing valid and invalid markup language in strict and relaxed tables respectively

Inventors:

Lynch, Kevin M. (San Francisco, CA)
Jaramillo, Narciso B. (Fremont, CA)
Edelstein, Hava B. (San Francisco, CA)
Fuller, Benjamin G. (Campbell, CA)

 

http://patft.uspto.gov/netacgi/nph-Parser?Sect1=PTO2&Sect2=HITOFF&p=1&u=%2Fnetahtml%2FPTO%2Fsearch-bool.html&r=1&f=G&l=50&co1=AND&d=PTXT&s1=6558431&s2=fuller&OS=6558431+AND+fuller&RS=6558431+AND+fuller

 

United States Patent

6,558,431

Lynch ,   et al.

May 6, 2003


Storing valid and invalid markup language in strict and relaxed tables respectively

Abstract

The inventive editor allows web authors to edit HTML visually while preserving the HTML source document. The editor preserves the structure and format of the HTML, and permits simultaneous modeless visual and source document editing. When an edit is made with the invention, only the HTML source around that edit is updated, rather than rewriting the whole HTML source document. Furthermore, when an edit is made, the new HTML source code is outputted in a format that is specified by the user. In order to preserve the format of the document, format information is stored in the parsed tree. The format of the node is preserved when its source is regenerated; edits to the node will reformat it according to user preferences. In order to preserve the structure of the document, invalid HTML structures are maintained and not corrected. The invention will either support the invalid structure by reflecting such structure in the parsed tree, and thus allow for editing of the structure, or the invention will not support such a structure, and represent such structures as invalid nodes. Moreover, the invention also maintains structure while editing, as the structure and format of the document is only minimally modified during editing, i.e. only the nodes affected by the edits are restructured and reformatted, and the remainder of the document is unmodified.


Inventors:

Lynch; Kevin M. (San Francisco, CA), Jaramillo; Narciso B. (Fremont, CA), Edelstein; Hava B. (San Francisco, CA), Fuller; Benjamin G. (Campbell, CA)

Assignee:

Macromedia, Inc. (San Francisco, CA)

Appl. No.:

09/151,605

Filed:

September 11, 1998


Current U.S. Class:

715/210 ; 707/E17.116; 715/236; 715/249; 715/260; 715/760; 717/110; 717/112; 717/113

Current International Class:

G06F 17/30 (20060101); G06F 015/00 ()

Field of Search:

707/501.1,513 345/760 717/111-113


References Cited [Referenced By]


U.S. Patent Documents

 

 

 

5845299

December 1998

Arora et al.

5911145

June 1999

Arora et al.

6009441

December 1999

Mathieu et al.

6038573

March 2000

Parks

6055544

April 2000

DeRose et al.

6061697

May 2000

Nakao

6076108

June 2000

Courts et al.

6209095

March 2001

Anderson et al.

6253204

June 2001

Glass et al.

6343302

January 2002

Graham

 

 

 

 

Other References


Creating Commercial Web Pages, Lemay et al, SAMS, 8/96, p. 4-7.* .
Surfing the Internet with Internet Explorer, Miller, M., Que Publishing, Mar. 19, 1998, p. 1-11.* .
HTML 4 Unleashed, Professional Reference Edition, Darnell, R., McMillan Computer Pub., 1/198, p. 1-4.* .
Lewis, Adobe PageMill 2.0 Handbook, Hayden Books, 1996, p. 244-249.* .
Laura Lemay's Web Workshop JavaScript, Lemay et al, Sams.net, 1996, p. 3-6.* .
Bovier, D., "Versions and Standards of HTML", IEEE, p. 9-15..


Primary Examiner: Hong; Stephen S.
Assistant Examiner: Paula; Cesar B.
Attorney, Agent or Firm: Fulbright & Jaworski L.L.P.


Claims




What is claimed is:

1. A system for modifying a program written in a language, wherein the system edits the program in at least one of a text mode which presents the program in a text manner and a visual mode which presents the program in a simulated runtime mode, the system comprising: an internal representation of the program which includes format information of the program; a strict table which defines valid program structures according to a standard for the program; a relaxed table which defines supported program structures, wherein at least one supported program structure is not listed on the strict table as a valid program structure; a parser that loads the program and forms the internal representation using the relaxed table, and uses the relaxed table in interpreting modifications to the internal representation in satisfying edit requests made in the text mode; and an edit engine that uses the strict table in performing modifications to the internal representation in satisfying edit requests made in the simulated runtime mode.

2. The system of claim 1, further comprising: a source formatter that reformats modifications made by the edit engine to conform to user formatting preferences.

3. The system of claim 1, further comprising: a renderer that forms a viewable version of the program in the simulated runtime mode, receives the edit requests from a user, and delivers the edit requests to the edit engine.

4. The system of claim 1, further comprising: a generator for producing a modified version of the program in the language from the internal representation using the format information; and a text editor that forms a viewable version of the program in the text mode from the modified version, receives the edit requests from a user, and delivers the edit requests to the parser.

5. The system of claim 4, wherein: the generator forms a version of the program to be saved from the internal representation, upon completion of editing.

6. The system of claim 1, wherein: the parser marks a program structure that is not listed on the strict table and the relaxed table as an invalid, unsupported structure on the internal representation, which cannot be modified by the system.

7. The system of claim 6, wherein: the system indicates to a user that the invalid, unsupported structure is not supported by the system.

8. The system of claim 1, wherein: the system maintains invalid program structures that are listed on the relaxed table and creates valid program structures listed on the strict table in satisfying the edit requests from a user, wherein said invalid program structures are defined by nesting of individual program elements.

9. The system of claim 1, wherein: the language is HTML.

10. The system of claim 1, wherein: the internal representation is a tree; and the tree comprises a plurality of nodes with the format information attached to each node.

11. The system of claim 10, wherein: a portion of the tree encompassing a modification is normalized to conform to the strict table prior to performing the modification.

12. The system of claim 1, wherein: a portion of the program selected in one mode of the text mode and the simulated runtime mode, is also selected in the other mode.

13. The system of claim 1, wherein: a viewable version of the program in the text mode and a viewable version of the program in the simulated runtime mode are simultaneously viewable and editable by a user.

14. A method implemented in a computer for modifying a program written in a language, wherein the method edits the program in at least one of a text mode which presents the program in a text manner and a visual mode which presents the program in a simulated runtime mode, the method comprising the steps of: providing a strict table which defines valid program structures according to a standard for the program; providing a relaxed table which defines supported program structures, wherein at least one supported program structure is not listed on the strict table as a valid program structure; forming an internal representation of the program which includes format information of the program using the relaxed table, via a parser; interpreting modifications to the internal representation in satisfying edit requests made in the text mode using the relaxed table, via the parser; and performing modifications to the internal representation in satisfying edit requests made in the simulated runtime mode using the strict table, via an edit engine.

15. The method of claim 14, further comprising the step of: reformatting modifications made by the edit engine to conform to user formatting preferences, via a source formatter.

16. The method of claim 14, further comprising the steps of: forming a viewable version of the program in the simulated runtime mode, via a renderer; and receiving the edit requests from a user and delivering the edit requests to the edit engine, via the renderer.

17. The method of claim 14, further comprising the steps of: producing a modified version of the program in the language from the internal representation using the format information, via a generator; forming a viewable version of the program in the text mode from the modified version, via a text editor; and receiving the edit requests from a user and delivering the edit requests to the parser, via the text editor.

18. The method of claim 17, further comprising the step of forming a version of the program to be saved from the internal representation upon completion of editing, via the generator.

19. The method of claim 14, further comprising the step of: marking a program structure that is not listed on the strict table and the relaxed table as an invalid, unsupported structure on the internal representation, which cannot be modified by the method, via the parser.

20. The method of claim 19, further comprising the step of: indicating to a user that the invalid, unsupported structure is not supported by the method.

21. The method of claim 14, further comprising the steps of: maintaining an invalid program structure that is listed on the relaxed table; and creating valid program structures listed on the strict table in satisfying the edit requests from a user.

22. The method of claim 14, wherein: the language is HTML.

23. The method of claim 14, wherein: the internal representation is a tree; and the tree comprises a plurality of nodes with the format information attached to each node.

24. The method of claim 23, further comprising the step of: normalizing a portion of the tree encompassing a modification to conform to the strict table prior to performing the modification.

25. The method of claim 14, wherein: a portion of the program selected in one mode of the text mode and the simulated runtime mode, is also selected in the other mode.

26. The method of claim 14, wherein: a viewable version of the program in the text mode and a viewable version of the program in the simulated runtime mode are simultaneously viewable and editable by a user.

27. A system for modifying a program written in HTML language, wherein the system edits the program in at least one of a text mode which presents the program in a text manner and a visual mode which presents the program in a simulated runtime mode, the system comprising: an internal representational tree of the program, which includes format information of the program, and is comprised of a plurality of nodes; a strict table which defines valid program structures according to a standard for the program; a relaxed table which defines supported program structures, wherein at least one supported program structure is not listed on the strict table as a valid program structure; a parser that loads the program and forms the tree using the relaxed table, and uses the relaxed table in interpreting modifications to the tree in satisfying edit requests made in the text mode; an edit engine that uses the strict table in performing modifications to the tree in satisfying edit requests made in the simulated runtime mode; and a source formatter that reformats modifications made by the edit engine to conform to user formatting preferences; wherein the system maintains an invalid program structure that is listed on the relaxed table and creates valid program structures listed on the strict table in satisfying edit requests from a user.

28. The system of claim 27, further comprising: a renderer that forms a viewable version of the program in the simulated runtime mode, receives the edit requests from the user, and delivers the edit requests to the edit engine; a generator for producing a modified version of the program in the language from the tree using the format information; and a text editor that forms a viewable version of the program in the text mode from the modified version, receives the edit requests from the user, and delivers the edit requests to the parser.

29. The system of claim 27, wherein: a portion of the tree encompassing a modification is normalized to conform to the strict table prior to performing the modification.

30. The system of claim 27, further comprising: means for tracking selections between the modes such that a portion of the program selected in one mode of the text mode and the simulated runtime mode, is also selected in the other mode.

31. The system of claim 27, wherein: a viewable version of the program in the text mode and a viewable version of the program in the simulated runtime mode are simultaneously viewable and editable by the user.

32. A computer program product having a computer readable medium having computer program logic recorded thereon for modifying a program written in a language, the computer program product comprising: code for parsing the program into a text mode which presents the program in a textual view and a visual mode which presents the program in a simulated runtime view; code for editing the simulated runtime view: wherein edits made in the simulated runtime view cause corresponding edits in the textual view; wherein the code for editing the simulated runtime view changes only the format of the textual view which corresponds to the portion of the program edited in the simulated runtime view, the format comprising word spacing, line spacing, and other information relating to a visual representation of the textual view; and wherein the code for editing the simulated runtime view changes only the syntax structure of the textual view which corresponds to the portion of the program edited in the simulated runtime view, the syntax structure comprising the syntax, programming codes, and code relationships of the language.

33. The computer program product of claim 32 further comprising: code for simultaneously displaying the textual view and the simulated runtime view, wherein selections made in one view cause associated selections to be made in the other view.

34. The computer program product of claim 33 further comprising: code for editing the textual view, wherein edits to the textual view cause corresponding changes in the simulated runtime view.

35. The computer program product of claim 34 wherein the computer program product preserves edits made in the textual view unless subsequent edits are made to the same portion of the program in the simulated runtime view.

36. The computer program product of claim 32 wherein the format and syntax structure are preserved by said code for parsing when the program is one of loaded in or written out.

37. The computer program product of claim 32 further comprising: code for verifying language syntax.

38. The computer program product of claim 37 further comprising: code for displaying invalid language syntax distinct from valid language syntax.

39. The computer program product of claim 38 further comprising: code for determining acceptable invalid syntax.

40. The computer program product of claim 39 further comprising: code for determining changes to acceptable invalid syntax responsive to edits made in the simulated runtime view, wherein the computer program product changes only the acceptable invalid syntax corresponding to an edited portion of the simulated runtime view, and wherein acceptable invalid syntax not within the edited portion is preserved.

41. The computer program product of claim 38 further comprising: code for correcting all invalid language syntax responsive to a preselected choice made by a user.

42. The computer program product of claim 32 wherein the language is HTML.

43. The computer program product of claim 32 wherein the language is DHTML.

44. The computer program product of claim 32 wherein the language is XML.

45. A computer system for modifying a program written in a language, the system comprising: software that verifies program structure, wherein the program structure comprises language syntax and code relations; software that determines preservable invalid program structure, wherein said preservable invalid structure is defined by invalid nesting of individual program elements, and wherein said preservable invalid program structure is executable; and software that edits the program, wherein edits made to preservable invalid program structure are implemented with valid program structure formulated responsive to an internal set of programming rules, and wherein preservable invalid structure not within a portion of the program edited is maintained.

46. The system of claim 45 further comprising: software that simultaneously displays the program to a user in a text mode which presents the program in a text view and in a visual mode which presents the program in a graphical view.

47. The system of claim 46 wherein the system preserves formatting parameters in the program when the program is one of loaded and stored, wherein formatting parameters comprise instructions that control the visual layout of the text view as displayed to the user.

48. The system of claim 46 wherein the editing software allows a user to make at least one of edits and selections in one view of the text view and the graphical view, such that the at least one edits and selections in the one view are applied in both views.

49. The system of claim 48 further comprising: software that changes the formatting parameters of a portion of the text view edited in the graphical view.

50. The system of claim 46 further comprising: a format table comprising a list of formatting parameters pre-selected by a user.

51. The system of claim 50 wherein the system generates new programs in the text view and graphical view in accordance with the format table.

52. The system of claim 50 wherein the editing software changes the program structure of a portion of the text view edited in the graphical view.

53. The system of claim 50 wherein invalid program syntax is displayed differently that valid program syntax.

54. The system of claim 45 wherein the verification software provides a user an option to automatically correct the invalid program structure.

55. The system of claim 46 further comprising: a software routine that parses the program into a tree structure, wherein the tree structure comprises a plurality of nodes.

56. The system of claim 55 wherein each of the plurality of nodes corresponds to a portion of the program.

57. The system of claim 56 wherein formatting parameters of a portion of the program are stored in the nodes corresponding to that portion, wherein the tree structure is used to preserve the formatting of the program.

58. The method of claim 45 wherein the language comprises HTML.

59. The method of claim 45 wherein the language comprises DHTML.

60. The method of claim 45 wherein the language comprises XML.