diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer-src/org/eclipse/wst/ws/internal/explorer/platform/favorites/perspective/FavoritesPerspective.java b/bundles/org.eclipse.wst.ws.explorer/wsexplorer-src/org/eclipse/wst/ws/internal/explorer/platform/favorites/perspective/FavoritesPerspective.java
index bff8db0..dfce85fb 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer-src/org/eclipse/wst/ws/internal/explorer/platform/favorites/perspective/FavoritesPerspective.java
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer-src/org/eclipse/wst/ws/internal/explorer/platform/favorites/perspective/FavoritesPerspective.java
@@ -16,6 +16,7 @@
 import org.eclipse.wst.ws.internal.explorer.platform.favorites.actions.*;
 import org.eclipse.wst.ws.internal.explorer.platform.favorites.datamodel.FavoritesMainElement;
 import org.eclipse.wst.ws.internal.explorer.platform.perspective.*;
+import org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils;
 
 import javax.servlet.*;
 
@@ -43,7 +44,10 @@
         nodeManager_.setRootNode(favMainNode);
         
         // Starting frameset sizes.
-        perspectiveContentFramesetCols_ = "30%,*";
+        if (!DirUtils.isRTL())
+          perspectiveContentFramesetCols_ = "30%,*";
+        else
+          perspectiveContentFramesetCols_ = "*,30%";
         savedPerspectiveContentFramesetCols_ = perspectiveContentFramesetCols_;
         actionsContainerFramesetRows_ = "75%,*";
         savedActionsContainerFramesetRows_ = actionsContainerFramesetRows_;        
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer-src/org/eclipse/wst/ws/internal/explorer/platform/uddi/perspective/UDDIPerspective.java b/bundles/org.eclipse.wst.ws.explorer/wsexplorer-src/org/eclipse/wst/ws/internal/explorer/platform/uddi/perspective/UDDIPerspective.java
index 2221895..ba5e870 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer-src/org/eclipse/wst/ws/internal/explorer/platform/uddi/perspective/UDDIPerspective.java
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer-src/org/eclipse/wst/ws/internal/explorer/platform/uddi/perspective/UDDIPerspective.java
@@ -40,6 +40,7 @@
 import org.eclipse.wst.ws.internal.explorer.platform.uddi.datamodel.CategoryModel;
 import org.eclipse.wst.ws.internal.explorer.platform.uddi.datamodel.RegistryElement;
 import org.eclipse.wst.ws.internal.explorer.platform.uddi.datamodel.UDDIMainElement;
+import org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils;
 import org.eclipse.wst.ws.internal.explorer.platform.util.URLUtils;
 import org.eclipse.wst.ws.internal.explorer.platform.util.Validator;
 import org.eclipse.wst.ws.internal.parser.favorites.IFavoritesUDDIRegistry;
@@ -138,7 +139,10 @@
     categoryTModelKey_ = null;
     
     // Starting frameset sizes.
-    perspectiveContentFramesetCols_ = "30%,*";
+    if (!DirUtils.isRTL())
+      perspectiveContentFramesetCols_ = "30%,*";
+    else
+      perspectiveContentFramesetCols_ = "*,30%";
     savedPerspectiveContentFramesetCols_ = perspectiveContentFramesetCols_;
     actionsContainerFramesetRows_ = "75%,*";
     savedActionsContainerFramesetRows_ = actionsContainerFramesetRows_;
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer-src/org/eclipse/wst/ws/internal/explorer/platform/util/DirUtils.java b/bundles/org.eclipse.wst.ws.explorer/wsexplorer-src/org/eclipse/wst/ws/internal/explorer/platform/util/DirUtils.java
new file mode 100644
index 0000000..b4dc81a
--- /dev/null
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer-src/org/eclipse/wst/ws/internal/explorer/platform/util/DirUtils.java
@@ -0,0 +1,58 @@
+package org.eclipse.wst.ws.internal.explorer.platform.util;
+
+import java.util.Locale;
+import org.eclipse.core.runtime.Platform;
+
+public final class DirUtils
+{
+  public static boolean isRTL()
+  {
+    return "rtl".equals(getDir());
+  }
+
+  public static String getDir()
+  {
+    String rtl = "rtl";
+    String ltr = "ltr";
+
+    // from system property
+    String orientation = System.getProperty("eclipse.orientation"); //$NON-NLS-1$
+    if (rtl.equals(orientation)) //$NON-NLS-1$
+      return rtl;
+    else if (ltr.equals(orientation)) //$NON-NLS-1$
+      return ltr;
+
+    // from command line
+    String[] args = Platform.getCommandLineArgs();
+    for (int i = 0; i < args.length; i++)
+    {
+      if ("-dir".equalsIgnoreCase(args[i])) //$NON-NLS-1$
+      {
+        if ((i + 1) < args.length && "rtl".equalsIgnoreCase(args[i + 1])) //$NON-NLS-1$
+        {
+          return rtl;
+        }
+        return ltr;
+      }
+    }
+
+    // Check if the user property is set. If not do not
+    // rely on the vm.
+    if (System.getProperty("osgi.nl.user") == null) //$NON-NLS-1$
+      return ltr;
+
+    // guess from default locale
+    String locale = Platform.getNL();
+    if (locale == null)
+    {
+      locale = Locale.getDefault().toString();
+    }
+    if (locale.startsWith("ar") || locale.startsWith("fa") //$NON-NLS-1$//$NON-NLS-2$
+        || locale.startsWith("he") || locale.startsWith("iw") //$NON-NLS-1$//$NON-NLS-2$
+        || locale.startsWith("ur")) //$NON-NLS-1$
+    {
+      return rtl;
+    }
+    return ltr;
+  }
+}
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer-src/org/eclipse/wst/ws/internal/explorer/platform/wsdl/perspective/WSDLPerspective.java b/bundles/org.eclipse.wst.ws.explorer/wsexplorer-src/org/eclipse/wst/ws/internal/explorer/platform/wsdl/perspective/WSDLPerspective.java
index 51782d0..cc23a50 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer-src/org/eclipse/wst/ws/internal/explorer/platform/wsdl/perspective/WSDLPerspective.java
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer-src/org/eclipse/wst/ws/internal/explorer/platform/wsdl/perspective/WSDLPerspective.java
@@ -26,6 +26,7 @@
 import org.eclipse.wst.ws.internal.explorer.platform.perspective.Node;
 import org.eclipse.wst.ws.internal.explorer.platform.perspective.NodeManager;
 import org.eclipse.wst.ws.internal.explorer.platform.perspective.Perspective;
+import org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils;
 import org.eclipse.wst.ws.internal.explorer.platform.util.URLUtils;
 import org.eclipse.wst.ws.internal.explorer.platform.wsdl.actions.OpenWSDLAction;
 import org.eclipse.wst.ws.internal.explorer.platform.wsdl.actions.SwitchPerspectiveFromWSDLAction;
@@ -80,7 +81,10 @@
     nodeManager_.setRootNode(wsdlMainNode);
 
     // Starting frameset sizes.
-    perspectiveContentFramesetCols_ = "30%,*";
+    if (!DirUtils.isRTL())
+      perspectiveContentFramesetCols_ = "30%,*";
+    else
+      perspectiveContentFramesetCols_ = "*,30%";
     savedPerspectiveContentFramesetCols_ = perspectiveContentFramesetCols_;
     actionsContainerFramesetRows_ = "75%,*";
     savedActionsContainerFramesetRows_ = actionsContainerFramesetRows_;
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer-src/org/eclipse/wst/ws/internal/explorer/platform/wsil/perspective/WSILPerspective.java b/bundles/org.eclipse.wst.ws.explorer/wsexplorer-src/org/eclipse/wst/ws/internal/explorer/platform/wsil/perspective/WSILPerspective.java
index e512686..46f4a9e 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer-src/org/eclipse/wst/ws/internal/explorer/platform/wsil/perspective/WSILPerspective.java
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer-src/org/eclipse/wst/ws/internal/explorer/platform/wsil/perspective/WSILPerspective.java
@@ -15,6 +15,7 @@
 import org.eclipse.wst.ws.internal.explorer.platform.constants.*;
 import org.eclipse.wst.ws.internal.explorer.platform.datamodel.*;
 import org.eclipse.wst.ws.internal.explorer.platform.perspective.*;
+import org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils;
 import org.eclipse.wst.ws.internal.explorer.platform.wsil.actions.*;
 
 import javax.servlet.*;
@@ -43,7 +44,10 @@
         nodeManager_.setRootNode(wsilMainNode);
 
         // Starting frameset sizes.
-        perspectiveContentFramesetCols_ = "30%,*";
+        if (!DirUtils.isRTL())
+          perspectiveContentFramesetCols_ = "30%,*";
+        else
+          perspectiveContentFramesetCols_ = "*,30%";
         savedPerspectiveContentFramesetCols_ = perspectiveContentFramesetCols_;
         actionsContainerFramesetRows_ = "75%,*";
         savedActionsContainerFramesetRows_ = actionsContainerFramesetRows_;
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actionengine_container.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actionengine_container.jsp
index f199792..f9fc6cf 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actionengine_container.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actionengine_container.jsp
@@ -83,7 +83,7 @@
     }
   </script>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
   <form method="post">
     <%
     String labelModePlay = controller.getMessage("FORM_LABEL_MODE_PLAY");
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/CheckWorkbenchFileReadOnlyActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/CheckWorkbenchFileReadOnlyActionJSP.jsp
index 6f8c006..a8a9a78 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/CheckWorkbenchFileReadOnlyActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/CheckWorkbenchFileReadOnlyActionJSP.jsp
@@ -23,7 +23,7 @@
 %>
 <jsp:include page="<%=panesFile.toString()%>" flush="true"/>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <script language="javascript">
 <%
    ImportToWorkbenchAction action = (ImportToWorkbenchAction)session.getAttribute(ActionInputs.IMPORT_ACTION);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/ClearNodeAction.inc b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/ClearNodeAction.inc
