Free java applications sony ericsson software for linux

UJAC provides a collection of JAVA components which may be useful in some projects.
Each component is designed for easy use, easy integration into existing projects, extensibility and last but not least efficiency.
Enhancements:
Chart Module:
- Moved common types into the interface org.ujac.util.UjacTypes.
Form Module:
- Fixed handling of default values.
Print Module:
- At < insert-document > tag: Fixed offset handling.
- At tags < background-image > & < watermark >: Removed code that forces the existance of a page for the background image.
Utils Module:
- Added interface UjacTypes, which defines common types, used inside the UJAC project.
- Added class UjacTypeHelper, which provides methods to convert data type IDs to Strings and vice versa.
- Moved class XmlUtils into sub package org.ujac.util.xml
SimplePatternMatcher:
- Fixed handling of empty patterns (always matches).
Table:
- Moved common types into the interface org.ujac.util.UjacTypes.
TemplateInterpreter:
- Fixed handling of underscores that are not part of statements.
- Added class BaseObjectSerializer, which provides basic code to easily read/write Objects from/to XML.
Web Module:
- Added support for PageTiles to ActionContext.
- Added < tile > tag which includes PageTiles into JSPs.
- Added class WebFormSerializer, which reads/writes WebForm definitions from/to XML.
- Added support for dynamic form registration from XML definitions.
- Fixed bugs in form field value handling.
- Fixed bugs in form field rendering.

Java Tetris project is a simple Tetris game.
Java Tetris is a game written with Eclipse and the VE Plugin. It is a nice starting point if you want to learn Java and Eclipse.
The game can be started as Java applet or Java application.
Enhancements:
- The dependency on jdom was removed.
- The jar is now only 30kb.
- A bug was fixed in the score list.

Java Tools is a lightweight integrated development environment for creating, compiling, and executing Java applications and applets.
Java Tools includes point and click access to the Java files, commands, and documents. It also includes a built-in text editor and user interface for the Java debugger.
It is intended for the new Java user who needs help getting started. Its also for the more experienced Java user who wants easy access to the Java commands and a text editor.
Main features:
- GUI with built-in help and small footprint.
- Point and click access to all files (Java, manifest, HTML, image and sound) and directories (package).
- Point and click access to all commands for compiling (javac), archiving (jar), documenting (javadoc), executing (java), debugging (jdb) and disassembling (javap).
- Point and click access to all documents (Java API Specification, Java Tools and Utilities, Java Features and Java Tutorial).
- Point and click creation of all files (Java, manifest and HTML) and directories (package).
- Point and click installation of distribution archive files (Java document, Java source code, Java Tutorial and Sun Tools).
- Automatic determination of class file dependencies for archiving (jar) and documenting (javadoc) Java files.
- Checking for unused, redundant and missing imports.
- Logging of all commands invoked by GUI.
- Code metrics for Java files.
- Built-in text editor (see Edit for details).
- Built-in user interface for the Java debugger with command-line editing and history.
- Self-installing executable (Java archive file).
- Comprehensive installation and user documentation for Java and Java Tools.

JavaNativeCompiler (JNC) is a Java to native compiler. The project allows AOT (ahead of time) compilation of your Java applications. With JNC, you can create real standalone native binaries (.exe on Windows) which will no longer depend on a JRE.
This is especially useful when applications have to be deployed to end-users. All vexatious problems of deploying Java applications can be solved by compiling them to native. They will be:
- Easy to deploy
No JRE dependency. Most end-users dont know what they have installed.
No more problems on how to create an executable file out of a JAR or class file.
- Hard to decompile
Java can easily be decompiled. Native compilation will protect your source code.
- Run fast from the start
No more overhead for loading a JRE.
Enhancements:
- This release fixes a couple of problems with AWT/Swing and XML.
- It also once again contains a version for Linux.
- The compiler binary downloads are smaller.

Secure Diary is a Java application that uses the Bouncy Castle JCE to provide strong encryption for your diary.

It stores the entries using blowfish and triple DES. It allows you to enter/view/export diary enteries in multiple diaries.

Java::Import::Examples is an example of how to use Java::Import to call into Java classes.

Making RMI calls from Perl

One nice thing about Java is the extremely straight forward manner in which it allows you to make calls to remote objects residing on distant servers. Many people use this ability as a point of integration between their system and a posible third party or legacy system. Unfortunatly, for the most part the ability to make calls to these remote objects is something that only other Java applications can do without making a big fuss about it. However, we can now do this from Perl.

Assume that I have a RMI server from which I can get data from in the form of simple Java Beans. One method of doing this is to use the GCJ::Cni library and natively compile and wrap a set of Java Classes which can then be used from my Perl script. However, there is an easier way.

Lets begin by descriping the Java interfaces that well be working with. We first have the Remote Interface that we will be interacting with:

import java.rmi.*;
public interface RemoteInterface extends Remote {
public SomeBean getMessage(String seedMessage) throws RemoteException;
}
And we also have the bean we will be asking for:
import java.io.*;
public class SomeBean implements Serializable {
private String value;
public SomeBean() {}
public void setValue ( String _value ) { ... }
public String getValue ( ) { ... }
}
As far as any Perl client program is concerned this is all we need to know about.
Now all there is left to do is write a client:
use Java::Import qw(
java.rmi.Naming
);

my $remote_interface = java::rmi::Naming->lookup(jstring("//localhost/Home"));
my $bean = $remote_interface->getMessage(jstring("Hi there"));
print $bean->getValue(), "n";

Thats all there is. Notice that all we had to tell Java::Import about was java.rmi.Naming, this is because it was the only class we used by name in our Perl code, every other Java class (the objects held by $bean and $remote_interface) was returned by some other method call originating from java.rmi.Naming.

In order to run this example we have to make sure everything is in its place. We start by compiling the client code. Assuming that we have been given a Stub class file (RemoteObject_Stub.class) we can do the following:

gcj -C SomeBean.java RemoteInterface.java
fastjar -cvf client.jar SomeBean.class RemoteInterface.class RemoteObject_Stub.class

Making sure our server is reachable we can then run the client code:

CLASSPATH=client.jar perl client.pl

Thats it, you should then see the message returned by your server.

Westhawk SNMP is a lightweight SNMP stack in Java, with Java applet, application, and servlet examples.
The stack provides manager functionality for SNMPv1, SNMPv2c, and SNMPv3 (authentication and privacy).
Westhawks Java SNMP stack is capable of sending and receiving PDUs, but has limited agent functionality. The stack supports IPv6.
Enhancements:
- The stack is able to listen for incoming requests (and no longer for traps only).
- The stack is able to listen on multiple ports for requests and traps.
- Contexts (incoming and outgoing) can be bound to a local bind address.
- A separate package stubBrowser4_14.zip that contains a new and experimantal Stub Browser was released.
- Support for DateAndTime text convention was added to AsnOctets.
- A MultiSourcePdu that can do broadcast requests was added.
- Built-in support for IPv6 was added.
- Built-in support for "Reliable SNMP" was added.

Java Compiler Compiler (JavaCC) is the most a parser generator for use with Java applications.

A parser generator is a tool that reads a grammar specification and converts it to a Java program that can recognize matches to the grammar.

In addition to the parser generator itself, JavaCC provides other standard capabilities related to parser generation, such as tree building (via a tool called JJTree included with JavaCC), actions, debugging, and more.