pidwright.qtjambi.4.5.2_01.source-code.install.html Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of qtjambi Show documentation

Legacy QtJambi library for RapidWright, from: https://sourceforge.net/projects/qtjambi/files/4.5.2/

The newest version!






  Qt 4.5: Installing Qt Jambi
  





   Home · Overviews · Examples 
Installing Qt Jambi

Qt Jambi is available both in prebuilt and source packages for Linux, Mac OS X, and Windows. Java 1.5 or later is required to install Qt Jambi.
The procedure of installing is different depending on whether you have downloaded a source or prebuilt package. This installation guide has separate sections for each approach.
Enjoy !
Installing from a Prebuilt Package
Manually Launching Qt Jambi Applications
Alternate way of loading native libraries


Building Qt Jambi from a Source Package
Configuring the System for Qt Jambi
Building Qt for Qt Jambi
Setting up the environment
Building Qt Jambi
Trouble Shooting
Common Problems
Load Issues


Platform Notes
Running the Qt Designer
Running the Qt Jambi Generator


Installing from a Prebuilt Package
After extracting the package, you are ready to run the Launcher, which is an application that runs the examples and demos that come with Qt Jambi.
To run the examples and demo launcher on Windows run the
    qtjambi.exe
executable from the Qt Jambi directory. On Linux and Mac OS X run the
    qtjambi.sh
shell script from the Qt Jambi directory.
Running these files will verify the virtual machine version and set the correct environment for running Qt Jambi applications.
When you are ready to distribute your own applications, see the deployment document.

Manually Launching Qt Jambi Applications
To manually run Qt Jambi, the qtjambi classes archive and qtjambi platform archive must be available in the CLASSPATH. The qtjambi classes archive is named qtjambi-4.5.0_01.jar and the platform archive is named according to the operating system and compiler used to generated the native binaries, such as qtjambi-win32-msvc2005-4.5.0_01.jar
To run the examples or launcher, the classpath must also include the qtjambi-examples-4.5.0_01.jar.
    // Linux
    java -cp qtjambi-4.5.0_01.jar:qtjambi-linux32-gcc-4.5.0_01.jar:qtjambi-examples-4.5.0_01.jar com.trolltech.launcher.Launcher

    // Mac OS X
    java -XstartOnFirstThread -cp qtjambi-4.5.0_01.jar:qtjambi-mac-gcc-4.5.0_01.jar:qtjambi-examples-4.5.0_01.jar com.trolltech.launcher.Launcher

    // Windows
    java -cp qtjambi-4.5.0_01.jar:qtjambi-win32-msvc2005-4.5.0_01.jar:qtjambi-examples-4.5.0_01.jar com.trolltech.launcher.Launcher
Note: When running a Qt Jambi application on Mac, it is necessary to pass the -XstartOnFirstThread argument to the Java executable.

Alternate way of loading native libraries
Qt Jambi must be enabled to find the native libraries. The Qt Jambi libraries is a set of class files contained in the qtjambi-4.5.0_01.jar file and a set of native libraries. The native libraries are located in a .jar file named according to your operating system, hardware configuration and the compiler that was used to build the package, for instance qtjambi-win64-msvc2005x64-4.5.0_01.jar. The native libraries will be automatically loaded when this jar file is part of the classpath.
An alternative way of loading the native libraries is to rely on Java's standard method of loading native libraries. This is done by specifying either the JVM system property -Djava.library.path=[path_to_libraries] or setting the following environment variable:

Platform Comment
Windows Set the PATH environment variable to include the bin directory in the Qt Jambi directory.
Linux Set the LD_LIBRARY_PATH environment variable to include the lib directory in the Qt Jambi directory.
Mac OS X Set the DYLD_LIBRARY_PATH environment variable to include the lib directory in the Qt Jambi directory.