index ae4f972..18f981d 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/ClearNodeAction.inc
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/ClearNodeAction.inc
@@ -24,7 +24,7 @@
 <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/browserdetect.js"))%>">
 </script>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <script language="javascript">
   if (isMicrosoftInternetExplorer())
   {    
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/ClearViewElementAction.inc b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/ClearViewElementAction.inc
index a212411..24ee121 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/ClearViewElementAction.inc
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/ClearViewElementAction.inc
@@ -22,7 +22,7 @@
 %>
 <jsp:include page="<%=panesFile.toString()%>" flush="true"/>
 <head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <script language="javascript">
 <%
    String propertiesContainerVar = action.getPropertiesContainerVar();
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/ImportToFileSystemAction.inc b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/ImportToFileSystemAction.inc
index d8e0777..6086b90 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/ImportToFileSystemAction.inc
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/ImportToFileSystemAction.inc
@@ -39,7 +39,7 @@
 %>
 <jsp:include page="<%=panesFile.toString()%>" flush="true"/>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
       if (action.getStatusContentVar() != null)
       {
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/ImportToWorkbenchAction.inc b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/ImportToWorkbenchAction.inc
index bce5781..812ad18 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/ImportToWorkbenchAction.inc
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/ImportToWorkbenchAction.inc
@@ -19,7 +19,7 @@
 %>
 <jsp:include page="<%=panesFile.toString()%>" flush="true"/>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <script language="javascript">
 <%
    //Load the parameters for the action from the servlet request.
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/LaunchWebServiceWizardAction.inc b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/LaunchWebServiceWizardAction.inc
index 9c149a7..1dbdeb6 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/LaunchWebServiceWizardAction.inc
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/LaunchWebServiceWizardAction.inc
@@ -26,7 +26,7 @@
 %>
 <jsp:include page="<%=panesFile.toString()%>" flush="true"/>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    if (!actionResult)
    {
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/RetrieveHistoryActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/RetrieveHistoryActionJSP.jsp
index a7e51a6..9ae19b3 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/RetrieveHistoryActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/RetrieveHistoryActionJSP.jsp
@@ -30,7 +30,7 @@
   <meta http-equiv="Content-Type" content="text/html; UTF-8">
   <jsp:include page="/scripts/panes.jsp" flush="true"/>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <script language="javascript">
 <%
    BreadCrumb b = action.getBreadCrumb();
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/SelectNodeAction.inc b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/SelectNodeAction.inc
index 8bf86fc..b2f3efe 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/SelectNodeAction.inc
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/SelectNodeAction.inc
@@ -24,7 +24,7 @@
 <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/browserdetect.js"))%>">
 </script>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    if (!actionResult)
    {
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/SelectNodeToolAction.inc b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/SelectNodeToolAction.inc
index 4b4cfad..b337f2b 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/SelectNodeToolAction.inc
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/SelectNodeToolAction.inc
@@ -24,7 +24,7 @@
 <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/browserdetect.js"))%>">
 </script>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    if (!actionResult)
    {
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/ShowPerspectiveActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/ShowPerspectiveActionJSP.jsp
index ba1ed37..c01dde3 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/ShowPerspectiveActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/ShowPerspectiveActionJSP.jsp
@@ -52,7 +52,7 @@
   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
   <jsp:include page="<%=framesetsFile.toString()%>" flush="true"/>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <jsp:useBean id="formAction" class="java.lang.StringBuffer" scope="request">
 <%
    formAction.append(currentPerspective.getSwitchPerspectiveFormActionLink(targetPerspectiveId,isHistory));
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/ToggleNodeAction.inc b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/ToggleNodeAction.inc
index 5db4f35..506fe91 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/ToggleNodeAction.inc
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/ToggleNodeAction.inc
@@ -24,7 +24,7 @@
 <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/browserdetect.js"))%>">
 </script>  
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    if (!actionResult)
    {
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/ValidateEditActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/ValidateEditActionJSP.jsp
index c27dd8e..b053830 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/ValidateEditActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/ValidateEditActionJSP.jsp
@@ -23,7 +23,7 @@
 %>
 <jsp:include page="<%=panesFile.toString()%>" flush="true"/>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    ImportToWorkbenchAction action = (ImportToWorkbenchAction)session.getAttribute(ActionInputs.IMPORT_ACTION);
    boolean result = action.validateEdit();
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/WriteWSDLToWorkbenchActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/WriteWSDLToWorkbenchActionJSP.jsp
index 8e7eb57..93cd580 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/WriteWSDLToWorkbenchActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/actions/WriteWSDLToWorkbenchActionJSP.jsp
@@ -23,7 +23,7 @@
 %>
 <jsp:include page="<%=panesFile.toString()%>" flush="true"/>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    ImportToWorkbenchAction action = (ImportToWorkbenchAction)session.getAttribute(ActionInputs.IMPORT_ACTION);
    action.run();
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/calendar_toolbar.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/calendar_toolbar.jsp
index 5ae79fc..ea55fb6 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/calendar_toolbar.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/calendar_toolbar.jsp
@@ -24,7 +24,7 @@
   <title><%=controller.getMessage("FRAME_TITLE_CALENDAR_TOOLBAR")%></title>
   <link rel="stylesheet" type="text/css" href="<%=response.encodeURL(controller.getPathWithContext("css/toolbar.css"))%>">
 </head>
-<body onUnload="top.opener.calendarBrowserClosed=true" class="toolbarbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" onUnload="top.opener.calendarBrowserClosed=true" class="toolbarbodymargin">
 <div id="toolbarborder">
   <div id="toolbar">
     <table width="100%" height=25 cellpadding=0 cellspacing=0 border=0>
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/actions/AddWSILToWSILPerspectiveActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/actions/AddWSILToWSILPerspectiveActionJSP.jsp
index 05244a9..24dfde4 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/actions/AddWSILToWSILPerspectiveActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/actions/AddWSILToWSILPerspectiveActionJSP.jsp
@@ -22,7 +22,7 @@
 <head>
   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
   // Prepare the action.
   AddWSILToWSILPerspectiveAction action = new AddWSILToWSILPerspectiveAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/actions/FavoritesAddToUDDIPerspectiveActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/actions/FavoritesAddToUDDIPerspectiveActionJSP.jsp
index c094ee6..0fb010f 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/actions/FavoritesAddToUDDIPerspectiveActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/actions/FavoritesAddToUDDIPerspectiveActionJSP.jsp
@@ -22,7 +22,7 @@
 <head>
   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
   // Prepare the action.
   AddToUDDIPerspectiveAction action = AddToUDDIPerspectiveAction.newAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/actions/FavoritesAddToWSDLPerspectiveActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/actions/FavoritesAddToWSDLPerspectiveActionJSP.jsp
index 7556a8e..9fb21cb 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/actions/FavoritesAddToWSDLPerspectiveActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/actions/FavoritesAddToWSDLPerspectiveActionJSP.jsp
@@ -24,7 +24,7 @@
 <head>
   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
 // Prepare the action.
 FavoritesAddToWSDLPerspectiveAction action = new FavoritesAddToWSDLPerspectiveAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/actions/RemoveFavoritesConfirmJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/actions/RemoveFavoritesConfirmJSP.jsp
index 147b1a3..d2d89c9 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/actions/RemoveFavoritesConfirmJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/actions/RemoveFavoritesConfirmJSP.jsp
@@ -21,7 +21,7 @@
 <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
     <script language="javascript">
         if (confirm("<%=controller.getFavoritesPerspective().getMessage("MSG_CONFIRM_REMOVE_NODE", controller.getFavoritesPerspective().getNodeManager().getSelectedNode().getNodeName())%>")) {
             <%
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/actions/ResizeFavoritesFramesActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/actions/ResizeFavoritesFramesActionJSP.jsp
index cc062a1..dd7591d 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/actions/ResizeFavoritesFramesActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/actions/ResizeFavoritesFramesActionJSP.jsp
@@ -28,7 +28,7 @@
 <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/browserdetect.js"))%>">
 </script>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    if (result)
    {
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/actions/RestoreDefaultFavoritesActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/actions/RestoreDefaultFavoritesActionJSP.jsp
index c276625..afe4b17 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/actions/RestoreDefaultFavoritesActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/actions/RestoreDefaultFavoritesActionJSP.jsp
@@ -21,7 +21,7 @@
 <head>
   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
     // Prepare the action.
     FavoritesRestoreDefaultFavoritesAction action = new FavoritesRestoreDefaultFavoritesAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/actions/RestoreDefaultFavoritesConfirmJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/actions/RestoreDefaultFavoritesConfirmJSP.jsp
index d5c94fd..a5c539d 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/actions/RestoreDefaultFavoritesConfirmJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/actions/RestoreDefaultFavoritesConfirmJSP.jsp
@@ -18,7 +18,7 @@
 <head>
   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
     <script language="javascript">
         if (confirm("<%=controller.getFavoritesPerspective().getMessage("MSG_CONFIRM_RESTORE_DEFAULT_FAVORITES")%>"))
             perspectiveWorkArea.location = "<%=response.encodeURL(controller.getPathWithContext("favorites/actions/RestoreDefaultFavoritesActionJSP.jsp"))%>";
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/fav_navigator_content.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/fav_navigator_content.jsp
index 04f5b07..2406ce8 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/fav_navigator_content.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/fav_navigator_content.jsp
@@ -41,7 +41,7 @@
             focusedAnchorName = selectedAnchorName;
     }
 %>
-<body onLoad="self.location.hash='#<%=focusedAnchorName%>';setSelectedAnchorName('<%=selectedAnchorName%>')" class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" onLoad="self.location.hash='#<%=focusedAnchorName%>';setSelectedAnchorName('<%=selectedAnchorName%>')" class="contentbodymargin">
 <div id="treecontentborder">
     <%=nodeManager.renderTreeView(response)%>
 </div>
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/fav_navigator_toolbar.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/fav_navigator_toolbar.jsp
index aad8c94..24a3723 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/fav_navigator_toolbar.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/fav_navigator_toolbar.jsp
@@ -27,7 +27,7 @@
 <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/toolbar.js"))%>">
 </script>  
 </head>
-<body class="toolbarbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="toolbarbodymargin">
 <div id="toolbarborder">
   <div id="toolbar" ondblclick="processFramesetSizes(document.forms[0])">
 <jsp:useBean id="formAction" class="java.lang.StringBuffer" scope="request">
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/fav_perspective_content.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/fav_perspective_content.jsp
index 4c84e68..ad319ab 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/fav_perspective_content.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/fav_perspective_content.jsp
@@ -23,6 +23,20 @@
   <title><%=favPerspective.getMessage("FRAME_TITLE_PERSPECTIVE_CONTENT")%></title>
 </head>
 <frameset cols="<%=favPerspective.getPerspectiveContentFramesetCols()%>" bgcolor=#ECE9D8>
+  <%
+  if (org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.isRTL())
+  {
+  %>
+  <frame name="<%=FavoritesFrameNames.ACTIONS_CONTAINER%>" title="<%=favPerspective.getMessage("FRAME_TITLE_ACTIONS_CONTAINER")%>" src="<%=response.encodeURL(controller.getPathWithContext("favorites/fav_actions_container.jsp"))%>" marginwidth=0 marginheight=0 scrolling="no" frameborder=1>
+  <frame name="<%=FavoritesFrameNames.NAVIGATOR_CONTAINER%>" title="<%=favPerspective.getMessage("FRAME_TITLE_NAVIGATOR_CONTAINER")%>" src="<%=response.encodeURL(controller.getPathWithContext("favorites/fav_navigator_container.jsp"))%>" marginwidth=0 marginheight=0 scrolling="no" frameborder=1>
+  <%
+  }
+  else
+  {
+  %>
   <frame name="<%=FavoritesFrameNames.NAVIGATOR_CONTAINER%>" title="<%=favPerspective.getMessage("FRAME_TITLE_NAVIGATOR_CONTAINER")%>" src="<%=response.encodeURL(controller.getPathWithContext("favorites/fav_navigator_container.jsp"))%>" marginwidth=0 marginheight=0 scrolling="no" frameborder=1>
   <frame name="<%=FavoritesFrameNames.ACTIONS_CONTAINER%>" title="<%=favPerspective.getMessage("FRAME_TITLE_ACTIONS_CONTAINER")%>" src="<%=response.encodeURL(controller.getPathWithContext("favorites/fav_actions_container.jsp"))%>" marginwidth=0 marginheight=0 scrolling="no" frameborder=1>
+  <%
+  }
+  %>
 </frameset>
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/fav_properties_content.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/fav_properties_content.jsp
index 8c19156..e572c12 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/fav_properties_content.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/fav_properties_content.jsp
@@ -24,7 +24,7 @@
   <title><%=favPerspective.getMessage("FRAME_TITLE_PROPERTIES_CONTENT")%></title>
   <link rel="stylesheet" type="text/css" href="<%=response.encodeURL(controller.getPathWithContext("css/windows.css"))%>">
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
 <%
     NodeManager nodeManager = favPerspective.getNodeManager();
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/fav_properties_toolbar.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/fav_properties_toolbar.jsp
index 3e9c6f9..3b9464e 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/fav_properties_toolbar.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/fav_properties_toolbar.jsp
@@ -29,7 +29,7 @@
 <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/toolbar.js"))%>">
 </script>
 </head>
-<body class="toolbarbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="toolbarbodymargin">
 <div id="toolbarborder">
   <div id="toolbar" ondblclick="processFramesetSizes(document.forms[0])">
 <jsp:useBean id="formAction" class="java.lang.StringBuffer" scope="request">
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/fav_status_content.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/fav_status_content.jsp
index d5981e1..f6e1493 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/fav_status_content.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/fav_status_content.jsp
@@ -22,7 +22,7 @@
   <title><%=favPerspective.getMessage("FRAME_TITLE_STATUS_CONTENT")%></title>
   <link rel="stylesheet" type="text/css" href="<%=response.encodeURL(controller.getPathWithContext("css/windows.css"))%>">
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
   <table>
     <tr>
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/fav_status_toolbar.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/fav_status_toolbar.jsp
index 6441c3f..4f466a7 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/fav_status_toolbar.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/fav_status_toolbar.jsp
@@ -27,7 +27,7 @@
 <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/toolbar.js"))%>">
 </script>
 </head>
-<body class="toolbarbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="toolbarbodymargin">
 <div id="toolbarborder">
   <div id="toolbar" ondblclick="processFramesetSizes(document.forms[0])">
 <jsp:useBean id="formAction" class="java.lang.StringBuffer" scope="request">
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/forms/FavoritesUDDIBusinessDetailsPage.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/forms/FavoritesUDDIBusinessDetailsPage.jsp
index e51086f..fa4aac5 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/forms/FavoritesUDDIBusinessDetailsPage.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/forms/FavoritesUDDIBusinessDetailsPage.jsp
@@ -32,7 +32,7 @@
     <title><%=favPerspective.getMessage("FORM_TITLE_UDDI_BUSINESS_DETAILS")%></title>
     <link rel="stylesheet" type="text/css" href="<%=response.encodeURL(controller.getPathWithContext("css/windows.css"))%>">
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
 
     <%
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/forms/FavoritesUDDIRegistryDetailsPage.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/forms/FavoritesUDDIRegistryDetailsPage.jsp
index 94b42e4..432425f 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/forms/FavoritesUDDIRegistryDetailsPage.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/forms/FavoritesUDDIRegistryDetailsPage.jsp
@@ -34,7 +34,7 @@
     <title><%=favPerspective.getMessage("FORM_TITLE_UDDI_REGISTRY_DETAILS")%></title>
     <link rel="stylesheet" type="text/css" href="<%=response.encodeURL(controller.getPathWithContext("css/windows.css"))%>">
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
 
     <%
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/forms/FavoritesUDDIServiceDetailsPage.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/forms/FavoritesUDDIServiceDetailsPage.jsp
index caa6017..3c56f58 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/forms/FavoritesUDDIServiceDetailsPage.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/forms/FavoritesUDDIServiceDetailsPage.jsp
@@ -32,7 +32,7 @@
     <title><%=favPerspective.getMessage("FORM_TITLE_UDDI_SERVICE_DETAILS")%></title>
     <link rel="stylesheet" type="text/css" href="<%=response.encodeURL(controller.getPathWithContext("css/windows.css"))%>">
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
 
     <%
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/forms/FavoritesUDDIServiceIntDetailsPage.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/forms/FavoritesUDDIServiceIntDetailsPage.jsp
index 977b9c1..d31a0f4 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/forms/FavoritesUDDIServiceIntDetailsPage.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/forms/FavoritesUDDIServiceIntDetailsPage.jsp
@@ -32,7 +32,7 @@
     <title><%=favPerspective.getMessage("FORM_TITLE_UDDI_SERVICE_INTERFACE_DETAILS")%></title>
     <link rel="stylesheet" type="text/css" href="<%=response.encodeURL(controller.getPathWithContext("css/windows.css"))%>">
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
 
     <%
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/forms/FavoritesWSDLDetailsPage.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/forms/FavoritesWSDLDetailsPage.jsp
index f4c1e56..9906f47 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/forms/FavoritesWSDLDetailsPage.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/forms/FavoritesWSDLDetailsPage.jsp
@@ -31,7 +31,7 @@
     <title><%=favPerspective.getMessage("FORM_TITLE_WSDL_DETAILS")%></title>
     <link rel="stylesheet" type="text/css" href="<%=response.encodeURL(controller.getPathWithContext("css/windows.css"))%>">
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
 
     <%
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/forms/FavoritesWSILDetailsPage.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/forms/FavoritesWSILDetailsPage.jsp
index d0b1ead..6c0dcf4 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/forms/FavoritesWSILDetailsPage.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/forms/FavoritesWSILDetailsPage.jsp
@@ -32,7 +32,7 @@
     <title><%=favPerspective.getMessage("FORM_TITLE_WSIL_DETAILS")%></title>
     <link rel="stylesheet" type="text/css" href="<%=response.encodeURL(controller.getPathWithContext("css/windows.css"))%>">
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
 
     <%
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/views/ListFavoriteUDDIBusinessView.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/views/ListFavoriteUDDIBusinessView.jsp
index a20a9a6..f2d170a 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/views/ListFavoriteUDDIBusinessView.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/views/ListFavoriteUDDIBusinessView.jsp
@@ -39,7 +39,7 @@
     <jsp:include page="/favorites/scripts/favoritesFormSubmit.jsp" flush="true"/>
     <jsp:include page="/favorites/scripts/favoritesTable.jsp" flush="true"/>
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
 <%
    String titleImagePath = "wsil/images/list_business_highlighted.gif";
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/views/ListFavoriteUDDIRegistryView.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/views/ListFavoriteUDDIRegistryView.jsp
index 3d4d236..9841b59 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/views/ListFavoriteUDDIRegistryView.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/views/ListFavoriteUDDIRegistryView.jsp
@@ -39,7 +39,7 @@
     <jsp:include page="/favorites/scripts/favoritesFormSubmit.jsp" flush="true"/>
     <jsp:include page="/favorites/scripts/favoritesTable.jsp" flush="true"/>
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
     <%
     String titleImagePath = "favorites/images/list_registry_highlighted.gif";
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/views/ListFavoriteUDDIServiceInterfaceView.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/views/ListFavoriteUDDIServiceInterfaceView.jsp
index 8ef4a64..f73424b 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/views/ListFavoriteUDDIServiceInterfaceView.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/views/ListFavoriteUDDIServiceInterfaceView.jsp
@@ -39,7 +39,7 @@
     <jsp:include page="/favorites/scripts/favoritesFormSubmit.jsp" flush="true"/>
     <jsp:include page="/favorites/scripts/favoritesTable.jsp" flush="true"/>
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
     <%
     String titleImagePath = "favorites/images/list_service_interface_highlighted.gif";
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/views/ListFavoriteUDDIServiceView.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/views/ListFavoriteUDDIServiceView.jsp
index fd76174..54f5366 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/views/ListFavoriteUDDIServiceView.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/views/ListFavoriteUDDIServiceView.jsp
@@ -39,7 +39,7 @@
     <jsp:include page="/favorites/scripts/favoritesFormSubmit.jsp" flush="true"/>
     <jsp:include page="/favorites/scripts/favoritesTable.jsp" flush="true"/>
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
     <%
     String titleImagePath = "wsil/images/list_UDDI_service_highlighted.gif";
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/views/ListFavoriteWSDLServiceView.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/views/ListFavoriteWSDLServiceView.jsp
index 8d5b11f..fe51ac3 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/views/ListFavoriteWSDLServiceView.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/views/ListFavoriteWSDLServiceView.jsp
@@ -39,7 +39,7 @@
     <jsp:include page="/favorites/scripts/favoritesFormSubmit.jsp" flush="true"/>
     <jsp:include page="/favorites/scripts/favoritesTable.jsp" flush="true"/>
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
     <%
     String titleImagePath = "wsil/images/list_WSDL_service_highlighted.gif";
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/views/ListFavoriteWSILView.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/views/ListFavoriteWSILView.jsp
index d0798ca..0045124 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/views/ListFavoriteWSILView.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/favorites/views/ListFavoriteWSILView.jsp
@@ -39,7 +39,7 @@
     <jsp:include page="/favorites/scripts/favoritesFormSubmit.jsp" flush="true"/>
     <jsp:include page="/favorites/scripts/favoritesTable.jsp" flush="true"/>
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
     <%
     String titleImagePath = "favorites/images/list_WSIL_highlighted.gif";
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/forms/ImportToWorkbenchForm.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/forms/ImportToWorkbenchForm.jsp
index 6be8fc3..8ded419 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/forms/ImportToWorkbenchForm.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/forms/ImportToWorkbenchForm.jsp
@@ -26,7 +26,7 @@
 <jsp:include page="/scripts/formsubmit.jsp" flush="true"/>
 <jsp:include page="/scripts/formutils.jsp" flush="true"/>    
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
 
     <form action="<%=response.encodeURL(controller.getPathWithContext((String)formProperties.get("formActionLink")))%>" method="post" target="<%=FrameNames.PERSPECTIVE_WORKAREA%>" enctype="multipart/form-data">
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/forms/ImportWSDLAndWSILToWorkbenchForm.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/forms/ImportWSDLAndWSILToWorkbenchForm.jsp
index aa4c03e..2122afe 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/forms/ImportWSDLAndWSILToWorkbenchForm.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/forms/ImportWSDLAndWSILToWorkbenchForm.jsp
@@ -36,7 +36,7 @@
   <jsp:include page="/scripts/formsubmit.jsp" flush="true"/>
   <jsp:include page="/scripts/formutils.jsp" flush="true"/>
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
 
   <form action="<%=response.encodeURL(controller.getPathWithContext((String)formProperties.get("formActionLink")))%>" method="post" target="<%=FrameNames.PERSPECTIVE_WORKAREA%>" enctype="multipart/form-data">
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/forms/LaunchWebServiceWizardForm.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/forms/LaunchWebServiceWizardForm.jsp
index 773a0d1..7041318 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/forms/LaunchWebServiceWizardForm.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/forms/LaunchWebServiceWizardForm.jsp
@@ -24,7 +24,7 @@
 <jsp:include page="/scripts/formsubmit.jsp" flush="true"/>
 <jsp:include page="/scripts/formutils.jsp" flush="true"/>
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
   <form action="<%=response.encodeURL(controller.getPathWithContext(formActionLink.toString()))%>" method="post" target="<%=FrameNames.PERSPECTIVE_WORKAREA%>" enctype="multipart/form-data">
 
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/forms/ProxyLoadContent.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/forms/ProxyLoadContent.jsp
index d424366..918e570 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/forms/ProxyLoadContent.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/forms/ProxyLoadContent.jsp
@@ -56,7 +56,7 @@
   }
 </script>  
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
   <div id="contentborder">
     <table>
       <tr>
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/perspective_content.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/perspective_content.jsp
index 5bbadea..41f07ec 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/perspective_content.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/perspective_content.jsp
@@ -19,7 +19,7 @@
   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
   <title><%=controller.getMessage("FRAME_TITLE_PERSPECTIVE_CONTENT")%></title>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <jsp:include page="/scripts/panes.jsp" flush="true"/>
 <script language="javascript">
   perspectiveWorkArea.location="<%=response.encodeURL(controller.getPathWithContext(ShowPerspectiveAction.getActionLink(controller.getCurrentPerspective().getPerspectiveId(),false)))%>";
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/perspective_toolbar.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/perspective_toolbar.jsp
index 6684bb9..95dc0d3 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/perspective_toolbar.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/perspective_toolbar.jsp
@@ -41,7 +41,7 @@
     }
   </script>
 </head>
-<body class="gtoolbarbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="gtoolbarbodymargin">
 <div id="globaltoolbar">
 <table width="100%" cellpadding=3 cellspacing=0 border=0>
   <tr>
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/scripts/switchperspective.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/scripts/switchperspective.jsp
index 3fe6727..2a0fc38 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/scripts/switchperspective.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/scripts/switchperspective.jsp
@@ -20,7 +20,7 @@
   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <jsp:include page="/scripts/panes.jsp" flush="true"/>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <script language="javascript">
   perspectiveContent.location = "<%=response.encodeURL(controller.getPathWithContext(controller.getCurrentPerspective().getPerspectiveContentPage()))%>";
 </script>
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/AddItemsToFavoritesActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/AddItemsToFavoritesActionJSP.jsp
index 1d820c7..b679791 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/AddItemsToFavoritesActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/AddItemsToFavoritesActionJSP.jsp
@@ -31,7 +31,7 @@
 <head>
   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <script language="javascript">
   propertiesContent.location = "<%=response.encodeURL(controller.getPathWithContext("uddi/properties_content.jsp"))%>";
   statusContent.location = "<%=response.encodeURL(controller.getPathWithContext("uddi/status_content.jsp"))%>";
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/AddPublisherAssertionsActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/AddPublisherAssertionsActionJSP.jsp
index 9cca067..3dac339 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/AddPublisherAssertionsActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/AddPublisherAssertionsActionJSP.jsp
@@ -22,7 +22,7 @@
 <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/browserdetect.js"))%>">
 </script>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    // Prepare the action.
    AddPublisherAssertionsAction action = new AddPublisherAssertionsAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/AddToFavoritesActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/AddToFavoritesActionJSP.jsp
index bbd6530..0e0d1a5 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/AddToFavoritesActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/AddToFavoritesActionJSP.jsp
@@ -31,7 +31,7 @@
 <head>
   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <script language="javascript">
   propertiesContent.location = "<%=response.encodeURL(controller.getPathWithContext("uddi/properties_content.jsp"))%>";
   statusContent.location = "<%=response.encodeURL(controller.getPathWithContext("uddi/status_content.jsp"))%>";
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/BusPublishServiceAdvancedActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/BusPublishServiceAdvancedActionJSP.jsp
index dfbe503..5575220 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/BusPublishServiceAdvancedActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/BusPublishServiceAdvancedActionJSP.jsp
@@ -24,7 +24,7 @@
 </script>
 <jsp:include page="/uddi/scripts/uddipanes.jsp" flush="true"/>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    // Prepare the action
    BusPublishServiceAdvancedAction action = new BusPublishServiceAdvancedAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/BusPublishServiceSimpleActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/BusPublishServiceSimpleActionJSP.jsp
index f0f3d80..1070025 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/BusPublishServiceSimpleActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/BusPublishServiceSimpleActionJSP.jsp
@@ -24,7 +24,7 @@
 </script>
 <jsp:include page="/uddi/scripts/uddipanes.jsp" flush="true"/>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    // Prepare the action.
    BusPublishServiceSimpleAction action = new BusPublishServiceSimpleAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/CheckFavoriteExistsActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/CheckFavoriteExistsActionJSP.jsp
index e9f6ce3..4f033e5 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/CheckFavoriteExistsActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/CheckFavoriteExistsActionJSP.jsp
@@ -24,7 +24,7 @@
 <head>
   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <form action="<%=response.encodeURL(controller.getPathWithContext("uddi/actions/AddToFavoritesActionJSP.jsp"))%>" method="post" target="<%=FrameNames.PERSPECTIVE_WORKAREA%>">
 <%
 Enumeration paramNames = request.getParameterNames();
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/ClearNavigatorNodesActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/ClearNavigatorNodesActionJSP.jsp
index 0a6d173..5dbf188 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/ClearNavigatorNodesActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/ClearNavigatorNodesActionJSP.jsp
@@ -22,7 +22,7 @@
 <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/browserdetect.js"))%>">
 </script>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    // Prepare the action.
    ClearNavigatorNodesAction action = new ClearNavigatorNodesAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/CompletePublisherAssertionsActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/CompletePublisherAssertionsActionJSP.jsp
index 1576255..8904ba9 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/CompletePublisherAssertionsActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/CompletePublisherAssertionsActionJSP.jsp
@@ -22,7 +22,7 @@
 <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/browserdetect.js"))%>">
 </script>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    // Prepare the action.
    CompletePublisherAssertionsAction action = new CompletePublisherAssertionsAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/ManageReferencedServicesActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/ManageReferencedServicesActionJSP.jsp
index 50f7b41..a5d5553 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/ManageReferencedServicesActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/ManageReferencedServicesActionJSP.jsp
@@ -26,7 +26,7 @@
 </script>
 <jsp:include page="/uddi/scripts/uddipanes.jsp" flush="true"/>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    // Prepare the action.
    ManageReferencedServicesAction action = new ManageReferencedServicesAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/OpenRegistryActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/OpenRegistryActionJSP.jsp
index f6964fa..2472eb3 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/OpenRegistryActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/OpenRegistryActionJSP.jsp
@@ -22,7 +22,7 @@
 <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/browserdetect.js"))%>">
 </script>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    // Prepare the action.
 
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RefreshUDDINodeActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RefreshUDDINodeActionJSP.jsp
index 23832a4..303be50 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RefreshUDDINodeActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RefreshUDDINodeActionJSP.jsp
@@ -61,7 +61,7 @@
   }
 </script>    
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <form action="<%=response.encodeURL(controller.getPathWithContext("uddi/actions/ClearNavigatorNodesActionJSP.jsp"))%>" target="<%=FrameNames.PERSPECTIVE_WORKAREA%>" method="post" enctype="multipart/form-data">
 </form>
 <%
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RefreshUDDINodesActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RefreshUDDINodesActionJSP.jsp
index 4cc9f7e..e376294 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RefreshUDDINodesActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RefreshUDDINodesActionJSP.jsp
@@ -55,7 +55,7 @@
   }         
 </script>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <form action="<%=response.encodeURL(controller.getPathWithContext("uddi/actions/ClearNavigatorNodesActionJSP.jsp"))%>" target="<%=FrameNames.PERSPECTIVE_WORKAREA%>" method="post" enctype="multipart/form-data">
 </form>
 <script language="javascript">
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegFindBusinessUUIDActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegFindBusinessUUIDActionJSP.jsp
index 777a332..435459c 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegFindBusinessUUIDActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegFindBusinessUUIDActionJSP.jsp
@@ -24,7 +24,7 @@
 </script>
 <jsp:include page="/uddi/scripts/uddipanes.jsp" flush="true"/>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    // Prepare the action.
    RegFindBusinessUUIDAction action = new RegFindBusinessUUIDAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegFindBusinessesAdvancedActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegFindBusinessesAdvancedActionJSP.jsp
index 1ea61ee..e18b6b3 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegFindBusinessesAdvancedActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegFindBusinessesAdvancedActionJSP.jsp
@@ -26,7 +26,7 @@
 </script>
 <jsp:include page="/uddi/scripts/uddipanes.jsp" flush="true"/>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    // Prepare the action.
    RegFindBusinessesAdvancedAction action = new RegFindBusinessesAdvancedAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegFindBusinessesSimpleActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegFindBusinessesSimpleActionJSP.jsp
index f0465c1..d5716b0 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegFindBusinessesSimpleActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegFindBusinessesSimpleActionJSP.jsp
@@ -24,7 +24,7 @@
 </script>
 <jsp:include page="/uddi/scripts/uddipanes.jsp" flush="true"/>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    // Prepare the action.
    RegFindBusinessesSimpleAction action = new RegFindBusinessesSimpleAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegFindServiceInterfaceUUIDActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegFindServiceInterfaceUUIDActionJSP.jsp
index 9c4f339..2b44c9f 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegFindServiceInterfaceUUIDActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegFindServiceInterfaceUUIDActionJSP.jsp
@@ -24,7 +24,7 @@
 </script>
 <jsp:include page="/uddi/scripts/uddipanes.jsp" flush="true"/>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    // Prepare the action.
    RegFindServiceInterfaceUUIDAction action = new RegFindServiceInterfaceUUIDAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegFindServiceInterfacesAdvancedActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegFindServiceInterfacesAdvancedActionJSP.jsp
index 6dce414..16d324e 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegFindServiceInterfacesAdvancedActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegFindServiceInterfacesAdvancedActionJSP.jsp
@@ -24,7 +24,7 @@
 </script>
 <jsp:include page="/uddi/scripts/uddipanes.jsp" flush="true"/>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    // Prepare the action.
    RegFindServiceInterfacesAdvancedAction action = new RegFindServiceInterfacesAdvancedAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegFindServiceInterfacesSimpleActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegFindServiceInterfacesSimpleActionJSP.jsp
index 657817b..fcace6d 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegFindServiceInterfacesSimpleActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegFindServiceInterfacesSimpleActionJSP.jsp
@@ -24,7 +24,7 @@
 </script>
 <jsp:include page="/uddi/scripts/uddipanes.jsp" flush="true"/>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    // Prepare the action.
    RegFindServiceInterfacesSimpleAction action = new RegFindServiceInterfacesSimpleAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegFindServiceUUIDActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegFindServiceUUIDActionJSP.jsp
index 6ceefaf..5ca5e67 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegFindServiceUUIDActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegFindServiceUUIDActionJSP.jsp
@@ -24,7 +24,7 @@
 </script>
 <jsp:include page="/uddi/scripts/uddipanes.jsp" flush="true"/>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    // Prepare the action.
    RegFindServiceUUIDAction action = new RegFindServiceUUIDAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegFindServicesAdvancedActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegFindServicesAdvancedActionJSP.jsp
index 83931ca..9838de2 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegFindServicesAdvancedActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegFindServicesAdvancedActionJSP.jsp
@@ -26,7 +26,7 @@
 </script>
 <jsp:include page="/uddi/scripts/uddipanes.jsp" flush="true"/>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    // Prepare the action.
    RegFindServicesAdvancedAction action = new RegFindServicesAdvancedAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegFindServicesSimpleActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegFindServicesSimpleActionJSP.jsp
index 2074caf..62ad590 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegFindServicesSimpleActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegFindServicesSimpleActionJSP.jsp
@@ -24,7 +24,7 @@
 </script>
 <jsp:include page="/uddi/scripts/uddipanes.jsp" flush="true"/>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    // Prepare the action.
    RegFindServicesSimpleAction action = new RegFindServicesSimpleAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegPublishBusinessAdvancedActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegPublishBusinessAdvancedActionJSP.jsp
index b956daa..af639c1 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegPublishBusinessAdvancedActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegPublishBusinessAdvancedActionJSP.jsp
@@ -25,7 +25,7 @@
 </script>
 <jsp:include page="/uddi/scripts/uddipanes.jsp" flush="true"/>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    // Prepare the action.
    RegPublishBusinessAdvancedAction action = new RegPublishBusinessAdvancedAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegPublishBusinessSimpleActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegPublishBusinessSimpleActionJSP.jsp
index af0734e..6f012c6 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegPublishBusinessSimpleActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegPublishBusinessSimpleActionJSP.jsp
@@ -24,7 +24,7 @@
 </script>
 <jsp:include page="/uddi/scripts/uddipanes.jsp" flush="true"/>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    // Prepare the action.
    RegPublishBusinessSimpleAction action = new RegPublishBusinessSimpleAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegPublishServiceAdvancedActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegPublishServiceAdvancedActionJSP.jsp
index 8380505..f066ba7 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegPublishServiceAdvancedActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegPublishServiceAdvancedActionJSP.jsp
@@ -24,7 +24,7 @@
 </script>
 <jsp:include page="/uddi/scripts/uddipanes.jsp" flush="true"/>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    // Prepare the action.
    RegPublishServiceAdvancedAction action = new RegPublishServiceAdvancedAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegPublishServiceInterfaceAdvancedActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegPublishServiceInterfaceAdvancedActionJSP.jsp
index b1569cc..765275f 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegPublishServiceInterfaceAdvancedActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegPublishServiceInterfaceAdvancedActionJSP.jsp
@@ -24,7 +24,7 @@
 </script>
 <jsp:include page="/uddi/scripts/uddipanes.jsp" flush="true"/>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    // Prepare the action.
    RegPublishServiceInterfaceAdvancedAction action = new RegPublishServiceInterfaceAdvancedAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegPublishServiceInterfaceSimpleActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegPublishServiceInterfaceSimpleActionJSP.jsp
index c251da5..025dc57 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegPublishServiceInterfaceSimpleActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegPublishServiceInterfaceSimpleActionJSP.jsp
@@ -24,7 +24,7 @@
 </script>
 <jsp:include page="/uddi/scripts/uddipanes.jsp" flush="true"/>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    // Prepare the action.
    RegPublishServiceInterfaceSimpleAction action = new RegPublishServiceInterfaceSimpleAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegPublishServiceSimpleActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegPublishServiceSimpleActionJSP.jsp
index a2412bc..01b04f8 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegPublishServiceSimpleActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RegPublishServiceSimpleActionJSP.jsp
@@ -24,7 +24,7 @@
 </script>
 <jsp:include page="/uddi/scripts/uddipanes.jsp" flush="true"/>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    // Prepare the action.
    RegPublishServiceSimpleAction action = new RegPublishServiceSimpleAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RemovePublisherAssertionsActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RemovePublisherAssertionsActionJSP.jsp
index b6aa627..b66cefd 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RemovePublisherAssertionsActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RemovePublisherAssertionsActionJSP.jsp
@@ -22,7 +22,7 @@
 <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/browserdetect.js"))%>">
 </script>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    // Prepare the action.
    RemovePublisherAssertionsAction action = new RemovePublisherAssertionsAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RemoveSubQueryItemActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RemoveSubQueryItemActionJSP.jsp
index 50ae31f..d65f63f 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RemoveSubQueryItemActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/RemoveSubQueryItemActionJSP.jsp
@@ -23,7 +23,7 @@
   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <jsp:include page="/uddi/scripts/uddipanes.jsp" flush="true"/>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    // Prepare the action.
    RemoveSubQueryItemAction action = new RemoveSubQueryItemAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/ResizeUDDIFramesActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/ResizeUDDIFramesActionJSP.jsp
index c1e0f46..d272223 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/ResizeUDDIFramesActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/ResizeUDDIFramesActionJSP.jsp
@@ -28,7 +28,7 @@
 <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/browserdetect.js"))%>">
 </script>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    if (result)
    {
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/SelectCategoryNodeActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/SelectCategoryNodeActionJSP.jsp
index 78aa970..1b84f63 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/SelectCategoryNodeActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/SelectCategoryNodeActionJSP.jsp
@@ -72,6 +72,6 @@
   categoryBrowserWindow.opener.closeCategoryBrowser();
 </script>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 </body>
 </html>
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/SelectSubQueryItemActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/SelectSubQueryItemActionJSP.jsp
index 2596110..3600eeb 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/SelectSubQueryItemActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/SelectSubQueryItemActionJSP.jsp
@@ -31,7 +31,7 @@
   <meta http-equiv="Content-Type" content="text/html; UTF-8">
 <jsp:include page="/scripts/panes.jsp" flush="true"/>  
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <script language="javascript">
   if (confirm("<%=HTMLUtils.JSMangle(uddiPerspective.getMessage("MSG_QUESTION_ITEM_VALIDATION_FAILED",action.getItemName()))%>"))
     perspectiveWorkArea.location = "<%=response.encodeURL(controller.getPathWithContext(RemoveSubQueryItemAction.getActionLink(subQueryKey,subQueryListKey,subQueryListItemId)))%>";
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/ShowPublisherAssertionsActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/ShowPublisherAssertionsActionJSP.jsp
index 5acb1b3..e46d18e 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/ShowPublisherAssertionsActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/ShowPublisherAssertionsActionJSP.jsp
@@ -24,7 +24,7 @@
 <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/browserdetect.js"))%>">
 </script>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    // Prepare the action.
    ShowPublisherAssertionsAction action = new ShowPublisherAssertionsAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/ToggleCategoryNodeActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/ToggleCategoryNodeActionJSP.jsp
index 2ea0cf6..15753ae 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/ToggleCategoryNodeActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/ToggleCategoryNodeActionJSP.jsp
@@ -53,6 +53,6 @@
 %>
 </script>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 </body>
 </html>
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/TransferSubQueryResultsActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/TransferSubQueryResultsActionJSP.jsp
index 948ecd7..b6b2803 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/TransferSubQueryResultsActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/TransferSubQueryResultsActionJSP.jsp
@@ -20,7 +20,7 @@
   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <jsp:include page="/uddi/scripts/uddipanes.jsp" flush="true"/>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    TransferSubQueryResultsAction action = new TransferSubQueryResultsAction(controller);
 
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/TransferToAddCategoryDataActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/TransferToAddCategoryDataActionJSP.jsp
index 02396a1..4bd6353 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/TransferToAddCategoryDataActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/TransferToAddCategoryDataActionJSP.jsp
@@ -36,7 +36,7 @@
 </script>
 <jsp:include page="/uddi/scripts/uddipanes.jsp" flush="true"/>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <script language="javascript">
   perspectiveWorkArea.location = "<%=response.encodeURL(controller.getPathWithContext(SelectNavigatorNodeAction.getActionLink(regNode.getNodeId(),false)))%>";
 </script>
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/UDDIAddToWSDLPerspectiveActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/UDDIAddToWSDLPerspectiveActionJSP.jsp
index 3dd95fb..6484df4 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/UDDIAddToWSDLPerspectiveActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/UDDIAddToWSDLPerspectiveActionJSP.jsp
@@ -49,6 +49,6 @@
 <head>
   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 </body>
 </html>
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/UnpublishActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/UnpublishActionJSP.jsp
index 387471e..f0358e3 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/UnpublishActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/UnpublishActionJSP.jsp
@@ -22,7 +22,7 @@
 <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/browserdetect.js"))%>">
 </script>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    // Prepare the action.
    UnpublishAction action = new UnpublishAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/UpdateBusinessActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/UpdateBusinessActionJSP.jsp
index 371861c..0f47ab0 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/UpdateBusinessActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/UpdateBusinessActionJSP.jsp
@@ -27,7 +27,7 @@
 </script>
 <jsp:include page="/uddi/scripts/uddipanes.jsp" flush="true"/>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    // Prepare the action.
    UpdateBusinessAction action = new UpdateBusinessAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/UpdateNewPublishActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/UpdateNewPublishActionJSP.jsp
index de14719..4fa57ef 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/UpdateNewPublishActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/UpdateNewPublishActionJSP.jsp
@@ -21,7 +21,7 @@
 </script>
 <jsp:include page="/uddi/scripts/uddipanes.jsp" flush="true"/>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    UpdateAction action = (UpdateAction)session.getAttribute(UDDIActionInputs.PUBLISH_ACTION);
    session.removeAttribute(UDDIActionInputs.PUBLISH_ACTION);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/UpdateRegistryActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/UpdateRegistryActionJSP.jsp
index 0eca62a..4f7ebbd 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/UpdateRegistryActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/UpdateRegistryActionJSP.jsp
@@ -27,7 +27,7 @@
 </script>
 <jsp:include page="/uddi/scripts/uddipanes.jsp" flush="true"/>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    // Prepare the action.
    UpdateRegistryAction action = new UpdateRegistryAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/UpdateServiceActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/UpdateServiceActionJSP.jsp
index ef7afb6..5514f49 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/UpdateServiceActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/UpdateServiceActionJSP.jsp
@@ -27,7 +27,7 @@
 </script>
 <jsp:include page="/uddi/scripts/uddipanes.jsp" flush="true"/>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    // Prepare the action.
    UpdateServiceAction action = new UpdateServiceAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/UpdateServiceInterfaceActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/UpdateServiceInterfaceActionJSP.jsp
index 3345e2a..4618bc8 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/UpdateServiceInterfaceActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/UpdateServiceInterfaceActionJSP.jsp
@@ -27,7 +27,7 @@
 </script>
 <jsp:include page="/uddi/scripts/uddipanes.jsp" flush="true"/>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    // Prepare the action.
    UpdateServiceInterfaceAction action = new UpdateServiceInterfaceAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/UpdateServiceNewPublishBusinessActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/UpdateServiceNewPublishBusinessActionJSP.jsp
index 64e37cf..cad4e1d 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/UpdateServiceNewPublishBusinessActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/actions/UpdateServiceNewPublishBusinessActionJSP.jsp
@@ -22,7 +22,7 @@
 </script>
 <jsp:include page="/uddi/scripts/uddipanes.jsp" flush="true"/>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    UpdateServiceAction action = (UpdateServiceAction)session.getAttribute(UDDIActionInputs.PUBLISH_ACTION);
    session.removeAttribute(UDDIActionInputs.PUBLISH_ACTION);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/category_content.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/category_content.jsp
index e3d7f1c..076b7cf 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/category_content.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/category_content.jsp
@@ -42,7 +42,7 @@
   }  
 </script>
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <%   
    // Check if the category is a common category.
    CategoryModel categoryModel = (CategoryModel)commonCategoryModels.get(categoryTModelKey);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/category_toolbar.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/category_toolbar.jsp
index 07dde77..a5e6b49 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/category_toolbar.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/category_toolbar.jsp
@@ -26,7 +26,7 @@
   <title><%=uddiPerspective.getMessage("FRAME_TITLE_CATEGORIES_TOOLBAR")%></title>
   <link rel="stylesheet" type="text/css" href="<%=response.encodeURL(controller.getPathWithContext("css/toolbar.css"))%>">
 </head>
-<body class="toolbarbodymargin" onUnload="top.opener.categoryWindowClosed=true">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="toolbarbodymargin" onUnload="top.opener.categoryWindowClosed=true">
 <div id="toolbarborder">
   <div id="toolbar">
     <table width="100%" height=25 cellpadding=0 cellspacing=0 border=0>
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/BusPublishServiceForm.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/BusPublishServiceForm.jsp
index c23ce7b..57121d3 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/BusPublishServiceForm.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/BusPublishServiceForm.jsp
@@ -218,7 +218,7 @@
   }
 </script>
 </head>
-<body class="contentbodymargin" onUnload="closeAllUddiChildWindows()">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin" onUnload="closeAllUddiChildWindows()">
   <div id="contentborder">
     <table id="loadScreen">
       <tr>
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/BusinessDetailsForm.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/BusinessDetailsForm.jsp
index 79bb31c..5327070 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/BusinessDetailsForm.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/BusinessDetailsForm.jsp
@@ -200,7 +200,7 @@
   }
 </script>
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
   <div id="contentborder">
     <form action="<%=response.encodeURL(controller.getPathWithContext("uddi/actions/UpdateBusinessActionJSP.jsp"))%>" method="post" target="<%=FrameNames.PERSPECTIVE_WORKAREA%>" enctype="multipart/form-data" onSubmit="return processForm(this)">
       <table id="loadScreen">
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/GetForm.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/GetForm.jsp
index 5dfbbd7..b372f60 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/GetForm.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/GetForm.jsp
@@ -152,7 +152,7 @@
   }
 </script>
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
 <div id="content">
   <table id="loadScreen">
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/ItemsSummaryForm.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/ItemsSummaryForm.jsp
index ba4802a..07b3b62 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/ItemsSummaryForm.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/ItemsSummaryForm.jsp
@@ -137,7 +137,7 @@
   }
 </script>
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
 <div id="content">
   <table id="loadScreen">
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/ManagePublisherAssertionsForm.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/ManagePublisherAssertionsForm.jsp
index 7fdc17b..f67f782 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/ManagePublisherAssertionsForm.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/ManagePublisherAssertionsForm.jsp
@@ -306,7 +306,7 @@
 
 </script>
 </head>
