| 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_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_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/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/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. |
| 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. |