Next: Ka-Km Up: Linux Software Encyclopedia Previous: Ja-Jm Contents

Jn-Jz

Last checked or modified: Aug. 16, 2000

JNet: A collection of UNIX commands for writing scripts that can be installed either as a single program with full functionality or as a set of programs, one for each function. The JNet functions include:

claim-lockfile, to create a lockfile atomically, i.e. only create it if one of the same name doesn't already exist;

fetch-url, to download a web page;

for, to print out integers in a given range;

getpass, to read a password and print it on standard output;

ip, to print the IP address of a specified host;

local-ip, to print the IP address of the computer you're on;

net-connect, an 8-bit clean application to open a TCP/IP connection on a specified port on a specified host;

net-server, which waits for a TCP/IP connection on a specified port;

net-repeater, which starts a local repeater daemon that relays all connection to the local machine on the specified local port through to the specified remote machine and port;

net-check-server, which attempts to connect to a specified server;

older-days, which returns true if a file is older than a specified number of days;

older-seconds, which does the same for seconds;

older-than, to compare the ages of two files;

path-relative-to, which converts a path into a path relative to a specified environment variable;

random-hex, which prints a sequence of random hex digits;

random-decimal, which prints a sequence of random decimal digits;

random-line, which prints a randomly selected line from a specified file;

random-pick, which randomly picks from a list of specified values;

random-sort, which reads a file and reorders the lines randomly;

seach-path, which searches a path for a program and prints out the path;

strip-ctrl-chars, which strips all control characters except tab and newline from a file; and

wait-file, which waits for a file to be modified, created or deleted and exits when it changes.

