diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..41dd57c
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,43 @@
+**/bin/
+**/target/
+**._trace
+**/WebContent/
+**/build/
+**/error-screenshots/
+**/reference-screenshots/
+**.DS_Store
+**git.properties
+
+**/target/
+**/.metadata/
+
+**/emf-gen/**/.gitignore
+**/src-gen/**/.gitignore
+**/git.properties
+**/*.java._trace
+**/*.log
+**/*.log.properties
+
+**/bin/
+**/build/
+*.class
+*.ctrl
+**/Debug/
+.DS_Store
+*.ear
+*.war
+
+**/*.actionbin
+**/*.blipbin
+**/*.chartbin
+**/*.cubebin
+**/*.datatypebin
+**/*.dtobin
+**/*.entitybin
+**/*.servicebin
+**/*.tablebin
+**/*.uibin
+**/*.uisemanticbin
+**/*.xtendbin
+**/*.xtextbin
+
diff --git a/.settings/org.eclipse.core.resources.prefs b/.settings/org.eclipse.core.resources.prefs
new file mode 100644
index 0000000..99f26c0
--- /dev/null
+++ b/.settings/org.eclipse.core.resources.prefs
@@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+encoding/<project>=UTF-8
diff --git a/.settings/org.eclipse.m2e.core.prefs b/.settings/org.eclipse.m2e.core.prefs
new file mode 100644
index 0000000..f897a7f
--- /dev/null
+++ b/.settings/org.eclipse.m2e.core.prefs
@@ -0,0 +1,4 @@
+activeProfiles=
+eclipse.preferences.version=1
+resolveWorkspaceProjects=true
+version=1
diff --git a/org.eclipse.osbp.vaadin.addons.absolutelayout/.classpath b/org.eclipse.osbp.vaadin.addons.absolutelayout/.classpath
new file mode 100644
index 0000000..da23375
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.absolutelayout/.classpath
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry including="**/*.java" kind="src" output="target/classes" path="src">
+		<attributes>
+			<attribute name="optional" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="src" path="sample"/>
+	<classpathentry kind="con" path="org.eclipse.jst.j2ee.internal.web.container"/>
+	<classpathentry kind="con" path="org.eclipse.jst.j2ee.internal.module.container"/>
+	<classpathentry kind="src" path="test"/>
+	<classpathentry kind="con" path="org.apache.ivyde.eclipse.cpcontainer.IVYDE_CONTAINER/?project=org.eclipse.osbp.vaadin.addons.absolutelayout&amp;ivyXmlPath=ivy.xml&amp;confs=default&amp;ivySettingsPath=%24%7Bworkspace_loc%3Aorg.eclipse.osbp.vaadin.addons.absolutelayout%2Fivysettings.xml%7D&amp;loadSettingsOnDemand=false&amp;ivyUserDir=&amp;propertyFiles=">
+		<attributes>
+			<attribute name="org.eclipse.jst.component.dependency" value="/WEB-INF/lib"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.apache.ivyde.eclipse.cpcontainer.IVYDE_CONTAINER/?project=org.eclipse.osbp.vaadin.addons.absolutelayout&amp;ivyXmlPath=ivy.xml&amp;confs=widgetset-compile&amp;ivySettingsPath=%24%7Bworkspace_loc%3Aorg.eclipse.osbp.vaadin.addons.absolutelayout%2Fivysettings.xml%7D&amp;loadSettingsOnDemand=false&amp;ivyUserDir=&amp;propertyFiles="/>
+	<classpathentry kind="con" path="org.apache.ivyde.eclipse.cpcontainer.IVYDE_CONTAINER/?project=org.eclipse.osbp.vaadin.addons.absolutelayout&amp;ivyXmlPath=ivy.xml&amp;confs=nodeploy&amp;ivySettingsPath=%24%7Bworkspace_loc%3Aorg.eclipse.osbp.vaadin.addons.absolutelayout%2Fivysettings.xml%7D&amp;loadSettingsOnDemand=false&amp;ivyUserDir=&amp;propertyFiles="/>
+	<classpathentry exported="true" kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="output" path="target/classes"/>
+</classpath>
diff --git a/org.eclipse.osbp.vaadin.addons.absolutelayout/.gitignore b/org.eclipse.osbp.vaadin.addons.absolutelayout/.gitignore
new file mode 100644
index 0000000..9c43300
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.absolutelayout/.gitignore
@@ -0,0 +1,3 @@
+META-INF/
+**/git.properties
+**/target/
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaadin.addons.absolutelayout/.settings/.jsdtscope b/org.eclipse.osbp.vaadin.addons.absolutelayout/.settings/.jsdtscope
new file mode 100644
index 0000000..92e666d
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.absolutelayout/.settings/.jsdtscope
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry excluding="**/bower_components/*|**/node_modules/*|**/*.min.js" kind="src" path="WebContent"/>
+	<classpathentry kind="con" path="org.eclipse.wst.jsdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="con" path="org.eclipse.wst.jsdt.launching.WebProject">
+		<attributes>
+			<attribute name="hide" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.wst.jsdt.launching.baseBrowserLibrary"/>
+	<classpathentry kind="output" path=""/>
+</classpath>
diff --git a/org.eclipse.osbp.vaadin.addons.absolutelayout/.settings/com.vaadin.integration.eclipse.prefs b/org.eclipse.osbp.vaadin.addons.absolutelayout/.settings/com.vaadin.integration.eclipse.prefs
new file mode 100644
index 0000000..6f6c7b3
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.absolutelayout/.settings/com.vaadin.integration.eclipse.prefs
@@ -0,0 +1,11 @@
+com.vaadin.integration.eclipse.notifyOfVaadinUpdates=false
+com.vaadin.integration.eclipse.previousCompileAction=widgetset
+com.vaadin.integration.eclipse.useLatestNightly=false
+com.vaadin.integration.eclipse.widgetsetBuildsSuspended=true
+com.vaadin.integration.eclipse.widgetsetCompilationEta=62314
+com.vaadin.integration.eclipse.widgetsetDirty=true
+com.vaadin.integration.eclipse.widgetsetExtraParameters=-logLevel WARN
+com.vaadin.integration.eclipse.widgetsetParallelism=4
+com.vaadin.integration.eclipse.widgetsetStyle=OBF
+com.vaadin.integration.eclipse.widgetsetVerbose=true
+eclipse.preferences.version=1
diff --git a/org.eclipse.osbp.vaadin.addons.absolutelayout/.settings/org.apache.ivyde.eclipse.prefs b/org.eclipse.osbp.vaadin.addons.absolutelayout/.settings/org.apache.ivyde.eclipse.prefs
new file mode 100644
index 0000000..a95f744
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.absolutelayout/.settings/org.apache.ivyde.eclipse.prefs
@@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+org.apache.ivyde.eclipse.standaloneretrieve=<?xml version\="1.0" encoding\="UTF-8" standalone\="no"?><setuplist/>
diff --git a/org.eclipse.osbp.vaadin.addons.absolutelayout/.settings/org.eclipse.core.resources.prefs b/org.eclipse.osbp.vaadin.addons.absolutelayout/.settings/org.eclipse.core.resources.prefs
new file mode 100644
index 0000000..7a53139
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.absolutelayout/.settings/org.eclipse.core.resources.prefs
@@ -0,0 +1,3 @@
+eclipse.preferences.version=1
+encoding/<project>=UTF-8
+encoding/src=UTF-8
diff --git a/org.eclipse.osbp.vaadin.addons.absolutelayout/.settings/org.eclipse.jdt.core.prefs b/org.eclipse.osbp.vaadin.addons.absolutelayout/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..13b3428
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.absolutelayout/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,13 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.methodParameters=do not generate
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
+org.eclipse.jdt.core.compiler.source=1.8
diff --git a/org.eclipse.osbp.vaadin.addons.absolutelayout/.settings/org.eclipse.jst.j2ee.ejb.annotations.xdoclet.prefs b/org.eclipse.osbp.vaadin.addons.absolutelayout/.settings/org.eclipse.jst.j2ee.ejb.annotations.xdoclet.prefs
new file mode 100644
index 0000000..7c8126d
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.absolutelayout/.settings/org.eclipse.jst.j2ee.ejb.annotations.xdoclet.prefs
@@ -0,0 +1,5 @@
+XDOCLETBUILDERACTIVE=true
+XDOCLETHOME=
+XDOCLETUSEGLOBAL=true
+XDOCLETVERSION=1.2.1
+eclipse.preferences.version=1
diff --git a/org.eclipse.osbp.vaadin.addons.absolutelayout/.settings/org.eclipse.m2e.core.prefs b/org.eclipse.osbp.vaadin.addons.absolutelayout/.settings/org.eclipse.m2e.core.prefs
new file mode 100644
index 0000000..f897a7f
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.absolutelayout/.settings/org.eclipse.m2e.core.prefs
@@ -0,0 +1,4 @@
+activeProfiles=
+eclipse.preferences.version=1
+resolveWorkspaceProjects=true
+version=1
diff --git a/org.eclipse.osbp.vaadin.addons.absolutelayout/.settings/org.eclipse.wst.common.component b/org.eclipse.osbp.vaadin.addons.absolutelayout/.settings/org.eclipse.wst.common.component
new file mode 100644
index 0000000..96aa954
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.absolutelayout/.settings/org.eclipse.wst.common.component
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?><project-modules id="moduleCoreId" project-version="1.5.0">
+    <wb-module deploy-name="org.osbee.vaadin.addons.absolutelayout">
+        <wb-resource deploy-path="/" source-path="/WebContent" tag="defaultRootSource"/>
+        <wb-resource deploy-path="/WEB-INF/classes" source-path="/src"/>
+        <wb-resource deploy-path="/WEB-INF/classes" source-path="/sample"/>
+        <property name="java-output-path" value="/org.osbee.vaadin.addons.absolutelayout/build/classes"/>
+        <property name="context-root" value="org.osbee.vaadin.addons.absolutelayout"/>
+    </wb-module>
+</project-modules>
diff --git a/org.eclipse.osbp.vaadin.addons.absolutelayout/.settings/org.eclipse.wst.common.project.facet.core.xml b/org.eclipse.osbp.vaadin.addons.absolutelayout/.settings/org.eclipse.wst.common.project.facet.core.xml
new file mode 100644
index 0000000..f67d52d
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.absolutelayout/.settings/org.eclipse.wst.common.project.facet.core.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<faceted-project>
+  <fixed facet="wst.jsdt.web"/>
+  <fixed facet="java"/>
+  <fixed facet="com.vaadin.integration.eclipse.core"/>
+  <fixed facet="jst.web"/>
+  <installed facet="jst.web" version="3.0"/>
+  <installed facet="com.vaadin.integration.eclipse.core" version="7.0"/>
+  <installed facet="wst.jsdt.web" version="1.0"/>
+  <installed facet="java" version="1.7"/>
+</faceted-project>
diff --git a/org.eclipse.osbp.vaadin.addons.absolutelayout/.settings/org.eclipse.wst.jsdt.ui.superType.container b/org.eclipse.osbp.vaadin.addons.absolutelayout/.settings/org.eclipse.wst.jsdt.ui.superType.container
new file mode 100644
index 0000000..3bd5d0a
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.absolutelayout/.settings/org.eclipse.wst.jsdt.ui.superType.container
@@ -0,0 +1 @@
+org.eclipse.wst.jsdt.launching.baseBrowserLibrary
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaadin.addons.absolutelayout/.settings/org.eclipse.wst.jsdt.ui.superType.name b/org.eclipse.osbp.vaadin.addons.absolutelayout/.settings/org.eclipse.wst.jsdt.ui.superType.name
new file mode 100644
index 0000000..05bd71b
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.absolutelayout/.settings/org.eclipse.wst.jsdt.ui.superType.name
@@ -0,0 +1 @@
+Window
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaadin.addons.absolutelayout/META-INF/MANIFEST.MF b/org.eclipse.osbp.vaadin.addons.absolutelayout/META-INF/MANIFEST.MF
index c01b4d9..abf1206 100644
--- a/org.eclipse.osbp.vaadin.addons.absolutelayout/META-INF/MANIFEST.MF
+++ b/org.eclipse.osbp.vaadin.addons.absolutelayout/META-INF/MANIFEST.MF
@@ -1,31 +1,37 @@
 Manifest-Version: 1.0
-Bnd-LastModified: 1491902092179
-Build-Jdk: 1.8.0_91
+Bnd-LastModified: 1467971825881
+Build-Jdk: 1.8.0_65
 Built-By: mollik
 Bundle-ActivationPolicy: lazy
 Bundle-Description: A parent POM aimed to set up the build of general Ma
  ven based projects.
-Bundle-DocURL: http://www.eclipse.org/osbp
+Bundle-DocURL: www.osbee.org
 Bundle-ManifestVersion: 2
 Bundle-Name: org.eclipse.osbp.vaadin.addons.absolutelayout
-Bundle-RequiredExecutionEnvironment: JavaSE-1.8
+Bundle-RequiredExecutionEnvironment: JavaSE-1.7
 Bundle-SymbolicName: org.eclipse.osbp.vaadin.addons.absolutelayout
-Bundle-Vendor: Eclipse OSBP
+Bundle-Vendor: Loetz GmbH&Co.KG - 69115 Heidelberg - Germany
 Bundle-Version: 0.9.0.qualifier
 Created-By: Apache Maven Bundle Plugin
 Export-Package: org.eclipse.osbp.vaadin.addons.absolutelayout;version="0
  .9.0",org.eclipse.osbp.vaadin.addons.absolutelayout.client;version="0.9
  .0",org.eclipse.osbp.vaadin.addons.absolutelayout.public.oabsolutelayou
  t;version="0.9.0"
-Import-Package: com.vaadin.annotations;version="[7.5.7,7.7.0)",com.vaadi
- n.client.communication;version="[7.5.7,7.7.0)",com.vaadin.client.ui.dd;
- version="[7.5.7,7.7.0)",com.vaadin.server;version="[7.5.7,7.7.0)",com.v
- aadin.ui;version="[7.5.7,7.7.0)",javax.servlet.annotation;resolution:=o
- ptional;version="[3.0,4)",org.eclipse.osbp.vaadin.addons.absolutelayout
- .client;version="[0.9,1)",org.junit
+Import-Package: com.vaadin.client;version="[7.5.7,7.7.0)",com.vaadin.cli
+ ent.communication;version="[7.5.7,7.7.0)",com.vaadin.client.ui;version=
+ "[7.5.7,7.7.0)",com.vaadin.client.ui.dd;version="[7.5.7,7.7.0)",com.vaa
+ din.server;version="[7.5.7,7.7.0)",com.vaadin.shared;version="[7.5.7,7.
+ 7.0)",com.vaadin.shared.communication;version="[7.5.7,7.7.0)",com.vaadi
+ n.shared.ui;version="[7.5.7,7.7.0)",com.vaadin.shared.ui.absolutelayout
+ ;version="[7.5.7,7.7.0)",com.vaadin.ui;version="[7.5.7,7.7.0)",com.vaad
+ in.util;version="[7.5.7,7.7.0)",com.google.gwt.core.client;version="[7.
+ 5,8)",com.google.gwt.dom.client;version="[7.5,8)",com.google.gwt.event.
+ shared;version="[7.5,8)",com.google.gwt.user.client;version="[7.5,8)",c
+ om.google.gwt.user.client.ui;version="[7.5,8)",javax.servlet.annotation
+ ;resolution:=optional;version="[3.0,4)"
 Require-Bundle: com.vaadin.server;bundle-version="[7.5.7,7.7.0)",com.vaa
  din.client;bundle-version="[7.5.7,7.7.0)",com.vaadin.shared;bundle-vers
  ion="[7.5.7,7.7.0)",org.jsoup;bundle-version="[1.8.3,1.8.4)",dragdropla
  youts.osgi;bundle-version="[1.1.3,1.1.4)"
 Require-Capability: osgi.ee;filter:="(&(osgi.ee=JavaSE)(version=1.8))"
-Tool: Bnd-3.2.0.201605172007
+Tool: Bnd-2.3.0.201405100607
diff --git a/org.eclipse.osbp.vaadin.addons.absolutelayout/META-INF/git.properties b/org.eclipse.osbp.vaadin.addons.absolutelayout/META-INF/git.properties
index 5eccd6e..96b55fc 100644
--- a/org.eclipse.osbp.vaadin.addons.absolutelayout/META-INF/git.properties
+++ b/org.eclipse.osbp.vaadin.addons.absolutelayout/META-INF/git.properties
@@ -1,14 +1,14 @@
 #Generated by Git-Commit-Id-Plugin
-#Tue Apr 11 11:17:32 CEST 2017
+#Thu Jul 14 16:21:42 CEST 2016
 git.remote.origin.url=ssh\://compex@10.1.13.14/osbpgit/org.eclipse.osbp.vaadin.addons.git
-git.closest.tag.name=OSBP-initial-commit-2-Eclipse-4-luna-2017-03-31-17-10-39
-git.commit.id.describe-short=OSBP-initial-commit-2-Eclipse-4-luna-2017-03-31-17-10-39-dirty
-git.commit.time=02.02.2017 @ 18\:04\:55 MEZ
-git.commit.message.full=remove the feature from build
-git.commit.message.short=remove the feature from build
-git.commit.id.abbrev=90dd482
-git.branch=OSBP-initial-commit-2-Eclipse-4-luna
-git.closest.tag.commit.count=0
-git.commit.id.describe=OSBP-initial-commit-2-Eclipse-4-luna-2017-03-31-17-10-39-dirty
-git.commit.id=90dd482e5bc78cd1a404d12445cebc868ee417b0
-git.tags=OSBP-initial-commit-2-Eclipse-4-luna-2017-03-31-17-10-39
+git.closest.tag.name=
+git.commit.id.describe-short=8e68853-dirty
+git.commit.time=08.07.2016 @ 12\:02\:34 MESZ
+git.commit.message.full=Merge branch 'mavenizing' of ssh\://10.1.13.14/osbpgit/org.eclipse.osbp.vaadin.addons into mavenizing
+git.commit.message.short=Merge branch 'mavenizing' of ssh\://10.1.13.14/osbpgit/org.eclipse.osbp.vaadin.addons into mavenizing
+git.commit.id.abbrev=8e68853
+git.branch=mavenizing
+git.closest.tag.commit.count=
+git.commit.id.describe=8e68853-dirty
+git.commit.id=8e688530eab4a10955fec4308c9265c6a00ed4c9
+git.tags=
diff --git a/org.eclipse.osbp.vaadin.addons.absolutelayout/pom.xml b/org.eclipse.osbp.vaadin.addons.absolutelayout/pom.xml
index 24eaf9f..1bcf950 100644
--- a/org.eclipse.osbp.vaadin.addons.absolutelayout/pom.xml
+++ b/org.eclipse.osbp.vaadin.addons.absolutelayout/pom.xml
@@ -38,6 +38,11 @@
 			<version>${vaadin.version}</version>
 		</dependency>
 		<dependency>
+			<groupId>com.vaadin</groupId>
+			<artifactId>vaadin-shared</artifactId>
+			<version>${vaadin.version}</version>
+		</dependency>
+		<dependency>
 			<groupId>javax.servlet</groupId>
 			<artifactId>javax.servlet-api</artifactId>
 			<version>3.0.1</version>
@@ -45,7 +50,7 @@
 		<dependency>
 			<groupId>org.eclipse.osbp.dependencies</groupId>
 			<artifactId>org.eclipse.osbp.dependencies.bundle.vaadin.addon.dragdroplayouts</artifactId>
-			<version>1.1.3-SNAPSHOT</version>
+			<version>1.3.2-SNAPSHOT</version>
 		</dependency>
 	</dependencies>
 
@@ -63,7 +68,6 @@
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-compiler-plugin</artifactId>
-				<version>3.0</version>
 				<configuration>
 					<encoding>UTF-8</encoding>
 					<source>1.8</source>
