Drop By! » netbeans

Netbeans Font Size Settings in Ubuntu

Fri, 26 Jun 2009 15:31:57 +0000

(ubuntu 9.04 gnome, netbeans 6.5, Java 1.6)

I assume you are familiar with: FaqNetbeansConf , Change the Font Size .

Setting the font size of your editors is easy : Tools – Options – Font and Colors .

If you want to change font size of the menues and panels of the GUI and you are using startup options

--laf javax.swing.plaf.metal.MetalLookAndFeel

you can set the GUI font size:

--fontsize 13

and it will work without any problems.

In case you are using the default GTK Theme you will find that the last option doesn’t change the font size of the menues. Here it helps to edit the ~/.gtkrc-2.0 configuration file:

# This file was written by KDE
# You can edit it in the KDE control center, under "GTK Styles and Fonts"

include "/usr/share/themes/Qt/gtk-2.0/gtkrc"

style "user-font"
{
  font_name="Verdana 11"
}
widget_class "*" style "user-font"

gtk-theme-name="Qt"
gtk-font-name="Verdana 11"

Change entries like “Verdana 11″ according to your needs.

PMD in Ant Problem – “Could not find class”

admin — Wed, 31 Dec 2008 19:01:22 +0000

(ant 1.7, pmd 4.2.4)

I’ve recently tried to use PMD – sourcecode inspection tool in an ant powered build. Here is a basic example from a test in the build.xml of a Netbeans project (the pmd jar is located in ant’s home lib directory):

     name="pmd" depends="init">
         
         name="pmd" classname="net.sourceforge.pmd.ant.PMDTask"/>
         dir="${build.test.results.dir}"/>
         targetjdk="1.6">
            
            >basic>
            
            
             type="xml" toFile="${build.test.results.dir}/pmd_report.xml" />
             dir="${src.dir}">
                 name="**/*.java" />
            >
        >
    >

More examples you will find at PMD Ant Task.

Running this task from command line ant -v pmd gives a warning

[pmd] Could not find class test.hallo.Main

or running same from Netbeans (using external ant).

Could not find class test.hallo.Main
java.lang.NoClassDefFoundError: org/jaxen/JaxenException
        at net.sourceforge.pmd.rules.XPathRule.getRuleChainVisits(XPathRule.java:87)

After looking around for a while I found this thread Ant could not find class.

Citation from there:

As far as what this will do to the PMD results… these errors come from the Type Resolution code. Only Rules which use the Type resolution capabilities even have a chance to give less than accurate results, and then only in circumstances requiring type information not apparent from the .java file directly. Finally, there only a few Rules in PMD that actively use Type Resolution right now, although I know several folks have written custom Rules using this capability.

Solution?

PMD 5 is not out yet. But I was successful by using the latest snapshot (at time of writing)
pmd-5.0-20081231.082852-77.jar. Also, I had to change the target definition a little:

  name="pmd" depends="init">
         name="pmd" classname="net.sourceforge.pmd.ant.PMDTask"/>
         dir="${build.test.results.dir}"/>
        >
            > 
                location="dist/test.jar" /> 
            >

            >rulesets/java/basic.xml>
             type="xml" toFile="${build.test.results.dir}/pmd_report.xml" />
             dir="${src.dir}">
                 name="**/*.java" />
            >
        >
    >

Now it’s working.

Adaptation of Netbeans Ant Build for Integration II – Auto Increment Build/Version Number

admin — Wed, 17 Dec 2008 00:05:07 +0000

(netbeans 6.1, external ant 1.7)

Here is a code snippet from build.xml which shows a possible way to customize your build in Netbeans by providing a version number and including it into the MANIFEST.MF of the created distribution jar. The current property version will be stored in a version.properties file. This version number will be retrieved and written back to the file. The script knows then the new version number (custom.version.property) and uses it in the jar creation task (see also Adaptation of Netbeans Ant Build for Integration – CopyLibs Issue).

