--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/make/netbeans/awt2d/README Sat Dec 01 00:00:00 2007 +0000
@@ -0,0 +1,224 @@
+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:
+ make.options=\
+ 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):
+ http://www.netbeans.org/community/releases/55/cnd-install.html
+ 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
+ jdk/make/netbeans/awt2d
+ jdk/make/netbeans/awt2d-native-windows-i586
+
+ 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,
+ src/share/native/sun/java2d
+ src/windows/native/sun/java2d
+ ....
+ (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/javavm/include;
+ ../../src/share/native/common;
+ ../../src/share/native/sun/awt/debug;
+ ../../src/share/native/sun/awt/image/cvutils;
+ ../../src/share/native/sun/awt/image;
+ ../../src/share/native/sun/awt/medialib;
+ ../../src/share/native/sun/awt;
+ ../../src/share/native/sun/font/bidi;
+ ../../src/share/native/sun/font/layout;
+ ../../src/share/native/sun/font;
+ ../../src/share/native/sun/java2d/cmm/lcms;
+ ../../src/share/native/sun/java2d/cmm;
+ ../../src/share/native/sun/java2d/loops;
+ ../../src/share/native/sun/java2d/opengl;
+ ../../src/share/native/sun/java2d/pipe;
+ ../../src/share/native/sun/java2d;
+ ../../src/windows/javavm/export;
+ ../../src/windows/native/common;
+ ../../src/windows/native/sun/awt;
+ ../../src/windows/native/sun/java2d/d3d;
+ ../../src/windows/native/sun/java2d/opengl;
+ ../../src/windows/native/sun/java2d/windows;
+ ../../src/windows/native/sun/java2d;
+ ../../src/windows/native/sun/windows;
+ ../../build/windows-i586/tmp/sun/sun.awt/awt/CClassHeaders;
+ ../../build/windows-i586/tmp/sun/sun.awt/awt/obj;
+ ../../build/windows-i586/tmp/sun/sun.awt/awt/obj_gO;
+ ../../build/windows-i586/tmp/sun/sun.awt/jpeg/CClassHeaders;
+ ../../build/windows-i586/tmp/sun/sun.awt/splashscreen/CClassHeaders;
+ ../../build/windows-i586/tmp/sun/sun.font/fontmanager/CClassHeaders;
+ ../../build/windows-i586/tmp/sun/sun.font/t2k/CClassHeaders;
+ C:/DevTools/DirectX/DXSDK_Dec06/Include;
+ C:/devtools/VS2003/SDK/v1.1/include;
+ C:/devtools/VS2003/VC7/ATLMFC/INCLUDE;
+ C:/devtools/VS2003/VC7/INCLUDE;
+ C:/devtools/VS2003/VC7/PlatformSDK/include;
+ C:/devtools/VS2003/VC7/PlatformSDK/include/prerelease;
+
+ (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.