Free html document software for linux

XML::DOM::Document is an XML document node in XML::DOM.

XML::DOM::Document extends XML::DOM::Node.

It is the main root of the XML document structure as returned by XML::DOM::Parser::parse and XML::DOM::Parser::parsefile.

Since elements, text nodes, comments, processing instructions, etc. cannot exist outside the context of a Document, the Document interface also contains the factory methods needed to create these objects. The Node objects created have a getOwnerDocument method which associates them with the Document within whose context they were created.

METHODS

getDocumentElement

This is a convenience method that allows direct access to the child node that is the root Element of the document.

getDoctype

The Document Type Declaration (see DocumentType) associated with this document. For HTML documents as well as XML documents without a document type declaration this returns undef. The DOM Level 1 does not support editing the Document Type Declaration.

Not In DOM Spec: This implementation allows editing the doctype. See XML::DOM::ignoreReadOnly for details.

getImplementation

The DOMImplementation object that handles this document. A DOM application may use objects from multiple implementations.

createElement (tagName)

Creates an element of the type specified. Note that the instance returned implements the Element interface, so attributes can be specified directly on the returned object.

DOMExceptions:

INVALID_CHARACTER_ERR

Raised if the tagName does not conform to the XML spec.

createTextNode (data)

Creates a Text node given the specified string.

createComment (data)

Creates a Comment node given the specified string.

createCDATASection (data)

Creates a CDATASection node given the specified string.

createAttribute (name [, value [, specified ]])

Creates an Attr of the given name. Note that the Attr instance can then be set on an Element using the setAttribute method.

Not In DOM Spec: The DOM Spec does not allow passing the value or the specified property in this method. In this implementation they are optional.

Parameters: value The attributes value. See Attr::setValue for details. If the value is not supplied, the specified property is set to 0. specified Whether the attribute value was specified or whether the default value was used. If not supplied, its assumed to be 1.

DOMExceptions:

INVALID_CHARACTER_ERR

Raised if the name does not conform to the XML spec.

createProcessingInstruction (target, data)

Creates a ProcessingInstruction node given the specified name and data strings.

Parameters: target The target part of the processing instruction. data The data for the node.

DOMExceptions:

INVALID_CHARACTER_ERR

Raised if the target does not conform to the XML spec.

createDocumentFragment

Creates an empty DocumentFragment object.

createEntityReference (name)

Creates an EntityReference object.

Auto Save Document is an extension used to store the currently shown document in a separate directory automatically.

Autosave is a small extension, which can be used to store the currently shown document in a seperate directory automatically when browsing a certain site. You may configure the sites, where all pages will be stored to cache, by adding them to a list. The documents are stored as html-text only (no embedded objects like pictures etc.)

The files are cyclic reused, e.g. if you set the cache size to 100, Autosave will store the document contents to X:/MyCache/Autosave_0.html ... AutoSave_100.html and start again with AutoSave_0.htm when the 101st page is browsed. A small Icon in the statusbar will change its colour each time to indicate a page was written.

If you click this small icon, the current page will be dumped, regardless if the site is in the autosave list or not.

NOTE: this extension is really, really simple! Only plain text is saved, no external .css,.js => the result may look ugly! The one and only intention for this extension is, to save the text for external parsing or similar! Look for Scrapbook etc. in case you want to store more than the plain text!

HTML::GenToc is a Perl module that generate a Table of Contents for HTML documents.

SYNOPSIS

use HTML::GenToc;

# create a new object
my $toc = new HTML::GenToc();

my $toc = new HTML::GenToc(title=>"Table of Contents",
toc=>$my_toc_file,
toc_entry=>{
H1=>1,
H2=>2
},
toc_end=>{
H1=>/H1,
H2=>/H2
}
);

# add further arguments
$toc->args(toc_tag=>"BODY",
toc_tag_replace=>0,
);

# generate anchors for a file
$toc->generate_anchors(infile=>$html_file,
overwrite=>0,
);

# generate a ToC from a file
$toc->generate_toc(infile=>$html_file,
footer=>$footer_file,
header=>$header_file
);

HTML::GenToc generates anchors and a table of contents for HTML documents. Depending on the arguments, it will insert the information it generates, or output to a string, a separate file or STDOUT.

While it defaults to taking H1 and H2 elements as the significant elements to put into the table of contents, any tag can be defined as a significant element. Also, it doesnt matter if the input HTML code is complete, pure HTML, one can input pseudo-html or page-fragments, which makes it suitable for using on templates and HTML meta-languages such as WML.

Also included in the distrubution is hypertoc, a script which uses the module so that one can process files on the command-line in a user-friendly manner.