-<body class="contentbodymargin" onUnload="closeAllUddiChildWindows()">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin" onUnload="closeAllUddiChildWindows()">
   <div id="contentborder">
     <div id="publisherAssertions">
       <form action="<%=response.encodeURL(controller.getPathWithContext("uddi/actions/ShowPublisherAssertionsActionJSP.jsp"))%>" method="post" target="<%=FrameNames.PERSPECTIVE_WORKAREA%>" enctype="multipart/form-data">
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/ManageReferencedServicesForm.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/ManageReferencedServicesForm.jsp
index d5dbfd3..bafda37 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/ManageReferencedServicesForm.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/ManageReferencedServicesForm.jsp
@@ -169,7 +169,7 @@
   }
 </script>
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
   <div id="contentborder">
     <div id="manageReferencedServices">
 <%
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/OpenRegistryForm.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/OpenRegistryForm.jsp
index e3216b3..471ea49 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/OpenRegistryForm.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/OpenRegistryForm.jsp
@@ -95,7 +95,7 @@
     }
   </script>
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
   <div id="contentborder">
     <table id="loadScreen">
       <tr>
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/RegDetailsForm.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/RegDetailsForm.jsp
index dc93a70..efaf642 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/RegDetailsForm.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/RegDetailsForm.jsp
@@ -124,7 +124,7 @@
   }
 </script>
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
   <div id="contentborder">
     <form action="<%=response.encodeURL(controller.getPathWithContext("uddi/actions/UpdateRegistryActionJSP.jsp"))%>" method="post" target="<%=FrameNames.PERSPECTIVE_WORKAREA%>" enctype="multipart/form-data" onSubmit="return processForm(this)">
       <table id="loadScreen">
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/RegFindForm.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/RegFindForm.jsp
index a3cf1c0..cf1523a 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/RegFindForm.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/RegFindForm.jsp
@@ -624,7 +624,7 @@
   }
 </script>
 </head>
