All Packages from ulu.jini.* to ulu.why.*

Home >> All

•	ulu.jini.* (8)	•	ulu.jnlp.* (2)	•	ulu.pict.* (4)	•	ulu.show.* (7)
•	ulu.sim.* (87)	•	ulu.ut.* (55)	•	ulu.view.* (187)	•	ulu.why.* (23)

Package Samples:

• ulu.view.ui.cetus: Core user interface classes that can be reused for any type of user interface, handling low-level issues such as resolving tree position against text path descriptions, navigation history, paging of long lists, and so on.
• ulu.sim.dyn.macros: Core classes for a system dynamics simulator program designed for running the ECCO simulation models, but also applicable to other SD models.
• ulu.view.img.themes.wildthings: Contains a marker class used to find image resources inside jar files.
• ulu.view.io.zip: Classes used to serialise and deserialise Uncle Unc items.
• ulu.sim.boid: Common base-classes for simulation models of any kind.
• ulu.view.net: Define the core classes of the Uncle unc item tree.
• ulu.jnlp
• ulu.sim.ca
• ulu.sim.dyn.parser
• ulu.sim.dyn.gui
• ulu.sim.dyn.tools
• ulu.sim.dyn
• ulu.sim
• ulu.ut
• ulu.jini
• ulu.why
• ulu.pict
• ulu.show
• ulu.view.img.themes.ikons
• ulu.view.img.themes.freeicons

Classes:

