| Name | Date | Size | |
|---|---|---|---|
| .. | 2013-05-16 00:04:17 | 12 | |
| build.properties | 2013-05-16 00:04:17 | 2.4 KiB | |
| build.xml | 2013-05-16 00:04:17 | 4.8 KiB | |
| nbproject | 2013-05-16 00:04:17 | 3 | |
| README | 2013-05-16 00:04:17 | 9.5 KiB |
README
Working on AWT and Java2D code with NetBeans
This project includes most of Java2D and AWT-related files,
allows easy navigation and builds from within NetBeans.
Since both AWT and Java2D have lots of native code, this
project uses "make" targets for building.
Unfortunately currently this project doesn't support
working with native code. Meaning, there is no navigation, code
completion, refactoring, etc.
In the future we will provide native code support.
You can certainly install the C/C++ pack for NetBeans 6.0
once it becomes available, or use any other editor for
working with C/C++ files.
In order to use this project from within NetBeans you will have
to perform a full jdk build first.
Here are the steps:
1. setup your jdk build environment as described in
other documents (see build documentation)
2. perform a full jdk build (preferably a FASTDEBUG build,
as it simplifies the debugging - the classes and object files
will be built with the debug information).
You only need to build jdk's "all" target:
#> cd jdk/make
#> make all > build.log 2>&1
3. set "make" and "make.options" properties in your
~/.openjdk/build.properties file (see the main README
file for more information on property files)
to set up the environment in NetBeans.
To get a list of variables you most likely will need to override
to make the the build work in NetBeans, you can do something like this
(on Windows):
#>env | grep ALT
ALT_JDK_IMPORT_PATH=c:/devtools/java/jdk1.7.0
ALT_DXSDK_PATH=c:/devtools/DirectX/DXSDK_Dec06
ALT_BOOTDIR=c:/DevTools/java/jdk1.6.0
If your build is a FASTDEBUG build, don't forget
to set FASTDEBUG=true in the property file as well so that what you
have built from the terminal matches what will be built from NetBeans.
Set "make.options" in your build.properties
accordingly:
ALT_JDK_IMPORT_PATH=c:/devtools/java/jdk1.7.0 \
ALT_DXSDK_PATH=c:/devtools/DirectX/DXSDK_Dec06 \
ALT_BOOTDIR=c:/DevTools/java/jdk1.6.0 \
FASTDEBUG=true
make=c:/devtools/cygwin/bin/make
4. Windows only: make sure you either call vcvars32.bat
file which sets the compiler environment
(typically located in <YourVisualStudioInstallDir>/VC7/bin)
and start NetBeans from the same terminal,
or make Visual Studio register its environment
variables globally.
(When building on 64-bit Windows platform, use setenv.cmd
from Platform SDK instead of vcvars32, as described in the
build documentation)
5. Now you can launch NetBeans
Notes on building the project from NetBeans
If you work only with Java files, you can compile them
with "Compile Single File" target ("F9" by default), the ant build
will compile the class files into the correct directory automatically.
However, if you touched any of C/C++ files,
you will need to use "build main project" ("F11") which launches
"make" on a set of directories.
Same goes if you touched a Java file which has native
methods. You will need to run the build so that
"javah" can generate the JNI header files used by
the native code.
Demos
The default run target for this project is Font2DTest,
which is launched with the runtime you built.
You can also start other demos by selecting a demo
in the Project or Files view and choosing "Run" from
the menu.
In particular, there is a J2DBench demo project,
which is a Java2D benchmark. To run it,
select java2d.J2DBench/build.xml node in the
"Projects" explorer and execute "Run" target.
For more information on this benchmark, see
the project's README file in the "Files" view.
Notes on using CND (C/C++ pack) with this project and NetBeans.
As mentioned above currently a project for working with native code is not
provided. However, you can set it up by yourself if you have
access to CND pack for NetBeans 6.0.
First, install CND as described here (this is a page for CND 5.5,
there likely will be one for 6.0 as well):
and make sure everyting works it works.
Then, create a new C/C++ project of "from existing code" type (see page
mentioned above for examples). The project should be located in the same
directoryas this project is - on the same level. Call it something like
"awt2d-native-${platform}-${arch}". So, for example, you may have
Specify the top level Makefile (jdk/make/Makefile), even though
you will not be using, as the Java awt2d project is set up
for building the workspace (thus make sure it's the default project,
so when you hit "Build Project" it's awt2d one that's chosen).
The most important thing is to specify the directories which will
be included into this project, the defines, and the directories for
include files.
This will enable code completion and limited navigation.
Using the project wizard, select the source directories you're interested in.
For example,
....
(this will recursively include the subdirectories)
Then set the list of the includes required by CND to enable code assistance.
You can get a complete list of include directories by looking at your
build log file and checking what directories are included with "-I" when
the files you're interesed in are built (you can probably devise some
script to generate the list of include files relative to the native
cnd project directory, and the list of defines passed to the compiler)
For example, on Windows x86, you might have something like this
(a somewhat complete list of awt and 2d native directories on windows):
../../src/share/javavm/export;
../../src/share/native/common;
(you can format this into a single line with ';' delimiters and paste it
into the text field instead of entering them one by one)
Note that most paths are relative to the native project directory -
this helps if you decide to relocate the workspace later. The ones that
aren't relative are paths to external include directories, like those
of the Platform SDK, DirectX SDK.
On Unix platforms these may be directories like /usr/include.
The parser must know some defines to correctly parse the source files,
these can also be obtained from the log file. For example, on Windows
x86 with debugging enabled, the defines would be something like this:
D3D_OVERLOADS; UNICODE; _UNICODE; WIN32; IAL; _LITTLE_ENDIAN; WIN32; _X86_;
x86; WIN32_LEAN_AND_MEAN; INTERNAL_BUILD; JDK_MAJOR_VERSION='"1"';
JDK_MINOR_VERSION='"7"'; RELEASE=1.7.0-internal; DEBUG="true"
(again, format it into a single line with '; ' delimiter - note the
space after ';' - and paste into the corresponding text field)
Note that the list of include directories will be different on different
platforms and architectures - consult you build log file.
After the project is created a loaded, you may want to check the list
of include files which weren't found (right-click on the native
project root in Projects exprorer, and select "View failed #include Directives"
from the popup menu. Update the inlcude directories list accordingly.
You can later create a different configuration for non-debug build,
just make a copy of your current configuration - call it ${arch}-debug
(in the native project's Properties dialog) and remove "DEBUG=true" from
the list of defines.
Note that with both Java and native projects opened the default
heap size NetBeans starts with might not be sufficient for comfortable work,
so you may need to increase it. You can do it either from the command line
or by editing your ~/.netbeans/dev/etc/netbeans.conf file and adding
something like this:
-J-Xms312m -J-Xmx512m -J-XX:PermSize=128m -J-XX:MaxPermSize=200m
to netbeans_default_options property.