view make/netbeans/awt2d/README @ 17050:101f35eefb01

author anazarov
date Thu, 20 Apr 2017 22:46:22 -0700
parents 3a4370604bab
line wrap: on
line source
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/ 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

      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
            ALT_JDK_IMPORT_PATH=c:/devtools/java/jdk1.7.0 \
            ALT_BOOTDIR=c:/DevTools/java/jdk1.6.0 \

   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.


  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):


  (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:
    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.