Dealing with version number:

  
     
      name="custom.version.file" value="${basedir}/version.properties"/>
     name="-post-init">
        
         file="${custom.version.file}" property="custom.version.available"/>
    >
     name="pre-inc-version" depends="init"  unless="custom.version.available">
         message="No version file found. Creating ${custom.version.file} with Initial Version 0."/>
         file="${custom.version.file}" message="version=0"/>
    >
      name="inc-version" depends="pre-inc-version">
         
         file="${custom.version.file}">
             key="version" value="1" type="int" operation="+"/>
        >
        
         file="${custom.version.file}" prefix="custom"/>
         message="project ${ant.project.name} released with version ${custom.version}" />
    >
     name="-pre-jar" depends="inc-version">
        
        
    >
     name="clean-version" depends="-do-clean" description="Remove version property file">
         file="${custom.version.file}"/>
    >

(You could also use ant BuildNumber task.)

Using the version number in jar file creation:


      depends="init,compile,-pre-jar,-post-jar" description="Custom Build JAR with libs and version. See -do-jar-with-libs." name="jar">
         location="${build.classes.dir}" name="build.classes.dir.resolved"/>
         message="-------------run.classpath------- ${run.classpath}"/>
         message="--------- build.classes.dir.resolved ------ ${build.classes.dir.resolved}"/>
         property="run.classpath.without.build.classes.dir">
             path="${run.classpath}"/>
             from="${build.classes.dir.resolved}" to=""/>
        >
         message="-------- run.classpath.without.build.classes.dir ---- ${run.classpath.without.build.classes.dir}"/>
         pathsep=" " property="jar.classpath">
             path="${run.classpath.without.build.classes.dir}"/>
            >
                />
                 from="*" to="lib/*"/>
            >
        >
         message="--- build.classes.dir --- ${build.classes.dir}" />
         todir="${dist.dir}/lib" flatten="true">
            >
                 path="${run.classpath.without.build.classes.dir}"/>
            >
        >
         manifest="${manifest.file}">
            >
                 name="Main-Class" value="${main.class}"/>
                 name="Class-Path" value="${jar.classpath}"/>
                 name="Build-Version" value="${custom.version}" />
            >
        >
        >To run this application from the command line without Ant, try:>
         location="${dist.jar}" name="dist.jar.resolved"/>
        >java -jar "${dist.jar.resolved}">
    >

Visualizing Default Ant Task Dependencies for Netbeans build-impl.xml

admin — Tue, 16 Dec 2008 17:49:03 +0000

(netbeans 6.1, external ant 1.7)

There are some great tools out there to generate a visual overview of the dependencies between the tasks within an ant file. Here is an example for Netbeans build-impl.xml file using Grand:

build-impl ant task dependencies

Here is the snippet from the task in my build.xml (following descriptions in Visual Documentation of Ant Dependencies in 3 Simple Steps):

     name="visual-ant-task-dependencies">
         resource="net/ggtools/grand/antlib.xml" />
         output="build.dot" buildfile="${basedir}/nbproject/build-impl.xml">
              name="fromnode" node="jar"/>
             
        >
	 executable="dot">
            
             line="-Tpng -Gsize=23.39,16.54 -o build.png ${basedir}/build.dot" />
        >
    >

I uploaded the grand.jar to my ant home /lib directory. Of course you will need graphviz to be installed for the dot command. Have fun!

Adaptation of Netbeans Ant Build for Integration – CopyLibs Issue

admin — Mon, 15 Dec 2008 17:55:36 +0000

(Netbeans 6.1, external ant 1.7 )

If you create a standalone Java application project (i.e. one that comes with all used external jars and libs included, so there are copied to dist/lib) in Netbeans, commit the changes to version control, checkout or update the changes to your test and integration server and try to build the same project there, you might run into problems even if you used an external ant for building the same project in Netbeans on your local machine. (Look here for an explanation why jars are not includeable in the distribution jar itself.)