Loading directly from files is \b not recommended as the wrong libraries can be found, such as /usr/lib/libQtCore.4.so because /usr/lib is always part of LD_LIBRARY_PATH.
Some of Qt's functionality is loaded via native plugins. This includes for instance support for jpeg images. When using the platform archive, plugins are configured and loaded correctly automatically. When loading native libraries from the file system, Qt will try to load plugins from the directories in the QT_PLUGIN_PATH environment variable.
You are then ready to run Qt Jambi applications. An example of how to run the launcher manually is illustrated below:

Building Qt Jambi from a Source Package
This section describes how to build Qt Jambi from source. We first explain how to configure your system, and then we go through the procedure of building Qt Jambi from the command line. Finally, we look at some common installation problems.
Note that a source package requires a Qt installation. On Mac OS X, Qt must be configured without frameworks (by running the configure script with the --no-framework option).

Configuring the System for Qt Jambi
The Jambi source package requires a Qt source package, JDK 1.5 or higher and the build utility ant.

Building Qt for Qt Jambi
The first step is to build Qt for Qt Jambi. A normal Qt build will normally work, but there are a few exceptions. For more details on building Qt on any given system see the Qt installation guides.

Configuration Comment
Mac OS X Qt Jambi only supports Qt configured with -no-framework
Linux Sun's Java Virtual Machine has a bug preventing it from using MMX and SSE instructions. For deployment against 1.5 Java runtimes, configure Qt with the options -no-mmx -no-sse -no-sse2 -no-3dnow to avoid problems.


Setting up the environment
The following table describes the environment variables necessary to install Qt Jambi.

QTDIR This variable must contain the path to the directory where Qt is installed.
JAVADIR This variable must contain the path to the directory where Java is installed.
QMAKESPEC This variable is redundant in most cases, but may be required to pick between ambigous compilers, such as MinGW or MSVC on windows.


Building Qt Jambi
Qt Jambi provides a ant task which handles all the tasks of building the Qt Jambi libraries. To build Qt Jambi simply make sure the above requirements are met and type
    > ant
in the Qt Jambi directory. This will automatically go through the following steps:

Compile the Qt Jambi Generator
Generate the Qt Jambi libraries based on the Qt specified by $QTDIR
Compile the Juic tool
Compile and bundle the native libraries
Compile and bundle the class libraries
Run Juic over the examples.
Compile and bundle the examples

For a description of the various sub-targets of the ant build one can:
    > ant -projecthelp
For a description of the various build configurations, one can do:
    > ant help

Trouble Shooting
If you have trouble compiling and running Qt Jambi, we present problems that are commonly encountered in a table. This should be sufficient to solve most problems; failing that, try asking someone. The Jambi FAQ is a good place to start. In the Jambi Mailing List, active Jambi users and the Jambi development team can be helpful with installation problems; please run Qt Jambi with the com.trolltech.qt.verbose-loading system property and give stack traces if Qt Jambi fails to load native libraries.

Common Problems
In this section, we have tried to gather common problems encountered while building Qt Jambi. They are listed in a table with columns for the problem description and solution.

Problem Solution
On Linux the gcj (GNU Java Compiler) is located in /usr/bin; the path to the correct java version must be before this in the PATH. This usually results in java.lang.ClassFormatError errors. Make sure that it is the correct java executable in the PATH.
Environment variables are not set correctly. Check with the Configuring the System for Qt Jambi section that your system is properly configured for Jambi.
Qt Jambi uses the Qt Header files to generate the mapping from c++ to java. Unless Qt was built with default settings, you may get link problems for bindings that are not in the native libraries. Build Qt with default settings
juic does not update .jui files that are not modified, which can be a problem if Java sources are deleted. Run juic with the -a option.
Qt Jambi expects that Qt was built with debugging turned off. If Qt was built with debugging, the libraries will not be found. Run Qt Jambi with the com.trolltech.qt.debug system property.


Load Issues
If Jambi cannot find the native libraries, you will get java.lang.UnsatisfiedLinkError's or other load issues. The search paths - in the order Jambi searches - for libraries are listed below.

