All Packages from org.merlotxml.awt.* to org.merlotxml.util.*

Home >> All >> org >> merlotxml

•

Package Samples:

• org.merlotxml.merlot.plugins.action.configeditor
• org.merlotxml.merlot.plugins.configeditor
• org.merlotxml.util.xml.xml4j
• org.merlotxml.util.xml.xerces
• org.merlotxml.util.xml
• org.merlotxml.util
• org.merlotxml.merlot.appicons
• org.merlotxml.merlot.plugin.dtd
• org.merlotxml.merlot.plugin.action
• org.merlotxml.merlot.plugin
• org.merlotxml.merlot.icons
• org.merlotxml.merlot
• org.merlotxml.awt

Classes:

• DTDContentSpecNode: Interface to specify a ContentSpecification node. This is used to describe the content specification of what a DTD element can contain. Example from a DTD: (el1?, el2+ (el3 | el4 | el5)*) Each node is part of a tree and has a type. CONTENT_GROUP nodes correspond to a ( ) delimted container, a CONTENT_SINGLE node would be a single element leaf with no ordinality specified. (like 'el3' in the above example) Possible types: CONTENT_GROUP: ( stuff between parens ) getLeft returns the first node getRight returns null CONTENT_OR: el3 | el4 getLeft returns the first leaf getRight returns a leaf or another ...
• XMLEditorFrame: The main frame for the application. This sets up the menus and toolbars. This also manages the internal frames via the JDesktopPane. It is a singleton instance class similar to XMLEditor. You get the singleton instance with the getSharedInstance() method. Methods of interest in this class are the addInternalFrame() methods for displaying a JInternalFrame within this main frame. This class also includes some of the main operation methods which are called by their cooresponding Action in XMLEditorActions. These include quit(), newFile(), openFile(), revert(), save(), saveAs(), cut(), copy(), paste() ...
• DTDCache: This singleton class is responsible for loading and caching all DTD's required by the system. This manager can load DTD's from the filesystem, URL's, and zip/jar files (not currently implemented). Apps should use this class to retrieve all their DTD's for valid documents (non-validating apps usually ignore the DTD anyway, so they don't really need to use this, but if they do get a DTD, it might be a good idea to call into this class. Here's an example of getting a dtd: DTDCacheEntry dtdentry = DTDCache.getSharedInstance().findDTD(publicId, systemId); where publicId is the DOCTYPE's given public ...
• PluginClassLoader: This classloader loads plugin classes and resources from merlot plugin jar files or plugin development directories. When loading a class or a resource from a jar file, it first looks in the jar directly (as the normal class loader does), then it checks the classes directory, and lastly, it checks for embedded jar files located in a lib directory within the plugin jar file. To load classes and resource from embedded jar files, the PluginClassLoader must write out jars in the lib directory to a temporary location to be used by ZipFile.
• XMLEditor: This is the main class for Merlot. It provides the entry point to the application with the main static method. This starts by loading up the XMLEditorSettings which handles parsing the command line options, and reading in the application properties files. Next, this loads plugins via the PluginManager, and finally it initializes and opens up the main XMLEditorFrame. XMLEditor is a Singleton class. Use getSharedInstance to get the singleton instance of this class.
• MerlotDOMEditor: This is an interface which every Node editor panel must implement. Node editors provide a way to change information contained in a DOM node within an xml file. This includes special menu items to add to the right-click popup menu and an editing panel to change attributes and sub-nodes. DOMEditors can also specify what types of nodes should not show up in the tree view (this functionality may move into the plugin classes instead of here... it doesn't really belong here.)
• ConfigEditorCfgPanel: This is a generic node editing panel which provides a component for each attribute listed with the element it's created to edit, along with a text box for PCDATA. This class can be extended to change what the user sees for each attribute field. Typically the easiest methods to overload for this type of custom editors are getEditComponent() and sometimes save().
• ConfigEditorRecordPanel: This is a generic node editing panel which provides a component for each attribute listed with the element it's created to edit, along with a text box for PCDATA. This class can be extended to change what the user sees for each attribute field. Typically the easiest methods to overload for this type of custom editors are getEditComponent() and sometimes save().
• GenericDOMEditPanel: This is a generic node editing panel which provides a component for each attribute listed with the element it's created to edit, along with a text box for PCDATA. This class can be extended to change what the user sees for each attribute field. Typically the easiest methods to overload for this type of custom editors are getEditComponent() and sometimes save().
• CommentEditPanel: This is a generic node editing panel which provides a component for each attribute listed with the element it's created to edit, along with a text box for PCDATA. This class can be extended to change what the user sees for each attribute field. Typically the easiest methods to overload for this type of custom editors are getEditComponent() and sometimes save().
• DNDJScrollPane: JScrollPane that delegates drag and drop events to it's viewport component if the viewport supports drag and drop. This is usefull for things like tables or trees that might not fill their scrollpane, but you still want to be able to drop stuff within the full pane and have it go to the component. XXX I don't thinks this works currently
• MerlotTransferableListener: This interface allows for certain operations like cut, copy, paste, etc. to be performed at the top level (the XMLEditorFrame) and be passed on to the correct internal frame that needs to handle it. This is so we don't have a myriad of actions to enable/disable when the all do basically the same thing.
• DTDContentSpec: Interface to specify a ContentSpecification This is used to describe the content specification of what a DTD element can contain. The types this can return are ANY, EMPTY, PCDATA, GROUP where GROUP type specs will have a tree of ContentSpecNodes describing what's in the content specification
• DTDElement: This is an interface that will provide DTD information about an element definition. In the above example, the element's name is "blah", and it has a content spec with (foo?, bar+, baz*).
• MerlotEditorFactory: Factory singleton to get editors for particular types of nodes and elements. This is the class that gets editor panels from plugins for whatever element type they want to handle. otherwise, this produces a generic Xml component editor
• MerlotDOMDocument: DOM document container for Merlot. Contains a DOM node, handles getting an icon for a particular node, getting the editor for a node, etc. Also implements transferable so that the node can be drag and dropped, or cut and pasted.
• MerlotDOMDoctype: DOM document container for Merlot. Contains a DOM node, handles getting an icon for a particular node, getting the editor for a node, etc. Also implements transferable so that the node can be drag and dropped, or cut and pasted.
• MerlotDOMElement: DOM element container for Merlot. Contains a DOM node, handles getting an icon for a particular node, getting the editor for a node, etc. Also implements transferable so that the node can be drag and dropped, or cut and pasted.
• MerlotDOMNode: DOM node container for Merlot. Contains a DOM node, handles getting an icon for a particular node, getting the editor for a node, etc. Also implements transferable so that the node can be drag and dropped, or cut and pasted.
• XMLFile: An XML file. This provides an internface into a particular XML file, including its dtd and its file location. It provides methods for loading and parsing a file, saving a file, and accessing the content model in the dtd.
• DTDDocument: This interface provides means to access the DTD definitions in a manner that can be independent of whatever third party underlying structures are used for the implementation.
• DOMLiaison: DOM Liaison This interface makes up for deficiencies in the DOM API. It allows you to plug in different XML libraries by creating implementations of this interface.
• DTDContentSpecImpl: A Content Specification based on xml4j This is mostly unimplemented due to a possible requirements change while working on this. Do not try to use this stuff :-)
• ActionPluginConfig: Merlot Action Plugin Configuration An action plugin can contain multiple actions. Similarly, an action plugin config can contain multiple action configs.

Home | Contact Us | Privacy Policy | Terms of Service