On the integration server the libs will not be copied to the dist/lib folder. The reason is that Netbeans is using an own ant task org.netbeans.modules.java.j2seproject.copylibstask which extends import org.apache.tools.ant.taskdefs.Jar and this jar will just not be found on the integration server except you completly reconstruct your local build environment on the integration server, what will be difficult if you are using a CI system (in my case it’s hudson). So let’s have a closer look at this issue and some possible solutions:

There are two principal ant build files Netbeans is using during the build process: build.xml – user can edit this file, build-impl.xml – user should not edit this one. Also have a look at this post Visualizing Default Ant Task Dependencies for Netbeans build-impl.xml.

Where and when the Libs are copied to dist/lib by the CopyLibs task?

For that we have to look into build-impl.xml. The libs are copied when the jar target ist executed:

  
depends="init,compile,-pre-jar,-do-jar-with-manifest,-do-jar-without-manifest,-do-jar-with-mainclass,-do-jar-with-libraries,-post-jar"
description="Build JAR." 
name="jar"/>

There are several jar related tasks, which are executed when certain conditions are valid, that means certain variables are set. The interesting task here is -do-jar-with-libraries:

  depends="init,compile,-pre-pre-jar,-pre-jar" 
if="manifest.available+main.class+mkdist.available" 
name="-do-jar-with-libraries">

This task will be executed if property manifest.available+main.class+mkdist.available is set. Especially if the path to CopyLibs is set.

         property="manifest.available+main.class+mkdist.available">
            >
                 value="${manifest.available+main.class}"/>
                 property="libs.CopyLibs.classpath"/>
            >
        >

Where does this path comes from. It is read in

     depends="-pre-init,-init-private,-init-libraries" name="-init-user">
         file="${user.properties.file}"/>

For example from: .netbeans/6.1/build.properties.

libs.CopyLibs.classpath=/home/user/bin/netbeans/java2/ant/extra/org-netbeans-modules-java-j2seproject-copylibstask.jar
libs.CopyLibs.javadoc=
libs.CopyLibs.maven-pom=
libs.CopyLibs.src=

That’s a problem! The build.properties file will not be found on the integration server, the properties libs.CopyLIbs.classpath and manifest.available+main.class+mkdist.available will not be set, the task -do-jar-with-libraries will not be executed.

What do you need CopyLibs task for?

Look at how the task is used (I included some echos for better understanding):

 depends="init,compile,-pre-pre-jar,-pre-jar" if="manifest.available+main.class+mkdist.available" name="-do-jar-with-libraries">
         location="${build.classes.dir}" name="build.classes.dir.resolved"/>
         message="-------------run.classpath------- ${run.classpath}"/> message="--------- build.classes.dir.resolved ------ ${build.classes.dir.resolved}"/>
         property="run.classpath.without.build.classes.dir">
             path="${run.classpath}"/>
             from="${build.classes.dir.resolved}" to=""/>
        >
         message="-------- run.classpath.without.build.classes.dir ---- ${run.classpath.without.build.classes.dir}"/>
         pathsep=" " property="jar.classpath">
 
             path="${run.classpath.without.build.classes.dir}"/>
            >
                />  depends="init,compile,-pre-pre-jar,-pre-jar" if="manifest.available+main.class+mkdist.available" name="-do-jar-with-libraries">
                 from="*" to="lib/*"/>
            >
        >
         classname="org.netbeans.modules.java.j2seproject.copylibstask.CopyLibs" classpath="${libs.CopyLibs.classpath}" name="copylibs"/>
         compress="${jar.compress}" jarfile="${dist.jar}" manifest="${manifest.file}" runtimeclasspath="${run.classpath.without.build.classes.dir}">
             dir="${build.classes.dir}"/>
            >
                 name="Main-Class" value="${main.class}"/>
                 name="Class-Path" value="${jar.classpath}"/>
            >
        >
        >To run this application from the command line without Ant, try:>
         location="${dist.jar}" name="dist.jar.resolved"/>
        >java -jar "${dist.jar.resolved}">
    >

