<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">

<html>
<head>
	<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
	<title>Configuring JAX-WS Annotation Processing</title>
	<link href="../book.css" rel="stylesheet" charset="ISO-8859-1" type="text/css">
</head>

<body>
<h2>Enable JAX-WS Annotation Processing</h2>
<p>If the <strong>Enable annotation validation processing</strong> setting on the <a href="PLUGINS_ROOT/org.eclipse.jst.ws.cxf.doc.user/reference/jaxws_tab.html">JAX-WS</a> tab in
the Apache CXF 2.x preferences is selected, annotation processing will be enabled on projects on as part of the CXF Facet install.</p>

<h3>Enabling Existing Projects</h3>
To turn annotation processing on or off on an existing project right-click on the project and choose <b>Properties</b> from the context menu. 
 On the <strong>Java Compiler > Annotation Processing</strong> properties page select or deselect the <strong>Enable Annotation Processing</strong> check box and then click <b>OK</b>.
<p><img src="./images/annotation_processing.png" alt="Annotation Processing" > </p>
<p><img src="../images/ngrelr.png" alt="Related reference" border="0" ></p>
<a href="PLUGINS_ROOT/org.eclipse.jst.ws.cxf.doc.user/reference/cxf_facet.html">CXF Project Facet</a><br>
</body>
</html>