-<body class="contentbodymargin" onUnload="closeAllUddiChildWindows()">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin" onUnload="closeAllUddiChildWindows()">
   <div id="contentborder">
     <table id="loadScreen">
       <tr>
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/RegPublishForm.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/RegPublishForm.jsp
index fe04c89..e9f1c03 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/RegPublishForm.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/RegPublishForm.jsp
@@ -541,7 +541,7 @@
   }
 </script>
 </head>
-<body class="contentbodymargin" onUnload="closeAllUddiChildWindows()">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin" onUnload="closeAllUddiChildWindows()">
   <div id="contentborder">
     <table id="loadScreen">
       <tr>
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/ResultsForm.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/ResultsForm.jsp
index 638d3b6..4df0217 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/ResultsForm.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/ResultsForm.jsp
@@ -102,7 +102,7 @@
   }
 </script>
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
 <div id="content">
   <table id="loadScreen">
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/ServiceDetailsForm.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/ServiceDetailsForm.jsp
index 7c1dd94..8efc51b 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/ServiceDetailsForm.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/ServiceDetailsForm.jsp
@@ -190,7 +190,7 @@
   }
 </script>
 </head>
-<body class="contentbodymargin" onUnload="closeAllUddiChildWindows()">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin" onUnload="closeAllUddiChildWindows()">
   <div id="contentborder">
     <form action="<%=response.encodeURL(controller.getPathWithContext("uddi/actions/UpdateServiceActionJSP.jsp"))%>" method="post" target="<%=FrameNames.PERSPECTIVE_WORKAREA%>" enctype="multipart/form-data" onSubmit="return processForm(this)">
       <table id="loadScreen">
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/ServiceInterfaceDetailsForm.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/ServiceInterfaceDetailsForm.jsp
index 7eb6702..31e38c0 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/ServiceInterfaceDetailsForm.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/ServiceInterfaceDetailsForm.jsp
@@ -201,7 +201,7 @@
   }   
 </script>  
 </head>