and then study the java code. So not much problems here. Mainly copying some files and using standard jar functions, also providing some README file. Below I will show how you can workaround using this task.

Solutions?

First, you could copy the CopyLibs Task jar somewhere and set the property libs.CopyLibs.classpath in your build.xml to the appropriate location or use project.properties file which comes with the Netbeans build scripts. There are little chances that this task will change and you will have to update the CopyLibs Task jar.

Second, you could build your standalone application using One-JAR overriding the jar target from build-impl.xml.

Third, don’t change build structure but avoid using CopyLibs task. Here is an example how to change build.xml:

First make macrodefs and presetdefs from build-impl.xml callable by declaring appropriate namespaces in build.xml:

 name="Test" default="default" basedir="."
xmlns:j2seproject1="http://www.netbeans.org/ns/j2se-project/1"
xmlns:j2seproject3="http://www.netbeans.org/ns/j2se-project/3">
    >Builds, tests, and runs the project Test.>

Then redefine the jar target a little and override it in build.xml (echos only for feedback):


      depends="init,compile,-pre-jar,-post-jar" description="Build JAR." name="jar">
         location="${build.classes.dir}" name="build.classes.dir.resolved"/>
         message="-------------run.classpath------- ${run.classpath}"/>
         message="--------- build.classes.dir.resolved ------ ${build.classes.dir.resolved}"/>
         property="run.classpath.without.build.classes.dir">
             path="${run.classpath}"/>
             from="${build.classes.dir.resolved}" to=""/>
        >
         message="-------- run.classpath.without.build.classes.dir ---- ${run.classpath.without.build.classes.dir}"/>
         pathsep=" " property="jar.classpath">
             path="${run.classpath.without.build.classes.dir}"/>
            >
                />
                 from="*" to="lib/*"/>
            >
        >
         message="--- build.classes.dir --- ${build.classes.dir}" />
         todir="${dist.dir}/lib" flatten="true">
            >
                 path="${run.classpath.without.build.classes.dir}"/>
            >
        >
         manifest="${manifest.file}">
            >
                 name="Main-Class" value="${main.class}"/>
                 name="Class-Path" value="${jar.classpath}"/>
                
                
            >
        >
        >To run this application from the command line without Ant, try:>
         location="${dist.jar}" name="dist.jar.resolved"/>
        >java -jar "${dist.jar.resolved}">
    >

… and you’ve got rid of the annoying CopyLibs task thing.

JAXB and XML Schema in Netbeans 6.0 – Customizing

admin — Thu, 31 Jan 2008 17:28:58 +0000

Problem:Create an XML Schema which will be binded by JAXB to a class structure following certain constrains. You have certain degrees of freedom for your schema design and later you might also use schema annotations provided by JAXB. Modularize your XML schemas, simplest example is: A.xsd uses <include> to include declarations from schema B.xsd.

I want to try Netbeans’ excellent schema design features. Eventually I want to publish the schemas in a WAR deployed in a web container. That’s why I decided to put the files directly into the /web directory of the web-project.

