Information Ona Tumor In The Thumb

How to become a soldier

In einem sehr beeindruckenden Photoprojekt dokumentiert Craig F. Walker bei der Denver Post den Werdegang von Ian Fisher zum Berufssoldaten.

Hier gibt es die schön gestaltete Site.

Iphone Fox Racing Background

Amazing HDR Photography


When it comes to HDR divorce is indeed the spirits. One finds great, the other too pop, colorful, younameit. I count myself among the "Class!" Group, and therefore there is here a gallery of stunning HDR images (or what to do as if).

If that's not enough, you can even sometimes right in the broadcast Flickr Pool . Or in the HDR gallery of Chromasia (where there are also very impressive non-HDR photos). To top it off, there are still a few delicacies from Smashing Magazine .

Who would like to try even once, which finds eg here and here nice tutorial.

How Much Is Silver Patron In New Mexico

Show Me Your Secrets

long time, rest, but there is again a treat. Post Secret is an art project that collects confessions, sending the people anonymously on postcards. Very pretty to look at and with high entertainment value.

Remove Write Protection Micro Sdhc

GWT 1.6 Hosted Mode: internal Jetty server with JDNI Data Sources and Environment Information for PostgreSQL provide

Update: In GWT Version 2.0.3 seems method will still work!

As one of the most tedious things you find when entering the GWT programming must admit I felt the solution to the following question: How does

internal Jetty server that is in the hosted mode used development under Eclipse with the plugin Google to provide the server-side programming JBDC connections or connection pools and other JNDI resources?

will probably be almost any reasonably ambitious GWT project sometime before this task. If it does not resolve you would have the enormous advantages of the hosted mode development waive his translation GWT project for each test run (Java -> Javascript) and do without the helpful development functions.

information on the web

In the actual GWT pages you find any particularly useful information. In the thread Setting DataSource (JNDI) in GWT 1.6 (hosted mode - Jetty) in Google Groups can be found, however, help that take us finally to the solution.
On my first attempt to solve the problem but I am following the link followed from the comments, because the solution seemed simple:
http://humblecode.blogspot.com/2009/05/gwt-16-using-jndi-datasource.html
also find other helpful links, such as Jetty to appropriate pages. Unfortunately, I am with this solution failed due to the question of how the Jetty server the missing by default JNDI context java: is comp / env available. Therefore, I have finally ended the solution of the Google Groups implemented. This, and the adjustment for our PostgreSQL database will be described below:

bit by bit

first Jetty and JDBC JARs

First you should get the necessary JARs. These are the extensions for a Jetty, on the other hand, the JDBC driver for PostgreSQL. Click the links for the download:
Jetty: http://dist.codehaus.org/jetty/
Here you can find to Jetty version 6 Version 7 of the download the Eclipse project can be found. When you download a version 6 in one of the subdirectories to go and the larger (non- src) Get ZIP archive, it to find the two jars.
PostgreSQL JDBC: http://jdbc.postgresql.org/download.html
JDBC3 the version I have used.
Altogether you the Jetty server then make available the following JARs:

• jetty-naming-*. jar
• jetty-plus-*. jar
• postgresql-*. jdbc3.jar

Man the JARs, the simplicity in / was placed / WEB-INF / lib / , even if not needed for the actual application. The JARs must be placed in the launch configuration properties in the classpath (under User Entries ).

second jetty-env.xml

In was / / Create WEB-INF / directory the file jetty-env.xml . Here are the resources for the JNDI context can be created. Unfortunately you can only learn from a little any existing configuration for Tomcat, Jetty as many different makes. In our case, in addition to the DataSource configuration information is stored. Both definitions see my jetty-env.xml this:

 \u0026lt;xml version = "1.0"?> \u0026lt;
 
 - Is used only for the use of the GWT hosted mode development - -> 
 
 \u0026lt;configure class="org.mortbay.jetty.webapp.WebAppContext"> 
 
 \u0026lt;new class="org.mortbay.jetty.plus.naming.EnvEntry"> 
 \u0026lt;arg> \u0026lt;/ arg> 
 \u0026lt;arg> meinEnvParameter \u0026lt;/ arg> 
 \u0026lt;arg type = "java . lang.String> some string \u0026lt;/ arg> 
 \u0026lt;arg type="boolean"> true \u0026lt;/ arg> 
 \u0026lt;/ new> 
 
 \u0026lt;new id = "jdbc / meinDBPool" class = " org.mortbay.jetty.plus.naming.Resource> 
 \u0026lt;arg> \u0026lt;/ arg> 
 \u0026lt;arg> jdbc / meinDBPool \u0026lt;/> arg  
 <arg> 
 <new class="org.postgresql.ds.PGSimpleDataSource"> 
 <set name="User">meinPostgresBenutzer</set> 
 <set name="Password">meinPostgresPasswort</set> 
 <set name="DatabaseName">meinePostgresDatenbank</set> 
 <set name="ServerName">localhost</set> 
 <set name="PortNumber">5432</set> 
 </new> 
 </arg> 
 </new> 
 
 \u0026lt;/ configure> 

The appropriate resources must of course be, as always, defined in the web.xml :

 \u0026lt;resource-ref> 
 \u0026lt;res-ref-name> jdbc / meinDBPool \u0026lt; ; / res-ref-name> 
 \u0026lt;res-type> javax.sql.DataSource \u0026lt;/ res-type> 
 \u0026lt;res-auth> Container \u0026lt;/ res-auth> 
 \u0026lt;/ resource-ref> 

But that should already be the case in most cases.

third env context configure

One problem is overcome now: Jetty known in the standard configuration or not Environment Context, which is what you queries typically:

 Context initCtx = new InitialContext (); 
 Context myenv = (Context) initCtx. lookup ("java: comp / env"); 

Jetty might want to be kept lean this way for certain scenarios, but here it is another stumbling block is that is overcome. There seems to be possible to supply the Jetty XML configuration of context, but unfortunately I have not figured out how. It is therefore in the way described Google Groups taken, which is to implement your own starter class for the internal server.


The GWT uses by default the class

com.google.gwt.dev.shell.jetty.JettyLauncher

to the server for the hosted mode launch. This class is located, including source code in gwt-dev- windows.jar . This class must be extended. The easiest way is probably where you copied the source code is in a class (when you upgrade to the next GWT needs to see it, perhaps, if anything has changed). Let's call the new class

org.unibi.sm.edit. MyCustomJettyLauncher