• ProcessChainConfig: A utility for rapidly configuring a process chain via an XML spec. The spec is simple and follows the hierarchy of the underlying objects, i.e. value 37.5 27 48.1 This will create a group with three processors, two direct children, and one subgroup containing a further two, the latter being inactive initially. Note that the 'class' attribute refers to a fully-qualified java class name, and is mandatory for <processor> tags, but optional for <group> tags, which will default to a ulu.ut.ProcessChain if no class is defined. Optionally, a second argument can be passed to the create method ...
• XMLBeanInfo: A generic BeanInfo class that reads all it's info from an XML file, using the tiny nanoxml library. The XML spec allows definition of: a bean's display name icons for color and bw, 16- and 32- pixel property descriptors, and specification of a default event set descriptors, and specification of a default method descriptors The format of the XML structure is illustrated by the following example, which describes the bean info for a hypothetical 'lucky bean' object:
• ProcessChain: A common pattern to delegate processing of an object to one or more child tasks, each of which can either: return the object unchanged modify the object and then return it return null, stopping any further processing of the current chain and any parent chains throw an Exception, stopping any further processing of the current chain only (the parent will be handed the object as modified by the Processor in this chain immediately before the one that threw the exception This is similar to the old java 1.0 AWT event processing model, for example, or the Apache James Mailet processing chain. These both ...
• UpdateEvent: A View Event for sending update notifications to the client. Various types of update may be scheduled: complete update - throw away all previous info and reconstruct everything specified items have been added to the container specified items have been removed from the container unspecified properties have altered: update all properties for the specified items specific named properties have been altered: update only these properties redirect to a completely different View object. A UI may have several components that can change the view (e.g. a header bar showing ancestry and a body view showing ...
• Handler: A URLStreamHandler for the jarclass:// protocol, used to reference resources located in deployment jars that are retrieved by the ClassLoader.getResourceAsStream() method. This is a useful shorthand way of setting bean properties that point to a resource that will eventually be bundled with the bean, for example. A typical url is of the form jarclass://[reference-class-name]/[path-to-resource] For example: jarclass://ulu.view.View/img/src/default/item.png will generate a URL able to read the PNG image data located at path img/src/default in the jar (or file system) that is deploying the class ulu.view.View, ...
• Hermes: Hermes is a network-based installation program that brings together the java network launch protocol (JNLP, a.k.a. Java WebStart) and the apache group's Ant build tool. JNLP provides a strong model for deploying applications over a network automatically, but has rather strict requirements for the packaging of these apps, which many existing java apps don't meet (basically, any resources - images, config files, whatever) must be stored within a jar file, and extracted at runtime by a rather arcane method involving ClassLoaders and marker classes. Ant is a near-ubiquitous build tool that provides ...
• ObjectShaper: A Shaper that will set a live java object as the Item's reference, in a way that allows live interaction with that object through the UI. A refactoring of the ulu.view.sys.refl.ObjectView to use the Shaper delegate interface that can be applied to any Item rather than presenting a specialist subclass. Objects may be represented in several ways, with reflected members presented as child items (most suitable for documenting an object, say) or as properties and methods of the top-level item (which is better suited for live introspection, say). Further, bean accessor/mutator methods may be presented ...
• RSView: View service for browsing a JDBC ResultSet, with subviews listing the data and structure contained by the ResultSet This view holds a live ResultSet, and will scroll through it using an IteratingPager. Some ResultSets are not generated by SQL statements directly (e.g. many methods in the DatabaseMetaData class), and so this is the only viable option here. In cases where a SQL statement is available, a more flexible paging system can be implemented by deconstructing the SQL statement and using 'SELECT SUM(1)' to determine the size of the ResultSet, and SELECT's LIMIT clause to retrieve the individual ...
• Shaper: An object capable of modifying the fields and methods of an Item, possibly adding new children or pruning existing ones too. Earlier versions of Uncle Unc used specialised subclasses of ItemImpl or ViewImpl to represent specific services e.g. the StoredLogView, RSView, ObjectView. This led to some problems with multiple inheritance - for example, we might want to wrap a specific stream of content in more than one way (e.g. an Ant build file as a filesystem file, a plain XML file using a generic XML parser, and as an Ant Project object). The Shaper interface would allow more than one Shaper delegate ...
• ItemFactory: A factory object that can generate Items that act as wrappers around any object. The advantage of having a factory pattern is that it can return different specialist subclasses intelligently (which a constructor cannot). Uncle Unc ItemFactories work in a hierarchical fashion. To wrap an object, always pass it to the DefaultItemFactory, which will look up a class mapping, which will either return an Item object directly (typically for more complicated or specialist object types, such as a JavaSpace or a JDBC connection, say), or a custom factory class that may determine what class type to return ...
• Pager: A generic assistant for a User Interface of any kind that divides a large list up into pages (a la search engine results). This is a generic interface. In practice, there are two ways of doing the paging: request the full list of items and divide them into chunks within the pager component. This is good because its generic, and requires no service-specific code. request the items from the nderlying service one chunk at a time. For very large lists (a database with a million records, web search results) this will be much more efficient. It does require that the Unc wrapper implement additional methods ...
• MethodEvent: This was originally developed to allow authentication of the database module, which has since been solved differently using a 'login' UMethod. This approach may be more useful in other circumstances, left in for now as deprecated. Event indicating a request for input from the back-end to the user. Several items may be requested at once, in form of a Hashtable, allowing construction of a flexible dialog or input. Typical usage would be requesting userID and password for a locked resource. We re-use the UMethod object here that is used to represent Item methods. From a UI perspective, the two are ...
• NativePager: A generic assistant for a User Interface of any kind that divides a large list up into pages (a la search engine results). For a wrapper service, there are two ways of doing the paging: request the full list of items and divide them into chunks within the pager component. This is good because its generic, and requires no service-specific code. request the items from the nderlying service one chunk at a time. For very large lists (a database with a million records, web search results) this will be much more efficient. It does require that the Unc wrapper implement additional methods to retrieve ...
• Unloader: Generic interface for a mechanism that unloads the contents of a live Uncle Unc view to a persistent store of some sort (via a stream). Commonly used for backup between sessions, and remote networking between clients, for example. Note that this is similar in concept to serialization, but more specialised. We may wish to apply specific rules about what does and doesn't get recorded, particularly in the case of complicated auto-generated structures fetched from databases, jini, class hierarchies or whatever. In these cases its sometimes better to save a bookmark to the jdbc url or to the directory, ...
• ListHandler: A bespoke HTTP Handler for the Jetty web server that serves up flat listings from an Unc root view, using the HTTP path information to map to child views. Preliminary implementation, many bells and whistles we could add, for example: error reporting for unresolvable path data passing of ItemFilter specs to allow a query language? support for page numbering Need to work out the protocol for ths e.,g. passing as extra http headers, as a querystring or whatever. Note that this uses Jetty-specific APIs and bypasses the entire servlet API. We will undoubtedly wish to develop a complete servlet-based ...
• IteratingPagerImpl: An implementation of the Pager interface, suitable for views whose contents are filled by an iterating mechanism of some sort (whether an Iterator, a jdbc resultset, reading from a stream, or whatever). The common underlying feature is that the source can return an unknown (potentially infinite) number of items, and this stream will pull them in a chunk at a time and 'cache' them in the View being served, allowing reversible browsing through the cached section and forward-only browsing of the uncached region. Where the input iterator reaches an end, the pager will default to behaviour similar to ...
• Item: A generic interface for an item in a view, describing its properties and actions. Think icon in a file-manager as a starting point, but it could be a database table, a row in a database, a jini service, an element in a vector or hashtable, a live object, an email message, etc. etc. A Item may also implement View, in which case we get a nice tree structure e.g. filesystem directories By default it is Serializable - this first came up as an issue when implementing drag'n'drop in the ui/gui viewer, but seems like a good thing to do anyway, given the network-centric nature of the whole project refactored ...
• ObjectView: Objects may be represented in several ways, with reflected members presented as child items (most suitable for documenting an object, say) or as properties and methods of the top-level item (which is better suited for live introspection, say). Further, bean accessor/mutator methods may be presented as properties rather than the raw methods, if desired. Distinctions may be drawn between members declared in that class, and those inherited from parent classes. Under some situations, it may be useful for the user to interactively alter the mode of representation. This facility can be switched on or ...
• ProcessEvent: An event sent out by a Processor indicating that activity has occurred in the Process Chain. This is provided for debugging/interactive purposes, and is not a core part of the ProcessChain function. If no ProcessListeners are registered with the Chain, no events will be generated. Note that the substrate object is serialised via a RMI MarshalledObject. In many cases, the chain will modify an object and pass it on, so these modifications will be applied to any direct references to the substrate, resulting in us not getting a true picture of changes to the object as it percolates down the chain (which ...
• ShowPiece: ShowMan is a simple configurable network-based presentation tool. It is intended to facilitate interactive demonstrations of java code by providing a nice-looking commentary alongside real-live running code. This is a base interface for all pieces that make up a show presentation. Beyond implementing this interface, a good ShowPiece should follow bean-like design patterns, i.e. implement a no-arg constructor and provide get and set methods for public attributes, which may be defined as XML (so allow the setter to accept Strings). Setter methods ought to be hot-deployable too, i.e. the piece will ...
• UnloadConfig: Object that takes decisions about what level of detail to present when unloading a View to persistent storage. There is no single 'correct' way to persist a View hierarchy, and this object helps to present the options to the user. This is particularly important in the case of complicated auto-generated structures fetched from databases, jini, class hierarchies or whatever. In these cases its sometimes better to save a bookmark to the jdbc url or to the directory, say, if one simply wishes to reconstitute from source later, but at other times the user may wish to save all the details, to browse ...
• SocketLogView: LogView implementation that listens for input from a log4j SocketAppender. My thanks to Oliver Burn, author of the chainsaw GUI for log4j, whose 'LoggingReceiver' code I have referred to in creating this class. NB: There is no provision at present for saving this view to a file. Its a 'nice to have', for sure, but log4j is flexible enough to allow multiple appenders, so if that's required, then one can configure log4j to append to a file and a socket. For emergency situations, there will soon be the ability to persist any arbitrary view to XML, so that angle is covered too, I guess. Dave Crane ...
• UncItemDataSource: This class is an implementation of HierarchicalDataSource wherein tree nodes represent Items in an Uncle Unc tree. The ignoreLeaves argument of some forms of the constructor allows for the creation of leafless data sources. These are useful for driving a directory chooser, for example. Although designed for use with Uncle Unc Item s, the interactions with the item tree are all expressed in terms of the lower-level interfaces ( UContainer , UContained , Propertied ,etc.) so that other objects that implement these interfaces may also be dropped into the GUI and displayed.
• InheritanceTreeMethodShaper: A Shaper that will set a live java object's reflected Methods into several categories, one for each class in the inheritance tree, and one for each implemented interface. Categories are named after the relevant class or interfaces' non-qualified name, for brevity. This could lead to confusion potentially, if a class implements or extends both com.a.Something and com.b.Something, for example, but this is fairly unlikely to arise, and the alternative of using fully-qualified names would be horrendous. The fully-qualified class or interface is added as an extra property for reference, either as 'superclass' ...
• InheritanceTreePropertyShaper: A Shaper that will set a live java object's reflected Fields into several categories, one for each class in the inheritance tree, and one for each implemented interface. Categories are named after the relevant class or interfaces' non-qualified name, for brevity. This could lead to confusion potentially, if a class implements or extends both com.a.Something and com.b.Something, for example, but this is fairly unlikely to arise, and the alternative of using fully-qualified names would be horrendous. The fully-qualified class or interface is added as an extra property for reference, either as 'superclass' ...

Home | Contact Us | Privacy Policy | Terms of Service