A source code distribution of the JNet tools is available.
[http://charm.cs.uiuc.edu/~jyelon/jnet.html]
John the Ripper: A password cracker that combines several cracking modes in one program. It supports and autodetects several ciphertext formats including standard and double-length DES-based, BSDI's extended DES-based, FreeBSD's MD5-based and OpenBSD's Blowfish-based. This contains its own highly optimized modules for different ciphertext formats and architectures as well as assembly routines for several processors and architectures (e.g. for Intel Pentium, X86 with MMX, generic X86, Alpha EV4 and SPARC V8 processors). A source code distribution is available.
[http://www.openwall.com/john/]
JOnAS: The Java Open Application Server is an implementation of the EJB (Enterprise JavaBeans) specification built on top of JD and JNDI. It is a project that aims to provide a complete Java middleware infrastructure. The JOnAS package is composed of:

a Java Transaction Monitor (JTM);

a set of Java classes implementing the EJB specification; and

a set of tools for generating interposition classes (containers) and deployment descriptors.

The features and functionality of JOnAS include:

support for stateless and stateful Session Beans;

support for Entity Beans with either Bean Managed Persistence or Container Managed Persistence (both via JDBC);

support for all transaction attributes;

support for JTA 1.0.1; and

distribution via RMI and naming via JNDI.

JOnAS is available under an MPL-like license wherein distribution is allow with commercial applications with a modification that covers the provided core application server. Documentation is included in the distribution package.
[http://www.evidian.com/jonas/]
JOODA: The Java Object Oriented Development Environment is a project to develop a sophisticated IDE for Java. It is still (4/00) under heavy development with the current feature set including:

the look and feel of the Smalltalk-IDE Envy/Developer package;

syntax highlighting;

dynamic code execution;

on-the-fly source code parsing;

file- and class-based editing of source code; and

project management.

[http://jooda.sourceforge.net/]
JOS: The Java Operating System is a collaborative project to create a free and open Java-based operating system. An initial working nano-kernel is supposed to be available in the first quarter of 1998.
[http://www.jos.org/]
joyd: A device driver that allows commands to be triggered via a joystick. This can be used to execute any command with a joystick, allowing commands to be bound to single buttons, joystick movements, or combinations thereof. Multiple commands can even be bound to one combination. This can run in either normal or daemon mode.
[http://www.h.shuttle.de/mitch/joyd.en.html]
JPEG: The Joint Photographic Experts Group is a standarized image compression mechanism named for the committee that wrote the standard. JPEG is designed for compressing either full-color or gray-scale images of natural, real-world scenes. It works well on photographs, naturalistic artwork, and similar material and not so well on lettering, simple cartoons, or line drawings. It handles only still images with moving images handled by MPEG. It is a lossy compression technique which means that a decompressed image isn't exactly the same as the original (although some implementations do allow lossless compression as an option). JPEG is designed to exploit known limitations of the human eye, e.g. small color details aren't perceived as well as small details of light and dark, which explains why it does better on images that will be looked at by humans. JPEG implementations allow for a trade-off between file size and output quality, allowing users to make file sizes smaller/bigger in trade for worse/better image quality.
Source code for performing JPEG compression is available from several sources, including the PVRG-JPEG package. There are several software packages that allow the viewing and manipulating of JPEG images on X11, including xv, ImageMagick, xloadimage, and xli.
[http://www.jpeg.org/]
[http://www.faqs.org/faqs/jpeg-faq/]
jpeg2ps: A utility for converting JPEG images into compressed PostScript leve 2 files without uncompressing the images. This simply wraps the JPEG data with PostScript to create smaller PostScript files than with other methods.
[http://www.pdflib.com/jpeg2ps/]
JPHS: JPEG Hide and Seek is a steganography package containing programs for hiding and extracting files in a JPEG image. The design goal was to not only hide files but to also do it in such a way that it is impossible to prove that the image contains a hidden file. The distribution consists of jphide for hiding the files and jpseek for extracting the files.
[http://linux01.gwdg.de/~alatham/]
JPICC: A program for computing incomplete Cholesky factors of sparse matrices for use as preconditioners in a conjugate gradient algorithm. The code implements two incomplete factorization algorithms as well as an efficient version of standard incomplete Cholesky factorization. This is TOMS algorithm 740 and is documented in Jones and Plassmann (1995b) and Jones and Plassmann (1995a).
[http://www.acm.org/calgo/contents/]
[http://www.netlib.org/toms/index.html]
jpub: A software concept for intranets that can also be though of as an operating system for internal webs. Jpub provides a framework for doing nearly anything you might want to do in a browser as opposed to using a veritable plethora of proprietary client tools. The features include:

a highly specialized web server that makes creating documents as easy as retrieving them;

user tracking and permission facilities built to deal with non-anonymous participants, each having their own privileges and rights;

a virtual file system that gives the server a fuller measure of control over its output than servers usually have; and

an integrated GUI for users including a file manager with directories and documents listed by title and description.

A source code distribution of this Java package is available.
[http://www.jpub.de/]
jPVM: An interface written using the Java native methods capability which allows Java applications to use the PVM software. JavaPVM extends the capabilities of PVM to Java, an architecture-independent programming language for the Internet. It allows Java applications (and possibly applets) and existing C, C++ and Fortran applications to communicate with one another. This enables such things as building Java interfaces to existing programs and use PVM to ship data from those programs to the Java interface, or use it as a communications package while translating one's applications from C or C++ to Java. This is not an implementation of PVM written in Java.
The jPVM package requires an implementation of Java, PVM, GNU make, and gcc. The program is currently (3/97) set up for Sun Solaris, SGI IRIX, and IBM RS6000 platforms, but is supposedly easily portable via tweaking a few include files. This has been built with the V1.1b2 version of the JDK. The documentation is included in the distribution in the form of HTML files.
[http://www.chmsr.gatech.edu/jPVM/]
JPython: An implementation of the Python language designed to run on top of any Java virtual machine. It compiles Python source code to Java bytecodes which will run on any JVM. It also provides a clean interface to allow JPython programmers easy access to Java packages. The features include high-level built-in data types, dynamic typing, packages, classes, and interactive compilation to Java by bytecodes. The integration with Java includes the ability to call Java methods, create instances of Java classes, subclass Java classes within JPython, and use JPython classes from Java.
[http://www.jpython.org/]
Jrju: A Perl program which weaves hypertext notebooks out of plain text files. A series of notebook pages are created in the very simple JTX file format and Jrju processes them into a cross-linked collection of HTML pages. Each notebook has a table of contents which serves as a top level index, and hierarchical indexes supply more specificity when needed. Other features include automatic linking of cross-references and inverse references, automatic placement of graphics, automatic linking of external resources and email address, and support for modest HTML formatting.
[http://www.med.ufl.edu/medinfo/mtx/jrju/]
JRTPLIB: An object-oriented RTP library written in C++.
[http://lumumba.luc.ac.be/jori/jrtplib/jrtplib.html]
js: The NGS JavaScript interpreter is an independent implementation of the JavaScript language that was developed by Netscape. This implementation is designed to be re-entrant, extensible, fast and programmable.
[http://www.ngs.fi/js/]
JSCC: The Java Specialization Classes Compiler is a compiler for the Java language extended with specialization classes, i.e. a language extension for integrating forms of adaptive behavior in an existing program. An adaptive class is defined by attaching a number of alternative implementations to a regular Java class that complement the existing implementation, with each alternative defined by a specialization class to be used in some specific situation. The adaptive behavior consists of monitoring the internal state of each object and switching to the right implementation whenever it is needed. The JSCC produces a standard Java program which manages its own specialization by itself, with the compiler also written in Java. The source code for the compiler is available. It is documented in a man page. Several technical reports which explain specialization classes in greater detail are also available.
[http://www.irisa.fr/compose/jscc/]
JavaSci: A set of Java packages based on an ObSci object model whose aim is to encapsulate scientific methods in the most natural way possible such that they can aid in the development of scientific software. The package consists of a main class JSci and subclasses awt, io, chemistry, maths, and physics. The first two subclasses are for graphical data presentation and input/output, while the latter three contain further subclasses to facilitate development of programs in each discipline. Documentation is available in the form of comments within each class, and a source code distribution is also available.
[http://fourier.dur.ac.uk:8000/~dma3mjh/jsci/]
JSP: JavaServer Pages are a platform-independent technology for creating dynamic Web pages. JSP separates the user interface from the content generation. This enables the overall page layout to be changes without altering the underlying dynamic content. A reusable and component-based design makes it easy and quick to build Web-based applications.
[http://www.javasoft.com/products/jsp/]

GnuJSP

A free implementation of JSP. JSP translates files with a specific extension suffix and into Java source files, compiles them, and runs them. GnuJSP automatically detects changes to JSP files and recompiles them if necessary. A source code distribution is available.
[http://www.klomp.org/gnujsp/]

JSWDK

The JavaServer Web Development Kit combines the reference implementation for JSP 1.0 (9/99) and the Java Servlet API 2.1. It offers a simplified way for creating dynamic Web pages.
[http://www.javasoft.com/products/jsp/download.html]

PolyJsp

A extensible JSP implementation designed to support multiple scripting languages and multiple versions of JSP. PolyJsp is based wholly on XML and XSL and currently (9/99) supports Java, JavaScript and WebL. The features include:

simple extensibility in a mostly declarative way;

theoretical extensibility to any of the over 60 languages for which a Java interpreter exists;

addition of new language processors as specialized Java classes or as XML declarative language definitions scripted with JavaScript;

dynamic loading of version tag syntax by the parser at runtime on a per-script basis;

implementation of source code generators as XSL stylesheets that transform the DOM tree produced by the JSP parser into an equivalent program written in the target scripting language.

An Open Source distribution of PolyJsp is available.
[http://www.plenix.org/polyjsp/polyjsp.html]

Resin

A package for creating Web applications with server-side JavaScript and JSP 1.0, with pages able to use either JavaScript or Java to power active content. Resin allows JavaScript, XML and XSL to be used with JSP. Web applications can mix HTML and JavaScript or Java to create HTML pages using standard JSP 1.0 syntax. The features include:

compilation of server-side JavaScript directly to Java bytecodes;

use of Java standards for HTTP (servlets) and databases (JDBC);

automatic support for any Java classes;

a fast 2.1 servlet engine supporting both Apache and IIS servers;

an included HTTP/1.1 server;

support for XML and the standard XML DOM;

formatting of XML pages with the XML Stylesheet Language (XSL);

use of XML Template Pages (XTP) to create JSP pages from XML pages using XSL; and

provision of public Java APIs for Resin's XML, XPath, XSL and JavaScript.

Resin is freely available although redistribution and the creation of derivative works are prohibited.
[http://www.caucho.com/]

SJSP

An implementation of JSP 0.92 that uses compile time introspection and generates more readable and faster code. The features include:

compatibility with Java Servlet versions 2.0 and 2.1a;

compile-time and run-time introspection;

automatic application and session bean synchronizing;

support for interfaces as bean type;

automatic URL encoding; and

automatic page recompiling and reloading.

This is freely available for development purposes, with commercial versions eventually to be available containing source code and additional features.
[http://www.razdva.cz/jschejbal/projects/]
jsplot: An interactive drawing and charting tool. It is mostly a vector graphics program but can also process several image formats. A programming interface allows the creation of symbol libraries and simple graphical applications. Several primitives can be drawn including lines, polylines, markers, polygons, rectangles, circles, circular arcs, ellipses, elliptical arcs, and text. Standard simple graph macros are available for X-Y graphs, line charts, bar charts, pie charts, and 3-D diagrams. Documentation is contained within HTML files that use a standard web browser that is called when help is invoked. Files can be exported in EPS and CGM formats.
[http://ourworld.compuserve.com/homepages/jsieberer/]
jSSL: A project to develop a free SSL implementation in Java.
[http://www.vonnieda.org/SSLv3/]
JSTrack: A hurricane tracking program with a GUI interface built using Tcl/Tk. It plots past storm positions, the current storm position, and the official forecast positions from NHC data. The features of JStrack include:

direct processing of NHC Forecast/Advisory text for storm information extraction,

a text-only interface as an alternative to the GUI,

plotting the wind radii for both current and past positions,

displaying the Saffir-Simpson scale,

displaying a table showing the history of the storm,

displaying detailed information for any storm location identified via a mouse click, and

handling multiple storms.

A source code distribution of JStrack is available. It is written entirely in Tcl/Tk and requires Tcl 7.6 and Tk 4.2 or newer, Expect, and Extended Tcl (TclX).
[http://www.gnt.net/~n5ial/jstrack.html]
Jsync: A set of synchronization primitives for Java that simplify the development of concurrent applications. These classes included such synchronization primitives as Dijkstra semaphores, events and mutexes as well as higher level classes for controlling parallel tasks and intertask communication. The Jsync classes include:

Assert, for checking program invariants;

Barrier, for synchronizing the concurrent execution of several threads;

Concurrent, for initiating parallel execution of several threads and collecting their results;

Conveyor, for parallel input data reading and processing;

Event, a synchronization object;

JoinInputStream, for multiplexing input from several streams;

Lock, for supporting resource locking;

Mutex, for providing mutual exclusion of threads;

Pipe, for linking input and output streams;

Queue, a first-in first-out queue for sychronizing data exchange between threads; and

Semaphore, a semaphore with wait and signal operations.

A source code distribution is available.
[http://www.ispras.ru/~knizhnik/]
jTcl: The Java-like syntax in Tcl project proposes coding in Tcl using Java syntax and objects. It is a flying parser which transforms Java-like Tcl syntax into pure Tcl code. The transformation is performed in one pass and it should handle any Tcl higher than version 7.
The package contains several jTcl library classes: TcpChannel, a basic TCP client communication mechanism; TcpServer, a server TCP class; TcpRpc, a derivative of the TcpServer class which creates a remote procedure server; and TcpHttpd, a basic HTTPD server derived from TcpServer.
The source code for the jTcl package is available. The distribution includes the basic package plus several demos. There is some sketchy documention (4/97) available in HTML format. See also Jacl.
[http://www.fridu.com/]
JTS: The Jakarta Tool Suite is a collection of Java compiler tools. Jak is an extensible superset of Java that supports metaprogramming extensions allowing Java programs to be written that produce other Java programs. The features of Jak include:

abstract syntax tree (AST) constructors for the internal representation of programs and code fragments;

generation scoping (GS), an adaptation and generalization of the hygeinic, lexically-scoped macros used to solve the variable binding or inadvertent capture problem arising when independently-written code fragments are composed; and

a Java package of classes for searching and editing trees;

easy language extensibility via an approach called intention-based programming.

Another JTS tool is Bali, a GenVoca generator of DSL precompilers. It is both a tool for writing precompilers for domain-specific langauges and a GenVoca generator. A GenVoca generator is a scalable model of component-based software construction wherein the central idea is that software domains are characterized by a finite set of fundamental abstractions. A source code distribution is available.
[http://www.cs.utexas.edu/users/schwartz/]
[ftp://ftp.cs.utexas.edu/pub/JTS/]
J2EE: The Java 2 Enterprise Edition is a platform for developing, deploying and managing multi-tier server-centric applications built on top of the Java 2 Standard Edition. The technologies included in J2EE include:

Enterprise JavaBeans, the server-side component that enables the rapid and simplified development of distributed, transactional, secure and portable Java applications;

JavaServer Pages (JSP), a method for creating platform independent dynamic web content;

servlets, a consistent method for extending the functionality of a web server;

the Java Naming and Directory Interface (JNDI), which provides a unified interface to multiple naming and directory services;

the Java Transaction API (JTA) and Java Transaction Service (JTS), the former providing a protocol independent API that allows applications and application servers to access transactions, and the latter specifying the implementation of a Transaction Manager supporting JTA and implementing the Java mapping of the OMG Ojbect Transaction Service (OTS);

the Java Message Service (JMS), which works with other technologies to provide reliable, asynchronous communication between components in a distributed computing environment;

the J2EE Connector Architecture, which defines a standard architecture for connecting the J2EE platform to heterogeneous enterprise information systems (EIS);

CORBA, the open standard for heterogeneous computing; and

the JDBC, an API allowing the access of virtually any tabular data source from Java.

[http://java.sun.com/j2ee/]
Juggernaut: A high-performance application server with a component-based, plug-and-play and extensible framework. Juggernaut was developed as a set of components built on a server API, with a kernel responsible for loading a set of configurable APIs including those for services, file management, scripting management, resource management, component management, user management and logging. The standard API set provides the base-level functionality needed for most installations, with additional needs taken care of via custom API components. The features of Juggernaut include:

an HTTP 1.1 compliant extensible web server;

static document caching;

script object caching with output optimization features;

server-side compiled HTML scripting with macros;

shared and private application resource management;

persistent-state object management and storage;

a simple Java scripting API;

an abstracted file system/database management layer; and

architectural extensibility via interface APIs.

The Juggernaut HTTP server features include:

customizable method handlers for extending or modifying the behavior of web content retrieval;

software virtual multi-homing to allow a single server to host multiple sites;

directory aliasing and grouping for web access to content in different locations;

static document caching for high-performance retrieval;

HTTP persistent connections; and

basic user authentication.

A source code distribution of Juggernaut is available. It is written entirely in Java and will work on any system capable of running the JVM.
[http://www.dbxmlgroup.com/juggernaut.html]
Juggernaut Search: A search engine whose source code is available under the GPL.
[http://www.hproject.com/]
JuJu: A smart decoder for uu-, base64-, binhex-, or xxencoded data. The juju program automatically scans any input for valid encoded data, detects the encoding method, and decodes it. Encoded files that consists of several parts will be merged together, and files with missing parts will remain unmerged until the last part is found. The program performs smart decoding in that data can be a mixture of all encoding methods with multiple parts and in any possible order. It reads data from files or stdin and can also scan complete directories for valid data. It decodes on the fly (not keeping the scanned data in memory), and can quickly decode huge (more than 200 Mb) amounts of data. The package also includes an encoder program juen which encodes binary data with uu-, base64-, or xxencoding and supports automatic mailing or posting in one or more parts. A source code distribution is available. It is written in C and can be compiled on most platforms.
[http://hottemax.uni-muenster.de/~grover/juju.html]
Jultaf: The JUmble Library for Tcl And Friends is a collection of Tcl and [incr Tcl] scripts for for performing various tasks inluding building a shared library for accessing GDBM databases. The modules include:

an error module with error handlnig and evaluation functions;

a debug module which lets you embed debugging code in Tcl scripts;

a command line processing module with functions for option specifying, listing, and processing;

a string processing module with functions for string splitting, comparison, and character counting;

array and file handling modules; and

a module containing functions for accessing GDBM databases.

Installing and using the source code distribution of Jultaf requires the prior installation of both Tcl/Tk and [incr Tcl]. The documentation is a bit sketchy thus far.
[http://www.han.de/~racke/jultaf/jultaf.html]
JUMBO: An element-oriented system for processing XML that can read and parse. It creates a tree of elements and attributes with various types of content, and also supports processing instruction in a generic way. The browsing model is based on a tree/TOC model, event streams, and customized element display. JUMBO also supports authoring and editing facilities. The features of JUMBO include:

written in 100% pure Java and can run as an applet or an application;

mostly complaint with the XML specifications;

designed to be used with the SAX API and therefore any complaint parser;

treatment and display of the parse result on a table of contents;

rendering of components as subtrees/TOCs, event streams, and individual objects;

menus driven by internal XML documents which include HTML-based help on a per-item basis;

a GUI with several components allowing assessment of the document and its processing including error announcement;

implementation of XPointers for linking into subcomponents of XML documents, searching XML documents, and internal management of documents;

user-based searching through an interface that allows boolean combination of strict XPointer addressing;

importation of non-XML documents via setting MIME types and requiring per-MIME conversion code;

reading XSL documents; and

easy extensibility with several extensions included.

A source code distribution is freely available but may not be redistributed or used or commercial or teaching purposes without permission.
[http://www.xml-cml.org/jumbo/]
JUMP: A bytecode compiler which allows Java source code to be compiled into portable bytcode which conforms to the Java VM specification and can be executed by any Java VM. JUMP is a replacement for the Java compiler javac which ships with the JDK.
JUMP improves and extends javac in several ways including being about 10-30 times faster; having an output format which can be changed to adapt JUMP to other development environments; containing a fully functional dissassembler; and extend Java with several features such as class templates, operator overloading, default parameters, and global variables and functions.
The JUMP distribution includes the compiler binary, documentation, examples showing the use of the extensions, container support files, and several demonstration programs. It is currently (5/97) available for Windows 95/NT and Linux Intel platforms.
[http://ourworld.compuserve.com/homepages/DeHoeffner/jump.htm]
JUMP (math): The Java Ultimate Math Package is a library offering arbitrary precision mathematical computations which provides a base for real, rational and integer numbers. A source code distribution is available.
[http://members.xoom.com/znerd/java/jump/]
Jun: A Java framework for developing 3-D graphics applications that uses OpenGL as a rendering engine. The features include:

geometric elements (e.g. points, lines, NURBS curves, planes, etc.) and operations (e.g. rotation, translation, resizing, etc.);

topological elements (e.g. vertices, edges, loops, etc.) and operations (e.g. Eulerian, geometry, global and set operations);

display objects and model;

texture mapping;

3-D grapher, charts and plotter;

simple animation;

solid modeling by rotation of 2-D plots;

parametrically-determined solid modeling; and

a VRML 1.0/2.0 reader/writer.

This requires JDK 1.1.6 or greater, and it is documented in an online manual.
[http://www.sra.co.jp/people/nisinaka/Jun4Java/]
Junkbuster: See Internet Junkbuster Proxy.
junkfilter: A procmail-based filter system for electronic mail. It sets the SPAMMER variable within procmail and then takes action based on the presence and/or content of the variable. Junkfilter doesn't bounce or resend mail to the sender.
[http://junkfilter.zer0.org/]
JVerge: A library of Java classes that mimic the VRML node structure, automatically creating the parameters of individual nodes upon instantiation. The features include:

a complete implementation of all VRML 2.0 nodes as classes;

independence from the working VRML/Java API environment;

enforced correctness of VRML via Java class mechanisms;

output of entire scenegraphs to any streamable source;

automatic DEF/USE capabilities;

a deep clone to replicate chunks of scenegraphs with a single method call; and

a VRML file parser to turn VRML code into JVerge classes.

A source code distribution is available. See also the related VermelGen editor.
[http://www.vlc.com.au/JVerge/]
JVN: The John Von Neumann Universal Constructor is an extension of the logical concept of a universal computing machine. Von Neumann proposed a cellular environment in which both computing and constructive universality can be achieved. Both a Turing machine and a machine capable of producing any other cellular assembly, i.e. a universal constructor, when fed with a suitable program can be embedded in this environment. He showed that this constructor was capable of reproducing when provided with a program containing its own description. The self reproduction takes place via two different processes. In the first the program is interpreted to generate a copy of the constructor, and in the second a copy of the program is produced and attached to the copy of the constructor. The CVN package contains three different universal constructor implementations. The first is governed by the original transition rule and collects just one bit of information at a time from a single tape. It needs to store a quintuplet of those bits to direct a single constructive operation. The second uses an extended transition rule possessing single crossing capabilities and can read nine tapes at a time, i.e. much faster than the first. The third can attach a copy of the tape read to the cell assembly produced and activate the assembly with a starting pulse, i.e. all the operations for a universal constructor.
A source code version of JVN is available. It is written in C and requires the XForms library for compilation and usage.
[http://alife.santafe.edu/alife/topics/jvn/jvn.html]
JX: A full-featured application framework and GUI class library for use with X Windows. It is built on top of Xlib and has been optimized for performance. JX comes with a complete application that demonstrates all of the features of the library. It also comes with a graphical class browser called jcc that helps you visualize and understand inheritance relationships between classes.
JX features include:

a built-in drag-and-drop capability;

support for Encapsulated PostScript printing;

support for distributed programming via UNIX sockets;

support for simple animations;

a graphical layout editor that generates code;

a flexible messaging system that lets objects receive notification of changes in other objects;

support for basic application level objects;

support for standard widget types including buttons, checkboxes, radio buttons, scrolling menus, input fields, scrollbars, partitions, etc.;

dynamic window layout in which an application can show, hide, create, destroy and resize widgets;

automated geometry management of all widgets;

a 2-D table class suite including support for in-place editing of cell contents;

a text editor class which supports fully styled text;

easy creation of customized widgets;

connecting applications to a unlimited number of X servers;

support for interacting documents;

integrated support for the X selection mechanism, i.e. clipboard;

an image class which encapsulates offscreen drawing operations;

cooperative multi-tasking;

a built-in, extensible file browser;

animated cursors;

and more.
The source code is available in both stable and cutting-edge release forms. The documentation is contained within the distribution. The software is free for non-commercial use. Several applications are under development including:

Code Crusader, a C/C++ code development environment;

Code Medic, a GUI to gdb;

System G, a full-featured file manager;

Arrow, an email front-end;

Glove, a data acquisition, manipulation, and analysis tool; and

mathgui, a GUI to Mathematica.

[http://www.cco.caltech.edu/~jafl/jx/]

[ home / linux ]

Next: Ka-Km Up: Linux Software Encyclopedia Previous: Ja-Jm Contents

Manbreaker Crag 2001-03-08