diff --git a/bundles/org.eclipse.swt/Eclipse SWT Accessibility/common/org/eclipse/swt/accessibility/ACC.java b/bundles/org.eclipse.swt/Eclipse SWT Accessibility/common/org/eclipse/swt/accessibility/ACC.java
index f909027..3fe7f0d 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT Accessibility/common/org/eclipse/swt/accessibility/ACC.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT Accessibility/common/org/eclipse/swt/accessibility/ACC.java
@@ -368,10 +368,10 @@
 	/**
 	 * Send when an object's state has changed, for example enabled/disabled, pressed/released, or checked/unchecked.
 	 * <p>
-	 * The eventData object is an array of 2 ints specifying the following:<ul>
+	 * The eventData object is an array of 2 ints specifying the following:</p><ul>
 	 * <li>state - the STATE_* constant identifying the state that changed</li>
 	 * <li>newValue - either 1 or 0, indicating whether the state has changed to true or false</li>
-	 * </ul></p>
+	 * </ul>
 	 *
 	 * @since 3.6
 	 */
@@ -404,10 +404,11 @@
 	/**
 	 * Send when an object's value has changed.
 	 * <p>
-	 * The eventData object is an array of 2 Numbers specifying the following:<ul>
+	 * The eventData object is an array of 2 Numbers specifying the following:</p>
+	 * <ul>
 	 * <li>oldValue - the object's old value</li>
 	 * <li>newValue - the object's new value</li>
-	 * </ul></p>
+	 * </ul>
 	 *
 	 * @since 3.6
 	 */
@@ -543,13 +544,14 @@
 	/**
 	 * Send when a table's data has changed.
 	 * <p>
-	 * The eventData object is an array of 5 ints specifying the following:<ul>
+	 * The eventData object is an array of 5 ints specifying the following:</p>
+	 * <ul>
 	 * <li>type - {@link ACC#INSERT} or {@link ACC#DELETE} - the type of change</li>
 	 * <li>rowStart - the index of the first row that changed</li>
 	 * <li>rowCount - the number of contiguous rows that changed, or 0 if no rows changed</li>
 	 * <li>columnStart - the index of the first column that changed</li>
 	 * <li>columnCount - the number of contiguous columns that changed, or 0 if no columns changed</li>
-	 * </ul></p>
+	 * </ul>
 	 *
 	 * @since 3.6
 	 */
@@ -602,12 +604,13 @@
 	/**
 	 * Send when text was inserted or deleted.
 	 * <p>
-	 * The eventData object is an array of 4 objects specifying the following:<ul>
+	 * The eventData object is an array of 4 objects specifying the following:</p>
+	 * <ul>
 	 * <li>type - {@link ACC#INSERT} or {@link ACC#DELETE} - the type of change</li>
 	 * <li>start - the index of the first character that changed</li>
 	 * <li>end - the index of the last character that changed</li>
 	 * <li>text - the text string that was inserted or deleted</li>
-	 * </ul></p>
+	 * </ul>
 	 *
 	 * @since 3.6
 	 */
diff --git a/bundles/org.eclipse.swt/Eclipse SWT Accessibility/common/org/eclipse/swt/accessibility/AccessibleControlAdapter.java b/bundles/org.eclipse.swt/Eclipse SWT Accessibility/common/org/eclipse/swt/accessibility/AccessibleControlAdapter.java
index 7ea52a1..b1de1ec 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT Accessibility/common/org/eclipse/swt/accessibility/AccessibleControlAdapter.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT Accessibility/common/org/eclipse/swt/accessibility/AccessibleControlAdapter.java
@@ -88,13 +88,14 @@
 	 * for a child of the control by index or childID, or when a client
 	 * requests the index of an accessible object in its parent.
 	 * <p>