The com.trolltech.qt.library-path system property, which can be given java as command line argument.
The classpath (including jar files).
The subdirectory lib (Mac OS X and Linux) or bin (Windows) under the root of the Jambi package structure (i.e., the Qt Jambi directory).
The java.library.path system property, which is set to LD_LIBRARY_PATH on Linux, PATH on Windows, and DYLD_LIBRARY_PATH on Mac OS X.


Platform Notes

Platform Comment
Mac OS X When running a Qt Jambi application, it is necessary to pass the -XstartOnFirstThread argument to the Java executable. Also, if you have a source package, you have to build Qt with the --no-framework option.
Linux / 64 bit: Install a 32 bit virtual machine, e.g., on Ubuntu, install the ia32-sun-java5-bin package and put /usr/lib/jvm/ia32-java-1.5.0-sun-1.5.0.06/jre/bin into the PATH environment variable.


Running the Qt Designer
The Qt Designer is Qt Software's tool for designing and building user interfaces. If you have a prebuilt package, you can run it from the command line with the designer.bat or designer.sh scripts. The Eclipse integration handles the designer automatically.
You will find more information in the Qt Designer document.

Running the Qt Jambi Generator
The generator is a Qt application which can be used to map C++ based Qt APIs onto equivalent Java APIs. The Qt Jambi package provides an example on how to use the Qt Jambi Generator, located in the path/to/Qt Jambi/generator_example directory.
To build the generator example from the source package simply do:
        ant -f build_generator_example.xml
Warning: The Qt Jambi generator is written to handle Qt based source code, and is not intended for mapping C++ libraries in general.


Copyright © 2009 Qt Software
Trademarks
Qt Jambi 4.5.0_01

Platform	Comment
Windows	Set the `PATH` environment variable to include the bin directory in the Qt Jambi directory.
Linux	Set the `LD_LIBRARY_PATH` environment variable to include the lib directory in the Qt Jambi directory.
Mac OS X	Set the `DYLD_LIBRARY_PATH` environment variable to include the lib directory in the Qt Jambi directory.

Configuration	Comment
Mac OS X	Qt Jambi only supports Qt configured with `-no-framework`
Linux	Sun's Java Virtual Machine has a bug preventing it from using MMX and SSE instructions. For deployment against 1.5 Java runtimes, configure Qt with the options `-no-mmx -no-sse -no-sse2 -no-3dnow` to avoid problems.

QTDIR	This variable must contain the path to the directory where Qt is installed.
JAVADIR	This variable must contain the path to the directory where Java is installed.
QMAKESPEC	This variable is redundant in most cases, but may be required to pick between ambigous compilers, such as MinGW or MSVC on windows.

Problem	Solution
On Linux the `gcj` (GNU Java Compiler) is located in `/usr/bin`; the path to the correct java version must be before this in the PATH. This usually results in `java.lang.ClassFormatError` errors.	Make sure that it is the correct java executable in the PATH.
Environment variables are not set correctly.	Check with the Configuring the System for Qt Jambi section that your system is properly configured for Jambi.
Qt Jambi uses the Qt Header files to generate the mapping from c++ to java. Unless Qt was built with default settings, you may get link problems for bindings that are not in the native libraries.	Build Qt with default settings
`juic` does not update .jui files that are not modified, which can be a problem if Java sources are deleted.	Run juic with the `-a` option.
Qt Jambi expects that Qt was built with debugging turned off. If Qt was built with debugging, the libraries will not be found.	Run Qt Jambi with the `com.trolltech.qt.debug` system property.

Platform	Comment
Mac OS X	When running a Qt Jambi application, it is necessary to pass the `-XstartOnFirstThread` argument to the Java executable. Also, if you have a source package, you have to build Qt with the --no-framework option.
Linux / 64 bit:	Install a 32 bit virtual machine, e.g., on Ubuntu, install the `ia32-sun-java5-bin` package and put `/usr/lib/jvm/ia32-java-1.5.0-sun-1.5.0.06/jre/bin` into the `PATH` environment variable.