@@ -79,17 +83,17 @@
 					<instructions>
 						<Bundle-Name>OSBP Addon for Vaadin: Absolute Layout</Bundle-Name>
 						<Bundle-SymbolicName>org.eclipse.osbp.vaadin.addons.absolutelayout</Bundle-SymbolicName>
-                        <Bundle-Version>0.9.0.{osgi-version-qualifier}</Bundle-Version>
-						<Require-Bundle>com.vaadin.server;bundle-version="[7.5.7,7.7.0)",
-							com.vaadin.client;bundle-version="[7.5.7,7.7.0)",
-							com.vaadin.shared;bundle-version="[7.5.7,7.7.0)",
+						<Bundle-Version>0.9.0.{osgi-version-qualifier}</Bundle-Version>
+						<Require-Bundle>com.vaadin.server;bundle-version="[7.7.6,7.8.0)",
+							com.vaadin.client;bundle-version="[7.7.6,7.8.0)",
+							com.vaadin.shared;bundle-version="[7.7.6,7.8.0)",
 							org.jsoup;bundle-version="[1.8.3,1.8.4)",
-							dragdroplayouts.osgi;bundle-version="[1.1.3,1.1.4)"
+							dragdroplayouts.osgi;bundle-version="[1.3.2,1.3.3)"
 						</Require-Bundle>
 						<Import-Package>
-							com.vaadin.*;version="[7.5.7,7.7.0)",
+							com.vaadin.*;version="[7.7.6,7.8.0)",
 							!fi.jasoft.*,
-                            javax.servlet.annotation;resolution:=optional,
+							javax.servlet.annotation;resolution:=optional,
 							*
 						</Import-Package>
 						<Export-Package>
@@ -105,7 +109,6 @@
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-source-plugin</artifactId>
-				<version>2.2.1</version>
 				<executions>
 					<execution>
 						<id>attach-sources</id>
diff --git a/org.eclipse.osbp.vaadin.addons.designer.overlay/.classpath b/org.eclipse.osbp.vaadin.addons.designer.overlay/.classpath
new file mode 100644
index 0000000..972cf35
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.designer.overlay/.classpath
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry including="**/*.java" kind="src" output="target/classes" path="src">
+		<attributes>
+			<attribute name="optional" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="src" path="sample"/>
+	<classpathentry kind="con" path="org.eclipse.jst.j2ee.internal.web.container"/>
+	<classpathentry kind="con" path="org.eclipse.jst.j2ee.internal.module.container"/>
+	<classpathentry kind="src" path="test"/>
+	<classpathentry kind="con" path="org.apache.ivyde.eclipse.cpcontainer.IVYDE_CONTAINER/?project=org.eclipse.osbp.vaadin.addons.designer.overlay&amp;ivyXmlPath=ivy.xml&amp;confs=default&amp;ivySettingsPath=%24%7Bworkspace_loc%3Aorg.eclipse.osbp.vaadin.addons.designer.overlay%2Fivysettings.xml%7D&amp;loadSettingsOnDemand=false&amp;ivyUserDir=&amp;propertyFiles=">
+		<attributes>
+			<attribute name="org.eclipse.jst.component.dependency" value="/WEB-INF/lib"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.apache.ivyde.eclipse.cpcontainer.IVYDE_CONTAINER/?project=org.eclipse.osbp.vaadin.addons.designer.overlay&amp;ivyXmlPath=ivy.xml&amp;confs=widgetset-compile&amp;ivySettingsPath=%24%7Bworkspace_loc%3Aorg.eclipse.osbp.vaadin.addons.designer.overlay%2Fivysettings.xml%7D&amp;loadSettingsOnDemand=false&amp;ivyUserDir=&amp;propertyFiles="/>
+	<classpathentry kind="con" path="org.apache.ivyde.eclipse.cpcontainer.IVYDE_CONTAINER/?project=org.eclipse.osbp.vaadin.addons.designer.overlay&amp;ivyXmlPath=ivy.xml&amp;confs=nodeploy&amp;ivySettingsPath=%24%7Bworkspace_loc%3Aorg.eclipse.osbp.vaadin.addons.designer.overlay%2Fivysettings.xml%7D&amp;loadSettingsOnDemand=false&amp;ivyUserDir=&amp;propertyFiles="/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry exported="true" kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="output" path="target/classes"/>
+</classpath>
diff --git a/org.eclipse.osbp.vaadin.addons.designer.overlay/.gitignore b/org.eclipse.osbp.vaadin.addons.designer.overlay/.gitignore
new file mode 100644
index 0000000..9c43300
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.designer.overlay/.gitignore
@@ -0,0 +1,3 @@
+META-INF/
+**/git.properties
+**/target/
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaadin.addons.designer.overlay/.settings/.jsdtscope b/org.eclipse.osbp.vaadin.addons.designer.overlay/.settings/.jsdtscope
new file mode 100644
index 0000000..92e666d
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.designer.overlay/.settings/.jsdtscope
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry excluding="**/bower_components/*|**/node_modules/*|**/*.min.js" kind="src" path="WebContent"/>
+	<classpathentry kind="con" path="org.eclipse.wst.jsdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="con" path="org.eclipse.wst.jsdt.launching.WebProject">
+		<attributes>
+			<attribute name="hide" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.wst.jsdt.launching.baseBrowserLibrary"/>
+	<classpathentry kind="output" path=""/>
+</classpath>
diff --git a/org.eclipse.osbp.vaadin.addons.designer.overlay/.settings/com.vaadin.designer.prefs b/org.eclipse.osbp.vaadin.addons.designer.overlay/.settings/com.vaadin.designer.prefs
new file mode 100644
index 0000000..935ea6e
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.designer.overlay/.settings/com.vaadin.designer.prefs
@@ -0,0 +1,6 @@
+eclipse.preferences.version=1
+paletteComponents={"groups"\:{"Components"\:{"classes"\:["com.vaadin.ui.Audio","com.vaadin.ui.BrowserFrame","com.vaadin.ui.Button","com.vaadin.ui.CheckBox","com.vaadin.ui.ColorPicker","com.vaadin.ui.ColorPickerArea","com.vaadin.ui.ComboBox","com.vaadin.ui.DateField","com.vaadin.ui.Flash","com.vaadin.ui.Grid","com.vaadin.ui.Image","com.vaadin.ui.InlineDateField","com.vaadin.ui.Label","com.vaadin.ui.Link","com.vaadin.ui.ListSelect","com.vaadin.ui.MenuBar","com.vaadin.ui.NativeButton","com.vaadin.ui.NativeSelect","com.vaadin.ui.OptionGroup","com.vaadin.ui.PasswordField","com.vaadin.ui.PopupDateField","com.vaadin.ui.ProgressBar","com.vaadin.ui.RichTextArea","com.vaadin.ui.Slider","com.vaadin.ui.Table","com.vaadin.ui.TextArea","com.vaadin.ui.TextField","com.vaadin.ui.Tree","com.vaadin.ui.TreeTable","com.vaadin.ui.TwinColSelect","com.vaadin.ui.Upload","com.vaadin.ui.Video"]},"Layouts"\:{"classes"\:["com.vaadin.ui.AbsoluteLayout","com.vaadin.ui.Accordion","com.vaadin.ui.CssLayout","com.vaadin.ui.FormLayout","com.vaadin.ui.GridLayout","com.vaadin.ui.HorizontalLayout","com.vaadin.ui.HorizontalSplitPanel","com.vaadin.ui.Panel","com.vaadin.ui.TabSheet","com.vaadin.ui.VerticalLayout","com.vaadin.ui.VerticalSplitPanel"]},"Project components"\:{"classes"\:[]}}}
+paletteViewMode=GRID
+serverAddress=192.168.0.100
+serverPort=55945
+theme=org_osbee_vaadin_addons_designer_overlay
diff --git a/org.eclipse.osbp.vaadin.addons.designer.overlay/.settings/com.vaadin.integration.eclipse.prefs b/org.eclipse.osbp.vaadin.addons.designer.overlay/.settings/com.vaadin.integration.eclipse.prefs
new file mode 100644
index 0000000..3121837
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.designer.overlay/.settings/com.vaadin.integration.eclipse.prefs
@@ -0,0 +1,10 @@
+com.vaadin.integration.eclipse.previousCompileAction=widgetset
+com.vaadin.integration.eclipse.useLatestNightly=false
+com.vaadin.integration.eclipse.widgetsetBuildsSuspended=true
+com.vaadin.integration.eclipse.widgetsetCompilationEta=51853
+com.vaadin.integration.eclipse.widgetsetDirty=true
+com.vaadin.integration.eclipse.widgetsetExtraParameters=-logLevel WARN
+com.vaadin.integration.eclipse.widgetsetParallelism=2
+com.vaadin.integration.eclipse.widgetsetStyle=OBF
+com.vaadin.integration.eclipse.widgetsetVerbose=true
+eclipse.preferences.version=1
diff --git a/org.eclipse.osbp.vaadin.addons.designer.overlay/.settings/org.eclipse.core.resources.prefs b/org.eclipse.osbp.vaadin.addons.designer.overlay/.settings/org.eclipse.core.resources.prefs
new file mode 100644
index 0000000..7a53139
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.designer.overlay/.settings/org.eclipse.core.resources.prefs
@@ -0,0 +1,3 @@
+eclipse.preferences.version=1
+encoding/<project>=UTF-8
+encoding/src=UTF-8
diff --git a/org.eclipse.osbp.vaadin.addons.designer.overlay/.settings/org.eclipse.jdt.core.prefs b/org.eclipse.osbp.vaadin.addons.designer.overlay/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..13b3428
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.designer.overlay/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,13 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.methodParameters=do not generate
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
+org.eclipse.jdt.core.compiler.source=1.8
diff --git a/org.eclipse.osbp.vaadin.addons.designer.overlay/.settings/org.eclipse.m2e.core.prefs b/org.eclipse.osbp.vaadin.addons.designer.overlay/.settings/org.eclipse.m2e.core.prefs
new file mode 100644
index 0000000..f897a7f
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.designer.overlay/.settings/org.eclipse.m2e.core.prefs
@@ -0,0 +1,4 @@
+activeProfiles=
+eclipse.preferences.version=1
+resolveWorkspaceProjects=true
+version=1
diff --git a/org.eclipse.osbp.vaadin.addons.designer.overlay/.settings/org.eclipse.wst.common.component b/org.eclipse.osbp.vaadin.addons.designer.overlay/.settings/org.eclipse.wst.common.component
new file mode 100644
index 0000000..8c1e84d
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.designer.overlay/.settings/org.eclipse.wst.common.component
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?><project-modules id="moduleCoreId" project-version="1.5.0">
+    <wb-module deploy-name="org.osbee.vaadin.addons.designer.overlay">
+        <wb-resource deploy-path="/" source-path="/WebContent" tag="defaultRootSource"/>
+        <wb-resource deploy-path="/WEB-INF/classes" source-path="/src"/>
+        <wb-resource deploy-path="/WEB-INF/classes" source-path="/sample"/>
+        <property name="context-root" value="org.osbee.vaadin.addons.designer.overlay"/>
+        <property name="java-output-path" value="/org.osbee.vaadin.addons.designer.overlay/build/classes"/>
+    </wb-module>
+</project-modules>
diff --git a/org.eclipse.osbp.vaadin.addons.designer.overlay/.settings/org.eclipse.wst.common.project.facet.core.xml b/org.eclipse.osbp.vaadin.addons.designer.overlay/.settings/org.eclipse.wst.common.project.facet.core.xml
new file mode 100644
index 0000000..f67d52d
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.designer.overlay/.settings/org.eclipse.wst.common.project.facet.core.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<faceted-project>
+  <fixed facet="wst.jsdt.web"/>
+  <fixed facet="java"/>
+  <fixed facet="com.vaadin.integration.eclipse.core"/>
+  <fixed facet="jst.web"/>
+  <installed facet="jst.web" version="3.0"/>
+  <installed facet="com.vaadin.integration.eclipse.core" version="7.0"/>
+  <installed facet="wst.jsdt.web" version="1.0"/>
+  <installed facet="java" version="1.7"/>
+</faceted-project>
diff --git a/org.eclipse.osbp.vaadin.addons.designer.overlay/.settings/org.eclipse.wst.jsdt.ui.superType.container b/org.eclipse.osbp.vaadin.addons.designer.overlay/.settings/org.eclipse.wst.jsdt.ui.superType.container
new file mode 100644
index 0000000..3bd5d0a
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.designer.overlay/.settings/org.eclipse.wst.jsdt.ui.superType.container
@@ -0,0 +1 @@
+org.eclipse.wst.jsdt.launching.baseBrowserLibrary
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaadin.addons.designer.overlay/.settings/org.eclipse.wst.jsdt.ui.superType.name b/org.eclipse.osbp.vaadin.addons.designer.overlay/.settings/org.eclipse.wst.jsdt.ui.superType.name
new file mode 100644
index 0000000..05bd71b
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.designer.overlay/.settings/org.eclipse.wst.jsdt.ui.superType.name
@@ -0,0 +1 @@
+Window
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaadin.addons.designer.overlay/pom.xml b/org.eclipse.osbp.vaadin.addons.designer.overlay/pom.xml
index cb11805..27050f4 100644
--- a/org.eclipse.osbp.vaadin.addons.designer.overlay/pom.xml
+++ b/org.eclipse.osbp.vaadin.addons.designer.overlay/pom.xml
@@ -37,6 +37,11 @@
 			<version>${vaadin.version}</version>
 		</dependency>
 		<dependency>
+			<groupId>com.vaadin</groupId>
+			<artifactId>vaadin-shared</artifactId>
+			<version>${vaadin.version}</version>
+		</dependency>
+		<dependency>
 			<groupId>javax.servlet</groupId>
 			<artifactId>javax.servlet-api</artifactId>
 			<version>3.0.1</version>
@@ -57,7 +62,6 @@
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-compiler-plugin</artifactId>
-				<version>3.0</version>
 				<configuration>
 					<encoding>UTF-8</encoding>
 					<source>1.8</source>
@@ -65,11 +69,6 @@
 				</configuration>
 			</plugin>
 
-			<!--<plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-jar-plugin</artifactId> 
-				<version>2.3.1</version> <configuration> <archive> <index>true</index> <manifestEntries> 
-				<Bundle-SymbolicName>org.eclipse.osbp.vaadin.addons.absolutelayout</Bundle-SymbolicName> 
-				<Vaadin-Stylesheets>/VAADIN/addons/osbee/vaadin/addons/absolutelayout/styles.scss</Vaadin-Stylesheets> 
-				</manifestEntries> </archive> </configuration> </plugin> -->
 			<plugin>
 				<groupId>org.apache.felix</groupId>
 				<artifactId>maven-bundle-plugin</artifactId>
@@ -78,14 +77,14 @@
 					<instructions>
 						<Bundle-Name>OSBP Addon for Vaadin: Designer Overlay</Bundle-Name>
 						<Bundle-SymbolicName>org.eclipse.osbp.vaadin.addons.designer.overlay</Bundle-SymbolicName>
-                        <Bundle-Version>0.9.0.{osgi-version-qualifier}</Bundle-Version>
-						<Require-Bundle>com.vaadin.server;bundle-version="[7.5.7,7.7.0)",
-							com.vaadin.client;bundle-version="[7.5.7,7.7.0)",
-							com.vaadin.shared;bundle-version="[7.5.7,7.7.0)",
+						<Bundle-Version>0.9.0.{osgi-version-qualifier}</Bundle-Version>
+						<Require-Bundle>com.vaadin.server;bundle-version="[7.7.6,7.8.0)",
+							com.vaadin.client;bundle-version="[7.7.6,7.8.0)",
+							com.vaadin.shared;bundle-version="[7.7.6,7.8.0)",
 							org.jsoup;bundle-version="[1.8.3,1.8.4)"
 						</Require-Bundle>
 						<Import-Package>
-                            javax.servlet.annotation;resolution:=optional,
+							javax.servlet.annotation;resolution:=optional,
 							*
 						</Import-Package>
 						<Export-Package>
@@ -98,13 +97,10 @@
 					</instructions>
 				</configuration>
 			</plugin>
-			<!-- <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-javadoc-plugin</artifactId> 
-				<version>2.9</version> <executions> <execution> <id>attach-javadoc</id> <goals> 
-				<goal>jar</goal> </goals> </execution> </executions> </plugin> -->
+
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-source-plugin</artifactId>
-				<version>2.2.1</version>
 				<executions>
 					<execution>
 						<id>attach-sources</id>
