* As always, Alex Ruiz (@alexRuiz) has been busy, this week announcing the 1.1 release of FEST-Swing which is a Java library that provides a fluent interface for functional Swing GUI testing.
* Ken Orr has announced that he will be at JavaOne, presenting on the topic of component-oriented design. This will be an interesting talk, given the inheritance-oriented design that went into Swing, and the issues that has created, particularly in terms of method-overload.
* elliotth gave the Swing 2.0 counter-argument this week, suggesting that the point of Swing 2.0 is misguided and irrelevant. For the purposes of proper and full discourse, I appreciate his post, although I wish he had comments enabled so that a discussion could occur.

JavaFX

* Michael Heinrichs has posted the third in his series of blog posts about best practices for JavaFX mobile. I never knew of this blog until now. The first post suggests to avoid unnecessary bindings, the second post suggests to keep the scenegraph as small as possible, and the third post has two tips: use simple shapes over images, and use small shapes over complex shapes.
* More demos have been developed to show off the ease of developing in JavaFX. JFXStudio has a simple ’sink a ship’ game, Sergey Malenkov has posted a demo that creates a fireworks display (which Kirill Grouchnikov (@kirillcool) recreated in his Trident animation framework), and Santiago Pericas-Geertsen has created a Space Invaders-esque game for JavaFX.

1. JDK 1.5 above (download)
2. Tomcat 5.x above or any other container (Glassfish, JBoss, Websphere, Weblogic etc) (download)
3. Eclipse 3.2.x above (download)
4. Sun Reference Implementation of JSF: (download). Following are the list of JAR files required for this application.
* jsf-impl.jar
* jsf-api.jar
* jstl.jar
* common-logging.jar
* common-beanutils.jar
* common-collections.jar
* common-chain.jar
* common-digester.jar

We will implement a JSF application with an Add User screen with two fields, ID and User Name. Once user enter these values and press submit, she will be redirected to a welcome page displaying the user name.

Let us start with our first JSF based web application.
Step 1: Create Dynamic Web project

Open Eclipse and goto File -> New -> Project and select Dynamic Web Project in the New Project wizard screen.
dynamic web project eclipse

Select Dynamic Web application and click Next.
create dynamic web project jsf

Write the name of the project HelloWorldJSF. Once this is done, select the target runtime environment (e.g. Apache Tomcat v6.0). This is to run the project inside Eclipse environment. In configuration select JavaServer Faces v1.2 Project and press Next.

jsf-new-project

On Project Facets window, select Java 5 and JSF 1.2 and press Next.

Skip Web module window and press Next.

jsf-capabilities-face-servlet