-<body class="contentbodymargin" onUnload="closeAllUddiChildWindows()">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin" onUnload="closeAllUddiChildWindows()">
   <div id="contentborder">
     <form action="<%=response.encodeURL(controller.getPathWithContext("uddi/actions/UpdateServiceInterfaceActionJSP.jsp"))%>" method="post" target="<%=FrameNames.PERSPECTIVE_WORKAREA%>" enctype="multipart/form-data" onSubmit="return processForm(this)">  
       <table id="loadScreen">
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/UnpublishForm.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/UnpublishForm.jsp
index 36302d7..cd1db2c 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/UnpublishForm.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/forms/UnpublishForm.jsp
@@ -61,7 +61,7 @@
   }
 </script>
 </head>
-<body class="contentbodymargin" onUnload="closeAllUddiChildWindows()">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin" onUnload="closeAllUddiChildWindows()">
   <div id="contentborder">
     <form action="<%=response.encodeURL(controller.getPathWithContext("uddi/actions/UnpublishActionJSP.jsp"))%>" method="post" target="<%=FrameNames.PERSPECTIVE_WORKAREA%>" enctype="multipart/form-data" onSubmit="return handleSubmit(this)">
 <%
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/navigator_content.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/navigator_content.jsp
index 9aa193b..a472951 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/navigator_content.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/navigator_content.jsp
@@ -42,7 +42,7 @@
        focusedAnchorName = selectedAnchorName;
    }
 %>
-<body onLoad="self.location.hash='#<%=focusedAnchorName%>';setSelectedAnchorName('<%=selectedAnchorName%>')" class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" onLoad="self.location.hash='#<%=focusedAnchorName%>';setSelectedAnchorName('<%=selectedAnchorName%>')" class="contentbodymargin">
 <div id="treecontentborder">
 <%=navigatorManager.renderTreeView(response)%>
 </div>
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/navigator_toolbar.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/navigator_toolbar.jsp
index 3c6ec03..41974bb 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/navigator_toolbar.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/navigator_toolbar.jsp
@@ -27,7 +27,7 @@
 <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/toolbar.js"))%>">
 </script>
 </head>
-<body class="toolbarbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="toolbarbodymargin">
 <div id="toolbarborder">
   <div id="toolbar" ondblclick="processFramesetSizes(document.forms[0])">
 <jsp:useBean id="formAction" class="java.lang.StringBuffer" scope="request">
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/properties_content.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/properties_content.jsp
index aef15b0..5023787 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/properties_content.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/properties_content.jsp
@@ -24,7 +24,7 @@
   <title><%=uddiPerspective.getMessage("FRAME_TITLE_PROPERTIES_CONTENT")%></title>
   <link rel="stylesheet" type="text/css" href="<%=response.encodeURL(controller.getPathWithContext("css/windows.css"))%>">
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
 <%
    NodeManager navigatorManager = uddiPerspective.getNavigatorManager();
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/properties_toolbar.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/properties_toolbar.jsp
index 90047a4..7939ad1 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/properties_toolbar.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/properties_toolbar.jsp
@@ -29,7 +29,7 @@
 <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/toolbar.js"))%>">
 </script>
 </head>
-<body class="toolbarbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="toolbarbodymargin">
 <div id="toolbarborder">
   <div id="toolbar" ondblclick="processFramesetSizes(document.forms[0])">
 <jsp:useBean id="formAction" class="java.lang.StringBuffer" scope="request">
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/status_content.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/status_content.jsp
index c6888f5..57a5a33 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/status_content.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/status_content.jsp
@@ -22,7 +22,7 @@
   <title><%=uddiPerspective.getMessage("FRAME_TITLE_STATUS_CONTENT")%></title>
   <link rel="stylesheet" type="text/css" href="<%=response.encodeURL(controller.getPathWithContext("css/windows.css"))%>">
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
   <table>
     <tr>
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/status_toolbar.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/status_toolbar.jsp
index 50ea597..a383f8c 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/status_toolbar.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/status_toolbar.jsp
@@ -26,7 +26,7 @@
 <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/toolbar.js"))%>">
 </script>
 </head>