Proposed Solution:
Trying to use Netbeans’ JAXB Wizard (or see http://wiki.netbeans.org/JAXBWizard) to create a JAXB Binding for A.xsd you will meet certain limitations: schema file changes won’t be visible to the “Regenerate” operation. You could edit the copy of A.xsd created by the JAXB Wizard in src/conf/xml-resources/jaxb/name_of_the_binding to make changes visible to the task but that will not see changes in B.xsd. The reason is that the ant tasks created by the JAXB Wizard do not provide this kind of granularity.

So the solution for me was to create the binding using JAXB Wizard, then overriding the created tasks. I copied <target name="jaxb-code-generation" ... from nbproject/xml_binding_build.xml to build.xml and customized the parameters of the XJC task:

   file="nbproject/build-impl.xml"/>
 
     name="ask-something">
     message="Do you like to customize the best IDE of all times?"
    validargs="Yes, Yes"
    addproperty="answer"/>
 message="Answer Yes! ${answer}" />
    >
 
      name="jaxb-code-generation" depends="xjc-typedef-target">
         dir="build/generated/addons/jaxb" xmlns:s="http://xml.netbeans.org/schema/JAXBWizConfig"/>
         dir="build/generated/jaxbCache" xmlns:s="http://xml.netbeans.org/schema/JAXBWizConfig"/>
         dir="${build.classes.dir}" xmlns:s="http://xml.netbeans.org/schema/JAXBWizConfig"/>
         dir="build/generated/jaxbCache/HandleSystemBinding"/>
 

         package="de.gbv.examples.handesystembinding" destdir="build/generated/jaxbCache/HandleSystemBinding">
            >
                 location="${src.dir}"/>
                 path="${jaxbwiz.xjcrun.classpath}"/>
            >
             value="-xmlschema"/>
             value="-verbose"/>
 
            
             file="web/A.xsd"/>
 
             file="web/B.xsd"/>
            
 
             dir="build/generated/jaxbCache/HandleSystemBinding"/>
        >
 
         todir="build/generated/addons/jaxb">
             dir="build/generated/jaxbCache/HandleSystemBinding"/>
        >
         destdir="${build.classes.dir}" srcdir="build/generated/addons/jaxb" source="${javac.source}" target="${javac.target}" xmlns:s="http://xml.netbeans.org/schema/JAXBWizConfig">
             location="${src.dir}"/>
             path="${jaxbwiz.gensrc.classpath}"/>
        >
    >

Note: Later discussions on netbeans issue tracking showed that there is a simpler way by first running “refresh” on the bindings schema and then doing “clean and build”. For that you don’t need to modify the ant target, nevertheless the discussed modification gives you this with just the “Regenerate” action click.

Netbeans Help Browser Font Size Issue

admin — Wed, 30 Jan 2008 18:15:38 +0000

Netbeans’ help browser doesn’t react on font size settings (User Startup Settings ). This is an old issue which you can study here . Actually all to do is to override the default CSS settings in:
netbeans-6.0/ide8/docs/org/netbeans/modules/usersguide/ide.css
Download a workaround version ide.css.

I had to edit this file to fit my needs (on KDE, ubuntu):

body {
font-size: 15pt;
font-family:  Arial, Helvetica, SansSerif, sans-serif;
...

To see the changes you do not need to restart the IDE or something like that. Just go to another help page.

Netbeans 6.5

Here you the appropriate .css file is ide10/docs/org/netbeans/modules/usersguide/ide.css .

An example for a possible adaptation:

body  {font-size: 15pt;
	font-family: SansSerif, Arial, Helvetica, sans-serif;
	margin-left: 5;
	margin-right: 5;
	color: Black;
	background-color: White}
 
p  {font-size: 15pt;
     margin-top: 5;
     margin-bottom: 5}
 
....

NetBeans User Configuration Settings Location on Linux

admin — Sun, 23 Dec 2007 02:28:19 +0000

To see your currently used user directory go to Help – About – Details.

To override the default settings in the file netbeans-install-dir/etc/netbeans.conf you can create a directory etc/ in /home/myhome/.netbeans/6.0 ( with 6.0 being the version number of your NetBeans installation). Then use the default netbeans.conf file from netbeans-install-dir/etc/netbeans.conf as a template to create a user specific settings in /home/myhome/.netbeans/6.0/etc/netbeans.conf (see How do I make my custom startup parameters permanent? ).

For instance you could change you user name (used in templates):

# Options used by NetBeans launcher by default, can be overridden by explicit
# command line switches:
netbeans_default_options="-J-client -J-Xss2m -J-Xms256m -J-XX:PermSize=64m -J-XX:MaxPermSize=200m -J-Xverify:none -J-Duser.name='My Name' -J-Dapple.laf.useScreenMenuBar=true -J-Dswing.aatext=true --fontsize 14"

(… or use Tools -> Template Manager -> User configuration properties .)

Read more about startup parameter for Netbeans IDE in FaqStartupParameters .