Document clustering project is a data mining suite to cluster a document set. This set of tools was implemented from a series of papers: "Clustering Web Pages Semantically using Combinatorial Topology", "Data mining using granular computing", and "A fast association rule algorithm based on bitmap and granular computing".
Enhancements:
- A bug with hash table has been fixed.

HTML Purifier project is the premiere PHP solution for all your HTML filtering needs. Tired of forcing users to use BBCode or some other obscure custom markup language due to the current landscape of deficient or hole-ridden HTML filterers? Look no further: HTMLPurifier will not only remove all malicious code (the stuff of XSS), it will also make sure the HTML is standards compliant.
There are a number of ad hoc HTML filtering solutions out there on the web (some examples including PEARs HTML_Safe, kses and SafeHtmlChecker.class.php) that claim to filter HTML properly, preventing malicious JavaScript and layout breaking HTML from getting through the parser. None of them, however, demonstrates a thorough knowledge of the DTD that defines HTML or the caveats of HTML that cannot be expressed by a DTD.
Configurable filters (such as kses or PHPs built-in striptags() function) have trouble validating the contents of attributes and can be subject to security attacks due to poor configuration. Other filters take the naive approach of blacklisting known threats and tags, failing to account for the introduction of new technologies, new tags, new attributes or quirky browser behavior.
However, HTML Purifier takes a different approach, one that doesnt use specification-ignorant regexes or narrow blacklists. HTML Purifier will decompose the whole document into tokens, and rigorously process the tokens by: removing non-whitelisted elements, transforming bad practice tags like font into span, properly checking the nesting of tags and their children and validating all attributes according to their RFCs.
To my knowledge, there is nothing like this on the web yet. Not even MediaWiki, which allows an amazingly diverse mix of HTML and wikitext in its documents, gets all the nesting quirks right. Existing solutions hope that no JavaScript will slip through, but either do not attempt to ensure that the resulting output is valid XHTML or send the HTML through a draconic XML parser (and yet still get the nesting wrong: SafeHtmlChecker.class.php does not prevent a tags from being nested within each other).
Enhancements:
- This version amends a few bugs in some of newly introduced features for 2.1, namely running the standalone download version in PHP4 and %URI.MakeAbsolute.

Structured Document Validator project implements a generalized method for validating both the structure and content of structured documents.

Any data format that can be deterministically divided into tags and data is classed as a structured document. This definition applies to a wide array of data formats, including XML, Java properties files, and delimited value files.

The application performs validations based on user-defined Structured Document Definitions (SDDs). It provides an environment for validation, SDD development, and document editing.

HTMLatex is a mod_python application that uses memcached to reduce the massive overhead of repeatedly rendering the same equation. It has an option to sanitize the latex source removing any potentially dangerous code. Currently it is only tested on Apache 2 + mod_python with python 2.3 and py-memcached-1.2. It is fairly generous about the HTML and latex it accepts.
Im unsure if this will work on Windows as I paid zero attention to interoperability.
HTMLatex has two main goals: first, I wanted to avoid preprocessing; I wanted to be able to type the raw latex into an HTML document and be finished. Second, I wanted the HTML/Latex file to remain untouched.
There is one option: DEBUG. If DEBUG is set, the intermediate files are maintained on disk in /tmp/htmlatex -- this is the only method available for helping to troubleshoot latex errors. Oddly enough, performance should theoretically *increase* if debug mode is on as it doesnt require repeated filesystem access to delete files.
There used to be another option: SANITIZE, which checked the latex source for dangerous code and replaces it with a sanitized graphic. I decidd that giving people the option to auto-render latex code over the web that could do arbitrary things to their PC was a bad idea.
All latex code is sanitized now. If you want to turn it off, just comment out all of the _sanitize() calls in Equation._translateToTex().
Enhancements:
- Internet Explorer users can now see the rendered equations.
- Memcached is no longer used. Instead, images are served from the filesystem.

NOAH is a Web-based document management system that is feature-rich, easy to use, and simple to install. Through a browser interface, users can easily create, update, lock, search, and manage document revisions for access by multiple users across many geographical sites.
NOAH includes many powerful features such as client scripting, hierarchical document access control, and email notification. Administrators can manage users and archives and monitor database activity through an extensive suite of tools.
Main features:
- no expiry date.
- maximum number of users: 5 plus one Super Admin user.
- maximum number of documents: 100 (unlimited number of versions per document).
- includes Content Search option.
- does NOT include Client Scripting.
- does NOT include Email Notification.
- does NOT include multiple databases.
- does NOT include Support however emails will be answered if time permits.
Enhancements:
- A user can now get NOAH to report on recently changed files for a given directory tree and integrate this report in a wiki or HTML page.
- A user can also associate a filename with a custom icon and link a DokuWiki page with NOAHs content search engine, link critical NOAH documents and directories to your wiki project page, and manage usernames and passwords smoothly from NOAH to DokuWiki.