-<body class="toolbarbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="toolbarbodymargin">
 <div id="toolbarborder">
   <div id="toolbar" ondblclick="processFramesetSizes(document.forms[0])">
 <jsp:useBean id="formAction" class="java.lang.StringBuffer" scope="request">
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/uddi_perspective_content.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/uddi_perspective_content.jsp
index 4f81853..8661bdf 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/uddi_perspective_content.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/uddi/uddi_perspective_content.jsp
@@ -23,6 +23,20 @@
   <title><%=uddiPerspective.getMessage("FRAME_TITLE_UDDI_PERSPECTIVE_CONTENT")%></title>
 </head>
 <frameset cols="<%=uddiPerspective.getPerspectiveContentFramesetCols()%>" bgcolor=#ECE9D8>
+  <%
+  if (org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.isRTL())
+  {
+  %>
+  <frame name="<%=UDDIFrameNames.ACTIONS_CONTAINER%>" title="<%=uddiPerspective.getMessage("FRAME_TITLE_ACTIONS_CONTAINER")%>" src="<%=response.encodeURL(controller.getPathWithContext("uddi/actions_container.jsp"))%>" marginwidth=0 marginheight=0 scrolling="no" frameborder=1>
+  <frame name="<%=UDDIFrameNames.NAVIGATOR_CONTAINER%>" title="<%=uddiPerspective.getMessage("FRAME_TITLE_NAVIGATOR_CONTAINER")%>" src="<%=response.encodeURL(controller.getPathWithContext("uddi/navigator_container.jsp"))%>" marginwidth=0 marginheight=0 scrolling="no" frameborder=1>
+  <%
+  }
+  else
+  {
+  %>
   <frame name="<%=UDDIFrameNames.NAVIGATOR_CONTAINER%>" title="<%=uddiPerspective.getMessage("FRAME_TITLE_NAVIGATOR_CONTAINER")%>" src="<%=response.encodeURL(controller.getPathWithContext("uddi/navigator_container.jsp"))%>" marginwidth=0 marginheight=0 scrolling="no" frameborder=1>
   <frame name="<%=UDDIFrameNames.ACTIONS_CONTAINER%>" title="<%=uddiPerspective.getMessage("FRAME_TITLE_ACTIONS_CONTAINER")%>" src="<%=response.encodeURL(controller.getPathWithContext("uddi/actions_container.jsp"))%>" marginwidth=0 marginheight=0 scrolling="no" frameborder=1>
+  <%
+  }
+  %>
 </frameset>
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/CreateInstanceActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/CreateInstanceActionJSP.jsp
index 122c59d..678eeb2 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/CreateInstanceActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/CreateInstanceActionJSP.jsp
@@ -21,7 +21,7 @@
 <head>
   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
   <%
   CreateInstanceAction action = new CreateInstanceAction(controller);
   action.populatePropertyTable(request);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/InvokeWSDLHttpGetOperationFormActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/InvokeWSDLHttpGetOperationFormActionJSP.jsp
index 1e2011a..449c9ef 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/InvokeWSDLHttpGetOperationFormActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/InvokeWSDLHttpGetOperationFormActionJSP.jsp
@@ -21,7 +21,7 @@
 <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/browserdetect.js"))%>">
 </script>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
   <%
   // Prepare the action.
   InvokeWSDLHttpGetOperationFormAction action = new InvokeWSDLHttpGetOperationFormAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/InvokeWSDLHttpPostOperationFormActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/InvokeWSDLHttpPostOperationFormActionJSP.jsp
index 474f53e..d3f4e52 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/InvokeWSDLHttpPostOperationFormActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/InvokeWSDLHttpPostOperationFormActionJSP.jsp
@@ -21,7 +21,7 @@
 <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/browserdetect.js"))%>">
 </script>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
   <%
   // Prepare the action.
   InvokeWSDLHttpPostOperationFormAction action = new InvokeWSDLHttpPostOperationFormAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/InvokeWSDLSOAPOperationFormActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/InvokeWSDLSOAPOperationFormActionJSP.jsp
index ff35430..b44fe04 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/InvokeWSDLSOAPOperationFormActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/InvokeWSDLSOAPOperationFormActionJSP.jsp
@@ -52,7 +52,7 @@
       <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
       <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/browserdetect.js"))%>"></script>
     </head>
-    <body>
+    <body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
       <script language="javascript">
         wsdlPropertiesContent.location = "<%=response.encodeURL(controller.getPathWithContext("wsdl/wsdl_properties_content.jsp"))%>";
         wsdlStatusContent.location = "<%=response.encodeURL(controller.getPathWithContext("wsdl/wsdl_status_content.jsp"))%>";
@@ -74,7 +74,7 @@
         <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
         <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/browserdetect.js"))%>"></script>
       </head>
-      <body>
+      <body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
         <script language="javascript">
           wsdlPropertiesContainer.location = "<%=response.encodeURL(controller.getPathWithContext("wsdl/wsdl_properties_container.jsp"))%>";
           <%
@@ -124,7 +124,7 @@
             <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
             <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/browserdetect.js"))%>"></script>
           </head>
-          <body>
+          <body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
             <script language="javascript">
               wsdlPropertiesContent.location = "<%=response.encodeURL(controller.getPathWithContext("wsdl/wsdl_properties_content.jsp"))%>";
               wsdlStatusContent.location = "<%=response.encodeURL(controller.getPathWithContext("wsdl/wsdl_status_content.jsp"))%>";
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/InvokeWSDLSOAPOperationSourceActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/InvokeWSDLSOAPOperationSourceActionJSP.jsp
index 554f871..a907688 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/InvokeWSDLSOAPOperationSourceActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/InvokeWSDLSOAPOperationSourceActionJSP.jsp
@@ -48,7 +48,7 @@
         <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
         <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/browserdetect.js"))%>"></script>
       </head>
-      <body>
+      <body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
         <script language="javascript">
           wsdlPropertiesContent.location = "<%=response.encodeURL(controller.getPathWithContext("wsdl/wsdl_properties_content.jsp"))%>";
           wsdlStatusContent.location = "<%=response.encodeURL(controller.getPathWithContext("wsdl/wsdl_status_content.jsp"))%>";
@@ -68,7 +68,7 @@
           <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
           <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/browserdetect.js"))%>"></script>
         </head>
-        <body>
+        <body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
           <script language="javascript">
             wsdlPropertiesContent.location = "<%=response.encodeURL(controller.getPathWithContext("wsdl/wsdl_properties_content.jsp"))%>";
             wsdlStatusContent.location = "<%=response.encodeURL(controller.getPathWithContext("wsdl/wsdl_status_content.jsp"))%>";
@@ -106,7 +106,7 @@
             <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
             <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/browserdetect.js"))%>"></script>
           </head>
-          <body>
+          <body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
             <script language="javascript">
               wsdlPropertiesContainer.location = "<%=response.encodeURL(controller.getPathWithContext("wsdl/wsdl_properties_container.jsp"))%>";
               <%
@@ -156,7 +156,7 @@
               <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
               <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/browserdetect.js"))%>"></script>
             </head>
-            <body>
+            <body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
               <script language="javascript">
                 wsdlPropertiesContainer.location = "<%=response.encodeURL(controller.getPathWithContext("wsdl/wsdl_properties_container.jsp"))%>";
                 wsdlStatusContent.location = "<%=response.encodeURL(controller.getPathWithContext("wsdl/wsdl_status_content.jsp"))%>";
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/OpenWSDLActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/OpenWSDLActionJSP.jsp
index 4ccda4a..b23ad77 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/OpenWSDLActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/OpenWSDLActionJSP.jsp
@@ -22,7 +22,7 @@
   <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/browserdetect.js"))%>">
   </script>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
   // Prepare the action.
   OpenWSDLAction action = new OpenWSDLAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/RefreshWSDLActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/RefreshWSDLActionJSP.jsp
index 34c6df8..81fc7f7 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/RefreshWSDLActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/RefreshWSDLActionJSP.jsp
@@ -68,6 +68,6 @@
 }
 %>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 </body>
 </html>
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/ResizeWSDLFramesActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/ResizeWSDLFramesActionJSP.jsp
index 1be8de4..1fbaf5b 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/ResizeWSDLFramesActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/ResizeWSDLFramesActionJSP.jsp
@@ -28,7 +28,7 @@
 <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/browserdetect.js"))%>">
 </script>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    if (result)
    {
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/SwitchReadOnlyFragmentViewsActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/SwitchReadOnlyFragmentViewsActionJSP.jsp
index 085097e..11d64a0 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/SwitchReadOnlyFragmentViewsActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/SwitchReadOnlyFragmentViewsActionJSP.jsp
@@ -32,6 +32,6 @@
 <head>
   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 </body>
 </html>
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/SwitchWSDLDetailsViewsActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/SwitchWSDLDetailsViewsActionJSP.jsp
index 087df01..46138b2 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/SwitchWSDLDetailsViewsActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/SwitchWSDLDetailsViewsActionJSP.jsp
@@ -32,6 +32,6 @@
 <head>
   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 </body>
 </html>
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/SynchronizeFragmentViewsActionAbortJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/SynchronizeFragmentViewsActionAbortJSP.jsp
index e0091a4..6911ceb 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/SynchronizeFragmentViewsActionAbortJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/SynchronizeFragmentViewsActionAbortJSP.jsp
@@ -33,6 +33,6 @@
 <head>
   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 </body>
 </html>
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/SynchronizeFragmentViewsActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/SynchronizeFragmentViewsActionJSP.jsp
index ae5267f..dca68ff 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/SynchronizeFragmentViewsActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/SynchronizeFragmentViewsActionJSP.jsp
@@ -51,6 +51,6 @@
 <head>
   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 </body>
 </html>
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/UpdateWSDLBindingActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/UpdateWSDLBindingActionJSP.jsp
index dee5274..11b1a24 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/UpdateWSDLBindingActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/UpdateWSDLBindingActionJSP.jsp
@@ -20,7 +20,7 @@
 <head>
   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
   UpdateWSDLBindingAction action = new UpdateWSDLBindingAction(controller);
   action.populatePropertyTable(request);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/WSDLAddToFavoritesActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/WSDLAddToFavoritesActionJSP.jsp
index 215adb9..fb8c8d1 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/WSDLAddToFavoritesActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/WSDLAddToFavoritesActionJSP.jsp
@@ -31,7 +31,7 @@
 <head>
   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <script language="javascript">
   wsdlPropertiesContent.location = "<%=response.encodeURL(controller.getPathWithContext("wsdl/wsdl_properties_content.jsp"))%>";
   wsdlStatusContent.location = "<%=response.encodeURL(controller.getPathWithContext("wsdl/wsdl_status_content.jsp"))%>";
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/WSDLCheckFavoriteExistsActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/WSDLCheckFavoriteExistsActionJSP.jsp
index be1f15f..b83258b 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/WSDLCheckFavoriteExistsActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/actions/WSDLCheckFavoriteExistsActionJSP.jsp
@@ -24,7 +24,7 @@
 <head>
   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <form action="<%=response.encodeURL(controller.getPathWithContext("wsdl/actions/WSDLAddToFavoritesActionJSP.jsp"))%>" method="post" target="<%=FrameNames.PERSPECTIVE_WORKAREA%>">
 <%
 Enumeration paramNames = request.getParameterNames();
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/forms/InvokeWSDLOperationForm.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/forms/InvokeWSDLOperationForm.jsp
index 73f720f..938de26 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/forms/InvokeWSDLOperationForm.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/forms/InvokeWSDLOperationForm.jsp
@@ -59,7 +59,7 @@
   }
 </script>
 </head>
-<body class="contentbodymargin" onUnload="closeChildWindows()">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin" onUnload="closeChildWindows()">
 <div id="contentborder">
   <form action="<%=invokeWSDLOperationURL%>" method="post" target="<%=FrameNames.PERSPECTIVE_WORKAREA%>" enctype="multipart/form-data">
     <input type="hidden" name="<%=WSDLActionInputs.SUBMISSION_ACTION%>" value="<%=WSDLActionInputs.SUBMISSION_ACTION_FORM%>">
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/forms/OpenWSDLForm.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/forms/OpenWSDLForm.jsp
index f4cd850..1b0a057 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/forms/OpenWSDLForm.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/forms/OpenWSDLForm.jsp
@@ -30,7 +30,7 @@
 <jsp:include page="/scripts/formutils.jsp" flush="true"/>
 <jsp:include page="/scripts/wsdlbrowser.jsp" flush="true"/>
 </head>