diff --git a/org.eclipse.osbp.vaadin.addons.kanban/.classpath b/org.eclipse.osbp.vaadin.addons.kanban/.classpath
new file mode 100644
index 0000000..6568971
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.kanban/.classpath
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry including="**/*.java" kind="src" output="target/classes" path="src">
+		<attributes>
+			<attribute name="optional" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="src" path="Sample"/>
+	<classpathentry kind="con" path="org.eclipse.jst.server.core.container/org.eclipse.jst.server.tomcat.runtimeTarget/Apache Tomcat v8.0">
+		<attributes>
+			<attribute name="owner.project.facets" value="jst.web"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.jst.j2ee.internal.web.container"/>
+	<classpathentry kind="con" path="org.eclipse.jst.j2ee.internal.module.container"/>
+	<classpathentry kind="con" path="org.apache.ivyde.eclipse.cpcontainer.IVYDE_CONTAINER/?project=org.eclipse.osbp.vaadin.addons.kanban&amp;ivyXmlPath=ivy.xml&amp;confs=default&amp;ivySettingsPath=%24%7Bworkspace_loc%3Aorg.eclipse.osbp.vaadin.addons.kanban%2Fivysettings.xml%7D&amp;loadSettingsOnDemand=false&amp;ivyUserDir=&amp;propertyFiles=">
+		<attributes>
+			<attribute name="org.eclipse.jst.component.dependency" value="/WEB-INF/lib"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.apache.ivyde.eclipse.cpcontainer.IVYDE_CONTAINER/?project=org.eclipse.osbp.vaadin.addons.kanban&amp;ivyXmlPath=ivy.xml&amp;confs=widgetset-compile&amp;ivySettingsPath=%24%7Bworkspace_loc%3Aorg.eclipse.osbp.vaadin.addons.kanban%2Fivysettings.xml%7D&amp;loadSettingsOnDemand=false&amp;ivyUserDir=&amp;propertyFiles="/>
+	<classpathentry kind="con" path="org.apache.ivyde.eclipse.cpcontainer.IVYDE_CONTAINER/?project=org.eclipse.osbp.vaadin.addons.kanban&amp;ivyXmlPath=ivy.xml&amp;confs=nodeploy&amp;ivySettingsPath=%24%7Bworkspace_loc%3Aorg.eclipse.osbp.vaadin.addons.kanban%2Fivysettings.xml%7D&amp;loadSettingsOnDemand=false&amp;ivyUserDir=&amp;propertyFiles="/>
+	<classpathentry exported="true" kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="output" path="target/classes"/>
+</classpath>
diff --git a/org.eclipse.osbp.vaadin.addons.kanban/.gitignore b/org.eclipse.osbp.vaadin.addons.kanban/.gitignore
new file mode 100644
index 0000000..9c43300
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.kanban/.gitignore
@@ -0,0 +1,3 @@
+META-INF/
+**/git.properties
+**/target/
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaadin.addons.kanban/.project b/org.eclipse.osbp.vaadin.addons.kanban/.project
new file mode 100644
index 0000000..5601cc9
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.kanban/.project
@@ -0,0 +1,59 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.osbp.vaadin.addons.kanban</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.wst.jsdt.core.javascriptValidator</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.wst.common.project.facet.core.builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.wst.validation.validationbuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.vaadin.integration.eclipse.widgetsetBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.babel.editor.rbeBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.sonarlint.eclipse.core.sonarlintBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.vaadin.integration.eclipse.addonStylesBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jem.workbench.JavaEMFNature</nature>
+		<nature>org.eclipse.wst.common.modulecore.ModuleCoreNature</nature>
+		<nature>org.eclipse.wst.common.project.facet.core.nature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.wst.jsdt.core.jsNature</nature>
+		<nature>com.vaadin.integration.eclipse.widgetsetNature</nature>
+		<nature>org.apache.ivyde.eclipse.ivynature</nature>
+		<nature>org.eclipse.babel.editor.rbeNature</nature>
+	</natures>
+</projectDescription>
diff --git a/org.eclipse.osbp.vaadin.addons.kanban/.project-for-debug b/org.eclipse.osbp.vaadin.addons.kanban/.project-for-debug
new file mode 100644
index 0000000..9ce0a66
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.kanban/.project-for-debug
@@ -0,0 +1,60 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>net.osbee.vaadin.addons.kanban</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.wst.jsdt.core.javascriptValidator</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.wst.common.project.facet.core.builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.wst.validation.validationbuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.vaadin.integration.eclipse.widgetsetBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.babel.editor.rbeBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.sonarlint.eclipse.core.sonarlintBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.pde.PluginNature</nature>
+		<nature>org.eclipse.jem.workbench.JavaEMFNature</nature>
+		<nature>org.eclipse.wst.common.modulecore.ModuleCoreNature</nature>
+		<nature>org.eclipse.wst.common.project.facet.core.nature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.wst.jsdt.core.jsNature</nature>
+		<nature>com.vaadin.integration.eclipse.widgetsetNature</nature>
+		<nature>org.apache.ivyde.eclipse.ivynature</nature>
+		<nature>org.eclipse.babel.editor.rbeNature</nature>
+	</natures>
+</projectDescription>
diff --git a/org.eclipse.osbp.vaadin.addons.kanban/.settings/.jsdtscope b/org.eclipse.osbp.vaadin.addons.kanban/.settings/.jsdtscope
new file mode 100644
index 0000000..92e666d
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.kanban/.settings/.jsdtscope
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry excluding="**/bower_components/*|**/node_modules/*|**/*.min.js" kind="src" path="WebContent"/>
+	<classpathentry kind="con" path="org.eclipse.wst.jsdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="con" path="org.eclipse.wst.jsdt.launching.WebProject">
+		<attributes>
+			<attribute name="hide" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.wst.jsdt.launching.baseBrowserLibrary"/>
+	<classpathentry kind="output" path=""/>
+</classpath>
diff --git a/org.eclipse.osbp.vaadin.addons.kanban/.settings/com.vaadin.integration.eclipse.prefs b/org.eclipse.osbp.vaadin.addons.kanban/.settings/com.vaadin.integration.eclipse.prefs
new file mode 100644
index 0000000..9af73b0
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.kanban/.settings/com.vaadin.integration.eclipse.prefs
@@ -0,0 +1,11 @@
+com.vaadin.integration.eclipse.mavenAutoCompileWidgetset=true
+com.vaadin.integration.eclipse.mavenLatestVersionsUpgrade=["7.5.10","7.7.3"]
+com.vaadin.integration.eclipse.notifyOfVaadinUpdates=true
+com.vaadin.integration.eclipse.previousCompileAction=widgetset
+com.vaadin.integration.eclipse.useLatestNightly=false
+com.vaadin.integration.eclipse.widgetsetBuildsSuspended=true
+com.vaadin.integration.eclipse.widgetsetCompilationEta=50910
+com.vaadin.integration.eclipse.widgetsetDirty=false
+com.vaadin.integration.eclipse.widgetsetStyle=OBF
+com.vaadin.integration.eclipse.widgetsetVerbose=true
+eclipse.preferences.version=1
diff --git a/org.eclipse.osbp.vaadin.addons.kanban/.settings/org.eclipse.core.resources.prefs b/org.eclipse.osbp.vaadin.addons.kanban/.settings/org.eclipse.core.resources.prefs
new file mode 100644
index 0000000..7a53139
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.kanban/.settings/org.eclipse.core.resources.prefs
@@ -0,0 +1,3 @@
+eclipse.preferences.version=1
+encoding/<project>=UTF-8
+encoding/src=UTF-8
diff --git a/org.eclipse.osbp.vaadin.addons.kanban/.settings/org.eclipse.jdt.core.prefs b/org.eclipse.osbp.vaadin.addons.kanban/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..13b3428
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.kanban/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,13 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.methodParameters=do not generate
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
+org.eclipse.jdt.core.compiler.source=1.8
diff --git a/org.eclipse.osbp.vaadin.addons.kanban/.settings/org.eclipse.m2e.core.prefs b/org.eclipse.osbp.vaadin.addons.kanban/.settings/org.eclipse.m2e.core.prefs
new file mode 100644
index 0000000..f897a7f
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.kanban/.settings/org.eclipse.m2e.core.prefs
@@ -0,0 +1,4 @@
+activeProfiles=
+eclipse.preferences.version=1
+resolveWorkspaceProjects=true
+version=1
diff --git a/org.eclipse.osbp.vaadin.addons.kanban/.settings/org.eclipse.wst.common.component b/org.eclipse.osbp.vaadin.addons.kanban/.settings/org.eclipse.wst.common.component
new file mode 100644
index 0000000..d96bada
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.kanban/.settings/org.eclipse.wst.common.component
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?><project-modules id="moduleCoreId" project-version="1.5.0">
+    <wb-module deploy-name="org.eclipse.osbp.vaadin.addons.kanban">
+        <wb-resource deploy-path="/" source-path="/WebContent" tag="defaultRootSource"/>
+        <wb-resource deploy-path="/WEB-INF/classes" source-path="/src"/>
+        <wb-resource deploy-path="/WEB-INF/classes" source-path="/Sample"/>
+        <property name="java-output-path" value="/org.eclipse.osbp.vaadin.addons.kanban/build/classes"/>
+        <property name="context-root" value="org.eclipse.osbp.vaadin.addons.kanban"/>
+    </wb-module>
+</project-modules>
diff --git a/org.eclipse.osbp.vaadin.addons.kanban/.settings/org.eclipse.wst.common.project.facet.core.xml b/org.eclipse.osbp.vaadin.addons.kanban/.settings/org.eclipse.wst.common.project.facet.core.xml
new file mode 100644
index 0000000..b662702
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.kanban/.settings/org.eclipse.wst.common.project.facet.core.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<faceted-project>
+  <runtime name="Apache Tomcat v8.0"/>
+  <fixed facet="wst.jsdt.web"/>
+  <fixed facet="java"/>
+  <fixed facet="com.vaadin.integration.eclipse.core"/>
+  <fixed facet="jst.web"/>
+  <installed facet="jst.web" version="3.1"/>
+  <installed facet="wst.jsdt.web" version="1.0"/>
+  <installed facet="com.vaadin.integration.eclipse.core" version="7.0"/>
+  <installed facet="java" version="1.8"/>
+</faceted-project>
diff --git a/org.eclipse.osbp.vaadin.addons.kanban/.settings/org.eclipse.wst.jsdt.ui.superType.container b/org.eclipse.osbp.vaadin.addons.kanban/.settings/org.eclipse.wst.jsdt.ui.superType.container
new file mode 100644
index 0000000..3bd5d0a
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.kanban/.settings/org.eclipse.wst.jsdt.ui.superType.container
@@ -0,0 +1 @@
+org.eclipse.wst.jsdt.launching.baseBrowserLibrary
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaadin.addons.kanban/.settings/org.eclipse.wst.jsdt.ui.superType.name b/org.eclipse.osbp.vaadin.addons.kanban/.settings/org.eclipse.wst.jsdt.ui.superType.name
new file mode 100644
index 0000000..05bd71b
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.kanban/.settings/org.eclipse.wst.jsdt.ui.superType.name
@@ -0,0 +1 @@
+Window
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaadin.addons.kanban/LICENSE.txt b/org.eclipse.osbp.vaadin.addons.kanban/LICENSE.txt
new file mode 100644
index 0000000..ff42ad4
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.kanban/LICENSE.txt
@@ -0,0 +1,161 @@
+Eclipse Public License -v 1.0
+
+THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION
+OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
+
+1. DEFINITIONS
+
+"Contribution" means:
+
+a) in the case of the initial Contributor, the initial code and documentation distributed under this Agreement, and
+
+b) in the case of each subsequent Contributor:
+
+i) changes to the Program, and
+
+ii) additions to the Program;
+
+where such changes and/or additions to the Program originate from and are distributed by that particular Contributor.
+A Contribution 'originates' from a Contributor if it was added to the Program by such Contributor itself or anyone
+acting on such Contributor's behalf. Contributions do not include additions to the Program which: (i) are separate
+modules of software distributed in conjunction with the Program under their own license agreement, and (ii) are not
+derivative works of the Program.
+
+"Contributor" means any person or entity that distributes the Program.
+
+"Licensed Patents " mean patent claims licensable by a Contributor which are necessarily infringed by the use or sale of
+its Contribution alone or when combined with the Program.
+
+"Program" means the Contributions distributed in accordance with this Agreement.
+
+"Recipient" means anyone who receives the Program under this Agreement, including all Contributors.
+
+2. GRANT OF RIGHTS
+
+a) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, distribute
+and sublicense the Contribution of such Contributor, if any, and such derivative works, in source code and object code
+form.
+
+b) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free patent license under Licensed Patents to make, use, sell, offer to sell, import and otherwise transfer the
+Contribution of such Contributor, if any, in source code and object code form. This patent license shall apply to the
+combination of the Contribution and the Program if, at the time the Contribution is added by the Contributor, such
+addition of the Contribution causes such combination to be covered by the Licensed Patents. The patent license shall not
+apply to any other combinations which include the Contribution. No hardware per se is licensed hereunder.
+
+c) Recipient understands that although each Contributor grants the licenses to its Contributions set forth herein, no
+assurances are provided by any Contributor that the Program does not infringe the patent or other intellectual property
+rights of any other entity. Each Contributor disclaims any liability to Recipient for claims brought by any other entity
+based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and
+licenses granted hereunder, each Recipient hereby assumes sole responsibility to secure any other intellectual property
+rights needed, if any. For example, if a third party patent license is required to allow Recipient to distribute the
+Program, it is Recipient's responsibility to acquire that license before distributing the Program.
+
+d) Each Contributor represents that to its knowledge it has sufficient copyright rights in its Contribution, if any, to
+grant the copyright license set forth in this Agreement.
+
+3. REQUIREMENTS
+
+A Contributor may choose to distribute the Program in object code form under its own license agreement, provided that:
+
+a) it complies with the terms and conditions of this Agreement; and
+
+b) its license agreement:
+
+i) effectively disclaims on behalf of all Contributors all warranties and conditions, express and implied, including
+warranties or conditions of title and non-infringement, and implied warranties or conditions of merchantability and
+fitness for a particular purpose;
+
+ii) effectively excludes on behalf of all Contributors all liability for damages, including direct, indirect, special,
+incidental and consequential damages, such as lost profits;
+
+iii) states that any provisions which differ from this Agreement are offered by that Contributor alone and not by any
+other party; and
+
+iv) states that source code for the Program is available from such Contributor, and informs licensees how to obtain it
+in a reasonable manner on or through a medium customarily used for software exchange.
+
+When the Program is made available in source code form:
+
+a) it must be made available under this Agreement; and
+
+b) a copy of this Agreement must be included with each copy of the Program.
+
+Contributors may not remove or alter any copyright notices contained within the Program.
+
+Each Contributor must identify itself as the originator of its Contribution, if any, in a manner that reasonably allows
+subsequent Recipients to identify the originator of the Contribution.
+
+4. COMMERCIAL DISTRIBUTION
+
+Commercial distributors of software may accept certain responsibilities with respect to end users, business partners and
+the like. While this license is intended to facilitate the commercial use of the Program, the Contributor who includes
+the Program in a commercial product offering should do so in a manner which does not create potential liability for
+other Contributors. Therefore, if a Contributor includes the Program in a commercial product offering, such Contributor
+("Commercial Contributor") hereby agrees to defend and indemnify every other Contributor ("Indemnified Contributor")
+against any losses, damages and costs (collectively "Losses") arising from claims, lawsuits and other legal actions
+brought by a third party against the Indemnified Contributor to the extent caused by the acts or omissions of such
+Commercial Contributor in connection with its distribution of the Program in a commercial product offering. The
+obligations in this section do not apply to any claims or Losses relating to any actual or alleged intellectual
+property infringement. In order to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
+Contributor in writing of such claim, and b) allow the Commercial Contributor to control, and cooperate with the
+Commercial Contributor in, the defense and any related settlement negotiations. The Indemnified Contributor may
+ participate in any such claim at its own expense.
+
+For example, a Contributor might include the Program in a commercial product offering, Product X. That Contributor is
+then a Commercial Contributor. If that Commercial Contributor then makes performance claims, or offers warranties
+related to Product X, those performance claims and warranties are such Commercial Contributor's responsibility alone.
+Under this section, the Commercial Contributor would have to defend claims against the other Contributors related to
+those performance claims and warranties, and if a court requires any other Contributor to pay any damages as a result,
+the Commercial Contributor must pay those damages.
+
+5. NO WARRANTY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely responsible for
+determining the appropriateness of using and distributing the Program and assumes all risks associated with its
+exercise of rights under this Agreement , including but not limited to the risks and costs of program errors, compliance
+with applicable laws, damage to or loss of data, programs or equipment, and unavailability or interruption of operations.
+
+6. DISCLAIMER OF LIABILITY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS),
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
+HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+7. GENERAL
+
+If any provision of this Agreement is invalid or unenforceable under applicable law, it shall not affect the validity or
+enforceability of the remainder of the terms of this Agreement, and without further action by the parties hereto, such
+provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.
+
+If Recipient institutes patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit)
+alleging that the Program itself (excluding combinations of the Program with other software or hardware) infringes such
+Recipient's patent(s), then such Recipient's rights granted under Section 2(b) shall terminate as of the date such
+litigation is filed.
+
+All Recipient's rights under this Agreement shall terminate if it fails to comply with any of the material terms or
+conditions of this Agreement and does not cure such failure in a reasonable period of time after becoming aware of such
+noncompliance. If all Recipient's rights under this Agreement terminate, Recipient agrees to cease use and distribution
+of the Program as soon as reasonably practicable. However, Recipient's obligations under this Agreement and any licenses
+ granted by Recipient relating to the Program shall continue and survive.
+
+Everyone is permitted to copy and distribute copies of this Agreement, but in order to avoid inconsistency the Agreement
+is copyrighted and may only be modified in the following manner. The Agreement Steward reserves the right to publish
+new versions (including revisions) of this Agreement from time to time. No one other than the Agreement Steward has the
+right to modify this Agreement. The Eclipse Foundation is the initial Agreement Steward. The Eclipse Foundation may
+assign the responsibility to serve as the Agreement Steward to a suitable separate entity. Each new version of the
+Agreement will be given a distinguishing version number. The Program (including Contributions) may always be
+distributed subject to the version of the Agreement under which it was received. In addition, after a new version of
+the Agreement is published, Contributor may elect to distribute the Program (including its Contributions) under the
+new version. Except as expressly stated in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
+the intellectual property of any Contributor under this Agreement, whether expressly, by implication, estoppel or
+otherwise. All rights in the Program not expressly granted under this Agreement are reserved.
+
+This Agreement is governed by the laws of the State of New York and the intellectual property laws of the United States
+of America. No party to this Agreement will bring a legal action under this Agreement more than one year after the cause
+of action arose. Each party waives its rights to a jury trial in any resulting litigation.
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaadin.addons.kanban/Sample/org/eclipse/osbp/vaadin/addons/kanban/sample/Bean.java b/org.eclipse.osbp.vaadin.addons.kanban/Sample/org/eclipse/osbp/vaadin/addons/kanban/sample/Bean.java
new file mode 100644
index 0000000..2182ff3
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.kanban/Sample/org/eclipse/osbp/vaadin/addons/kanban/sample/Bean.java
@@ -0,0 +1,50 @@
+package org.eclipse.osbp.vaadin.addons.kanban.sample;
+
+public class Bean {
+
+	private String id;
+	private SampleEnum state;
+	private String firstName;
+	private String lastName;
+
+	public Bean(String id, SampleEnum state, String firstName, String lastName) {
+		super();
+		this.id = id;
+		this.state = state;
+		this.firstName = firstName;
+		this.lastName = lastName;
+	}
+
+	public String getId() {
+		return id;
+	}
+
+	public void setId(String id) {
+		this.id = id;
+	}
+
+	public SampleEnum getState() {
+		return state;
+	}
+
+	public void setState(SampleEnum state) {
+		this.state = state;
+	}
+
+	public String getFirstName() {
+		return firstName;
+	}
+
+	public void setFirstName(String firstName) {
+		this.firstName = firstName;
+	}
+
+	public String getLastName() {
+		return lastName;
+	}
+
+	public void setLastName(String lastName) {
+		this.lastName = lastName;
+	}
+
+}
diff --git a/org.eclipse.osbp.vaadin.addons.kanban/Sample/org/eclipse/osbp/vaadin/addons/kanban/sample/KanbanBoardUI.java b/org.eclipse.osbp.vaadin.addons.kanban/Sample/org/eclipse/osbp/vaadin/addons/kanban/sample/KanbanBoardUI.java
new file mode 100644
index 0000000..f9712d5
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.kanban/Sample/org/eclipse/osbp/vaadin/addons/kanban/sample/KanbanBoardUI.java
@@ -0,0 +1,108 @@
+/**
+ *                                                                            
+ * Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
+ *                                                                            
+ * All rights reserved. This program and the accompanying materials           
+ * are made available under the terms of the Eclipse Public License v1.0       
+ * which accompanies this distribution, and is available at                  
+ * http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ * Contributors:   
+ * Florian Pirchner <florian.pirchner@gmail.com> - Initial implementation
+ */
+package org.eclipse.osbp.vaadin.addons.kanban.sample;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.servlet.annotation.WebServlet;
+
+import org.eclipse.osbp.vaadin.addons.kanban.KanbanBoard;
+import org.eclipse.osbp.vaadin.addons.kanban.KanbanCard;
+
+import com.vaadin.annotations.Theme;
+import com.vaadin.annotations.VaadinServletConfiguration;
+import com.vaadin.data.util.BeanItemContainer;
+import com.vaadin.server.VaadinRequest;
+import com.vaadin.server.VaadinServlet;
+import com.vaadin.ui.Label;
+import com.vaadin.ui.UI;
+import com.vaadin.ui.VerticalLayout;
+
+@SuppressWarnings("serial")
+@Theme("valo")
+public class KanbanBoardUI extends UI {
+
+	@WebServlet(value = "/*", asyncSupported = true)
+	@VaadinServletConfiguration(productionMode = false, ui = KanbanBoardUI.class, widgetset = "org.eclipse.osbp.vaadin.addons.kanban.KanbanWidgetset")
+	public static class Servlet extends VaadinServlet {
+	}
+
+	private VerticalLayout content;
+	private KanbanBoard board;
+
+	@Override
+	protected void init(VaadinRequest request) {
+
+		board = new KanbanBoard();
+		setContent(board);
+
+		board.setDoubleClickListener(this::refreshDto);
+
+		List<SampleEnum> allowedStates = new ArrayList<>();
+		allowedStates.add(SampleEnum.ENTERED);
+		allowedStates.add(SampleEnum.RELEASED);
+		allowedStates.add(SampleEnum.SHIPPED);
+		allowedStates.add(SampleEnum.INVOICED);
+		board.initialize(allowedStates.toArray(new SampleEnum[allowedStates.size()]), new KanbanBoard.DropAdapter() {
+			@Override
+			public boolean dropAllowed(Enum<?> sourceState, Enum<?> targetState, Object itemId) {
+				// if (sourceState == SampleEnum.INVOICED || targetState ==
+				// SampleEnum.ENTERED) {
+				// return false;
+				// }
+				return true;
+			}
+
+			@Override
+			public boolean drop(Enum<?> sourceState, Enum<?> targetState, Object itemId) {
+				return targetState != SampleEnum.RELEASED;
+			}
+		}, new KanbanBoard.KanbanCardAdapter() {
+
+			@Override
+			public KanbanCard createCard(Object itemId) {
+				Bean bean = (Bean) itemId;
+				KanbanCard card = new KanbanCard(bean.getId(), bean.getState(), bean);
+				card.setContent(new Label(bean.getFirstName() + " " + bean.getLastName()));
+				return card;
+			}
+		}, null);
+ 
+		BeanItemContainer<Bean> container = new BeanItemContainer<>(Bean.class);
+		for (int i = 0; i < 70; i++) {
+			container.addBean(new Bean(Integer.toString(i), getState(i), "Flo" + i, "Test" + i));
+		}
+
+		board.setContainerDatasource(container);
+	}
+
+	private void refreshDto(KanbanCard card) {
+		Bean newBean = new Bean(card.getCardId(), (SampleEnum) card.getCardState(), "Double", "Clicked");
+		board.refresh(newBean);
+	}
+
+	private SampleEnum getState(int i) {
+		if (i % 4 == 0) {
+			return SampleEnum.ENTERED;
+		}
+		if (i % 3 == 0) {
+			return SampleEnum.RELEASED;
+		}
+		if (i % 2 == 0) {
+			return SampleEnum.INVOICED;
+		}
+		return SampleEnum.SHIPPED;
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaadin.addons.kanban/Sample/org/eclipse/osbp/vaadin/addons/kanban/sample/SampleEnum.java b/org.eclipse.osbp.vaadin.addons.kanban/Sample/org/eclipse/osbp/vaadin/addons/kanban/sample/SampleEnum.java
new file mode 100644
index 0000000..65dec33
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.kanban/Sample/org/eclipse/osbp/vaadin/addons/kanban/sample/SampleEnum.java
@@ -0,0 +1,8 @@
+package org.eclipse.osbp.vaadin.addons.kanban.sample;
+
+public enum SampleEnum {
+
+	ENTERED, RELEASED, SHIPPED, INVOICED
+	
+}
+    
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaadin.addons.kanban/build.properties b/org.eclipse.osbp.vaadin.addons.kanban/build.properties
new file mode 100644
index 0000000..a172fdb
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.kanban/build.properties
@@ -0,0 +1,5 @@
+output.. = target/classes/
+bin.includes = META-INF/,\
+               .,\
+               build.properties
+source.. = src/
diff --git a/org.eclipse.osbp.vaadin.addons.kanban/epl-v10.html b/org.eclipse.osbp.vaadin.addons.kanban/epl-v10.html
new file mode 100644
index 0000000..b398acc
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.kanban/epl-v10.html
@@ -0,0 +1,259 @@
+<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml"><head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Eclipse Public License - Version 1.0</title>
+<style type="text/css">
+  body {
+    size: 8.5in 11.0in;
+    margin: 0.25in 0.5in 0.25in 0.5in;
+    tab-interval: 0.5in;
+    }
+  p {  	
+    margin-left: auto;
+    margin-top:  0.5em;
+    margin-bottom: 0.5em;
+    }
+  p.list {
+  	margin-left: 0.5in;
+    margin-top:  0.05em;
+    margin-bottom: 0.05em;
+    }
+  </style>
+
+</head>
+
+<body lang="EN-US">
+
+<h2>Eclipse Public License - v 1.0</h2>
+
+<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
+DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
+AGREEMENT.</p>
+
+<p><b>1. DEFINITIONS</b></p>
+
+<p>"Contribution" means:</p>
+
+<p class="list">a) in the case of the initial Contributor, the initial
+code and documentation distributed under this Agreement, and</p>
+<p class="list">b) in the case of each subsequent Contributor:</p>
+<p class="list">i) changes to the Program, and</p>
+<p class="list">ii) additions to the Program;</p>
+<p class="list">where such changes and/or additions to the Program
+originate from and are distributed by that particular Contributor. A
+Contribution 'originates' from a Contributor if it was added to the
+Program by such Contributor itself or anyone acting on such
+Contributor's behalf. Contributions do not include additions to the
+Program which: (i) are separate modules of software distributed in
+conjunction with the Program under their own license agreement, and (ii)
+are not derivative works of the Program.</p>
+
+<p>"Contributor" means any person or entity that distributes
+the Program.</p>
+
+<p>"Licensed Patents" mean patent claims licensable by a
+Contributor which are necessarily infringed by the use or sale of its
+Contribution alone or when combined with the Program.</p>
+
+<p>"Program" means the Contributions distributed in accordance
+with this Agreement.</p>
+
+<p>"Recipient" means anyone who receives the Program under
+this Agreement, including all Contributors.</p>
+
+<p><b>2. GRANT OF RIGHTS</b></p>
+
+<p class="list">a) Subject to the terms of this Agreement, each
+Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free copyright license to reproduce, prepare derivative works
+of, publicly display, publicly perform, distribute and sublicense the
+Contribution of such Contributor, if any, and such derivative works, in
+source code and object code form.</p>
+
+<p class="list">b) Subject to the terms of this Agreement, each
+Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free patent license under Licensed Patents to make, use, sell,
+offer to sell, import and otherwise transfer the Contribution of such
+Contributor, if any, in source code and object code form. This patent
+license shall apply to the combination of the Contribution and the
+Program if, at the time the Contribution is added by the Contributor,
+such addition of the Contribution causes such combination to be covered
+by the Licensed Patents. The patent license shall not apply to any other
+combinations which include the Contribution. No hardware per se is
+licensed hereunder.</p>
+
+<p class="list">c) Recipient understands that although each Contributor
+grants the licenses to its Contributions set forth herein, no assurances
+are provided by any Contributor that the Program does not infringe the
+patent or other intellectual property rights of any other entity. Each
+Contributor disclaims any liability to Recipient for claims brought by
+any other entity based on infringement of intellectual property rights
+or otherwise. As a condition to exercising the rights and licenses
+granted hereunder, each Recipient hereby assumes sole responsibility to
+secure any other intellectual property rights needed, if any. For
+example, if a third party patent license is required to allow Recipient
+to distribute the Program, it is Recipient's responsibility to acquire
+that license before distributing the Program.</p>
+
+<p class="list">d) Each Contributor represents that to its knowledge it
+has sufficient copyright rights in its Contribution, if any, to grant
+the copyright license set forth in this Agreement.</p>
+
+<p><b>3. REQUIREMENTS</b></p>
+
+<p>A Contributor may choose to distribute the Program in object code
+form under its own license agreement, provided that:</p>
+
+<p class="list">a) it complies with the terms and conditions of this
+Agreement; and</p>
+
+<p class="list">b) its license agreement:</p>
+
+<p class="list">i) effectively disclaims on behalf of all Contributors
+all warranties and conditions, express and implied, including warranties
+or conditions of title and non-infringement, and implied warranties or
+conditions of merchantability and fitness for a particular purpose;</p>
+
+<p class="list">ii) effectively excludes on behalf of all Contributors
+all liability for damages, including direct, indirect, special,
+incidental and consequential damages, such as lost profits;</p>
+
+<p class="list">iii) states that any provisions which differ from this
+Agreement are offered by that Contributor alone and not by any other
+party; and</p>
+
+<p class="list">iv) states that source code for the Program is available
+from such Contributor, and informs licensees how to obtain it in a
+reasonable manner on or through a medium customarily used for software
+exchange.</p>
+
+<p>When the Program is made available in source code form:</p>
+
+<p class="list">a) it must be made available under this Agreement; and</p>
+
+<p class="list">b) a copy of this Agreement must be included with each
+copy of the Program.</p>
+
+<p>Contributors may not remove or alter any copyright notices contained
+within the Program.</p>
+
+<p>Each Contributor must identify itself as the originator of its
+Contribution, if any, in a manner that reasonably allows subsequent
+Recipients to identify the originator of the Contribution.</p>
+
+<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
+
+<p>Commercial distributors of software may accept certain
+responsibilities with respect to end users, business partners and the
+like. While this license is intended to facilitate the commercial use of
+the Program, the Contributor who includes the Program in a commercial
+product offering should do so in a manner which does not create
+potential liability for other Contributors. Therefore, if a Contributor
+includes the Program in a commercial product offering, such Contributor
+("Commercial Contributor") hereby agrees to defend and
+indemnify every other Contributor ("Indemnified Contributor")
+against any losses, damages and costs (collectively "Losses")
+arising from claims, lawsuits and other legal actions brought by a third
+party against the Indemnified Contributor to the extent caused by the
+acts or omissions of such Commercial Contributor in connection with its
+distribution of the Program in a commercial product offering. The
+obligations in this section do not apply to any claims or Losses
+relating to any actual or alleged intellectual property infringement. In
+order to qualify, an Indemnified Contributor must: a) promptly notify
+the Commercial Contributor in writing of such claim, and b) allow the
+Commercial Contributor to control, and cooperate with the Commercial
+Contributor in, the defense and any related settlement negotiations. The
+Indemnified Contributor may participate in any such claim at its own
+expense.</p>
+
+<p>For example, a Contributor might include the Program in a commercial
+product offering, Product X. That Contributor is then a Commercial
+Contributor. If that Commercial Contributor then makes performance
+claims, or offers warranties related to Product X, those performance
+claims and warranties are such Commercial Contributor's responsibility
+alone. Under this section, the Commercial Contributor would have to
+defend claims against the other Contributors related to those
+performance claims and warranties, and if a court requires any other
+Contributor to pay any damages as a result, the Commercial Contributor
+must pay those damages.</p>
+
+<p><b>5. NO WARRANTY</b></p>
+
+<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
+PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
+OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
+ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
+OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
+responsible for determining the appropriateness of using and
+distributing the Program and assumes all risks associated with its
+exercise of rights under this Agreement , including but not limited to
+the risks and costs of program errors, compliance with applicable laws,
+damage to or loss of data, programs or equipment, and unavailability or
+interruption of operations.</p>
+
+<p><b>6. DISCLAIMER OF LIABILITY</b></p>
+
+<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
+NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
+WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
+DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
+HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
+
+<p><b>7. GENERAL</b></p>
+
+<p>If any provision of this Agreement is invalid or unenforceable under
+applicable law, it shall not affect the validity or enforceability of
+the remainder of the terms of this Agreement, and without further action
+by the parties hereto, such provision shall be reformed to the minimum
+extent necessary to make such provision valid and enforceable.</p>
+
+<p>If Recipient institutes patent litigation against any entity
+(including a cross-claim or counterclaim in a lawsuit) alleging that the
+Program itself (excluding combinations of the Program with other
+software or hardware) infringes such Recipient's patent(s), then such
+Recipient's rights granted under Section 2(b) shall terminate as of the
+date such litigation is filed.</p>
+
+<p>All Recipient's rights under this Agreement shall terminate if it
+fails to comply with any of the material terms or conditions of this
+Agreement and does not cure such failure in a reasonable period of time
+after becoming aware of such noncompliance. If all Recipient's rights
+under this Agreement terminate, Recipient agrees to cease use and
+distribution of the Program as soon as reasonably practicable. However,
+Recipient's obligations under this Agreement and any licenses granted by
+Recipient relating to the Program shall continue and survive.</p>
+
+<p>Everyone is permitted to copy and distribute copies of this
+Agreement, but in order to avoid inconsistency the Agreement is
+copyrighted and may only be modified in the following manner. The
+Agreement Steward reserves the right to publish new versions (including
+revisions) of this Agreement from time to time. No one other than the
+Agreement Steward has the right to modify this Agreement. The Eclipse
+Foundation is the initial Agreement Steward. The Eclipse Foundation may
+assign the responsibility to serve as the Agreement Steward to a
+suitable separate entity. Each new version of the Agreement will be
+given a distinguishing version number. The Program (including
+Contributions) may always be distributed subject to the version of the
+Agreement under which it was received. In addition, after a new version
+of the Agreement is published, Contributor may elect to distribute the
+Program (including its Contributions) under the new version. Except as
+expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
+rights or licenses to the intellectual property of any Contributor under
+this Agreement, whether expressly, by implication, estoppel or
+otherwise. All rights in the Program not expressly granted under this
+Agreement are reserved.</p>
+
+<p>This Agreement is governed by the laws of the State of New York and
+the intellectual property laws of the United States of America. No party
+to this Agreement will bring a legal action under this Agreement more
+than one year after the cause of action arose. Each party waives its
+rights to a jury trial in any resulting litigation.</p>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaadin.addons.kanban/ivy.xml b/org.eclipse.osbp.vaadin.addons.kanban/ivy.xml
new file mode 100644
index 0000000..ca3c426
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.kanban/ivy.xml
@@ -0,0 +1,50 @@
+<?xml version="1.0"?>
+<!DOCTYPE ivy-module [
+	<!ENTITY vaadin.version "7.7.6">
+]>
+<ivy-module version="2.0"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:noNamespaceSchemaLocation="http://ant.apache.org/ivy/schemas/ivy.xsd">
+	<info organisation="com.example" module="v7proj" />
+	<configurations>
+		<!-- The default configuration, which should be deployed to the server -->
+		<conf name="default" />
+		<!-- A configuration only needed when compiling the widget set. Should 
+			not be deployed to the server -->
+		<conf name="widgetset-compile" />
+		<!-- A configuration used in compilation of server side classes only.
+			Should be deployed to the server -->
+		<conf name="nodeploy" />
+	</configurations>
+	<dependencies defaultconf="default" defaultconfmapping="default->default">
+		<!-- The core server part of Vaadin -->
+		<dependency org="com.vaadin" name="vaadin-server" rev="&vaadin.version;" />
+
+		<!-- Vaadin themes -->
+		<dependency org="com.vaadin" name="vaadin-themes" rev="&vaadin.version;" />
+
+		<!-- Push support -->
+		<dependency org="com.vaadin" name="vaadin-push" rev="&vaadin.version;" />
+
+		<!-- Servlet 3.0 API -->
+		<dependency org="javax.servlet" name="javax.servlet-api" rev="3.0.1" conf="nodeploy->default" />
+
+		<!-- TestBench 4 -->
+		<dependency org="com.vaadin" name="vaadin-testbench-api" rev="latest.release" conf="nodeploy -> default" />
+
+		<!-- Precompiled DefaultWidgetSet -->
+		<dependency org="com.vaadin" name="vaadin-client-compiled"
+			rev="&vaadin.version;" />
+
+		<!-- Vaadin client side, needed for widget set compilation -->
+		<dependency org="com.vaadin" name="vaadin-client" rev="&vaadin.version;"
+			 conf="widgetset-compile->default" />
+
+		<!-- Compiler for custom widget sets. Should not be deployed -->
+		<dependency org="com.vaadin" name="vaadin-client-compiler"
+			rev="&vaadin.version;" conf="widgetset-compile->default" />
+			
+		<dependency org="org.vaadin.addons" name="dragdroplayouts" rev="1.2.2" />
+		
+	</dependencies>
+</ivy-module>
diff --git a/org.eclipse.osbp.vaadin.addons.kanban/ivysettings.xml b/org.eclipse.osbp.vaadin.addons.kanban/ivysettings.xml
new file mode 100644
index 0000000..9c0f653
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.kanban/ivysettings.xml
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ivysettings>
+	<settings defaultResolver="default" />
+	<resolvers>
+		<chain name="default">
+			<!-- Public Maven repository -->
+			<ibiblio name="public" m2compatible="true" />
+
+			<!-- Vaadin Add-on repository -->
+			<ibiblio name="vaadin-addons" usepoms="true" m2compatible="true"
+				root="http://maven.vaadin.com/vaadin-addons" />
+
+			<!-- Vaadin snapshots repository -->
+			<ibiblio name="vaadin-snapshots" usepoms="true" m2compatible="true"
+				root="https://oss.sonatype.org/content/repositories/vaadin-snapshots" />
+			<!-- Repository used for Vaadin modified smartsprites library -->
+			<dual name="custom-smartsprites">
+				<filesystem name="smartsprites-ivy">
+					<ivy pattern="${basedir}/ivymodule/[module]-ivy-[revision].xml" />
+				</filesystem>
+				<url name="smartsprites-artifact">
+					<artifact
+						pattern="http://dev.vaadin.com/svn/versions/6.8/build/smartsprites/lib/[artifact](-[revision]).[ext]" />
+				</url>
+			</dual>
+		</chain>
+	</resolvers>
+	<modules>
+		<!-- Vaadin patched SmartSprites -->
+		<module organisation="com.carrotsearch" name="smartsprites"
+			revision="0.2.3-itmill" resolver="custom-smartsprites" />
+	</modules>
+
+
+</ivysettings>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaadin.addons.kanban/license.html b/org.eclipse.osbp.vaadin.addons.kanban/license.html
new file mode 100644
index 0000000..6e579a5
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.kanban/license.html
@@ -0,0 +1,164 @@
+<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml"><head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Eclipse Foundation Software User Agreement</title>
+</head>
+
+<body lang="EN-US">
+<h2>Eclipse Foundation Software User Agreement</h2>
+<p>February 1, 2011</p>
+
+<h3>Usage Of Content</h3>
+
+<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+   (COLLECTIVELY "CONTENT").  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
+   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
+   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
+   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+
+<h3>Applicable Licenses</h3>
+
+<p>Unless otherwise indicated, all Content made available by the Eclipse
+ Foundation is provided to you under the terms and conditions of the 
+Eclipse Public License Version 1.0
+   ("EPL").  A copy of the EPL is provided with this Content and is also
+ available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+   For purposes of the EPL, "Program" will mean the Content.</p>
+
+<p>Content includes, but is not limited to, source code, object code, 
+documentation and other files maintained in the Eclipse Foundation 
+source code
+   repository ("Repository") in software modules ("Modules") and made 
+available as downloadable archives ("Downloads").</p>
+
+<ul>
+       <li>Content may be structured and packaged into modules to 
+facilitate delivering, extending, and upgrading the Content.  Typical 
+modules may include plug-ins ("Plug-ins"), plug-in fragments 
+("Fragments"), and features ("Features").</li>
+       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&#8482; ARchive) in a directory named "plugins".</li>
+       <li>A Feature is a bundle of one or more Plug-ins and/or 
+Fragments and associated material.  Each Feature may be packaged as a 
+sub-directory in a directory named "features".  Within a Feature, files 
+named "feature.xml" may contain a list of the names and version numbers 
+of the Plug-ins
+      and/or Fragments associated with that Feature.</li>
+       <li>Features may also include other Features ("Included 
+Features"). Within a Feature, files named "feature.xml" may contain a 
+list of the names and version numbers of Included Features.</li>
+</ul>
+
+<p>The terms and conditions governing Plug-ins and Fragments should be 
+contained in files named "about.html" ("Abouts"). The terms and 
+conditions governing Features and
+Included Features should be contained in files named "license.html" 
+("Feature Licenses").  Abouts and Feature Licenses may be located in any
+ directory of a Download or Module
+including, but not limited to the following locations:</p>
+
+<ul>
+       <li>The top-level (root) directory</li>
+       <li>Plug-in and Fragment directories</li>
+       <li>Inside Plug-ins and Fragments packaged as JARs</li>
+       <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
+       <li>Feature directories</li>
+</ul>
+
+<p>Note: if a Feature made available by the Eclipse Foundation is 
+installed using the Provisioning Technology (as defined below), you must
+ agree to a license ("Feature Update License") during the
+installation process.  If the Feature contains Included Features, the 
+Feature Update License should either provide you with the terms and 
+conditions governing the Included Features or
+inform you where you can locate them.  Feature Update Licenses may be 
+found in the "license" property of files named "feature.properties" 
+found within a Feature.
+Such Abouts, Feature Licenses, and Feature Update Licenses contain the 
+terms and conditions (or references to such terms and conditions) that 
+govern your use of the associated Content in
+that directory.</p>
+
+<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER 
+TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.
+  SOME OF THESE
+OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+
+<ul>
+       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
+       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
+       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
+       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
+       <li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
+       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
+</ul>
+
+<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND 
+CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, 
+or Feature Update License is provided, please
+contact the Eclipse Foundation to determine what terms and conditions 
+govern that particular Content.</p>
+
+
+<h3>Use of Provisioning Technology</h3>
+
+<p>The Eclipse Foundation makes available provisioning software, 
+examples of which include, but are not limited to, p2 and the Eclipse
+   Update Manager ("Provisioning Technology") for the purpose of 
+allowing users to install software, documentation, information and/or
+   other materials (collectively "Installable Software"). This 
+capability is provided with the intent of allowing such users to
+   install, extend and update Eclipse-based products. Information about 
+packaging Installable Software is available at <a href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+   ("Specification").</p>
+
+<p>You may use Provisioning Technology to allow other parties to install
+ Installable Software. You shall be responsible for enabling the
+   applicable license agreements relating to the Installable Software to
+ be presented to, and accepted by, the users of the Provisioning 
+Technology
+   in accordance with the Specification. By using Provisioning 
+Technology in such a manner and making it available in accordance with 
+the
+   Specification, you further acknowledge your agreement to, and the 
+acquisition of all necessary rights to permit the following:</p>
+
+<ol>
+       <li>A series of actions may occur ("Provisioning Process") in 
+which a user may execute the Provisioning Technology
+       on a machine ("Target Machine") with the intent of installing, 
+extending or updating the functionality of an Eclipse-based
+       product.</li>
+       <li>During the Provisioning Process, the Provisioning Technology 
+may cause third party Installable Software or a portion thereof to be
+       accessed and copied to the Target Machine.</li>
+       <li>Pursuant to the Specification, you will provide to the user 
+the terms and conditions that govern the use of the Installable
+       Software ("Installable Software Agreement") and such Installable 
+Software Agreement shall be accessed from the Target
+       Machine in accordance with the Specification. Such Installable 
+Software Agreement must inform the user of the terms and conditions that
+ govern
+       the Installable Software and must solicit acceptance by the end 
+user in the manner prescribed in such Installable Software Agreement. 
+Upon such
+       indication of agreement by the user, the provisioning Technology 
+will complete installation of the Installable Software.</li>
+</ol>
+
+<h3>Cryptography</h3>
+
+<p>Content may contain encryption software. The country in which you are
+ currently may have restrictions on the import, possession, and use, 
+and/or re-export to
+   another country, of encryption software. BEFORE using any encryption 
+software, please check the country's laws, regulations and policies 
+concerning the import,
+   possession, or use, and re-export of encryption software, to see if 
+this is permitted.</p>
+
+<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
+
+
+</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaadin.addons.kanban/pom.xml b/org.eclipse.osbp.vaadin.addons.kanban/pom.xml
new file mode 100644
index 0000000..eb3118f
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.kanban/pom.xml
@@ -0,0 +1,192 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ *                                                                            
+ * Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
+ *                                                                            
+ * All rights reserved. This program and the accompanying materials           
+ * are made available under the terms of the Eclipse Public License v1.0       
+ * which accompanies this distribution, and is available at                  
+ * http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ * Contributors:   
+ * Christophe Loetz (Loetz GmbH&Co.KG) - Initial implementation 
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<parent>
+		<groupId>org.eclipse.osbp.releng.maven</groupId>
+		<artifactId>org.eclipse.osbp.releng.maven.parent.mbp</artifactId>
+		<version>0.9.0-SNAPSHOT</version>
+		<relativePath />
+	</parent>
+
+	<groupId>org.eclipse.osbp.vaadin.addons</groupId>
+	<artifactId>org.eclipse.osbp.vaadin.addons.kanban</artifactId>
+	<packaging>bundle</packaging>
+
+	<dependencies>
+		<dependency>
+			<groupId>com.vaadin</groupId>
+			<artifactId>vaadin-server</artifactId>
+			<version>${vaadin.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>com.vaadin</groupId>
+			<artifactId>vaadin-client</artifactId>
+			<version>${vaadin.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>com.vaadin</groupId>
+			<artifactId>vaadin-shared</artifactId>
+			<version>${vaadin.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>com.vaadin.external.slf4j</groupId>
+			<artifactId>vaadin-slf4j-jdk14</artifactId>
+			<version>1.6.1</version>
+		</dependency>
+		<dependency>
+			<groupId>javax.servlet</groupId>
+			<artifactId>javax.servlet-api</artifactId>
+			<version>3.0.1</version>
+		</dependency>
+		<dependency>
+			<groupId>org.eclipse.osbp.dependencies</groupId>
+			<artifactId>org.eclipse.osbp.dependencies.bundle.vaadin.addon.dragdroplayouts</artifactId>
+			<version>1.3.2-SNAPSHOT</version>
+		</dependency>
+	</dependencies>
+
+	<build>
+		<sourceDirectory>${basedir}/src</sourceDirectory>
+
+		<plugins>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-resources-plugin</artifactId>
+				<configuration>
+					<encoding>UTF-8</encoding>
+				</configuration>
+			</plugin>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-compiler-plugin</artifactId>
+				<configuration>
+					<encoding>UTF-8</encoding>
+					<source>1.8</source>
+					<target>1.8</target>
+				</configuration>
+			</plugin>
+
+			<plugin>
+				<groupId>org.apache.felix</groupId>
+				<artifactId>maven-bundle-plugin</artifactId>
+				<extensions>true</extensions>
+				<configuration>
+					<instructions>
+						<Bundle-Name>OS.bee Addon for Vaadin: Kanban</Bundle-Name>
+						<Bundle-SymbolicName>org.eclipse.osbp.vaadin.addons.kanban</Bundle-SymbolicName>
+						<Bundle-Version>0.9.0.{osgi-version-qualifier}</Bundle-Version>
+						<Require-Bundle>com.vaadin.server;bundle-version="[7.7.6,7.8.0)",
+							com.vaadin.client;bundle-version="[7.7.6,7.8.0)",
+							com.vaadin.shared;bundle-version="[7.7.6,7.8.0)",
+							org.jsoup;bundle-version="[1.8.3,1.8.4)",
+							dragdroplayouts.osgi;bundle-version="[1.3.2,1.3.3)"
+						</Require-Bundle>
+						<Import-Package>
+							com.vaadin.*,
+							!fi.jasoft.*,
+							javax.servlet.annotation;resolution:=optional,
+							*
+						</Import-Package>
+						<Export-Package>
+							!LICENSE,!LICENSE.txt,!THIRD-PARTY.txt,!NOTICE,!README.txt,!VERSION.txt,!build.properties,
+							!VAADIN.*,
+							org.eclipse.osbp.vaadin.addons.kanban.*;version="0.9.0"
+						</Export-Package>
+						<Include-Resource>{maven-resources},LICENSE.txt,epl-v10.html</Include-Resource>
+						<_nouses>true</_nouses>
+					</instructions>
+				</configuration>
+			</plugin>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-source-plugin</artifactId>
+				<executions>
+					<execution>
+						<id>attach-sources</id>
+						<goals>
+							<goal>jar</goal>
+						</goals>
+					</execution>
+				</executions>
+			</plugin>
+		</plugins>
+		<pluginManagement>
+			<plugins>
+
+				<!--This plugin's configuration is used to store Eclipse m2e settings 
+					only. It has no influence on the Maven build itself. -->
+				<plugin>
+					<groupId>org.eclipse.m2e</groupId>
+					<artifactId>lifecycle-mapping</artifactId>
+					<version>1.0.0</version>
+					<configuration>
+						<lifecycleMappingMetadata>
+							<pluginExecutions>
+								<pluginExecution>
+									<pluginExecutionFilter>
+										<groupId>
+											org.apache.maven.plugins
+										</groupId>
+										<artifactId>
+											maven-dependency-plugin
+										</artifactId>
+										<versionRange>
+											[2.0.0,)
+										</versionRange>
+										<goals>
+											<goal>
+												copy-dependencies
+											</goal>
+										</goals>
+									</pluginExecutionFilter>
+									<action>
+										<ignore></ignore>
+									</action>
+								</pluginExecution>
+								<pluginExecution>
+									<pluginExecutionFilter>
+										<groupId>com.vaadin</groupId>
+										<artifactId>
+											vaadin-maven-plugin
+										</artifactId>
+										<versionRange>
+											[7.0-SNAPSHOT,)
+										</versionRange>
+										<goals>
+											<goal>compile</goal>
+										</goals>
+									</pluginExecutionFilter>
+									<action>
+										<ignore></ignore>
+									</action>
+								</pluginExecution>
+							</pluginExecutions>
+						</lifecycleMappingMetadata>
+					</configuration>
+				</plugin>
+			</plugins>
+		</pluginManagement>
+		<!-- This is needed for the sources required by the client-side compiler 
+			to be included in the produced JARs -->
+		<resources>
+			<resource>
+				<directory>src</directory>
+			</resource>
+		</resources>
+
+	</build>
+
+</project>
diff --git a/org.eclipse.osbp.vaadin.addons.kanban/src/org/eclipse/osbp/vaadin/addons/kanban/KanbanBoard.java b/org.eclipse.osbp.vaadin.addons.kanban/src/org/eclipse/osbp/vaadin/addons/kanban/KanbanBoard.java
new file mode 100644
index 0000000..b3c2d61
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.kanban/src/org/eclipse/osbp/vaadin/addons/kanban/KanbanBoard.java
@@ -0,0 +1,417 @@
+/**
+ *                                                                            
+ * Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
+ *                                                                            
+ * All rights reserved. This program and the accompanying materials           
+ * are made available under the terms of the Eclipse Public License v1.0       
+ * which accompanies this distribution, and is available at                  
+ * http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ * Contributors:   
+ * Florian Pirchner <florian.pirchner@gmail.com> - Initial implementation
+ */
+package org.eclipse.osbp.vaadin.addons.kanban;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.function.Consumer;
+
+import com.vaadin.data.Container;
+import com.vaadin.data.Container.Filter;
+import com.vaadin.event.dd.DragAndDropEvent;
+import com.vaadin.event.dd.DropTarget;
+import com.vaadin.event.dd.acceptcriteria.ServerSideCriterion;
+import com.vaadin.shared.ui.dd.VerticalDropLocation;
+import com.vaadin.ui.Alignment;
+import com.vaadin.ui.Component;
+import com.vaadin.ui.CustomComponent;
+import com.vaadin.ui.HorizontalLayout;
+import com.vaadin.ui.Label;
+import com.vaadin.ui.Panel;
+import com.vaadin.ui.VerticalLayout;
+
+import fi.jasoft.dragdroplayouts.DDVerticalLayout;
+import fi.jasoft.dragdroplayouts.DDVerticalLayout.VerticalLayoutTargetDetails;
+import fi.jasoft.dragdroplayouts.client.ui.Constants;
+import fi.jasoft.dragdroplayouts.client.ui.LayoutDragMode;
+import fi.jasoft.dragdroplayouts.drophandlers.DefaultVerticalLayoutDropHandler;
+import fi.jasoft.dragdroplayouts.events.LayoutBoundTransferable;
+
+@SuppressWarnings("serial")
+public class KanbanBoard extends CustomComponent {
+
+	private static final String O_COLUMN_SPACER = "o-column-spacer";
+	static final String O_MAIN_AREA = "o-main-area";
+	static final String O_FILTER_AREA = "o-filter-area";
+	static final String O_FOOTER_AREA = "o-footer-area";
+	static final String O_COLUMN_AREA = "o-column-area";
+	static final String O_COLUMN_HEADER_AREA = "o-column-header-area";
+	static final String O_COLUMN = "o-column";
+
+	Enum<?>[] columnIdentifiers;
+	VerticalLayout filterArea;
+	HorizontalLayout columnArea;
+	Map<String, Enum<?>> enumMapping = new HashMap<>();
+	Map<Enum<?>, CardsVerticalLayout> columns = new HashMap<>();
+	VerticalLayout mainArea;
+
+	Container.Filterable container;
+	DropAdapter dropAdapter;
+	private KanbanCardAdapter cardAdapter;
+	private FilterProvider filterProvider;
+	private CustomFilterChangedListener filterChangedListener;
+	private Panel columnScrollable;
+	private VerticalLayout footerArea;
+
+	private Consumer<KanbanCard> doubleClickListener;
+	private int noOfCards = 15;
+
+	public KanbanBoard() {
+	}
+
+	public int getNoOfCards() {
+		return noOfCards;
+	}
+
+	public void setNoOfCards(int noOfCards) {
+		this.noOfCards = noOfCards;
+	}
+
+	public void initialize(Enum<?>[] states, DropAdapter dropAdapter, KanbanCardAdapter cardAdapter,
+			FilterProvider filterProvider) {
+		setSizeFull();
+
+		this.columnIdentifiers = states;
+		this.dropAdapter = dropAdapter;
+		this.cardAdapter = cardAdapter;
+		this.filterProvider = filterProvider;
+
+		mainArea = new VerticalLayout();
+		mainArea.setStyleName(O_MAIN_AREA);
+		mainArea.setSizeFull();
+		setCompositionRoot(mainArea);
+
+		// main and filter
+		filterArea = new VerticalLayout();
+		mainArea.addComponent(filterArea);
+		filterArea.setWidth("100%");
+		filterArea.setStyleName(O_FILTER_AREA);
+		if (filterProvider != null) {
+			Component filterComponent = filterProvider.getFilterComponent();
+			filterComponent.setSizeFull();
+			filterArea.addComponent(filterComponent);
+			filterArea.setExpandRatio(filterComponent, 1.0f);
+
+			filterChangedListener = new CustomFilterChangedListener();
+			filterProvider.setFilterChangedListener(filterChangedListener);
+		}
+
+		// column headers
+		HorizontalLayout columnHeaderArea = new HorizontalLayout();
+		columnHeaderArea.setSizeUndefined();
+		columnHeaderArea.setWidth("100%");
+		columnHeaderArea.setStyleName(O_COLUMN_HEADER_AREA);
+		mainArea.addComponent(columnHeaderArea);
+
+		for (Enum<?> state : states) {
+			columnHeaderArea.addComponent(new Label(toCaption(state)));
+		}
+
+		// columns
+		columnScrollable = new Panel();
+		columnScrollable.setSizeFull();
+		mainArea.addComponent(columnScrollable);
+		mainArea.setExpandRatio(columnScrollable, 1.0f);
+
+		columnArea = new HorizontalLayout();
+		columnArea.setWidth("100%");
+		columnArea.setStyleName(O_COLUMN_AREA);
+		columnScrollable.setContent(columnArea);
+
+		for (Enum<?> state : states) {
+
+			enumMapping.put(state.toString(), state);
+
+			CardsVerticalLayout column = new CardsVerticalLayout();
+			column.setStyleName(O_COLUMN);
+			column.setDragMode(LayoutDragMode.CLONE);
+			column.setWidth("100%");
+			column.setSizeFull();
+			column.setDropHandler(new DropHandler());
+			columnArea.addComponent(column);
+			columnArea.setExpandRatio(column, 1.0f);
+			columns.put(state, column);
+
+			// the spacer
+			VerticalLayout columnSpacer = new VerticalLayout();
+			columnSpacer.setPrimaryStyleName(O_COLUMN_SPACER);
+			columnSpacer.setSizeFull();
+			columnSpacer.addComponent(new Label());
+			column.addComponent(columnSpacer);
+			column.setComponentAlignment(columnSpacer, Alignment.BOTTOM_CENTER);
+			column.setExpandRatio(columnSpacer, 1.0f);
+		}
+
+		// footer
+		footerArea = new VerticalLayout();
+		mainArea.addComponent(footerArea);
+		footerArea.setWidth("100%");
+		footerArea.setStyleName(O_FOOTER_AREA);
+	}
+
+	/**
+	 * Refreshes the card with the given dto
+	 * 
+	 * @param dto
+	 */
+	public void refresh(Object dto) {
+		KanbanCard newCard = cardAdapter.createCard(dto);
+		KanbanCard oldCard = findCardById(newCard.getCardId());
+
+		if (oldCard != null) {
+			CardsVerticalLayout vl = (CardsVerticalLayout) oldCard.getParent();
+			if (oldCard.getCardState() == newCard.getCardState()) {
+				vl.replaceComponent(oldCard, newCard);
+			} else {
+				vl.removeComponent(oldCard);
+				addCard(newCard);
+			}
+		} else {
+			addCard(newCard);
+		}
+
+	}
+
+	protected KanbanCard findCardById(String cardId) {
+		for (Map.Entry<Enum<?>, CardsVerticalLayout> entry : columns.entrySet()) {
+			CardsVerticalLayout vl = entry.getValue();
+			Iterator<Component> iter = vl.iterator();
+			while (iter.hasNext()) {
+				Component comp = iter.next();
+				if (comp instanceof KanbanCard) {
+					KanbanCard oldCard = (KanbanCard) comp;
+					if (oldCard.getCardId().equals(cardId)) {
+						return oldCard;
+					}
+				}
+			}
+		}
+		return null;
+	}
+
+	protected String toCaption(Enum<?> ident) {
+		return ident.name();
+	}
+
+	protected void updateCards() {
+		container.removeAllContainerFilters();
+
+		if (filterProvider != null) {
+			Filter filter = filterProvider.getFilter();
+			if (filter != null) {
+				container.addContainerFilter(filter);
+			}
+		}
+
+		for (CardsVerticalLayout vl : columns.values()) {
+			vl.removeAllCards();
+		}
+
+		for (Object dto : ((Container.Indexed) container).getItemIds(0, noOfCards)) {
+			addCard(cardAdapter.createCard(dto));
+		}
+	}
+
+	public void setContainerDatasource(Container.Filterable container) {
+		this.container = container;
+		updateCards();
+	}
+
+	public void addCard(KanbanCard card) {
+		card.setBoard(this);
+		columns.get(card.getCardState()).addCard(card);
+	}
+
+	protected Enum<?> findSourceState(Component source) {
+		for (Map.Entry<Enum<?>, CardsVerticalLayout> entry : columns.entrySet()) {
+			if (entry.getValue() == source.getParent()) {
+				return enumMapping.get(entry.getKey());
+			}
+		}
+		return null;
+	}
+
+	protected Enum<?> findTargetState(DropTarget target) {
+		for (Map.Entry<Enum<?>, CardsVerticalLayout> entry : columns.entrySet()) {
+			if (entry.getValue() == target) {
+				return enumMapping.get(entry.getKey());
+			}
+		}
+		return null;
+	}
+
+	void doubleClicked(KanbanCard card) {
+		if (doubleClickListener != null) {
+			doubleClickListener.accept(card);
+		}
+	}
+
+	public Consumer<KanbanCard> getDoubleClickListener() {
+		return doubleClickListener;
+	}
+
+	public void setDoubleClickListener(Consumer<KanbanCard> doubleClickListener) {
+		this.doubleClickListener = doubleClickListener;
+	}
+
+	private class AcceptCriterion extends ServerSideCriterion {
+
+		@Override
+		public boolean accept(DragAndDropEvent dragEvent) {
+			VerticalLayoutTargetDetails targetDetails = (VerticalLayoutTargetDetails) dragEvent.getTargetDetails();
+			DropTarget target = targetDetails.getTarget();
+			Component over = targetDetails.getOverComponent();
+			LayoutBoundTransferable transferable = (LayoutBoundTransferable) dragEvent.getTransferable();
+			Component source = (Component) transferable.getComponent();
+
+			if (O_COLUMN_SPACER.equals(source.getPrimaryStyleName())) {
+				return false;
+			}
+
+			if (O_COLUMN_SPACER.equals(over.getPrimaryStyleName())) {
+				VerticalDropLocation dropLocation = targetDetails.getDropLocation();
+				if (dropLocation != VerticalDropLocation.TOP) {
+					targetDetails.setData(Constants.DROP_DETAIL_VERTICAL_DROP_LOCATION,
+							VerticalDropLocation.TOP.toString());
+				}
+			}
+
+			Enum<?> sourceState = findSourceState(source);
+			Enum<?> targetState = findTargetState(target);
+
+			return dropAdapter.dropAllowed(sourceState, targetState, source);
+		}
+	}
+
+	private class DropHandler extends DefaultVerticalLayoutDropHandler {
+
+		public DropHandler() {
+			super(Alignment.TOP_CENTER);
+		}
+
+		@Override
+		public com.vaadin.event.dd.acceptcriteria.AcceptCriterion getAcceptCriterion() {
+			return new AcceptCriterion();
+		}
+
+		@Override
+		protected void handleDropFromLayout(DragAndDropEvent event) {
+			VerticalLayoutTargetDetails targetDetails = (VerticalLayoutTargetDetails) event.getTargetDetails();
+			DropTarget target = targetDetails.getTarget();
+			LayoutBoundTransferable transferable = (LayoutBoundTransferable) event.getTransferable();
+			Component source = (Component) transferable.getComponent();
+
+			Enum<?> sourceState = findSourceState(source);
+			Enum<?> targetState = findTargetState(target);
+
+			boolean dropped = dropAdapter.drop(sourceState, targetState, source);
+			if (dropped) {
+				source.addStyleName("in-statemachine-processing");
+				super.handleDropFromLayout(event);
+			}
+		}
+	}
+
+	/**
+	 * Delegates to the external implementation.
+	 */
+	public interface DropAdapter {
+
+		/**
+		 * Returns true, if the drop is allowed.
+		 * 
+		 * @param sourceState
+		 * @param targetState
+		 * @param dto
+		 * @return
+		 */
+		boolean dropAllowed(Enum<?> sourceState, Enum<?> targetState, Object dto);
+
+		/**
+		 * Executes the drop operation.
+		 * 
+		 * @param sourceState
+		 * @param targetState
+		 * @param dto
+		 * @return
+		 */
+		boolean drop(Enum<?> sourceState, Enum<?> targetState, Object dto);
+	}
+
+	protected static class CardsVerticalLayout extends DDVerticalLayout {
+
+		public void addCard(Component c) {
+			// add before the spacer
+			super.addComponent(c, getComponentCount() - 1);
+			setComponentAlignment(c, Alignment.MIDDLE_CENTER);
+		}
+
+		public void removeAllCards() {
+			// remove all except the spacer
+			for (int i = 0; i < getComponentCount() - 1; i++) {
+				removeComponent(getComponent(0));
+			}
+		}
+	}
+
+	public interface KanbanCardAdapter {
+		/**
+		 * Creates a kanban card for the given item id.
+		 * 
+		 * @param dto
+		 * @return
+		 */
+		KanbanCard createCard(Object dto);
+	}
+
+	public interface FilterProvider {
+
+		/**
+		 * Returns the filter component to be embedded in the board.
+		 * 
+		 * @return
+		 */
+		Component getFilterComponent();
+
+		/**
+		 * The kanban board registers itself for filter change events.
+		 * 
+		 * @param listener
+		 */
+		void setFilterChangedListener(FilterChangedListener listener);
+
+		/**
+		 * Returns the filter of the filter component.
+		 * 
+		 * @return
+		 */
+		Filter getFilter();
+	}
+
+	public interface FilterChangedListener {
+		/**
+		 * Is called by the filter component.
+		 */
+		void filterChanged();
+	}
+
+	private class CustomFilterChangedListener implements FilterChangedListener {
+
+		@Override
+		public void filterChanged() {
+			updateCards();
+		}
+	}
+
+}
diff --git a/org.eclipse.osbp.vaadin.addons.kanban/src/org/eclipse/osbp/vaadin/addons/kanban/KanbanCard.java b/org.eclipse.osbp.vaadin.addons.kanban/src/org/eclipse/osbp/vaadin/addons/kanban/KanbanCard.java
new file mode 100644
index 0000000..0076a02
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.kanban/src/org/eclipse/osbp/vaadin/addons/kanban/KanbanCard.java
@@ -0,0 +1,71 @@
+package org.eclipse.osbp.vaadin.addons.kanban;
+
+import org.eclipse.osbp.vaadin.addons.kanban.client.KanbanCardServerRpc;
+import org.eclipse.osbp.vaadin.addons.kanban.client.KanbanCardState;
+
+import com.vaadin.ui.AbstractSingleComponentContainer;
+
+@SuppressWarnings("serial")
+public class KanbanCard extends AbstractSingleComponentContainer {
+
+	protected KanbanBoard board;
+	protected Object dto;
+
+	KanbanCardServerRpc rpc = new KanbanCardServerRpc() {
+		@Override
+		public void onDoubleClick(String id) {
+			board.doubleClicked(KanbanCard.this);
+		}
+	};
+	private Enum<?> cardState;
+
+	public KanbanCard(String id, Enum<?> cardState, Object dto) {
+		super();
+
+		registerRpc(rpc);
+
+		setCardId(id);
+		setCardState(cardState);
+		this.dto = dto;
+	}
+
+	public KanbanBoard getBoard() {
+		return board;
+	}
+
+	void setBoard(KanbanBoard board) {
+		this.board = board;
+	}
+
+	public void setCardState(Enum<?> cardState) {
+		this.cardState = cardState;
+		getState().cardState = cardState.toString();
+	}
+
+	public Enum<?> getCardState() {
+		return cardState;
+	}
+
+	public void setCardId(String id) {
+		getState().cardId = id;
+	}
+
+	public String getCardId() {
+		return getState(false).cardId;
+	}
+
+	public Object getDto() {
+		return dto;
+	}
+
+	@Override
+	protected KanbanCardState getState() {
+		return (KanbanCardState) super.getState();
+	}
+
+	@Override
+	protected KanbanCardState getState(boolean markAsDirty) {
+		return (KanbanCardState) super.getState(markAsDirty);
+	}
+
+}
diff --git a/org.eclipse.osbp.vaadin.addons.kanban/src/org/eclipse/osbp/vaadin/addons/kanban/KanbanWidgetset.gwt.xml b/org.eclipse.osbp.vaadin.addons.kanban/src/org/eclipse/osbp/vaadin/addons/kanban/KanbanWidgetset.gwt.xml
new file mode 100644
index 0000000..bca4a02
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.kanban/src/org/eclipse/osbp/vaadin/addons/kanban/KanbanWidgetset.gwt.xml
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE module PUBLIC "-//Google Inc.//DTD Google Web Toolkit 2.5.1//EN" "http://google-web-toolkit.googlecode.com/svn/tags/2.5.1/distro-source/core/src/gwt-module.dtd">
+<module>
+	<inherits name="com.vaadin.DefaultWidgetSet" />
+	
+   <!-- Uncomment the following to compile the widgetset for one browser only. 
+		Multiple browsers can be specified as a comma separated list. The supported 
+		user agents at the moment of writing were: ie8,ie9,gecko1_8,safari,opera 
+		The value gecko1_8 is used for Firefox and safari is used for webkit based 
+		browsers including Google Chrome. -->
+
+ 	<!-- To enable SuperDevMode, uncomment this line. See https://vaadin.com/wiki/-/wiki/Main/Using%20SuperDevMode 
+ 		for more information and instructions. --> 
+ 	<!-- <set-configuration-property name="devModeRedirectEnabled" value="true" /> -->
+
+<!-- 	<add-linker name="xsiframe" /> -->
+<!-- 	<set-configuration-property name="devModeRedirectEnabled" value="true" /> -->
+<!-- 	<set-property name="user.agent" value="safari" /> -->
+
+	<stylesheet src="kanban/styles.css" />
+
+    <inherits name="fi.jasoft.dragdroplayouts.DragDropLayoutsWidgetSet" />
+</module>
diff --git a/org.eclipse.osbp.vaadin.addons.kanban/src/org/eclipse/osbp/vaadin/addons/kanban/client/Attribute.java b/org.eclipse.osbp.vaadin.addons.kanban/src/org/eclipse/osbp/vaadin/addons/kanban/client/Attribute.java
new file mode 100644
index 0000000..ab6990f
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.kanban/src/org/eclipse/osbp/vaadin/addons/kanban/client/Attribute.java
@@ -0,0 +1,22 @@
+package org.eclipse.osbp.vaadin.addons.kanban.client;
+
+public class Attribute {
+
+	public String name;
+
+	public String caption;
+
+	public String text;
+
+	public Attribute() {
+
+	}
+
+	public Attribute(String name, String caption, String text) {
+		super();
+		this.name = name;
+		this.caption = caption;
+		this.text = text;
+	}
+
+}
diff --git a/org.eclipse.osbp.vaadin.addons.kanban/src/org/eclipse/osbp/vaadin/addons/kanban/client/KanbanCardClientRpc.java b/org.eclipse.osbp.vaadin.addons.kanban/src/org/eclipse/osbp/vaadin/addons/kanban/client/KanbanCardClientRpc.java
new file mode 100644
index 0000000..466a772
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.kanban/src/org/eclipse/osbp/vaadin/addons/kanban/client/KanbanCardClientRpc.java
@@ -0,0 +1,18 @@
+/**
+ *                                                                            
+ * Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
+ *                                                                            
+ * All rights reserved. This program and the accompanying materials           
+ * are made available under the terms of the Eclipse Public License v1.0       
+ * which accompanies this distribution, and is available at                  
+ * http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ * Contributors:   
+ * Florian Pirchner <florian.pirchner@gmail.com> - Initial implementation
+ */
+package org.eclipse.osbp.vaadin.addons.kanban.client;
+
+import com.vaadin.shared.communication.ClientRpc;
+
+public interface KanbanCardClientRpc extends ClientRpc {
+}
diff --git a/org.eclipse.osbp.vaadin.addons.kanban/src/org/eclipse/osbp/vaadin/addons/kanban/client/KanbanCardConnector.java b/org.eclipse.osbp.vaadin.addons.kanban/src/org/eclipse/osbp/vaadin/addons/kanban/client/KanbanCardConnector.java
new file mode 100644
index 0000000..9a99b6d
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.kanban/src/org/eclipse/osbp/vaadin/addons/kanban/client/KanbanCardConnector.java
@@ -0,0 +1,105 @@
+/**
+ *                                                                            
+ * Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
+ *                                                                            
+ * All rights reserved. This program and the accompanying materials           
+ * are made available under the terms of the Eclipse Public License v1.0       
+ * which accompanies this distribution, and is available at                  
+ * http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ * Contributors:   
+ * Florian Pirchner <florian.pirchner@gmail.com> - Initial implementation
+ */
+package org.eclipse.osbp.vaadin.addons.kanban.client;
+
+import org.eclipse.osbp.vaadin.addons.kanban.KanbanCard;
+
+import com.google.gwt.event.dom.client.DoubleClickEvent;
+import com.google.gwt.event.dom.client.DoubleClickHandler;
+import com.vaadin.client.ComponentConnector;
+import com.vaadin.client.ConnectorHierarchyChangeEvent;
+import com.vaadin.client.communication.RpcProxy;
+import com.vaadin.client.communication.StateChangeEvent;
+import com.vaadin.client.ui.AbstractSingleComponentContainerConnector;
+import com.vaadin.shared.ui.Connect;
+
+// TODO: Auto-generated Javadoc
+/**
+ * The Class SuggestTextFieldConnector.
+ */
+@SuppressWarnings("serial")
+@Connect(KanbanCard.class)
+public class KanbanCardConnector extends AbstractSingleComponentContainerConnector implements DoubleClickHandler {
+
+	private KanbanCardServerRpc serverRPC = RpcProxy.create(KanbanCardServerRpc.class, this);
+
+	/**
+	 * Instantiates a new suggest text field connector.
+	 */
+	public KanbanCardConnector() {
+		registerRpc(KanbanCardClientRpc.class, new KanbanCardClientRpc() {
+
+		});
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see com.vaadin.client.ui.AbstractComponentConnector#getWidget()
+	 */
+	@Override
+	public OKanbanCard getWidget() {
+		return (OKanbanCard) super.getWidget();
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see com.vaadin.client.ui.AbstractComponentConnector#createWidget()
+	 */
+	public OKanbanCard createWidget() {
+		OKanbanCard widget = new OKanbanCard();
+		widget.setDoubleClickHandler(this);
+		return widget;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see com.vaadin.client.ui.AbstractComponentConnector#getState()
+	 */
+	@Override
+	public KanbanCardState getState() {
+		return (KanbanCardState) super.getState();
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see
+	 * com.vaadin.client.ui.AbstractComponentConnector#onStateChanged(com.vaadin
+	 * .client.communication.StateChangeEvent)
+	 */
+	@Override
+	public void onStateChanged(StateChangeEvent stateChangeEvent) {
+		super.onStateChanged(stateChangeEvent);
+
+		getWidget().setState(getState());
+	}
+
+	@Override
+	public void onDoubleClick(DoubleClickEvent event) {
+		serverRPC.onDoubleClick(getState().cardId);
+	}
+
+	@Override
+	public void updateCaption(ComponentConnector connector) {
+
+	}
+
+	@Override
+	public void onConnectorHierarchyChange(ConnectorHierarchyChangeEvent connectorHierarchyChangeEvent) {
+		getWidget().setWidget(getContentWidget());
+	}
+
+}
diff --git a/org.eclipse.osbp.vaadin.addons.kanban/src/org/eclipse/osbp/vaadin/addons/kanban/client/KanbanCardServerRpc.java b/org.eclipse.osbp.vaadin.addons.kanban/src/org/eclipse/osbp/vaadin/addons/kanban/client/KanbanCardServerRpc.java
new file mode 100644
index 0000000..ed48b48
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.kanban/src/org/eclipse/osbp/vaadin/addons/kanban/client/KanbanCardServerRpc.java
@@ -0,0 +1,20 @@
+/**
+ *                                                                            
+ * Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
+ *                                                                            
+ * All rights reserved. This program and the accompanying materials           
+ * are made available under the terms of the Eclipse Public License v1.0       
+ * which accompanies this distribution, and is available at                  
+ * http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ * Contributors:   
+ * Florian Pirchner <florian.pirchner@gmail.com> - Initial implementation
+ */
+package org.eclipse.osbp.vaadin.addons.kanban.client;
+
+import com.vaadin.shared.communication.ServerRpc;
+
+public interface KanbanCardServerRpc extends ServerRpc {
+	
+	void onDoubleClick(String id);
+}
diff --git a/org.eclipse.osbp.vaadin.addons.kanban/src/org/eclipse/osbp/vaadin/addons/kanban/client/KanbanCardState.java b/org.eclipse.osbp.vaadin.addons.kanban/src/org/eclipse/osbp/vaadin/addons/kanban/client/KanbanCardState.java
new file mode 100644
index 0000000..071e7b4
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.kanban/src/org/eclipse/osbp/vaadin/addons/kanban/client/KanbanCardState.java
@@ -0,0 +1,28 @@
+/**
+ *                                                                            
+ * Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
+ *                                                                            
+ * All rights reserved. This program and the accompanying materials           
+ * are made available under the terms of the Eclipse Public License v1.0       
+ * which accompanies this distribution, and is available at                  
+ * http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ * Contributors:   
+ * Florian Pirchner <florian.pirchner@gmail.com> - Initial implementation
+ */
+package org.eclipse.osbp.vaadin.addons.kanban.client;
+
+import com.vaadin.shared.AbstractComponentState;
+
+@SuppressWarnings("serial")
+public class KanbanCardState extends AbstractComponentState {
+
+	public String cardState;
+
+	public String cardId;
+
+//	public boolean processingStateChange;
+
+//	public List<Attribute> onCardValue = new ArrayList<>();
+
+}
diff --git a/org.eclipse.osbp.vaadin.addons.kanban/src/org/eclipse/osbp/vaadin/addons/kanban/client/OKanbanCard.java b/org.eclipse.osbp.vaadin.addons.kanban/src/org/eclipse/osbp/vaadin/addons/kanban/client/OKanbanCard.java
new file mode 100644
index 0000000..683506a
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.kanban/src/org/eclipse/osbp/vaadin/addons/kanban/client/OKanbanCard.java
@@ -0,0 +1,86 @@
+/**
+ *                                                                            
+ * Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
+ *                                                                            
+ * All rights reserved. This program and the accompanying materials           
+ * are made available under the terms of the Eclipse Public License v1.0       
+ * which accompanies this distribution, and is available at                  
+ * http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ * Contributors:   
+ * Florian Pirchner <florian.pirchner@gmail.com> - Initial implementation
+ */
+package org.eclipse.osbp.vaadin.addons.kanban.client;
+
+import com.google.gwt.event.dom.client.DoubleClickEvent;
+import com.google.gwt.event.dom.client.DoubleClickHandler;
+import com.google.gwt.event.shared.HandlerRegistration;
+import com.google.gwt.user.client.DOM;
+import com.google.gwt.user.client.Event;
+import com.google.gwt.user.client.ui.SimplePanel;
+import com.vaadin.client.Focusable;
+
+public class OKanbanCard extends SimplePanel implements Focusable {
+
+	private static final String CLASSNAME = "o-kanban-card";
+
+	@SuppressWarnings("unused")
+	private Object id;
+
+	private boolean initialized;
+	private HandlerRegistration doubleClickRegistration;
+
+	public OKanbanCard() {
+		super(DOM.createDiv());
+		sinkEvents(Event.ONCLICK | Event.MOUSEEVENTS | Event.FOCUSEVENTS | Event.KEYEVENTS);
+
+		setStyleName(CLASSNAME);
+	}
+
+	protected void initialize(KanbanCardState state) {
+		if (initialized) {
+			return;
+		}
+		initialized = true;
+
+		this.id = state.cardId;
+
+	}
+
+	public void setState(KanbanCardState state) {
+		if (!initialized) {
+			initialize(state);
+		}
+	}
+
+	/**
+	 * Sets the keyboard focus on the Panel
+	 * 
+	 * @param focus
+	 *            Should the panel have focus or not.
+	 */
+	public void setFocus(boolean focus) {
+		if (focus) {
+			getContainerElement().focus();
+		} else {
+			getContainerElement().blur();
+		}
+	}
+
+	@Override
+	public void focus() {
+		setFocus(true);
+	}
+
+	@Override
+	protected void onDetach() {
+		super.onDetach();
+
+		doubleClickRegistration.removeHandler();
+	}
+
+	public void setDoubleClickHandler(DoubleClickHandler doubleClickHandler) {
+		doubleClickRegistration = addDomHandler(doubleClickHandler, DoubleClickEvent.getType());
+	}
+
+}
diff --git a/org.eclipse.osbp.vaadin.addons.kanban/src/org/eclipse/osbp/vaadin/addons/kanban/public/kanban/styles.css b/org.eclipse.osbp.vaadin.addons.kanban/src/org/eclipse/osbp/vaadin/addons/kanban/public/kanban/styles.css
new file mode 100644
index 0000000..715af4b
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.kanban/src/org/eclipse/osbp/vaadin/addons/kanban/public/kanban/styles.css
@@ -0,0 +1,34 @@
+.o-filter-area {
+	height: 150px;
+}
+
+.o-kanban-board {
+	background-color: floralwhite;
+}
+
+.o-column-area {
+	background-color: floralwhite;
+}
+
+.o-column {
+    background-color: floralwhite;
+}
+
+.o-kanban-card {
+	border-width: 1px;
+    border-color: black;
+    border-style: solid;
+    width: 75%;
+    height: 75px;
+    background-color: aliceblue;
+    margin-top: 10px;
+    margin-bottom: 10px;
+}
+
+.o-footer-area {
+	height: 50px;
+}
+
+.o-kanban-board .in-statemachine-processing {
+	background-color: red;
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaadin.addons.suggesttext/.classpath b/org.eclipse.osbp.vaadin.addons.suggesttext/.classpath
new file mode 100644
index 0000000..000b921
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.suggesttext/.classpath
@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry including="**/*.java" kind="src" output="target/classes" path="src">
+		<attributes>
+			<attribute name="optional" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="src" path="Sample"/>
+	<classpathentry kind="con" path="org.eclipse.jst.server.core.container/org.eclipse.jst.server.tomcat.runtimeTarget/Apache Tomcat v8.0">
+		<attributes>
+			<attribute name="owner.project.facets" value="jst.web"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.jst.j2ee.internal.web.container"/>
+	<classpathentry kind="con" path="org.eclipse.jst.j2ee.internal.module.container"/>
+	<classpathentry kind="src" path="test"/>
+	<classpathentry kind="con" path="org.apache.ivyde.eclipse.cpcontainer.IVYDE_CONTAINER/?project=org.eclipse.osbp.vaadin.addons.suggesttext&amp;ivyXmlPath=ivy.xml&amp;confs=default&amp;ivySettingsPath=%24%7Bworkspace_loc%3Aorg.eclipse.osbp.vaadin.addons.suggesttext%2Fivysettings.xml%7D&amp;loadSettingsOnDemand=false&amp;ivyUserDir=&amp;propertyFiles=">
+		<attributes>
+			<attribute name="org.eclipse.jst.component.dependency" value="/WEB-INF/lib"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.apache.ivyde.eclipse.cpcontainer.IVYDE_CONTAINER/?project=org.eclipse.osbp.vaadin.addons.suggesttext&amp;ivyXmlPath=ivy.xml&amp;confs=widgetset-compile&amp;ivySettingsPath=%24%7Bworkspace_loc%3Aorg.eclipse.osbp.vaadin.addons.suggesttext%2Fivysettings.xml%7D&amp;loadSettingsOnDemand=false&amp;ivyUserDir=&amp;propertyFiles="/>
+	<classpathentry kind="con" path="org.apache.ivyde.eclipse.cpcontainer.IVYDE_CONTAINER/?project=org.eclipse.osbp.vaadin.addons.suggesttext&amp;ivyXmlPath=ivy.xml&amp;confs=nodeploy&amp;ivySettingsPath=%24%7Bworkspace_loc%3Aorg.eclipse.osbp.vaadin.addons.suggesttext%2Fivysettings.xml%7D&amp;loadSettingsOnDemand=false&amp;ivyUserDir=&amp;propertyFiles="/>
+	<classpathentry exported="true" kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="output" path="target/classes"/>
+</classpath>
diff --git a/org.eclipse.osbp.vaadin.addons.suggesttext/.gitignore b/org.eclipse.osbp.vaadin.addons.suggesttext/.gitignore
new file mode 100644
index 0000000..9c43300
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.suggesttext/.gitignore
@@ -0,0 +1,3 @@
+META-INF/
+**/git.properties
+**/target/
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaadin.addons.suggesttext/.project b/org.eclipse.osbp.vaadin.addons.suggesttext/.project
index 0b595d2..d05f5c2 100644
--- a/org.eclipse.osbp.vaadin.addons.suggesttext/.project
+++ b/org.eclipse.osbp.vaadin.addons.suggesttext/.project
@@ -40,15 +40,9 @@
 			<arguments>
 			</arguments>
 		</buildCommand>
-		<buildCommand>
-			<name>org.eclipse.m2e.core.maven2Builder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
 	</buildSpec>
 	<natures>
 		<nature>org.eclipse.pde.PluginNature</nature>
-		<nature>org.eclipse.m2e.core.maven2Nature</nature>
 		<nature>org.eclipse.jem.workbench.JavaEMFNature</nature>
 		<nature>org.eclipse.wst.common.modulecore.ModuleCoreNature</nature>
 		<nature>org.eclipse.wst.common.project.facet.core.nature</nature>
diff --git a/org.eclipse.osbp.vaadin.addons.suggesttext/.project-for-debug b/org.eclipse.osbp.vaadin.addons.suggesttext/.project-for-debug
new file mode 100644
index 0000000..02866a3
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.suggesttext/.project-for-debug
@@ -0,0 +1,60 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.osbp.vaadin.addons.suggesttext</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.wst.jsdt.core.javascriptValidator</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.wst.common.project.facet.core.builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.wst.validation.validationbuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.vaadin.integration.eclipse.widgetsetBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.babel.editor.rbeBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.sonarlint.eclipse.core.sonarlintBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.pde.PluginNature</nature>
+		<nature>org.eclipse.jem.workbench.JavaEMFNature</nature>
+		<nature>org.eclipse.wst.common.modulecore.ModuleCoreNature</nature>
+		<nature>org.eclipse.wst.common.project.facet.core.nature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.wst.jsdt.core.jsNature</nature>
+		<nature>com.vaadin.integration.eclipse.widgetsetNature</nature>
+		<nature>org.apache.ivyde.eclipse.ivynature</nature>
+		<nature>org.eclipse.babel.editor.rbeNature</nature>
+	</natures>
+</projectDescription>
diff --git a/org.eclipse.osbp.vaadin.addons.suggesttext/.settings/.jsdtscope b/org.eclipse.osbp.vaadin.addons.suggesttext/.settings/.jsdtscope
new file mode 100644
index 0000000..92e666d
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.suggesttext/.settings/.jsdtscope
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry excluding="**/bower_components/*|**/node_modules/*|**/*.min.js" kind="src" path="WebContent"/>
+	<classpathentry kind="con" path="org.eclipse.wst.jsdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="con" path="org.eclipse.wst.jsdt.launching.WebProject">
+		<attributes>
+			<attribute name="hide" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.wst.jsdt.launching.baseBrowserLibrary"/>
+	<classpathentry kind="output" path=""/>
+</classpath>
diff --git a/org.eclipse.osbp.vaadin.addons.suggesttext/.settings/com.vaadin.integration.eclipse.prefs b/org.eclipse.osbp.vaadin.addons.suggesttext/.settings/com.vaadin.integration.eclipse.prefs
new file mode 100644
index 0000000..a8de489
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.suggesttext/.settings/com.vaadin.integration.eclipse.prefs
@@ -0,0 +1,11 @@
+com.vaadin.integration.eclipse.mavenAutoCompileWidgetset=true
+com.vaadin.integration.eclipse.mavenLatestVersionsUpgrade=["7.5.10","7.7.3"]
+com.vaadin.integration.eclipse.notifyOfVaadinUpdates=true
+com.vaadin.integration.eclipse.previousCompileAction=widgetset
+com.vaadin.integration.eclipse.useLatestNightly=false
+com.vaadin.integration.eclipse.widgetsetBuildsSuspended=true
+com.vaadin.integration.eclipse.widgetsetCompilationEta=50065
+com.vaadin.integration.eclipse.widgetsetDirty=false
+com.vaadin.integration.eclipse.widgetsetStyle=OBF
+com.vaadin.integration.eclipse.widgetsetVerbose=true
+eclipse.preferences.version=1
diff --git a/org.eclipse.osbp.vaadin.addons.suggesttext/.settings/org.eclipse.core.resources.prefs b/org.eclipse.osbp.vaadin.addons.suggesttext/.settings/org.eclipse.core.resources.prefs
new file mode 100644
index 0000000..7a53139
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.suggesttext/.settings/org.eclipse.core.resources.prefs
@@ -0,0 +1,3 @@
+eclipse.preferences.version=1
+encoding/<project>=UTF-8
+encoding/src=UTF-8
diff --git a/org.eclipse.osbp.vaadin.addons.suggesttext/.settings/org.eclipse.jdt.core.prefs b/org.eclipse.osbp.vaadin.addons.suggesttext/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..13b3428
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.suggesttext/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,13 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.methodParameters=do not generate
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
+org.eclipse.jdt.core.compiler.source=1.8
diff --git a/org.eclipse.osbp.vaadin.addons.suggesttext/.settings/org.eclipse.m2e.core.prefs b/org.eclipse.osbp.vaadin.addons.suggesttext/.settings/org.eclipse.m2e.core.prefs
new file mode 100644
index 0000000..f897a7f
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.suggesttext/.settings/org.eclipse.m2e.core.prefs
@@ -0,0 +1,4 @@
+activeProfiles=
+eclipse.preferences.version=1
+resolveWorkspaceProjects=true
+version=1
diff --git a/org.eclipse.osbp.vaadin.addons.suggesttext/.settings/org.eclipse.wst.common.component b/org.eclipse.osbp.vaadin.addons.suggesttext/.settings/org.eclipse.wst.common.component
new file mode 100644
index 0000000..9578c6f
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.suggesttext/.settings/org.eclipse.wst.common.component
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?><project-modules id="moduleCoreId" project-version="1.5.0">
+    <wb-module deploy-name="org.eclipse.osbp.vaadin.addons.suggesttext">
+        <wb-resource deploy-path="/" source-path="/WebContent" tag="defaultRootSource"/>
+        <wb-resource deploy-path="/WEB-INF/classes" source-path="/src"/>
+        <wb-resource deploy-path="/WEB-INF/classes" source-path="/Sample"/>
+        <property name="java-output-path" value="/org.eclipse.osbp.vaadin.addons.suggesttext/build/classes"/>
+        <property name="context-root" value="org.eclipse.osbp.vaadin.addons.suggesttext"/>
+    </wb-module>
+</project-modules>
diff --git a/org.eclipse.osbp.vaadin.addons.suggesttext/.settings/org.eclipse.wst.common.project.facet.core.xml b/org.eclipse.osbp.vaadin.addons.suggesttext/.settings/org.eclipse.wst.common.project.facet.core.xml
new file mode 100644
index 0000000..b662702
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.suggesttext/.settings/org.eclipse.wst.common.project.facet.core.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<faceted-project>
+  <runtime name="Apache Tomcat v8.0"/>
+  <fixed facet="wst.jsdt.web"/>
+  <fixed facet="java"/>
+  <fixed facet="com.vaadin.integration.eclipse.core"/>
+  <fixed facet="jst.web"/>
+  <installed facet="jst.web" version="3.1"/>
+  <installed facet="wst.jsdt.web" version="1.0"/>
+  <installed facet="com.vaadin.integration.eclipse.core" version="7.0"/>
+  <installed facet="java" version="1.8"/>
+</faceted-project>
diff --git a/org.eclipse.osbp.vaadin.addons.suggesttext/.settings/org.eclipse.wst.jsdt.ui.superType.container b/org.eclipse.osbp.vaadin.addons.suggesttext/.settings/org.eclipse.wst.jsdt.ui.superType.container
new file mode 100644
index 0000000..3bd5d0a
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.suggesttext/.settings/org.eclipse.wst.jsdt.ui.superType.container
@@ -0,0 +1 @@
+org.eclipse.wst.jsdt.launching.baseBrowserLibrary
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaadin.addons.suggesttext/.settings/org.eclipse.wst.jsdt.ui.superType.name b/org.eclipse.osbp.vaadin.addons.suggesttext/.settings/org.eclipse.wst.jsdt.ui.superType.name
new file mode 100644
index 0000000..05bd71b
--- /dev/null
+++ b/org.eclipse.osbp.vaadin.addons.suggesttext/.settings/org.eclipse.wst.jsdt.ui.superType.name
@@ -0,0 +1 @@
+Window
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaadin.addons.suggesttext/Sample/org/eclipse/osbp/vaadin/addons/suggesttext/sample/SuggestTextUI.java b/org.eclipse.osbp.vaadin.addons.suggesttext/Sample/org/eclipse/osbp/vaadin/addons/suggesttext/sample/SuggestTextUI.java
index bcdc820..d704b50 100644
--- a/org.eclipse.osbp.vaadin.addons.suggesttext/Sample/org/eclipse/osbp/vaadin/addons/suggesttext/sample/SuggestTextUI.java
+++ b/org.eclipse.osbp.vaadin.addons.suggesttext/Sample/org/eclipse/osbp/vaadin/addons/suggesttext/sample/SuggestTextUI.java
@@ -153,18 +153,39 @@
 		selectCurrent.setWidth("100%");
 		touchLayout.addComponent(selectCurrent);
 
+		Button sendKeys = new Button("send 'Pirchner1234' as Keys", e -> {
+			int length = suggestionBox.getKeys().length();
+			if(length < "Pirchner12345".length()) {
+				String keys = suggestionBox.getKeys() + "Pirchner12345".substring(length, length+1);
+				suggestionBox.setKeys(keys);
+			}
+		});
+		sendKeys.setWidth("100%");
+		layout.addComponent(sendKeys);
+		
+		Button sendKeysAsValue = new Button("send 'Pirchner1234' as Value", e -> {
+			int length = suggestionBox.getValue().length();
+			if(length < "Pirchner12345".length()) {
+				String keys = suggestionBox.getValue() + "Pirchner12345".substring(length, length+1);
+				suggestionBox.setValue(keys);
+			}
+		});
+		sendKeysAsValue.setWidth("100%");
+		layout.addComponent(sendKeysAsValue);
+		
 		// configure and add suggestion box
 		suggestionBox.setCaption("Select");
 		suggestionBox.getTextField().addValueChangeListener(new Property.ValueChangeListener() {
 			@Override
 			public void valueChange(ValueChangeEvent event) {
-				System.out.println("Foo");
+				System.out.println("Value changed to " + event.getProperty().getValue());
 			}
 		});
 		suggestionBox.setSuggestionEnabled(true);
 		suggestionBox.setLimit(10);
 		suggestionBox.setPopupDelay(500);
 		suggestionBox.addStyleName("os-cash");
+		suggestionBox.setDisableSuggestionTooltip("enable / disable suggestions");
 		layout.addComponent(suggestionBox);
 		BeanItemContainer<Person> container = new BeanItemContainer<>(Person.class);
 
@@ -173,7 +194,12 @@
 			container.addBean(new Person("Klemens" + i, "Edler" + i));
 			container.addBean(new Person("Berni" + i, "Edler" + i));
 		}
-		container.addBean(new Person("Sabrina", "Hopf"));
+		container.addBean(new Person("Florian", "Pirchner1"));
+		container.addBean(new Person("Florian", "Pirchner12"));
+		container.addBean(new Person("Florian", "Pirchner123"));
+		container.addBean(new Person("Florian", "Pirchner1234"));
+		container.addBean(new Person("Florian", "Pirchner12345"));
+		container.addBean(new Person("Jörg", "Riegel"));
 
 		suggestionBox.setContainerDataSource(container);
 		suggestionBox.setCaptionPropertyId("lastname");
@@ -241,6 +267,7 @@
 		suggestionBox.setSuggestionEnabled(true);
 		suggestionBox.setLimit(10);
 		suggestionBox.setPopupDelay(500);
+		suggestionBox.setDisableSuggestionTooltip("enable / disable suggestions");
 		layout.addComponent(suggestionBox);
 		BeanItemContainer<PersonForUUIDMapping> container = new BeanItemContainer<>(PersonForUUIDMapping.class);
 
@@ -249,7 +276,7 @@
 			container.addBean(new PersonForUUIDMapping("Klemens" + i, "Edler" + i));
 			container.addBean(new PersonForUUIDMapping("Berni" + i, "Edler" + i));
 		}
-		container.addBean(new PersonForUUIDMapping("Sabrina", "Hopf"));
+		container.addBean(new PersonForUUIDMapping("Jörg", "Riegel"));
 
 		suggestionBox.setContainerDataSource(container);
 		suggestionBox.setCaptionPropertyId("lastname");
diff --git a/org.eclipse.osbp.vaadin.addons.suggesttext/SuperDevMode code server for org.eclipse.osbp.vaadin.addons.suggesttext.launch b/org.eclipse.osbp.vaadin.addons.suggesttext/SuperDevMode code server for org.eclipse.osbp.vaadin.addons.suggesttext.launch
index 802e6c0..23fcc34 100644
--- a/org.eclipse.osbp.vaadin.addons.suggesttext/SuperDevMode code server for org.eclipse.osbp.vaadin.addons.suggesttext.launch
+++ b/org.eclipse.osbp.vaadin.addons.suggesttext/SuperDevMode code server for org.eclipse.osbp.vaadin.addons.suggesttext.launch
@@ -13,12 +13,10 @@
 <listEntry value="&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot; standalone=&quot;no&quot;?&gt;&#10;&lt;runtimeClasspathEntry internalArchive=&quot;/org.eclipse.osbp.vaadin.addons.suggesttext/Sample&quot; path=&quot;3&quot; type=&quot;2&quot;/&gt;&#10;"/>
 <listEntry value="&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot; standalone=&quot;no&quot;?&gt;&#10;&lt;runtimeClasspathEntry internalArchive=&quot;/org.eclipse.osbp.vaadin.addons.suggesttext/test&quot; path=&quot;3&quot; type=&quot;2&quot;/&gt;&#10;"/>
 </listAttribute>
-<stringAttribute key="org.eclipse.jdt.launching.CLASSPATH_PROVIDER" value="org.eclipse.m2e.launchconfig.classpathProvider"/>
 <booleanAttribute key="org.eclipse.jdt.launching.DEFAULT_CLASSPATH" value="false"/>
 <stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="com.google.gwt.dev.codeserver.CodeServer"/>
 <stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="org.eclipse.osbp.vaadin.addons.suggesttext.SuggestTextWidgetset"/>
 <stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="org.eclipse.osbp.vaadin.addons.suggesttext"/>
-<stringAttribute key="org.eclipse.jdt.launching.SOURCE_PATH_PROVIDER" value="org.eclipse.m2e.launchconfig.sourcepathProvider"/>
 <stringAttribute key="org.eclipse.jdt.launching.VM_ARGUMENTS" value="-Xss8M -Xmx512M -XX:MaxPermSize=512M"/>
-<stringAttribute key="org.eclipse.jdt.launching.WORKING_DIRECTORY" value="/Users/florianpirchner/git/org.osbee.vaadin.addons/org.eclipse.osbp.vaadin.addons.suggestbox"/>
+<stringAttribute key="org.eclipse.jdt.launching.WORKING_DIRECTORY" value="/Users/florianpirchner/Work/dev/osbp-foodmart/git-Neon-final/org.eclipse.osbp.vaadin.addons/org.eclipse.osbp.vaadin.addons.suggesttext"/>
 </launchConfiguration>
diff --git a/org.eclipse.osbp.vaadin.addons.suggesttext/ivy.xml b/org.eclipse.osbp.vaadin.addons.suggesttext/ivy.xml
index 070ca06..1925187 100644
--- a/org.eclipse.osbp.vaadin.addons.suggesttext/ivy.xml
+++ b/org.eclipse.osbp.vaadin.addons.suggesttext/ivy.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0"?>
 <!DOCTYPE ivy-module [
-	<!ENTITY vaadin.version "7.6.5">
+	<!ENTITY vaadin.version "7.7.6">
 ]>
 <ivy-module version="2.0"
 	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
diff --git a/org.eclipse.osbp.vaadin.addons.suggesttext/pom.xml b/org.eclipse.osbp.vaadin.addons.suggesttext/pom.xml
index c0aa482..2e1f48a 100644
--- a/org.eclipse.osbp.vaadin.addons.suggesttext/pom.xml
+++ b/org.eclipse.osbp.vaadin.addons.suggesttext/pom.xml
@@ -37,6 +37,11 @@
 			<version>${vaadin.version}</version>
 		</dependency>
 		<dependency>
+			<groupId>com.vaadin</groupId>
+			<artifactId>vaadin-shared</artifactId>
+			<version>${vaadin.version}</version>
+		</dependency>
+		<dependency>
 			<groupId>com.vaadin.external.slf4j</groupId>
 			<artifactId>vaadin-slf4j-jdk14</artifactId>
 			<version>1.6.1</version>
@@ -62,7 +67,6 @@
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-compiler-plugin</artifactId>
-				<version>3.0</version>
 				<configuration>
 					<encoding>UTF-8</encoding>
 					<source>1.8</source>
@@ -78,10 +82,10 @@
 					<instructions>
 						<Bundle-Name>OS.bee Addon for Vaadin: Suggesttext</Bundle-Name>
 						<Bundle-SymbolicName>org.eclipse.osbp.vaadin.addons.suggesttext</Bundle-SymbolicName>
-                        <Bundle-Version>0.9.0.{osgi-version-qualifier}</Bundle-Version>
-						<Require-Bundle>com.vaadin.server;bundle-version="[7.5.7,7.7.0)",
-							com.vaadin.client;bundle-version="[7.5.7,7.7.0)",
-							com.vaadin.shared;bundle-version="[7.5.7,7.7.0)",
+						<Bundle-Version>0.9.0.{osgi-version-qualifier}</Bundle-Version>
+						<Require-Bundle>com.vaadin.server;bundle-version="[7.7.6,7.8.0)",
+							com.vaadin.client;bundle-version="[7.7.6,7.8.0)",
+							com.vaadin.shared;bundle-version="[7.7.6,7.8.0)",
 							org.jsoup;bundle-version="[1.8.3,1.8.4)"
 						</Require-Bundle>
 						<Import-Package>
@@ -103,7 +107,6 @@
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-source-plugin</artifactId>
-				<version>2.2.1</version>
 				<executions>
 					<execution>
 						<id>attach-sources</id>
diff --git a/org.eclipse.osbp.vaadin.addons.suggesttext/src/org/eclipse/osbp/vaadin/addons/suggesttext/SuggestTextField.java b/org.eclipse.osbp.vaadin.addons.suggesttext/src/org/eclipse/osbp/vaadin/addons/suggesttext/SuggestTextField.java
index b46c4be..292a420 100644
--- a/org.eclipse.osbp.vaadin.addons.suggesttext/src/org/eclipse/osbp/vaadin/addons/suggesttext/SuggestTextField.java
+++ b/org.eclipse.osbp.vaadin.addons.suggesttext/src/org/eclipse/osbp/vaadin/addons/suggesttext/SuggestTextField.java
@@ -100,13 +100,18 @@
 				fireSelectionChanged(itemId);
 			}
 		}
+
+		@Override
+		public void setSuggestionEnabled(boolean value) {
+			SuggestTextField.this.setSuggestionEnabled(value);
+		}
 	};
 
 	/** The container. */
 	private Container container;
 
 	/** The text field. */
-	private TextField textField;
+	private TextFieldCustom textField;
 
 	/** The needs uuid mapping. */
 	private boolean needsUUIDMapping;
@@ -120,11 +125,15 @@
 	public SuggestTextField() {
 		registerRpc(rpc);
 
-		textField = new TextField();
+		textField = createTextField();
 		textField.setSizeFull();
 		setContent(textField);
 	}
 
+	protected TextFieldCustom createTextField() {
+		return new TextFieldCustom();
+	}
+
 	/*
 	 * (non-Javadoc)
 	 * 
@@ -173,6 +182,29 @@
 	}
 
 	/**
+	 * Sets the value into the text field. Also calls {@link #closePopup()} and
+	 * {@link #openPopup()}
+	 * 
+	 * @param value
+	 */
+	public void setKeys(String value) {
+		closePopup();
+		textField.setValue(value);
+		if(isSuggestionEnabled()) {
+			openPopup();
+		}
+	}
+
+	/**
+	 * Returns the value from the text field.
+	 * 
+	 * @return
+	 */
+	public String getKeys() {
+		return textField.getValue();
+	}
+
+	/**
 	 * Opens the popup if not already opened and shows the suggested values.
 	 */
 	public void openPopup() {
@@ -233,6 +265,15 @@
 	}
 
 	/**
+	 * Tooltip for "disable suggestions" action.
+	 * 
+	 * @param disableSuggestionTooltip
+	 */
+	public void setDisableSuggestionTooltip(String disableSuggestionTooltip) {
+		getState(true).disableSuggestionTooltip = disableSuggestionTooltip;
+	}
+
+	/**
 	 * True, if suggestions should be enabled. False otherwise.
 	 *
 	 * @param suggestionEnabled
@@ -637,4 +678,11 @@
 		void selectionChanged(SelectionChangedEvent event);
 
 	}
+
+	public class TextFieldCustom extends TextField {
+
+		public TextFieldCustom() {
+			super();
+		}
+	}
 }
diff --git a/org.eclipse.osbp.vaadin.addons.suggesttext/src/org/eclipse/osbp/vaadin/addons/suggesttext/client/ODelegatingOracle.java b/org.eclipse.osbp.vaadin.addons.suggesttext/src/org/eclipse/osbp/vaadin/addons/suggesttext/client/ODelegatingOracle.java
index 0ad5543..b67e673 100644
--- a/org.eclipse.osbp.vaadin.addons.suggesttext/src/org/eclipse/osbp/vaadin/addons/suggesttext/client/ODelegatingOracle.java
+++ b/org.eclipse.osbp.vaadin.addons.suggesttext/src/org/eclipse/osbp/vaadin/addons/suggesttext/client/ODelegatingOracle.java
@@ -166,4 +166,9 @@
 	public void setSuggestionEnabled(boolean suggestionEnabled) {
 		this.suggestionEnabled = suggestionEnabled;
 	}
+
+	public boolean isSuggestionEnabled() {
+		return suggestionEnabled;
+	}
+	
 }
diff --git a/org.eclipse.osbp.vaadin.addons.suggesttext/src/org/eclipse/osbp/vaadin/addons/suggesttext/client/OSuggestBox.java b/org.eclipse.osbp.vaadin.addons.suggesttext/src/org/eclipse/osbp/vaadin/addons/suggesttext/client/OSuggestBox.java
index 50dc26d..a3cf881 100644
--- a/org.eclipse.osbp.vaadin.addons.suggesttext/src/org/eclipse/osbp/vaadin/addons/suggesttext/client/OSuggestBox.java
+++ b/org.eclipse.osbp.vaadin.addons.suggesttext/src/org/eclipse/osbp/vaadin/addons/suggesttext/client/OSuggestBox.java
@@ -37,6 +37,8 @@
 import com.google.gwt.event.logical.shared.ValueChangeHandler;
 import com.google.gwt.event.shared.HandlerRegistration;
 import com.google.gwt.user.client.DOM;
+import com.google.gwt.user.client.Event;
+import com.google.gwt.user.client.EventListener;
 import com.google.gwt.user.client.ui.DecoratedPopupPanel;
 import com.google.gwt.user.client.ui.Focusable;
 import com.google.gwt.user.client.ui.HasAnimation;
@@ -73,6 +75,8 @@
 public class OSuggestBox extends SimplePanel implements HasText, Focusable, HasEnabled, HasAllKeyHandlers,
 		HasValue<String>, HasSelectionHandlers<Suggestion>, IsEditor<LeafValueEditor<String>> {
 
+	private static final String SELECTED_CLASSNAME = "selected";
+
 	/**
 	 * The callback used when a user selects a {@link Suggestion}.
 	 */
@@ -801,6 +805,12 @@
 
 	private int openPopupModifier;
 
+	private Element suggestModeDiv;
+
+	private String disableSuggestionTooltip;
+
+	private SuggestTextFieldServerRpc serverRpc;
+
 	/**
 	 * Constructor for {@link OSuggestBox}. The text box will be removed from
 	 * it's current location and wrapped by the {@link OSuggestBox}.
@@ -851,7 +861,7 @@
 	public void setSingleSuggestionAndClosePopup(Suggestion selectedSuggestion) {
 		assert selectedSuggestion != null : "suggestion cannot be null";
 		String currentText = selectedSuggestion.getReplacementString();
-		setText(currentText);
+		setTextInternal(currentText);
 		((DefaultSuggestionDisplay) getSuggestionDisplay()).hideSuggestions();
 		SelectionEvent.fire(this, selectedSuggestion);
 	}
@@ -869,9 +879,34 @@
 		setWidget(box);
 		addEventsToTextBox();
 
+		Element mainElement = getElement();
+
+		suggestModeDiv = DOM.createDiv();
+		suggestModeDiv.addClassName("enableSuggestions");
+		mainElement.appendChild(suggestModeDiv);
+		suggestModeDiv.setTitle(disableSuggestionTooltip);
+
+		if (!isSuggestMode()) {
+			suggestModeDiv.removeClassName(SELECTED_CLASSNAME);
+		} else {
+			suggestModeDiv.addClassName(SELECTED_CLASSNAME);
+		}
+
+		Event.setEventListener(suggestModeDiv, new EventListener() {
+			@Override
+			public void onBrowserEvent(Event event) {
+				setSuggestionEnabled(!isSuggestMode());
+			}
+		});
+		Event.sinkEvents(suggestModeDiv, Event.ONCLICK);
+
 		setStyleName(STYLENAME_DEFAULT);
 	}
 
+	public boolean isSuggestMode() {
+		return suggestModeDiv.hasClassName(SELECTED_CLASSNAME);
+	}
+
 	/*
 	 * (non-Javadoc)
 	 * 
@@ -1164,6 +1199,12 @@
 	 * @see com.google.gwt.user.client.ui.HasText#setText(java.lang.String)
 	 */
 	public void setText(String text) {
+		setTextInternal(text);
+		// refresh the suggestions
+		refreshSuggestions();
+	}
+
+	public void setTextInternal(String text) {
 		box.setText(text);
 	}
 
@@ -1236,7 +1277,6 @@
 	 */
 	private void addEventsToTextBox() {
 		class TextBoxEvents implements KeyDownHandler, KeyUpHandler, ValueChangeHandler<String> {
-
 			public void onKeyDown(KeyDownEvent event) {
 				if (event.isAnyModifierKeyDown()) {
 					if (isOpenPopupKey(event) && isOpenPopupModifier(event)) {
@@ -1337,7 +1377,7 @@
 	private void setNewSelection(Suggestion curSuggestion) {
 		assert curSuggestion != null : "suggestion cannot be null";
 		currentText = curSuggestion.getReplacementString();
-		setText(currentText);
+		setTextInternal(currentText);
 		display.hideSuggestions();
 		fireSuggestionEvent(curSuggestion);
 	}
@@ -1359,7 +1399,31 @@
 	 *            the new suggestion enabled
 	 */
 	public void setSuggestionEnabled(boolean suggestionEnabled) {
+		if (((ODelegatingOracle) oracle).isSuggestionEnabled() == suggestionEnabled) {
+			return;
+		}
+
 		((ODelegatingOracle) oracle).setSuggestionEnabled(suggestionEnabled);
+
+		serverRpc.setSuggestionEnabled(suggestionEnabled);
+
+		if (!suggestionEnabled) {
+			suggestModeDiv.removeClassName(SELECTED_CLASSNAME);
+		} else {
+			suggestModeDiv.addClassName(SELECTED_CLASSNAME);
+		}
+	}
+
+	public void setDisableSuggestionTooltip(String disableSuggestionTooltip) {
+		this.disableSuggestionTooltip = disableSuggestionTooltip;
+
+		if (suggestModeDiv != null) {
+			suggestModeDiv.setTitle(disableSuggestionTooltip);
+		}
+	}
+
+	public void setServerRPC(SuggestTextFieldServerRpc serverRpc) {
+		this.serverRpc = serverRpc;
 	}
 
 }
diff --git a/org.eclipse.osbp.vaadin.addons.suggesttext/src/org/eclipse/osbp/vaadin/addons/suggesttext/client/SuggestTextFieldConnector.java b/org.eclipse.osbp.vaadin.addons.suggesttext/src/org/eclipse/osbp/vaadin/addons/suggesttext/client/SuggestTextFieldConnector.java
index 1116584..cf4782f 100644
--- a/org.eclipse.osbp.vaadin.addons.suggesttext/src/org/eclipse/osbp/vaadin/addons/suggesttext/client/SuggestTextFieldConnector.java
+++ b/org.eclipse.osbp.vaadin.addons.suggesttext/src/org/eclipse/osbp/vaadin/addons/suggesttext/client/SuggestTextFieldConnector.java
@@ -39,7 +39,7 @@
 
 	/** The rpc. */
 	private SuggestTextFieldServerRpc rpc = RpcProxy.create(SuggestTextFieldServerRpc.class, this);
-	
+
 	/** The query delegate. */
 	private OQueryDelegate queryDelegate;
 
@@ -80,7 +80,9 @@
 		});
 	}
 
-	/* (non-Javadoc)
+	/*
+	 * (non-Javadoc)
+	 * 
 	 * @see com.vaadin.client.ui.AbstractComponentConnector#getWidget()
 	 */
 	@Override
@@ -88,17 +90,22 @@
 		return (OSuggestBox) super.getWidget();
 	}
 
-	/* (non-Javadoc)
+	/*
+	 * (non-Javadoc)
+	 * 
 	 * @see com.vaadin.client.ui.AbstractComponentConnector#createWidget()
 	 */
 	public OSuggestBox createWidget() {
 		queryDelegate = new OQueryDelegate(rpc);
 		OSuggestBox widget = new OSuggestBox(new ODelegatingOracle(queryDelegate));
 		widget.addSelectionHandler(this);
+		widget.setServerRPC(rpc);
 		return widget;
 	}
-	
-	/* (non-Javadoc)
+
+	/*
+	 * (non-Javadoc)
+	 * 
 	 * @see com.vaadin.client.ui.AbstractComponentConnector#getState()
 	 */
 	@Override
@@ -106,8 +113,12 @@
 		return (SuggestTextFieldState) super.getState();
 	}
 
-	/* (non-Javadoc)
-	 * @see com.vaadin.client.ui.AbstractComponentConnector#onStateChanged(com.vaadin.client.communication.StateChangeEvent)
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see
+	 * com.vaadin.client.ui.AbstractComponentConnector#onStateChanged(com.vaadin
+	 * .client.communication.StateChangeEvent)
 	 */
 	@Override
 	public void onStateChanged(StateChangeEvent stateChangeEvent) {
@@ -119,10 +130,15 @@
 		getWidget().setAutoHide(getState().autoHide);
 		getWidget().setOpenPopupKey(getState().openPopup_key);
 		getWidget().setOpenPopupKeyModifier(getState().openPopup_modifier);
+		getWidget().setDisableSuggestionTooltip(getState().disableSuggestionTooltip);
 	}
 
-	/* (non-Javadoc)
-	 * @see com.google.gwt.event.logical.shared.SelectionHandler#onSelection(com.google.gwt.event.logical.shared.SelectionEvent)
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see
+	 * com.google.gwt.event.logical.shared.SelectionHandler#onSelection(com.
+	 * google.gwt.event.logical.shared.SelectionEvent)
 	 */
 	@Override
 	public void onSelection(SelectionEvent<Suggestion> event) {
@@ -132,17 +148,18 @@
 		}
 	}
 
-	/* (non-Javadoc)
-	 * @see com.vaadin.client.HasComponentsConnector#updateCaption(com.vaadin.client.ComponentConnector)
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see
+	 * com.vaadin.client.HasComponentsConnector#updateCaption(com.vaadin.client.
+	 * ComponentConnector)
 	 */
 	@Override
 	public void updateCaption(ComponentConnector connector) {
 
 	}
 
-	/* (non-Javadoc)
-	 * @see com.vaadin.client.ConnectorHierarchyChangeEvent.ConnectorHierarchyChangeHandler#onConnectorHierarchyChange(com.vaadin.client.ConnectorHierarchyChangeEvent)
-	 */
 	@SuppressWarnings("unchecked")
 	@Override
 	public void onConnectorHierarchyChange(ConnectorHierarchyChangeEvent connectorHierarchyChangeEvent) {
diff --git a/org.eclipse.osbp.vaadin.addons.suggesttext/src/org/eclipse/osbp/vaadin/addons/suggesttext/client/SuggestTextFieldServerRpc.java b/org.eclipse.osbp.vaadin.addons.suggesttext/src/org/eclipse/osbp/vaadin/addons/suggesttext/client/SuggestTextFieldServerRpc.java
index c2ebc8e..63b2080 100644
--- a/org.eclipse.osbp.vaadin.addons.suggesttext/src/org/eclipse/osbp/vaadin/addons/suggesttext/client/SuggestTextFieldServerRpc.java
+++ b/org.eclipse.osbp.vaadin.addons.suggesttext/src/org/eclipse/osbp/vaadin/addons/suggesttext/client/SuggestTextFieldServerRpc.java
@@ -25,16 +25,27 @@
 	 * 
 	 * @param handleId
 	 *            a unique id for every request to link request/response.
-	 * @param filter the filter string.
-	 * @param limit the maximum number of suggestions to be contained in the response. 
+	 * @param filter
+	 *            the filter string.
+	 * @param limit
+	 *            the maximum number of suggestions to be contained in the
+	 *            response.
 	 */
 	public void requestSuggestions(String handleId, String filter, int limit);
 
 	/**
 	 * The suggestion with the given id was selected.
 	 *
-	 * @param uuid the uuid
+	 * @param uuid
+	 *            the uuid
 	 */
 	public void selectionChanged(String uuid);
 
+	/**
+	 * The client notifies the server about suggestion enablement.
+	 * 
+	 * @param value
+	 */
+	public void setSuggestionEnabled(boolean value);
+
 }
diff --git a/org.eclipse.osbp.vaadin.addons.suggesttext/src/org/eclipse/osbp/vaadin/addons/suggesttext/client/SuggestTextFieldState.java b/org.eclipse.osbp.vaadin.addons.suggesttext/src/org/eclipse/osbp/vaadin/addons/suggesttext/client/SuggestTextFieldState.java
index 2bc82bc..f9d49b9 100644
--- a/org.eclipse.osbp.vaadin.addons.suggesttext/src/org/eclipse/osbp/vaadin/addons/suggesttext/client/SuggestTextFieldState.java
+++ b/org.eclipse.osbp.vaadin.addons.suggesttext/src/org/eclipse/osbp/vaadin/addons/suggesttext/client/SuggestTextFieldState.java
@@ -52,4 +52,9 @@
 	 * {@link #openPopup_key}
 	 */
 	public int openPopup_modifier = ShortcutAction.ModifierKey.ALT;
+	
+	/**
+	 * Tooltip text
+	 */
+	public String disableSuggestionTooltip = "disable / enable suggestion";
 }
diff --git a/org.eclipse.osbp.vaadin.addons.suggesttext/src/org/eclipse/osbp/vaadin/addons/suggesttext/public/suggesttext/styles.css b/org.eclipse.osbp.vaadin.addons.suggesttext/src/org/eclipse/osbp/vaadin/addons/suggesttext/public/suggesttext/styles.css
index 74d032f..41450f5 100644
--- a/org.eclipse.osbp.vaadin.addons.suggesttext/src/org/eclipse/osbp/vaadin/addons/suggesttext/public/suggesttext/styles.css
+++ b/org.eclipse.osbp.vaadin.addons.suggesttext/src/org/eclipse/osbp/vaadin/addons/suggesttext/public/suggesttext/styles.css
@@ -1,14 +1,13 @@
 .o-SuggestBoxPopup {
 	background-color: white;
 	color: darkgray;
-	
 	font-style: normal;
-    font-variant: normal;
-    font-weight: 300;
-    font-stretch: normal;
-    font-size: 16px;
-    line-height: 1.55;
-    font-family: 'Open Sans', sans-serif;
+	font-variant: normal;
+	font-weight: 300;
+	font-stretch: normal;
+	font-size: 16px;
+	line-height: 1.55;
+	font-family: 'Open Sans', sans-serif;
 }
 
 .o-SuggestBoxPopup .item-selected {
@@ -16,3 +15,13 @@
 	color: white;
 }
 
+.o-XSuggestBox .enableSuggestions {
+	width: 10px;
+	height: 10px;
+	background-color: red;
+	float: right;
+}
+
+.o-XSuggestBox .enableSuggestions.selected {
+	background-color: green;
+}
\ No newline at end of file
diff --git a/pom.xml b/pom.xml
index 68fa3ae..bc226fc 100644
--- a/pom.xml
+++ b/pom.xml
@@ -24,7 +24,6 @@
 
 	<groupId>org.eclipse.osbp.vaadin.addons</groupId>
 	<artifactId>org.eclipse.osbp.vaadin.addons.aggregator</artifactId>
-	<version>0.9.0-SNAPSHOT</version>
 	<packaging>pom</packaging>
 
 	<url>${osbp.site.repository.url}</url>
@@ -42,10 +41,11 @@
 	<modules>
 		<module>org.eclipse.osbp.vaadin.addons.absolutelayout</module>
 		<module>org.eclipse.osbp.vaadin.addons.designer.overlay</module>
+		<module>org.eclipse.osbp.vaadin.addons.kanban</module>
 		<module>org.eclipse.osbp.vaadin.addons.suggesttext</module>
-<!--		<module>org.eclipse.osbp.vaadin.addons.feature</module> -->
+	<!-- NO FEATURES IN MBP REACTORS! -->
+<!-- 		<module>org.eclipse.osbp.vaadin.addons.feature</module> -->
 	</modules>
-
 	<build>
 		<pluginManagement>
 			<plugins>
