diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..4188405
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,34 @@
+
+**/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/.project b/.project
new file mode 100644
index 0000000..d44b52d
--- /dev/null
+++ b/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.osbp.fork.vaadin.addon.maskedtextfield.aggregator</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+	</natures>
+</projectDescription>
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/jenkins.build.config.xml b/jenkins.build.config.xml
new file mode 100644
index 0000000..2d73b1c
--- /dev/null
+++ b/jenkins.build.config.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+/*
+ * Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License. 
+ * Contributors:
+ *      Loetz GmbH&Co.KG - initial API and implementation 
+ */
+-->
+<!--#======================================================================= -->
+<!--# Module specific parameters for the Jenkins Job 						 -->
+<!--#======================================================================= -->
+<jenkins>
+	<jenkins.build.technologystack />
+	<settings>${user.home}/.m2/settingsMirrors.xml</settings>
+	<!-- DO NOT EDIT BELOW THIS LINE -->
+        <jenkins.build.dependencies>
+                <jenkins.build.dependency>org.eclipse.osbp.releng.maven</jenkins.build.dependency>
+        </jenkins.build.dependencies>
+</jenkins>
diff --git a/license.html b/license.html
new file mode 100644
index 0000000..637a181
--- /dev/null
+++ b/license.html
@@ -0,0 +1,300 @@
+<!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" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <title>Eclipse Public License - Version 2.0</title>
+    <style type="text/css">
+      body {
+        margin: 1.5em 3em;
+      }
+      h1{
+        font-size:1.5em;
+      }
+      h2{
+        font-size:1em;
+        margin-bottom:0.5em;
+        margin-top:1em;
+      }
+      p {
+        margin-top:  0.5em;
+        margin-bottom: 0.5em;
+      }
+      ul, ol{
+        list-style-type:none;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>Eclipse Public License - v 2.0</h1>
+    <p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+      PUBLIC LICENSE (&ldquo;AGREEMENT&rdquo;). ANY USE, REPRODUCTION OR DISTRIBUTION
+      OF THE PROGRAM CONSTITUTES RECIPIENT&#039;S ACCEPTANCE OF THIS AGREEMENT.
+    </p>
+    <h2 id="definitions">1. DEFINITIONS</h2>
+    <p>&ldquo;Contribution&rdquo; means:</p>
+    <ul>
+      <li>a) in the case of the initial Contributor, the initial content
+        Distributed under this Agreement, and
+      </li>
+      <li>
+        b) in the case of each subsequent Contributor:
+        <ul>
+          <li>i) changes to the Program, and</li>
+          <li>ii) additions to the Program;</li>
+        </ul>
+        where such changes and/or additions to the Program originate from
+        and are Distributed by that particular Contributor. A Contribution
+        &ldquo;originates&rdquo; from a Contributor if it was added to the Program by such
+        Contributor itself or anyone acting on such Contributor&#039;s behalf.
+        Contributions do not include changes or additions to the Program that
+        are not Modified Works.
+      </li>
+    </ul>
+    <p>&ldquo;Contributor&rdquo; means any person or entity that Distributes the Program.</p>
+    <p>&ldquo;Licensed Patents&rdquo; 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>&ldquo;Program&rdquo; means the Contributions Distributed in accordance with this
+      Agreement.
+    </p>
+    <p>&ldquo;Recipient&rdquo; means anyone who receives the Program under this Agreement
+      or any Secondary License (as applicable), including Contributors.
+    </p>
+    <p>&ldquo;Derivative Works&rdquo; shall mean any work, whether in Source Code or other
+      form, that is based on (or derived from) the Program and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship.
+    </p>
+    <p>&ldquo;Modified Works&rdquo; shall mean any work in Source Code or other form that
+      results from an addition to, deletion from, or modification of the
+      contents of the Program, including, for purposes of clarity any new file
+      in Source Code form that contains any contents of the Program. Modified
+      Works shall not include works that contain only declarations, interfaces,
+      types, classes, structures, or files of the Program solely in each case
+      in order to link to, bind by name, or subclass the Program or Modified
+      Works thereof.
+    </p>
+    <p>&ldquo;Distribute&rdquo; means the acts of a) distributing or b) making available
+      in any manner that enables the transfer of a copy.
+    </p>
+    <p>&ldquo;Source Code&rdquo; means the form of a Program preferred for making
+      modifications, including but not limited to software source code,
+      documentation source, and configuration files.
+    </p>
+    <p>&ldquo;Secondary License&rdquo; means either the GNU General Public License,
+      Version 2.0, or any later versions of that license, including any
+      exceptions or additional permissions as identified by the initial
+      Contributor.
+    </p>
+    <h2 id="grant-of-rights">2. GRANT OF RIGHTS</h2>
+    <ul>
+      <li>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.
+      </li>
+      <li>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 or other 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.
+      </li>
+      <li>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&#039;s
+        responsibility to acquire that license before distributing the Program.
+      </li>
+      <li>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.
+      </li>
+      <li>e) Notwithstanding the terms of any Secondary License, no Contributor
+        makes additional grants to any Recipient (other than those set forth
+        in this Agreement) as a result of such Recipient&#039;s receipt of the
+        Program under the terms of a Secondary License (if permitted under
+        the terms of Section 3).
+      </li>
+    </ul>
+    <h2 id="requirements">3. REQUIREMENTS</h2>
+    <p>3.1 If a Contributor Distributes the Program in any form, then:</p>
+    <ul>
+      <li>a) the Program must also be made available as Source Code, in
+        accordance with section 3.2, and the Contributor must accompany
+        the Program with a statement that the Source Code for the Program
+        is available under this Agreement, and informs Recipients how to
+        obtain it in a reasonable manner on or through a medium customarily
+        used for software exchange; and
+      </li>
+      <li>
+        b) the Contributor may Distribute the Program under a license
+        different than this Agreement, provided that such license:
+        <ul>
+          <li>i) effectively disclaims on behalf of all other 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;
+          </li>
+          <li>ii) effectively excludes on behalf of all other Contributors all
+            liability for damages, including direct, indirect, special, incidental
+            and consequential damages, such as lost profits;
+          </li>
+          <li>iii) does not attempt to limit or alter the recipients&#039; rights in the
+            Source Code under section 3.2; and
+          </li>
+          <li>iv) requires any subsequent distribution of the Program by any party
+            to be under a license that satisfies the requirements of this section 3.
+          </li>
+        </ul>
+      </li>
+    </ul>
+    <p>3.2 When the Program is Distributed as Source Code:</p>
+    <ul>
+      <li>a) it must be made available under this Agreement, or if the Program (i)
+        is combined with other material in a separate file or files made available
+        under a Secondary License, and (ii) the initial Contributor attached to
+        the Source Code the notice described in Exhibit A of this Agreement,
+        then the Program may be made available under the terms of such
+        Secondary Licenses, and
+      </li>
+      <li>b) a copy of this Agreement must be included with each copy of the Program.</li>
+    </ul>
+    <p>3.3 Contributors may not remove or alter any copyright, patent, trademark,
+      attribution notices, disclaimers of warranty, or limitations of liability
+      (&lsquo;notices&rsquo;) contained within the Program from any copy of the Program which
+      they Distribute, provided that Contributors may add their own appropriate
+      notices.
+    </p>
+    <h2 id="commercial-distribution">4. COMMERCIAL DISTRIBUTION</h2>
+    <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 (&ldquo;Commercial Contributor&rdquo;)
+      hereby agrees to defend and indemnify every other Contributor
+      (&ldquo;Indemnified Contributor&rdquo;) against any losses, damages and costs
+      (collectively &ldquo;Losses&rdquo;) 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&#039;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>
+    <h2 id="warranty">5. NO WARRANTY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN &ldquo;AS IS&rdquo; 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>
+    <h2 id="disclaimer">6. DISCLAIMER OF LIABILITY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, 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>
+    <h2 id="general">7. GENERAL</h2>
+    <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&#039;s patent(s), then such Recipient&#039;s rights granted
+      under Section 2(b) shall terminate as of the date such litigation is filed.
+    </p>
+    <p>All Recipient&#039;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&#039;s rights under this Agreement
+      terminate, Recipient agrees to cease use and distribution of the Program
+      as soon as reasonably practicable. However, Recipient&#039;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.
+    </p>
+    <p>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. Nothing in this Agreement is intended
+      to be enforceable by any entity that is not a Contributor or Recipient.
+      No third-party beneficiary rights are created under this Agreement.
+    </p>
+    <h2 id="exhibit-a">Exhibit A &ndash; Form of Secondary Licenses Notice</h2>
+    <p>&ldquo;This Source Code may also be made available under the following 
+    	Secondary Licenses when the conditions for such availability set forth 
+    	in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+    	version(s), and exceptions or additional permissions here}.&rdquo;
+    </p>
+    <blockquote>
+      <p>Simply including a copy of this Agreement, including this Exhibit A
+        is not sufficient to license the Source Code under Secondary Licenses.
+      </p>
+      <p>If it is not possible or desirable to put the notice in a particular file,
+        then You may include the notice in a location (such as a LICENSE file in a
+        relevant directory) where a recipient would be likely to look for
+        such a notice.
+      </p>
+      <p>You may add additional accurate notices of copyright ownership.</p>
+    </blockquote>
+  </body>
+</html>
\ No newline at end of file
diff --git a/license.txt b/license.txt
new file mode 100644
index 0000000..e23ece2
--- /dev/null
+++ b/license.txt
@@ -0,0 +1,277 @@
+Eclipse Public License - v 2.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 content
+     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 changes or additions to the Program that
+  are not Modified Works.
+
+"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
+or any Secondary License (as applicable), including Contributors.
+
+"Derivative Works" shall mean any work, whether in Source Code or other
+form, that is based on (or derived from) the Program and for which the
+editorial revisions, annotations, elaborations, or other modifications
+represent, as a whole, an original work of authorship.
+
+"Modified Works" shall mean any work in Source Code or other form that
+results from an addition to, deletion from, or modification of the
+contents of the Program, including, for purposes of clarity any new file
+in Source Code form that contains any contents of the Program. Modified
+Works shall not include works that contain only declarations,
+interfaces, types, classes, structures, or files of the Program solely
+in each case in order to link to, bind by name, or subclass the Program
+or Modified Works thereof.
+
+"Distribute" means the acts of a) distributing or b) making available
+in any manner that enables the transfer of a copy.
+
+"Source Code" means the form of a Program preferred for making
+modifications, including but not limited to software source code,
+documentation source, and configuration files.
+
+"Secondary License" means either the GNU General Public License,
+Version 2.0, or any later versions of that license, including any
+exceptions or additional permissions as identified by the initial
+Contributor.
+
+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.
+
+  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 or other 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.
+
+  e) Notwithstanding the terms of any Secondary License, no
+  Contributor makes additional grants to any Recipient (other than
+  those set forth in this Agreement) as a result of such Recipient's
+  receipt of the Program under the terms of a Secondary License
+  (if permitted under the terms of Section 3).
+
+3. REQUIREMENTS
+
+3.1 If a Contributor Distributes the Program in any form, then:
+
+  a) the Program must also be made available as Source Code, in
+  accordance with section 3.2, and the Contributor must accompany
+  the Program with a statement that the Source Code for the Program
+  is available under this Agreement, and informs Recipients how to
+  obtain it in a reasonable manner on or through a medium customarily
+  used for software exchange; and
+
+  b) the Contributor may Distribute the Program under a license
+  different than this Agreement, provided that such license:
+     i) effectively disclaims on behalf of all other 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 other Contributors all
+     liability for damages, including direct, indirect, special,
+     incidental and consequential damages, such as lost profits;
+
+     iii) does not attempt to limit or alter the recipients' rights
+     in the Source Code under section 3.2; and
+
+     iv) requires any subsequent distribution of the Program by any
+     party to be under a license that satisfies the requirements
+     of this section 3.
+
+3.2 When the Program is Distributed as Source Code:
+
+  a) it must be made available under this Agreement, or if the
+  Program (i) is combined with other material in a separate file or
+  files made available under a Secondary License, and (ii) the initial
+  Contributor attached to the Source Code the notice described in
+  Exhibit A of this Agreement, then the Program may be made available
+  under the terms of such Secondary Licenses, and
+
+  b) a copy of this Agreement must be included with each copy of
+  the Program.
+
+3.3 Contributors may not remove or alter any copyright, patent,
+trademark, attribution notices, disclaimers of warranty, or limitations
+of liability ("notices") contained within the Program from any copy of
+the Program which they Distribute, provided that Contributors may add
+their own appropriate notices.
+
+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, AND TO THE EXTENT
+PERMITTED BY APPLICABLE LAW, 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, AND TO THE EXTENT
+PERMITTED BY APPLICABLE LAW, 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. Nothing in this Agreement is intended
+to be enforceable by any entity that is not a Contributor or Recipient.
+No third-party beneficiary rights are created under this Agreement.
+
+Exhibit A - Form of Secondary Licenses Notice
+
+"This Source Code may also be made available under the following 
+Secondary Licenses when the conditions for such availability set forth 
+in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+version(s), and exceptions or additional permissions here}."
+
+  Simply including a copy of this Agreement, including this Exhibit A
+  is not sufficient to license the Source Code under Secondary Licenses.
+
+  If it is not possible or desirable to put the notice in a particular
+  file, then You may include the notice in a location (such as a LICENSE
+  file in a relevant directory) where a recipient would be likely to
+  look for such a notice.
+
+  You may add additional accurate notices of copyright ownership.
\ No newline at end of file
diff --git a/notice.html b/notice.html
new file mode 100644
index 0000000..81fca9d
--- /dev/null
+++ b/notice.html
@@ -0,0 +1,189 @@
+<?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>November 22, 2014</p>
+
+	<h3>Usage Of Content</h3>
+
+	<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION,
+		INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+		(COLLECTIVELY &quot;CONTENT&quot;). 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 2.0 (&quot;EPL&quot;). A copy of the
+		EPL is provided with this Content and is also available at <a
+			href="http://www.eclipse.org/legal/epl-2.0">http://www.eclipse.org/legal/epl-2.0</a>.
+		For purposes of the EPL, &quot;Program&quot; 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 (&quot;Repository&quot;) in software
+		modules (&quot;Modules&quot;) and made available as downloadable
+		archives (&quot;Downloads&quot;).</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 (&quot;Plug-ins&quot;), plug-in
+			fragments (&quot;Fragments&quot;), and features
+			(&quot;Features&quot;).</li>
+		<li>Each Plug-in or Fragment may be packaged as a sub-directory
+			or JAR (Java&trade; ARchive) in a directory named
+			&quot;plugins&quot;.</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 &quot;features&quot;. Within a
+			Feature, files named &quot;feature.xml&quot; 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 (&quot;Included
+			Features&quot;). Within a Feature, files named
+			&quot;feature.xml&quot; 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 &quot;about.html&quot;
+		(&quot;Abouts&quot;). The terms and conditions governing Features and
+		Included Features should be contained in files named
+		&quot;license.html&quot; (&quot;Feature Licenses&quot;). 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 &quot;src&quot; 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 (&quot;Feature Update License&quot;) 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
+		&quot;license&quot; property of files named
+		&quot;feature.properties&quot; 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 Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>)
+		</li>
+		<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>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 (&quot;Provisioning Technology&quot;) for the purpose of
+		allowing users to install software, documentation, information and/or
+		other materials (collectively &quot;Installable Software&quot;). 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>
+		(&quot;Specification&quot;).
+	</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 (&quot;Provisioning
+			Process&quot;) in which a user may execute the Provisioning
+			Technology on a machine (&quot;Target Machine&quot;) 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 (&quot;Installable Software Agreement&quot;) 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>
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.classpath b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.classpath
new file mode 100644
index 0000000..99752e2
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.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.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="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.dependencies.bundle.vaadin.addon.maskedtextfield&amp;ivyXmlPath=ivy.xml&amp;confs=default&amp;ivySettingsPath=%24%7Bworkspace_loc%3Aorg.eclipse.osbp.dependencies.bundle.vaadin.addon.maskedtextfield%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.dependencies.bundle.vaadin.addon.maskedtextfield&amp;ivyXmlPath=ivy.xml&amp;confs=widgetset-compile&amp;ivySettingsPath=%24%7Bworkspace_loc%3Aorg.eclipse.osbp.dependencies.bundle.vaadin.addon.maskedtextfield%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.dependencies.bundle.vaadin.addon.maskedtextfield&amp;ivyXmlPath=ivy.xml&amp;confs=nodeploy&amp;ivySettingsPath=%24%7Bworkspace_loc%3Aorg.eclipse.osbp.dependencies.bundle.vaadin.addon.maskedtextfield%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="output" path="target/classes"/>
+</classpath>
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.gitignore b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.gitignore
new file mode 100644
index 0000000..80d0ff5
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.gitignore
@@ -0,0 +1,5 @@
+/bin/
+/target/
+/build/
+**/VAADIN/widgetsets/
+**/VAADIN/gwt-unitCache/
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.project b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.project
new file mode 100644
index 0000000..cb6021c
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.project
@@ -0,0 +1,61 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.osbp.dependencies.bundle.vaadin.addon.maskedtextfield</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>com.vaadin.integration.eclipse.addonStylesBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.babel.editor.rbeBuilder</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>
+		<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.fork.vaadin.addon.maskedtextfield/.settings/.jsdtscope b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.settings/.jsdtscope
new file mode 100644
index 0000000..92e666d
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.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.fork.vaadin.addon.maskedtextfield/.settings/com.vaadin.integration.eclipse.prefs b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.settings/com.vaadin.integration.eclipse.prefs
new file mode 100644
index 0000000..28988bd
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.settings/com.vaadin.integration.eclipse.prefs
@@ -0,0 +1,8 @@
+com.vaadin.integration.eclipse.notifyOfVaadinUpdates=false
+com.vaadin.integration.eclipse.useLatestNightly=false
+com.vaadin.integration.eclipse.widgetsetBuildsSuspended=true
+com.vaadin.integration.eclipse.widgetsetCompilationEta=59266
+com.vaadin.integration.eclipse.widgetsetDirty=true
+com.vaadin.integration.eclipse.widgetsetStyle=OBF
+com.vaadin.integration.eclipse.widgetsetVerbose=true
+eclipse.preferences.version=1
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.settings/org.eclipse.bpmn2.modeler.core.prefs b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.settings/org.eclipse.bpmn2.modeler.core.prefs
new file mode 100644
index 0000000..4bffcea
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.settings/org.eclipse.bpmn2.modeler.core.prefs
@@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+target.runtime=org.jboss.runtime.jbpm5
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.settings/org.eclipse.core.resources.prefs b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.settings/org.eclipse.core.resources.prefs
new file mode 100644
index 0000000..7a53139
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.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.fork.vaadin.addon.maskedtextfield/.settings/org.eclipse.jdt.core.prefs b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..6e80039
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,8 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.compliance=1.8
+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.fork.vaadin.addon.maskedtextfield/.settings/org.eclipse.m2e.core.prefs b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.settings/org.eclipse.m2e.core.prefs
new file mode 100644
index 0000000..f897a7f
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.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.fork.vaadin.addon.maskedtextfield/.settings/org.eclipse.pde.core.prefs b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.settings/org.eclipse.pde.core.prefs
new file mode 100644
index 0000000..d4322fa
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.settings/org.eclipse.pde.core.prefs
@@ -0,0 +1,4 @@
+BUNDLE_ROOT_PATH=target/classes
+eclipse.preferences.version=1
+pluginProject.extensions=false
+resolve.requirebundle=false
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.settings/org.eclipse.wst.common.component b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.settings/org.eclipse.wst.common.component
new file mode 100644
index 0000000..c54bc4b
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.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.fork.vaadin.addon.maskedtextfield">
+        <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.eclipse.osbp.fork.vaadin.addon.maskedtextfield"/>
+        <property name="java-output-path" value="/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/build/classes"/>
+    </wb-module>
+</project-modules>
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.settings/org.eclipse.wst.common.project.facet.core.xml b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.settings/org.eclipse.wst.common.project.facet.core.xml
new file mode 100644
index 0000000..e6e0802
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.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="java"/>
+  <fixed facet="com.vaadin.integration.eclipse.core"/>
+  <fixed facet="jst.web"/>
+  <fixed facet="wst.jsdt.web"/>
+  <installed facet="java" version="1.8"/>
+  <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"/>
+</faceted-project>
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.settings/org.eclipse.wst.jsdt.ui.superType.container b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.settings/org.eclipse.wst.jsdt.ui.superType.container
new file mode 100644
index 0000000..3bd5d0a
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.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.fork.vaadin.addon.maskedtextfield/.settings/org.eclipse.wst.jsdt.ui.superType.name b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.settings/org.eclipse.wst.jsdt.ui.superType.name
new file mode 100644
index 0000000..05bd71b
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.settings/org.eclipse.wst.jsdt.ui.superType.name
@@ -0,0 +1 @@
+Window
\ No newline at end of file
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.settings/org.eclipse.xtend.core.Xtend.prefs b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.settings/org.eclipse.xtend.core.Xtend.prefs
new file mode 100644
index 0000000..0933f8c
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/.settings/org.eclipse.xtend.core.Xtend.prefs
@@ -0,0 +1,10 @@
+//outlet.DEFAULT_OUTPUT.sourceFolder.src/test/java.directory=src/test/generated-sources/xtend
+eclipse.preferences.version=1
+is_project_specific=true
+outlet.DEFAULT_OUTPUT.hideLocalSyntheticVariables=true
+outlet.DEFAULT_OUTPUT.installDslAsPrimarySource=false
+outlet.DEFAULT_OUTPUT.sourceFolder.emf-gen.directory=xtend-gen
+outlet.DEFAULT_OUTPUT.sourceFolder.src-gen.directory=xtend-gen
+outlet.DEFAULT_OUTPUT.sourceFolder.src.directory=xtend-gen
+outlet.DEFAULT_OUTPUT.sourceFolder.xtend-gen.directory=xtend-gen
+outlet.DEFAULT_OUTPUT.userOutputPerSourceFolder=true
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/SuperDevMode code server for org.eclipse.osbp.dependencies.bundle.vaadin.addon.maskedtextfield.launch b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/SuperDevMode code server for org.eclipse.osbp.dependencies.bundle.vaadin.addon.maskedtextfield.launch
new file mode 100644
index 0000000..eb11759
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/SuperDevMode code server for org.eclipse.osbp.dependencies.bundle.vaadin.addon.maskedtextfield.launch
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<launchConfiguration type="org.eclipse.jdt.launching.localJavaApplication">
+<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
+<listEntry value="/org.eclipse.osbp.dependencies.bundle.vaadin.addon.maskedtextfield"/>
+</listAttribute>
+<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">
+<listEntry value="4"/>
+</listAttribute>
+<booleanAttribute key="org.eclipse.jdt.launching.ATTR_USE_START_ON_FIRST_THREAD" value="true"/>
+<listAttribute key="org.eclipse.jdt.launching.CLASSPATH">
+<listEntry value="&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot; standalone=&quot;no&quot;?&gt;&#10;&lt;runtimeClasspathEntry id=&quot;org.eclipse.jdt.launching.classpathentry.defaultClasspath&quot;&gt;&#10;&lt;memento exportedEntriesOnly=&quot;false&quot; project=&quot;org.eclipse.osbp.dependencies.bundle.vaadin.addon.maskedtextfield&quot;/&gt;&#10;&lt;/runtimeClasspathEntry&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.dependencies.bundle.vaadin.addon.maskedtextfield/src&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.dependencies.bundle.vaadin.addon.maskedtextfield/sample&quot; path=&quot;3&quot; type=&quot;2&quot;/&gt;&#10;"/>
+</listAttribute>
+<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.vaadin.addons.maskedtextfield.MaskedTextFieldWidgetset"/>
+<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="org.eclipse.osbp.dependencies.bundle.vaadin.addon.maskedtextfield"/>
+<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/Work/dev/osbp-foodmart/git/org.eclipse.osbp.fork.vaadin.addons/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield"/>
+</launchConfiguration>
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/WebContent/META-INF/MANIFEST.MF b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/WebContent/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..254272e
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/WebContent/META-INF/MANIFEST.MF
@@ -0,0 +1,3 @@
+Manifest-Version: 1.0
+Class-Path: 
+
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/about.html b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/about.html
new file mode 100644
index 0000000..1be778d
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/about.html
@@ -0,0 +1,47 @@
+<!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>About</title>
+</head>
+<body lang="EN-US">
+<h2>About This Content</h2>
+ 
+<p>November 1, 2017</p>		
+<h3>License</h3>
+
+<p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
+indicated below, the Content is provided to you under the terms and conditions of the
+Eclipse Public License Version 2.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="http://www.eclipse.org/legal/epl-v20.html">http://www.eclipse.org/legal/epl-v20.html</a>.
+For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
+
+<p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
+being redistributed by another party (&quot;Redistributor&quot;) and different terms and conditions may
+apply to your use of any object code in the Content.  Check the Redistributor's license that was 
+provided with the Content.  If no such license exists, contact the Redistributor.  Unless otherwise
+indicated below, the terms and conditions of the EPL still apply to any source code in the Content
+and such source code may be obtained at <a href="http://www.eclipse.org/">http://www.eclipse.org</a>.</p>
+
+		
+		<h3>Third Party Content</h3>
+		<p>The Content includes items that have been sourced from third parties as set out below. If you 
+		did not receive this Content directly from the Eclipse Foundation, the following is provided 
+		for informational purposes only, and you should look to the Redistributor's license for 
+		terms and conditions of use.</p>
+		<p>
+		<strong>Vaadin Addon maskedtextfield</strong> <br/><br/>
+		Project site: <a href="https://vaadin.com/directory/component/maskedtextfield">https://vaadin.com/directory/component/maskedtextfield</a><br/><br/> 
+		An extension to the <a href="https://vaadin.com/directory/component/maskedtextfield">Vaadin</a> TextField to allow the developer to specify a mask. 
+		It's a pure Vaadin/GWT implementation.<br/>
+		The original code can be found on <a href="https://github.com/EduFrazao/vaadin-masked-textfield">Github</a>.<br/>
+		It is published under the <a href="about_files/apl-20.txt">Apache License V2.0</a><br/><br/>
+		OSBP forked the code and adapted it to fit into the OSBP project.<br/>
+		
+		<br/><br/>
+		</p>
+
+
+</body>
+</html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/about.ini b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/about.ini
new file mode 100644
index 0000000..7df671f
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/about.ini
@@ -0,0 +1,17 @@
+# about.ini
+# contains information about a feature
+# java.io.Properties file (ISO 8859-1 with "\" escapes)
+# "%key" are externalized strings defined in about.properties
+# This file does not need to be translated.
+
+# Property "aboutText" contains blurb for "About" dialog (translated)
+aboutText=%featureText
+
+# Property "featureImage" contains path to feature image (32x32)
+featureImage=
+
+# Property "appName" contains name of the application (translated)
+appName=%featureName
+
+# Property "welcomePage" contains path to welcome page (special XML-based format)
+welcomePage=
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/about.mappings b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/about.mappings
new file mode 100644
index 0000000..4511a0a
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/about.mappings
@@ -0,0 +1,6 @@
+# about.mappings
+# contains fill-ins for about.properties
+# java.io.Properties file (ISO 8859-1 with "\" escapes)
+# This file does not need to be translated.
+
+0=qualifier
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/about.properties b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/about.properties
new file mode 100644
index 0000000..572102c
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/about.properties
@@ -0,0 +1,29 @@
+#
+# Copyright (c) 2011,2018 Loetz GmbH&Co.KG
+#
+# This program and the accompanying materials are made available under the 
+# terms of the Eclipse Public License 2.0 which is available at
+# http://www.eclipse.org/legal/epl-2.0.
+#
+# SPDX-License-Identifier: EPL-2.0 
+#
+# Contributors:
+#    Loetz GmbH&Co.KG - initial API and implementation
+#
+
+# NLS_MESSAGEFORMAT_VAR
+
+featureName=org.eclipse.osbp.fork.vaadin.addon.maskedtextfield
+
+################ blurb property ####################################
+featureText=\
+Copyright (c) 2011,2018, Loetz GmbH&Co.KG \n\
+This program and the accompanying materials are made available under the \n\
+terms of the Eclipse Public License 2.0 which is available at\n\
+http://www.eclipse.org/legal/epl-2.0.\n\
+\n\
+SPDX-License-Identifier: EPL-2.0 \n\
+\n\
+Contributors:\n\
+    Loetz GmbH&Co.KG - fork and adjustments\n
+################ end of blurb property ####################################
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/about_files/apl-20.txt b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/about_files/apl-20.txt
new file mode 100644
index 0000000..7a4a3ea
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/about_files/apl-20.txt
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) 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. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
\ No newline at end of file
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/epl-v20.html b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/epl-v20.html
new file mode 100644
index 0000000..637a181
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/epl-v20.html
@@ -0,0 +1,300 @@
+<!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" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <title>Eclipse Public License - Version 2.0</title>
+    <style type="text/css">
+      body {
+        margin: 1.5em 3em;
+      }
+      h1{
+        font-size:1.5em;
+      }
+      h2{
+        font-size:1em;
+        margin-bottom:0.5em;
+        margin-top:1em;
+      }
+      p {
+        margin-top:  0.5em;
+        margin-bottom: 0.5em;
+      }
+      ul, ol{
+        list-style-type:none;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>Eclipse Public License - v 2.0</h1>
+    <p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+      PUBLIC LICENSE (&ldquo;AGREEMENT&rdquo;). ANY USE, REPRODUCTION OR DISTRIBUTION
+      OF THE PROGRAM CONSTITUTES RECIPIENT&#039;S ACCEPTANCE OF THIS AGREEMENT.
+    </p>
+    <h2 id="definitions">1. DEFINITIONS</h2>
+    <p>&ldquo;Contribution&rdquo; means:</p>
+    <ul>
+      <li>a) in the case of the initial Contributor, the initial content
+        Distributed under this Agreement, and
+      </li>
+      <li>
+        b) in the case of each subsequent Contributor:
+        <ul>
+          <li>i) changes to the Program, and</li>
+          <li>ii) additions to the Program;</li>
+        </ul>
+        where such changes and/or additions to the Program originate from
+        and are Distributed by that particular Contributor. A Contribution
+        &ldquo;originates&rdquo; from a Contributor if it was added to the Program by such
+        Contributor itself or anyone acting on such Contributor&#039;s behalf.
+        Contributions do not include changes or additions to the Program that
+        are not Modified Works.
+      </li>
+    </ul>
+    <p>&ldquo;Contributor&rdquo; means any person or entity that Distributes the Program.</p>
+    <p>&ldquo;Licensed Patents&rdquo; 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>&ldquo;Program&rdquo; means the Contributions Distributed in accordance with this
+      Agreement.
+    </p>
+    <p>&ldquo;Recipient&rdquo; means anyone who receives the Program under this Agreement
+      or any Secondary License (as applicable), including Contributors.
+    </p>
+    <p>&ldquo;Derivative Works&rdquo; shall mean any work, whether in Source Code or other
+      form, that is based on (or derived from) the Program and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship.
+    </p>
+    <p>&ldquo;Modified Works&rdquo; shall mean any work in Source Code or other form that
+      results from an addition to, deletion from, or modification of the
+      contents of the Program, including, for purposes of clarity any new file
+      in Source Code form that contains any contents of the Program. Modified
+      Works shall not include works that contain only declarations, interfaces,
+      types, classes, structures, or files of the Program solely in each case
+      in order to link to, bind by name, or subclass the Program or Modified
+      Works thereof.
+    </p>
+    <p>&ldquo;Distribute&rdquo; means the acts of a) distributing or b) making available
+      in any manner that enables the transfer of a copy.
+    </p>
+    <p>&ldquo;Source Code&rdquo; means the form of a Program preferred for making
+      modifications, including but not limited to software source code,
+      documentation source, and configuration files.
+    </p>
+    <p>&ldquo;Secondary License&rdquo; means either the GNU General Public License,
+      Version 2.0, or any later versions of that license, including any
+      exceptions or additional permissions as identified by the initial
+      Contributor.
+    </p>
+    <h2 id="grant-of-rights">2. GRANT OF RIGHTS</h2>
+    <ul>
+      <li>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.
+      </li>
+      <li>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 or other 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.
+      </li>
+      <li>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&#039;s
+        responsibility to acquire that license before distributing the Program.
+      </li>
+      <li>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.
+      </li>
+      <li>e) Notwithstanding the terms of any Secondary License, no Contributor
+        makes additional grants to any Recipient (other than those set forth
+        in this Agreement) as a result of such Recipient&#039;s receipt of the
+        Program under the terms of a Secondary License (if permitted under
+        the terms of Section 3).
+      </li>
+    </ul>
+    <h2 id="requirements">3. REQUIREMENTS</h2>
+    <p>3.1 If a Contributor Distributes the Program in any form, then:</p>
+    <ul>
+      <li>a) the Program must also be made available as Source Code, in
+        accordance with section 3.2, and the Contributor must accompany
+        the Program with a statement that the Source Code for the Program
+        is available under this Agreement, and informs Recipients how to
+        obtain it in a reasonable manner on or through a medium customarily
+        used for software exchange; and
+      </li>
+      <li>
+        b) the Contributor may Distribute the Program under a license
+        different than this Agreement, provided that such license:
+        <ul>
+          <li>i) effectively disclaims on behalf of all other 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;
+          </li>
+          <li>ii) effectively excludes on behalf of all other Contributors all
+            liability for damages, including direct, indirect, special, incidental
+            and consequential damages, such as lost profits;
+          </li>
+          <li>iii) does not attempt to limit or alter the recipients&#039; rights in the
+            Source Code under section 3.2; and
+          </li>
+          <li>iv) requires any subsequent distribution of the Program by any party
+            to be under a license that satisfies the requirements of this section 3.
+          </li>
+        </ul>
+      </li>
+    </ul>
+    <p>3.2 When the Program is Distributed as Source Code:</p>
+    <ul>
+      <li>a) it must be made available under this Agreement, or if the Program (i)
+        is combined with other material in a separate file or files made available
+        under a Secondary License, and (ii) the initial Contributor attached to
+        the Source Code the notice described in Exhibit A of this Agreement,
+        then the Program may be made available under the terms of such
+        Secondary Licenses, and
+      </li>
+      <li>b) a copy of this Agreement must be included with each copy of the Program.</li>
+    </ul>
+    <p>3.3 Contributors may not remove or alter any copyright, patent, trademark,
+      attribution notices, disclaimers of warranty, or limitations of liability
+      (&lsquo;notices&rsquo;) contained within the Program from any copy of the Program which
+      they Distribute, provided that Contributors may add their own appropriate
+      notices.
+    </p>
+    <h2 id="commercial-distribution">4. COMMERCIAL DISTRIBUTION</h2>
+    <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 (&ldquo;Commercial Contributor&rdquo;)
+      hereby agrees to defend and indemnify every other Contributor
+      (&ldquo;Indemnified Contributor&rdquo;) against any losses, damages and costs
+      (collectively &ldquo;Losses&rdquo;) 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&#039;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>
+    <h2 id="warranty">5. NO WARRANTY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN &ldquo;AS IS&rdquo; 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>
+    <h2 id="disclaimer">6. DISCLAIMER OF LIABILITY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, 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>
+    <h2 id="general">7. GENERAL</h2>
+    <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&#039;s patent(s), then such Recipient&#039;s rights granted
+      under Section 2(b) shall terminate as of the date such litigation is filed.
+    </p>
+    <p>All Recipient&#039;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&#039;s rights under this Agreement
+      terminate, Recipient agrees to cease use and distribution of the Program
+      as soon as reasonably practicable. However, Recipient&#039;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.
+    </p>
+    <p>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. Nothing in this Agreement is intended
+      to be enforceable by any entity that is not a Contributor or Recipient.
+      No third-party beneficiary rights are created under this Agreement.
+    </p>
+    <h2 id="exhibit-a">Exhibit A &ndash; Form of Secondary Licenses Notice</h2>
+    <p>&ldquo;This Source Code may also be made available under the following 
+    	Secondary Licenses when the conditions for such availability set forth 
+    	in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+    	version(s), and exceptions or additional permissions here}.&rdquo;
+    </p>
+    <blockquote>
+      <p>Simply including a copy of this Agreement, including this Exhibit A
+        is not sufficient to license the Source Code under Secondary Licenses.
+      </p>
+      <p>If it is not possible or desirable to put the notice in a particular file,
+        then You may include the notice in a location (such as a LICENSE file in a
+        relevant directory) where a recipient would be likely to look for
+        such a notice.
+      </p>
+      <p>You may add additional accurate notices of copyright ownership.</p>
+    </blockquote>
+  </body>
+</html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/ivy.xml b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/ivy.xml
new file mode 100644
index 0000000..0c4afb5
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/ivy.xml
@@ -0,0 +1,44 @@
+<?xml version="1.0"?>
+<!DOCTYPE ivy-module [
+	<!ENTITY vaadin.version "7.5.7">
+]>
+<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" />
+
+		<!-- 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" />
+	</dependencies>
+</ivy-module>
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/ivysettings.xml b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/ivysettings.xml
new file mode 100644
index 0000000..9c0f653
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/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.fork.vaadin.addon.maskedtextfield/license.html b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/license.html
new file mode 100644
index 0000000..637a181
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/license.html
@@ -0,0 +1,300 @@
+<!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" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <title>Eclipse Public License - Version 2.0</title>
+    <style type="text/css">
+      body {
+        margin: 1.5em 3em;
+      }
+      h1{
+        font-size:1.5em;
+      }
+      h2{
+        font-size:1em;
+        margin-bottom:0.5em;
+        margin-top:1em;
+      }
+      p {
+        margin-top:  0.5em;
+        margin-bottom: 0.5em;
+      }
+      ul, ol{
+        list-style-type:none;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>Eclipse Public License - v 2.0</h1>
+    <p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+      PUBLIC LICENSE (&ldquo;AGREEMENT&rdquo;). ANY USE, REPRODUCTION OR DISTRIBUTION
+      OF THE PROGRAM CONSTITUTES RECIPIENT&#039;S ACCEPTANCE OF THIS AGREEMENT.
+    </p>
+    <h2 id="definitions">1. DEFINITIONS</h2>
+    <p>&ldquo;Contribution&rdquo; means:</p>
+    <ul>
+      <li>a) in the case of the initial Contributor, the initial content
+        Distributed under this Agreement, and
+      </li>
+      <li>
+        b) in the case of each subsequent Contributor:
+        <ul>
+          <li>i) changes to the Program, and</li>
+          <li>ii) additions to the Program;</li>
+        </ul>
+        where such changes and/or additions to the Program originate from
+        and are Distributed by that particular Contributor. A Contribution
+        &ldquo;originates&rdquo; from a Contributor if it was added to the Program by such
+        Contributor itself or anyone acting on such Contributor&#039;s behalf.
+        Contributions do not include changes or additions to the Program that
+        are not Modified Works.
+      </li>
+    </ul>
+    <p>&ldquo;Contributor&rdquo; means any person or entity that Distributes the Program.</p>
+    <p>&ldquo;Licensed Patents&rdquo; 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>&ldquo;Program&rdquo; means the Contributions Distributed in accordance with this
+      Agreement.
+    </p>
+    <p>&ldquo;Recipient&rdquo; means anyone who receives the Program under this Agreement
+      or any Secondary License (as applicable), including Contributors.
+    </p>
+    <p>&ldquo;Derivative Works&rdquo; shall mean any work, whether in Source Code or other
+      form, that is based on (or derived from) the Program and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship.
+    </p>
+    <p>&ldquo;Modified Works&rdquo; shall mean any work in Source Code or other form that
+      results from an addition to, deletion from, or modification of the
+      contents of the Program, including, for purposes of clarity any new file
+      in Source Code form that contains any contents of the Program. Modified
+      Works shall not include works that contain only declarations, interfaces,
+      types, classes, structures, or files of the Program solely in each case
+      in order to link to, bind by name, or subclass the Program or Modified
+      Works thereof.
+    </p>
+    <p>&ldquo;Distribute&rdquo; means the acts of a) distributing or b) making available
+      in any manner that enables the transfer of a copy.
+    </p>
+    <p>&ldquo;Source Code&rdquo; means the form of a Program preferred for making
+      modifications, including but not limited to software source code,
+      documentation source, and configuration files.
+    </p>
+    <p>&ldquo;Secondary License&rdquo; means either the GNU General Public License,
+      Version 2.0, or any later versions of that license, including any
+      exceptions or additional permissions as identified by the initial
+      Contributor.
+    </p>
+    <h2 id="grant-of-rights">2. GRANT OF RIGHTS</h2>
+    <ul>
+      <li>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.
+      </li>
+      <li>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 or other 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.
+      </li>
+      <li>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&#039;s
+        responsibility to acquire that license before distributing the Program.
+      </li>
+      <li>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.
+      </li>
+      <li>e) Notwithstanding the terms of any Secondary License, no Contributor
+        makes additional grants to any Recipient (other than those set forth
+        in this Agreement) as a result of such Recipient&#039;s receipt of the
+        Program under the terms of a Secondary License (if permitted under
+        the terms of Section 3).
+      </li>
+    </ul>
+    <h2 id="requirements">3. REQUIREMENTS</h2>
+    <p>3.1 If a Contributor Distributes the Program in any form, then:</p>
+    <ul>
+      <li>a) the Program must also be made available as Source Code, in
+        accordance with section 3.2, and the Contributor must accompany
+        the Program with a statement that the Source Code for the Program
+        is available under this Agreement, and informs Recipients how to
+        obtain it in a reasonable manner on or through a medium customarily
+        used for software exchange; and
+      </li>
+      <li>
+        b) the Contributor may Distribute the Program under a license
+        different than this Agreement, provided that such license:
+        <ul>
+          <li>i) effectively disclaims on behalf of all other 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;
+          </li>
+          <li>ii) effectively excludes on behalf of all other Contributors all
+            liability for damages, including direct, indirect, special, incidental
+            and consequential damages, such as lost profits;
+          </li>
+          <li>iii) does not attempt to limit or alter the recipients&#039; rights in the
+            Source Code under section 3.2; and
+          </li>
+          <li>iv) requires any subsequent distribution of the Program by any party
+            to be under a license that satisfies the requirements of this section 3.
+          </li>
+        </ul>
+      </li>
+    </ul>
+    <p>3.2 When the Program is Distributed as Source Code:</p>
+    <ul>
+      <li>a) it must be made available under this Agreement, or if the Program (i)
+        is combined with other material in a separate file or files made available
+        under a Secondary License, and (ii) the initial Contributor attached to
+        the Source Code the notice described in Exhibit A of this Agreement,
+        then the Program may be made available under the terms of such
+        Secondary Licenses, and
+      </li>
+      <li>b) a copy of this Agreement must be included with each copy of the Program.</li>
+    </ul>
+    <p>3.3 Contributors may not remove or alter any copyright, patent, trademark,
+      attribution notices, disclaimers of warranty, or limitations of liability
+      (&lsquo;notices&rsquo;) contained within the Program from any copy of the Program which
+      they Distribute, provided that Contributors may add their own appropriate
+      notices.
+    </p>
+    <h2 id="commercial-distribution">4. COMMERCIAL DISTRIBUTION</h2>
+    <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 (&ldquo;Commercial Contributor&rdquo;)
+      hereby agrees to defend and indemnify every other Contributor
+      (&ldquo;Indemnified Contributor&rdquo;) against any losses, damages and costs
+      (collectively &ldquo;Losses&rdquo;) 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&#039;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>
+    <h2 id="warranty">5. NO WARRANTY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN &ldquo;AS IS&rdquo; 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>
+    <h2 id="disclaimer">6. DISCLAIMER OF LIABILITY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, 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>
+    <h2 id="general">7. GENERAL</h2>
+    <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&#039;s patent(s), then such Recipient&#039;s rights granted
+      under Section 2(b) shall terminate as of the date such litigation is filed.
+    </p>
+    <p>All Recipient&#039;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&#039;s rights under this Agreement
+      terminate, Recipient agrees to cease use and distribution of the Program
+      as soon as reasonably practicable. However, Recipient&#039;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.
+    </p>
+    <p>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. Nothing in this Agreement is intended
+      to be enforceable by any entity that is not a Contributor or Recipient.
+      No third-party beneficiary rights are created under this Agreement.
+    </p>
+    <h2 id="exhibit-a">Exhibit A &ndash; Form of Secondary Licenses Notice</h2>
+    <p>&ldquo;This Source Code may also be made available under the following 
+    	Secondary Licenses when the conditions for such availability set forth 
+    	in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+    	version(s), and exceptions or additional permissions here}.&rdquo;
+    </p>
+    <blockquote>
+      <p>Simply including a copy of this Agreement, including this Exhibit A
+        is not sufficient to license the Source Code under Secondary Licenses.
+      </p>
+      <p>If it is not possible or desirable to put the notice in a particular file,
+        then You may include the notice in a location (such as a LICENSE file in a
+        relevant directory) where a recipient would be likely to look for
+        such a notice.
+      </p>
+      <p>You may add additional accurate notices of copyright ownership.</p>
+    </blockquote>
+  </body>
+</html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/license.txt b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/license.txt
new file mode 100644
index 0000000..e23ece2
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/license.txt
@@ -0,0 +1,277 @@
+Eclipse Public License - v 2.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 content
+     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 changes or additions to the Program that
+  are not Modified Works.
+
+"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
+or any Secondary License (as applicable), including Contributors.
+
+"Derivative Works" shall mean any work, whether in Source Code or other
+form, that is based on (or derived from) the Program and for which the
+editorial revisions, annotations, elaborations, or other modifications
+represent, as a whole, an original work of authorship.
+
+"Modified Works" shall mean any work in Source Code or other form that
+results from an addition to, deletion from, or modification of the
+contents of the Program, including, for purposes of clarity any new file
+in Source Code form that contains any contents of the Program. Modified
+Works shall not include works that contain only declarations,
+interfaces, types, classes, structures, or files of the Program solely
+in each case in order to link to, bind by name, or subclass the Program
+or Modified Works thereof.
+
+"Distribute" means the acts of a) distributing or b) making available
+in any manner that enables the transfer of a copy.
+
+"Source Code" means the form of a Program preferred for making
+modifications, including but not limited to software source code,
+documentation source, and configuration files.
+
+"Secondary License" means either the GNU General Public License,
+Version 2.0, or any later versions of that license, including any
+exceptions or additional permissions as identified by the initial
+Contributor.
+
+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.
+
+  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 or other 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.
+
+  e) Notwithstanding the terms of any Secondary License, no
+  Contributor makes additional grants to any Recipient (other than
+  those set forth in this Agreement) as a result of such Recipient's
+  receipt of the Program under the terms of a Secondary License
+  (if permitted under the terms of Section 3).
+
+3. REQUIREMENTS
+
+3.1 If a Contributor Distributes the Program in any form, then:
+
+  a) the Program must also be made available as Source Code, in
+  accordance with section 3.2, and the Contributor must accompany
+  the Program with a statement that the Source Code for the Program
+  is available under this Agreement, and informs Recipients how to
+  obtain it in a reasonable manner on or through a medium customarily
+  used for software exchange; and
+
+  b) the Contributor may Distribute the Program under a license
+  different than this Agreement, provided that such license:
+     i) effectively disclaims on behalf of all other 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 other Contributors all
+     liability for damages, including direct, indirect, special,
+     incidental and consequential damages, such as lost profits;
+
+     iii) does not attempt to limit or alter the recipients' rights
+     in the Source Code under section 3.2; and
+
+     iv) requires any subsequent distribution of the Program by any
+     party to be under a license that satisfies the requirements
+     of this section 3.
+
+3.2 When the Program is Distributed as Source Code:
+
+  a) it must be made available under this Agreement, or if the
+  Program (i) is combined with other material in a separate file or
+  files made available under a Secondary License, and (ii) the initial
+  Contributor attached to the Source Code the notice described in
+  Exhibit A of this Agreement, then the Program may be made available
+  under the terms of such Secondary Licenses, and
+
+  b) a copy of this Agreement must be included with each copy of
+  the Program.
+
+3.3 Contributors may not remove or alter any copyright, patent,
+trademark, attribution notices, disclaimers of warranty, or limitations
+of liability ("notices") contained within the Program from any copy of
+the Program which they Distribute, provided that Contributors may add
+their own appropriate notices.
+
+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, AND TO THE EXTENT
+PERMITTED BY APPLICABLE LAW, 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, AND TO THE EXTENT
+PERMITTED BY APPLICABLE LAW, 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. Nothing in this Agreement is intended
+to be enforceable by any entity that is not a Contributor or Recipient.
+No third-party beneficiary rights are created under this Agreement.
+
+Exhibit A - Form of Secondary Licenses Notice
+
+"This Source Code may also be made available under the following 
+Secondary Licenses when the conditions for such availability set forth 
+in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+version(s), and exceptions or additional permissions here}."
+
+  Simply including a copy of this Agreement, including this Exhibit A
+  is not sufficient to license the Source Code under Secondary Licenses.
+
+  If it is not possible or desirable to put the notice in a particular
+  file, then You may include the notice in a location (such as a LICENSE
+  file in a relevant directory) where a recipient would be likely to
+  look for such a notice.
+
+  You may add additional accurate notices of copyright ownership.
\ No newline at end of file
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/notice.html b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/notice.html
new file mode 100644
index 0000000..81fca9d
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/notice.html
@@ -0,0 +1,189 @@
+<?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>November 22, 2014</p>
+
+	<h3>Usage Of Content</h3>
+
+	<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION,
+		INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+		(COLLECTIVELY &quot;CONTENT&quot;). 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 2.0 (&quot;EPL&quot;). A copy of the
+		EPL is provided with this Content and is also available at <a
+			href="http://www.eclipse.org/legal/epl-2.0">http://www.eclipse.org/legal/epl-2.0</a>.
+		For purposes of the EPL, &quot;Program&quot; 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 (&quot;Repository&quot;) in software
+		modules (&quot;Modules&quot;) and made available as downloadable
+		archives (&quot;Downloads&quot;).</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 (&quot;Plug-ins&quot;), plug-in
+			fragments (&quot;Fragments&quot;), and features
+			(&quot;Features&quot;).</li>
+		<li>Each Plug-in or Fragment may be packaged as a sub-directory
+			or JAR (Java&trade; ARchive) in a directory named
+			&quot;plugins&quot;.</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 &quot;features&quot;. Within a
+			Feature, files named &quot;feature.xml&quot; 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 (&quot;Included
+			Features&quot;). Within a Feature, files named
+			&quot;feature.xml&quot; 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 &quot;about.html&quot;
+		(&quot;Abouts&quot;). The terms and conditions governing Features and
+		Included Features should be contained in files named
+		&quot;license.html&quot; (&quot;Feature Licenses&quot;). 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 &quot;src&quot; 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 (&quot;Feature Update License&quot;) 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
+		&quot;license&quot; property of files named
+		&quot;feature.properties&quot; 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 Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>)
+		</li>
+		<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>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 (&quot;Provisioning Technology&quot;) for the purpose of
+		allowing users to install software, documentation, information and/or
+		other materials (collectively &quot;Installable Software&quot;). 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>
+		(&quot;Specification&quot;).
+	</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 (&quot;Provisioning
+			Process&quot;) in which a user may execute the Provisioning
+			Technology on a machine (&quot;Target Machine&quot;) 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 (&quot;Installable Software Agreement&quot;) 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>
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/pom.xml b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/pom.xml
new file mode 100644
index 0000000..a003ac3
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/pom.xml
@@ -0,0 +1,250 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- /*                                                                           -->
+<!--  * Copyright (c) 2011, 2018 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany)   -->
+<!--  *                                                                           -->
+<!--  * This program and the accompanying materials are made available under the  -->
+<!--  * terms of the Eclipse Public License 2.0 which is available at             -->
+<!--  * http://www.eclipse.org/legal/epl-2.0.                                     -->
+<!--  *                                                                           -->
+<!--  * SPDX-License-Identifier: EPL-2.0                                          -->
+<!--  *                                                                           -->
+<!--  * Contributors:                                                             -->
+<!--  *      Loetz GmbH&Co.KG - forked from                                       --> 
+<!--  *              https://github.com/EduFrazao/vaadin-masked-textfield         -->
+<!--  */                                                                          -->
+<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/maven-v4_0_0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+
+	<parent>
+		<groupId>org.eclipse.osbp.fork.vaadin.addon.maskedtextfield</groupId>
+		<artifactId>org.eclipse.osbp.fork.vaadin.addon.maskedtextfield.aggregator</artifactId>
+		<version>0.9.0-SNAPSHOT</version>
+		<relativePath>..</relativePath>
+	</parent>
+
+	<!-- CQ: https://dev.eclipse.org/ipzilla/show_bug.cgi?id=15404 -->
+	<!-- artifact: vaadin.addon.maskedtextfield -->
+	<!-- version: 0.1.10 -->
+	<artifactId>org.eclipse.osbp.fork.vaadin.addon.maskedtextfield</artifactId>
+	<version>0.1.10-SNAPSHOT</version>
+	<packaging>bundle</packaging>
+
+	<properties>
+		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+		<vaadin.plugin.version>${vaadin.version}</vaadin.plugin.version>
+		<jdkVersion>1.8</jdkVersion>
+	</properties>
+
+	<repositories>
+		<repository>
+			<id>vaadin-snapshots</id>
+			<url>http://oss.sonatype.org/content/repositories/vaadin-snapshots/</url>
+			<releases>
+				<enabled>false</enabled>
+			</releases>
+			<snapshots>
+				<enabled>true</enabled>
+			</snapshots>
+		</repository>
+	</repositories>
+	<pluginRepositories>
+		<pluginRepository>
+			<id>vaadin-snapshots</id>
+			<url>http://oss.sonatype.org/content/repositories/vaadin-snapshots/</url>
+			<releases>
+				<enabled>false</enabled>
+			</releases>
+			<snapshots>
+				<enabled>true</enabled>
+			</snapshots>
+		</pluginRepository>
+	</pluginRepositories>
+
+	<dependencies>
+		<!-- CQ: https://dev.eclipse.org/ipzilla/show_bug.cgi?id=15328 (7.7.6) -->
+		<dependency>
+			<groupId>com.vaadin</groupId>
+			<artifactId>vaadin-server</artifactId>
+			<version>${vaadin.version}</version>
+			<scope>provided</scope>
+		</dependency>
+		
+		<!-- CQ: https://dev.eclipse.org/ipzilla/show_bug.cgi?id=15326 (7.7.6) -->
+		<dependency>
+			<groupId>com.vaadin</groupId>
+			<artifactId>vaadin-shared</artifactId>
+			<version>${vaadin.version}</version>
+			<scope>provided</scope>
+		</dependency>
+		
+		<!-- CQ: https://dev.eclipse.org/ipzilla/show_bug.cgi?id=15327 (7.7.6) -->
+		<dependency>
+			<groupId>com.vaadin</groupId>
+			<artifactId>vaadin-client</artifactId>
+			<version>${vaadin.version}</version>
+			<scope>provided</scope>
+		</dependency>
+
+		<!-- CQ: https://dev.eclipse.org/ipzilla/show_bug.cgi?id=15327 (7.7.6) -->
+		<dependency>
+			<groupId>com.vaadin</groupId>
+			<artifactId>vaadin-client-compiled</artifactId>
+			<version>${vaadin.version}</version>
+			<scope>provided</scope>
+		</dependency>
+
+		<!-- CQ: https://dev.eclipse.org/ipzilla/show_bug.cgi?id=15329 (7.7.6) -->
+		<dependency>
+			<groupId>com.vaadin</groupId>
+			<artifactId>vaadin-themes</artifactId>
+			<version>${vaadin.version}</version>
+			<scope>provided</scope>
+		</dependency>
+
+		<!-- CQ: https://dev.eclipse.org/ipzilla/show_bug.cgi?id=12749 -->
+		<dependency>
+			<groupId>org.jsoup</groupId>
+			<artifactId>jsoup</artifactId>
+			<version>1.8.3</version>
+		</dependency>
+
+		<dependency>
+			<groupId>org.eclipse.osbp.dependencies</groupId>
+			<artifactId>org.eclipse.osbp.dependencies.bundle.vaadin.external.gwt</artifactId>
+			<version>2.7.0-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: MaskedTextField (Fork)</Bundle-Name>
+						<Bundle-SymbolicName>org.eclipse.osbp.fork.vaadin.addon.maskedtextfield</Bundle-SymbolicName>
+						<Bundle-Version>0.1.10.${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.client-compiled;bundle-version="[7.7.6,7.8.0)",
+							com.vaadin.themes;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>
+							com.ibm.icu.*;version="56.1",
+							*
+						</Import-Package>
+						<Export-Package>
+							!LICENSE,!LICENSE.txt,!THIRD-PARTY.txt,!NOTICE,!README.txt,!VERSION.txt,!build.properties,
+							!VAADIN.*,!about_files*,
+							org.vaadin.addons.maskedtextfield.*
+						</Export-Package>
+						<Include-Resource>{maven-resources},license.txt,license.html,epl-v20.html,about_files/=about_files,about.html,about.ini,about.mappings,about.properties</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.fork.vaadin.addon.maskedtextfield/sample/org/vaadin/addons/maskedtextfield/sample/SampleUI.java b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/sample/org/vaadin/addons/maskedtextfield/sample/SampleUI.java
new file mode 100644
index 0000000..089a1cf
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/sample/org/vaadin/addons/maskedtextfield/sample/SampleUI.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ * 
+ * Contributions:
+ * 		- Florian Pirchner <florian.pirchner@gmail.com> - Initial implementation 
+ */
+
+package org.vaadin.addons.maskedtextfield.sample;
+
+import javax.servlet.annotation.WebServlet;
+
+import org.vaadin.addons.maskedtextfield.MaskedTextField;
+import org.vaadin.addons.maskedtextfield.NumericField;
+
+import com.vaadin.annotations.Theme;
+import com.vaadin.annotations.VaadinServletConfiguration;
+import com.vaadin.server.VaadinRequest;
+import com.vaadin.server.VaadinServlet;
+import com.vaadin.ui.Button;
+import com.vaadin.ui.Button.ClickEvent;
+import com.vaadin.ui.Button.ClickListener;
+import com.vaadin.ui.FormLayout;
+import com.vaadin.ui.Label;
+import com.vaadin.ui.Notification;
+import com.vaadin.ui.TabSheet;
+import com.vaadin.ui.UI;
+
+/**
+ * The Class AbsoluteLayoutUI.
+ */
+@SuppressWarnings("serial")
+@Theme("valo")
+public class SampleUI extends UI {
+
+	@Override
+	protected void init(VaadinRequest request) {
+
+TabSheet tabSheet = new TabSheet();
+        
+        FormLayout numbers = new FormLayout();
+        
+        final MaskedTextField phoneField = new MaskedTextField("Phone (##) ####-####", "+55 (##) ####-####");
+        
+        Button btnShowValue = new Button("Show value");
+        btnShowValue.addClickListener(new ClickListener() {
+            @Override
+            public void buttonClick(ClickEvent event) {
+                Notification.show((String) phoneField.getValue());
+            }
+        });
+        
+        numbers.addComponent(phoneField);
+        numbers.addComponent(btnShowValue);
+        
+        numbers.addComponent(new MaskedTextField("UU###-###-###LL", "UU###-###-###LL"));
+        numbers.addComponent(new MaskedTextField("USPS Express Mail", "EU#########'US"));
+        numbers.addComponent(new MaskedTextField("Alphanumeric", "AAAAAAAAAA"));
+        numbers.addComponent(new MaskedTextField("Hex 0xHHHHHHHH", "0xHHHHHHHH"));
+        numbers.addComponent(new MaskedTextField("Signed number", "~####"));
+        numbers.addComponent(new MaskedTextField("Escape #2010", "'#####"));
+        numbers.addComponent(new MaskedTextField("'2010'", "''####''"));
+        
+        FormLayout misc = new FormLayout();
+        misc.addComponent(new MaskedTextField("Capitalized name", "ULLLLLLLLLLLLLL"));
+        misc.addComponent(new MaskedTextField("Upper-case letters only", "UUUUUUUUU"));
+        misc.addComponent(new MaskedTextField("Lower-case letters only", "LLLLLLLLL"));
+        misc.addComponent(new MaskedTextField("Any letter", "????????"));
+        misc.addComponent(new MaskedTextField("Anything", "***********"));
+        misc.addComponent(new MaskedTextField("Time", "##:##"));
+        misc.addComponent(new MaskedTextField("Some preffix", "TR-####"));
+        
+        FormLayout numeric = new FormLayout();
+        numeric.addComponent(new Label("Use UP and DOWN keys to change the value"));
+        numeric.addComponent(new NumericField("Numeric Value"));
+        
+        tabSheet.addTab(numbers, "Numbers", null);
+        tabSheet.addTab(misc, "Misc", null);
+        tabSheet.addTab(numeric, "NumericField", null);
+        
+        setContent(tabSheet);
+	}
+	
+	/**
+	 * The Class Servlet.
+	 */
+	@WebServlet(value = "/*", asyncSupported = true)
+	@VaadinServletConfiguration(productionMode = false, ui = SampleUI.class, widgetset = "org.vaadin.addons.maskedtextfield.MaskedTextFieldWidgetset")
+	public static class Servlet extends VaadinServlet {
+	}
+
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/DecimalField.java b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/DecimalField.java
new file mode 100644
index 0000000..1678048
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/DecimalField.java
@@ -0,0 +1,187 @@
+package org.vaadin.addons.maskedtextfield;
+
+import java.text.DecimalFormat;
+import java.text.DecimalFormatSymbols;
+import java.text.ParseException;
+import java.util.Locale;
+
+import org.vaadin.addons.maskedtextfield.client.DecimalFieldState;
+import org.vaadin.addons.maskedtextfield.server.Utils;
+
+import com.vaadin.data.Property;
+import com.vaadin.data.util.converter.AbstractStringToNumberConverter;
+import com.vaadin.ui.TextField;
+
+public class DecimalField extends TextField {
+
+	private static final long serialVersionUID = 1L;
+
+	public DecimalField() {
+		super();
+		setConverter(new MaskNumberConverter());
+	}
+
+	public DecimalField(Property<?> dataSource) {
+		super(dataSource);
+		setConverter(new MaskNumberConverter());
+	}
+
+	public DecimalField(String caption, Property<?> dataSource) {
+		super(caption, dataSource);
+		setConverter(new MaskNumberConverter());
+	}
+
+	public DecimalField(String caption, String value) {
+		super(caption, value);
+		setConverter(new MaskNumberConverter());
+	}
+
+	public DecimalField(String caption) {
+		super(caption);
+		setConverter(new MaskNumberConverter());
+	}
+	
+	public DecimalField(String mask, char decimalSeparator, char groupingSeparator) {
+		this();
+		setMask(mask);
+		setDecimalSeparator(decimalSeparator);
+		setGroupingSeparator(groupingSeparator);
+	}
+	
+	@Override
+	public void setValue(String string) {
+		super.setValue(string);
+	}
+	
+	public void setValue(Number number) {
+		if(number != null) {
+			if(getConverter() != null) {
+				String v = getConverter().convertToPresentation(number, String.class, getLocale());
+				setValue(v);
+			} else {
+				setValue( (String) null);
+			}
+		} else {
+			setValue( (String) null);
+		}
+	}
+	
+	public void setMask(String mask) {
+		if(mask == null) {
+			throw new NullPointerException("The format mask cannot be null");
+		}
+		if(mask.trim().isEmpty()) {
+			throw new IllegalStateException("The format mask cannot be empty");
+		}
+		getState().mask = mask;
+	}
+	
+	public String getMask() {
+		return getState().mask;
+	}
+	
+	public void setDecimalSeparator(char decimalSeparator) {
+		getState().decimalSeparator = decimalSeparator;
+	}
+	
+	public char getDecimalSeparator() {
+		return getState().decimalSeparator;
+	}
+	
+	public void setGroupingSeparator(char groupingSeparator) {
+		getState().groupingSeparator = groupingSeparator;
+	}
+	
+	public char getGroupingSeparator() {
+		return getState().groupingSeparator;
+	}
+	
+	@Override
+	public DecimalFieldState getState() {
+		return (DecimalFieldState) super.getState();
+	}
+	
+	public void setSelectValueOnFocus(boolean selectOnFocus) {
+		getState().selectValuesOnFocus = selectOnFocus;
+	}
+	
+	public boolean isSelectValueOnFocus() {
+		return getState().selectValuesOnFocus;
+	}
+	
+	@SuppressWarnings("rawtypes")
+	@Override
+	public void setPropertyDataSource(Property newDataSource) {
+		if(newDataSource != null) {
+			if(!Number.class.isAssignableFrom(newDataSource.getType())) {
+				throw new IllegalArgumentException("This field is compatible with number datasources only");
+			}
+			super.setPropertyDataSource(newDataSource);
+		}
+	}
+
+	/**
+	 * Custom converter to handle custom separators
+	 * @author eduardo
+	 *
+	 */
+	private class MaskNumberConverter extends AbstractStringToNumberConverter<Number> {
+
+		private static final long serialVersionUID = 1L;
+
+		private DecimalFormat formatter;
+		
+		public MaskNumberConverter() {
+			refreshFormatter();
+		}
+		
+		private void refreshFormatter() {
+			if(formatter == null || 
+					(	formatter.getDecimalFormatSymbols().getGroupingSeparator() != getGroupingSeparator()
+					||  formatter.getDecimalFormatSymbols().getDecimalSeparator() != getDecimalSeparator()
+					)
+			) 
+			{
+				DecimalFormatSymbols decimalSymbols = new DecimalFormatSymbols();
+				decimalSymbols.setGroupingSeparator(getGroupingSeparator());
+				decimalSymbols.setDecimalSeparator(getDecimalSeparator());
+				formatter = new DecimalFormat();
+				formatter.setDecimalFormatSymbols(decimalSymbols);
+			}
+		}
+		
+		
+		@Override
+		public Number convertToModel(String value, Class<? extends Number> targetType, Locale locale) throws ConversionException {
+			refreshFormatter();
+			try {
+				if(value == null || value.trim().isEmpty()) {
+					return null;
+				}
+				Number number = formatter.parse(value);
+				if(getPropertyDataSource() != null) {
+					return Utils.convertToDataSource(number, getPropertyDataSource());
+				}
+				return number;
+			} catch (ParseException e) {
+				return Utils.convertToDataSource(new Double(0.0), getPropertyDataSource());
+			}
+		}
+
+		@Override
+		public String convertToPresentation(Number value, Class<? extends String> targetType, Locale locale) throws ConversionException {
+			if(value != null) {
+				refreshFormatter();
+				return formatter.format(value);
+			}
+			return null;
+		}
+
+		@Override
+		public Class<Number> getModelType() {
+			return Number.class;
+		}
+
+	}
+
+}
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/MaskedTextField.java b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/MaskedTextField.java
new file mode 100644
index 0000000..8e5fff2
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/MaskedTextField.java
@@ -0,0 +1,199 @@
+package org.vaadin.addons.maskedtextfield;
+
+import java.util.Arrays;
+import java.util.Locale;
+
+import org.vaadin.addons.maskedtextfield.client.MaskedTextFieldState;
+import org.vaadin.addons.maskedtextfield.server.Utils;
+import org.vaadin.addons.maskedtextfield.shared.Constants;
+
+import com.ibm.icu.math.BigDecimal;
+import com.vaadin.data.Property;
+import com.vaadin.data.util.converter.AbstractStringToNumberConverter;
+import com.vaadin.data.util.converter.Converter;
+import com.vaadin.ui.TextField;
+
+/**
+ * Server side component for the VMaskedTextField widget.
+ */
+public class MaskedTextField extends TextField {
+
+	private static final long serialVersionUID = 1L;
+	
+	private char digitRepresentation = '#';
+	
+	private Boolean maskClientOnly = false;
+	
+	public MaskedTextField() {
+		super();
+	}
+
+	public MaskedTextField(String caption) {
+		setCaption(caption);
+		setConverter(new UnmaskModelConverter(this));
+	}
+
+	public MaskedTextField(String caption, String mask) {
+		setCaption(caption);
+		setMask(mask);
+	}
+
+	public MaskedTextField(Property<?> dataSource) {
+		super(dataSource);
+		setConverter(new UnmaskModelConverter(this));
+	}
+
+	public MaskedTextField(String caption, Property<?> dataSource) {
+		super(caption, dataSource);
+		setConverter(new UnmaskModelConverter(this));
+	}
+
+	@SuppressWarnings("rawtypes")
+	@Override
+	public void setPropertyDataSource(Property newDataSource) {
+		if(newDataSource != null) {
+			super.setPropertyDataSource(newDataSource);
+			if(Number.class.isAssignableFrom(newDataSource.getType())) {
+				validateNumberPropertyWithMask();
+				setConverter(new MaskNumberConverter());
+			} else if (char.class.isAssignableFrom(newDataSource.getType()) || String.class.isAssignableFrom(newDataSource.getType())) {
+				setConverter(new UnmaskModelConverter(this));
+			}
+		}
+	}
+	
+	private void validateNumberPropertyWithMask() {
+		char[] maskChars = getMask().replaceAll("\\+", "").toCharArray();
+		for(char s : maskChars) {
+			if(Arrays.binarySearch(Constants.MASK_REPRESENTATIONS, s) >= 0 && s != digitRepresentation) {
+				throw new IllegalArgumentException("This mask is not compatible with numeric datasources");
+			}
+		}
+	}
+
+	public String getMask() {
+		return getState().mask;
+	}
+	
+	public void setMask(String mask) {
+		getState().mask = mask;
+	}
+	
+	public char getPlaceHolder() {
+		return getState().placeHolder;
+	}
+	
+	public void setPlaceHolder(char placeHolder) {
+		getState().placeHolder = placeHolder;
+	}
+	
+	public void setMaskClientOnly(boolean isMaskClientOnly) {
+		this.maskClientOnly = isMaskClientOnly;
+		setConverter(new UnmaskModelConverter(this));
+	}
+	
+	public boolean isMaskClientOnly() {
+		return maskClientOnly.booleanValue();
+	}
+
+	@Override
+	protected MaskedTextFieldState getState() {
+		return (MaskedTextFieldState) super.getState();
+	}
+	
+	protected String unmask(final String value, String mask) {
+		if(value == null || value.trim().isEmpty()) {
+			return null;
+		}
+		StringBuilder sb = new StringBuilder(value);
+		mask = mask.replaceAll("\\+", "");
+		int removedChars = 0;
+		for(int i = 0; i<mask.length(); i++) {
+			char s = mask.charAt(i);
+			if(Arrays.binarySearch(Constants.MASK_REPRESENTATIONS, s) < 0) {
+				if(i < value.length() && sb.charAt(i-removedChars) == s) {
+					sb.deleteCharAt(i-removedChars);
+					removedChars++;
+				}
+			}
+		}
+		return sb.toString();
+	}
+	
+	protected String unmask(final String value) {
+		return unmask(value, getMask());
+	}
+	
+	/**
+	 * Tenta converter uma instancia de mascaras unicamente de digitos para um numero aplicavel em um datasource
+	 * @author Eduardo Frazao
+	 *
+	 */
+	private class MaskNumberConverter extends AbstractStringToNumberConverter<Number> {
+
+		private static final long serialVersionUID = 1L;
+		
+		@Override
+		public Number convertToModel(String value, Class<? extends Number> targetType, Locale locale) throws ConversionException {
+			String unmasked = unmask(value);
+			if(unmasked != null) {
+				try {
+					Number n = new BigDecimal(value);
+					return Utils.convertToDataSource(n, getPropertyDataSource());
+				} catch (NumberFormatException ne) {
+					return Utils.convertToDataSource(0, getPropertyDataSource());
+				}
+			}
+			return Utils.convertToDataSource(0, getPropertyDataSource());
+		}
+
+		@Override
+		public Class<Number> getModelType() {
+			return Number.class;
+		}
+		
+	}
+	
+	/**
+	 * Converter simples para remover a mascara caso configurado pelo usuario
+	 * @author eduardo
+	 *
+	 */
+	private static class UnmaskModelConverter implements Converter<String, String> {
+
+		private static final long serialVersionUID = 1L;
+
+		private MaskedTextField field;
+		
+		public UnmaskModelConverter(MaskedTextField field) {
+			this.field = field;
+		}
+		@Override
+		public String convertToModel(String value, Class<? extends String> targetType, Locale locale) throws ConversionException {
+			return value;
+		}
+
+		@Override
+		public String convertToPresentation(String value, Class<? extends String> targetType, Locale locale) throws ConversionException {
+			if(field.isMaskClientOnly()) {
+				String unmasked = field.unmask(value);
+				if(unmasked != null) {
+					return unmasked;
+				}
+			} 
+			return value;
+		}
+
+		@Override
+		public Class<String> getModelType() {
+			return String.class;
+		}
+
+		@Override
+		public Class<String> getPresentationType() {
+			return String.class;
+		}
+		
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/MaskedTextFieldWidgetset.gwt.xml b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/MaskedTextFieldWidgetset.gwt.xml
new file mode 100644
index 0000000..801779a
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/MaskedTextFieldWidgetset.gwt.xml
@@ -0,0 +1,12 @@
+<module>
+
+	<!-- Inherit DefaultWidgetSet -->
+	<inherits name="com.vaadin.DefaultWidgetSet" />
+
+	<set-configuration-property name="devModeRedirectEnabled" value="true" />
+	<add-linker name="xsiframe" />
+
+	<source path="client" />
+	<source path="shared" />
+
+</module>
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/NumericField.java b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/NumericField.java
new file mode 100644
index 0000000..831d290
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/NumericField.java
@@ -0,0 +1,64 @@
+package org.vaadin.addons.maskedtextfield;
+
+import com.vaadin.data.Property;
+import com.vaadin.ui.TextField;
+
+public class NumericField extends TextField {
+
+	private static final long serialVersionUID = 1L;
+
+	public NumericField() {
+		super();
+	}
+
+	/*
+	public void setValue(Short number) {
+		setNumberValue((Number) number);
+	}
+	
+	public void setValue(Integer number) {
+		setNumberValue((Number) number);
+	}
+	
+	public void setValue(Long number) {
+		setNumberValue((Number) number);
+	}
+	
+	public void setValue(Double number) {
+		setNumberValue(number);
+	}
+	
+	public void setValue(Float number) {
+		setNumberValue(number);
+	}
+	*/
+	
+	public void setValue(Number number) {
+		if(number != null) {
+			if(getConverter() != null) {
+				String v = getConverter().convertToPresentation(number, String.class, getLocale());
+				setValue(v);
+			} else {
+				setValue( (String) null);
+			}
+		} else {
+			setValue( (String) null);
+		}
+	}
+	
+	public NumericField(Property<Number> dataSource) {
+		super(dataSource);
+	}
+
+	public NumericField(String caption, Property<Number> dataSource) {
+		super(caption, dataSource);
+	}
+
+	public NumericField(String caption, String value) {
+		super(caption, value);
+	}
+
+	public NumericField(String caption) {
+		super(caption);
+	}
+}
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/PrefixedMaskedTextField.java b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/PrefixedMaskedTextField.java
new file mode 100644
index 0000000..b2cdc93
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/PrefixedMaskedTextField.java
@@ -0,0 +1,74 @@
+package org.vaadin.addons.maskedtextfield;
+
+import java.util.Collections;
+import java.util.Map;
+
+import org.vaadin.addons.maskedtextfield.client.PrefixedMaskedTextFieldState;
+
+public class PrefixedMaskedTextField extends MaskedTextField {
+
+	private static final long serialVersionUID = 1L;
+
+	public PrefixedMaskedTextField(String caption) {
+		super(caption);
+	}
+	
+	public PrefixedMaskedTextField() {
+		super();
+	}
+	
+	public PrefixedMaskedTextField(String caption, String defaultMask, Map<String, String> masksByPrefix) {
+		super(caption, defaultMask);
+		setMasks(masksByPrefix);
+		getState().defaultMask = defaultMask;
+	}
+	
+	public Map<String, String> getMasksByPrefix() {
+		return Collections.unmodifiableMap(getState().masksByPrefix);
+	}
+	
+	public String getMaskByPrefix(String prefix) {
+		return getState().masksByPrefix.get(prefix);
+	}
+	
+	public void addMask(String prefix, String mask) {
+		getState().masksByPrefix.put(prefix, mask);
+	}
+	
+	public void removeMask(String prefix) {
+		getState().masksByPrefix.remove(prefix);
+	}
+	
+	public void setMasks(Map<String, String> masksByPrefix) {
+		getState().masksByPrefix.clear();
+		getState().masksByPrefix.putAll(masksByPrefix);
+	}
+	
+	@Override
+	public void setMask(String mask) {
+		super.setMask(mask);
+		getState().defaultMask = mask;
+	}
+
+	@Override
+	protected String unmask(final String value) {
+		return super.unmask(value, getMaskForValue(value));
+	}
+	
+	private String getMaskForValue(String value) {
+		if(value != null && !value.isEmpty() && !getState().masksByPrefix.isEmpty()) {
+			for(String prefix : getState().masksByPrefix.keySet()) {
+				if(value.startsWith(prefix)) {
+					return getState().masksByPrefix.get(prefix);
+				}
+			}
+		}
+		return super.getMask();
+	}
+	
+	@Override
+	public PrefixedMaskedTextFieldState getState() {
+		return (PrefixedMaskedTextFieldState) super.getState();
+	}
+	
+}
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/DecimalFieldConnector.java b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/DecimalFieldConnector.java
new file mode 100644
index 0000000..7f40fdd
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/DecimalFieldConnector.java
@@ -0,0 +1,40 @@
+package org.vaadin.addons.maskedtextfield.client;
+
+import org.vaadin.addons.maskedtextfield.DecimalField;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.user.client.ui.Widget;
+import com.vaadin.client.communication.StateChangeEvent;
+import com.vaadin.client.ui.textfield.TextFieldConnector;
+import com.vaadin.shared.ui.Connect;
+
+@Connect(DecimalField.class)
+public class DecimalFieldConnector extends TextFieldConnector {
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	protected Widget createWidget() {
+		return GWT.create(DecimalFieldWidget.class);
+	}
+	
+	@Override
+	public DecimalFieldWidget getWidget() {
+		return (DecimalFieldWidget) super.getWidget();
+	}
+
+	@Override
+	public DecimalFieldState getState() {
+		return (DecimalFieldState) super.getState();
+	}
+
+	@Override
+	public void onStateChanged(StateChangeEvent stateChangeEvent) {
+		getWidget().setGroupingSeparator(getState().groupingSeparator);
+		getWidget().setDecimalSeparator(getState().decimalSeparator);
+		getWidget().setMask(getState().mask);
+		getWidget().setSelectTextOnFocus(getState().selectValuesOnFocus);
+		super.onStateChanged(stateChangeEvent);
+	}
+	
+}
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/DecimalFieldState.java b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/DecimalFieldState.java
new file mode 100644
index 0000000..37946a4
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/DecimalFieldState.java
@@ -0,0 +1,17 @@
+package org.vaadin.addons.maskedtextfield.client;
+
+import com.vaadin.shared.ui.textfield.AbstractTextFieldState;
+
+public class DecimalFieldState extends AbstractTextFieldState {
+
+	private static final long serialVersionUID = 1L;
+	
+	public char decimalSeparator = '.';
+	
+	public char groupingSeparator = ',';
+	
+	public String mask = "#.00";
+
+	public boolean selectValuesOnFocus = false;
+	
+}
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/DecimalFieldWidget.java b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/DecimalFieldWidget.java
new file mode 100644
index 0000000..22a385b
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/DecimalFieldWidget.java
@@ -0,0 +1,254 @@
+package org.vaadin.addons.maskedtextfield.client;
+
+import java.util.Arrays;
+
+import org.vaadin.addons.maskedtextfield.shared.Constants;
+
+import com.google.gwt.event.dom.client.BlurEvent;
+import com.google.gwt.event.dom.client.BlurHandler;
+import com.google.gwt.event.dom.client.FocusEvent;
+import com.google.gwt.event.dom.client.FocusHandler;
+import com.google.gwt.event.dom.client.KeyCodes;
+import com.google.gwt.event.dom.client.KeyDownEvent;
+import com.google.gwt.event.dom.client.KeyPressEvent;
+import com.google.gwt.event.dom.client.KeyPressHandler;
+import com.google.gwt.i18n.client.NumberFormat;
+import com.google.gwt.user.client.Event;
+import com.vaadin.client.ui.VTextField;
+
+/**
+ * Widget para controlar a edicao de valores de moeda 
+ * @author Eduardo Frazao
+ *
+ */
+public class DecimalFieldWidget extends VTextField implements KeyPressHandler, BlurHandler, FocusHandler {
+	
+	
+	private char decimalSeparator;
+	private char groupingSeparator;
+	private String mask;
+	
+	private Number maxValue = Double.MAX_VALUE;
+	
+	private NumberFormat formatter;
+	private NumberFormat defaultFormatter = NumberFormat.getDecimalFormat();
+	
+	private boolean selectTextOnFocus = false;
+	
+	protected static char[] acceptedCharSet = {
+		(char) KeyCodes.KEY_BACKSPACE,
+		(char) KeyCodes.KEY_TAB,
+		(char) KeyCodes.KEY_DELETE,  
+		(char) KeyCodes.KEY_END,
+		(char) KeyCodes.KEY_ENTER,
+		(char) KeyCodes.KEY_ESCAPE,
+		(char) KeyCodes.KEY_HOME,
+		(char) KeyCodes.KEY_LEFT,
+		(char) KeyCodes.KEY_PAGEDOWN,
+		(char) KeyCodes.KEY_PAGEUP,
+		(char) KeyCodes.KEY_RIGHT
+	};
+	
+	static {
+		Arrays.sort(acceptedCharSet);
+	}
+	
+	public boolean isSelectTextOnFocus() {
+		return selectTextOnFocus;
+	}
+
+	public void setSelectTextOnFocus(boolean selectTextOnFocus) {
+		this.selectTextOnFocus = selectTextOnFocus;
+	}
+
+	public DecimalFieldWidget() {
+		setAlignment(TextAlignment.RIGHT);
+		
+		addKeyPressHandler(this);
+		addKeyDownHandler(this);
+		addFocusHandler(this);
+		sinkEvents(Event.ONPASTE);
+		
+		NumberFormat.setForcedLatinDigits(false);
+		formatter = NumberFormat.getFormat("#,###.00");
+	}
+	
+	private boolean isCopyOrPasteEvent(KeyPressEvent evt) {
+		if(evt.isControlKeyDown()) {
+			return Character.toString(evt.getCharCode()).toLowerCase().equals("c") ||
+					Character.toString(evt.getCharCode()).toLowerCase().equals("v");
+		}
+		return false;
+	}
+	
+	private boolean isAcceptedKey(char charCode) {
+		if(charCode == groupingSeparator) {
+			return false;
+		}
+		if(charCode == decimalSeparator) {
+			if(!mask.contains(Character.toString(Constants.FIXED_LOCALE_DECIMAL_SEPARATOR))) {
+				return false;
+			}
+			String str = getText().trim();
+			if(!str.isEmpty()) {
+				return !str.contains(Character.toString(decimalSeparator));
+			} else {
+				return false;
+			}
+		}
+		return Character.isDigit(charCode)
+				|| charCode == decimalSeparator 
+				|| Arrays.binarySearch(acceptedCharSet, charCode) >= 0;
+	}
+	
+	@Override
+	public void onKeyPress(KeyPressEvent event) {
+		if(!isCopyOrPasteEvent(event)) {
+			if (event.getCharCode() != Constants.EMPTY_CHAR && !isAcceptedKey(event.getCharCode()) ) {
+				cancelKey();
+			} else if(!getText().trim().isEmpty() && formatter.parse(getText()) >= maxValue.doubleValue()) {
+				cancelKey();
+			}
+		}
+	}
+	
+	
+	@Override
+	public void onKeyDown(KeyDownEvent event) {
+		super.onKeyDown(event);
+		if(event.getNativeKeyCode() == KeyCodes.KEY_ENTER) {
+			refreshValue();
+		}
+	}
+
+	@Override
+	public void onBlur(BlurEvent event) {
+		super.onBlur(event);
+		refreshValue();
+	}
+	
+	@Override
+	public void onFocus(FocusEvent event) {
+		super.onFocus(event);
+		if(selectTextOnFocus) {
+			String text = getText();
+			if(text != null && !text.isEmpty()) {
+				setSelectionRange(0, text.length());
+			}
+		}
+	}
+
+	@Override
+    public void onBrowserEvent(Event event) {
+        super.onBrowserEvent(event);
+        if (event.getTypeInt() == Event.ONPASTE) {
+            onPaste(event);
+        }
+    }
+	
+	public void onPaste(Event event) {
+		refreshValue();
+	}
+
+	private void refreshValue() {
+		super.setText(reformatContent(null));
+	}
+	
+	private void refreshValue(String withFormatedValue) {
+		super.setText(reformatContent(withFormatedValue));
+	}
+	
+	protected String reformatContent(String value) {
+	    String str = value == null ? getText() : value;
+	    if(!str.trim().isEmpty()) {
+	    	double amount = readDoubleFromFormattedValue(value);
+	  	    return replaceSeparators(formatter.format(amount));
+	    } 
+	    return str;
+	  }
+	
+	protected double parseDouble(String doubleNotationString) {
+		try {
+			return defaultFormatter.parse(doubleNotationString);
+		} catch (NumberFormatException ex) {
+			return 0.0;
+		}
+	}
+	
+	protected double readDoubleFromFormattedValue(String value) {
+		String str = (value == null || value.trim().isEmpty()) ? getText().trim() : value;
+		if(groupingSeparator != Constants.EMPTY_CHAR) {
+			str = str.replaceAll(groupingSeparator == '.' ? "\\." : Character.toString(groupingSeparator), "");
+		}
+		if(decimalSeparator != Constants.EMPTY_CHAR) {
+			if(decimalSeparator != '.') {
+				str = str.replaceAll(Character.toString(decimalSeparator), ".");
+			}
+		}
+		try {
+			return Double.parseDouble(str);
+		} catch (NumberFormatException ex) {
+			return 0.0;
+		}
+	}
+	
+	protected String replaceSeparators(final String defaultFormatedValue) {
+		String str = new String(defaultFormatedValue);
+		if(groupingSeparator != Constants.EMPTY_CHAR) {
+			str = str.replaceAll(Character.toString(Constants.FIXED_LOCALE_GROUPING_SEPARATOR), Character.toString(groupingSeparator));
+		}
+		if(decimalSeparator != Constants.EMPTY_CHAR) {
+			if(mask.contains(Character.toString(Constants.FIXED_LOCALE_DECIMAL_SEPARATOR))) {
+				int decimalLenght = mask.length() - mask.indexOf(Constants.FIXED_LOCALE_DECIMAL_SEPARATOR) - 1;
+				StringBuilder sb = new StringBuilder(str);
+				sb.setCharAt(str.length() - decimalLenght - 1 , decimalSeparator);
+				str = sb.toString();
+			}
+		}
+		return str;
+	}
+
+	public char getDecimalSeparator() {
+		return decimalSeparator;
+	}
+
+	public void setDecimalSeparator(char decimalSeparator) {
+		if(decimalSeparator != this.decimalSeparator) {
+			this.decimalSeparator = decimalSeparator;
+			refreshValue();
+		}
+	}
+
+	public char getGroupingSeparator() {
+		return groupingSeparator;
+	}
+
+	public void setGroupingSeparator(char groupingSeparator) {
+		if(groupingSeparator != this.groupingSeparator) {
+			this.groupingSeparator = groupingSeparator;
+			refreshValue();
+		}
+	}
+
+	public String getMask() {
+		return mask;
+	}
+
+	public void setMask(String mask) {
+		if(mask != this.mask) {
+			this.mask = mask;
+			formatter = NumberFormat.getFormat(this.mask);
+			refreshValue();
+		}
+	}
+	
+	@Override
+	public void setText(String value) {
+		if(value == null) {
+			super.setText(null);
+		} else {
+			refreshValue(value);
+		}
+	}
+	
+}
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/MaskedTextFieldConnector.java b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/MaskedTextFieldConnector.java
new file mode 100644
index 0000000..aeb69f5
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/MaskedTextFieldConnector.java
@@ -0,0 +1,37 @@
+package org.vaadin.addons.maskedtextfield.client;
+
+import org.vaadin.addons.maskedtextfield.MaskedTextField;
+
+import com.google.gwt.core.client.GWT;
+import com.vaadin.client.communication.StateChangeEvent;
+import com.vaadin.client.ui.textfield.TextFieldConnector;
+import com.vaadin.shared.ui.Connect;
+
+@Connect(MaskedTextField.class)
+public class MaskedTextFieldConnector extends TextFieldConnector {
+
+	private static final long serialVersionUID = 1L;
+	
+		@Override
+		protected MaskedTextFieldWidget createWidget() {
+			return GWT.create(MaskedTextFieldWidget.class);
+		}
+		
+		@Override
+		public MaskedTextFieldWidget getWidget() {
+			return (MaskedTextFieldWidget) super.getWidget();
+		}
+
+		@Override
+		public MaskedTextFieldState getState() {
+			return (MaskedTextFieldState) super.getState();
+		}
+
+		@Override
+		public void onStateChanged(StateChangeEvent stateChangeEvent) {
+			getWidget().setMask(getState().mask);
+			getWidget().setPlaceHolder(getState().placeHolder);
+			super.onStateChanged(stateChangeEvent);
+		}
+	
+}
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/MaskedTextFieldState.java b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/MaskedTextFieldState.java
new file mode 100644
index 0000000..d662940
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/MaskedTextFieldState.java
@@ -0,0 +1,19 @@
+package org.vaadin.addons.maskedtextfield.client;
+
+import com.vaadin.shared.ui.textfield.AbstractTextFieldState;
+
+public class MaskedTextFieldState extends AbstractTextFieldState {
+	
+	private static final long serialVersionUID = 1L;
+	
+	/**
+	 * The mask
+	 */
+	public String mask;
+	
+	/**
+	 * A Placeholder
+	 */
+	public char placeHolder = '_';
+	
+}
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/MaskedTextFieldWidget.java b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/MaskedTextFieldWidget.java
new file mode 100644
index 0000000..44bf0fd
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/MaskedTextFieldWidget.java
@@ -0,0 +1,467 @@
+package org.vaadin.addons.maskedtextfield.client;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.vaadin.addons.maskedtextfield.client.masks.AlphanumericMask;
+import org.vaadin.addons.maskedtextfield.client.masks.HexMask;
+import org.vaadin.addons.maskedtextfield.client.masks.LetterMask;
+import org.vaadin.addons.maskedtextfield.client.masks.LowerCaseMask;
+import org.vaadin.addons.maskedtextfield.client.masks.Mask;
+import org.vaadin.addons.maskedtextfield.client.masks.NumericMask;
+import org.vaadin.addons.maskedtextfield.client.masks.SignMask;
+import org.vaadin.addons.maskedtextfield.client.masks.UpperCaseMask;
+import org.vaadin.addons.maskedtextfield.client.masks.WildcardMask;
+import org.vaadin.addons.maskedtextfield.shared.Constants;
+
+import com.google.gwt.core.client.Scheduler;
+import com.google.gwt.event.dom.client.BlurEvent;
+import com.google.gwt.event.dom.client.BlurHandler;
+import com.google.gwt.event.dom.client.FocusEvent;
+import com.google.gwt.event.dom.client.FocusHandler;
+import com.google.gwt.event.dom.client.KeyCodes;
+import com.google.gwt.event.dom.client.KeyDownEvent;
+import com.google.gwt.event.dom.client.KeyDownHandler;
+import com.google.gwt.event.dom.client.KeyPressEvent;
+import com.google.gwt.event.dom.client.KeyPressHandler;
+import com.google.gwt.user.client.Event;
+import com.vaadin.client.ui.VTextField;
+
+public class MaskedTextFieldWidget extends VTextField implements KeyDownHandler,
+		FocusHandler, BlurHandler, KeyPressHandler {
+
+	protected String mask;
+	private String proccessedMask;
+	
+	private char placeholder = '_';
+	
+	private StringBuilder string;
+	private List<Mask> maskTest;
+	private List<Integer> nullablePositions;
+	
+	private char emptyChar ='\0';
+	
+	private boolean immediate = false;
+	
+	/**
+	 * Key press that might be ignored by event handlers
+	 */
+	private char[] ignoredKeys = new char[] {
+			KeyCodes.KEY_BACKSPACE,
+			KeyCodes.KEY_TAB,
+			KeyCodes.KEY_DELETE,  
+			KeyCodes.KEY_END,
+			KeyCodes.KEY_ENTER,
+			KeyCodes.KEY_ESCAPE,
+			KeyCodes.KEY_HOME,
+			KeyCodes.KEY_LEFT,
+			KeyCodes.KEY_PAGEDOWN,
+			KeyCodes.KEY_PAGEUP,
+			KeyCodes.KEY_RIGHT
+	};
+
+	public MaskedTextFieldWidget() {
+		super();
+		Arrays.sort(ignoredKeys);
+		addKeyPressHandler(this);
+		addKeyDownHandler(this);
+		addFocusHandler(this);
+		addBlurHandler(this);
+		sinkEvents(Event.ONPASTE);
+	}
+
+	@Override
+	public void setText(String value) {
+		setText(value, true);
+	}
+	
+	protected void setText(String value, boolean checkComplete) {
+		String v = formatString(value);
+		string = new StringBuilder(v);
+		super.setText((checkComplete && isFieldIfIncomplete()) ? "" : v);
+		valueChange(false);
+	}
+
+	public void setMask(String mask) {
+		setMask(mask, true);
+	}
+	
+	protected void setMask(String mask, boolean replaceValue) {
+		this.mask = mask;
+		string = new StringBuilder();
+		maskTest = new ArrayList<Mask>(mask.length());
+		nullablePositions = new ArrayList<Integer>();
+		if(replaceValue) {
+			configureUserView();
+		} else {
+			configureMask();
+		}
+		getNextPosition(0);
+	}
+	
+	public void setPlaceHolder(char placeHolder) {
+		this.placeholder = placeHolder;
+	}
+
+	private void configureMask() {
+		for (int index = 0; index < mask.length(); index++) {
+			char character = mask.charAt(index);
+			createCorrectMaskAndPlaceholder(character, index);
+		}
+		proccessedMask = string.toString();
+	}
+	
+	private void configureUserView() {
+		configureMask();
+		super.setText(proccessedMask);
+		valueChange(false);
+	}
+
+	private void createCorrectMaskAndPlaceholder(char character, int index) {
+		switch (character) {
+		case '\'':
+			addMaskStrategyAndCharacterPlaceHolder(null, mask.charAt(++index));
+			break;
+		case '#':
+			addMaskStrategyAndCharacterPlaceHolder(new NumericMask(),placeholder);
+			break;
+		case 'U':
+			addMaskStrategyAndCharacterPlaceHolder(new UpperCaseMask(), placeholder);
+			break;
+		case 'L':
+			addMaskStrategyAndCharacterPlaceHolder(new LowerCaseMask(), placeholder);
+			break;
+		case '?':
+			addMaskStrategyAndCharacterPlaceHolder(new LetterMask(), placeholder);
+			break;
+		case 'A':
+			addMaskStrategyAndCharacterPlaceHolder(new AlphanumericMask(), placeholder);
+			break;
+		case '*':
+			addMaskStrategyAndCharacterPlaceHolder(new WildcardMask(), placeholder);
+			break;
+		case 'H':
+			addMaskStrategyAndCharacterPlaceHolder(new HexMask(), placeholder);
+			break;
+		case '~':
+			addMaskStrategyAndCharacterPlaceHolder(new SignMask(), placeholder);
+			break;
+		case '+':
+			nullablePositions.add(index++);
+			break;
+		default:
+			addMaskStrategyAndCharacterPlaceHolder(null, character);
+			break;
+		}
+	}
+
+	private void addMaskStrategyAndCharacterPlaceHolder(Mask maskStrategy, char characterPlaceholder) {
+		maskTest.add(maskStrategy);
+		string.append(characterPlaceholder);
+	}
+
+	private int getNextPosition(int position) {
+		while (++position < maskTest.size() && maskTest.get(position) == null)
+			;
+		return position;
+	}
+
+	int getPreviousPosition(int position) {
+		while (--position >= 0 && maskTest.get(position) == null)
+			;
+		if (position < 0)
+			return getNextPosition(position);
+		return position;
+	}
+
+	private int getLastPosition() {
+		return getText().length() + 1;
+	}
+
+	public void onKeyPress(KeyPressEvent event) {
+		if (!isKeyIgnored(event)) {
+			if (getCursorPos() < maskTest.size()) {
+				validateAndShowUserInput(event);
+			} else {
+				if(event.getCharCode() != emptyChar) {
+					cancelKey();
+				}
+			}
+		}
+	}
+
+	private boolean isKeyIgnored(KeyPressEvent event) {
+		return (
+				event.getCharCode() == emptyChar ||
+				event.isShiftKeyDown() && isAnySelectionTextModifiedKey(event.getCharCode()) ||
+				isIgnoredKey(event.getCharCode()) ||
+				isPasteShorcutPressed(event) ||
+				event.isAnyModifierKeyDown() && !event.isShiftKeyDown()
+				);
+	}
+	
+	private boolean isIgnoredKey(char charCode) {
+		return Arrays.binarySearch(ignoredKeys, charCode) >= 0;
+	}
+	
+	private boolean isAnySelectionTextModifiedKey(char charCode) {
+		return (charCode == KeyCodes.KEY_END || charCode == KeyCodes.KEY_HOME);
+	}
+	
+	private boolean isPasteShorcutPressed(KeyPressEvent event) {
+		return event.isControlKeyDown() && (Character.toLowerCase(event.getCharCode()) == 'v');
+	}
+
+	private void validateAndShowUserInput(KeyPressEvent event) {
+		Mask maskStrategy = maskTest.get(getAvaliableCursorPos(getCursorPos()));
+		if (maskStrategy != null) {
+			if(event.getCharCode() == ' ' && nullablePositions.contains(getCursorPos())) {
+				showUserInput(' ');
+			}
+			else if (maskStrategy.isValid(event.getCharCode())) {
+				char character = maskStrategy.getChar(event.getCharCode());
+				showUserInput(character);
+			}
+			event.preventDefault();
+		}
+	}
+	
+	@Override 
+	public void onBrowserEvent(Event event) { 
+	    if(event.getTypeInt() == Event.ONPASTE) {
+	    	super.setText("");
+	    	processOriginalPasteEvent(event);
+	    	Scheduler.get().scheduleDeferred(new Scheduler.ScheduledCommand() {
+				@Override
+				public void execute() {
+					formatPaste();
+				}
+			});
+	    	
+	    } else {
+	    	super.onBrowserEvent(event);
+	    }
+	}
+	
+	protected void processOriginalPasteEvent(Event evt) {
+		super.onBrowserEvent(evt);
+	}
+	
+	protected void formatPaste() {
+		setText(formatString(super.getText()));
+	}
+	
+	protected String formatString(final String value) {
+		if(value == null || value.trim().isEmpty()) {
+			return "";
+		}
+		StringBuilder sb = new StringBuilder(proccessedMask);
+		int valueIndex = 0;
+		char[] valueChars = value.toCharArray();
+		for(int i=0; i<maskTest.size(); i++) {
+			Mask maskStrategy = maskTest.get(i);
+			if(maskStrategy != null) {
+				if(valueIndex<valueChars.length) {
+					while(valueIndex<valueChars.length) {
+						char s = valueChars[valueIndex++];
+						if(nullablePositions.contains(i) || maskStrategy.isValid(s)) {
+							if(s == ' ') {
+								sb.setCharAt(i, ' ');
+							} else {
+								sb.setCharAt(i, maskStrategy.getChar(s));
+							}
+							break;
+						}
+					}
+				}
+			}
+		}
+		return sb.toString();
+	}
+	
+	private void showUserInput(char character) {
+		if(getText().isEmpty()) {
+			configureUserView();
+		}
+		if(getText().length() < maskTest.size()) {
+			
+		}
+		int currentPosition = getAvaliableCursorPos(getCursorPos());
+		string.setCharAt(currentPosition, character); 
+		super.setText(string.toString());
+		setCursorPos(getNextPosition(currentPosition));
+		valueChange(false);
+	}
+
+	@Override
+	public void onKeyDown(KeyDownEvent event) {
+		if (event.getNativeKeyCode() == KeyCodes.KEY_BACKSPACE) {
+			deleteTextOnKeyDown(event);
+		} else if (event.getNativeKeyCode() == KeyCodes.KEY_DELETE) {
+			deleteTextOnKeyDown(event);
+		} else if (event.getNativeKeyCode() == KeyCodes.KEY_RIGHT) {
+			setCursorPositionAndPreventDefault(event,getNextPosition(getCursorPos()));
+		} else if (event.getNativeKeyCode() == KeyCodes.KEY_LEFT) {
+			setCursorPositionAndPreventDefault(event, getPreviousPosition(getCursorPos()));
+		} else if (event.getNativeKeyCode() == KeyCodes.KEY_HOME && !event.isShiftKeyDown()) {
+			setCursorPositionAndPreventDefault(event, getPreviousPosition(0));
+		} else if (event.getNativeKeyCode() == KeyCodes.KEY_END && !event.isShiftKeyDown()) {
+			setCursorPositionAndPreventDefault(event, getLastPosition());
+		} else if (event.getNativeKeyCode() == KeyCodes.KEY_ENTER) {
+			if(isFieldIfIncomplete()) {
+				cleanText();
+			}
+			super.onKeyDown(event);
+		} else {
+			super.onKeyDown(event);
+		}
+	}
+	
+	private void deleteTextOnKeyDown(KeyDownEvent event) {
+		if(!getSelectedText().isEmpty()) {
+			String selected = getSelectedText();
+			for(int i=(selected.length()-1); i>=0; i--) {
+				int index = getText().indexOf(Character.toString(selected.charAt(i)));
+				deleteCharacter(index);
+			}
+			setCursorPos(0);
+		} else {
+			if(event.getNativeKeyCode() == KeyCodes.KEY_DELETE) {
+				deleteCharacterAndPositionCursor(event, getCursorPos());
+			} else {
+				deleteCharacterAndPositionCursor(event, getPreviousPosition(getCursorPos()));
+			}
+		}
+	}
+
+	private void deleteCharacterAndPositionCursor(KeyDownEvent event, int position) {
+		deleteCharacter(position);
+		setCursorPositionAndPreventDefault(event, position);
+	}
+
+	private void setCursorPositionAndPreventDefault(KeyDownEvent event,int position) {
+		setCursorPos(position);
+		event.preventDefault();
+	}
+
+	private void deleteCharacter(int position) {
+		Mask maskStrategy = maskTest.get(position);
+		if (maskStrategy != null) {
+			string.setCharAt(position, placeholder);
+			super.setText(string.toString());
+			valueChange(false);
+		}
+	}
+
+	@Override
+	public void onFocus(FocusEvent event) {
+		if (getText().isEmpty()) {
+			setMask(mask);
+			Scheduler.get().scheduleDeferred(new Scheduler.ScheduledCommand() {
+				@Override
+				public void execute() {
+					setCursorPos(getAvaliableCursorPos(0));
+				}
+			});
+		}
+	}
+	
+	public int getAvaliableCursorPos(int desiredPosition) {
+		int i = desiredPosition;
+		for(;i<maskTest.size(); i++) {
+			if(maskTest.get(i) != null) {
+				break;
+			}
+		}
+		return i;
+	}
+
+	public int getNextAvaliableCursorPos(int desiredPosition) {
+		int i = desiredPosition;
+		for(;i<maskTest.size(); i++) {
+			if(maskTest.get(i) != null && string.charAt(i) == placeholder) {
+				break;
+			}
+		}
+		return i;
+	}
+	
+	@Override
+	protected boolean updateCursorPosition() {
+		if(!isImmediate()) {
+			return super.updateCursorPosition();
+		}
+		return false;
+	}
+
+	@Override
+	public void setImmediate(boolean immediate) {
+		super.setImmediate(immediate);
+		this.immediate = true;
+	}
+	
+	private boolean isImmediate() {
+		return immediate;
+	}
+	
+	@Override
+	public void valueChange(boolean blurred) {
+		if(!isFieldIfIncomplete()) {
+			super.valueChange(blurred);
+		}
+	}
+
+	@Override
+	public void onBlur(BlurEvent event) {
+		if(isFieldIfIncomplete()) {
+			cleanText();
+		} else {
+			super.onBlur(event);
+		}
+	}
+	
+	private void cleanText() {
+		super.setText("");
+		super.valueChange(true);
+	}
+	
+	protected boolean isFieldIfIncomplete() {
+		if(string == null || maskTest == null) {
+			return true;
+		}
+		for (int index = 0; index < string.length(); index++) {
+			char character = string.charAt(index);
+			if (maskTest.get(index) != null && character == placeholder) {
+				return true;
+			}
+		}
+		return false;
+	}
+	
+	protected String unmask() {
+		return unmask(super.getText());
+	}
+	
+	protected String unmask(final String value) {
+		char[] masks = Constants.MASK_REPRESENTATIONS;
+		Arrays.sort(masks);
+		if(value == null || value.trim().isEmpty()) {
+			return null;
+		}
+		StringBuilder sb = new StringBuilder(value);
+		String m = mask.replaceAll("\\+", "");
+		int removedChars = 0;
+		for(int i = 0; i<m.length(); i++) {
+			char s = m.charAt(i);
+			if(Arrays.binarySearch(masks, s) < 0) {
+				if(i < value.length() && sb.charAt(i-removedChars) == s) {
+					sb.deleteCharAt(i-removedChars);
+					removedChars++;
+				}
+			}
+		}
+		return sb.toString().replaceAll(String.valueOf(placeholder), "");
+	}
+	
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/NumericFieldConnector.java b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/NumericFieldConnector.java
new file mode 100644
index 0000000..b606f44
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/NumericFieldConnector.java
@@ -0,0 +1,24 @@
+package org.vaadin.addons.maskedtextfield.client;
+
+import org.vaadin.addons.maskedtextfield.NumericField;
+
+import com.google.gwt.core.client.GWT;
+import com.vaadin.client.ui.textfield.TextFieldConnector;
+import com.vaadin.shared.ui.Connect;
+
+@Connect(NumericField.class)
+public class NumericFieldConnector extends TextFieldConnector {
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	protected NumericFieldWidget createWidget() {
+		return GWT.create(NumericFieldWidget.class);
+	}
+	
+	@Override
+	public NumericFieldWidget getWidget() {
+		return (NumericFieldWidget) super.getWidget();
+	}
+	
+}
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/NumericFieldWidget.java b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/NumericFieldWidget.java
new file mode 100644
index 0000000..c2235b1
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/NumericFieldWidget.java
@@ -0,0 +1,72 @@
+package org.vaadin.addons.maskedtextfield.client;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+
+import org.vaadin.addons.maskedtextfield.shared.Constants;
+
+import com.google.gwt.event.dom.client.KeyCodes;
+import com.google.gwt.event.dom.client.KeyPressEvent;
+import com.google.gwt.event.dom.client.KeyPressHandler;
+import com.vaadin.client.ui.VTextField;
+
+public class NumericFieldWidget extends VTextField {
+	
+	private static Collection<Character> acceptedCharSet = new HashSet<Character>(Arrays.asList(
+			new Character[] {
+				(char) KeyCodes.KEY_BACKSPACE,
+				(char) KeyCodes.KEY_TAB,
+				(char) KeyCodes.KEY_DELETE,  
+				(char) KeyCodes.KEY_END,
+				(char) KeyCodes.KEY_ENTER,
+				(char) KeyCodes.KEY_ESCAPE,
+				(char) KeyCodes.KEY_HOME,
+				(char) KeyCodes.KEY_LEFT,
+				(char) KeyCodes.KEY_PAGEDOWN,
+				(char) KeyCodes.KEY_PAGEUP,
+				(char) KeyCodes.KEY_RIGHT
+			}
+			));
+	
+	private boolean isAcceptableKey(char charCode) {
+		return Character.isDigit(charCode)
+				|| acceptedCharSet.contains(charCode);
+	}
+	
+	public NumericFieldWidget() {
+		super();
+		addKeyPressHandler(new KeyPressHandler() {
+			@Override
+			public void onKeyPress(KeyPressEvent e) {
+				char code = (e.getCharCode() != Constants.EMPTY_CHAR) ? e.getCharCode() : (char) e.getNativeEvent().getKeyCode();
+				if(!isAcceptableKey(code)) {
+					e.preventDefault();
+				}	
+			}
+		});
+	}
+
+	@SuppressWarnings("unused")
+	private String getValueToOperate(String value) {
+		return value.length() > 1 ? value.substring(value.length() - 2) : value
+				.substring(value.length() - 1);
+	}
+
+	@SuppressWarnings("unused")
+	private String getLiteralValue(String value) {
+		return value.length() > 1 ? value.substring(0, value.length() - 2)
+				: value.substring(0, value.length() - 1);
+	}
+
+	@Override
+	public void setValue(String value) {
+		try {
+			Long v = Long.parseLong(value);
+			super.setValue(v.toString());
+		} catch (Throwable e) {
+			super.setValue("0");
+		}
+	}
+	
+}
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/PrefixedMaskedTextFieldConnector.java b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/PrefixedMaskedTextFieldConnector.java
new file mode 100644
index 0000000..641bf7e
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/PrefixedMaskedTextFieldConnector.java
@@ -0,0 +1,36 @@
+package org.vaadin.addons.maskedtextfield.client;
+
+import org.vaadin.addons.maskedtextfield.PrefixedMaskedTextField;
+
+import com.google.gwt.core.client.GWT;
+import com.vaadin.client.communication.StateChangeEvent;
+import com.vaadin.shared.ui.Connect;
+
+@Connect(PrefixedMaskedTextField.class)
+public class PrefixedMaskedTextFieldConnector extends MaskedTextFieldConnector {
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	protected PrefixedMaskedTextFieldWidget createWidget() {
+		return GWT.create(PrefixedMaskedTextFieldWidget.class);
+	}
+	
+	@Override
+	public PrefixedMaskedTextFieldWidget getWidget() {
+		return (PrefixedMaskedTextFieldWidget) super.getWidget();
+	}
+
+	@Override
+	public PrefixedMaskedTextFieldState getState() {
+		return (PrefixedMaskedTextFieldState) super.getState();
+	}
+
+	@Override
+	public void onStateChanged(StateChangeEvent stateChangeEvent) {
+		super.onStateChanged(stateChangeEvent);
+		getWidget().setMasks(getState().masksByPrefix);
+		getWidget().setDefaultMask(getState().defaultMask);
+	}
+	
+}
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/PrefixedMaskedTextFieldState.java b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/PrefixedMaskedTextFieldState.java
new file mode 100644
index 0000000..2e543ca
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/PrefixedMaskedTextFieldState.java
@@ -0,0 +1,14 @@
+package org.vaadin.addons.maskedtextfield.client;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class PrefixedMaskedTextFieldState extends MaskedTextFieldState {
+
+	private static final long serialVersionUID = 1L;
+
+	public String defaultMask;
+	
+	public Map<String, String> masksByPrefix = new HashMap<String, String>();
+	
+}
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/PrefixedMaskedTextFieldWidget.java b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/PrefixedMaskedTextFieldWidget.java
new file mode 100644
index 0000000..0524266
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/PrefixedMaskedTextFieldWidget.java
@@ -0,0 +1,131 @@
+package org.vaadin.addons.maskedtextfield.client;
+
+import java.util.Map;
+
+import com.google.gwt.core.client.Scheduler;
+import com.google.gwt.event.dom.client.KeyPressEvent;
+import com.google.gwt.user.client.Event;
+
+public class PrefixedMaskedTextFieldWidget extends MaskedTextFieldWidget {
+
+	private String defaultMask;
+	private Map<String, String> masks;
+	
+	public PrefixedMaskedTextFieldWidget() {
+		super();
+	}
+
+	public void setMasks(Map<String, String> masksByPrefix) {
+		this.masks = masksByPrefix;
+	}
+
+	public void setDefaultMask(String mask) {
+		defaultMask = mask;
+	}
+	
+	@Override
+	public void setMask(String mask) {
+		if(getText() == null || getText().isEmpty() || this.mask == null) {
+			super.setMask(mask);
+		}
+	}
+	
+	/*
+	private boolean isMaskCompatibleWithValue(String mask) {
+		if(getText() == null || getText().isEmpty()) {
+			
+		}
+		return true;
+	}
+	*/
+
+	@Override
+	public void onKeyPress(KeyPressEvent event) {
+		super.onKeyPress(event);
+		if(!masks.isEmpty()) {
+			String v = unmask();
+			if(v != null && !v.isEmpty()) {
+				checkForPrefix(v);
+			}
+		}
+	}
+	
+	protected void checkForPrefix(String v) {
+		String maskForPrefix = getMaskForPrefix(v);
+		if(updateMaskForPrefix(maskForPrefix)) {
+			updateValueOnNewMask(v);
+		}
+	}
+	
+	private String getMaskForPrefix(String value) {
+		value = formatString(unmask(value));
+		if(masks != null) {
+			for(String prefix : masks.keySet()) {
+				if(value.startsWith(prefix)) {
+					return masks.get(prefix);
+				}
+			}
+		}
+		return null;
+	}
+	
+	@Override
+	public void onBrowserEvent(Event event) {
+		if(event.getTypeInt() == Event.ONPASTE) {
+			super.setText("");
+			processOriginalPasteEvent(event);
+			if(!masks.isEmpty()) {
+				Scheduler.get().scheduleDeferred(new Scheduler.ScheduledCommand() {
+					@Override
+					public void execute() {
+						String v = unmask();
+						if(v != null && !v.isEmpty()) {
+							String maskForPrefix = getMaskForPrefix(v);
+							updateMaskForPrefix(maskForPrefix);
+						}
+						formatPaste();
+					}
+				});
+				
+			}
+		} else {
+			processOriginalPasteEvent(event);
+		}
+	}
+	
+	@Override
+	public void setText(String text) {
+		if(text != null && !text.isEmpty()) {
+			updateMaskForPrefix(getMaskForPrefix(formatString(unmask(text))));
+		}
+		super.setText(unmask(text));
+	}
+	
+	private boolean updateMaskForPrefix(String maskForPrefix) {
+		if(mask != null) {
+			if(maskForPrefix != null) {
+				if(!mask.equals(maskForPrefix)) {
+					super.setMask(maskForPrefix, false);
+					return true;
+				}
+			} else {
+				if(!mask.equals(defaultMask)) {
+					super.setMask(defaultMask, false);
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+	
+	/**
+	 * Updates the new value on field, without check if it is complete.
+	 * @param v
+	 */
+	protected void updateValueOnNewMask(String v) {
+		String formated = formatString(v); 
+		setText(formated, false);
+		setCursorPos(getNextAvaliableCursorPos(0));
+	}
+	
+}
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/masks/AbstractMask.java b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/masks/AbstractMask.java
new file mode 100644
index 0000000..7cbb678
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/masks/AbstractMask.java
@@ -0,0 +1,9 @@
+package org.vaadin.addons.maskedtextfield.client.masks;
+
+public abstract class AbstractMask implements Mask {
+
+	public char getChar(char character) {
+		return character;
+	}
+
+}
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/masks/AlphanumericMask.java b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/masks/AlphanumericMask.java
new file mode 100644
index 0000000..a844422
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/masks/AlphanumericMask.java
@@ -0,0 +1,8 @@
+package org.vaadin.addons.maskedtextfield.client.masks;
+
+public class AlphanumericMask extends AbstractMask {
+	
+	public boolean isValid(char character) {
+		return Character.isLetter(character) || Character.isDigit(character);
+	}
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/masks/HexMask.java b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/masks/HexMask.java
new file mode 100644
index 0000000..39f8ec2
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/masks/HexMask.java
@@ -0,0 +1,21 @@
+package org.vaadin.addons.maskedtextfield.client.masks;
+
+/**
+ * Represents a hex character, 0-9a-fA-F. a-f is mapped to A-F
+ */
+public class HexMask implements Mask {
+	public boolean isValid(char character) {
+		return ((character == '0' || character == '1' || character == '2' || character == '3' || character == '4'
+				|| character == '5' || character == '6' || character == '7' || character == '8' || character == '9'
+				|| character == 'a' || character == 'A' || character == 'b' || character == 'B' || character == 'c'
+				|| character == 'C' || character == 'd' || character == 'D' || character == 'e' || character == 'E'
+				|| character == 'f' || character == 'F'));
+	}
+
+	public char getChar(char character) {
+		if (Character.isDigit(character)) {
+			return character;
+		}
+		return Character.toUpperCase(character);
+	}
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/masks/LetterMask.java b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/masks/LetterMask.java
new file mode 100644
index 0000000..1342f24
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/masks/LetterMask.java
@@ -0,0 +1,9 @@
+package org.vaadin.addons.maskedtextfield.client.masks;
+
+public class LetterMask extends AbstractMask {
+
+	public boolean isValid(char character) {
+		return Character.isLetter(character);
+	}
+
+}
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/masks/LowerCaseMask.java b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/masks/LowerCaseMask.java
new file mode 100644
index 0000000..af31f01
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/masks/LowerCaseMask.java
@@ -0,0 +1,12 @@
+package org.vaadin.addons.maskedtextfield.client.masks;
+
+public class LowerCaseMask implements Mask {
+	
+	public boolean isValid(char character) {
+		return Character.isLetter(getChar(character));
+	}
+	
+	public char getChar(char character) {
+		return Character.toLowerCase(character);
+	}
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/masks/Mask.java b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/masks/Mask.java
new file mode 100644
index 0000000..d36c4c4
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/masks/Mask.java
@@ -0,0 +1,6 @@
+package org.vaadin.addons.maskedtextfield.client.masks;
+
+public interface Mask {
+	boolean isValid(char character);
+	char getChar(char character);
+}
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/masks/NumericMask.java b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/masks/NumericMask.java
new file mode 100644
index 0000000..8bc748e
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/masks/NumericMask.java
@@ -0,0 +1,9 @@
+package org.vaadin.addons.maskedtextfield.client.masks;
+
+public class NumericMask extends AbstractMask {
+	
+	public boolean isValid(char character) {
+		return Character.isDigit(character);
+	}
+
+}
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/masks/SignMask.java b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/masks/SignMask.java
new file mode 100644
index 0000000..a5cfd0a
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/masks/SignMask.java
@@ -0,0 +1,8 @@
+package org.vaadin.addons.maskedtextfield.client.masks;
+
+public class SignMask extends AbstractMask {
+	
+	public boolean isValid(char character) {
+		return character == '-' || character == '+';
+	}
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/masks/UpperCaseMask.java b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/masks/UpperCaseMask.java
new file mode 100644
index 0000000..9036f7d
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/masks/UpperCaseMask.java
@@ -0,0 +1,12 @@
+package org.vaadin.addons.maskedtextfield.client.masks;
+
+public class UpperCaseMask implements Mask {
+	
+	public boolean isValid(char character) {
+		return Character.isLetter(getChar(character));
+	}
+	
+	public char getChar(char character) {
+		return Character.toUpperCase(character);
+	}
+}
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/masks/WildcardMask.java b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/masks/WildcardMask.java
new file mode 100644
index 0000000..ff70dbf
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/client/masks/WildcardMask.java
@@ -0,0 +1,8 @@
+package org.vaadin.addons.maskedtextfield.client.masks;
+
+public class WildcardMask extends AbstractMask {
+	
+	public boolean isValid(char character) {
+		return true;
+	}
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/server/Utils.java b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/server/Utils.java
new file mode 100644
index 0000000..e2f2942
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/server/Utils.java
@@ -0,0 +1,36 @@
+package org.vaadin.addons.maskedtextfield.server;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+
+import com.vaadin.data.Property;
+
+public class Utils {
+	
+	/**
+	 * An utility method to convert some number to specific datasource final number implementation
+	 * @param number
+	 * @param property
+	 * @return
+	 */
+	public static Number convertToDataSource(final Number number, final Property<?> property) {
+		Class<?> propertyClass = property.getType();
+		if(Integer.class.isAssignableFrom(propertyClass) || int.class.isAssignableFrom(propertyClass)) {
+			return number.intValue();
+		} else if(Long.class.isAssignableFrom(propertyClass) || long.class.isAssignableFrom(propertyClass)) {
+			return number.longValue();
+		} else if(Double.class.isAssignableFrom(propertyClass) || double.class.isAssignableFrom(propertyClass)) {
+			return number.doubleValue();
+		} else if(Float.class.isAssignableFrom(propertyClass) || float.class.isAssignableFrom(propertyClass)) {
+			return number.floatValue();
+		} else if(BigDecimal.class.isAssignableFrom(propertyClass)) {
+			return new BigDecimal(number.doubleValue());
+		} else if (BigInteger.class.isAssignableFrom(propertyClass)) {
+			return new BigInteger(String.valueOf(number.longValue()));
+		} else if(Short.class.isAssignableFrom(propertyClass) || short.class.isAssignableFrom(propertyClass)) {
+			return number.shortValue();
+		}
+		return number;
+	}
+
+}
diff --git a/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/shared/Constants.java b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/shared/Constants.java
new file mode 100644
index 0000000..61c3119
--- /dev/null
+++ b/org.eclipse.osbp.fork.vaadin.addon.maskedtextfield/src/org/vaadin/addons/maskedtextfield/shared/Constants.java
@@ -0,0 +1,36 @@
+package org.vaadin.addons.maskedtextfield.shared;
+
+import java.util.Arrays;
+
+/**
+ * Some constants that can be used for any widget
+ * @author eduardo
+ *
+ */
+public class Constants {
+	
+	/**
+	 * For a fixed GWT i18n formatter
+	 */
+	public static final char FIXED_LOCALE_DECIMAL_SEPARATOR = '.';
+	
+	/**
+	 * For a fixed GWT i18n formatter
+	 */
+	public static final char FIXED_LOCALE_GROUPING_SEPARATOR = ',';
+	
+	/**
+	 * Empty char representation
+	 */
+	public static final char EMPTY_CHAR ='\0';
+	
+	/**
+	 * Supported masks representations
+	 */
+	public static final char[] MASK_REPRESENTATIONS = {'#', 'U', 'L', '?', 'A', '*', 'H', '~'};
+
+	static {
+		Arrays.sort(MASK_REPRESENTATIONS);
+	}
+	
+}
diff --git a/pom.xml b/pom.xml
new file mode 100644
index 0000000..53b076b
--- /dev/null
+++ b/pom.xml
@@ -0,0 +1,53 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- /*                                                                           -->
+<!--  * Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany)   -->
+<!--  *                                                                           -->
+<!--  * This program and the accompanying materials are made available under the  -->
+<!--  * terms of the Eclipse Public License 2.0 which is available at             -->
+<!--  * http://www.eclipse.org/legal/epl-2.0.                                     -->
+<!--  *                                                                           -->
+<!--  * SPDX-License-Identifier: EPL-2.0                                          -->
+<!--  *                                                                           -->
+<!--  * Contributors:                                                             -->
+<!--  *      Loetz GmbH&Co.KG - initial API and 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.mbp2</artifactId>
+        <version>0.9.0-SNAPSHOT</version>
+        <relativePath/>
+    </parent>
+
+    <groupId>org.eclipse.osbp.fork.vaadin.addon.maskedtextfield</groupId>
+    <artifactId>org.eclipse.osbp.fork.vaadin.addon.maskedtextfield.aggregator</artifactId>
+    <packaging>pom</packaging>
+
+    <url>${osbp.site.repository.url}</url>
+    <scm>
+        <url>${osbp.scm.url}</url>
+        <connection>${osbp.scm.connection}</connection>
+        <developerConnection>${osbp.scm.connection.dev}</developerConnection>
+        <tag>HEAD</tag>
+    </scm>
+    <distributionManagement>
+        <site>
+            <id>gh-pages</id>
+            <name>OSBP GitHub Pages</name>
+            <url>${distribution.site.url}</url>
+        </site>
+    </distributionManagement>
+
+    <properties>
+        
+		<osbp.gitrepo.name>${project.groupId}</osbp.gitrepo.name>
+    </properties>
+
+    <modules>
+        <module>org.eclipse.osbp.fork.vaadin.addon.maskedtextfield</module>
+    </modules>
+
+</project>