Select JSF component library. Click New in Component Libraries and add jstl.jar, jsf-api.jar and jsf-impl.jar. In URL Mapping Patterns add /faces/* and then click Finish.

Once the project is created, you can see its structure in Project Explorer.
jsf-project-explorer-view
Step 2: Create Package and Managed bean

Create a package net.viralpatel.jsf.helloworld in the source folder and create a Java file UserBean.java. Copy following content into UserBean.java.
view plaincopy to clipboardprint?

1. package net.viralpatel.jsf.helloworld;
2.
3. public class UserBean {
4. private int id;
5. private String name;
6.
7. //Action method to add user
8. public String addUser() {
9.
10. return “success”;
11. }
12. public int getId() {
13. return id;
14. }
15. public void setId(int id) {
16. this.id = id;
17. }
18. public String getName() {
19. return name;
20. }
21. public void setName(String name) {
22. this.name = name;
23. }
24. }

package net.viralpatel.jsf.helloworld;

public class UserBean {
private int id;
private String name;

//Action method to add user
public String addUser() {

return “success”;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

Above Java class is a User bean that we will use to store our user’s information. This class acts like a form bean and action class. The addUser() method will get called when we click Add button on our Add User page.
Step 3: Create JSP files

Create two JSP files: AddUser.jsp and ListUser.jsp in WebContent folder. Copy following content in each of these files.
AddUser.jsp

view plaincopy to clipboardprint?

1.
2.
3.
4.
5.
6. Add New User Form
7.
8.
9.
10.

11.
12.

13.
14.
15.
16.
17.
18.
19.
20.
21.
23.
24.
25.
26.
27.

Add New User Form

We have added a validation rule for ID using f:validateLongRange tag and required=”true” attribute. The ID must be in between 1 and 500.
ListUser.jsp
view plaincopy to clipboardprint?

1.
2.
3.
4.
5.
6. List of Users
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.

List of Users

Step 4: Modify faces-config.xml file

Open faces-config.xml from WebContent -> WEB-INF folder and copy following content into it.
view plaincopy to clipboardprint?

1.
2.
3.
7.
8. userBean
9.
10. net.viralpatel.jsf.helloworld.UserBean
11.
12. session
13.
14.
15. AddUser
16. /AddUser.jsp
17.
18. success
19. /ListUser.jsp
20.
21.
22.

userBean

net.viralpatel.jsf.helloworld.UserBean

session

AddUser
/AddUser.jsp

success
/ListUser.jsp

In faces config we have defined a managed bean UserBean with scope session and mapping from AddUser.jsp to ListUser.jsp.
Step 5: Execute and run the project

Final step is to execute the project and view it in browser.
For this, right click on Project Name in Project Explorer -> Run As -> Run on Server (Shortcut Alt+Shift+X, R).

add-new-user-jsf-project-eclipse

Once you enter ID and Username and press Add User, following success screen will appear.

add-user-success-jsf-project-eclipse
Download complete WAR file with source

http://viralpatel.net/blogs/download/jsf/HelloWorldJSF.war

JSF provides different tags to handle and display messages on the view. There are two message tags in SUN’s reference implementation of JSF HTML library:
view plaincopy to clipboardprint?

1.
2.

h:messages is used to display all messages at once. You can place h:messages tag in start of your form. You may need to display only global messages using h:messages tag. For displaying only global messages set globleOnly attribute of h:messages to true.
view plaincopy to clipboardprint?

1.

Use h:message to display message attached to one component. An attibute for=”” can be used to specify the id of a component whose error messages we need to display. h:message is used to display error message next to the component that generated the error. If more then one message is attached to that component, h:message will display the last message.
view plaincopy to clipboardprint?

1. …
2.
3.
4. …

…

…

Each message can have a summary description and a detailed description. When using the h:message tag, the default is to show the detail message. When using the h:messages tag, the default is to display the summary descriptions. To change the defaults, modify the boolean showSummary and showDetail attributes.
view plaincopy to clipboardprint?

1.
2.

You can also enable component’s detail message to appear as a tooltip. To do so, set tooltip attribute of message tag to true. Note that for enabling this option, showDetail and showSummary must be set to true.

There are four forms of JSF validation:
1. Built-in validation components
2. Application level validations
3. Custom validation components using Validator interface
4. Validation methods in backing beans
Built-in validation components

The SUN’s reference implementation of JSF provides some default validation components that can be leveraged to implement validation of any user inputs. The JSF’s core library provides tags to validate input. Following are few tags that can be used to validate the input.

f:validateDoubleRange : This tag checks the value of component within specified range. The value must be convertible to floating-point type or a floating-point itself.

f:validateLength : This tag checks the length of a value and restrict it within a specified range. The value must be of type java.lang.String.

f:validateLongRange : Checks is component value is within a specified range. The value must be of numeric type or string convertible to a long.
Example:
view plaincopy to clipboardprint?

1.
2.
3.
4. ….
5.
6.
7.

….

Validation using Backing Bean methods

A backing bean method can be used for doing validation of any input field. First we need to create the backing bean method that will get called during validation process. The signature of the method can be:
view plaincopy to clipboardprint?

1. public void (FacesContext context, UIComponent component, Object value) { .. }

public void (FacesContext context, UIComponent component, Object value) { .. }

Once a backing bean method is ready we can bind it with a component using f:validator tag.
view plaincopy to clipboardprint?

1.
2.

In above snippet, we have bind checkUsername() method of userBean to component inputText. It is possible to bind more than one validators to one component.

Backing bean method of validation is easy to implement, but this method is specific for one application and may not be reused for different application. To create generic validators which can be used in different application, Validator interface can be used.
Custom validation components using Validator interface

Validator interface can be extended and a custom validator can be created which can be reused across different applications in JSF. To create a custom validator, we need to create a Java class that implements javax.faces.validator.Validator interface. Validator interface provides a method validate () that needs to be implemented. Following is the signature of validate() method.
view plaincopy to clipboardprint?

1. import javax.faces.component.UIComponent;
2. import javax.faces.context.FacesContext;
3. import javax.faces.validator.Validator;
4. import javax.faces.validator.ValidatorException;
5. …
6. …
7. public void validate(FacesContext context, UIComponent component, Object value)
8. throws ValidatorException {
9. }

import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.validator.Validator;
import javax.faces.validator.ValidatorException;
…
…
public void validate(FacesContext context, UIComponent component, Object value)
throws ValidatorException {
}

Once the Validator is implemented, we need to register this validator in faces-config.xml file. To do so copy following code in faces-config.xml assuming that our validator class name is net.viralpatel.jsf.helloworld.EmailValidator.
view plaincopy to clipboardprint?

1.
2. emailValidator
3. net.viralpatel.jsf.helloworld.EmailValidator
4.

emailValidator
net.viralpatel.jsf.helloworld.EmailValidator

We can bind this validator with any component using f:validator tag.
view plaincopy to clipboardprint?

1.
2.
3.

Note that in above code snippet, validatorId attribute of f:validator tag points to the validator’s ID that is registered in faces-config.xml file.
For validating email address we can create a Validator class as:
view plaincopy to clipboardprint?

1. package net.viralpatel.jsf.helloworld;
2.
3. import javax.faces.application.FacesMessage;
4. import javax.faces.component.UIComponent;
5. import javax.faces.context.FacesContext;
6. import javax.faces.validator.Validator;
7. import javax.faces.validator.ValidatorException;
8.
9. public class EmailValidator implements Validator{
10. public void validate(FacesContext context, UIComponent component, Object value)
11. throws ValidatorException {
12.
13. String email = (String) value;
14.
15. if(!email.contains(“@”)) {
16. FacesMessage message = new FacesMessage();
17. message.setSeverity(FacesMessage.SEVERITY_ERROR);
18. message.setSummary(“Email is not valid.”);
19. message.setDetail(“Email is not valid.”);
20. context.addMessage(“userForm:Email”, message);
21. throw new ValidatorException(message);
22. }
23. }
24. }

package net.viralpatel.jsf.helloworld;

import javax.faces.application.FacesMessage;
import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.validator.Validator;
import javax.faces.validator.ValidatorException;

public class EmailValidator implements Validator{
public void validate(FacesContext context, UIComponent component, Object value)
throws ValidatorException {

String email = (String) value;

if(!email.contains(“@”)) {
FacesMessage message = new FacesMessage();
message.setSeverity(FacesMessage.SEVERITY_ERROR);
message.setSummary(“Email is not valid.”);
message.setDetail(“Email is not valid.”);
context.addMessage(“userForm:Email”, message);
throw new ValidatorException(message);
}
}
}

Thus by using JSF Validation framework, it is possible to validate user input easily. We saw different ways of validation in JSF: Default validators, backing bean methods and validation through validator interface.

Clique aqui

Abraços
João Sávio

Não deixem de ver aqui. Capítulos 10 a 12.

Abraços
João Sávio

Clique aqui

Abraços
João Sávio

Abraços
João Sávio

Abraços pessoal

1. What does this following code mean?

<managed-bean>
        <managed-bean-name>applicantEditor</managed-bean-name>
        <managed-bean-class>training.jobapplication.bean.backing.ApplicantEditor</managed-bean-class>
        <managed-bean-scope>request</managed-bean-scope>

    </managed-bean>

It means to create an instance of ApplicantEditor.java and make it available in request scope.

ApplicantEditor applicantEditor = new ApplicantEditor();

Here the ApplicantEditor.java looks like.

public class ApplicantEditor {

	private boolean formRendered = false;

	public boolean isFormRendered() {
		return formRendered;
	}

	public void setFormRendered(boolean formRendered) {
		this.formRendered = formRendered;
	}
}

2. Let me explain these following code snippets

<managed-bean>
		<managed-bean-name>applicantList</managed-bean-name>
		<managed-bean-class>training.jobapplication.bean.backing.ApplicantList</managed-bean-class>
		<managed-bean-scope>request</managed-bean-scope>
		<managed-property>
<property-name>applicantEditor</property-name>
			<value>#{applicantEditor}</value>
		</managed-property>
		<managed-property>
<property-name>applicantListModel</property-name>
			<value>#{applicantListModel}</value>
		</managed-property>
	</managed-bean>

First of all, an instance has been created for ApplicantList in a request scope. Now, by looking at the line 6, I can tell that ApplicantList.java has a property/instance variable name applicantEditor <property-name> (it is a type of ApplicantEditor.java). Line 7, it’s calling setApplicantEditor() to set the value <#value>. Also same things are happening in line 10 and 11 for applicantListModel.  Declare the property name using this tag <property-name>, and set the value by using this value tag <value> .  ApplicantList contains a ‘has-a’ relationship of ApplicantEditor type.  Easy, piece of cake and here is the proof:

package training.jobapplication.bean.backing;

import training.jobapplication.bean.model.ApplicantListModel;

import training.jobapplication.transfer.Applicant;

import javax.faces.component.UICommand;
import javax.faces.event.ActionEvent;

public class ApplicantList {

	private ApplicantForm applicantForm;
	private ApplicantEditor applicantEditor;
	private ApplicantListModel applicantListModel;

	public ApplicantForm getApplicantForm() {
		return applicantForm;
	}

	public void setApplicantForm(ApplicantForm applicantForm) {
		this.applicantForm = applicantForm;
	}

	public ApplicantListModel getApplicantListModel() {
		return applicantListModel;
	}

	public void setApplicantListModel(ApplicantListModel applicantListModel) {
		this.applicantListModel = applicantListModel;
	}

	public void checkAll(ActionEvent actionEvent) {
		getApplicantListModel().checkAll();
	}

	public void create(ActionEvent actionEvent) {
		getApplicantListModel().setSelectedAsNew();
		getApplicantEditor().setFormRendered(true);
	}

	public void deleteChecked(ActionEvent actionEvent) {
		getApplicantListModel().deleteChecked();
	}

	public void edit(ActionEvent actionEvent) {
		UICommand uiCommand = (UICommand)actionEvent.getComponent();
		Applicant applicant = (Applicant)uiCommand.getValue();
		getApplicantListModel().setSelected(applicant);
		getApplicantEditor().setFormRendered(true);
	}

	public void uncheckAll(ActionEvent actionEvent) {
		getApplicantListModel().uncheckAll();
	}

	public ApplicantEditor getApplicantEditor() {
		return applicantEditor;
	}

	public void setApplicantEditor(ApplicantEditor applicantEditor) {
		this.applicantEditor = applicantEditor;
	}
}

3. These snippets are the most confusing to me:

<managed-bean>
		<managed-bean-name>applicantListModel</managed-bean-name>
		<managed-bean-class>training.jobapplication.bean.model.ApplicantLazyListModel</managed-bean-class>
		<managed-bean-scope>session</managed-bean-scope>
		<managed-property>
<property-name>applicantService</property-name>
			<value>#{applicantService}</value>
		</managed-property>
		<managed-property>
<property-name>rowsPerPage</property-name>
			<value>#{userPreferences.rowsPerPage}</value>
		</managed-property>
	</managed-bean>

I try my best to explain.  First of all, here’re some basic java polymorphism code.

Car car = new BMW();
car.go(); --> it calls BMW go() method
super.go() --> it calls Car go() method.

We have to use our polymorphic power to understand this part. This is what’s happening in line 2 and 3 in above xml.

ApplicantListModel applicantListModel = new ApplicantLazyListModel();
or,
ListModel applicantListModel = new ApplicantLazyListModel();
or,
ApplicantLazyListModel applicantListModel = new ApplicantLazyListModel();

We dont know what ApplicantLazyListModel will rertun in run time.  You may have noticed that applicantListModel is not the exact same object type as ApplicantLazyListModel.java  but ApplicantLazyListModel.java extends ApplicantListModel.java.  So there is an ‘is-a’ relationship going on. But Line 6, there is no guarantee that applicantService will be an instance variable (property) of ApplicantLazyListModel.java.  Since ApplicantLazyListModel extends ApplicantListModel, we assume applicantService is a member of ApplicantListModel.java not ApplicantLazyListModel.
Okay, got that, if you dont just pretend you do, it will get clear after you see these following code. Now, here is the another fun part.

<managed-property>
<property-name>rowsPerPage</property-name>
			<value>#{userPreferences.rowsPerPage}</value>
		</managed-property>

I cant not find the property, rowsPerPage nor in ApplicantLazyListModel or ApplicantListModel, where it can be?  ApplicantListModel also extends ListModel. So, rowPerPage is a member of ListModel.java. rowPerPage is also a proerty of UserPreferences.java.  In the above xml,  I’d read like this.  rowPerPage is a property of applicantListModel which value has been set by calling get method, userPreferences.rowPerPage. Objects hierarchies are as follows.

public class ApplicantLazyListModel extends ApplicantListModel {
.....
}
public class ApplicantListModel extends ListModel {

private ApplicantService applicantService;
...
}
public abstract class ListModel {
private int rowsPerPage = -1;
...
}

package training.jobapplication.bean.util;

public class UserPreferences {

	private int rowsPerPage = 5;
	private int maxPageNumberNavControls = 3;
	private boolean pageNumberNavControlsShown = true;

	public int getRowsPerPage() {
		return rowsPerPage;
	}
	public void setRowsPerPage(int rowsPerPage) {
		this.rowsPerPage = rowsPerPage;
	}
	public int getMaxPageNumberNavControls() {
		return maxPageNumberNavControls;
	}
	public void setMaxPageNumberNavControls(int maxPageNumberNavControls) {
		this.maxPageNumberNavControls = maxPageNumberNavControls;
	}
	public boolean isPageNumberNavControlsShown() {
		return pageNumberNavControlsShown;
	}
	public void setPageNumberNavControlsShown(boolean pageNumberNavControlsShown) {
		this.pageNumberNavControlsShown = pageNumberNavControlsShown;
	}

}

Man, now my brain hurts to think all these object relations.  Feel free to write comments and more details in concept wise, visit my cohort David Wilson-Burns blog. He explains why we need Injection instantiation vs. using ‘new’ to create an object reference in Java. Here is the full faces-config.xml

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE faces-config PUBLIC "-//Sun Microsystems, Inc.//DTD JavaServer Faces Config 1.1//EN" "http://java.sun.com/dtd/web-facesconfig_1_1.dtd">
<faces-config>
	<application>
		<message-bundle>JSF-override</message-bundle>
		<view-handler>com.icesoft.faces.facelets.D2DFaceletViewHandler</view-handler>
		<variable-resolver>org.springframework.web.jsf.DelegatingVariableResolver</variable-resolver>
	</application>
	<!--
	<lifecycle>
<phase-listener>training.jobapplication.lifecycle.LoggingPhaseListener</phase-listener> </lifecycle>
	-->
	<converter>
		<converter-id> provinceIdConverter </converter-id>
		<converter-class> training.jobapplication.converter.ProvinceIdConverter </converter-class>
	</converter>
	<managed-bean>
		<managed-bean-name>applicantEditor</managed-bean-name>
		<managed-bean-class>training.jobapplication.bean.backing.ApplicantEditor</managed-bean-class>
		<managed-bean-scope>request</managed-bean-scope>
	</managed-bean>

	<managed-bean>
		<managed-bean-name>applicantList</managed-bean-name>
		<managed-bean-class>training.jobapplication.bean.backing.ApplicantList</managed-bean-class>
		<managed-bean-scope>request</managed-bean-scope>
		<managed-property>
<property-name>applicantEditor</property-name>
			<value>#{applicantEditor}</value>
		</managed-property>
		<managed-property>
<property-name>applicantListModel</property-name>
			<value>#{applicantListModel}</value>
		</managed-property>
	</managed-bean>

	<managed-bean>
		<managed-bean-name>applicantForm</managed-bean-name>
		<managed-bean-class>training.jobapplication.bean.backing.ApplicantForm</managed-bean-class>
		<managed-bean-scope>request</managed-bean-scope>
		<managed-property>
<property-name>applicantEditor</property-name>
			<value>#{applicantEditor}</value>
		</managed-property>
		<managed-property>
<property-name>applicantListModel</property-name>
			<value>#{applicantListModel}</value>
		</managed-property>
		<managed-property>
<property-name>citySupport</property-name>
			<value>#{citySupport}</value>
		</managed-property>
	</managed-bean>
	<managed-bean>
		<managed-bean-name>provinceSupport</managed-bean-name>
		<managed-bean-class>training.jobapplication.bean.support.ProvinceSupport</managed-bean-class>
		<managed-bean-scope>request</managed-bean-scope>
		<managed-property>
<property-name>provinceService</property-name>
			<value>#{provinceService}</value>
		</managed-property>
	</managed-bean>
	<managed-bean>
		<managed-bean-name>citySupport</managed-bean-name>
		<managed-bean-class>training.jobapplication.bean.support.CitySupport</managed-bean-class>
		<managed-bean-scope>request</managed-bean-scope>
		<managed-property>
<property-name>cityService</property-name>
			<value>#{cityService}</value>
		</managed-property>
	</managed-bean>

	<managed-bean>
		<managed-bean-name>applicantListModel</managed-bean-name>
		<managed-bean-class>training.jobapplication.bean.model.ApplicantLazyListModel</managed-bean-class>
		<managed-bean-scope>session</managed-bean-scope>
		<managed-property>
<property-name>applicantService</property-name>
			<value>#{applicantService}</value>
		</managed-property>
		<managed-property>
<property-name>rowsPerPage</property-name>
			<value>#{userPreferences.rowsPerPage}</value>
		</managed-property>
	</managed-bean>

	<managed-bean>
		<managed-bean-name>userPreferences</managed-bean-name>
		<managed-bean-class>training.jobapplication.bean.util.UserPreferences</managed-bean-class>
		<managed-bean-scope>session</managed-bean-scope>
	</managed-bean>
	<navigation-rule>
		<from-view-id>/applicantList.xhtml</from-view-id>
		<navigation-case>
			<to-view-id>/applicantForm.xhtml</to-view-id>
		</navigation-case>
	</navigation-rule>
	<navigation-rule>
		<from-view-id>/applicantForm.xhtml</from-view-id>
		<navigation-case>
			<to-view-id>/applicantList.xhtml</to-view-id>
		</navigation-case>
	</navigation-rule>
</faces-config>

Related Topics: What is Dependency Injection (DI) / Inversion of Control (IoC):  “Hollywood Principle”—”don’t call us, we will call you”. – Wiki’s definition

Pros: The dependency injection approach offers more flexibility because it becomes easier to create alternative implementations of a given service type, and then to specify which implementation is to be used via a configuration file, without any change to the objects that use the service. This is especially useful in unit testing, because it is easy to inject a mock implementation of a service into the object being tested.

Cons: The price paid for that additional flexibility is greatly increased complexity and the fact that the program is no longer deterministic: it’s no longer possible to tell what functions will be called just by looking at the code.

Entendendo um pouco de Java Server Faces (JSF)

Agradecimentos para o JavaFree

Spring Web Flow seems to support Java Server Faces via Spring Faces which I like.

So I’ll be exploring this for the next little while.  I usually ramp up pretty fast, so I’ll see how this works out.

Thanks

Today! I install Google Chrome… Actually I expected JSF not to work at all… let alone how it does.

JSF runs VERY VERY VERY Fast in Google Chrome, sorry, actually, the whole internet runs VERY VERY VERY FAST.

Our tests so far show perfect compatibilty with JSF and it turns the web browser into an application browser, apart from the fact we can perform more customisations of the browser and use it as a real tool for accessing the multiple JSF projects we have.

We can now see bottlenecks without running profiler. The time between the pages loading shows where the problems are. IE really struggled with massive amounts of componants on pages. 

GOOD JOB GOOGLE

If you’ve not tried Google Chrome please please do… hitch it up to your JSF application (or any web app) or your favorite website and just fall off your chair at the MARKED DIFFERENCE in speed. 

I would think once word gets out that people will not want to use IE any longer.

1. Edit the table with the email in it – and set the type of the email field to a HYPERLINK.

2. Create a STATIC TEXT field on the form somewhere, change its ID to txtJAVASCRIPT, turn off the escape property and add a binding attribute to it. We’ll use this to run a bit of javascript to call the email.

3. Add a binding attribute to tablerowgroup1 on your table

4. In the action code for the Hyperlink insert the following code, this will make the javascript basically tell the browser to open the users email programme with the email address in the subject. Obviously you’ll need to change tblcustomersDataProvider1 to your data provider and email to the field in the database corresponding to the persons email address.

public String hyperlink2_action() {
        // Process email
        tblcustomersDataProvider1.setCursorRow(
                tableRowGroup1.getRowKey());
        String sEmail=tblcustomersDataProvider1.getValue("email")+"";
        if (!sEmail.equals("")) {
           
            txtJAVASCRIPT.setText("<script language='javascript'>\nwindow.location=\"mailto:"+sEmail+"\";\n</script>");
           
        } else {
           
            txtJAVASCRIPT.setText("");
        }
        return null;
    }

5. To cancel the email request we add the following into the public void preprocess() code for the jsf page

    txtJAVASCRIPT.setText(""); 

Using this technique you can pretty much make any javascript happen on a page based on an event.

EPF Tree

Now, if I click “EPF Work Group”, I get this following data

EPF Tree 2

But, I’d like to see this screen without clicking “EPF Work Group” tree node or when application gets initialized.  I assume, I have to do it in backing bean, fire up an Action Event or so on.

Solution: http://www.icefaces.org/JForum/posts/list/9588.page

Lo bueno de todo esto es que en vez de pagar por el instalador, podemos crear por nuestra cuenta el Jboss Developer Studio, ¿cómo?, de la siguiente forma:

Ir a la página:

http://download.jboss.org/jbosstools/builds/nightly/

Una vez ahí, elegir la carpeta con la fecha y la hora más reciente.

Luego descargar todo lo que aparezca debajo de “Build Drivers” (los 6 links), notar que el primer Link es para bajar eclipse, ese link lleva directo a la versión para Windows, los linuxeros deberán saber bajar la versión para Linux del directorio en donde aparece el link para windows, es decir, si el link de descarga para windows es:

http://repository.jboss.com/eclipse/sdk/3.4RC3/eclipse-SDK-3.4RC3-win32.zip

entonces deben situarse en:

http://repository.jboss.com/eclipse/sdk/3.4RC3/

Se entiende???, espero q sí.

Luego hay que descargar el plugin Jboss-tools (aparece justo debajo de donde dice All Plugins), deben descargar el que corresponda a su arquitectura (Mac, Windows, Linux).

Una vez descargado todo se debe descomprimir el link que daba a eclipse y luego los otros links (que son plugins) deben descomprimirlos en alguna otra carpeta. Podrán darse cuenta de que al descomprimir los plugins aparece un directorio llamado eclipse, deben ubicarse dentro de él y podrán ver dos carpetas features y plugins (Quizás también aparezca a veces readme). Luego tendrán que ubicarse dentro de cada uno de esos directorios y copiar todo el contenido en los directorios del mismo nombre que se encuentran en la ruta en donde han descomprimido eclipse, por ejemplo:

cp -r /home/usuario/plugins/eclipse/features/* /home/usuario/eclipse/features

Luego debemos descargar Xdoclet, que nos facilitará la creación de EJB’s, Contenido Web, etc. Para eso deben ir a:

http://sourceforge.net/project/showfiles.php?group_id=31602

Y descargar la versión más reciente.

Una vez que lo descompriman deben mover la carpeta que aparece (xdoclet{version}), al directorio plugins del directorio en donde han descomprimido eclipse (en realidad pueden ubicarla en cualquier parte, pero por orden yo la dejo ahí). Luego hay que ejecutar eclipse.  Una vez cargado deben ir a Window->Preferences y escoger xdoclet y donde dice Xdoclet Home deben escoger el directorio en donde han dejado la carpeta descomprimida del plugin y luego en Version deben escoger la versión que se han descargado.

Eso es todo!!!, ya está listo Jboss Developer Studio, ahora queda descargar e instalar Jboss Server y enlazarlo al IDE que hemos creado, es muy simple, pero eso ya es tema de otro post.

1. Put The following code in your application bean.

public String OutputFromTableToCSV(
String sFilename,
TableRowGroup tableRowGroup1,
CachedRowSetDataProvider tblzonesDataProvider) {
// Create an ooutput text file
FileOutputStream out; // declare a file output object
PrintStream p; // declare a print stream object

try {
out = new FileOutputStream(sFilename
+".txt");

p=new PrintStream(out);
} catch (Exception e) {
return "Error, could not write to "+sFilename+".txt";
}

String sFields = "";
String sColumnTitle = "";
String sThisFieldName="";
List theseColumns = tableRowGroup1.getChildren();
// Columns
for (int i = 0; i < tableRowGroup1.getColumnCount(); ++i) {
sColumnTitle = sColumnTitle.concat(sColumnTitle);
sColumnTitle = sColumnTitle.concat(",");

// Get the SQL mapped fields
TableColumn thisComponant = (TableColumn) theseColumns.get(i);
try {
sColumnTitle = sColumnTitle.concat(
thisComponant.getHeaderText());
} catch (Exception e) {
}
}
if (!sColumnTitle.equals("")) {
sColumnTitle=sColumnTitle.substring(1); // Chop off initial ,
}
// Write it out
p.println(sColumnTitle);

RowKey[] TheseRows = tblzonesDataProvider.getAllRows();
for (int rowCount = 0; rowCount < TheseRows.length; ++rowCount) {
// Now do the rows
tblzonesDataProvider.setCursorRow(TheseRows[rowCount]);
for (int i = 0; i < tableRowGroup1.getColumnCount(); ++i) {
sFields = sFields.concat(sFields);
sFields = sFields.concat(",");
// Get the SQL mapped fields
TableColumn thisColumn = (TableColumn) theseColumns.get(i);
UIComponent thisChild=(UIComponent) thisColumn.getChildren().get(0);
// ",[#{currentRow.value['ZoneDescription']}]"
try {
sThisFieldName = thisChild.getValueExpression("text").toString();
sThisFieldName = sThisFieldName.substring(
sThisFieldName.indexOf("['") + 2);
sThisFieldName = sThisFieldName.substring(0,
sThisFieldName.indexOf("']"));

} catch (Exception e) {
}

// Add the field to the string to write out

sFields = sFields.concat(
tblzonesDataProvider.getValue(sThisFieldName).toString()
);

}
if (!sFields.equals("")) {
sFields = sFields.substring(1); // Chop off initial ,
}
p.println(sFields);

sFields="";
} // Next Row
// At this point we have to csv strings
// sfields and column title

// Now we have a comma delimited string called sresult in theory

p.close();
return "OK";
}

2. On the form with the JSF page.
a. Add the binding attribute to the tableRowGroup (in the left hand bottom pane).

Create an “Export to CSV file” button and in the event when clicked add this code:-

thefilename – the filename you want to write to
tableRowGroup1 - The table row group from your JSF page table
yourdataprovider – The data provider that feeds the JSF table

getApplicationBean1().OutputFromTableToCSV("thefilename", tableRowGroup1, yourDataProvider);

So:-

FORM WITH DATA —> CLICK PRINT —> Bring up Popup Print Window —> CLOSE WINDOW –> RETURN TO FORM

The Popup JSF page

1. Create the Popup window java server faces page. (just a normal jsf page)
2. Add a Button to the page to close it
3. Add a static text box, rename it to txtJAVASCRIPT, set the escape checkbox to off, add a binding attribute
4. Now, on the Popup I have a close button and the code in the close button simply sets the static text box’s javascript:

public String cmdClOSE_action() {
getSessionBean1().sPrintReportRequest="";
        txtJAVASCRIPT.setText("<script language='javascript'>window.close();</script>");
        txtJAVASCRIPT.setVisible(true); 
        return null;
}

The calling JSF page

1. Create your page that you want to call the popup box.
2. Add the popup code into the JSF for the page calling the popup (I put it into a page fragement that appears on every page):-

<script LANGUAGE="JavaScript">
       
            function popUp(URL) {
            day = new Date();
            id = day.getTime();
            eval("page" + id + " = window.open(URL, '" + id + "',
'toolbar=0,scrollbars=0,location=0,statusbar=0,menubar=0,resizable=0,width=382,height=286,left = 529,top = 307');");
            }
       
        </script>

Ofcourse you can change the settings as you wish (i.e. popup window size)

3. Making the popup appear.

a. Add a static text box, rename it to txtJAVASCRIPT, set the escape checkbox to off, add a binding attribute (this stores the javascript when i want the box to appear).

b. Add a button to the form you want the popup to appear on, in the button java put :-

  public String cmdPRINT_action() {
      // in this case i am printing a report so i set the session variable to tell the server the popup needs to be displayed
         getSessionBean1().sPrintReportRequest="rptzones";
// now set the txt of the static text box I set up on the same page, note its normally not visible or rendered
// in this case the popup is a jsf page called frmPRINTREPORTS.jsp
         txtJAVASCRIPT.setRendered(true);
         txtJAVASCRIPT.setText("<script language='javascript'>popUp('frmPRINTREPORTS.jsp');</script>" );
        txtJAVASCRIPT.setVisible(true);
       
       
        return null;
    }
 

4. Lastly in the form that called the popup I want to stop it from appearing so I have to kill the javascript.

    public void preprocess() {
       
        String sReportRequest=getSessionBean1().sPrintReportRequest;
        if (sReportRequest.equals("")) {
            txtJAVASCRIPT.setVisible(false);
            txtJAVASCRIPT.setText("");
           
        }
       
       
   

Note that the code has to run in the preprocess stage of the page, this simply makes sure that the javascript won’t run when it’s not wanted.

There you go!

In this case I have a master detail form here as you can see. Now. To make sure the detail form only has the data in from THAT purchase order I insert some code into the init() function of the page.

 try {
            String sSQL="SELECT ALL polines.id, polines.poid, polines.description, polines.qty, polines.price, polines.total  FROM polines WHERE poid=" + cachedRowSetDataProvider1.getValue("id");
            polinesDataProvider.getCachedRowSet().setCommand(sSQL);
            polinesDataProvider.getCachedRowSet().execute();
            polinesDataProvider.refresh();
              } catch (Exception e) {
                  
              }

(polinesDataProvider is the rows of the table, the “detail part” if you like, cachedDataProvider1 is the header)

Now here’s the tricky part. Normally I would do an ADDNEW and just do:-

 RowKey newRow = polinesDataProvider.appendRow();
        polinesDataProvider.setCursorRow(newRow);
        polinesDataProvider.setValue("poid", cachedRowSetDataProvider1.getValue("id"));
        return null;

But I discovered that when you do the “CommitChanges()” command the new row is not saved because there is a WHERE in the command query I set earlier. This is a bug (http://www.netbeans.org/issues/show_bug.cgi?id=139024), in fact the software just ignores the command (I got my MYSQL server to log the queiries and nothing happens).

So the workaround code for the New Item (new detail line) button is:-

        RowKey newRow = polinesDataProvider.appendRow();
        polinesDataProvider.setCursorRow(newRow);
        polinesDataProvider.setValue("poid", cachedRowSetDataProvider1.getValue("id"));
        polinesDataProvider.commitChanges();
        polinesDataProvider.refresh();
        return null;

Note that I set the poid field to the header’s PrimaryKey otherwise it will not look up correctly.

Strangely If you edit a record it works absolutely fine with the default just “commitingchanges” when someone clicks save.

JSF eases Web-based application development because it:

* Lets you create user interfaces from a set of standard,
reusable server-side components
* Provides a set of JSP tags to access those components
* Transparently saves state information and repopulates forms
when they redisplay
* Provides a framework for implementing custom components
* Encapsulates event handling and component rendering so you
can use standard

According to SUN:

JavaServer Faces technology is a server-side user interface
component framework for Java technology-based web
applications. A set of APIs for: representing UI components
and managing their state, handling events and input
validation,defining page navigation, and supporting
internationalization and accessibility.

A JavaServer Pages (JSP) custom tag library for expressing
a JavaServer Faces interface within a JSP page. JSF is built
on standard J2EE technologies,which include JSP tag
libraries,a controller servlet, and other Java classes that
make up its UI component library and event-processing model.

The Java Enterprise Edition 5 platform includes JavaServer
Faces (JSF) technology,which provides a mature and extensible
user interface component model.The design of this model makes
it easy for application developers to create custom components
by extending the standard components included with JSF and to
reuse these components across applications.

Tools supporting JSF-Java Server Faces:

* Borland JBuilder Enterprise Edition 2005
* Eclipse with Exadel Studio Pro IDE
* Eclipse with Nitrox JSF IDE
* IBM Rational with JSF Support
* Macromedia Dreamweaver with JSTL & JSF extensions
* MyEclipse with JSF Designer
* Oracle’s JDeveloper IDE
* Sun’s Java Studio Creator

Important Links For Developers

http://exadel.com/tutorial/jsf/jsftutorial-kickstart.html

http://resources.coreservlets.com/jsf.html

To Create Your Own Java Server Faces Components

http://www.jsftutorials.net/components/