-<body class="contentbodymargin" onUnload="closeWSDLBrowser()">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin" onUnload="closeWSDLBrowser()">
 <div id="contentborder">
   <form action="<%=response.encodeURL(controller.getPathWithContext("wsdl/actions/OpenWSDLActionJSP.jsp"))%>" method="post" target="<%=FrameNames.PERSPECTIVE_WORKAREA%>" enctype="multipart/form-data" onSubmit="return handleSubmit(this)">
     <%
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/forms/WSDLBindingDetailsForm.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/forms/WSDLBindingDetailsForm.jsp
index b1abdd7..8647191 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/forms/WSDLBindingDetailsForm.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/forms/WSDLBindingDetailsForm.jsp
@@ -37,7 +37,7 @@
 <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/browserdetect.js"))%>">
 </script>
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
 <form action="<%=response.encodeURL(controller.getPathWithContext("wsdl/actions/UpdateWSDLBindingActionJSP.jsp"))%>" method="post" target="<%=FrameNames.PERSPECTIVE_WORKAREA%>" enctype="multipart/form-data" onSubmit="return handleSubmit(this)">
 <%
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/forms/WSDLDetailsForm.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/forms/WSDLDetailsForm.jsp
index 1b9ff13..eead075 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/forms/WSDLDetailsForm.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/forms/WSDLDetailsForm.jsp
@@ -39,7 +39,7 @@
   }
 </script>
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
 <%
    String titleImagePath = "wsdl/images/open_wsdl_highlighted.gif";
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/forms/WSDLServiceDetailsForm.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/forms/WSDLServiceDetailsForm.jsp
index 2ece390..4e24cc8 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/forms/WSDLServiceDetailsForm.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/forms/WSDLServiceDetailsForm.jsp
@@ -29,7 +29,7 @@
   <link rel="stylesheet" type="text/css" href="<%=response.encodeURL(controller.getPathWithContext("css/windows.css"))%>">
 <jsp:include page="/scripts/tables.jsp" flush="true"/>
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
 <%
    String titleImagePath = "wsdl/images/open_wsdl_highlighted.gif";
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/fragment/XSDDefaultRFragmentXML.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/fragment/XSDDefaultRFragmentXML.jsp
index a5a0138..6a90818 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/fragment/XSDDefaultRFragmentXML.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/fragment/XSDDefaultRFragmentXML.jsp
@@ -74,7 +74,7 @@
   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
   <title><%=frag.getName()%></title>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
   sb = new StringBuffer();
   response.setContentType("text/html; charset=UTF-8");
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/fragment/XSDInfo_content.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/fragment/XSDInfo_content.jsp
index e08f889..81ed2ac 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/fragment/XSDInfo_content.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/fragment/XSDInfo_content.jsp
@@ -39,7 +39,7 @@
   <title><%=wsdlPerspective.getMessage("FRAME_TITLE_XSD_INFORMATION_CONTENT")%></title>
   <link rel="stylesheet" type="text/css" href="<%=response.encodeURL(controller.getPathWithContext("css/windows.css"))%>">
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
 <jsp:include page="<%=frag.getInformationFragment()%>" flush="true"/>
 </div>
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/fragment/XSDInfo_toolbar.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/fragment/XSDInfo_toolbar.jsp
index 30e74db..85a008f 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/fragment/XSDInfo_toolbar.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/fragment/XSDInfo_toolbar.jsp
@@ -32,7 +32,7 @@
   <title><%=wsdlPerspective.getMessage("FRAME_TITLE_XSD_INFORMATION_TOOLBAR")%></title>
   <link rel="stylesheet" type="text/css" href="<%=response.encodeURL(controller.getPathWithContext("css/toolbar.css"))%>">
 </head>
-<body onUnload="top.opener.xsdInfoDialogClosed=true" class="toolbarbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" onUnload="top.opener.xsdInfoDialogClosed=true" class="toolbarbodymargin">
 <div id="toolbarborder">
   <div id="toolbar">
     <table width="100%" height=25 cellpadding=0 cellspacing=0 border=0>
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/wsdl_navigator_content.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/wsdl_navigator_content.jsp
index 41cd80d..7b47e4d 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/wsdl_navigator_content.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/wsdl_navigator_content.jsp
@@ -41,7 +41,7 @@
             focusedAnchorName = selectedAnchorName;
     }
 %>
-<body onLoad="self.location.hash='#<%=focusedAnchorName%>';setSelectedAnchorName('<%=selectedAnchorName%>')" class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" onLoad="self.location.hash='#<%=focusedAnchorName%>';setSelectedAnchorName('<%=selectedAnchorName%>')" class="contentbodymargin">
     <div id="treecontentborder">
         <%=nodeManager.renderTreeView(response)%>
     </div>
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/wsdl_navigator_toolbar.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/wsdl_navigator_toolbar.jsp
index 54b7056..afc523c 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/wsdl_navigator_toolbar.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/wsdl_navigator_toolbar.jsp
@@ -27,7 +27,7 @@
 <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/toolbar.js"))%>">
 </script>  
 </head>
-<body class="toolbarbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="toolbarbodymargin">
 <div id="toolbarborder">
   <div id="toolbar" ondblclick="processFramesetSizes(document.forms[0])">
 <jsp:useBean id="formAction" class="java.lang.StringBuffer" scope="request">
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/wsdl_perspective_content.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/wsdl_perspective_content.jsp
index ad0a98a..aab86c9 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/wsdl_perspective_content.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/wsdl_perspective_content.jsp
@@ -22,7 +22,21 @@
   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 </head>
 <frameset cols="<%=wsdlPerspective.getPerspectiveContentFramesetCols()%>" bgcolor="#ECE9D8">
+  <%
+  if (org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.isRTL())
+  {
+  %>
+  <frame name="<%=WSDLFrameNames.WSDL_ACTIONS_CONTAINER%>" title="<%=wsdlPerspective.getMessage("FRAME_TITLE_ACTIONS_CONTAINER")%>" src="<%=response.encodeURL("wsdl_actions_container.jsp")%>" marginwidth=0 marginheight=0 scrolling="no" frameborder=1>
+  <frame name="<%=WSDLFrameNames.WSDL_NAVIGATOR_CONTAINER%>" title="<%=wsdlPerspective.getMessage("FRAME_TITLE_NAVIGATOR_CONTAINER")%>" src="<%=response.encodeURL("wsdl_navigator_container.jsp")%>" marginwidth=0 marginheight=0 scrolling="no" frameborder=1>
+  <%
+  }
+  else
+  {
+  %>
   <frame name="<%=WSDLFrameNames.WSDL_NAVIGATOR_CONTAINER%>" title="<%=wsdlPerspective.getMessage("FRAME_TITLE_NAVIGATOR_CONTAINER")%>" src="<%=response.encodeURL("wsdl_navigator_container.jsp")%>" marginwidth=0 marginheight=0 scrolling="no" frameborder=1>
   <frame name="<%=WSDLFrameNames.WSDL_ACTIONS_CONTAINER%>" title="<%=wsdlPerspective.getMessage("FRAME_TITLE_ACTIONS_CONTAINER")%>" src="<%=response.encodeURL("wsdl_actions_container.jsp")%>" marginwidth=0 marginheight=0 scrolling="no" frameborder=1>
+  <%
+  }
+  %>
 </frameset>
 </html>
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/wsdl_properties_content.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/wsdl_properties_content.jsp
index 8fb2575..876e36d 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/wsdl_properties_content.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/wsdl_properties_content.jsp
@@ -24,7 +24,7 @@
   <title><%=wsdlPerspective.getMessage("FRAME_TITLE_PROPERTIES_CONTENT")%></title>
   <link rel="stylesheet" type="text/css" href="<%=response.encodeURL(controller.getPathWithContext("css/windows.css"))%>">
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
 <%
     NodeManager nodeManager = wsdlPerspective.getNodeManager();
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/wsdl_properties_toolbar.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/wsdl_properties_toolbar.jsp
index f321d52..d882c30 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/wsdl_properties_toolbar.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/wsdl_properties_toolbar.jsp
@@ -28,7 +28,7 @@
 <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/toolbar.js"))%>">
 </script>
 </head>
-<body class="toolbarbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="toolbarbodymargin">
 <div id="toolbarborder">
   <div id="toolbar" ondblclick="processFramesetSizes(document.forms[0])">
 <jsp:useBean id="formAction" class="java.lang.StringBuffer" scope="request">
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/wsdl_result_content.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/wsdl_result_content.jsp
index 15630e8..74e79f6 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/wsdl_result_content.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/wsdl_result_content.jsp
@@ -31,7 +31,7 @@
   }
 </script>
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
   <table width="95%" border=0 cellpadding=3 cellspacing=0>
     <tr>
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/wsdl_status_content.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/wsdl_status_content.jsp
index 043e765..95ba86f 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/wsdl_status_content.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/wsdl_status_content.jsp
@@ -23,7 +23,7 @@
   <title><%=wsdlPerspective.getMessage("FRAME_TITLE_STATUS_CONTENT")%></title>
   <link rel="stylesheet" type="text/css" href="<%=response.encodeURL(controller.getPathWithContext("css/windows.css"))%>">
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
   <table>
     <tr>
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/wsdl_status_toolbar.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/wsdl_status_toolbar.jsp
index 58dc71f..c5164e5 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/wsdl_status_toolbar.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl/wsdl_status_toolbar.jsp
@@ -27,7 +27,7 @@
 <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/toolbar.js"))%>">
 </script>
 </head>
-<body class="toolbarbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="toolbarbodymargin">
 <div id="toolbarborder">
   <div id="toolbar" ondblclick="processFramesetSizes(document.forms[0])">
 <jsp:useBean id="formAction" class="java.lang.StringBuffer" scope="request">
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl_content.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl_content.jsp
index b1791c8..80c07c4 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl_content.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl_content.jsp
@@ -179,7 +179,7 @@
 </script>
 </head>
 
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
   <div id="contentborder">
     <table id="loadScreen">
       <tr>
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl_toolbar.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl_toolbar.jsp
index d4ccc58..d7c838d 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl_toolbar.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsdl_toolbar.jsp
@@ -24,7 +24,7 @@
   <title><%=controller.getMessage("FRAME_TITLE_WSDL_TOOLBAR")%></title>
   <link rel="stylesheet" type="text/css" href="<%=response.encodeURL(controller.getPathWithContext("css/toolbar.css"))%>">
 </head>