and put them in the source directory of the GWT project. Now it's just a matter of the WebappClassLoader foist the corresponding configuration with which he presents the required context is available. Here's the code snippet, in the end finds himself once again the complete MyCustomJettyLaucher.java :

 / / Additional code Start: 
 private static string [] = {__dftConfigurationClasses 
 "org.mortbay.jetty.webapp.WebInfConfiguration" / / 
 "org.mortbay.jetty.plus.webapp.EnvConfiguration", / /  jetty-env 
 "org.mortbay.jetty.plus.webapp.Configuration", // web.xml 
 "org.mortbay.jetty.webapp.JettyWebXmlConfiguration",// jettyWeb 
 }; 
 // Zusaetzlicher Quellcode Ende. 
  
 /** 
 * A {@link WebAppContext} tailored to GWT hosted mode. Features.... 
 */ 
 protected final class WebAppContextWithReload extends WebAppContext { 
  
 /** 
 * Specialized {@link WebAppClassLoader} that allows outside… 
 */ 
 private class WebAppClassLoaderExtension extends WebAppClassLoader { 
  
 private static final String META_INF_SERVICES = "META-INF/services/"; 
  
 public WebAppClassLoaderExtension() throws IOException {super 
 (bootStrapOnlyClassLoader, WebAppContextWithReload.this); 
 
 / / Additional code Start: 
 setConfigurationClasses (__dftConfigurationClasses); 
 / / Additional code end. 
} 

are therefore added in the constructor of the inner class that extends the WebappClassLoader , a list of previously defined configuration classes. Last you need now run the Configuration of the project made to launch our new explanation aces are used. This is simply the argument tab under Program arguments adds the following option:

-server org.unibi.sm.edit.MyCustomJettyLauncher

So it looks like:

4th should start

If everything was done correctly, the internal Jetty now start without error messages and the GWT server-side programming can be as described above to access databases and other environment objects.


Important: If To test the effect of changes to stop a possibly running hosted mode environment completely and start again.

The third way

addition to the hint a possible third way between waiving the hosted mode, and the arduous Jetty configuration: Oliver describes a way to get the hosted mode without the built-in server to use. Here then the server-side code and the static content of the project by an external AppServer be performed or delivered. This is especially interesting when you have finished anyway has a configured AppServer for its development. However, Oliver's text refers to a somewhat older version of GWT, the Tomcat was still used as an internal server.

Source 'org.unibi.sm.edit.MyCustomJettyLauncher'

 package  org.unibi.sm.edit; 
  
 import com.google.gwt.core.ext.ServletContainer; 
 import com.google.gwt.core.ext.ServletContainerLauncher; 
 import com.google.gwt.core.ext.TreeLogger; 
 import com.google.gwt.core.ext.UnableToCompleteException; 
 import com.google.gwt.dev.shell.jetty.JettyNullLogger; 
 import com.google.gwt.dev.util.InstalledHelpInfo; 
  
 import org.mortbay.component.AbstractLifeCycle; 
 import org.mortbay.jetty.AbstractConnector; 
 import org.mortbay.jetty.Request; 
 import org.mortbay.jetty.RequestLog; 
 import org.mortbay.jetty.Response; 
 import org.mortbay.jetty.Server; 
 import org.mortbay.jetty.handler.RequestLogHandler; 
 import org.mortbay.jetty.nio.SelectChannelConnector;  
 import org.mortbay.jetty.webapp.WebAppClassLoader; 
 import org.mortbay.jetty.webapp.WebAppContext; 
 import org.mortbay.log.Log; 
 import org.mortbay.log.Logger; 
  
 import java.io.File; 
 import java.io.IOException; 
 import java.net.URL; 
 import java.util.Enumeration; 
  
 /** 
 * A {@link ServletContainerLauncher} for an embedded Jetty server. 
 */ 
 public class MyCustomJettyLauncher extends ServletContainerLauncher { 
  
 /** 
 * Log jetty requests/responses to TreeLogger. 
 */ 
 public static class JettyRequestLogger extends AbstractLifeCycle implements 
 RequestLog { 
  
 private final TreeLogger  logger; 
  
 public JettyRequestLogger(TreeLogger logger) { 
 this.logger = logger; 
 } 
  
 /** 
 * Log an HTTP request/response to TreeLogger. 
 */ 
 @SuppressWarnings("unchecked") 
 public void log(Request request, Response response) { 
 int status = response.getStatus(); 
 if (status < 0) { 
 // Copied from NCSARequestLog 
 status = 404; 
 } 
 TreeLogger.Type logStatus, logHeaders; 
 if (status >= 500) { 
 logStatus = TreeLogger.ERROR; 
 logHeaders = TreeLogger.INFO; 
 } else if (status >= 400) { 
 logStatus = TreeLogger.WARN;  
 logHeaders = TreeLogger.INFO; 
 } else { 
 logStatus = TreeLogger.INFO; 
 logHeaders = TreeLogger.DEBUG; 
 } 
 String userString = request.getRemoteUser(); 
 if (userString == null) { 
 userString = ""; 
 } else { 
 userString += "@"; 
 } 
 String bytesString = ""; 
 if (response.getContentCount() > 0) { 
 bytesString = " " + response.getContentCount() + " bytes"; 
 } 
 TreeLogger branch = logger.branch(logStatus, String.valueOf(status) 
 + " - " + request.getMethod() + ' ' + request.getUri() 
 + " (" + userString + request.getRemoteHost()  + ')' 
 + bytesString); 
 TreeLogger headers = branch.branch(logHeaders, "Request headers"); 
 Enumeration   headerNames = request.getHeaderNames(); 
 while (headerNames.hasMoreElements()) { 
 String hdr = headerNames.nextElement(); 
 String hdrVal = request.getHeader(hdr); 
 headers.log(logHeaders, hdr + ": " + hdrVal); 
 } 
 // TODO(jat): add response headers 
 } 
 } 
  
 /** 
 * An adapter for the Jetty logging system to GWT's TreeLogger. This 
 * implementation class is only public to allow {@link Log} to instantiate 
 * it. 
 *  
 * The weird static data  / default construction setup is a game we play with 
 * {@link Log}'s static initializer to prevent the initial log message from 
 * going to stderr. 
 */ 
 public static class JettyTreeLogger implements Logger { 
 private final TreeLogger logger; 
  
 public JettyTreeLogger(TreeLogger logger) { 
 if (logger == null) { 
 throw new NullPointerException(); 
 } 
 this.logger = logger; 
 } 
  
 public void debug(String msg, Object arg0, Object arg1) { 
 logger.log(TreeLogger.SPAM, format(msg, arg0, arg1)); 
 } 
  
 public void debug(String msg, Throwable th) { 
 logger.log(TreeLogger.SPAM, msg,  th); 
 } 
  
 public Logger getLogger(String name) { 
 return this; 
 } 
  
 public void info(String msg, Object arg0, Object arg1) { 
 logger.log(TreeLogger.INFO, format(msg, arg0, arg1)); 
 } 
  
 public boolean isDebugEnabled() { 
 return logger.isLoggable(TreeLogger.SPAM); 
 } 
  
 public void setDebugEnabled(boolean enabled) { 
 // ignored 
 } 
  
 public void warn(String msg, Object arg0, Object arg1) { 
 logger.log(TreeLogger.WARN, format(msg, arg0, arg1)); 
 } 
  
 public void warn(String msg, Throwable th) { 
 logger.log(TreeLogger.WARN, msg, th); 
 
 
} / ** * copied from org.mortbay.log.StdErrLog 
. 
 * / 
 private String format (String msg, Object arg0, Object arg1) {int 
 0 = msg.indexOf ("{}"); 
 int i1 = I0 \u0026lt;0? -1: Msg.indexOf ("{}", I0 + 2); 
 
 if (arg1! = Null & & i1> = 0) {msg = msg.substring 
 (0, i1) + arg1 + msg.substring (i1 + 2); 
 
} if (arg0! = null & & I0> = 0) {msg = msg.substring 
 (0, I0) + arg0 + msg.substring (I0 + 2 );} 
 
 return msg;} 
} 
 
 
  /** 
 * The resulting {@link ServletContainer} this is launched. 
 */ 
 protected static class JettyServletContainer extends ServletContainer { 
 private final int actualPort; 
 private final File appRootDir; 
 private final TreeLogger logger; 
 private final Server server; 
 private final WebAppContext wac; 
  
 public JettyServletContainer(TreeLogger logger, Server server, 
 WebAppContext wac, int actualPort, File appRootDir) { 
 this.logger = logger; 
 this.server = server; 
 this.wac = wac; 
 this.actualPort = actualPort; 
 this.appRootDir = appRootDir; 
 } 
  
 public int getPort() { 
 return actualPort;  
 } 
  
 public void refresh() throws UnableToCompleteException { 
 String msg = "Reloading web app to reflect changes in " 
 + appRootDir.getAbsolutePath(); 
 TreeLogger branch = logger.branch(TreeLogger.INFO, msg); 
 // Temporarily log Jetty on the branch. 
 Log.setLog(new JettyTreeLogger(branch)); 
 try { 
 wac.stop(); 
 wac.start(); 
 branch.log(TreeLogger.INFO, "Reload completed successfully"); 
 } catch (Exception e) { 
 branch.log(TreeLogger.ERROR, 
 "Unable to restart embedded Jetty server", e); 
 throw new UnableToCompleteException(); 
 } finally { 
 // Reset the top-level  logger. 
 Log.setLog(new JettyTreeLogger(logger)); 
 } 
 } 
  
 public void stop() throws UnableToCompleteException { 
 TreeLogger branch = logger.branch(TreeLogger.INFO, 
 "Stopping Jetty server"); 
 // Temporarily log Jetty on the branch. 
 Log.setLog(new JettyTreeLogger(branch)); 
 try { 
 server.stop(); 
 server.setStopAtShutdown(false); 
 branch.log(TreeLogger.INFO, "Stopped successfully"); 
 } catch (Exception e) { 
 branch.log(TreeLogger.ERROR, 
 "Unable to stop embedded Jetty server", e); 
 throw new UnableToCompleteException(); 
 } finally { 
 // Reset the top-level  logger. 
 Log.setLog(new JettyTreeLogger(logger)); 
 } 
 } 
 } 
  
 private static String[] __dftConfigurationClasses = { 
 "org.mortbay.jetty.webapp.WebInfConfiguration", //  
 "org.mortbay.jetty.plus.webapp.EnvConfiguration",// jetty-env 
 "org.mortbay.jetty.plus.webapp.Configuration", // web.xml 
 "org.mortbay.jetty.webapp.JettyWebXmlConfiguration",// jettyWeb 
 }; 
  
 /** 
 * A {@link WebAppContext} tailored to GWT hosted mode. Features hot-reload 
 * with a new {@link WebAppClassLoader} to pick up disk changes. The default 
 * Jetty {@code WebAppContext} will create new instances of servlets,  but it 
 * will not create a brand new {@link ClassLoader}. By creating a new 
 * {@code ClassLoader} each time, we re-read updated classes from disk. 
 *  
 * Also provides special class filtering to isolate the web app from the GWT 
 * hosting environment. 
 */ 
 protected final class WebAppContextWithReload extends WebAppContext { 
  
 /** 
 * Specialized {@link WebAppClassLoader} that allows outside resources 
 * to be brought in dynamically from the system path. A warning is 
 * issued when this occurs. 
 */ 
 private class WebAppClassLoaderExtension extends WebAppClassLoader { 
  
 private static final String META_INF_SERVICES = "META-INF/services/";  
  
 public WebAppClassLoaderExtension() throws IOException { 
 super(bootStrapOnlyClassLoader, WebAppContextWithReload.this); 
  
 setConfigurationClasses(__dftConfigurationClasses); 
 } 
  
 @Override 
 public URL findResource(String name) { 
 // Specifically for 
 // META-INF/services/javax.xml.parsers.SAXParserFactory 
 String checkName = name; 
 if (checkName.startsWith(META_INF_SERVICES)) { 
 checkName = checkName.substring(META_INF_SERVICES.length()); 
 } 
  
 // For a system path, load from the outside world. 
 URL found; 
 if (isSystemPath(checkName)) { 
 found = systemClassLoader.getResource(name);  
 if (found != null) { 
 return found; 
 } 
 } 
  
 // Always check this ClassLoader first. 
 found = super.findResource(name); 
 if (found != null) { 
 return found; 
 } 
  
 // See if the outside world has it. 
 found = systemClassLoader.getResource(name); 
 if (found == null) { 
 return null; 
 } 
  
 // Warn, add containing URL to our own ClassLoader, and retry 
 // the call. 
 String warnMessage = "Server resource '" 
 + name 
 + "' could not be found in the web app, but was found on the system classpath"; 
 if (!addContainingClassPathEntry(warnMessage,  found, name)) { 
 return null; 
 } 
 return super.findResource(name); 
 } 
  
 /** 
 * Override to additionally consider the most commonly available JSP 
 * and XML implementation as system resources. (In fact, Jasper is 
 * in gwt-dev via embedded Tomcat, so we always hit this case.) 
 */ 
 @Override 
 public boolean isSystemPath(String name) { 
 name = name.replace('/', '.'); 
 return super.isSystemPath(name) 
   name) 
 throws ClassNotFoundException { 
 // For system path, always prefer the outside world. 
 if (isSystemPath(name)) { 
 try { 
 return systemClassLoader.loadClass(name); 
 } catch (ClassNotFoundException e) { 
 } 
 } 
  
 try { 
 return super.findClass(name); 
 } catch (ClassNotFoundException e) { 
 // Don't allow server classes to be loaded from the outside. 
 if (isServerPath(name)) { 
 throw e; 
 } 
 } 
  
 // See if the outside world has a URL for it. 
 String resourceName = name.replace('.', '/') + ".class"; 
 URL found = systemClassLoader.getResource(resourceName);  
 if (found == null) { 
 return null; 
 } 
  
 // Warn, add containing URL to our own ClassLoader, and retry 
 // the call. 
 String warnMessage = "Server class '" 
 + name 
 + "' could not be found in the web app, but was found on the system classpath"; 
 if (!addContainingClassPathEntry(warnMessage, found, 
 resourceName)) { 
 throw new ClassNotFoundException(name); 
 } 
 return super.findClass(name); 
 } 
  
 private boolean addContainingClassPathEntry(String warnMessage, 
 URL resource, String resourceName) { 
 TreeLogger.Type logLevel = (System 
 .getProperty(PROPERTY_NOWARN_WEBAPP_CLASSPATH)  == null) ? TreeLogger.WARN 
 : TreeLogger.DEBUG; 
 TreeLogger branch = logger.branch(logLevel, warnMessage); 
 String classPathURL; 
 String foundStr = resource.toExternalForm(); 
 if (resource.getProtocol().equals("file")) { 
 assert foundStr.endsWith(resourceName); 
 classPathURL = foundStr.substring(0, foundStr.length() 
 - resourceName.length()); 
 } else if (resource.getProtocol().equals("jar")) { 
 assert foundStr.startsWith("jar:"); 
 assert foundStr.endsWith("!/" + resourceName); 
 classPathURL = foundStr.substring(4, foundStr.length() 
 - (2 + resourceName.length()));  
 } else { 
 branch.log(TreeLogger.ERROR, 
 "Found resouce but unrecognized URL format: '" 
 + foundStr + '\''); 
 return false; 
 } 
 branch = branch.branch(logLevel, "Adding classpath entry '" 
 + classPathURL 
 + "' to the web app classpath for this session", null, 
 new InstalledHelpInfo("webAppClassPath.html")); 
 try { 
 addClassPath(classPathURL); 
 return true; 
 } catch (IOException e) { 
 branch.log(TreeLogger.ERROR, "Failed add container URL: '" 
 + classPathURL + '\'', e); 
 return false; 
 } 
 } 
 } 
  
 /** 
  * Parent ClassLoader for the Jetty web app, which can only load JVM 
 * classes. We would just use  
 null 
  for the parent 
 * ClassLoader except this makes Jetty unhappy. 
 */ 
 private final ClassLoader bootStrapOnlyClassLoader = new ClassLoader(  null) {  }; 
  
 private final TreeLogger logger; 
  
 /** 
 * In the usual case of launching {@link com.google.gwt.dev.HostedMode}, 
 * this will always by the system app ClassLoader. 
 */ 
 private final ClassLoader systemClassLoader = Thread.currentThread() 
 .getContextClassLoader(); 
  
 @SuppressWarnings("unchecked") 
 private WebAppContextWithReload(TreeLogger  logger, String webApp, 
 String contextPath) { 
 super(webApp, contextPath); 
 this.logger = logger; 
  
 // Prevent file locking on Windows; pick up file changes. 
 getInitParams().put( 
 "org.mortbay.jetty.servlet.Default.useFileMappedBuffer", 
 "false"); 
  
 // Since the parent class loader is bootstrap-only, prefer it first. 
 setParentLoaderPriority(true); 
 } 
  
 @Override 
 protected void doStart() throws Exception { 
 setClassLoader(new WebAppClassLoaderExtension()); 
 super.doStart(); 
 } 
  
 @Override 
 protected void doStop() throws Exception { 
 super.doStop();  
 setClassLoader(null); 
 } 
 } 
  
 /** 
 * System property to suppress warnings about loading web app classes from 
 * the system classpath. 
 */ 
 private static final String PROPERTY_NOWARN_WEBAPP_CLASSPATH = "gwt.nowarn.webapp.classpath"; 
  
 static { 
 // Suppress spammy Jetty log initialization. 
 System.setProperty("org.mortbay.log.class", JettyNullLogger.class 
 .getName()); 
 Log.getLog(); 
  
 /* 
 * Make JDT the default Ant compiler so that JSP compilation just works 
 * out-of-the-box. If we don't set this, it's very, very difficult to 
 * make JSP compilation work. 
 */  
 String antJavaC = System.getProperty("build.compiler", 
 "org.eclipse.jdt.core.JDTCompilerAdapter"); 
 System.setProperty("build.compiler", antJavaC); 
 } 
  
 public ServletContainer start(TreeLogger logger, int port, File appRootDir) 
 throws Exception { 
 TreeLogger branch = logger.branch(TreeLogger.INFO, 
 "Starting Jetty on port " + port, null); 
  
 checkStartParams(branch, port, appRootDir); 
  
 // Setup our branch logger during startup. 
 Log.setLog(new JettyTreeLogger(branch)); 
  
 // Turn off XML validation. 
 System.setProperty("org.mortbay.xml.XmlParser.Validating", "false");  
  
 AbstractConnector connector = getConnector(); 
 connector.setPort(port); 
  
 // Don't share ports with an existing process. 
 connector.setReuseAddress(false); 
  
 // Linux keeps the port blocked after shutdown if we don't disable this. 
 connector.setSoLingerTime(0); 
  
 Server server = new Server(); 
 server.addConnector(connector); 
  
 // Create a new web app in the war directory. 
 WebAppContext wac = new WebAppContextWithReload(logger, appRootDir 
 .getAbsolutePath(), "/"); 
  
 RequestLogHandler logHandler = new RequestLogHandler(); 
 logHandler.setRequestLog(new JettyRequestLogger(logger));  
 logHandler.setHandler(wac); 
 server.setHandler(logHandler); 
 server.start(); 
 server.setStopAtShutdown(true); 
  
 // Now that we're started, log to the top level logger. 
 Log.setLog(new JettyTreeLogger(logger)); 
  
 return new JettyServletContainer(logger, server, wac, connector 
 .getLocalPort(), appRootDir); 
 } 
  
 protected AbstractConnector getConnector() { 
 return new SelectChannelConnector(); 
 } 
  
 private void checkStartParams(TreeLogger logger, int port, File appRootDir) { 
 if (logger == null) { 
 throw new NullPointerException("logger cannot be null"); 
 
 
} if (port \u0026lt;0  probably a distinction between the free (aka ad-supported) Standard Edition and the paid Professional Edition to take. An overview of the different editions provide the rest of the English Wikipedia article 
 
. 
 
 Google Apps Premier / Premier 
 
 In 
 Google Apps Help 
 is made available to the following statement: 
 
 
 We guarantee that Google is at least 99.9 percent of the time is available to help make employees more productive and less to have to worry about a breakdown .** 
 
 
 After Google's calculation gives the 15 minutes of downtime month. In the footnotes, however, the 
 Terms  directed with the restriction that the SLA is valid only if the apps in accordance with these conditions are used. The Professional Edition is available today (08/07/2009) at a price of 40 € / user account / year. 

in the side, a comparison with Microsoft Exchange from the Radicati Group is listed. Thus was with Exchange servers with significantly higher unplanned downtime expected.

Education Edition

is loud Wikipedia a variant of the Premier / Professional Edition. However, apparently without the availability guarantee. Standard Edition

Here I have found no information from Google. However, according to the experience almost as high as the reliability of the Professional Edition. Or knows somebody sources?

convince yourself ... .. can to some extent on the status

Apps Dashboard

:

http://www.google.com/appsstatus # hl = en

Here you can for the various services the corresponding status information, it can also go far in the past and look at the (relatively few) problem cases, such as Google has dealt with it (and see, for example, the solution time). The objectives pursued with the Dashboard and Google, Google itself

as described

:

In February, we brought the Apps Status Dashboard

on the way to keep you better informed about the condition and efficiency of our services such as Google Mail to keep Google Calendar or Google Docs to date. This dashboard you can use to check at any time, whether our service will work as smoothly or whether you experience an error. We have received many positive feedback and helpful hints from users and customers to make the dashboard more useful.

Due the high visibility, it is probably not Google simply be possible in the dashboard to conceal losses.

What Happened To Scrabble

reliability of Google Apps services

for the integration of our Café blog

in our home we use the services offered by

Blogspot News feeds and the Google Ajax Feed API

. For most purposes, it gave the standard feed, which can be accessed at the following URL for this blog (Atom format): http://

curtstech .blogspot.com / feeds / posts / default

The bold part of the address would be different from another blog. Alternatively, it is also possible following URL:

http://www.blogger.com/feeds/

2321699238659363147

/ posts / default

It is 2321699238659363147

the blog ID, which can be found for example in the news feed itself.

What about categories and labels? the entries can be assigned to multiple categories or labels to Blogspot blogs. For our website we need now is also the possibility all the reports of the category / label of News

to call for a separate engagement. A description of how to also get feeds of the entries of certain categories can be found in the Help for Blogger API specifically in the page ' Protocol'. There, the text brings under the heading

Retrieving posts using query parameters

the solution: Court

http:// - .blogspot.com/feeds/posts/default/- / brune News

or

http://www.blogger.com/feeds/

3088683439170101886 / posts/default/- / News

Can Mycoplasma Pneumoniae Last For Years

news feeds for categories in Blogspot / Blogger blog

Google's ever-growing portfolio of web-based applications is becoming obvious interest for universities. Via the Google Enterprise Blog

success stories such as the Boise State University in which apparently more than 20,000 students plus staff were converted to common Google services. Google itself combines the description of its offer for education on a special page . is interesting for me initially, the question of the proliferation of these services, which do indeed have relatively young and are often characterized as a beta version, now at universities in Germany, but also achieved the world. After that I will still dare not assess the benefits of using this service entails, and what problems in the introduction cope with a university probably will be.

Who uses the Google Services

When asked 'Who uses the Google Services' is to ask an interesting, because the extent to which services are used, on the other, how large the respective educational institution. It obviously makes a difference if you move a university with 1,000 students or 65,000. Also many examples of universities can be found on the customer side of Google Apps. USA Here are just a small selection of very large projects is made. According to Google, there will be hundreds of educational institutions that use the Google Apps:

University # students / staff

scope of use

Arizona State University

65 000 students case study Wikipedia The announcement of the IT service provider deals with issues such as advertisements and data ownership, existing mail addresses have been retained Australia University

GMail, IM, calendar	case study	Lakehead University, Ontario 38,000 students and staff	GMail chat, and VoIP, calendar
	Northwestern University	GMail Chat, Calendar	students called for the introduction
University of Maine system, association of universities of the State of Maine	According	total of approximately 34,000 students. Have a central IT service provider	GMail, Calendar, Docs
	# students / staff		scope of use

University of Adelaide

16,000 students

GMail The mail service of the complete The State was allocated centrally concerned, apparently 1.3 million pupils / students It was thus one of the largest Outlook / Exchange installations replaced University # students / staff

ZDNet article mail from existing accounts will be transferred automatically	New South Wales, State	GMail	Bloomberg message
	Macquarie University	31,000 students, 37,000 alumni , associate later (in 2007)	GMail MIS message
		Germany	Here I am, unfortunately, did not become really find. While there are many areas of e-learning at German universities, the use of Google Docs discuss, but a university that the use of Google Apps has made to the strategy, I could not track down. So only a hit:
			scope of use

TU Chemnitz

calendar What benefits could be from using the Google Services expect : Google Apps Education Arizona State University in its development support towards a highly flexible university that can provide extraordinary technology experiences for its students. The integration of webmail, instant messaging and calendar functions with Google is simply unrivaled. Cool mentioned, are today probably the best and most innovative of its kind. Here are just a minimal, highly subjective list: and spam is almost no problem. And the students are already there , at least a significant proportion. Then there is the virtually unlimited memory and comes with 7 gigabytes of today. provide mail services offered by universities in most cases a Fraction, so students receive at the University of Bielefeld

URZ Info Page		What makes the Google offer really so attractive to universities? Here a user commitment from a Google page
- Kari Barlow, assistant vice president, University Technology Office, Arizona State University			GMail: Has the way you work revolutionized mail. It could appear difficult today to imagine how conversations without thread, super-fast search, built-in chat, documents, live preview and the like ever and efficiency. In a test of Stiftung Warentest GMail fared the best service

500 megabytes

large mailboxes. sure

With its openness, flexibility and collaboration features one of the leading products in this segment:

calendar. The calendar can be used in GMail, iGoogle and integrate other calendar applications.

Docs:

Even if they continue to offer in comparison to the traditional office suites less functionality, so they have only just in the area of collaboration shown new ways for a university such as the field of electronic teaching and learning support to assess much higher.

Because all services fully Web-based developments are to be rolled out very quickly and are available to all users immediately available.

integration possibilities

Google seems to be competing with Microsoft to sit on openness (see Heise

). This is confirmed by case studies such as that of Arizona State University

, were realized in which, for example, an application through the university's own CAS service. Money on this Google page is talk that the services are free. But perhaps it is certain expenses if you like the Grand Valley State University the mail accounts free of advertising will hold. This article in the PC world

but also the question of which is that free for educational use is. The personal savings

The use of Google applications could the massive relief operation to bring the IT infrastructure. This has two reasons:

Cloud Computing

: A number of as yet to be operated by the university services will be outsourced and can be served by far fewer staff. Examples of such cut correspond Services: Mail Server, e-learning services, server operations, backup

The Web as a new desktop: All Google applications are completely web-based and can be customized with a large number of browsers use on any operating system. users of these services, which need no other applications can log on and work on any PC. For IT support, this means the option highly standardized, low-maintenance PC to make installations.

Both aspects have the potential to relieve the existing IT staff in higher education strongly. What problems could be expected

dispensing control

The use of Google services to enter the cloud computing means. So far right on the university-operated services such as mail servers are listed out in the technical structure, on which the university has no direct access more. This leads to the following questions: How can access the university on

their data is backed up, for example, to change providers in principle, be kept open?

part question: can / should be the university completely rely on the data security by the provider, or is a separate backup necessary?

part question: What are the data at all

1. the university? Staff and especially students will use the platforms for individual purposes (private documents, emails, etc.). These are then no data of the college more
2. As such outsourcing of data processing and data compatible with data protection legislation?

What are appropriate

Service Level Agreements (SLAs)

, how is compliance monitored and how violations will be sanctioned?

reluctance of users to Google Google

comes despite his 'Do not be evil' motto -rise with reservations particularly for data protection officials, where the hunger for information of the company is suspect. In the heterogeneous environment of a university is definitely to be expected that among the staff and students, a proportion present is that shares this concern.

Finally
• Have I forgotten anything? Are there other universities in Germany that I have overlooked? Am grateful to you for help and information!
  Update
  The specific question of the reliability of Google services, I briefly considered in a later blog entry:
  • reliability of Google Apps
  Update 2
Here are two interesting blog entries that the integration with Google Apps Learning Management Systems (LMS) like Moodle and Blackboard describe:
• http://googleenterprise.blogspot.com/2009/02/lms-and-google-apps-first-comes-love.html

http://googleenterprise.blogspot.com/2009/07/building-blocks-connecting-google-apps.html

goes in another post there is a range of schools their mail service from Google's Postini service to be safer:

http://googleenterprise.blogspot.com/2009/07/todays-day-signups-open-for-free-google.html show

These contributions, on how different ways Google offers to educational institutions located.

Tiffany Granath Panties

use of Gmail, Calendar, Docs and Apps at universities in Germany and worldwide

The Google Web Toolkit GWT

offers native already has a relatively easy way usable

Data from servers in
• JSON format to pick . Here is a little comparison to be made with the possibilities offered by GXT and Ext GWT
.
• is important in particular the question of how simple JSON data are connected to widgets, since we have relatively many types of data sets to be processed, but in a more or less identical masks. The question of how the data is then sent back to the server plays no role here first.
Test Preparations: Static JSON files

be made to simplify the implementation of the JSON data in GWT using static files available. In my Google about the plugin have created the Eclipse project

/ was

folder that contains GWT version 1.6 are a complete Web application. For the static JSON files there just created a subdirectory, let's call him
• model / .
example file:

was / / model / abschluss.json

contents of the file:

[

{id: 123, name: degree 1, symbol: Abs1 }, { id: 456, name: degree 2,

symbol: Abs2

},

]

This file may Jetty Server that is started in Ecplise, are available on http://localhost:8080/modell/abschluss.json

(or under the configured port).

 
 
 
 
 
 
 
 JSON with GWT 
 
 
 
 

This works only a very brief sketch like this, the detailed description can be found in this
GWT 1.6 Page
:

Creating

JSON source (we have)

stub class , Which implements create JSNI methods to directly access the contents of the JSON structure. Instances of the stub class generated by a JSNI method that essentially

eval ()
calls (note the safety instructions!)

implementation of an asynchronous
request builder
call, the JSON data collected and processed .
1. 
   
   
   
   
   



2. generating a representation, z. As a Grid .
   
   
   
   
   
   



3. 
   
   Important: Do not
   The URL to the JSON file
   GWT.getModuleBaseURL ()
   be preceded by as shown in the GWT tutorial. It extends an indication of this type:
   



4. 
   
   
   private static final String JSON_URL
= "/ model / abschluss.json";

experience

 The implementation of the stub class can mean annoying repetition of work, if appropriate on the server side already are (bean) classes. Here, however, can not achieve Reuse 
 

Once you have the stub classes, the rest of the implementation relatively easy, apart from the usual 'hardship' of the representation with the relatively primitive GWT widgets

Source


• 
  
  
  
  
  

package com.chb.gxt2m3.client;

• com.google.gwt.core.client.EntryPoint import;
  com.google import. gwt.core.client.JsArray;
  import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.event.dom.client.ClickHandler;
import com.google.gwt.http.client.Request;

import com.google.gwt.http.client.RequestBuilder;
com.google import. gwt.http.client.RequestCallback;
import com.google.gwt.http.client.RequestException;
import com.google.gwt.http.client.Response;
import com.google.gwt.user.client.ui. Button;
com.google.gwt.user.client.ui.Grid import, import
com.google.gwt.user.client.ui.HTML;
import com.google.gwt.user.client.ui.Label;
import com.google.gwt.user.client.ui.RootPanel;

public class GXTTest implements EntryPoint {public void

onModuleLoad () {

btLaden Button = new Button ("Load");
RootPanel.get ("buttons") add (btLaden).

btLaden.addClickHandler (new click handler () {public void onClick

 (click event) {
 refreshAbschluesse ();} 
 
 
}); 
 } private static final String 
 
 JSON_URL_ABS = "/ model / abschluesse.json"; 
 
 private void refreshAbschluesse () {
 
 RootPanel.get ("display") clear ();. 
 RootPanel.get (" display "). add (
 new Label (" financial statements are loaded of "+ JSON_URL_ABS)); 
 
 request builder builder builder = new request (RequestBuilder.GET, 
 JSON_URL_ABS); 
 
 try {
 builder.sendRequest (null, new request callback () {public void onError 
 
 (Request request, Throwable exception) {
 display error ("JSON call could not be executed");} 
 
 
 public void onResponseReceived (Request request, Response response 
) {
 
 if (200 == response.getStatusCode ()) {
 
 ClearError (); 
 abschluesseZeigen (asArrayOfAbsData (response.getText ()));} else {
 
 
 display error ("Failed to call JSON (
 response.getStatusText + () + ")");} 
 
 
} 
});} catch 
 (request Exception e) {
 display error ("access to JSON failed");} 
 
 
 
} private void abschluesseZeigen (JsArray 
 abs) {
 
 RootPanel.get ("display") . clear (); 
 
 if (abs == null  
 Name ")); 
 
 for (int idx = 0; idx \u0026lt;abs.length (), idx + +) {a = data 
 statements abs.get (idx); 
 agrid.setWidget (idx + 1, 0, new Label ("" + 
 a.getId ())); 
 agrid.setWidget (idx + 1, 1, new Label (a.getKuerzel ())); 
 agrid.setWidget (idx + 1, 2, new Label ("" + a.getName 
 ()));}} 
 
 
 
} private void clear error () {
 RootPanel.get ("errorMsg") clear ();. 
} 
 
 private void display error (String error) {
 clear error (); 
 if (error = null) 
 RootPanel.get ("errorMsg") add (new Label (error));. 
}  
 private final native JsArray 
 asArrayOfAbsData (String json) / *- {return 
 eval (json);} 
 }-*/; 
 
 
 
 
 
   
   JSON with GXT 
   
 
 
 
 
 
 
 A strength GXT (whose version 2 is available today as Milestone 3) are certainly the great widgets and Databinding ways through which changes the underlying data model to sign in all parts of the application can be. Unfortunately in the demo page only 
 Grid example with an XML source 
. Anything but a search shows that there is a 
 JsonReader 
. One can transfer the sample also. 
 
 
 
 
 
 
 
 
 
 One problem is the structure of the JSON file. Apparently, nested styles are not possible, at least you can understand this thread in the ExtJS Forum 
  be so. 
 
 
 

There are, however, a different example:
http://extjs.net/forum/showthread.php?t=71978

Shannon Whirry Appreciation

use of JSON in GWT and GXT


Blogging on topics of programming you quickly to many source
to want to show appetizers, so what is said can be illustrated directly. A Copy-and-paste of the favorite development environment works because, unfortunately, not often, in fact there is only a confused heap of words that must be processed manually tedious and again.

But there are solutions to (almost) reached the simplicity of a copy-and-paste:

Google Code Prettifier

The Google Code Prettifier be blog content with source code, provided they are enclosed in a given day, by pimped by Google delivered Javascript. A Description in German can be found in Google Watch Blog , where the set of supported languages is defined as:

currently supported languages bash, C, C + +,
Java
, JavaScript, Perl, Python, XML, HTML , HTMLXmp, white space and Misc1 - almost all important.


Even CSS has become one of the features seem to result. So you have everything in order such as a
GWT
show programming beautiful. How does it work

In preparation to Load the CSS and JS files from the Prettify website. These files must be on your own Web server to make available. It is for this the different languages of their own JS files, you can probably those from whom they accept never need to leave out. After that binds one CSS file, and the main javascript file in his blog and complements the body

day



\u0026lt;body onload="prettyPrint()">

The preparations are complete. In order to format source code of the corresponding block of code is simply surrounded by a

\u0026lt;pre class="prettyprint"> ...\u0026lt;/ pre>

. It is possible specify the language if you do not, so 'advises' the Prettifier. Example:

\u0026lt;pre class="prettyprint lang-java"> ...\u0026lt;/ pre>

Links:

Homepage Google Code Prettify

: By downloading the necessary files and documentation

Open

Tutorial: Here is additional information in German for the integration of HTML / XML

example

And it looks like:

/ **

* Small helper method to test for empty strings. * * @ Param

to_test to be tested * @ return string

* If the string

null or empty or only with * space is filled is

true, otherwise false.

* * / public static boolean isEmptyString (String to_test) {return to_test == null to do.

The name

The first hurdle was the name: we understand something like 'full tilt', 'Carrachero' or 'Karachiro'. With a little googling, we found initially to 'Carachillio', which does bring some search results

, including even a menu. However, no recipe or no useful description. a "real" and at least in the German web frequently-used name is

Carachillo

. Under these keyword search to find it already some useful results

.

Having now the 'ch' in English through the usual 'J', we were finally replaced at the goal and recognized. So we have a

C arajillo drunk

! Under this name we can find an entry in the Wikipedia

 
. We are interested, of course, not the simple version in which are simply coffee and alcohol to bulk. We want the full program with fire and caramel flavor. 
 
 recipes on the Internet 
 
 When Google for  Carachillo  found, for example, the following recipes: 
   http://www.cocktaildreams.de/cooldrinks/cocktailrezept.carachillo.2446.html 
 
 
 
 the Veterano in the cup (a large coffee cup) and heat it with steam. Then light to get the right taste. 
 Now two coffee beans and lemon rind in the cup and to pour the hot espresso. 

http://toprezepte.ch/index.php/rezepte-von-az/trinkbares/54-carachillo

4-6 cl Brandy purely preferably delivered in a small, sturdy glass

2 sugar cubes add

Brandy heated with steam and then set fire Stir with a spoon until no sugar grain is visible. An espresso in a thin stream to Brandy give (it must be to hear a crackling sound)

is crucial pour Where appropriate flame

the burning of sugar to a caramel flavor is created that makes the espresso first to Carajillo. Even the Wikipedia article emphasizes this. Not quite agreement among the different recipes in whether coffee beans and lemon zest into it belong, and if so, whether they are already heated with brandy together or come until later.

Must it be High-proof?

burn Normally spirits until an alcohol content of about 50%. Must say for the Carajillo a suitably potent brandy are used? No, because by the heating The alcohol is readily released and a brandy Veterano as sufficient by 36%. And so we then made our first Carajillos Two teaspoons of sugar in one of our cappuccino cups. Ca. 3 cl, a little more than a shot glass

, Veterano it. The 4-6cl appeared from one of the previous recipes us something very hard. With the heat

Wasserdampfdüse the espresso machine, the sugar-brandy mixture well. Beware, it injected. But the hotter the better it makes the whole thing is burning brandy. After heating, the pivot cup of something, usually the sugar dissolves then already.

Now it so far: A match to keep the cup edge and should immediately blazing blue flames. We had a fear it may burn too much alcohol obtained, but even at the trial with the longest burn time was the result is still very high percentage. So: Brandy really hot and can burn properly so that it can also arise caramel.

During firing still stir with a long spoon bit, maybe it will help that the sugar is dissolved and heated properly. On lemon and coffee beans we have been dispensed with.

Before the flames go out the cup under the espresso machine and pour in the picture by running into the espresso. We added a double espresso, what was just right for our taste. If you do it right (with us until the 4th attempt) can be heard crackling in a really strong moment in which flows the first coffee in the hot brandy.

us for the special way of Carajillos is next to his taste and the current in the sheep's cold very helpful Durchwärmeffekt especially the aesthetics of its production: the blue flames that billow around the espresso machine to give the matter a unique charm.

Oh yes, be VERY careful when drinking, as the cup edges are

enormously hot. And unlike, for example, in a Sambuca, guests at the table do not see that the drink was once burned and therefore are unprepared.

similar drinks

The Carajillo seems to be not unlike the Café Royal

. A recipe can be found for example here:

http://www.lebensmittellexikon.de/c0001200.php

Or at Maggi:


http://www.maggi.de/Rezepte/kochstudio/ ? recipe / prescription search / default.htm id = 12 142 & action = detail

And again:

http://www.ecocktail.de/de/ecocktail-cgi/datenbank/cocktail_rezept.cgi?cocktail_id=2790 & ; cocktail_name Cafe =% 201% 20Royal

Hawaiian Phrases And Translation

Java, HTML and JavaScript source code constitute good on the blog?

In building

want my pages with the GWT, I use the usual HTML tags

H1-H6 . How does it work? The direct use of a label

not work. A statement such as:

add (new Label ("\u0026lt;h1> title \u0026lt;/ h1 >"));

generated in hosted mode the display

\u0026lt;h1> Title \u0026lt; , / h1>

, the tags are so quoted. It is also in the Label

Java Doc

. There is also found the reference on the HTML widget

. This can solve the task. The statement:

add (new HTML ("\u0026lt;h1> title \u0026lt;/ h1 >"));

produces the desired look. must consider only that you lose the security benefits that it provides automatic HTML quoting of Labels .

Are Deep Set Eyes Beautiful

How to do a proper Carajillo?

use in my GWT 1.6 application, both the client-server-side code as well as the same business model classes. These classes are, however, in another Eclipse project and are therefore not simply in my with the Google plugin Eclipse GWT project creator available. To ensure that everything runs smoothly following configurations are required:

Eclipse configuration Simple: 'As always' expand in the Project Properties Java Build Path

the project, in which the business model is developed (ie, extend the CLASSPATH). Then you can be in the client-and server-side programming GWT ever use the appropriate classes in Eclipse.

generation of client-side code

The most in my view, best GWT, namely the translation of JavaScript code from Java code, provides a small complication: The GWT compiler needs for all classes referenced in the client program source code. Without any JS code conversion, and therefore no client application. One finds in the error output of

Hosted Modes

entries like the following, not as long as the business model classes are available:

[ERROR] Line 21: No source code is available for type xyzmodell.KlasseXY, did you forget to inherit a required module?

Similar messages you get when you recompile the project in Eclipse:

Compiling module xyzGWTProj Refresher module from source       Validating newly compiled units          Removing units with errors             [ERROR] Errors in 'file:/…/GWTProj/src/x/y/z/client/Modell.java'                [ERROR] Line 5: The import can not be resolved xyz.modell.KlasseXY ... ..

[ERROR] Line 40: Missing code implementation in the compiler

The reference in the error message on a missing

inherit

take a module in the description of the XML files

. Actually I was hoping that it would at least in the case of classes that are not widgets not be necessary my entire business model with special

module XML files to enforce. But I think unfortunately no way. Therefore had to proceed as follows:

The business model is packaged in org.xy.smod . In this package, I create the new module XML file SMod.gwt.xml

, has the following contents:

\u0026lt;? Xml version = "1.0" encoding = "UTF-8"?> ! \u0026lt;DOCTYPE module PUBLIC "- / / Google Inc. / / DTD Google Web Toolkit 1.6.4 / / EN" "

http://google-web-toolkit.googlecode.com/svn/tags/ 1.6.4/distro-source/core/src/gwt-module.dtd "

>

\u0026lt;module rename-to='smod'>

\u0026lt;source path =" " />

\u0026lt;/ module>


So I put a new 'module' in the name
smod
. The source

statement is necessary so that all classes are directly involved in the package. Otherwise, the file is empty. In particular, not the usual GWT modules such

com.google.gwt.user.User

be involved, including of course there are no entry-point

.

Now I have in the module XML file of my actual application only inherit include this module . The following line is added: ... \u0026lt;inherits name='org.xy.smod.SMod'/>

...

We're done! At least in my area of the GWT compiler will now find the source code of the business model classes that are in another Eclipse project, and can be used to compile as well as the launch in hosted mode to perform successfully.

Note: A good description of the GWT compiler in general can be found in the internet freely available section "Understand the GWT compiler

'from the book
GWT in Practice . test the server-side programming / deployment in the web server
Once you want to test the server-side programming and installing the application WARs in the production server RPC servlets also have the business model classes are available. As this again is a pure Java byte code, only the matter is, for example in the form of a corresponding JARs necessary. The jar, you simply put 'whatever' in
/ WEB-INF/lib / and is ready.

Raylene Richards Camouflage

GWT learning: use of H1, H2, etc. to use for headlines

Here is a small collection of links about serializability in Java, which amounts in particular to the implementation of the interface Serializable

.

Java Rebel: implement Serializable could probably contains EVERYTHING (and more) to know what you want - Java Object Serialization Specification : - Good summary SUN.

short answer to the question of how to make a Java class serializable:

Serializable interface class must implement

class must have a
serialVersionUID and that the value most about the tool included with JDK

servialver

is generated (this may well follow the instructions

the CLASSPATH and NOT accidentally address the source directory). If you use Eclipse, the IDE can also be used to generate. Notes to here.

The final class looks for example like this: public class

SMAbschluss

implements Serializable {

static final long serialVersionUID =- 689428171468533962L;

• ....

Lime Green Pinstripe Suits

External classes in the GWT

About British firm Phorm are

it at present a lot of excitement in the media, for example, in this article on

Heise Online

.
1. You can get it to do with fear, when one reads
, the one in the future cookies not only by the visited web pages (and the many there may GoogleAds integrated, banners, trackers, etc.) can be pushed but also from a 'service' that allows you wanted to do something and never does apparently also at least temporarily, the role of surfing in Web server.
2. Basically it seems essentially a question of whether their own Internet service provider partners with Phorm.

Cake Ideas For A 54th Birthday Part

handling java.io.Serializable

Today, reported a user of our services that has a problem when downloading a Word file from our website. She uses the Internet Explorer (version and operating system unknown). The problem can be seen at "but MSIE 8.0.6001 on Windows XP.
limit 1: Problem with SSL With a newly created test file, the problem can also be verified, it is not so in the special file, which has used a major user. However, the problem occurs only if access to the site using SSL (HTTPS) is carried out. With an HTTP access, there is no problem. limit 2: Problem with certain formats

The problem occurs at least in Word (*. doc extension

) and PDF files (*. pdf extension
). For image files (extension *. jpeg ) it does not occur.

Internet sources
There is a page Microsoft, which is a similar (identical?) Takes care problem, but only up to IE 6 is sufficient.

By the way: this page is an interesting example of the sometimes puzzling results of automatic translations. So one can of neologisms such as: brood 'Cache-Control no-store':)

is Here

an English MS page that will handle the issue (only up to IE 6) applies. A more illuminating description, in

the downside

. solution As in the downside of the

cited blog described the following lines inserted in the servlet:

response.setHeader ("Content-Disposition", "attachment; filename = \\" "+ filename + "\\" ");

response.setHeader (" Pragma "," public ");

response.setHeader (" Cache-Control ", "Max-age = 0"); works

So then in IE 8 and continues in Firefox and Chrome.

I Think I Am Having A Herpes Outbreak

How can you protect yourself from Phorm?

We often have a very large table in the eKVV Search for free rooms . In each cell, the spaces are shown, with the same space can be in different cells at different positions. This can not be prevented because the table would otherwise be even greater. order to view the users yet simple, if the room in other cells (ie, at other times) is available with Javascript and CSS is the following Functionality implemented:

Once the cursor is on a particular area all occurrences of the space in the table are formatted differently.

When the mouse pointer leaves the room is re-established the old format again.

preparation of the common formatting: CSS classes

ensure that the formatting of all occurrences of a room can be done easily with CSS to get the links of the rooms another CSS class that derives from the name space. Example:

\u0026lt;a href=".." class="… raum_h1"> ... \u0026lt;/ a> Because basically in the room with all the characters are allowed an adjustment must be carried out. In the cleanup, all characters except az and away 0-9.

can be marked on a CSS statement like the following, all places with the same room with this preparation:

a.raum_h1

{border: 1px solid black;}

Here are set of fantasy, of course, no limits. The manipulation of the style sheet just for large tables performance advantages compared to the manipulation of each to format element, such as adding / removing a particular class to all links of the same area in the onmouseover / onmouseout

events.

JavaScript functions for the events onmouseover and onmouseout

All we need now are two event handlers to the anchor tag:

onmouseover: when 'entering' the room area with the mouse, the marking with CSS enabled onmouseout:

When leaving the marking must be disabled in order not marked by one, all rooms remain

Because there are so many links, we store the two Actions in its own function definitions. This saves space in the generated HTML code. The anchor tags look like this:
\u0026lt;a class = ".. raum_h11 "

onmouseover =" javascript: zr ('raum_h11' ); "

onmouseout =" javascript: vr () , "...

Now we need only the functions zr

(for

show room) and

vr

implement (for

hiding space) and put in the HTML code of the page. Why the call to

vr

no parameter is passed? This is what we see.

useful instructions on how to manipulate the stylesheet using Javascript, for example, in
DADABase Blog
and the javascript.faqts

. With these tools you can get quickly out the necessary functions. The essential element is the DOM

document.styleSheets

:

\u0026lt;- This empty STYLE tag is used for the following JS! Features ->

\u0026lt;style> \u0026lt;/ style> \u0026lt;script type="text/javascript">

function zr (CssClass) {

& # 160; vr ();
1. & # 160; var = SSHEET document.styleSheets [document.styleSheets.length-1]; ; var selector = "a." + CssClass; var rule = "border: 1px solid black; "
sSheet.insertRule (" "+ selector +" {" + rule + "}", 0);}
2. vr function () { & # 160; was sSheet = document.styleSheets [document.styleSheets.length-1];
while (sSheet.cssRules & & sSheet.cssRules.length> 0) {

; sSheet.deleteRule (0);}

;}

\u0026lt;/ Script>

We make it easy here and attack us with document.styleSheets [document.styleSheets.length-1]

directly on the extra for this purpose created, initially empty STYLE day. If there should follow other style tags, of course, that does not that easy!

This construct works fine in Firefox 3.0.8, 2.0.x in Chrome, Safari 4 Public Beta and Opera 9.64. But of course it works so far on Internet Explorer. And it does not, in fact in MSIE 8th The reason is that the MSIE insertRule not know, but a addRule function. The same applies to the functions of removing Rules . An example of how to handle it, is found in CodingsForums.com . An even more sophisticated trick is described on

TUTORIALHELPDESK.COM

. There, for the MSIE stylesheet object simply adds the missing features. This approach may be the single methods is only when you add the Rules its border, since insertRule fewer parameters than expected addRule .

Armed with this knowledge, we now extend the functions so that they also MSIE work. Here are the results, which now also works in MSIE 8:

\u0026lt;- This empty STYLE tag is used for the following JS functions ->
\u0026lt;style> \u0026lt;/ style>



\u0026lt;script type="text/javascript">

;
function zr (CssClass) {
vr();
        var sSheet = provideSSheet();
        var selector = "a." + cssClass;
        var rule = "border: 1px solid black;";
        try {           
sSheet.insertRule (" , "+ selector +" {"+ rule +"} ", 0); & # 160;} catch (msie) {

& # 160; try {

sSheet.addRule(selector, rule);

            } catch (err) {             }         }

    }

    function vr () {

was sSheet provideSSheet = ();

& # 160; while (sSheet.cssRules & & sSheet.cssRules.length> 0) { ; sSheet.deleteRule (0); & # 160; }     }     function provideSSheet() {         var sSheet = document.styleSheets[document.styleSheets.length-1];         // Check to see if we are operating in Internet Explorer         if (sSheet.rules)         {             // Map the standard DOM attributes and methods to the internet explorer             // equivalents             sSheet.cssRules = sSheet.rules;  sSheet.deleteRule = function (ruleIndex) { & # 160 this.removeRule (ruleIndex) }; & # 160;}

& # SSHEET return;, 160

} \u0026lt;/ script>

We're done! And so it looks like this:

experience

The solution seems to react differently in different browsers quickly. Here are some initial experience:


Firefox:
Basically, the easiest. Everything is fluid.


Opera:
Similar to Firefox.


Chrome / Safari:
The very first call to the JS functions takes a certain time, after which all liquid


MSIE 8:
Never really fast, the rapid scrolling through the pages is sometimes hampered by the JS functions