-	 * The childID field in the event object can be one of the following:<ul>
+	 * The childID field in the event object can be one of the following:</p>
+	 * <ul>
 	 *    <li>an integer child ID - return the accessible object for the specified child ID,
 	 *    	or null if the specified child does not have its own accessible</li>
 	 *    <li>{@link ACC#CHILDID_CHILD_AT_INDEX} - return the accessible child object at the specified index,
 	 *    	or null if this object has no children</li>
 	 *    <li>{@link ACC#CHILDID_CHILD_INDEX} - return the index of this accessible in its parent</li>
-	 * </ul></p>
+	 * </ul>
 	 *
 	 * @param e an event object containing the following fields:<ul>
 	 *    <li>childID [IN] - an identifier specifying a child of the control, or one of the predefined CHILDID constants</li>
diff --git a/bundles/org.eclipse.swt/Eclipse SWT Accessibility/common/org/eclipse/swt/accessibility/AccessibleControlListener.java b/bundles/org.eclipse.swt/Eclipse SWT Accessibility/common/org/eclipse/swt/accessibility/AccessibleControlListener.java
index 6aba030..e938a35 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT Accessibility/common/org/eclipse/swt/accessibility/AccessibleControlListener.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT Accessibility/common/org/eclipse/swt/accessibility/AccessibleControlListener.java
@@ -14,7 +14,7 @@
 package org.eclipse.swt.accessibility;
 
 
-import org.eclipse.swt.internal.SWTEventListener;
+import org.eclipse.swt.internal.*;
 
 /**
  * Classes that implement this interface provide methods
@@ -85,13 +85,14 @@
 	 * for a child of the control by index or childID, or when a client
 	 * requests the index of an accessible object in its parent.
 	 * <p>
-	 * The childID field in the event object can be one of the following:<ul>
+	 * The childID field in the event object can be one of the following:</p>
+	 * <ul>
 	 *    <li>an integer child ID - return the accessible object for the specified child ID,
 	 *    	or null if the specified child does not have its own accessible</li>
 	 *    <li>{@link ACC#CHILDID_CHILD_AT_INDEX} - return the accessible child object at the specified index,
 	 *    	or null if this object has no children</li>
 	 *    <li>{@link ACC#CHILDID_CHILD_INDEX} - return the index of this accessible in its parent</li>
-	 * </ul></p>
+	 * </ul>
 	 *
 	 * @param e an event object containing the following fields:<ul>
 	 *    <li>childID [IN] - an identifier specifying a child of the control, or one of the predefined CHILDID constants</li>
diff --git a/bundles/org.eclipse.swt/Eclipse SWT Browser/common/org/eclipse/swt/browser/Browser.java b/bundles/org.eclipse.swt/Eclipse SWT Browser/common/org/eclipse/swt/browser/Browser.java
index 4c137a6..16af5d3 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT Browser/common/org/eclipse/swt/browser/Browser.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT Browser/common/org/eclipse/swt/browser/Browser.java
@@ -656,7 +656,7 @@
  * An <code>SWTException</code> is thrown if the return value has an
  * unsupported type, or if evaluating the script causes a javascript
  * error to be thrown.
- * </p><p>
+ * <p>
  * Note: Chrome security context is applicable only to Browsers with style <code>SWT.Mozilla</code>.
  * </p>
  * @param script the script with javascript commands
diff --git a/bundles/org.eclipse.swt/Eclipse SWT Browser/common/org/eclipse/swt/browser/BrowserFunction.java b/bundles/org.eclipse.swt/Eclipse SWT Browser/common/org/eclipse/swt/browser/BrowserFunction.java
index e3e3f94..d55a44a 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT Browser/common/org/eclipse/swt/browser/BrowserFunction.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT Browser/common/org/eclipse/swt/browser/BrowserFunction.java
@@ -153,7 +153,7 @@
 /**
  * Disposes of the resources associated with this BrowserFunction.
  * Applications must dispose of all BrowserFunctions that they create.
- * </p><p>
+ * <p>
  * Note that disposing a Browser automatically disposes all
  * BrowserFunctions associated with it.
  * </p>
diff --git a/bundles/org.eclipse.swt/Eclipse SWT Browser/common/org/eclipse/swt/browser/CloseWindowListener.java b/bundles/org.eclipse.swt/Eclipse SWT Browser/common/org/eclipse/swt/browser/CloseWindowListener.java
index e9f9806..a35b08c 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT Browser/common/org/eclipse/swt/browser/CloseWindowListener.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT Browser/common/org/eclipse/swt/browser/CloseWindowListener.java
@@ -37,10 +37,10 @@
  * hosts the <code>Browser</code>. The <code>Browser</code> is disposed after this
  * notification.
  *
- * <p>The following fields in the <code>WindowEvent</code> apply:
+ * <p>The following fields in the <code>WindowEvent</code> apply:</p>
  * <ul>
  * <li>(in) widget the <code>Browser</code> that is going to be disposed
- * </ul></p>
+ * </ul>
  *
  * @param event the <code>WindowEvent</code> that specifies the <code>Browser</code>
  * that is going to be disposed
diff --git a/bundles/org.eclipse.swt/Eclipse SWT Custom Widgets/common/org/eclipse/swt/custom/CTabFolderRenderer.java b/bundles/org.eclipse.swt/Eclipse SWT Custom Widgets/common/org/eclipse/swt/custom/CTabFolderRenderer.java
index d5cce86..2fa60dc 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT Custom Widgets/common/org/eclipse/swt/custom/CTabFolderRenderer.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT Custom Widgets/common/org/eclipse/swt/custom/CTabFolderRenderer.java
@@ -251,6 +251,7 @@
 	 * </p><p>
 	 * The <code>part</code> value indicated what component the preferred size is
 	 * to be calculated for. Valid values are any of the part constants:
+	 * </p>
 	 * <ul>
 	 * <li>PART_BODY</li>
 	 * <li>PART_HEADER</li>
@@ -262,14 +263,13 @@
 	 * <li>PART_CLOSE_BUTTON</li>
 	 * <li>A positive integer which is the index of an item in the CTabFolder.</li>
 	 * </ul>
-	 * </p>
 	 * <p>
 	 * The <code>state</code> parameter may be one of the following:
+	 * </p>
 	 * <ul>
 	 * <li>SWT.NONE</li>
 	 * <li>SWT.SELECTED - whether the part is selected</li>
 	 * </ul>
-	 * </p>
 	 * @param part a part constant
 	 * @param state current state
 	 * @param gc the gc to use for measuring
@@ -570,6 +570,7 @@
 	/**
 	 * Draw a specified <code>part</code> of the CTabFolder using the provided <code>bounds</code> and <code>GC</code>.
 	 * <p>The valid CTabFolder <code>part</code> constants are:
+	 * </p>
 	 * <ul>
 	 * <li>PART_BODY - the entire body of the CTabFolder</li>
 	 * <li>PART_HEADER - the upper tab area of the CTabFolder</li>
@@ -581,16 +582,15 @@
 	 * <li>PART_CLOSE_BUTTON</li>
 	 * <li>A positive integer which is the index of an item in the CTabFolder.</li>
 	 * </ul>
-	 * </p>
 	 * <p>
 	 * The <code>state</code> parameter may be a combination of:
+	 * </p>
 	 * <ul>
 	 * <li>SWT.BACKGROUND - whether the background should be drawn</li>
 	 * <li>SWT.FOREGROUND - whether the foreground should be drawn</li>
 	 * <li>SWT.SELECTED - whether the part is selected</li>
 	 * <li>SWT.HOT - whether the part is hot (i.e. mouse is over the part)</li>
 	 * </ul>
-	 * </p>
 	 *
 	 * @param part part to draw
 	 * @param state state of the part
diff --git a/bundles/org.eclipse.swt/Eclipse SWT Custom Widgets/common/org/eclipse/swt/custom/TableTreeItem.java b/bundles/org.eclipse.swt/Eclipse SWT Custom Widgets/common/org/eclipse/swt/custom/TableTreeItem.java
index 93354bb..92632cc 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT Custom Widgets/common/org/eclipse/swt/custom/TableTreeItem.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT Custom Widgets/common/org/eclipse/swt/custom/TableTreeItem.java
@@ -270,7 +270,7 @@
 /**
  * Returns <code>true</code> if the receiver is checked,
  * and false otherwise.  When the parent does not have
- * the <code>CHECK style, return false.
+ * the <code>CHECK</code> style, return false.
  *
  * @return the checked state of the checkbox
  *
diff --git a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/cocoa/org/eclipse/swt/dnd/Clipboard.java b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/cocoa/org/eclipse/swt/dnd/Clipboard.java
index 06defb2..567d2e5 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/cocoa/org/eclipse/swt/dnd/Clipboard.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/cocoa/org/eclipse/swt/dnd/Clipboard.java
@@ -202,7 +202,7 @@
  * <p>The following snippet shows text and RTF text being retrieved from the
  * clipboard:</p>
  *
- *    <code><pre>
+ *    <pre><code>
  *    Clipboard clipboard = new Clipboard(display);
  *    TextTransfer textTransfer = TextTransfer.getInstance();
  *    String textData = (String)clipboard.getContents(textTransfer);
@@ -238,7 +238,7 @@
  * <p>The following snippet shows text and RTF text being retrieved from the
  * clipboard:</p>
  *
- *    <code><pre>
+ *    <pre><code>
  *    Clipboard clipboard = new Clipboard(display);
  *    TextTransfer textTransfer = TextTransfer.getInstance();
  *    String textData = (String)clipboard.getContents(textTransfer);
@@ -340,7 +340,7 @@
  * clipboard:
  * </p>
  *
- * <code><pre>
+ * <pre><code>
  * 	Clipboard clipboard = new Clipboard(display);
  *	String textData = "Hello World";
  *	String rtfData = "{\\rtf1\\b\\i Hello World}";
@@ -397,7 +397,7 @@
  * clipboard:
  * </p>
  *
- * <code><pre>
+ * <pre><code>
  * 	Clipboard clipboard = new Clipboard(display);
  *	String textData = "Hello World";
  *	String rtfData = "{\\rtf1\\b\\i Hello World}";
diff --git a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/common/org/eclipse/swt/dnd/DND.java b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/common/org/eclipse/swt/dnd/DND.java
index 96575ae..9363386 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/common/org/eclipse/swt/dnd/DND.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/common/org/eclipse/swt/dnd/DND.java
@@ -246,7 +246,7 @@
  * The <code>hresult</code> argument should be either 0, or the
  * platform specific error code.
  * <p>
- * In DND, errors are reported by throwing one of three exceptions:
+ * In DND, errors are reported by throwing one of three exceptions:</p>
  * <dl>
  * <dd>java.lang.IllegalArgumentException</dd>
  * <dt>thrown whenever one of the API methods is invoked with an illegal argument</dt>
@@ -255,6 +255,7 @@
  * <dd>org.eclipse.swt.SWTError (extends java.lang.Error)</dd>
  * <dt>thrown whenever a <b>non-recoverable</b> error happens internally in SWT</dt>
  * </dl>
+ * <p>
  * This method provides the logic which maps between error codes
  * and one of the above exceptions.
  * </p>
diff --git a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/gtk/org/eclipse/swt/dnd/Clipboard.java b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/gtk/org/eclipse/swt/dnd/Clipboard.java
index fca5cf2..635196b 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/gtk/org/eclipse/swt/dnd/Clipboard.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/gtk/org/eclipse/swt/dnd/Clipboard.java
@@ -215,7 +215,7 @@
  * <p>The following snippet shows text and RTF text being retrieved from the
  * clipboard:</p>
  *
- *    <code><pre>
+ *    <pre><code>
  *    Clipboard clipboard = new Clipboard(display);
  *    TextTransfer textTransfer = TextTransfer.getInstance();
  *    String textData = (String)clipboard.getContents(textTransfer);
@@ -251,7 +251,7 @@
  * <p>The following snippet shows text and RTF text being retrieved from the
  * clipboard:</p>
  *
- *    <code><pre>
+ *    <pre><code>
  *    Clipboard clipboard = new Clipboard(display);
  *    TextTransfer textTransfer = TextTransfer.getInstance();
  *    String textData = (String)clipboard.getContents(textTransfer);
@@ -357,7 +357,7 @@
  * clipboard:
  * </p>
  *
- * <code><pre>
+ * <pre><code>
  * 	Clipboard clipboard = new Clipboard(display);
  *	String textData = "Hello World";
  *	String rtfData = "{\\rtf1\\b\\i Hello World}";
@@ -414,7 +414,7 @@
  * clipboard:
  * </p>
  *
- * <code><pre>
+ * <pre><code>
  * 	Clipboard clipboard = new Clipboard(display);
  *	String textData = "Hello World";
  *	String rtfData = "{\\rtf1\\b\\i Hello World}";
diff --git a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/win32/org/eclipse/swt/dnd/Clipboard.java b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/win32/org/eclipse/swt/dnd/Clipboard.java
index b3bb76b..f314942 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/win32/org/eclipse/swt/dnd/Clipboard.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/win32/org/eclipse/swt/dnd/Clipboard.java
@@ -235,7 +235,7 @@
  * <p>The following snippet shows text and RTF text being retrieved from the
  * clipboard:</p>
  *
- *    <code><pre>
+ *    <pre><code>
  *    Clipboard clipboard = new Clipboard(display);
  *    TextTransfer textTransfer = TextTransfer.getInstance();
  *    String textData = (String)clipboard.getContents(textTransfer);
@@ -270,7 +270,7 @@
  * <p>The following snippet shows text and RTF text being retrieved from the
  * clipboard:</p>
  *
- *    <code><pre>
+ *    <pre><code>
  *    Clipboard clipboard = new Clipboard(display);
  *    TextTransfer textTransfer = TextTransfer.getInstance();
  *    String textData = (String)clipboard.getContents(textTransfer);
@@ -379,7 +379,7 @@
  * clipboard:
  * </p>
  *
- * <code><pre>
+ * <pre><code>
  * 	Clipboard clipboard = new Clipboard(display);
  *	String textData = "Hello World";
  *	String rtfData = "{\\rtf1\\b\\i Hello World}";
@@ -436,7 +436,7 @@
  * clipboard:
  * </p>
  *
- * <code><pre>
+ * <pre><code>
  * 	Clipboard clipboard = new Clipboard(display);
  *	String textData = "Hello World";
  *	String rtfData = "{\\rtf1\\b\\i Hello World}";
diff --git a/bundles/org.eclipse.swt/Eclipse SWT OpenGL/cocoa/org/eclipse/swt/opengl/GLCanvas.java b/bundles/org.eclipse.swt/Eclipse SWT OpenGL/cocoa/org/eclipse/swt/opengl/GLCanvas.java
index a4cf29d..1317bcf 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT OpenGL/cocoa/org/eclipse/swt/opengl/GLCanvas.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT OpenGL/cocoa/org/eclipse/swt/opengl/GLCanvas.java
@@ -43,8 +43,8 @@
  * @param data the requested attributes of the GLCanvas
  *
  * @exception IllegalArgumentException
- * <ul><li>ERROR_NULL_ARGUMENT when the data is null
- *     <li>ERROR_UNSUPPORTED_DEPTH when the requested attributes cannot be provided</ul>
+ * <ul><li>ERROR_NULL_ARGUMENT when the data is null</li>
+ *     <li>ERROR_UNSUPPORTED_DEPTH when the requested attributes cannot be provided</li>
  * </ul>
  */
 public GLCanvas (Composite parent, int style, GLData data) {
diff --git a/bundles/org.eclipse.swt/Eclipse SWT OpenGL/gtk/org/eclipse/swt/opengl/GLCanvas.java b/bundles/org.eclipse.swt/Eclipse SWT OpenGL/gtk/org/eclipse/swt/opengl/GLCanvas.java
index 0b69f7f..214b8e6b 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT OpenGL/gtk/org/eclipse/swt/opengl/GLCanvas.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT OpenGL/gtk/org/eclipse/swt/opengl/GLCanvas.java
@@ -46,8 +46,8 @@
  * @param data the requested attributes of the GLCanvas
  *
  * @exception IllegalArgumentException
- * <ul><li>ERROR_NULL_ARGUMENT when the data is null
- *     <li>ERROR_UNSUPPORTED_DEPTH when the requested attributes cannot be provided</ul>
+ * <ul><li>ERROR_NULL_ARGUMENT when the data is null</li>
+ *     <li>ERROR_UNSUPPORTED_DEPTH when the requested attributes cannot be provided</li>
  * </ul>
  */
 public GLCanvas (Composite parent, int style, GLData data) {
diff --git a/bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32/org/eclipse/swt/opengl/GLCanvas.java b/bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32/org/eclipse/swt/opengl/GLCanvas.java
index 58d90c6..4a57f1d 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32/org/eclipse/swt/opengl/GLCanvas.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT OpenGL/win32/org/eclipse/swt/opengl/GLCanvas.java
@@ -41,8 +41,8 @@
  * @param data the requested attributes of the GLCanvas
  *
  * @exception IllegalArgumentException
- * <ul><li>ERROR_NULL_ARGUMENT when the data is null
- *     <li>ERROR_UNSUPPORTED_DEPTH when the requested attributes cannot be provided</ul>
+ * <ul><li>ERROR_NULL_ARGUMENT when the data is null</li>
+ *     <li>ERROR_UNSUPPORTED_DEPTH when the requested attributes cannot be provided</li>
  * </ul>
  */
 public GLCanvas (Composite parent, int style, GLData data) {
diff --git a/bundles/org.eclipse.swt/Eclipse SWT Printing/cocoa/org/eclipse/swt/printing/Printer.java b/bundles/org.eclipse.swt/Eclipse SWT Printing/cocoa/org/eclipse/swt/printing/Printer.java
index 38b8071..6937904 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT Printing/cocoa/org/eclipse/swt/printing/Printer.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT Printing/cocoa/org/eclipse/swt/printing/Printer.java
@@ -149,13 +149,13 @@
  * for the top and left edges of the paper, and the resulting width and height
  * (offset by the resulting x and y) to determine the minimum margins for the
  * bottom and right edges of the paper, as follows:
+ * </p>
  * <ul>
  * 		<li>The left trim width is -x pixels</li>
  * 		<li>The top trim height is -y pixels</li>
  * 		<li>The right trim width is (x + width) pixels</li>
  * 		<li>The bottom trim height is (y + height) pixels</li>
  * </ul>
- * </p>
  *
  * @param x the x coordinate of the client area
  * @param y the y coordinate of the client area
diff --git a/bundles/org.eclipse.swt/Eclipse SWT Printing/gtk/org/eclipse/swt/printing/Printer.java b/bundles/org.eclipse.swt/Eclipse SWT Printing/gtk/org/eclipse/swt/printing/Printer.java
index ace846c..d7cd48d 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT Printing/gtk/org/eclipse/swt/printing/Printer.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT Printing/gtk/org/eclipse/swt/printing/Printer.java
@@ -683,13 +683,13 @@
  * for the top and left edges of the paper, and the resulting width and height
  * (offset by the resulting x and y) to determine the minimum margins for the
  * bottom and right edges of the paper, as follows:
+ * </p>
  * <ul>
  * 		<li>The left trim width is -x pixels</li>
  * 		<li>The top trim height is -y pixels</li>
  * 		<li>The right trim width is (x + width) pixels</li>
  * 		<li>The bottom trim height is (y + height) pixels</li>
  * </ul>
- * </p>
  *
  * @param x the x coordinate of the client area
  * @param y the y coordinate of the client area
diff --git a/bundles/org.eclipse.swt/Eclipse SWT Printing/win32/org/eclipse/swt/printing/Printer.java b/bundles/org.eclipse.swt/Eclipse SWT Printing/win32/org/eclipse/swt/printing/Printer.java
index 3f4d68b..8422cba 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT Printing/win32/org/eclipse/swt/printing/Printer.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT Printing/win32/org/eclipse/swt/printing/Printer.java
@@ -535,13 +535,13 @@
  * for the top and left edges of the paper, and the resulting width and height
  * (offset by the resulting x and y) to determine the minimum margins for the
  * bottom and right edges of the paper, as follows:
+ * </p>
  * <ul>
  * 		<li>The left trim width is -x pixels</li>
  * 		<li>The top trim height is -y pixels</li>
  * 		<li>The right trim width is (x + width) pixels</li>
  * 		<li>The bottom trim height is (y + height) pixels</li>
  * </ul>
- * </p>
  *
  * @param x the x coordinate of the client area
  * @param y the y coordinate of the client area
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/graphics/FontData.java b/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/graphics/FontData.java
index 69e2485..3eb3e19 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/graphics/FontData.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/graphics/FontData.java
@@ -392,11 +392,12 @@
  * Sets the name of the receiver.
  * <p>
  * Some platforms support font foundries. On these platforms, the name
- * of the font specified in setName() may have one of the following forms:
+ * of the font specified in setName() may have one of the following forms:</p>
  * <ol>
  * <li>a face name (for example, "courier")</li>
  * <li>a foundry followed by a dash ("-") followed by a face name (for example, "adobe-courier")</li>
  * </ol>
+ * <p>
  * In either case, the name returned from getName() will include the
  * foundry.
  * </p>
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/graphics/GC.java b/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/graphics/GC.java
index f62acd3..1e64473 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/graphics/GC.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/graphics/GC.java
@@ -1125,7 +1125,7 @@
  * @exception IllegalArgumentException <ul>
  *    <li>ERROR_NULL_ARGUMENT - if the image is null</li>
  *    <li>ERROR_INVALID_ARGUMENT - if the image has been disposed</li>
- *    <li>ERROR_INVALID_ARGUMENT - if the given coordinates are outside the bounds of the image</li>
+ *    <li>ERROR_INVALID_ARGUMENT - if the given coordinates are outside the bounds of the image</li></ul>
  * @exception SWTException <ul>
  *    <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been disposed</li>
  * </ul>
@@ -1724,6 +1724,7 @@
  * receiver's background color.
  * <p>
  * The parameter <code>flags</code> may be a combination of:
+ * </p>
  * <dl>
  * <dt><b>DRAW_DELIMITER</b></dt>
  * <dd>draw multiple lines</dd>
@@ -1734,7 +1735,6 @@
  * <dt><b>DRAW_TRANSPARENT</b></dt>
  * <dd>transparent background</dd>
  * </dl>
- * </p>
  *
  * @param string the string to be drawn
  * @param x the x coordinate of the top left corner of the rectangular area where the text is to be drawn
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/graphics/Image.java b/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/graphics/Image.java
index f292c7a..f426f91 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/graphics/Image.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/graphics/Image.java
@@ -1670,13 +1670,13 @@
  * In these cases, it may be desired to simulate transparency by using
  * the background color of the widget to paint the transparent pixels
  * of the image. This method specifies the color that will be used in
- * these cases. For example:
+ * these cases. For example:</p>
  * <pre>
  *    Button b = new Button();
  *    image.setBackground(b.getBackground());
  *    b.setImage(image);
  * </pre>
- * </p><p>
+ * <p>
  * The image may be modified by this operation (in effect, the
  * transparent regions may be filled with the supplied color).  Hence
  * this operation is not reversible and it is not legal to call
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/graphics/TextLayout.java b/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/graphics/TextLayout.java
index deda859..fd140d8 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/graphics/TextLayout.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/graphics/TextLayout.java
@@ -887,7 +887,7 @@
  *    <li>ERROR_INVALID_ARGUMENT - if the character offset is out of range</li>
  * </ul>
  * @exception SWTException <ul>
- *    <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been disposed</li>
+ *    <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been disposed</li></ul>
  */
 public int getLevel(int offset) {
 	checkLayout();
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/widgets/Group.java b/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/widgets/Group.java
index 3386332..79617f9 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/widgets/Group.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/widgets/Group.java
@@ -259,7 +259,7 @@
  * Sets the receiver's text, which is the string that will
  * be displayed as the receiver's <em>title</em>, to the argument,
  * which may not be null. The string may include the mnemonic character.
- * </p>
+ * <p>
  * Mnemonics are indicated by an '&amp;' that causes the next
  * character to be the mnemonic.  When the user presses a
  * key sequence that matches the mnemonic, focus is assigned
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/widgets/Menu.java b/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/widgets/Menu.java
index 44e20e8..8c7a253 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/widgets/Menu.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/widgets/Menu.java
@@ -474,7 +474,6 @@
  *
  * @return the default menu item.
  *
- * </ul>
  * @exception SWTException <ul>
  *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
  *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/widgets/Shell.java b/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/widgets/Shell.java
index 8dbea1f..0601151 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/widgets/Shell.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/widgets/Shell.java
@@ -1899,7 +1899,6 @@
  *
  * @param modified the new modified state for the receiver
  *
- * </ul>
  * @exception SWTException <ul>
  *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
  *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/widgets/TabItem.java b/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/widgets/TabItem.java
index d86cfbf..ce775aa 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/widgets/TabItem.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/widgets/TabItem.java
@@ -372,7 +372,6 @@
 /**
  * Sets the receiver's text.  The string may include
  * the mnemonic character.
- * </p>
  * <p>
  * Mnemonics are indicated by an '&amp;' that causes the next
  * character to be the mnemonic.  When the user presses a
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/widgets/TableItem.java b/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/widgets/TableItem.java
index ca16796..a535a98 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/widgets/TableItem.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/widgets/TableItem.java
@@ -1014,7 +1014,6 @@
  *
  * @param indent the new indent
  *
- * </ul>
  * @exception SWTException <ul>
  *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
  *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/widgets/ToolItem.java b/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/widgets/ToolItem.java
index cda8f93..57db12a 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/widgets/ToolItem.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/widgets/ToolItem.java
@@ -1132,7 +1132,6 @@
 /**
  * Sets the receiver's text. The string may include
  * the mnemonic character.
- * </p>
  * <p>
  * Mnemonics are indicated by an '&amp;' that causes the next
  * character to be the mnemonic.  When the user presses a
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/widgets/TreeItem.java b/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/widgets/TreeItem.java
index 7fc16bb..1e402b4 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/widgets/TreeItem.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/cocoa/org/eclipse/swt/widgets/TreeItem.java
@@ -538,8 +538,7 @@
 /**
  * Returns <code>true</code> if the receiver is checked,
  * and false otherwise.  When the parent does not have
- * the <code>CHECK style, return false.
- * <p>
+ * the <code>CHECK</code> style, return false.
  *
  * @return the checked state
  *
@@ -658,8 +657,7 @@
 /**
  * Returns <code>true</code> if the receiver is grayed,
  * and false otherwise. When the parent does not have
- * the <code>CHECK style, return false.
- * <p>
+ * the <code>CHECK</code> style, return false.
  *
  * @return the grayed state of the checkbox
  *
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/common/org/eclipse/swt/events/MouseEvent.java b/bundles/org.eclipse.swt/Eclipse SWT/common/org/eclipse/swt/events/MouseEvent.java
index d8447f9..24a36df 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT/common/org/eclipse/swt/events/MouseEvent.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/common/org/eclipse/swt/events/MouseEvent.java
@@ -42,6 +42,7 @@
 	 * <li>2 for the second button (usually 'middle')</li>
 	 * <li>3 for the third button (usually 'right')</li>
 	 * <li>etc.</li>
+	 * </ul>
 	 */
 	public int button;
 
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/common/org/eclipse/swt/events/SelectionEvent.java b/bundles/org.eclipse.swt/Eclipse SWT/common/org/eclipse/swt/events/SelectionEvent.java
index 347366b..aa6bc87 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT/common/org/eclipse/swt/events/SelectionEvent.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/common/org/eclipse/swt/events/SelectionEvent.java
@@ -37,9 +37,12 @@
 	/**
 	 * Extra detail information about the selection, depending on the widget.
 	 *
-	 * <p><b>Sash</b><ul>
+	 * <p><b>Sash</b></p>
+	 * <ul>
 	 * <li>{@link org.eclipse.swt.SWT#DRAG}</li>
-	 * </ul></p><p><b>ScrollBar and Slider</b><ul>
+	 * </ul>
+	 * <p><b>ScrollBar and Slider</b></p>
+	 * <ul>
 	 * <li>{@link org.eclipse.swt.SWT#DRAG}</li>
 	 * <li>{@link org.eclipse.swt.SWT#HOME}</li>
 	 * <li>{@link org.eclipse.swt.SWT#END}</li>
@@ -47,13 +50,19 @@
 	 * <li>{@link org.eclipse.swt.SWT#ARROW_UP}</li>
 	 * <li>{@link org.eclipse.swt.SWT#PAGE_DOWN}</li>
 	 * <li>{@link org.eclipse.swt.SWT#PAGE_UP}</li>
-	 * </ul></p><p><b>Table and Tree</b><ul>
+	 * </ul>
+	 * <p><b>Table and Tree</b></p>
+	 * <ul>
 	 * <li>{@link org.eclipse.swt.SWT#CHECK}</li>
-	 * </ul></p><p><b>Text</b><ul>
+	 * </ul>
+	 * <p><b>Text</b></p>
+	 * <ul>
 	 * <li>{@link org.eclipse.swt.SWT#CANCEL}</li>
-	 * </ul></p><p><b>CoolItem and ToolItem</b><ul>
+	 * </ul>
+	 * <p><b>CoolItem and ToolItem</b></p>
+	 * <ul>
 	 * <li>{@link org.eclipse.swt.SWT#ARROW}</li>
-	 * </ul></p>
+	 * </ul>
 	 */
 	public int detail;
 
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/graphics/FontData.java b/bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/graphics/FontData.java
index 26e365a..ca717f6 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/graphics/FontData.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/graphics/FontData.java
@@ -392,11 +392,12 @@
  * Sets the name of the receiver.
  * <p>
  * Some platforms support font foundries. On these platforms, the name
- * of the font specified in setName() may have one of the following forms:
+ * of the font specified in setName() may have one of the following forms:</p>
  * <ol>
  * <li>a face name (for example, "courier")</li>
  * <li>a foundry followed by a dash ("-") followed by a face name (for example, "adobe-courier")</li>
  * </ol>
+ * <p>
  * In either case, the name returned from getName() will include the
  * foundry.
  * </p>
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/graphics/Image.java b/bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/graphics/Image.java
index 5b344f7..ef188ea 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/graphics/Image.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/graphics/Image.java
@@ -1497,13 +1497,13 @@
  * In these cases, it may be desired to simulate transparency by using
  * the background color of the widget to paint the transparent pixels
  * of the image. This method specifies the color that will be used in
- * these cases. For example:
+ * these cases. For example:</p>
  * <pre>
  *    Button b = new Button();
  *    image.setBackground(b.getBackground());
  *    b.setImage(image);
  * </pre>
- * </p><p>
+ * <p>
  * The image may be modified by this operation (in effect, the
  * transparent regions may be filled with the supplied color).  Hence
  * this operation is not reversible and it is not legal to call
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/graphics/TextLayout.java b/bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/graphics/TextLayout.java
index d3bca49..8c2498f 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/graphics/TextLayout.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/graphics/TextLayout.java
@@ -926,7 +926,7 @@
  *    <li>ERROR_INVALID_ARGUMENT - if the character offset is out of range</li>
  * </ul>
  * @exception SWTException <ul>
- *    <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been disposed</li>
+ *    <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been disposed</li></ul>
  */
 public int getLevel(int offset) {
 	checkLayout();
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/widgets/Group.java b/bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/widgets/Group.java
index 6a6653a..8d0add7 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/widgets/Group.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/widgets/Group.java
@@ -374,7 +374,7 @@
  * Sets the receiver's text, which is the string that will
  * be displayed as the receiver's <em>title</em>, to the argument,
  * which may not be null. The string may include the mnemonic character.
- * </p>
+ * <p>
  * Mnemonics are indicated by an '&amp;' that causes the next
  * character to be the mnemonic.  When the user presses a
  * key sequence that matches the mnemonic, focus is assigned
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/widgets/Menu.java b/bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/widgets/Menu.java
index 24ec16a..ff56ac6 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/widgets/Menu.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/widgets/Menu.java
@@ -520,7 +520,6 @@
  *
  * @return the default menu item.
  *
- * </ul>
  * @exception SWTException <ul>
  *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
  *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/widgets/Shell.java b/bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/widgets/Shell.java
index 9454470..0755828 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/widgets/Shell.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/widgets/Shell.java
@@ -2482,7 +2482,6 @@
  *
  * @param modified the new modified state for the receiver
  *
- * </ul>
  * @exception SWTException <ul>
  *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
  *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/widgets/TableItem.java b/bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/widgets/TableItem.java
index a8185c8..a80aabf 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/widgets/TableItem.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/widgets/TableItem.java
@@ -1257,7 +1257,6 @@
  *
  * @param indent the new indent
  *
- * </ul>
  * @exception SWTException <ul>
  *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
  *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/widgets/ToolItem.java b/bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/widgets/ToolItem.java
index 6d5833e..3c6be8b 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/widgets/ToolItem.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/widgets/ToolItem.java
@@ -1162,7 +1162,6 @@
 /**
  * Sets the receiver's text. The string may include
  * the mnemonic character.
- * </p>
  * <p>
  * Mnemonics are indicated by an '&amp;' that causes the next
  * character to be the mnemonic.  When the user presses a
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/widgets/TreeItem.java b/bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/widgets/TreeItem.java
index 988d013..1019df2 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/widgets/TreeItem.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/gtk/org/eclipse/swt/widgets/TreeItem.java
@@ -528,8 +528,7 @@
 /**
  * Returns <code>true</code> if the receiver is checked,
  * and false otherwise.  When the parent does not have
- * the <code>CHECK style, return false.
- * <p>
+ * the <code>CHECK</code> style, return false.
  *
  * @return the checked state
  *
@@ -649,8 +648,7 @@
 /**
  * Returns <code>true</code> if the receiver is grayed,
  * and false otherwise. When the parent does not have
- * the <code>CHECK style, return false.
- * <p>
+ * the <code>CHECK</code> style, return false.
  *
  * @return the grayed state of the checkbox
  *
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/graphics/FontData.java b/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/graphics/FontData.java
index 06840aa..7c814b7 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/graphics/FontData.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/graphics/FontData.java
@@ -532,11 +532,12 @@
  * Sets the name of the receiver.
  * <p>
  * Some platforms support font foundries. On these platforms, the name
- * of the font specified in setName() may have one of the following forms:
+ * of the font specified in setName() may have one of the following forms:</p>
  * <ol>
  * <li>a face name (for example, "courier")</li>
  * <li>a foundry followed by a dash ("-") followed by a face name (for example, "adobe-courier")</li>
  * </ol>
+ * <p>
  * In either case, the name returned from getName() will include the
  * foundry.
  * </p>
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/graphics/GC.java b/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/graphics/GC.java
index 0f4a9f4..7e30eb9 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/graphics/GC.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/graphics/GC.java
@@ -858,7 +858,7 @@
  * @exception IllegalArgumentException <ul>
  *    <li>ERROR_NULL_ARGUMENT - if the image is null</li>
  *    <li>ERROR_INVALID_ARGUMENT - if the image has been disposed</li>
- *    <li>ERROR_INVALID_ARGUMENT - if the given coordinates are outside the bounds of the image</li>
+ *    <li>ERROR_INVALID_ARGUMENT - if the given coordinates are outside the bounds of the image</li></ul>
  * @exception SWTException <ul>
  *    <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been disposed</li>
  * </ul>
@@ -2228,6 +2228,7 @@
  * receiver's background color.
  * <p>
  * The parameter <code>flags</code> may be a combination of:
+ * </p>
  * <dl>
  * <dt><b>DRAW_DELIMITER</b></dt>
  * <dd>draw multiple lines</dd>
@@ -2238,7 +2239,6 @@
  * <dt><b>DRAW_TRANSPARENT</b></dt>
  * <dd>transparent background</dd>
  * </dl>
- * </p>
  *
  * @param string the string to be drawn
  * @param x the x coordinate of the top left corner of the rectangular area where the text is to be drawn
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/graphics/Image.java b/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/graphics/Image.java
index 2d57308..86c7ce5 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/graphics/Image.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/graphics/Image.java
@@ -2084,13 +2084,13 @@
  * In these cases, it may be desired to simulate transparency by using
  * the background color of the widget to paint the transparent pixels
  * of the image. This method specifies the color that will be used in
- * these cases. For example:
+ * these cases. For example:</p>
  * <pre>
  *    Button b = new Button();
  *    image.setBackground(b.getBackground());
  *    b.setImage(image);
  * </pre>
- * </p><p>
+ * <p>
  * The image may be modified by this operation (in effect, the
  * transparent regions may be filled with the supplied color).  Hence
  * this operation is not reversible and it is not legal to call
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/graphics/TextLayout.java b/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/graphics/TextLayout.java
index 046bfbb..63de7fc 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/graphics/TextLayout.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/graphics/TextLayout.java
@@ -1843,7 +1843,7 @@
  *    <li>ERROR_INVALID_ARGUMENT - if the character offset is out of range</li>
  * </ul>
  * @exception SWTException <ul>
- *    <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been disposed</li>
+ *    <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been disposed</li></ul>
  */
 public int getLevel (int offset) {
 	checkLayout();
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/widgets/Group.java b/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/widgets/Group.java
index a337b61..fd6ade2 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/widgets/Group.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/widgets/Group.java
@@ -381,7 +381,7 @@
  * Sets the receiver's text, which is the string that will
  * be displayed as the receiver's <em>title</em>, to the argument,
  * which may not be null. The string may include the mnemonic character.
- * </p>
+ * <p>
  * Mnemonics are indicated by an '&amp;' that causes the next
  * character to be the mnemonic.  When the user presses a
  * key sequence that matches the mnemonic, focus is assigned
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/widgets/Menu.java b/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/widgets/Menu.java
index df858ea..3a7bb71 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/widgets/Menu.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/widgets/Menu.java
@@ -543,7 +543,6 @@
  *
  * @return the default menu item.
  *
- * </ul>
  * @exception SWTException <ul>
  *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
  *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/widgets/Shell.java b/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/widgets/Shell.java
index 1eb50b1..4d5c2d3 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/widgets/Shell.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/widgets/Shell.java
@@ -1772,7 +1772,6 @@
  *
  * @param modified the new modified state for the receiver
  *
- * </ul>
  * @exception SWTException <ul>
  *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
  *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/widgets/TabItem.java b/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/widgets/TabItem.java
index 93cd0fc..fa8952f 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/widgets/TabItem.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/widgets/TabItem.java
@@ -323,7 +323,6 @@
 /**
  * Sets the receiver's text.  The string may include
  * the mnemonic character.
- * </p>
  * <p>
  * Mnemonics are indicated by an '&amp;' that causes the next
  * character to be the mnemonic.  When the user presses a
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/widgets/TableItem.java b/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/widgets/TableItem.java
index 79ff386..63e5ae1 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/widgets/TableItem.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/widgets/TableItem.java
@@ -1141,7 +1141,6 @@
  *
  * @param indent the new indent
  *
- * </ul>
  * @exception SWTException <ul>
  *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
  *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/widgets/ToolItem.java b/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/widgets/ToolItem.java
index 3c088fb..1b179f0 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/widgets/ToolItem.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/widgets/ToolItem.java
@@ -827,7 +827,6 @@
 /**
  * Sets the receiver's text. The string may include
  * the mnemonic character.
- * </p>
  * <p>
  * Mnemonics are indicated by an '&amp;' that causes the next
  * character to be the mnemonic.  When the user presses a
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/widgets/TreeItem.java b/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/widgets/TreeItem.java
index edb363e..4823e50 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/widgets/TreeItem.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/widgets/TreeItem.java
@@ -562,8 +562,7 @@
 /**
  * Returns <code>true</code> if the receiver is checked,
  * and false otherwise.  When the parent does not have
- * the <code>CHECK style, return false.
- * <p>
+ * the <code>CHECK</code> style, return false.
  *
  * @return the checked state
  *
@@ -697,8 +696,7 @@
 /**
  * Returns <code>true</code> if the receiver is grayed,
  * and false otherwise. When the parent does not have
- * the <code>CHECK style, return false.
- * <p>
+ * the <code>CHECK</code> style, return false.
  *
  * @return the grayed state of the checkbox
  *