-<body onUnload="top.opener.wsdlWindowClosed=true" class="toolbarbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" onUnload="top.opener.wsdlWindowClosed=true" class="toolbarbodymargin">
 <div id="toolbarborder">
   <div id="toolbar">
     <table width="100%" height=25 cellpadding=0 cellspacing=0 border=0>
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/actions/ClearNodeConfirmJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/actions/ClearNodeConfirmJSP.jsp
index 19a52b6..5c1337f 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/actions/ClearNodeConfirmJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/actions/ClearNodeConfirmJSP.jsp
@@ -20,7 +20,7 @@
 <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
     <script language="javascript">
         if (confirm("<%=controller.getWSILPerspective().getMessage("MSG_CONFIRM_REMOVE_NODE", controller.getWSILPerspective().getNodeManager().getSelectedNode().getNodeName())%>")) {
             perspectiveWorkArea.location = "<%=response.encodeURL(controller.getPathWithContext(ClearWSILAction.getActionLink(controller.getWSILPerspective().getNodeManager().getSelectedNode().getNodeId())))%>";
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/actions/OpenWSILActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/actions/OpenWSILActionJSP.jsp
index 327402c..23a4c47 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/actions/OpenWSILActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/actions/OpenWSILActionJSP.jsp
@@ -22,7 +22,7 @@
   <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/browserdetect.js"))%>">
   </script>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
 // Prepare the action.
 OpenWSILAction action = new OpenWSILAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/actions/OpenWSILLinkActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/actions/OpenWSILLinkActionJSP.jsp
index 7da4016..9ca75e6 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/actions/OpenWSILLinkActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/actions/OpenWSILLinkActionJSP.jsp
@@ -22,7 +22,7 @@
   <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/browserdetect.js"))%>">
   </script>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
 // Prepare the action.
 OpenWSILLinkAction action = new OpenWSILLinkAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/actions/RefreshActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/actions/RefreshActionJSP.jsp
index 0c11a7e..baf3e1a 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/actions/RefreshActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/actions/RefreshActionJSP.jsp
@@ -31,7 +31,7 @@
 <head>
   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
     <%
     if (!actionResult) {
         if (action instanceof RefreshWSILAction) {
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/actions/ResizeWSILFramesActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/actions/ResizeWSILFramesActionJSP.jsp
index 1da4955..b9e376b 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/actions/ResizeWSILFramesActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/actions/ResizeWSILFramesActionJSP.jsp
@@ -16,7 +16,7 @@
 <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/browserdetect.js"))%>">
 </script>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
    if (result)
    {
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/actions/WsilAddToFavoritesActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/actions/WsilAddToFavoritesActionJSP.jsp
index ba0c01b..d083686 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/actions/WsilAddToFavoritesActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/actions/WsilAddToFavoritesActionJSP.jsp
@@ -30,7 +30,7 @@
 <head>
   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
   <script language="javascript">
     wsilPropertiesContainer.location = "<%=response.encodeURL(controller.getPathWithContext("wsil/wsil_properties_container.jsp"))%>";
     wsilStatusContent.location = "<%=response.encodeURL(controller.getPathWithContext("wsil/wsil_status_content.jsp"))%>";
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/actions/WsilAddToUDDIPerspectiveActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/actions/WsilAddToUDDIPerspectiveActionJSP.jsp
index 10e5ae7..08a37b9 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/actions/WsilAddToUDDIPerspectiveActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/actions/WsilAddToUDDIPerspectiveActionJSP.jsp
@@ -22,7 +22,7 @@
   <jsp:include page="/scripts/panes.jsp" flush="true"/>
   <jsp:include page="/wsil/scripts/wsilPanes.jsp" flush="true"/>
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
   <%
   // Prepare the action.
   Action action = AddToUDDIPerspectiveAction.newAction(request, controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/actions/WsilAddToWSDLPerspectiveActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/actions/WsilAddToWSDLPerspectiveActionJSP.jsp
index 80bc689..a1f49dc 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/actions/WsilAddToWSDLPerspectiveActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/actions/WsilAddToWSDLPerspectiveActionJSP.jsp
@@ -22,7 +22,7 @@
 <head>
   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
 <%
 // Prepare the action.
 WsilAddToWSDLPerspectiveAction action = new WsilAddToWSDLPerspectiveAction(controller);
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/actions/WsilCheckFavoriteExistsActionJSP.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/actions/WsilCheckFavoriteExistsActionJSP.jsp
index 8bbd71c..9ba9903 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/actions/WsilCheckFavoriteExistsActionJSP.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/actions/WsilCheckFavoriteExistsActionJSP.jsp
@@ -23,7 +23,7 @@
 <head>
   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 </head>
-<body>
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>">
   <form action="<%=response.encodeURL(controller.getPathWithContext("wsil/actions/WsilAddToFavoritesActionJSP.jsp"))%>" method="post" target="<%=FrameNames.PERSPECTIVE_WORKAREA%>">
 <%
     Enumeration paramNames = request.getParameterNames();
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/forms/OpenWSILForm.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/forms/OpenWSILForm.jsp
index 5874387..0d77081 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/forms/OpenWSILForm.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/forms/OpenWSILForm.jsp
@@ -30,7 +30,7 @@
 <jsp:include page="/scripts/formsubmit.jsp" flush="true"/>
 <jsp:include page="/scripts/formutils.jsp" flush="true"/>
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
   <form action="<%=response.encodeURL(controller.getPathWithContext("wsil/actions/OpenWSILActionJSP.jsp"))%>" method="post" target="<%=FrameNames.PERSPECTIVE_WORKAREA%>" enctype="multipart/form-data" onSubmit="return handleSubmit(this)">
   <%
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/forms/UddiBusinessDetailsPage.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/forms/UddiBusinessDetailsPage.jsp
index 298b9a2..dab8bc7 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/forms/UddiBusinessDetailsPage.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/forms/UddiBusinessDetailsPage.jsp
@@ -53,7 +53,7 @@
     <link rel="stylesheet" type="text/css" href="<%=response.encodeURL(controller.getPathWithContext("css/windows.css"))%>">
     <jsp:include page="/wsil/scripts/wsilFormSubmit.jsp" flush="true"/>
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
     <form action="<%=response.encodeURL(controller.getPathWithContext(AddToFavoritesAction.getBaseActionLink()))%>" method="post" target="<%=FrameNames.PERSPECTIVE_WORKAREA%>">
 
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/forms/UddiServiceDetailsPage.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/forms/UddiServiceDetailsPage.jsp
index 798303e..a01e396 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/forms/UddiServiceDetailsPage.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/forms/UddiServiceDetailsPage.jsp
@@ -57,7 +57,7 @@
     <link rel="stylesheet" type="text/css" href="<%=response.encodeURL(controller.getPathWithContext("css/windows.css"))%>">
     <jsp:include page="/wsil/scripts/wsilFormSubmit.jsp" flush="true"/>
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
     <form action="<%=response.encodeURL(controller.getPathWithContext(AddToFavoritesAction.getBaseActionLink()))%>" method="post" target="<%=FrameNames.PERSPECTIVE_WORKAREA%>">
 
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/forms/WSILImportWSILToWorkbenchForm.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/forms/WSILImportWSILToWorkbenchForm.jsp
index 8863f9c..51336d1 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/forms/WSILImportWSILToWorkbenchForm.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/forms/WSILImportWSILToWorkbenchForm.jsp
@@ -35,7 +35,7 @@
   <jsp:include page="/scripts/formsubmit.jsp" flush="true"/>
   <jsp:include page="/scripts/formutils.jsp" flush="true"/>
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
   <form action="<%=response.encodeURL(controller.getPathWithContext("wsil/actions/WSILImportWSILToWorkbenchActionJSP.jsp"))%>" method="post" target="<%=FrameNames.PERSPECTIVE_WORKAREA%>" enctype="multipart/form-data">
   <input type="hidden" name="<%=ActionInputs.IMPORT_FILE%>" value="<%=ActionInputs.IMPORT_FILE%>">
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/forms/WsdlServiceDetailsPage.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/forms/WsdlServiceDetailsPage.jsp
index 5f80745..497e6d4 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/forms/WsdlServiceDetailsPage.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/forms/WsdlServiceDetailsPage.jsp
@@ -60,7 +60,7 @@
     <jsp:include page="/wsil/scripts/wsilTable.jsp" flush="true"/>
     <jsp:include page="/wsil/scripts/wsilFormSubmit.jsp" flush="true"/>
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
     <form action="<%=response.encodeURL(controller.getPathWithContext(AddToFavoritesAction.getBaseActionLink()))%>" method="post" target="<%=FrameNames.PERSPECTIVE_WORKAREA%>">
 
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/forms/WsilDetailsPage.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/forms/WsilDetailsPage.jsp
index f8ecdaf..cc70096 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/forms/WsilDetailsPage.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/forms/WsilDetailsPage.jsp
@@ -43,7 +43,7 @@
     <link rel="stylesheet" type="text/css" href="<%=response.encodeURL(controller.getPathWithContext("css/windows.css"))%>">
     <jsp:include page="/wsil/scripts/wsilFormSubmit.jsp" flush="true"/>
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
     <form action="<%=response.encodeURL(controller.getPathWithContext(AddToFavoritesAction.getBaseActionLink()))%>" method="post" target="<%=FrameNames.PERSPECTIVE_WORKAREA%>">
 
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/forms/WsilLinkDetailsPage.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/forms/WsilLinkDetailsPage.jsp
index 2d4b7ec..10c1f3f 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/forms/WsilLinkDetailsPage.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/forms/WsilLinkDetailsPage.jsp
@@ -44,7 +44,7 @@
     <title><%=wsilPerspective.getMessage("FORM_TITLE_WSIL_LINK_DETAILS")%></title>
     <link rel="stylesheet" type="text/css" href="<%=response.encodeURL(controller.getPathWithContext("css/windows.css"))%>">
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
     <%
     String titleImagePath = "images/details_highlighted.gif";
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/views/UddiBusinessView.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/views/UddiBusinessView.jsp
index e8b93b2..517fae0 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/views/UddiBusinessView.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/views/UddiBusinessView.jsp
@@ -44,7 +44,7 @@
     <jsp:include page="/wsil/scripts/wsilTable.jsp" flush="true"/>
     <jsp:include page="/wsil/scripts/wsilFormSubmit.jsp" flush="true"/>
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
     <%
     String titleImagePath = "wsil/images/list_business_highlighted.gif";
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/views/UddiServicesView.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/views/UddiServicesView.jsp
index 08548ec..f3b0444 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/views/UddiServicesView.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/views/UddiServicesView.jsp
@@ -44,7 +44,7 @@
     <jsp:include page="/wsil/scripts/wsilTable.jsp" flush="true"/>
     <jsp:include page="/wsil/scripts/wsilFormSubmit.jsp" flush="true"/>
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
     <%
     String titleImagePath = "wsil/images/list_UDDI_service_highlighted.gif";
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/views/WsdlServicesView.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/views/WsdlServicesView.jsp
index 0c29c75..96469b3 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/views/WsdlServicesView.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/views/WsdlServicesView.jsp
@@ -41,7 +41,7 @@
     <jsp:include page="/wsil/scripts/wsilTable.jsp" flush="true"/>
     <jsp:include page="/wsil/scripts/wsilFormSubmit.jsp" flush="true"/>
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
     <%
     String titleImagePath = "wsil/images/list_WSDL_service_highlighted.gif";
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/views/WsilLinksView.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/views/WsilLinksView.jsp
index 925323b..fd97da7 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/views/WsilLinksView.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/views/WsilLinksView.jsp
@@ -40,7 +40,7 @@
     <jsp:include page="/wsil/scripts/wsilTable.jsp" flush="true"/>
     <jsp:include page="/wsil/scripts/wsilFormSubmit.jsp" flush="true"/>
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
     <%
     String titleImagePath = "wsil/images/list_WSIL_highlighted.gif";
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/wsil_navigator_content.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/wsil_navigator_content.jsp
index 1520d2b..bb3c4bc 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/wsil_navigator_content.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/wsil_navigator_content.jsp
@@ -41,7 +41,7 @@
             focusedAnchorName = selectedAnchorName;
     }
 %>
-<body onLoad="self.location.hash='#<%=focusedAnchorName%>';setSelectedAnchorName('<%=selectedAnchorName%>')" class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" onLoad="self.location.hash='#<%=focusedAnchorName%>';setSelectedAnchorName('<%=selectedAnchorName%>')" class="contentbodymargin">
     <div id="treecontentborder">
         <%=nodeManager.renderTreeView(response)%>
     </div>
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/wsil_navigator_toolbar.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/wsil_navigator_toolbar.jsp
index c769cd5..ef42244 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/wsil_navigator_toolbar.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/wsil_navigator_toolbar.jsp
@@ -27,7 +27,7 @@
 <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/toolbar.js"))%>">
 </script>  
 </head>
-<body class="toolbarbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="toolbarbodymargin">
 <div id="toolbarborder">
   <div id="toolbar" ondblclick="processFramesetSizes(document.forms[0])">
 <jsp:useBean id="formAction" class="java.lang.StringBuffer" scope="request">
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/wsil_perspective_content.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/wsil_perspective_content.jsp
index e7a42dd..98ded4b 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/wsil_perspective_content.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/wsil_perspective_content.jsp
@@ -22,7 +22,21 @@
   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 </head>
 <frameset cols="<%=wsilPerspective.getPerspectiveContentFramesetCols()%>" bgcolor="#ECE9D8">
+  <%
+  if (org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.isRTL())
+  {
+  %>
+  <frame name="<%=WsilFrameNames.WSIL_ACTIONS_CONTAINER%>" title="<%=wsilPerspective.getMessage("FRAME_TITLE_ACTIONS_CONTAINER")%>" src="<%=response.encodeURL("wsil_actions_container.jsp")%>" marginwidth=0 marginheight=0 scrolling="no" frameborder=1>
+  <frame name="<%=WsilFrameNames.WSIL_NAVIGATOR_CONTAINER%>" title="<%=wsilPerspective.getMessage("FRAME_TITLE_NAVIGATOR_CONTAINER")%>" src="<%=response.encodeURL("wsil_navigator_container.jsp")%>" marginwidth=0 marginheight=0 scrolling="no" frameborder=1>
+  <%
+  }
+  else
+  {
+  %>
   <frame name="<%=WsilFrameNames.WSIL_NAVIGATOR_CONTAINER%>" title="<%=wsilPerspective.getMessage("FRAME_TITLE_NAVIGATOR_CONTAINER")%>" src="<%=response.encodeURL("wsil_navigator_container.jsp")%>" marginwidth=0 marginheight=0 scrolling="no" frameborder=1>
   <frame name="<%=WsilFrameNames.WSIL_ACTIONS_CONTAINER%>" title="<%=wsilPerspective.getMessage("FRAME_TITLE_ACTIONS_CONTAINER")%>" src="<%=response.encodeURL("wsil_actions_container.jsp")%>" marginwidth=0 marginheight=0 scrolling="no" frameborder=1>
+  <%
+  }
+  %>
 </frameset>
 </html>
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/wsil_properties_content.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/wsil_properties_content.jsp
index ee74a03..a72cc74 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/wsil_properties_content.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/wsil_properties_content.jsp
@@ -24,7 +24,7 @@
   <title><%=wsilPerspective.getMessage("FRAME_TITLE_PROPERTIES_CONTENT")%></title>
   <link rel="stylesheet" type="text/css" href="<%=response.encodeURL(controller.getPathWithContext("css/windows.css"))%>">
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
 <%
     NodeManager nodeManager = wsilPerspective.getNodeManager();
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/wsil_properties_toolbar.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/wsil_properties_toolbar.jsp
index 7e8762f..49aa504 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/wsil_properties_toolbar.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/wsil_properties_toolbar.jsp
@@ -28,7 +28,7 @@
 <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/toolbar.js"))%>">
 </script>
 </head>
-<body class="toolbarbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="toolbarbodymargin">
 <div id="toolbarborder">
   <div id="toolbar" ondblclick="processFramesetSizes(document.forms[0])">
 <jsp:useBean id="formAction" class="java.lang.StringBuffer" scope="request">
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/wsil_status_content.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/wsil_status_content.jsp
index d1b7199..959a6f3 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/wsil_status_content.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/wsil_status_content.jsp
@@ -22,7 +22,7 @@
   <title><%=wsilPerspective.getMessage("FRAME_TITLE_STATUS_CONTENT")%></title>
   <link rel="stylesheet" type="text/css" href="<%=response.encodeURL(controller.getPathWithContext("css/windows.css"))%>">
 </head>
-<body class="contentbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="contentbodymargin">
 <div id="contentborder">
   <table>
     <tr>
diff --git a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/wsil_status_toolbar.jsp b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/wsil_status_toolbar.jsp
index ce2d4ee..4d4f30e 100644
--- a/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/wsil_status_toolbar.jsp
+++ b/bundles/org.eclipse.wst.ws.explorer/wsexplorer/wsil/wsil_status_toolbar.jsp
@@ -26,7 +26,7 @@
 <script language="javascript" src="<%=response.encodeURL(controller.getPathWithContext("scripts/toolbar.js"))%>">
 </script>
 </head>
-<body class="toolbarbodymargin">
+<body dir="<%=org.eclipse.wst.ws.internal.explorer.platform.util.DirUtils.getDir()%>" class="toolbarbodymargin">
 <div id="toolbarborder">
   <div id="toolbar" ondblclick="processFramesetSizes(document.forms[0])">
 <jsp:useBean id="formAction" class="java.lang.StringBuffer" scope="request">
